2005-01-10 08:39:26 +00:00
|
|
|
/*-
|
2017-11-20 19:49:47 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-26 06:18:55 +00:00
|
|
|
* Copyright (c) 1989, 1993, 1994
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
* Michael Fischbein.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-26 06:18:55 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef lint
|
1997-08-07 15:33:50 +00:00
|
|
|
static const char copyright[] =
|
1994-05-26 06:18:55 +00:00
|
|
|
"@(#) Copyright (c) 1989, 1993, 1994\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n";
|
1997-08-07 22:28:25 +00:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#if 0
|
2002-02-03 20:55:54 +00:00
|
|
|
#ifndef lint
|
1997-08-07 22:28:25 +00:00
|
|
|
static char sccsid[] = "@(#)ls.c 8.5 (Berkeley) 4/2/94";
|
1994-05-26 06:18:55 +00:00
|
|
|
#endif /* not lint */
|
2002-02-03 20:55:54 +00:00
|
|
|
#endif
|
2002-06-30 05:13:54 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2011-10-18 13:10:46 +00:00
|
|
|
#include <sys/param.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/ioctl.h>
|
2002-10-24 00:07:30 +00:00
|
|
|
#include <sys/mac.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <fts.h>
|
2018-08-17 04:15:51 +00:00
|
|
|
#include <getopt.h>
|
2002-02-19 00:05:59 +00:00
|
|
|
#include <grp.h>
|
2003-05-03 16:39:34 +00:00
|
|
|
#include <inttypes.h>
|
1999-08-19 11:36:12 +00:00
|
|
|
#include <limits.h>
|
|
|
|
#include <locale.h>
|
2002-02-19 00:05:59 +00:00
|
|
|
#include <pwd.h>
|
2018-08-16 01:27:16 +00:00
|
|
|
#include <stdbool.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2000-06-05 19:36:06 +00:00
|
|
|
#include <unistd.h>
|
2000-06-05 02:14:01 +00:00
|
|
|
#ifdef COLORLS
|
2000-06-05 19:36:06 +00:00
|
|
|
#include <termcap.h>
|
|
|
|
#include <signal.h>
|
2000-06-05 02:14:01 +00:00
|
|
|
#endif
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
#include "ls.h"
|
|
|
|
#include "extern.h"
|
|
|
|
|
1999-08-19 11:36:12 +00:00
|
|
|
/*
|
|
|
|
* Upward approximation of the maximum number of characters needed to
|
|
|
|
* represent a value of integral type t as a string, excluding the
|
|
|
|
* NUL terminator, with provision for a sign.
|
|
|
|
*/
|
1999-08-19 13:04:08 +00:00
|
|
|
#define STRBUF_SIZEOF(t) (1 + CHAR_BIT * sizeof(t) / 3 + 1)
|
1999-08-19 11:36:12 +00:00
|
|
|
|
2003-05-03 16:39:34 +00:00
|
|
|
/*
|
2012-11-09 20:19:56 +00:00
|
|
|
* MAKENINES(n) turns n into (10**n)-1. This is useful for converting a width
|
2003-05-03 16:39:34 +00:00
|
|
|
* into a number that wide in decimal.
|
|
|
|
* XXX: Overflows are not considered.
|
|
|
|
*/
|
|
|
|
#define MAKENINES(n) \
|
|
|
|
do { \
|
|
|
|
intmax_t i; \
|
|
|
|
\
|
|
|
|
/* Use a loop as all values of n are small. */ \
|
|
|
|
for (i = 1; n > 0; i *= 10) \
|
|
|
|
n--; \
|
|
|
|
n = i - 1; \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
static void display(const FTSENT *, FTSENT *, int);
|
2002-09-21 01:28:41 +00:00
|
|
|
static int mastercmp(const FTSENT * const *, const FTSENT * const *);
|
2002-02-02 06:48:10 +00:00
|
|
|
static void traverse(int, char **, int);
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2018-08-17 04:15:51 +00:00
|
|
|
#define COLOR_OPT (CHAR_MAX + 1)
|
|
|
|
|
|
|
|
static const struct option long_opts[] =
|
|
|
|
{
|
|
|
|
#ifdef COLORLS
|
|
|
|
{"color", optional_argument, NULL, COLOR_OPT},
|
|
|
|
#endif
|
|
|
|
{NULL, no_argument, NULL, 0}
|
|
|
|
};
|
|
|
|
|
2003-05-03 16:39:34 +00:00
|
|
|
static void (*printfcn)(const DISPLAY *);
|
2002-02-02 06:48:10 +00:00
|
|
|
static int (*sortfcn)(const FTSENT *, const FTSENT *);
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
long blocksize; /* block size units */
|
|
|
|
int termwidth = 80; /* default terminal width */
|
|
|
|
|
|
|
|
/* flags */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_accesstime; /* use time of last access */
|
2006-03-24 16:38:02 +00:00
|
|
|
int f_birthtime; /* use time of birth */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_flags; /* show flags associated with a file */
|
|
|
|
int f_humanval; /* show human-readable file sizes */
|
|
|
|
int f_inode; /* print inode */
|
|
|
|
static int f_kblocks; /* print size in kilobytes */
|
2012-11-08 00:24:26 +00:00
|
|
|
int f_label; /* show MAC label */
|
2002-02-03 19:11:32 +00:00
|
|
|
static int f_listdir; /* list actual directory, not contents */
|
|
|
|
static int f_listdot; /* list files beginning with . */
|
|
|
|
int f_longform; /* long listing format */
|
2012-11-08 00:24:26 +00:00
|
|
|
static int f_noautodot; /* do not automatically enable -A for root */
|
2010-02-08 15:42:55 +00:00
|
|
|
static int f_nofollow; /* don't follow symbolic link arguments */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_nonprint; /* show unprintables as ? */
|
|
|
|
static int f_nosort; /* don't sort output */
|
|
|
|
int f_notabs; /* don't use tab-separated multi-col output */
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
static int f_numericonly; /* don't convert uid/gid to name */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_octal; /* show unprintables as \xxx */
|
|
|
|
int f_octal_escape; /* like f_octal but use C escapes if possible */
|
|
|
|
static int f_recursive; /* ls subdirectories also */
|
|
|
|
static int f_reversesort; /* reverse whatever sort is used */
|
2012-11-08 00:24:26 +00:00
|
|
|
int f_samesort; /* sort time and name in same direction */
|
|
|
|
int f_sectime; /* print full time information */
|
2002-02-03 19:11:32 +00:00
|
|
|
static int f_singlecol; /* use single column output */
|
|
|
|
int f_size; /* list size in short listing */
|
2012-11-08 00:24:26 +00:00
|
|
|
static int f_sizesort;
|
2002-05-19 02:51:36 +00:00
|
|
|
int f_slash; /* similar to f_type, but only for dirs */
|
2008-04-04 03:57:46 +00:00
|
|
|
int f_sortacross; /* sort across rows, not down columns */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_statustime; /* use time of last mode change */
|
2003-05-03 16:39:34 +00:00
|
|
|
static int f_stream; /* stream the output, separate with commas */
|
2012-11-08 00:24:26 +00:00
|
|
|
int f_thousands; /* show file sizes with thousands separators */
|
2012-11-08 23:45:19 +00:00
|
|
|
char *f_timeformat; /* user-specified time format */
|
2012-11-08 00:24:26 +00:00
|
|
|
static int f_timesort; /* sort by time vice name */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_type; /* add type character for non-regular files */
|
|
|
|
static int f_whiteout; /* show whiteout entries */
|
2000-06-05 02:14:01 +00:00
|
|
|
#ifdef COLORLS
|
2020-05-21 03:50:56 +00:00
|
|
|
int colorflag = COLORFLAG_NEVER; /* passed in colorflag */
|
2002-02-03 19:11:32 +00:00
|
|
|
int f_color; /* add type in color for non-regular files */
|
2018-08-17 04:15:51 +00:00
|
|
|
bool explicitansi; /* Explicit ANSI sequences, no termcap(5) */
|
2000-06-05 03:51:29 +00:00
|
|
|
char *ansi_bgcol; /* ANSI sequence to set background colour */
|
|
|
|
char *ansi_fgcol; /* ANSI sequence to set foreground colour */
|
|
|
|
char *ansi_coloff; /* ANSI sequence to reset colours */
|
2001-12-28 18:14:50 +00:00
|
|
|
char *attrs_off; /* ANSI sequence to turn off attributes */
|
|
|
|
char *enter_bold; /* ANSI sequence to set color to bold mode */
|
2000-06-05 02:14:01 +00:00
|
|
|
#endif
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2002-02-03 19:11:32 +00:00
|
|
|
static int rval;
|
1996-08-27 21:51:48 +00:00
|
|
|
|
2018-08-16 01:27:16 +00:00
|
|
|
static bool
|
|
|
|
do_color_from_env(void)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
bool doit;
|
|
|
|
|
|
|
|
doit = false;
|
|
|
|
p = getenv("CLICOLOR");
|
|
|
|
if (p == NULL) {
|
|
|
|
/*
|
|
|
|
* COLORTERM is the more standard name for this variable. We'll
|
|
|
|
* honor it as long as it's both set and not empty.
|
|
|
|
*/
|
|
|
|
p = getenv("COLORTERM");
|
|
|
|
if (p != NULL && *p != '\0')
|
|
|
|
doit = true;
|
|
|
|
} else
|
|
|
|
doit = true;
|
|
|
|
|
|
|
|
return (doit &&
|
|
|
|
(isatty(STDOUT_FILENO) || getenv("CLICOLOR_FORCE")));
|
|
|
|
}
|
|
|
|
|
2018-08-17 04:15:51 +00:00
|
|
|
static bool
|
|
|
|
do_color(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
#ifdef COLORLS
|
|
|
|
if (colorflag == COLORFLAG_NEVER)
|
|
|
|
return (false);
|
|
|
|
else if (colorflag == COLORFLAG_ALWAYS)
|
|
|
|
return (true);
|
|
|
|
#endif
|
|
|
|
return (do_color_from_env());
|
|
|
|
}
|
|
|
|
|
2018-08-18 21:03:19 +00:00
|
|
|
#ifdef COLORLS
|
2018-08-18 20:55:20 +00:00
|
|
|
static bool
|
|
|
|
do_color_always(const char *term)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (strcmp(term, "always") == 0 || strcmp(term, "yes") == 0 ||
|
|
|
|
strcmp(term, "force") == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
do_color_never(const char *term)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (strcmp(term, "never") == 0 || strcmp(term, "no") == 0 ||
|
|
|
|
strcmp(term, "none") == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
do_color_auto(const char *term)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (strcmp(term, "auto") == 0 || strcmp(term, "tty") == 0 ||
|
|
|
|
strcmp(term, "if-tty") == 0);
|
|
|
|
}
|
2018-08-18 21:03:19 +00:00
|
|
|
#endif /* COLORLS */
|
2018-08-18 20:55:20 +00:00
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
int
|
2002-02-02 06:48:10 +00:00
|
|
|
main(int argc, char *argv[])
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
2001-12-29 00:18:16 +00:00
|
|
|
static char dot[] = ".", *dotav[] = {dot, NULL};
|
1994-05-26 06:18:55 +00:00
|
|
|
struct winsize win;
|
|
|
|
int ch, fts_options, notused;
|
|
|
|
char *p;
|
2015-07-13 05:56:27 +00:00
|
|
|
const char *errstr = NULL;
|
2000-06-05 03:51:29 +00:00
|
|
|
#ifdef COLORLS
|
2001-12-29 00:18:16 +00:00
|
|
|
char termcapbuf[1024]; /* termcap definition buffer */
|
|
|
|
char tcapbuf[512]; /* capability buffer */
|
2018-08-17 04:15:51 +00:00
|
|
|
char *bp = tcapbuf, *term;
|
2000-06-05 03:51:29 +00:00
|
|
|
#endif
|
|
|
|
|
2001-12-29 00:18:16 +00:00
|
|
|
(void)setlocale(LC_ALL, "");
|
1995-10-26 10:56:38 +00:00
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
/* Terminal defaults to -Cq, non-terminal defaults to -1. */
|
|
|
|
if (isatty(STDOUT_FILENO)) {
|
2002-06-04 10:11:29 +00:00
|
|
|
termwidth = 80;
|
|
|
|
if ((p = getenv("COLUMNS")) != NULL && *p != '\0')
|
2015-07-13 05:56:27 +00:00
|
|
|
termwidth = strtonum(p, 0, INT_MAX, &errstr);
|
2002-06-04 10:11:29 +00:00
|
|
|
else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != -1 &&
|
|
|
|
win.ws_col > 0)
|
1994-05-26 06:18:55 +00:00
|
|
|
termwidth = win.ws_col;
|
2002-02-03 19:11:32 +00:00
|
|
|
f_nonprint = 1;
|
1994-12-18 19:00:01 +00:00
|
|
|
} else {
|
1994-05-26 06:18:55 +00:00
|
|
|
f_singlecol = 1;
|
1994-12-18 19:00:01 +00:00
|
|
|
/* retrieve environment variable, in case of explicit -C */
|
2002-02-03 19:11:32 +00:00
|
|
|
p = getenv("COLUMNS");
|
|
|
|
if (p)
|
2015-07-13 05:56:27 +00:00
|
|
|
termwidth = strtonum(p, 0, INT_MAX, &errstr);
|
1994-12-18 19:00:01 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2015-07-13 05:56:27 +00:00
|
|
|
if (errstr)
|
|
|
|
termwidth = 80;
|
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
fts_options = FTS_PHYSICAL;
|
2012-11-08 00:24:26 +00:00
|
|
|
if (getenv("LS_SAMESORT"))
|
|
|
|
f_samesort = 1;
|
2020-05-21 14:39:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For historical compatibility, we'll use our autodetection if CLICOLOR
|
|
|
|
* is set.
|
|
|
|
*/
|
2020-05-21 15:15:50 +00:00
|
|
|
#ifdef COLORLS
|
2020-05-21 14:39:00 +00:00
|
|
|
if (getenv("CLICOLOR"))
|
|
|
|
colorflag = COLORFLAG_AUTO;
|
2020-05-21 15:15:50 +00:00
|
|
|
#endif
|
2018-08-17 04:15:51 +00:00
|
|
|
while ((ch = getopt_long(argc, argv,
|
|
|
|
"+1ABCD:FGHILPRSTUWXZabcdfghiklmnopqrstuwxy,", long_opts,
|
|
|
|
NULL)) != -1) {
|
1994-05-26 06:18:55 +00:00
|
|
|
switch (ch) {
|
|
|
|
/*
|
2002-05-19 02:51:36 +00:00
|
|
|
* The -1, -C, -x and -l options all override each other so
|
|
|
|
* shell aliasing works right.
|
1994-05-26 06:18:55 +00:00
|
|
|
*/
|
|
|
|
case '1':
|
|
|
|
f_singlecol = 1;
|
2002-02-03 19:11:32 +00:00
|
|
|
f_longform = 0;
|
2002-05-19 02:51:36 +00:00
|
|
|
f_stream = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case 'C':
|
2002-05-19 02:51:36 +00:00
|
|
|
f_sortacross = f_longform = f_singlecol = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case 'l':
|
|
|
|
f_longform = 1;
|
2002-02-03 19:11:32 +00:00
|
|
|
f_singlecol = 0;
|
2002-05-19 02:51:36 +00:00
|
|
|
f_stream = 0;
|
|
|
|
break;
|
|
|
|
case 'x':
|
|
|
|
f_sortacross = 1;
|
|
|
|
f_longform = 0;
|
|
|
|
f_singlecol = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2006-03-24 16:38:02 +00:00
|
|
|
/* The -c, -u, and -U options override each other. */
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'c':
|
|
|
|
f_statustime = 1;
|
|
|
|
f_accesstime = 0;
|
2006-03-24 16:38:02 +00:00
|
|
|
f_birthtime = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case 'u':
|
|
|
|
f_accesstime = 1;
|
|
|
|
f_statustime = 0;
|
2006-03-24 16:38:02 +00:00
|
|
|
f_birthtime = 0;
|
|
|
|
break;
|
|
|
|
case 'U':
|
|
|
|
f_birthtime = 1;
|
|
|
|
f_accesstime = 0;
|
|
|
|
f_statustime = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2014-04-03 05:48:28 +00:00
|
|
|
case 'f':
|
|
|
|
f_nosort = 1;
|
|
|
|
/* FALLTHROUGH */
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'a':
|
|
|
|
fts_options |= FTS_SEEDOT;
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 'A':
|
|
|
|
f_listdot = 1;
|
|
|
|
break;
|
|
|
|
/* The -t and -S options override each other. */
|
|
|
|
case 'S':
|
|
|
|
f_sizesort = 1;
|
|
|
|
f_timesort = 0;
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
f_timesort = 1;
|
|
|
|
f_sizesort = 0;
|
|
|
|
break;
|
2012-11-09 20:19:56 +00:00
|
|
|
/* Other flags. Please keep alphabetic. */
|
2012-11-08 00:24:26 +00:00
|
|
|
case ',':
|
|
|
|
f_thousands = 1;
|
|
|
|
break;
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'B':
|
|
|
|
f_nonprint = 0;
|
|
|
|
f_octal = 1;
|
|
|
|
f_octal_escape = 0;
|
|
|
|
break;
|
2012-11-08 23:45:19 +00:00
|
|
|
case 'D':
|
|
|
|
f_timeformat = optarg;
|
|
|
|
break;
|
|
|
|
case 'F':
|
1994-05-26 06:18:55 +00:00
|
|
|
f_type = 1;
|
2002-05-19 02:51:36 +00:00
|
|
|
f_slash = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'G':
|
2020-05-21 14:39:00 +00:00
|
|
|
/*
|
|
|
|
* We both set CLICOLOR here and set colorflag to
|
|
|
|
* COLORFLAG_AUTO, because -G should not force color if
|
|
|
|
* stdout isn't a tty.
|
|
|
|
*/
|
2012-11-07 23:37:24 +00:00
|
|
|
setenv("CLICOLOR", "", 1);
|
2020-05-21 15:15:50 +00:00
|
|
|
#ifdef COLORLS
|
2020-05-21 14:39:00 +00:00
|
|
|
colorflag = COLORFLAG_AUTO;
|
2020-05-21 15:15:50 +00:00
|
|
|
#endif
|
2012-11-07 23:37:24 +00:00
|
|
|
break;
|
1998-04-24 12:43:26 +00:00
|
|
|
case 'H':
|
2001-12-29 00:18:16 +00:00
|
|
|
fts_options |= FTS_COMFOLLOW;
|
2010-02-08 15:42:55 +00:00
|
|
|
f_nofollow = 0;
|
1998-04-24 12:43:26 +00:00
|
|
|
break;
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'I':
|
|
|
|
f_noautodot = 1;
|
2000-06-02 14:53:42 +00:00
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'L':
|
|
|
|
fts_options &= ~FTS_PHYSICAL;
|
|
|
|
fts_options |= FTS_LOGICAL;
|
2010-02-08 15:42:55 +00:00
|
|
|
f_nofollow = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
1998-04-24 12:43:26 +00:00
|
|
|
case 'P':
|
2001-12-29 00:18:16 +00:00
|
|
|
fts_options &= ~FTS_COMFOLLOW;
|
1998-04-24 12:43:26 +00:00
|
|
|
fts_options &= ~FTS_LOGICAL;
|
|
|
|
fts_options |= FTS_PHYSICAL;
|
2010-02-08 15:42:55 +00:00
|
|
|
f_nofollow = 1;
|
1998-04-24 12:43:26 +00:00
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'R':
|
|
|
|
f_recursive = 1;
|
|
|
|
break;
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'T':
|
|
|
|
f_sectime = 1;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2012-11-07 23:37:24 +00:00
|
|
|
case 'W':
|
|
|
|
f_whiteout = 1;
|
|
|
|
break;
|
|
|
|
case 'Z':
|
|
|
|
f_label = 1;
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
f_nonprint = 0;
|
|
|
|
f_octal = 0;
|
|
|
|
f_octal_escape = 1;
|
2005-11-10 00:02:32 +00:00
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
/* The -d option turns off the -R option. */
|
|
|
|
case 'd':
|
|
|
|
f_listdir = 1;
|
|
|
|
f_recursive = 0;
|
|
|
|
break;
|
2001-12-29 00:18:16 +00:00
|
|
|
case 'g': /* Compatibility with 4.3BSD. */
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2001-12-28 20:50:12 +00:00
|
|
|
case 'h':
|
|
|
|
f_humanval = 1;
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'i':
|
|
|
|
f_inode = 1;
|
|
|
|
break;
|
1994-09-19 07:49:56 +00:00
|
|
|
case 'k':
|
2003-12-01 19:10:29 +00:00
|
|
|
f_humanval = 0;
|
1994-09-19 07:49:56 +00:00
|
|
|
f_kblocks = 1;
|
|
|
|
break;
|
2002-05-19 02:51:36 +00:00
|
|
|
case 'm':
|
|
|
|
f_stream = 1;
|
|
|
|
f_singlecol = 0;
|
|
|
|
f_longform = 0;
|
|
|
|
break;
|
1999-08-02 14:55:58 +00:00
|
|
|
case 'n':
|
|
|
|
f_numericonly = 1;
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'o':
|
|
|
|
f_flags = 1;
|
|
|
|
break;
|
2002-05-19 02:51:36 +00:00
|
|
|
case 'p':
|
|
|
|
f_slash = 1;
|
|
|
|
f_type = 1;
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'q':
|
|
|
|
f_nonprint = 1;
|
1998-04-21 22:02:01 +00:00
|
|
|
f_octal = 0;
|
2001-12-29 00:18:16 +00:00
|
|
|
f_octal_escape = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
f_reversesort = 1;
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
f_size = 1;
|
|
|
|
break;
|
2001-12-29 00:22:29 +00:00
|
|
|
case 'w':
|
|
|
|
f_nonprint = 0;
|
|
|
|
f_octal = 0;
|
|
|
|
f_octal_escape = 0;
|
|
|
|
break;
|
2012-11-08 00:24:26 +00:00
|
|
|
case 'y':
|
|
|
|
f_samesort = 1;
|
|
|
|
break;
|
2018-08-17 04:15:51 +00:00
|
|
|
#ifdef COLORLS
|
|
|
|
case COLOR_OPT:
|
2018-08-18 20:55:20 +00:00
|
|
|
if (optarg == NULL || do_color_always(optarg))
|
2018-08-17 04:15:51 +00:00
|
|
|
colorflag = COLORFLAG_ALWAYS;
|
2018-08-18 20:55:20 +00:00
|
|
|
else if (do_color_auto(optarg))
|
2018-08-17 04:15:51 +00:00
|
|
|
colorflag = COLORFLAG_AUTO;
|
2018-08-18 20:55:20 +00:00
|
|
|
else if (do_color_never(optarg))
|
2018-08-17 04:15:51 +00:00
|
|
|
colorflag = COLORFLAG_NEVER;
|
|
|
|
else
|
|
|
|
errx(2, "unsupported --color value '%s' (must be always, auto, or never)",
|
|
|
|
optarg);
|
|
|
|
break;
|
|
|
|
#endif
|
1994-05-26 06:18:55 +00:00
|
|
|
default:
|
|
|
|
case '?':
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
2005-11-16 07:13:37 +00:00
|
|
|
/* Root is -A automatically unless -I. */
|
|
|
|
if (!f_listdot && getuid() == (uid_t)0 && !f_noautodot)
|
2005-11-10 00:02:32 +00:00
|
|
|
f_listdot = 1;
|
|
|
|
|
2018-08-17 04:15:51 +00:00
|
|
|
/*
|
|
|
|
* Enabling of colours is conditional on the environment in conjunction
|
|
|
|
* with the --color and -G arguments, if supplied.
|
|
|
|
*/
|
|
|
|
if (do_color()) {
|
2000-08-13 12:17:03 +00:00
|
|
|
#ifdef COLORLS
|
2018-08-17 04:15:51 +00:00
|
|
|
if ((term = getenv("TERM")) != NULL &&
|
|
|
|
tgetent(termcapbuf, term) == 1) {
|
2000-08-12 22:40:14 +00:00
|
|
|
ansi_fgcol = tgetstr("AF", &bp);
|
|
|
|
ansi_bgcol = tgetstr("AB", &bp);
|
2001-12-28 18:14:50 +00:00
|
|
|
attrs_off = tgetstr("me", &bp);
|
|
|
|
enter_bold = tgetstr("md", &bp);
|
2000-08-12 22:40:14 +00:00
|
|
|
|
|
|
|
/* To switch colours off use 'op' if
|
|
|
|
* available, otherwise use 'oc', or
|
|
|
|
* don't do colours at all. */
|
|
|
|
ansi_coloff = tgetstr("op", &bp);
|
|
|
|
if (!ansi_coloff)
|
|
|
|
ansi_coloff = tgetstr("oc", &bp);
|
|
|
|
if (ansi_fgcol && ansi_bgcol && ansi_coloff)
|
|
|
|
f_color = 1;
|
2018-08-17 04:15:51 +00:00
|
|
|
} else if (colorflag == COLORFLAG_ALWAYS) {
|
|
|
|
/*
|
|
|
|
* If we're *always* doing color but we don't have
|
|
|
|
* a functional TERM supplied, we'll fallback to
|
|
|
|
* outputting raw ANSI sequences.
|
|
|
|
*/
|
|
|
|
f_color = 1;
|
|
|
|
explicitansi = true;
|
2000-08-12 22:40:14 +00:00
|
|
|
}
|
2000-08-13 12:17:03 +00:00
|
|
|
#else
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warnx("color support not compiled in");
|
2000-08-13 12:17:03 +00:00
|
|
|
#endif /*COLORLS*/
|
2018-08-17 04:15:51 +00:00
|
|
|
}
|
2000-08-12 22:40:14 +00:00
|
|
|
|
2000-08-13 12:17:03 +00:00
|
|
|
#ifdef COLORLS
|
2000-06-05 19:36:06 +00:00
|
|
|
if (f_color) {
|
2000-06-06 12:44:29 +00:00
|
|
|
/*
|
|
|
|
* We can't put tabs and color sequences together:
|
|
|
|
* column number will be incremented incorrectly
|
|
|
|
* for "stty oxtabs" mode.
|
|
|
|
*/
|
|
|
|
f_notabs = 1;
|
2001-12-29 00:18:16 +00:00
|
|
|
(void)signal(SIGINT, colorquit);
|
|
|
|
(void)signal(SIGQUIT, colorquit);
|
2000-06-02 14:53:42 +00:00
|
|
|
parsecolors(getenv("LSCOLORS"));
|
2000-06-05 19:36:06 +00:00
|
|
|
}
|
2000-06-05 02:14:01 +00:00
|
|
|
#endif
|
2000-06-02 14:53:42 +00:00
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
/*
|
2005-06-03 11:05:58 +00:00
|
|
|
* If not -F, -i, -l, -s, -S or -t options, don't require stat
|
2000-06-02 14:53:42 +00:00
|
|
|
* information, unless in color mode in which case we do
|
|
|
|
* need this to determine which colors to display.
|
1994-05-26 06:18:55 +00:00
|
|
|
*/
|
2005-06-03 11:05:58 +00:00
|
|
|
if (!f_inode && !f_longform && !f_size && !f_timesort &&
|
|
|
|
!f_sizesort && !f_type
|
2000-06-05 02:14:01 +00:00
|
|
|
#ifdef COLORLS
|
|
|
|
&& !f_color
|
|
|
|
#endif
|
2001-12-29 00:18:16 +00:00
|
|
|
)
|
1994-05-26 06:18:55 +00:00
|
|
|
fts_options |= FTS_NOSTAT;
|
|
|
|
|
|
|
|
/*
|
2010-02-08 15:42:55 +00:00
|
|
|
* If not -F, -P, -d or -l options, follow any symbolic links listed on
|
2015-06-08 19:13:04 +00:00
|
|
|
* the command line, unless in color mode in which case we need to
|
|
|
|
* distinguish file type for a symbolic link itself and its target.
|
1994-05-26 06:18:55 +00:00
|
|
|
*/
|
2015-06-08 19:13:04 +00:00
|
|
|
if (!f_nofollow && !f_longform && !f_listdir && (!f_type || f_slash)
|
|
|
|
#ifdef COLORLS
|
|
|
|
&& !f_color
|
|
|
|
#endif
|
|
|
|
)
|
1994-05-26 06:18:55 +00:00
|
|
|
fts_options |= FTS_COMFOLLOW;
|
|
|
|
|
1996-12-14 06:03:29 +00:00
|
|
|
/*
|
|
|
|
* If -W, show whiteout entries
|
|
|
|
*/
|
|
|
|
#ifdef FTS_WHITEOUT
|
|
|
|
if (f_whiteout)
|
|
|
|
fts_options |= FTS_WHITEOUT;
|
|
|
|
#endif
|
|
|
|
|
2011-10-19 15:35:41 +00:00
|
|
|
/* If -i, -l or -s, figure out block size. */
|
|
|
|
if (f_inode || f_longform || f_size) {
|
1994-09-19 07:49:56 +00:00
|
|
|
if (f_kblocks)
|
1995-03-23 19:05:00 +00:00
|
|
|
blocksize = 2;
|
|
|
|
else {
|
|
|
|
(void)getbsize(¬used, &blocksize);
|
|
|
|
blocksize /= 512;
|
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
/* Select a sort function. */
|
|
|
|
if (f_reversesort) {
|
2005-06-03 11:05:58 +00:00
|
|
|
if (!f_timesort && !f_sizesort)
|
1994-05-26 06:18:55 +00:00
|
|
|
sortfcn = revnamecmp;
|
2006-03-24 16:47:22 +00:00
|
|
|
else if (f_sizesort)
|
|
|
|
sortfcn = revsizecmp;
|
1994-05-26 06:18:55 +00:00
|
|
|
else if (f_accesstime)
|
|
|
|
sortfcn = revacccmp;
|
2006-03-24 16:38:02 +00:00
|
|
|
else if (f_birthtime)
|
|
|
|
sortfcn = revbirthcmp;
|
1994-05-26 06:18:55 +00:00
|
|
|
else if (f_statustime)
|
|
|
|
sortfcn = revstatcmp;
|
2001-12-29 00:18:16 +00:00
|
|
|
else /* Use modification time. */
|
1994-05-26 06:18:55 +00:00
|
|
|
sortfcn = revmodcmp;
|
|
|
|
} else {
|
2005-06-03 11:05:58 +00:00
|
|
|
if (!f_timesort && !f_sizesort)
|
1994-05-26 06:18:55 +00:00
|
|
|
sortfcn = namecmp;
|
2006-03-24 16:47:22 +00:00
|
|
|
else if (f_sizesort)
|
|
|
|
sortfcn = sizecmp;
|
1994-05-26 06:18:55 +00:00
|
|
|
else if (f_accesstime)
|
|
|
|
sortfcn = acccmp;
|
2006-03-24 16:38:02 +00:00
|
|
|
else if (f_birthtime)
|
|
|
|
sortfcn = birthcmp;
|
1994-05-26 06:18:55 +00:00
|
|
|
else if (f_statustime)
|
|
|
|
sortfcn = statcmp;
|
2001-12-29 00:18:16 +00:00
|
|
|
else /* Use modification time. */
|
1994-05-26 06:18:55 +00:00
|
|
|
sortfcn = modcmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Select a print function. */
|
|
|
|
if (f_singlecol)
|
|
|
|
printfcn = printscol;
|
|
|
|
else if (f_longform)
|
|
|
|
printfcn = printlong;
|
2002-05-19 02:51:36 +00:00
|
|
|
else if (f_stream)
|
|
|
|
printfcn = printstream;
|
1994-05-26 06:18:55 +00:00
|
|
|
else
|
|
|
|
printfcn = printcol;
|
|
|
|
|
|
|
|
if (argc)
|
|
|
|
traverse(argc, argv, fts_options);
|
|
|
|
else
|
|
|
|
traverse(1, dotav, fts_options);
|
1996-08-27 21:51:48 +00:00
|
|
|
exit(rval);
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
|
2001-12-29 00:18:16 +00:00
|
|
|
static int output; /* If anything output. */
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Traverse() walks the logical directory structure specified by the argv list
|
|
|
|
* in the order specified by the mastercmp() comparison function. During the
|
|
|
|
* traversal it passes linked lists of structures to display() which represent
|
|
|
|
* a superset (may be exact set) of the files to be displayed.
|
|
|
|
*/
|
|
|
|
static void
|
2002-02-02 06:48:10 +00:00
|
|
|
traverse(int argc, char *argv[], int options)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
|
|
|
FTS *ftsp;
|
|
|
|
FTSENT *p, *chp;
|
|
|
|
int ch_options;
|
|
|
|
|
|
|
|
if ((ftsp =
|
|
|
|
fts_open(argv, options, f_nosort ? NULL : mastercmp)) == NULL)
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
err(1, "fts_open");
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2004-06-08 09:30:10 +00:00
|
|
|
/*
|
|
|
|
* We ignore errors from fts_children here since they will be
|
|
|
|
* replicated and signalled on the next call to fts_read() below.
|
|
|
|
*/
|
|
|
|
chp = fts_children(ftsp, 0);
|
|
|
|
if (chp != NULL)
|
|
|
|
display(NULL, chp, options);
|
1994-05-26 06:18:55 +00:00
|
|
|
if (f_listdir)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If not recursing down this tree and don't need stat info, just get
|
|
|
|
* the names.
|
|
|
|
*/
|
2002-12-18 21:05:15 +00:00
|
|
|
ch_options = !f_recursive && !f_label &&
|
|
|
|
options & FTS_NOSTAT ? FTS_NAMEONLY : 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
while ((p = fts_read(ftsp)) != NULL)
|
|
|
|
switch (p->fts_info) {
|
|
|
|
case FTS_DC:
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warnx("%s: directory causes a cycle", p->fts_name);
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case FTS_DNR:
|
|
|
|
case FTS_ERR:
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warnx("%s: %s", p->fts_path, strerror(p->fts_errno));
|
1996-08-27 21:51:48 +00:00
|
|
|
rval = 1;
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
case FTS_D:
|
|
|
|
if (p->fts_level != FTS_ROOTLEVEL &&
|
2005-11-16 07:13:37 +00:00
|
|
|
p->fts_name[0] == '.' && !f_listdot)
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If already output something, put out a newline as
|
2012-11-09 20:19:56 +00:00
|
|
|
* a separator. If multiple arguments, precede each
|
1994-05-26 06:18:55 +00:00
|
|
|
* directory with its name.
|
|
|
|
*/
|
2002-10-18 10:59:45 +00:00
|
|
|
if (output) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
putchar('\n');
|
|
|
|
(void)printname(p->fts_path);
|
|
|
|
puts(":");
|
2002-10-18 10:59:45 +00:00
|
|
|
} else if (argc > 1) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
(void)printname(p->fts_path);
|
|
|
|
puts(":");
|
1994-05-26 06:18:55 +00:00
|
|
|
output = 1;
|
|
|
|
}
|
|
|
|
chp = fts_children(ftsp, ch_options);
|
2002-10-24 00:07:30 +00:00
|
|
|
display(p, chp, options);
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
if (!f_recursive && chp != NULL)
|
|
|
|
(void)fts_set(ftsp, p, FTS_SKIP);
|
|
|
|
break;
|
2002-05-15 18:53:56 +00:00
|
|
|
default:
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
if (errno)
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
err(1, "fts_read");
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Display() takes a linked list of FTSENT structures and passes the list
|
|
|
|
* along with any other necessary information to the print function. P
|
|
|
|
* points to the parent directory of the display list.
|
|
|
|
*/
|
|
|
|
static void
|
2003-05-03 16:39:34 +00:00
|
|
|
display(const FTSENT *p, FTSENT *list, int options)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
|
|
|
struct stat *sp;
|
|
|
|
DISPLAY d;
|
|
|
|
FTSENT *cur;
|
|
|
|
NAMES *np;
|
2002-02-03 19:11:32 +00:00
|
|
|
off_t maxsize;
|
2003-05-03 16:39:34 +00:00
|
|
|
long maxblock;
|
2012-09-27 23:31:12 +00:00
|
|
|
uintmax_t maxinode;
|
|
|
|
u_long btotal, labelstrlen, maxlen, maxnlink;
|
2002-10-24 00:07:30 +00:00
|
|
|
u_long maxlabelstr;
|
2011-09-28 18:53:36 +00:00
|
|
|
u_int sizelen;
|
2010-01-24 19:23:07 +00:00
|
|
|
int maxflags;
|
2002-02-03 19:11:32 +00:00
|
|
|
gid_t maxgroup;
|
|
|
|
uid_t maxuser;
|
|
|
|
size_t flen, ulen, glen;
|
1998-07-29 00:46:13 +00:00
|
|
|
char *initmax;
|
1994-05-26 06:18:55 +00:00
|
|
|
int entries, needstats;
|
2002-05-15 09:49:59 +00:00
|
|
|
const char *user, *group;
|
2002-10-24 00:07:30 +00:00
|
|
|
char *flags, *labelstr = NULL;
|
1999-08-19 11:36:12 +00:00
|
|
|
char ngroup[STRBUF_SIZEOF(uid_t) + 1];
|
|
|
|
char nuser[STRBUF_SIZEOF(gid_t) + 1];
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
needstats = f_inode || f_longform || f_size;
|
|
|
|
flen = 0;
|
1998-07-29 00:46:13 +00:00
|
|
|
btotal = 0;
|
|
|
|
initmax = getenv("LS_COLWIDTHS");
|
|
|
|
/* Fields match -lios order. New ones should be added at the end. */
|
2012-09-27 23:31:12 +00:00
|
|
|
maxlabelstr = maxblock = maxlen = maxnlink = 0;
|
|
|
|
maxuser = maxgroup = maxflags = maxsize = 0;
|
|
|
|
maxinode = 0;
|
1998-07-29 00:46:13 +00:00
|
|
|
if (initmax != NULL && *initmax != '\0') {
|
|
|
|
char *initmax2, *jinitmax;
|
|
|
|
int ninitmax;
|
|
|
|
|
|
|
|
/* Fill-in "::" as "0:0:0" for the sake of scanf. */
|
2003-05-03 16:39:34 +00:00
|
|
|
jinitmax = malloc(strlen(initmax) * 2 + 2);
|
1998-07-29 00:46:13 +00:00
|
|
|
if (jinitmax == NULL)
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
err(1, "malloc");
|
2003-05-03 16:39:34 +00:00
|
|
|
initmax2 = jinitmax;
|
1998-07-29 00:46:13 +00:00
|
|
|
if (*initmax == ':')
|
|
|
|
strcpy(initmax2, "0:"), initmax2 += 2;
|
|
|
|
else
|
|
|
|
*initmax2++ = *initmax, *initmax2 = '\0';
|
|
|
|
for (initmax++; *initmax != '\0'; initmax++) {
|
|
|
|
if (initmax[-1] == ':' && initmax[0] == ':') {
|
|
|
|
*initmax2++ = '0';
|
|
|
|
*initmax2++ = initmax[0];
|
|
|
|
initmax2[1] = '\0';
|
|
|
|
} else {
|
|
|
|
*initmax2++ = initmax[0];
|
|
|
|
initmax2[1] = '\0';
|
|
|
|
}
|
|
|
|
}
|
2001-12-29 00:18:16 +00:00
|
|
|
if (initmax2[-1] == ':')
|
|
|
|
strcpy(initmax2, "0");
|
1998-07-29 00:46:13 +00:00
|
|
|
|
|
|
|
ninitmax = sscanf(jinitmax,
|
2012-09-27 23:31:12 +00:00
|
|
|
" %ju : %ld : %lu : %u : %u : %i : %jd : %lu : %lu ",
|
1998-07-29 00:46:13 +00:00
|
|
|
&maxinode, &maxblock, &maxnlink, &maxuser,
|
2002-10-24 00:07:30 +00:00
|
|
|
&maxgroup, &maxflags, &maxsize, &maxlen, &maxlabelstr);
|
1998-07-29 00:46:13 +00:00
|
|
|
f_notabs = 1;
|
|
|
|
switch (ninitmax) {
|
2001-12-29 00:18:16 +00:00
|
|
|
case 0:
|
|
|
|
maxinode = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 1:
|
|
|
|
maxblock = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 2:
|
|
|
|
maxnlink = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 3:
|
|
|
|
maxuser = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 4:
|
|
|
|
maxgroup = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 5:
|
|
|
|
maxflags = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 6:
|
|
|
|
maxsize = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 7:
|
|
|
|
maxlen = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2001-12-29 00:18:16 +00:00
|
|
|
case 8:
|
2002-10-24 00:07:30 +00:00
|
|
|
maxlabelstr = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2000-06-06 13:02:52 +00:00
|
|
|
#ifdef COLORLS
|
2001-12-29 00:18:16 +00:00
|
|
|
if (!f_color)
|
2000-06-06 12:44:29 +00:00
|
|
|
#endif
|
2001-12-29 00:18:16 +00:00
|
|
|
f_notabs = 0;
|
2002-08-25 13:01:47 +00:00
|
|
|
/* FALLTHROUGH */
|
2002-02-03 19:11:32 +00:00
|
|
|
default:
|
2002-05-15 18:53:56 +00:00
|
|
|
break;
|
1998-07-29 00:46:13 +00:00
|
|
|
}
|
2003-05-03 16:39:34 +00:00
|
|
|
MAKENINES(maxinode);
|
|
|
|
MAKENINES(maxblock);
|
|
|
|
MAKENINES(maxnlink);
|
|
|
|
MAKENINES(maxsize);
|
2004-06-03 15:04:00 +00:00
|
|
|
free(jinitmax);
|
2002-02-03 19:11:32 +00:00
|
|
|
}
|
2011-09-28 18:53:36 +00:00
|
|
|
d.s_size = 0;
|
|
|
|
sizelen = 0;
|
1995-03-19 13:29:28 +00:00
|
|
|
flags = NULL;
|
1994-05-26 06:18:55 +00:00
|
|
|
for (cur = list, entries = 0; cur; cur = cur->fts_link) {
|
|
|
|
if (cur->fts_info == FTS_ERR || cur->fts_info == FTS_NS) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warnx("%s: %s",
|
1994-05-26 06:18:55 +00:00
|
|
|
cur->fts_name, strerror(cur->fts_errno));
|
|
|
|
cur->fts_number = NO_PRINT;
|
1996-08-27 21:51:48 +00:00
|
|
|
rval = 1;
|
1994-05-26 06:18:55 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* P is NULL if list is the argv list, to which different rules
|
|
|
|
* apply.
|
|
|
|
*/
|
|
|
|
if (p == NULL) {
|
|
|
|
/* Directories will be displayed later. */
|
|
|
|
if (cur->fts_info == FTS_D && !f_listdir) {
|
|
|
|
cur->fts_number = NO_PRINT;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Only display dot file if -a/-A set. */
|
2005-11-16 07:13:37 +00:00
|
|
|
if (cur->fts_name[0] == '.' && !f_listdot) {
|
1994-05-26 06:18:55 +00:00
|
|
|
cur->fts_number = NO_PRINT;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (cur->fts_namelen > maxlen)
|
|
|
|
maxlen = cur->fts_namelen;
|
1998-04-24 07:49:51 +00:00
|
|
|
if (f_octal || f_octal_escape) {
|
2001-12-29 00:18:16 +00:00
|
|
|
u_long t = len_octal(cur->fts_name, cur->fts_namelen);
|
|
|
|
|
|
|
|
if (t > maxlen)
|
|
|
|
maxlen = t;
|
1998-07-29 00:46:13 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
if (needstats) {
|
|
|
|
sp = cur->fts_statp;
|
|
|
|
if (sp->st_blocks > maxblock)
|
|
|
|
maxblock = sp->st_blocks;
|
|
|
|
if (sp->st_ino > maxinode)
|
|
|
|
maxinode = sp->st_ino;
|
|
|
|
if (sp->st_nlink > maxnlink)
|
|
|
|
maxnlink = sp->st_nlink;
|
|
|
|
if (sp->st_size > maxsize)
|
|
|
|
maxsize = sp->st_size;
|
|
|
|
|
|
|
|
btotal += sp->st_blocks;
|
|
|
|
if (f_longform) {
|
1999-08-02 14:55:58 +00:00
|
|
|
if (f_numericonly) {
|
|
|
|
(void)snprintf(nuser, sizeof(nuser),
|
|
|
|
"%u", sp->st_uid);
|
|
|
|
(void)snprintf(ngroup, sizeof(ngroup),
|
|
|
|
"%u", sp->st_gid);
|
|
|
|
user = nuser;
|
|
|
|
group = ngroup;
|
|
|
|
} else {
|
|
|
|
user = user_from_uid(sp->st_uid, 0);
|
2020-05-05 18:06:32 +00:00
|
|
|
/*
|
|
|
|
* user_from_uid(..., 0) only returns
|
|
|
|
* NULL in OOM conditions. We could
|
|
|
|
* format the uid here, but (1) in
|
|
|
|
* general ls(1) exits on OOM, and (2)
|
|
|
|
* there is another allocation/exit
|
|
|
|
* path directly below, which will
|
|
|
|
* likely exit anyway.
|
|
|
|
*/
|
|
|
|
if (user == NULL)
|
|
|
|
err(1, "user_from_uid");
|
1999-08-02 14:55:58 +00:00
|
|
|
group = group_from_gid(sp->st_gid, 0);
|
2020-05-05 18:06:32 +00:00
|
|
|
/* Ditto. */
|
|
|
|
if (group == NULL)
|
|
|
|
err(1, "group_from_gid");
|
1999-08-02 14:55:58 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
if ((ulen = strlen(user)) > maxuser)
|
|
|
|
maxuser = ulen;
|
|
|
|
if ((glen = strlen(group)) > maxgroup)
|
|
|
|
maxgroup = glen;
|
|
|
|
if (f_flags) {
|
2000-06-17 14:19:33 +00:00
|
|
|
flags = fflagstostr(sp->st_flags);
|
|
|
|
if (flags != NULL && *flags == '\0') {
|
|
|
|
free(flags);
|
|
|
|
flags = strdup("-");
|
|
|
|
}
|
|
|
|
if (flags == NULL)
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
err(1, "fflagstostr");
|
2002-02-03 19:11:32 +00:00
|
|
|
flen = strlen(flags);
|
|
|
|
if (flen > (size_t)maxflags)
|
1994-05-26 06:18:55 +00:00
|
|
|
maxflags = flen;
|
|
|
|
} else
|
|
|
|
flen = 0;
|
2002-10-24 00:07:30 +00:00
|
|
|
labelstr = NULL;
|
|
|
|
if (f_label) {
|
2002-10-24 01:01:53 +00:00
|
|
|
char name[PATH_MAX + 1];
|
2002-10-24 00:07:30 +00:00
|
|
|
mac_t label;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = mac_prepare_file_label(&label);
|
|
|
|
if (error == -1) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warn("MAC label for %s/%s",
|
2002-12-18 21:05:15 +00:00
|
|
|
cur->fts_parent->fts_path,
|
|
|
|
cur->fts_name);
|
2002-10-24 00:07:30 +00:00
|
|
|
goto label_out;
|
|
|
|
}
|
|
|
|
|
2002-10-24 01:01:53 +00:00
|
|
|
if (cur->fts_level == FTS_ROOTLEVEL)
|
|
|
|
snprintf(name, sizeof(name),
|
|
|
|
"%s", cur->fts_name);
|
|
|
|
else
|
|
|
|
snprintf(name, sizeof(name),
|
2002-12-18 21:05:15 +00:00
|
|
|
"%s/%s", cur->fts_parent->
|
|
|
|
fts_accpath, cur->fts_name);
|
2002-10-24 01:01:53 +00:00
|
|
|
|
2002-10-24 00:07:30 +00:00
|
|
|
if (options & FTS_LOGICAL)
|
2002-10-24 01:01:53 +00:00
|
|
|
error = mac_get_file(name,
|
|
|
|
label);
|
2002-10-24 00:07:30 +00:00
|
|
|
else
|
2002-10-24 01:01:53 +00:00
|
|
|
error = mac_get_link(name,
|
|
|
|
label);
|
2002-10-24 00:07:30 +00:00
|
|
|
if (error == -1) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warn("MAC label for %s/%s",
|
2002-12-18 21:05:15 +00:00
|
|
|
cur->fts_parent->fts_path,
|
|
|
|
cur->fts_name);
|
2002-10-24 00:07:30 +00:00
|
|
|
mac_free(label);
|
|
|
|
goto label_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = mac_to_text(label,
|
|
|
|
&labelstr);
|
|
|
|
if (error == -1) {
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
warn("MAC label for %s/%s",
|
2002-12-18 21:05:15 +00:00
|
|
|
cur->fts_parent->fts_path,
|
|
|
|
cur->fts_name);
|
2002-10-24 00:07:30 +00:00
|
|
|
mac_free(label);
|
|
|
|
goto label_out;
|
|
|
|
}
|
|
|
|
mac_free(label);
|
|
|
|
label_out:
|
|
|
|
if (labelstr == NULL)
|
2003-04-26 02:31:26 +00:00
|
|
|
labelstr = strdup("-");
|
2002-10-24 00:07:30 +00:00
|
|
|
labelstrlen = strlen(labelstr);
|
|
|
|
if (labelstrlen > maxlabelstr)
|
|
|
|
maxlabelstr = labelstrlen;
|
2001-11-26 22:21:15 +00:00
|
|
|
} else
|
2002-10-24 00:07:30 +00:00
|
|
|
labelstrlen = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
|
2002-10-24 00:07:30 +00:00
|
|
|
if ((np = malloc(sizeof(NAMES) + labelstrlen +
|
2001-11-26 22:21:15 +00:00
|
|
|
ulen + glen + flen + 4)) == NULL)
|
Convert ls(1) to not use libxo(3)
libxo imposes a large burden on system utilities. In the case of ls, that
burden is difficult to justify -- any language that can interact with json
output can use readdir(3) and stat(2).
Logically, this reverts r291607, r285857, r285803, r285734, r285425,
r284494, r284489, r284252, and r284198.
Kyua tests continue to pass (libxo integration was entirely untested).
Reported by: many
Reviewed by: imp
Discussed with: manu, bdrewery
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D13959
2018-01-17 22:47:34 +00:00
|
|
|
err(1, "malloc");
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
np->user = &np->data[0];
|
|
|
|
(void)strcpy(np->user, user);
|
|
|
|
np->group = &np->data[ulen + 1];
|
|
|
|
(void)strcpy(np->group, group);
|
|
|
|
|
2011-09-28 18:53:36 +00:00
|
|
|
if (S_ISCHR(sp->st_mode) ||
|
|
|
|
S_ISBLK(sp->st_mode)) {
|
|
|
|
sizelen = snprintf(NULL, 0,
|
|
|
|
"%#jx", (uintmax_t)sp->st_rdev);
|
|
|
|
if (d.s_size < sizelen)
|
|
|
|
d.s_size = sizelen;
|
2010-01-24 19:23:07 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
if (f_flags) {
|
|
|
|
np->flags = &np->data[ulen + glen + 2];
|
2001-12-29 00:18:16 +00:00
|
|
|
(void)strcpy(np->flags, flags);
|
2000-06-17 14:19:33 +00:00
|
|
|
free(flags);
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
2002-10-24 00:07:30 +00:00
|
|
|
if (f_label) {
|
|
|
|
np->label = &np->data[ulen + glen + 2
|
2001-11-26 22:21:15 +00:00
|
|
|
+ (f_flags ? flen + 1 : 0)];
|
2002-10-24 00:07:30 +00:00
|
|
|
(void)strcpy(np->label, labelstr);
|
|
|
|
free(labelstr);
|
2001-11-26 22:21:15 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
cur->fts_pointer = np;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
++entries;
|
|
|
|
}
|
|
|
|
|
2004-06-08 09:30:10 +00:00
|
|
|
/*
|
|
|
|
* If there are no entries to display, we normally stop right
|
|
|
|
* here. However, we must continue if we have to display the
|
|
|
|
* total block count. In this case, we display the total only
|
|
|
|
* on the second (p != NULL) pass.
|
|
|
|
*/
|
|
|
|
if (!entries && (!(f_longform || f_size) || p == NULL))
|
1994-05-26 06:18:55 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
d.list = list;
|
|
|
|
d.entries = entries;
|
|
|
|
d.maxlen = maxlen;
|
|
|
|
if (needstats) {
|
|
|
|
d.btotal = btotal;
|
2011-10-18 13:10:46 +00:00
|
|
|
d.s_block = snprintf(NULL, 0, "%lu", howmany(maxblock, blocksize));
|
1994-05-26 06:18:55 +00:00
|
|
|
d.s_flags = maxflags;
|
2002-10-24 00:07:30 +00:00
|
|
|
d.s_label = maxlabelstr;
|
1994-05-26 06:18:55 +00:00
|
|
|
d.s_group = maxgroup;
|
2012-09-27 23:31:12 +00:00
|
|
|
d.s_inode = snprintf(NULL, 0, "%ju", maxinode);
|
2011-09-28 18:53:36 +00:00
|
|
|
d.s_nlink = snprintf(NULL, 0, "%lu", maxnlink);
|
|
|
|
sizelen = f_humanval ? HUMANVALSTR_LEN :
|
|
|
|
snprintf(NULL, 0, "%ju", maxsize);
|
|
|
|
if (d.s_size < sizelen)
|
|
|
|
d.s_size = sizelen;
|
1994-05-26 06:18:55 +00:00
|
|
|
d.s_user = maxuser;
|
|
|
|
}
|
2012-11-08 23:45:19 +00:00
|
|
|
if (f_thousands) /* make space for commas */
|
2012-11-08 00:24:26 +00:00
|
|
|
d.s_size += (d.s_size - 1) / 3;
|
1994-05-26 06:18:55 +00:00
|
|
|
printfcn(&d);
|
|
|
|
output = 1;
|
|
|
|
|
|
|
|
if (f_longform)
|
|
|
|
for (cur = list; cur; cur = cur->fts_link)
|
|
|
|
free(cur->fts_pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ordering for mastercmp:
|
|
|
|
* If ordering the argv (fts_level = FTS_ROOTLEVEL) return non-directories
|
2012-11-09 20:19:56 +00:00
|
|
|
* as larger than directories. Within either group, use the sort function.
|
1994-05-26 06:18:55 +00:00
|
|
|
* All other levels use the sort function. Error entries remain unsorted.
|
|
|
|
*/
|
|
|
|
static int
|
2002-09-21 01:28:41 +00:00
|
|
|
mastercmp(const FTSENT * const *a, const FTSENT * const *b)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
|
|
|
int a_info, b_info;
|
|
|
|
|
|
|
|
a_info = (*a)->fts_info;
|
|
|
|
if (a_info == FTS_ERR)
|
|
|
|
return (0);
|
|
|
|
b_info = (*b)->fts_info;
|
|
|
|
if (b_info == FTS_ERR)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
if (a_info == FTS_NS || b_info == FTS_NS)
|
|
|
|
return (namecmp(*a, *b));
|
|
|
|
|
1997-09-18 06:42:27 +00:00
|
|
|
if (a_info != b_info &&
|
|
|
|
(*a)->fts_level == FTS_ROOTLEVEL && !f_listdir) {
|
1994-05-26 06:18:55 +00:00
|
|
|
if (a_info == FTS_D)
|
|
|
|
return (1);
|
1997-09-18 06:42:27 +00:00
|
|
|
if (b_info == FTS_D)
|
1994-05-26 06:18:55 +00:00
|
|
|
return (-1);
|
1997-09-18 06:42:27 +00:00
|
|
|
}
|
|
|
|
return (sortfcn(*a, *b));
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|