logo

bootstrap-initrd

Linux initrd to bootstrap from a small binary seed git clone https://hacktivis.me/git/bootstrap-initrd.git

ls-stub.c (35347B)

    

  1. // SPDX-License-Identifier: BSD-3-Clause
  2. /*	ls 4.1 - List files.				Author: Kees J. Bot
  3.  *								25 Apr 1989
  4.  */
  6. /*
  7.  * Changes by Gunnar Ritter, Freiburg i. Br., Germany, October 2001. Taken
  8.  * from the MINIX sources:
  9.  */
  11. /*
  12.  * Copyright (c) 1987,1997, Prentice Hall All rights reserved.
  13.  * 
  14.  * Redistribution and use of the MINIX operating system in source and binary
  15.  * forms, with or without modification, are permitted provided that the
  16.  * following conditions are met:
  17.  * 
  18.  * Redistributions of source code must retain the above copyright notice, this
  19.  * list of conditions and the following disclaimer.
  20.  * 
  21.  * Redistributions in binary form must reproduce the above copyright notice,
  22.  * this list of conditions and the following disclaimer in the documentation
  23.  * and/or other materials provided with the distribution.
  24.  * 
  25.  * Neither the name of Prentice Hall nor the names of the software authors or
  26.  * contributors may be used to endorse or promote products derived from this
  27.  * software without specific prior written permission.
  28.  * 
  29.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS, AUTHORS, AND CONTRIBUTORS
  30.  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  32.  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PRENTICE HALL OR ANY
  33.  * AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  35.  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  36.  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  37.  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  38.  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  39.  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40.  */
  42. /*
  43.  * About the amount of bytes for heap + stack under Minix:
  44.  * Ls needs a average amount of 42 bytes per unserviced directory entry, so
  45.  * scanning 10 directory levels deep in an ls -R with 100 entries per directory
  46.  * takes 42000 bytes of heap.  So giving ls 10000 bytes is tight, 20000 is
  47.  * usually enough, 40000 is pessimistic.
  48.  */
  50. /* The array ifmt_c[] is used in an 'ls -l' to map the type of a file to a
  51.  * letter.  This is done so that ls can list any future file or device type
  52.  * other than symlinks, without recompilation.  (Yes it's dirty.)
  53.  */
  54. static char ifmt_c[] = "-pc-d-b--nl-SD--";
  55. /*                       S_IFIFO
  56.  *                        S_IFCHR
  57.  *                          S_IFDIR
  58.  *                            S_IFBLK
  59.  *                              S_IFREG
  60.  *                               S_IFNWK
  61.  *                                S_IFLNK
  62.  *                                  S_IFSOCK
  63.  *                                   S_IFDOOR
  64.  */
  66. #define ifmt(mode) ifmt_c[((mode) >> 12) & 0xF]
  68. #include <ctype.h>
  69. #include <dirent.h>
  70. #include <errno.h>
  71. #include <fcntl.h>
  72. #include <grp.h>
  73. #include <libgen.h>
  74. #include <limits.h>
  75. #include <locale.h>
  76. #include <pwd.h>
  77. #include <stddef.h>
  78. #include <stdio.h>
  79. #include <stdlib.h>
  80. #include <string.h>
  81. #include <sys/ioctl.h>
  82. #include <sys/stat.h>
  83. #include <sys/types.h>
  84. #include <termios.h>
  85. #include <time.h>
  86. #include <unistd.h>
  87. #include <wchar.h>
  88. #include <wctype.h>
  90. #if defined(__linux__) || defined(_AIX)
  91. #include <sys/sysmacros.h>
  92. #endif /* __linux__ or _AIX, since sys/sysmacros.h
  93.          * adds a definition of "major". */
  95. #ifndef S_IFNAM
  96. #define S_IFNAM 0x5000 /* XENIX special named file */
  97. #endif
  98. #ifndef S_INSEM
  99. #define S_INSEM 0x1 /* XENIX semaphore subtype of IFNAM */
  100. #endif
  101. #ifndef S_INSHD
  102. #define S_INSHD 0x2 /* XENIX shared data subtype of IFNAM */
  103. #endif
  104. #ifndef S_IFDOOR
  105. #define S_IFDOOR 0xD000 /* Solaris door */
  106. #endif
  107. #ifndef S_IFNWK
  108. #define S_IFNWK 0x9000 /* HP-UX network special */
  109. #endif
  111. #if !__minix
  112. #define SUPER_ID uid /* Let -A flag be default for SUPER_ID == 0. */
  113. #else
  114. #define SUPER_ID gid
  115. #endif
  117. #if __minix
  118. #define BLOCK 1024
  119. #else
  120. #define BLOCK 512
  121. #endif
  123. /* Assume other systems have st_blocks. */
  124. #if !__minix
  125. #define ST_BLOCKS 1
  126. #endif
  128. /* Some terminals ignore more than 80 characters on a line.  Dumb ones wrap
  129.  * when the cursor hits the side.  Nice terminals don't wrap until they have
  130.  * to print the 81st character.  Wether we like it or not, no column 80.
  131.  */
  132. static int ncols = 79;
  134. #define NSEP 2 /* # spaces between columns. */
  136. #define MAXCOLS 150 /* Max # of files per line. */
  138. static char *arg0;         /* Last component of argv[0]. */
  139. static int uid, gid;       /* callers id. */
  140. static int ex = 0;         /* Exit status to be. */
  141. static int istty;          /* Output is on a terminal. */
  142. static int tinfostat = -1; /* terminfo is initalized */
  144. #ifdef SU3
  145. static struct visit
  146. {
  147. 	ino_t v_ino;
  148. 	dev_t v_dev;
  149. } *visited;
  150. static int vismax; /* number of members in visited */
  151. #endif             /* SU3 */
  153. static enum { PER_LS = 0, PER_DIR = 1 } personality = PER_LS;
  155. static struct
  156. {
  157. 	const char *per_opt;
  158. } personalities[] = {
  159. /* orig: acdfgilnqrstu1ACFLMRTX */
  160. #ifdef UCB
  161.     {":1RaAdClgrtucFqisfLSUXhH"},   /* PER_LS */
  162. #else                               /* !UCB */
  163.     {"1RadCxmnlogrtucpFbqisfLSUXhH"}, /* PER_LS */
  164. #endif                              /* !UCB */
  165.     {"1RadCxmnlogrtucpFbqiOfLSXhH"} /* PER_DIR */
  166. };
  168. /* Safer versions of malloc and realloc: */
  170. static void
  171. heaperr(void)
  172. {
  173. 	write(2, "out of memory\n", 14);
  174. 	exit(077);
  175. }
  177. /*
  178.  * Deliver or die.
  179.  */
  180. static void *
  181. salloc(size_t n)
  182. {
  183. 	void *a;
  185. 	if((a = malloc(n)) == NULL) heaperr();
  186. 	return a;
  187. }
  189. static void *
  190. srealloc(void *a, size_t n)
  191. {
  192. 	if((a = realloc(a, n)) == NULL) heaperr();
  193. 	return a;
  194. }
  196. static char flags[0477];
  198. static int
  199. present(int f)
  200. {
  201. 	return f == 0 || flags[f] != 0;
  202. }
  204. /*
  205.  * Like perror(3), but in the style: "ls: junk: No such file or directory.
  206.  */
  207. static void
  208. report(const char *f)
  209. {
  210. #ifdef UCB
  211. 	fprintf(stderr, "%s not found\n", f);
  212. #else  /* !UCB */
  213. 	fprintf(stderr, "%s: %s\n", f, strerror(errno));
  214. #endif /* !UCB */
  215. 	ex = 1;
  216. }
  218. #ifdef UCB
  219. #define blockcount(n) (((n) & 1 ? (n) + 1 : (n)) >> 1)
  220. #else
  221. #define blockcount(n) (n)
  222. #endif
  224. /*
  225.  * Two functions, uidname and gidname, translate id's to readable names.
  226.  * All names are remembered to avoid searching the password file.
  227.  */
  228. #define NNAMES (1 << (sizeof(int) + sizeof(char *)))
  229. enum whatmap
  230. {
  231. 	PASSWD,
  232. 	GROUP
  233. };
  235. static struct idname
  236. { /* Hash list of names. */
  237. 	struct idname *next;
  238. 	char *name;
  239. 	uid_t id;
  240. } *uids[NNAMES], *gids[NNAMES];
  242. /*
  243.  * Return name for a given user/group id.
  244.  */
  245. static char *
  246. idname(unsigned id, enum whatmap map)
  247. {
  248. 	struct idname *i;
  249. 	struct idname **ids = &(map == PASSWD ? uids : gids)[id % NNAMES];
  251. 	while((i = *ids) != NULL && id < i->id)
  252. 		ids = &i->next;
  253. 	if(i == NULL || id != i->id)
  254. 	{
  255. 		/* Not found, go look in the password or group map. */
  256. 		char *name = NULL;
  257. 		char noname[3 * sizeof(uid_t)];
  259. 		if(!present('n'))
  260. 		{
  261. 			if(map == PASSWD)
  262. 			{
  263. 				struct passwd *pw = getpwuid(id);
  265. 				if(pw != NULL) name = pw->pw_name;
  266. 			}
  267. 			else
  268. 			{
  269. 				struct group *gr = getgrgid(id);
  271. 				if(gr != NULL) name = gr->gr_name;
  272. 			}
  273. 		}
  274. 		if(name == NULL)
  275. 		{
  276. 			/* Can't find it, weird.  Use numerical "name." */
  277. 			sprintf(noname, "%lu", (long)id);
  278. 			name = noname;
  279. 		}
  280. 		/* Add a new id-to-name cell. */
  281. 		i = salloc(sizeof(*i));
  282. 		i->id = id;
  283. 		i->name = salloc(strlen(name) + 1);
  284. 		strcpy(i->name, name);
  285. 		i->next = *ids;
  286. 		*ids = i;
  287. 	}
  288. 	return i->name;
  289. }
  291. #define uidname(uid) idname((uid), PASSWD)
  292. #define gidname(gid) idname((gid), GROUP)
  294. /*
  295.  * Path name construction, addpath adds a component, delpath removes it.
  296.  * The string path is used throughout the program as the file under examination.
  297.  */
  299. static char *path;             /* Path name constructed in path[]. */
  300. static int plen = 0, pidx = 0; /* Lenght/index for path[]. */
  302. /*
  303.  * Add a component to path. (name may also be a full path at the first call)
  304.  * The index where the current path ends is stored in *pdi.
  305.  */
  306. static void
  307. addpath(int *didx, char *name)
  308. {
  309. 	if(plen == 0) path = salloc((plen = 32) * sizeof(path[0]));
  310. 	if(pidx == 1 && path[0] == '.') pidx = 0; /* Remove "." */
  311. 	*didx = pidx;                             /* Record point to go back to for delpath. */
  312. 	if(pidx > 0 && path[pidx - 1] != '/') path[pidx++] = '/';
  313. 	do
  314. 	{
  315. 		if(*name != '/' || pidx == 0 || path[pidx - 1] != '/')
  316. 		{
  317. 			if(pidx == plen)
  318. 			{
  319. 				path = srealloc(path, (plen *= 2) * sizeof(path[0]));
  320. 			}
  321. 			path[pidx++] = *name;
  322. 		}
  323. 	} while(*name++ != 0);
  324. 	--pidx; /*
  325. 			 * Put pidx back at the null.  The path[pidx++] = '/'
  326. 			 * statement will overwrite it at the next call.
  327. 			 */
  328. }
  330. #define delpath(didx) (path[pidx = didx] = 0) /* Remove component. */
  332. static int field = 0; /* (used to be) Fields that must be printed. */
  333. /* (now) Effects triggered by certain flags. */
  335. #define FL_INODE 0x001  /* -i */
  336. #define FL_BLOCKS 0x002 /* -s */
  337. #define FL_UNUSED 0x004
  338. #define FL_MODE 0x008   /* -lMX */
  339. #define FL_LONG 0x010   /* -l */
  340. #define FL_GROUP 0x020  /* -g */
  341. #define FL_BYTIME 0x040 /* -tuc */
  342. #define FL_ATIME 0x080  /* -u */
  343. #define FL_CTIME 0x100  /* -c */
  344. #define FL_MARK 0x200   /* -F */
  345. /*#define FL_UNUSED	0x400	*/
  346. #define FL_DIR 0x800    /* -d */
  347. #define FL_OWNER 0x1000 /* -o */
  348. #define FL_STATUS 0x2000
  350. #define ENDCOL 0x001 /* last printable column in -x mode */
  352. struct file
  353. { /* A file plus stat(2) information. */
  354. 	off_t size;
  355. #if ST_BLOCKS
  356. 	blkcnt_t blocks;
  357. #endif
  358. 	ino_t ino;
  359. 	struct file *next; /* Lists are made of them. */
  360. 	struct file *sord; /* Saved order of list. */
  361. 	char *name;        /* Null terminated name. */
  362. 	time_t mtime;
  363. 	time_t atime;
  364. 	time_t ctime;
  365. 	mode_t mode;
  366. 	int flag;
  367. 	uid_t uid;
  368. 	gid_t gid;
  369. 	dev_t rdev;
  370. 	nlink_t nlink;
  371. 	unsigned short namlen;
  372. };
  374. static void
  375. setstat(struct file *f, struct stat *stp)
  376. {
  377. 	f->ino = stp->st_ino;
  378. 	f->mode = stp->st_mode;
  379. 	f->nlink = stp->st_nlink;
  380. 	f->uid = stp->st_uid;
  381. 	f->gid = stp->st_gid;
  382. 	f->rdev = stp->st_rdev;
  383. 	f->size = stp->st_size;
  384. 	f->mtime = stp->st_mtime;
  385. 	f->atime = stp->st_atime;
  386. 	f->ctime = stp->st_ctime;
  387. #if ST_BLOCKS
  388. 	f->blocks = stp->st_blocks;
  389. #endif
  390. }
  392. #define PAST (26 * 7 * 24 * 3600L) /* Half a year ago. */
  393. /* Between PAST and FUTURE from now a time is printed, otherwise a year. */
  394. #define FUTURE (15 * 60L) /* Fifteen minutes. */
  396. /*
  397.  * Transform the right time field into something readable.
  398.  */
  399. static char *
  400. timestamp(struct file *f)
  401. {
  402. 	struct tm *tm;
  403. 	time_t t;
  404. 	static time_t now;
  405. 	static int drift = 0;
  406. 	static char date[32];
  408. 	t = f->mtime;
  409. 	if(field & FL_ATIME) t = f->atime;
  410. 	if(field & FL_CTIME) t = f->ctime;
  411. 	tm = localtime(&t);
  412. 	if(--drift < 0)
  413. 	{
  414. 		time(&now);
  415. 		drift = 50;
  416. 	} /* limit time() calls */
  417. 	if(t < now - PAST || t > now + FUTURE)
  418. 	{
  419. 		strftime(date, sizeof date - 1, "%b %e  %Y", tm);
  420. 	}
  421. 	else
  422. 	{
  423. 		strftime(date, sizeof date - 1, "%b %e %H:%M", tm);
  424. 	}
  425. 	return date;
  426. }
  428. /*
  429.  * Compute long or short rwx bits.
  430.  */
  431. static char *
  432. permissions(struct file *f)
  433. {
  434. 	/*
  435. 	 * Note that rwx[0] is a guess for the more alien file types.  It is
  436. 	 * correct for BSD4.3 and derived systems.  I just don't know how
  437. 	 * "standardized" these numbers are.
  438. 	 */
  439. 	static char rwx[] = "drwxr-x--x ";
  440. 	char *p = rwx + 1;
  441. 	int mode = f->mode;
  443. 	rwx[0] = ifmt(f->mode);
  444. 	if((f->mode & S_IFMT) == S_IFNAM)
  445. 	{
  446. 		if(f->rdev == S_INSEM)
  447. 			rwx[0] = 's';
  448. 		else if(f->rdev == S_INSHD)
  449. 			rwx[0] = 'm';
  450. 		else
  451. 			rwx[0] = '?';
  452. 	}
  453. 	do
  454. 	{
  455. 		p[0] = (mode & S_IRUSR) ? 'r' : '-';
  456. 		p[1] = (mode & S_IWUSR) ? 'w' : '-';
  457. 		p[2] = (mode & S_IXUSR) ? 'x' : '-';
  458. 		mode <<= 3;
  459. 	} while((p += 3) <= rwx + 7);
  460. 	if(f->mode & S_ISUID) rwx[3] = f->mode & (S_IXUSR >> 0) ? 's' : 'S';
  461. 	if(f->mode & S_ISGID)
  462. 		rwx[6] = f->mode & (S_IXGRP >> 0) ? 's' :
  463. #ifndef UCB
  464. 		         (f->mode & S_IFMT) != S_IFDIR ?
  465. #if defined(SUS) || defined(SU3)
  466. 		                                       'L'
  467. #else  /* !SUS, !SU3 */
  468. 		                                       'l'
  469. #endif /* !SUS, !SU3 */
  470. 		                                       :
  471. #endif /* !UCB */
  472. 		                                       'S';
  473. 	if(f->mode & S_ISVTX) rwx[9] = f->mode & (S_IXUSR >> 6) ? 't' : 'T';
  474. 	/*
  475. 	 * rwx[10] would be the "optional alternate access method flag",
  476. 	 * leave as a space for now.
  477. 	 */
  478. 	return rwx;
  479. }
  481. #ifdef notdef
  482. void
  483. numeral(int i, char **pp)
  484. {
  485. 	char itoa[3 * sizeof(int)], *a = itoa;
  487. 	do
  488. 		*a++ = i % 10 + '0';
  489. 	while((i /= 10) > 0);
  490. 	do
  491. 		*(*pp)++ = *--a;
  492. 	while(a > itoa);
  493. }
  494. #endif
  496. static char *
  497. extension(const char *fn)
  498. {
  499. 	const char *ep = "";
  501. 	while(*fn++)
  502. 		if(*fn == '.') ep = &fn[1];
  503. 	return (char *)ep;
  504. }
  506. static int (*CMP)(struct file *f1, struct file *f2);
  507. static int (*rCMP)(struct file *f1, struct file *f2);
  509. /*
  510.  * This is either a stable mergesort, or thermal noise, I'm no longer sure.
  511.  * It must be called like this: if (L != NULL && L->next != NULL) mergesort(&L);
  512.  */
  513. static void
  514. _mergesort(struct file **al)
  515. {
  516. 	/* static */ struct file *l1, **mid; /* Need not be local */
  517. 	struct file *l2;
  519. 	l1 = *(mid = &(*al)->next);
  520. 	do
  521. 	{
  522. 		if((l1 = l1->next) == NULL) break;
  523. 		mid = &(*mid)->next;
  524. 	} while((l1 = l1->next) != NULL);
  525. 	l2 = *mid;
  526. 	*mid = NULL;
  527. 	if((*al)->next != NULL) _mergesort(al);
  528. 	if(l2->next != NULL) _mergesort(&l2);
  529. 	l1 = *al;
  530. 	for(;;)
  531. 	{
  532. 		if((*CMP)(l1, l2) <= 0)
  533. 		{
  534. 			if((l1 = *(al = &l1->next)) == NULL)
  535. 			{
  536. 				*al = l2;
  537. 				break;
  538. 			}
  539. 		}
  540. 		else
  541. 		{
  542. 			*al = l2;
  543. 			l2 = *(al = &l2->next);
  544. 			*al = l1;
  545. 			if(l2 == NULL) break;
  546. 		}
  547. 	}
  548. }
  550. static int
  551. namecmp(struct file *f1, struct file *f2)
  552. {
  553. 	return strcoll(f1->name, f2->name);
  554. }
  556. static int
  557. extcmp(struct file *f1, struct file *f2)
  558. {
  559. 	return strcoll(extension(f1->name), extension(f2->name));
  560. }
  562. static int
  563. mtimecmp(struct file *f1, struct file *f2)
  564. {
  565. 	return f1->mtime == f2->mtime ? 0 : f1->mtime > f2->mtime ? -1 : 1;
  566. }
  568. static int
  569. atimecmp(struct file *f1, struct file *f2)
  570. {
  571. 	return f1->atime == f2->atime ? 0 : f1->atime > f2->atime ? -1 : 1;
  572. }
  574. static int
  575. ctimecmp(struct file *f1, struct file *f2)
  576. {
  577. 	return f1->ctime == f2->ctime ? 0 : f1->ctime > f2->ctime ? -1 : 1;
  578. }
  580. static int
  581. sizecmp(struct file *f1, struct file *f2)
  582. {
  583. 	return f1->size == f2->size ? 0 : f1->size > f2->size ? -1 : 1;
  584. }
  586. static int
  587. revcmp(struct file *f1, struct file *f2)
  588. {
  589. 	return (*rCMP)(f2, f1);
  590. }
  592. /*
  593.  * Sort the files according to the flags.
  594.  */
  595. static void
  596. sort(struct file **al)
  597. {
  598. 	if(present('U')) return;
  599. 	if(!present('f') && *al != NULL && (*al)->next != NULL)
  600. 	{
  601. 		CMP = namecmp;
  602. 		if(!(field & FL_BYTIME))
  603. 		{
  604. 			/* Sort on name */
  606. 			if(present('r'))
  607. 			{
  608. 				rCMP = CMP;
  609. 				CMP = revcmp;
  610. 			}
  611. 			_mergesort(al);
  612. 		}
  613. 		else
  614. 		{
  615. 			/* Sort on name first, then sort on time. */
  616. 			_mergesort(al);
  617. 			if(field & FL_CTIME)
  618. 			{
  619. 				CMP = ctimecmp;
  620. 			}
  621. 			else if(field & FL_ATIME)
  622. 			{
  623. 				CMP = atimecmp;
  624. 			}
  625. 			else
  626. 			{
  627. 				CMP = mtimecmp;
  628. 			}
  629. 			if(present('r'))
  630. 			{
  631. 				rCMP = CMP;
  632. 				CMP = revcmp;
  633. 			}
  634. 			_mergesort(al);
  635. 		}
  636. 		if(present('X'))
  637. 		{
  638. 			CMP = extcmp;
  639. 			if(present('r'))
  640. 			{
  641. 				rCMP = CMP;
  642. 				CMP = revcmp;
  643. 			}
  644. 			_mergesort(al);
  645. 		}
  646. 		if(present('S'))
  647. 		{
  648. 			CMP = sizecmp;
  649. 			if(present('r'))
  650. 			{
  651. 				rCMP = CMP;
  652. 				CMP = revcmp;
  653. 			}
  654. 			_mergesort(al);
  655. 		}
  656. 	}
  657. }
  659. /*
  660.  * Create file structure for given name.
  661.  */
  662. static struct file *
  663. newfile(char *name)
  664. {
  665. 	struct file *new;
  667. 	new = salloc(sizeof(*new));
  668. 	new->name = strcpy(salloc(strlen(name) + 1), name);
  669. 	new->namlen = 0;
  670. 	new->flag = 0;
  671. 	return new;
  672. }
  674. /*
  675.  * Add file to the head of a list.
  676.  */
  677. static void
  678. pushfile(struct file **flist, struct file *new)
  679. {
  680. 	new->next = *flist;
  681. 	*flist = new;
  682. }
  684. /*
  685.  * Release old file structure.
  686.  */
  687. static void
  688. delfile(struct file *old)
  689. {
  690. 	free(old->name);
  691. 	free(old);
  692. }
  694. /*
  695.  * Pop file off top of file list.
  696.  */
  697. static struct file *
  698. popfile(struct file **flist)
  699. {
  700. 	struct file *f;
  702. 	f = *flist;
  703. 	*flist = f->next;
  704. 	return f;
  705. }
  707. /*
  708.  * Save the current file order.
  709.  */
  710. static void
  711. savord(struct file *f)
  712. {
  713. 	while(f)
  714. 	{
  715. 		f->sord = f->next;
  716. 		f = f->next;
  717. 	}
  718. }
  720. /*
  721.  * Restore the saved file order.
  722.  */
  723. static void
  724. resord(struct file *f)
  725. {
  726. 	while(f)
  727. 	{
  728. 		f->next = f->sord;
  729. 		f = f->sord;
  730. 	}
  731. }
  733. /*
  734.  * Return flag that would make ls list this name: -a or -A.
  735.  */
  736. static int
  737. dotflag(char *name)
  738. {
  739. 	if(*name++ != '.') return 0;
  740. 	switch(*name++)
  741. 	{
  742. 	case 0:
  743. 		return 'a'; /* "." */
  744. 	case '.':
  745. 		if(*name == 0) return 'a'; /* ".." */
  746. 	default:
  747. 		return 'A'; /* ".*" */
  748. 	}
  749. }
  751. /*
  752.  * Add directory entries of directory name to a file list.
  753.  */
  754. static int
  755. adddir(struct file **aflist, char *name)
  756. {
  757. 	DIR *d;
  758. 	struct dirent *e;
  760. 	if(access(name, 0) < 0)
  761. 	{
  762. 		report(name);
  763. 		return 0;
  764. 	}
  765. 	if((d = opendir(name)) == NULL)
  766. 	{
  767. #ifdef UCB
  768. 		fprintf(stderr, "%s unreadable\n", name);
  769. #else
  770. 		fprintf(stderr, "can not access directory %s\n", name);
  771. #endif
  772. 		ex = 1;
  773. 		return 0;
  774. 	}
  775. 	while((e = readdir(d)) != NULL)
  776. 	{
  777. 		if(e->d_ino != 0 && present(dotflag(e->d_name)))
  778. 		{
  779. 			pushfile(aflist, newfile(e->d_name));
  780. 			aflist = &(*aflist)->next;
  781. 		}
  782. 	}
  783. 	closedir(d);
  784. 	return 1;
  785. }
  787. /*
  788.  * Compute total block count for a list of files.
  789.  */
  790. static off_t
  791. countblocks(struct file *flist)
  792. {
  793. 	off_t cb = 0;
  795. 	while(flist != NULL)
  796. 	{
  797. 		switch(flist->mode & S_IFMT)
  798. 		{
  799. 		case S_IFDIR:
  800. 		case S_IFREG:
  801. #ifdef S_IFLNK
  802. 		case S_IFLNK:
  803. #endif
  804. 			cb += flist->blocks;
  805. 		}
  806. 		flist = flist->next;
  807. 	}
  808. 	return cb;
  809. }
  811. static char *
  812. #ifdef LONGLONG
  813. hfmt(long long n, int fill)
  814. #else
  815. hfmt(long n, int fill)
  816. #endif
  817. {
  818. 	static char b[10];
  819. 	const char units[] = " KMGTPE", *up = units;
  820. 	int rest = 0;
  822. 	while(n > 1023)
  823. 	{
  824. 		rest = (n % 1024) / 128;
  825. 		n /= 1024;
  826. 		up++;
  827. 	}
  828. #ifdef LONGLONG
  829. 	if(up == units)
  830. 		snprintf(b, sizeof b, "%*llu", fill ? 5 : 1, n);
  831. 	else if(n < 10 && rest)
  832. 		snprintf(b, sizeof b, "%*llu.%u%c", fill ? 2 : 1, n, rest, *up);
  833. 	else
  834. 		snprintf(b, sizeof b, "%*llu%c", fill ? 4 : 1, n, *up);
  835. #else  /* !LONGLONG */
  836. 	if(up == units)
  837. 		snprintf(b, sizeof b, "%*lu", fill ? 5 : 1, n);
  838. 	else if(n < 10 && rest)
  839. 		snprintf(b, sizeof b, "%*lu.%u%c", fill ? 2 : 1, n, rest, *up);
  840. 	else
  841. 		snprintf(b, sizeof b, "%*lu%c", fill ? 4 : 1, n, *up);
  842. #endif /* !LONGLONG */
  843. 	return b;
  844. }
  846. #define FC_NORMAL 0
  847. #define FC_BLACK 30
  848. #define FC_RED 31
  849. #define FC_GREEN 32
  850. #define FC_YELLOW 33
  851. #define FC_BLUE 34
  852. #define FC_MAGENTA 35
  853. #define FC_CYAN 36
  854. #define FC_WHITE 37
  856. /*
  857.  * Display a nonprintable character.
  858.  */
  859. static unsigned
  860. nonprint(register int c, int doit)
  861. {
  862. 	register int d;
  863. 	unsigned n;
  865. 	if(present('b'))
  866. 	{
  867. 		n = 4;
  868. 		if(doit)
  869. 		{
  870. 			char *nums = "01234567";
  872. 			putchar('\\');
  873. 			putchar(nums[(c & ~077) >> 6]);
  874. 			c &= 077;
  875. 			d = c & 07;
  876. 			if(c > d)
  877. 				putchar(nums[(c - d) >> 3]);
  878. 			else
  879. 				putchar(nums[0]);
  880. 			putchar(nums[d]);
  881. 		}
  882. 	}
  883. 	else
  884. 	{
  885. 		n = 1;
  886. 		if(doit) putchar('?');
  887. 	}
  888. 	return n;
  889. }
  891. /*
  892.  * Print a name with control characters as '?' (unless -q).  The terminal is
  893.  * assumed to be eight bit clean.
  894.  */
  895. static unsigned
  896. printname(const char *name, struct file *f, int doit)
  897. {
  898. 	int c, q = present('q');
  899. 	unsigned n = 0;
  901. 	if(f != NULL && doit == 0 && f->namlen != 0) return f->namlen;
  902. 	if(q || istty)
  903. 	{
  904. #ifdef MB_CUR_MAX
  905. 		wchar_t wc;
  907. 		while(
  908. #define ASCII
  909. #ifdef ASCII
  910. 		    (*name & 0200) == 0 ? c = 1,
  911. 		    (wc = *name) != '\0'
  912. 		                        :
  913. #endif
  914. 		                        (c = mbtowc(&wc, name, MB_CUR_MAX)) != 0)
  915. 		{
  916. 			if(c != -1)
  917. 			{
  918. 				if(iswprint(wc)
  919. #ifdef UCB
  920. 				   || wc == '\t' || wc == '\n'
  921. #else  /* !UCB */
  922. 				    && wc != '\t'
  923. #endif /* !UCB */
  924. 				)
  925. 				{
  926. 					if(doit)
  927. 					{
  928. 						while(c-- > 0)
  929. 							putchar(*name++ & 0377);
  930. 					}
  931. 					else
  932. 						name += c;
  933. 					n += wcwidth(wc);
  934. 				}
  935. 				else
  936. 				{
  937. 					while(c-- > 0)
  938. 						n += nonprint(*name++ & 0377, doit);
  939. 				}
  940. 			}
  941. 			else
  942. 				n += nonprint(*name++ & 0377, doit);
  943. 		}
  944. #else /* !MB_CUR_MAX */
  945. 		while((c = (*name++ & 0377)) != '\0')
  946. 		{
  947. 			if(isprint(c)
  948. #ifdef UCB
  949. 			   || c == '\t' || c == '\n'
  950. #else  /* !UCB */
  951. 			    && c != '\t'
  952. #endif /* !UCB */
  953. 			)
  954. 			{
  955. 				if(doit) putchar(c);
  956. 				n++;
  957. 			}
  958. 			else
  959. 				n += nonprint(c, doit);
  960. 		}
  961. #endif /* !MB_CUR_MAX */
  962. 	}
  963. 	else
  964. 	{
  965. 		while((c = (*name++ & 0377)) != '\0')
  966. 		{
  967. 			if(doit) putchar(c);
  968. 			n++;
  969. 		}
  970. 	}
  971. 	if(f) f->namlen = n;
  972. 	return n;
  973. }
  975. static int
  976. mark(struct file *f, int doit)
  977. {
  978. 	int c;
  980. 	if(!(field & FL_MARK)) return 0;
  981. 	switch(f->mode & S_IFMT)
  982. 	{
  983. 	case S_IFDIR:
  984. 		c = '/';
  985. 		break;
  986. #ifdef S_IFIFO
  987. 	case S_IFIFO:
  988. 		c = '|';
  989. 		break;
  990. #endif
  991. #ifdef S_IFLNK
  992. 	case S_IFLNK:
  993. 		c = '@';
  994. 		break;
  995. #endif
  996. #ifdef S_IFSOCK
  997. 	case S_IFSOCK:
  998. 		c = '=';
  999. 		break;
  1000. #endif
  1001. #ifdef S_IFDOOR
  1002. 	case S_IFDOOR:
  1003. 		c = '>';
  1004. 		break;
  1005. #endif
  1006. 	case S_IFREG:
  1007. 		if(f->mode & (S_IXUSR | S_IXGRP | S_IXOTH))
  1008. 		{
  1009. 			c = '*';
  1010. 			break;
  1011. 		}
  1012. 	default:
  1013. 		c = 0;
  1014. 	}
  1015. 	if(doit && c != 0) putchar(c);
  1016. 	return c;
  1017. }
  1019. static int colwidth[MAXCOLS]; /* Need colwidth[i] spaces to print column i. */
  1020. static int sizwidth[MAXCOLS]; /* Spaces for the size field in a -X print. */
  1021. static int namwidth[MAXCOLS]; /* Name field. */
  1023. /*
  1024.  * Set *aw to the larger of it and w.  Then return it.
  1025.  */
  1026. static int
  1027. maxise(int *aw, int w)
  1028. {
  1029. 	if(w > *aw) *aw = w;
  1030. 	return *aw;
  1031. }
  1033. static int nsp = 0; /* This many spaces have not been printed yet. */
  1034. #define spaces(n) (nsp = (n))
  1035. #define terpri() (nsp = 0, putchar('\n')) /* No trailing spaces */
  1037. /*
  1038.  * Either compute the number of spaces needed to print file f (doit == 0) or
  1039.  * really print it (doit == 1).
  1040.  */
  1041. static int
  1042. print1(struct file *f, int col, int doit)
  1043. {
  1044. 	int width = 0, n;
  1046. 	n = printname(f->name, f, 0);
  1047. 	if(present('m'))
  1048. 	{
  1049. 		if(present('p') && (f->mode & S_IFMT) == S_IFDIR) width++;
  1050. 		if(present('F')) width++;
  1051. 	}
  1052. 	while(nsp > 0)
  1053. 	{
  1054. 		putchar(' ');
  1055. 		nsp--;
  1056. 	} /* Fill gap between two columns */
  1057. 	if(field & FL_INODE)
  1058. 	{
  1059. 		char dummy[2];
  1060. 		if(doit)
  1061. #ifdef LONGLONG
  1062. 			printf("%*llu ", present('m') ? 1 : 5, (long long)f->ino);
  1063. #else
  1064. 			printf("%*lu ", present('m') ? 1 : 5, (long)f->ino);
  1065. #endif
  1066. 		else
  1067. #ifdef LONGLONG
  1068. 			width += snprintf(dummy, sizeof dummy, "%*llu ", present('m') ? 1 : 5, (long long)f->ino);
  1069. #else
  1070. 			width += snprintf(dummy, sizeof dummy, "%*lu ", present('m') ? 1 : 5, (long)f->ino);
  1071. #endif
  1072. 	}
  1073. 	if(field & FL_BLOCKS)
  1074. 	{
  1075. 		char dummy[2];
  1076. 		if(doit)
  1077. 		{
  1078. 			if(present('h'))
  1079. 				printf("%s ", hfmt(f->blocks * 512, !present('m')));
  1080. 			else
  1081. #ifdef LONGLONG
  1082. 				printf("%*llu ", present('m') ? 1 : 4, (long long)blockcount(f->blocks));
  1083. #else
  1084. 				printf("%*lu ", present('m') ? 1 : 4, (long)blockcount(f->blocks));
  1085. #endif
  1086. 		}
  1087. 		else
  1088. 		{
  1089. 			if(present('h'))
  1090. 				width += 6;
  1091. 			else
  1092. #ifdef LONGLONG
  1093. 				width +=
  1094. 				    snprintf(dummy, sizeof dummy, "%*llu ", present('m') ? 1 : 4, (long long)f->blocks);
  1095. #else
  1096. 				width += snprintf(dummy, sizeof dummy, "%*lu ", present('m') ? 1 : 4, (long)f->blocks);
  1097. #endif
  1098. 		}
  1099. 	}
  1100. 	if(field & FL_MODE)
  1101. 	{
  1102. 		if(doit)
  1103. 		{
  1104. 			printf("%s ", permissions(f));
  1105. 		}
  1106. 		else
  1107. 		{
  1108. 			width += 11;
  1109. 		}
  1110. 	}
  1111. 	if(field & FL_LONG)
  1112. 	{
  1113. 		if(doit)
  1114. 		{
  1115. 			printf("%2u ", (unsigned)f->nlink);
  1116. 			if(!(field & FL_GROUP))
  1117. 			{
  1118. 				printf("%-8s ", uidname(f->uid));
  1119. 			}
  1120. 			if(!(field & FL_OWNER))
  1121. 			{
  1122. 				printf("%-8s ", gidname(f->gid));
  1123. 			}
  1124. 			switch(f->mode & S_IFMT)
  1125. 			{
  1126. 			case S_IFBLK:
  1127. 			case S_IFCHR:
  1128. #ifdef S_IFMPB
  1129. 			case S_IFMPB:
  1130. #endif
  1131. #ifdef S_IFMPC
  1132. 			case S_IFMPC:
  1133. #endif
  1134. 				printf("%3lu,%3lu ", (long)major(f->rdev), (long)minor(f->rdev));
  1135. 				break;
  1136. 			default:
  1137. 				if(present('h'))
  1138. 					printf("%5s ", hfmt(f->size, 1));
  1139. 				else
  1140. #ifdef LONGLONG
  1141. 					printf("%7llu ", (long long)f->size);
  1142. #else
  1143. 					printf("%7lu ", (long)f->size);
  1144. #endif
  1145. 			}
  1146. 			printf("%s ", timestamp(f));
  1147. 		}
  1148. 		else
  1149. 		{
  1150. 			width += (field & FL_GROUP) ? 34 : 43;
  1151. 		}
  1152. 	}
  1153. 	if(doit)
  1154. 	{
  1155. 		printname(f->name, f, 1);
  1156. 		if(mark(f, 1) != 0) n++;
  1157. 		if(present('p') && (f->mode & S_IFMT) == S_IFDIR)
  1158. 		{
  1159. 			n++;
  1160. 			if(doit) putchar('/');
  1161. 		}
  1162. #ifdef S_IFLNK
  1163. 		if((field & FL_LONG) && (f->mode & S_IFMT) == S_IFLNK)
  1164. 		{
  1165. 			char *buf;
  1166. 			int sz, r, didx;
  1168. 			sz = f->size ? f->size : PATH_MAX;
  1169. 			buf = salloc(sz + 1);
  1170. 			addpath(&didx, f->name);
  1171. 			if((r = readlink(path, buf, sz)) < 0) r = 0;
  1172. 			delpath(didx);
  1173. 			buf[r] = 0;
  1174. 			printf(" -> ");
  1175. 			printname(buf, NULL, 1);
  1176. 			free(buf);
  1177. 			n += 4 + r;
  1178. 		}
  1179. #endif
  1180. 		if(!present('m')) spaces(namwidth[col] - n);
  1181. 	}
  1182. 	else
  1183. 	{
  1184. 		if(mark(f, 0) != 0) n++;
  1185. #ifdef S_IFLNK
  1186. 		if((field & FL_LONG) && (f->mode & S_IFMT) == S_IFLNK)
  1187. 		{
  1188. 			n += 4 + (int)f->size;
  1189. 		}
  1190. #endif
  1191. 		if(!present('m'))
  1192. 		{
  1193. 			width += maxise(&namwidth[col], n + NSEP);
  1194. 			maxise(&colwidth[col], width);
  1195. 		}
  1196. 	}
  1197. 	return n + width;
  1198. }
  1200. /*
  1201.  * Return number of files in the list.
  1202.  */
  1203. static int
  1204. countfiles(struct file *flist)
  1205. {
  1206. 	int n = 0;
  1208. 	while(flist != NULL)
  1209. 	{
  1210. 		n++;
  1211. 		flist = flist->next;
  1212. 	}
  1213. 	return n;
  1214. }
  1216. static struct file *filecol[MAXCOLS]; /*
  1217. 					 * filecol[i] is list of files
  1218. 					 * for column i.
  1219. 					 */
  1220. static int nfiles, nlines;            /* # files to print, # of lines needed. */
  1222. /*
  1223.  * Chop list of files up in columns.  Note that 3 columns are used for 5 files
  1224.  * even though nplin may be 4, filecol[3] will simply be NULL.
  1225.  */
  1226. static void
  1227. columnise(struct file **flist, struct file *fsav, int nplin)
  1228. {
  1229. 	struct file *f = *flist;
  1230. 	int i, j;
  1232. 	nlines = (nfiles + nplin - 1) / nplin; /* nlines needed for nfiles */
  1233. 	filecol[0] = f;
  1234. 	if(!present('x'))
  1235. 	{
  1236. 		for(i = 1; i < nplin; i++)
  1237. 		{
  1238. 			/* Give nlines files to each column. */
  1239. 			for(j = 0; j < nlines && f != NULL; j++)
  1240. 				f = f->next;
  1241. 			filecol[i] = f;
  1242. 		}
  1243. 	}
  1244. 	else
  1245. 	{
  1246. 		/*
  1247. 		 * Ok, this is an ugly hack. We use the mechanisms for '-C'
  1248. 		 * and thus have to change the file list order.
  1249. 		 */
  1250. 		struct file *curcol[MAXCOLS];
  1252. 		resord(fsav);
  1253. 		*flist = fsav;
  1254. 		f = *flist;
  1255. 		for(i = 0; i < nplin && f; i++)
  1256. 		{
  1257. 			filecol[i] = curcol[i] = f;
  1258. 			f->flag &= ~ENDCOL;
  1259. 			f = f->next;
  1260. 		}
  1261. 		while(f != NULL)
  1262. 		{
  1263. 			for(i = 0; i < nplin && f; i++)
  1264. 			{
  1265. 				curcol[i]->next = f;
  1266. 				curcol[i] = f;
  1267. 				f->flag &= ~ENDCOL;
  1268. 				f = f->next;
  1269. 			}
  1270. 		}
  1271. 		for(i = 1; i < nplin; i++)
  1272. 		{
  1273. 			curcol[i - 1]->next = filecol[i];
  1274. 			curcol[i - 1]->flag |= ENDCOL;
  1275. 		}
  1276. 		curcol[nplin - 1]->next = NULL;
  1277. 	}
  1278. }
  1280. /*
  1281.  * Try (doit == 0), or really print the list of files over nplin columns.
  1282.  * Return true if it can be done in nplin columns or if nplin == 1.
  1283.  */
  1284. static int
  1285. print(struct file **flist, struct file *fsav, int nplin, int doit)
  1286. {
  1287. 	register struct file *f;
  1288. 	register int i, totlen;
  1290. 	if(present('m'))
  1291. 	{
  1292. 		if(!doit) return 1;
  1293. 		totlen = 0;
  1294. 		for(f = *flist; f; f = f->next)
  1295. 		{
  1296. 			i = print1(f, 0, 0) + 2;
  1297. 			totlen += i;
  1298. 			if(totlen > ncols + 1)
  1299. 			{
  1300. 				putchar('\n');
  1301. 				totlen = i;
  1302. 			}
  1303. 			else if(f != *flist)
  1304. 				putchar(' ');
  1305. 			print1(f, 0, 1);
  1306. 			if(f->next) putchar(',');
  1307. 		}
  1308. 		putchar('\n');
  1309. 		return 1;
  1310. 	}
  1311. 	columnise(flist, fsav, nplin);
  1312. 	if(!doit)
  1313. 	{
  1314. 		if(nplin == 1) return 1; /* No need to try 1 column. */
  1315. 		for(i = 0; i < nplin; i++)
  1316. 		{
  1317. 			colwidth[i] = sizwidth[i] = namwidth[i] = 0;
  1318. 		}
  1319. 	}
  1320. 	while(--nlines >= 0)
  1321. 	{
  1322. 		totlen = 0;
  1323. 		for(i = 0; i < nplin; i++)
  1324. 		{
  1325. 			if((f = filecol[i]) != NULL)
  1326. 			{
  1327. 				if(f->flag & ENDCOL)
  1328. 					filecol[i] = NULL;
  1329. 				else
  1330. 					filecol[i] = f->next;
  1331. 				print1(f, i, doit);
  1332. 			}
  1333. 			if(!doit && nplin > 1)
  1334. 			{
  1335. 				/* See if this line is not too long. */
  1336. 				totlen += colwidth[i];
  1337. 				if(totlen > ncols + NSEP) return 0;
  1338. 			}
  1339. 		}
  1340. 		if(doit && !present('m')) terpri();
  1341. 	}
  1342. 	return 1;
  1343. }
  1345. enum depth
  1346. {
  1347. 	SURFACE,
  1348. 	SURFACE1,
  1349. 	SUBMERGED
  1350. };
  1351. enum state
  1352. {
  1353. 	BOTTOM,
  1354. 	SINKING,
  1355. 	FLOATING
  1356. };
  1358. /*
  1359.  * Main workhorse of ls, it sorts and prints the list of files.  Flags:
  1360.  * depth: working with the command line / just one file / listing dir.
  1361.  * state: How "recursive" do we have to be.
  1362.  */
  1363. static void
  1364. listfiles(struct file *flist, enum depth depth, enum state state, int level)
  1365. {
  1366. 	struct file *dlist = NULL, **afl = &flist, **adl = &dlist, *fsav;
  1367. 	int nplin, t;
  1368. 	static int white = 1; /* Nothing printed yet. */
  1370. 	/*
  1371. 	 * Flush everything previously printed, so new error output will
  1372. 	 * not intermix with files listed earlier.
  1373. 	 */
  1374. 	fflush(stdout);
  1375. 	if(field != 0 || state != BOTTOM)
  1376. 	{ /* Need stat(2) info. */
  1377. 		while(*afl != NULL)
  1378. 		{
  1379. 			static struct stat st;
  1380. 			int didx;
  1381. #ifdef S_IFLNK
  1382. 			int (*status)(const char *file, struct stat *stp) =
  1383. 			    depth == SURFACE1 && (field & FL_LONG) == 0
  1384. #ifdef SU3
  1385. 			                && !present('F')
  1386. #endif /* SU3 */
  1387. 			            || present('L') || present('H') && depth != SUBMERGED
  1388. 			        ? stat
  1389. 			        : lstat;
  1390. #else
  1391. #define status stat
  1392. #endif
  1394. 			/* Basic disk block size is 512 except for one niche O.S. */
  1396. 			addpath(&didx, (*afl)->name);
  1397. 			if((t = status(path, &st)) < 0
  1398. #ifdef S_IFLNK
  1399. 			   && (status == lstat || lstat(path, &st) < 0)
  1400. #endif
  1401. 			)
  1402. 			{
  1403. 				if(depth != SUBMERGED || errno != ENOENT) report((*afl)->name);
  1404. #ifdef SU3
  1405. 			fail:
  1406. #endif /* SU3 */
  1407. 				delfile(popfile(afl));
  1408. 			}
  1409. 			else
  1410. 			{
  1411. #ifdef SU3
  1412. 				if(t < 0 && errno == ELOOP && (present('H') || present('L')))
  1413. 				{
  1414. 					report((*afl)->name);
  1415. 					goto fail;
  1416. 				}
  1417. 				if(present('L'))
  1418. 				{
  1419. 					int i;
  1420. 					for(i = 0; i < level; i++)
  1421. 					{
  1422. 						if(st.st_dev == visited[i].v_dev && st.st_ino == visited[i].v_ino)
  1423. 						{
  1424. 							fprintf(stderr,
  1425. 							        "link "
  1426. 							        "loop at %s\n",
  1427. 							        path);
  1428. 							ex = 1;
  1429. 							goto fail;
  1430. 						}
  1431. 					}
  1432. 					if(level >= vismax)
  1433. 					{
  1434. 						vismax += 20;
  1435. 						visited = srealloc(visited, sizeof *visited * vismax);
  1436. 					}
  1437. 					visited[level].v_dev = st.st_dev;
  1438. 					visited[level].v_ino = st.st_ino;
  1439. 				}
  1440. #endif /* SU3 */
  1441. 				if(((field & FL_MARK) || tinfostat == 1 || present('H')) && !present('L') &&
  1442. 				   status != lstat && (st.st_mode & S_IFMT) != S_IFDIR)
  1443. 				{
  1444. 					struct stat lst;
  1446. 					if(lstat(path, &lst) == 0) st = lst;
  1447. 				}
  1448. 				setstat(*afl, &st);
  1449. 				afl = &(*afl)->next;
  1450. 			}
  1451. 			delpath(didx);
  1452. 		}
  1453. 	}
  1454. 	sort(&flist);
  1455. 	if(depth == SUBMERGED && (field & (FL_BLOCKS | FL_LONG)))
  1456. 	{
  1457. 		printf("total ");
  1458. 		if(present('h'))
  1459. 			printf("%s\n", hfmt(countblocks(flist) * 512, 0));
  1460. 		else
  1461. #ifdef LONGLONG
  1462. 			printf("%lld\n", (long long)blockcount(countblocks(flist)));
  1463. #else
  1464. 			printf("%ld\n", (long)blockcount(countblocks(flist)));
  1465. #endif
  1466. 	}
  1467. 	if(state == SINKING || depth == SURFACE1)
  1468. 	{
  1469. 		/* Don't list directories themselves, list their contents later. */
  1470. 		afl = &flist;
  1471. 		while(*afl != NULL)
  1472. 		{
  1473. 			if(((*afl)->mode & S_IFMT) == S_IFDIR)
  1474. 			{
  1475. 				pushfile(adl, popfile(afl));
  1476. 				adl = &(*adl)->next;
  1477. 			}
  1478. 			else
  1479. 			{
  1480. 				afl = &(*afl)->next;
  1481. 			}
  1482. 		}
  1483. 	}
  1484. 	if((nfiles = countfiles(flist)) > 0)
  1485. 	{
  1486. 		/* Print files in how many columns? */
  1487. 		nplin = !present('C') && !present('x') ? 1 : nfiles < MAXCOLS ? nfiles : MAXCOLS;
  1488. 		fsav = flist;
  1489. 		if(present('x')) savord(flist);
  1490. 		while(!print(&flist, fsav, nplin, 0))
  1491. 			nplin--;                     /* Try first */
  1492. 		print(&flist, fsav, nplin, 1); /* Then do it! */
  1493. 		white = 0;
  1494. 	}
  1495. 	while(flist != NULL)
  1496. 	{ /* Destroy file list */
  1497. 		if(state == FLOATING && (flist->mode & S_IFMT) == S_IFDIR)
  1498. 		{
  1499. 			/* But keep these directories for ls -R. */
  1500. 			pushfile(adl, popfile(&flist));
  1501. 			adl = &(*adl)->next;
  1502. 		}
  1503. 		else
  1504. 		{
  1505. 			delfile(popfile(&flist));
  1506. 		}
  1507. 	}
  1508. 	while(dlist != NULL)
  1509. 	{ /* List directories */
  1510. 		if(dotflag(dlist->name) != 'a' || depth != SUBMERGED)
  1511. 		{
  1512. 			int didx;
  1514. 			addpath(&didx, dlist->name);
  1516. 			flist = NULL;
  1517. 			if(adddir(&flist, path))
  1518. 			{
  1519. 				if(depth != SURFACE1)
  1520. 				{
  1521. 					if(!white) putchar('\n');
  1522. 					white = 0;
  1523. 				}
  1524. 				if(depth != SURFACE1 || present('R')) printf("%s:\n", path);
  1525. 				listfiles(flist, SUBMERGED, state == FLOATING ? FLOATING : BOTTOM, level + 1);
  1526. 			}
  1527. 			delpath(didx);
  1528. 		}
  1529. 		delfile(popfile(&dlist));
  1530. 	}
  1531. }
  1533. #ifndef UCB
  1534. static void
  1535. usage(void)
  1536. {
  1537. 	if(personality == PER_LS) fprintf(stderr, "usage: %s -1RadCxmnlogrtucpFbqisfL [files]\n", arg0);
  1538. 	exit(2);
  1539. }
  1540. #else /* UCB */
  1541. #define usage()
  1542. #endif /* UCB */
  1544. int
  1545. main(int argc, char **argv)
  1546. {
  1547. 	struct file *flist = NULL, **aflist = &flist;
  1548. 	enum depth depth;
  1549. 	struct winsize ws;
  1550. 	int i;
  1551. 	char *cp;
  1553. 	setlocale(LC_ALL, "");
  1554. 	uid = geteuid();
  1555. 	gid = getegid();
  1556. 	arg0 = basename(argv[0]);
  1557. 	if(strcmp(arg0, "dir") == 0)
  1558. 	{
  1559. 		flags['s'] = flags['U'] = 1;
  1560. 		personality = PER_DIR;
  1561. 	}
  1562. 	else if(strcmp(arg0, "lc") == 0)
  1563. 	{
  1564. 		flags['C'] = 1;
  1565. 		istty = 1;
  1566. 	}
  1567. 	if(istty || isatty(1))
  1568. 	{
  1569. 		istty = 1;
  1570. 		field |= FL_STATUS;
  1571. 	}
  1572. 	while((i = getopt(argc, argv, personalities[personality].per_opt)) != EOF)
  1573. 	{
  1574. 		switch(i)
  1575. 		{
  1576. 		case '?':
  1577. 			usage();
  1578. 			break;
  1580. 		case 'O':
  1581. 			flags['U'] = 0;
  1582. 			break;
  1583. 		case '1':
  1584. 			flags[i] = 1;
  1585. 			flags['C'] = 0;
  1586. 			break;
  1587. 		case 'L':
  1588. 			flags[i] = 1;
  1589. 			flags['H'] = 0;
  1590. 			break;
  1591. 		case 'H':
  1592. 			flags[i] = 1;
  1593. 			flags['L'] = 0;
  1594. 			break;
  1595. #if defined(SUS) || defined(SU3)
  1596. 		case 'C':
  1597. 			flags[i] = 1;
  1598. 			flags['l'] = flags['m'] = flags['x'] = flags['o'] = flags['g'] = flags['n'] = flags['1'] = 0;
  1599. 			break;
  1600. 		case 'm':
  1601. 			flags[i] = 1;
  1602. 			flags['l'] = flags['C'] = flags['x'] = flags['o'] = flags['g'] = flags['n'] = flags['1'] = 0;
  1603. 			break;
  1604. 		case 'l':
  1605. 			flags[i] = 1;
  1606. 			flags['m'] = flags['C'] = flags['x'] = flags['o'] = flags['g'] = 0;
  1607. 			break;
  1608. 		case 'x':
  1609. 			flags[i] = 1;
  1610. 			flags['m'] = flags['C'] = flags['l'] = flags['o'] = flags['g'] = flags['n'] = flags['1'] = 0;
  1611. 			break;
  1612. 		case 'g':
  1613. 			flags[i] = 1;
  1614. 			flags['m'] = flags['C'] = flags['l'] = flags['x'] = flags['o'] = 0;
  1615. 			break;
  1616. 		case 'o':
  1617. 			flags[i] = 1;
  1618. 			flags['m'] = flags['C'] = flags['l'] = flags['x'] = flags['g'] = 0;
  1619. 			break;
  1620. 		case 'n':
  1621. 			flags[i] = 1;
  1622. 			flags['m'] = flags['C'] = flags['x'] = 0;
  1623. 			break;
  1624. #endif /* !SUS, !SU3 */
  1625. 		default:
  1626. 			flags[i] = 1;
  1627. 		}
  1628. 	}
  1629. #ifdef UCB
  1630. 	if(present('l'))
  1631. 	{
  1632. 		if(present('g'))
  1633. 			flags['g'] = 0;
  1634. 		else
  1635. 			flags['o'] = 1;
  1636. 	}
  1637. 	else if(present('g'))
  1638. 		flags['g'] = 0;
  1639. #endif
  1640. #ifdef UCB
  1641. 	if(SUPER_ID == 0 || present('a')) flags['A'] = 1;
  1642. #else  /* !UCB */
  1643. 	if(present('a')) flags['A'] = 1;
  1644. #endif /* !UCB */
  1645. 	if(present('i')) field |= FL_INODE;
  1646. 	if(present('s')) field |= FL_BLOCKS;
  1647. 	if(present('t')) field |= FL_BYTIME;
  1648. 	if(present('u')) field |= FL_ATIME;
  1649. 	if(present('c')) field |= FL_CTIME;
  1650. 	if(present('l') || present('n') || present('g') || present('o'))
  1651. 	{
  1652. 		field = field | FL_MODE | FL_LONG;
  1653. 		flags['m'] = flags['C'] = flags['x'] = 0;
  1654. 	}
  1655. 	if(present('g')) field = field | FL_MODE | FL_LONG | FL_GROUP;
  1656. 	if(present('o')) field = field | FL_MODE | FL_LONG | FL_OWNER;
  1657. 	if(present('F')) field |= FL_MARK;
  1658. 	if(present('d')) field |= FL_DIR;
  1659. 	if(present('f'))
  1660. 	{
  1661. 		field &= ~(FL_LONG | FL_BYTIME | FL_BLOCKS | FL_MODE | FL_MARK | FL_DIR);
  1662. 		flags['o'] = flags['g'] = flags['l'] = flags['t'] = flags['s'] = flags['r'] = flags['d'] =
  1663. 		    flags['F'] = flags['R'] = flags['p'] = 0;
  1664. 		flags['a'] = flags['A'] = 1;
  1665. 		field |= FL_STATUS;
  1666. 	}
  1667. 	if(!present('1') && !present('C') && !present('l') && !present('o') && !present('g') &&
  1668. 	   !present('m') && (istty || present('x')))
  1669. 		flags['C'] = 1;
  1670. 	if(istty) flags['q'] = 1;
  1671. 	if((cp = getenv("COLUMNS")) != NULL)
  1672. 	{
  1673. 		ncols = atoi(cp);
  1674. 	}
  1675. 	else if((present('C') || present('x') || present('m')) && istty)
  1676. 	{
  1677. 		if(ioctl(1, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) ncols = ws.ws_col - 1;
  1678. 	}
  1679. 	depth = SURFACE;
  1680. 	if(optind == argc)
  1681. 	{
  1682. 		if(!(field & FL_DIR)) depth = SURFACE1;
  1683. 		pushfile(aflist, newfile("."));
  1684. 	}
  1685. 	else
  1686. 	{
  1687. 		if(optind + 1 == argc && !(field & FL_DIR)) depth = SURFACE1;
  1688. 		while(optind < argc)
  1689. 		{
  1690. 			if(present('f'))
  1691. 			{
  1692. 				struct stat st;
  1694. 				if(stat(argv[optind], &st) == 0 && (st.st_mode & S_IFMT) != S_IFDIR)
  1695. 				{
  1696. #ifdef UCB
  1697. 					fprintf(stderr, "%s unreadable\n", argv[optind]);
  1698. #else
  1699. 					fprintf(stderr, "%s: Not a directory\n", argv[optind]);
  1700. #endif
  1701. 					ex = 1;
  1702. 					optind++;
  1703. 					continue;
  1704. 				}
  1705. 			}
  1706. 			pushfile(aflist, newfile(argv[optind++]));
  1707. 			aflist = &(*aflist)->next;
  1708. 		}
  1709. 	}
  1710. 	listfiles(flist, depth, (field & FL_DIR) ? BOTTOM : present('R') ? FLOATING : SINKING, 0);
  1711. 	return ex;
  1712. }