/*
* Copyright (c) 1989 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 are permitted
* provided that: (1) source distributions retain this entire copyright
* notice and comment, and (2) distributions including binaries display
* the following acknowledgement: ``This product includes software
* developed by the University of California, Berkeley and its contributors''
* in the documentation or other materials provided with the distribution
* and in all advertising materials mentioning features or use of this
* software. Neither the name of the University nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
All rights reserved.\n";
#endif /* not lint */
#ifndef lint
static char sccsid[] = "@(#)ls.c 5.42 (Berkeley) 5/17/90";
#endif /* not lint */
#include "client.h"
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>
#include "ls.h"
static int (*sortfcn)(const LS *, const LS *);
static void (*printfcn)(LS *stats, unsigned int num);
static void doargs(int argc, const char * const argv[]);
static void displaydir(LS *stats, unsigned int num);
static void subdir(LS *lp);
static int tabdir(LS *lp, LS **s_stats);
int termwidth; /* default terminal width */
static int ls_retval;
/* flags */
int f_accesstime; /* use time of last access */
static int f_column; /* columnated format */
static int f_dirname; /* if precede with directory name */
int f_group; /* show group ownership of a file */
static int f_ignorelink; /* indirect through symbolic link operands */
int f_inode; /* print inode */
static int f_kblocks; /* print size in kilobytes */
static int f_listalldot; /* list . and .. as well */
static int f_listdir; /* list actual directory, not contents */
static int f_listdot; /* list files beginning with . */
static int f_longform; /* long listing format */
static int f_needstat; /* if need to stat files */
static int f_newline; /* if precede with newline */
static int f_nonprint; /* show unprintables as ? */
static int f_nosort; /* don't sort output */
static int f_recursive; /* ls subdirectories also */
static int f_reversesort; /* reverse whatever sort is used */
static int f_singlecol; /* use single column output */
int f_size; /* list size in short listing */
int f_statustime; /* use time of last mode change */
static int f_timesort; /* sort by time vice name */
int f_total; /* if precede with "total" line */
int f_type; /* add type character for non-regular files */
int
fls_main(int argc, const char * const argv[])
{
int ch, exit_after_options;
char *p;
ls_retval = 0;
f_accesstime = f_column = f_group = f_ignorelink = f_inode =
f_kblocks = f_listalldot = f_listdir = f_listdot =
f_longform = f_needstat = f_newline = f_nonprint =
f_nosort = f_recursive = f_reversesort = f_singlecol =
f_size = f_statustime = f_dirname = f_timesort =
f_total = f_type = 0;
/* terminal defaults to -Cq, non-terminal defaults to -1 */
termwidth = 80;
if (isatty(1)) {
f_nonprint = 1;
#ifdef TIOCGWINSZ
{ struct winsize win;
if (ioctl(1, TIOCGWINSZ, &win) == -1 || !win.ws_col) {
if ((p = (char *)getenv("COLUMNS")))
termwidth = atoi(p);
}
else
termwidth = win.ws_col;
}
#endif
f_column = 1;
} else
f_singlecol = 1;
/* root is -A automatically */
#if 0
/* within FSP, if there are dot files to be seen, then the person
** *must* be root
*/
if (!getuid())
f_listdot = 1;
#endif
/* within my mechanism, there are dot files if you are root */
f_listdot = 1;
opterr = 0;
#ifdef HAVE_OPTRESET
optreset = 1;
optind = 1;
#else
optind = 0;
#endif
exit_after_options = 0;
while ((ch = getopt(argc, argv, "1ACFLRacdfgiklqrstu")) != EOF) {
switch (ch) {
/*
* -1, -C and -l all override each other
* so shell aliasing works right
*/
case '1':
f_singlecol = 1;
f_column = f_longform = 0;
break;
case 'C':
f_column = 1;
f_longform = f_singlecol = 0;
break;
case 'l':
f_longform = 1;
f_column = f_singlecol = 0;
break;
/* -c and -u override each other */
case 'c':
f_statustime = 1;
f_accesstime = 0;
break;
case 'u':
f_accesstime = 1;
f_statustime = 0;
break;
case 'F':
f_type = 1;
break;
case 'L':
f_ignorelink = 1;
break;
case 'R':
f_recursive = 1;
break;
case 'a':
f_listalldot = 1;
/* FALLTHROUGH */
case 'A':
f_listdot = 1;
break;
case 'd':
f_listdir = 1;
break;
case 'f':
f_nosort = 1;
break;
case 'g':
f_group = 1;
break;
case 'i':
f_inode = 1;
break;
case 'k':
f_kblocks = 1;
break;
case 'q':
f_nonprint = 1;
break;
case 'r':
f_reversesort = 1;
break;
case 's':
f_size = 1;
break;
case 't':
f_timesort = 1;
break;
default:
case '?':
exit_after_options = 1;
}
}
if (exit_after_options)
usage();
argc -= optind;
argv += optind;
/* -d turns off -R */
if (f_listdir)
f_recursive = 0;
/* if need to stat files */
f_needstat = f_longform || f_recursive || f_timesort ||
f_size || f_type || (sincetime > 0);
/* select a sort function */
if (f_reversesort) {
if (!f_timesort)
sortfcn = revnamecmp;
else if (f_accesstime)
sortfcn = revacccmp;
else if (f_statustime)
sortfcn = revstatcmp;
else /* use modification time */
sortfcn = revmodcmp;
} else {
if (!f_timesort)
sortfcn = namecmp;
else if (f_accesstime)
sortfcn = acccmp;
else if (f_statustime)
sortfcn = statcmp;
else /* use modification time */
sortfcn = modcmp;
}
/* select a print function */
if (f_singlecol)
printfcn = printscol;
else if (f_longform)
printfcn = printlong;
else
printfcn = printcol;
if (!argc) {
const char * const myargv[] = { ".",NULL } ;
argc = 1;
doargs(argc, myargv);
}
else
doargs(argc, argv);
return ls_retval;
}
static char path[2*1024 + 1];
static char *endofpath;
static void
tidyup_mem(int gavi, char *const**gav, LS *dstats, LS *rstats)
{
int i;
for (i = 0; i < gavi; i++)
free_glob(gav[i]);
(void)free(gav);
if (dstats) (void)free((char*)dstats);
if (rstats) (void)free((char*)rstats);
}
static void
doargs(int argc, const char * const argv[])
{
LS *dstatp, *rstatp;
int maxlen;
unsigned int regcnt, regmax, dircnt,dirmax,cnt;
LS *dstats, *rstats;
struct stat sb;
char top[2*1024 + 1];
char const **av;
char const *av2[2];
unsigned long blocks;
char *const**gav;
int gavi = 0;
gav = (char*const**) malloc(sizeof(char**) * argc);
endofpath = path;
/*
* walk through the operands, building separate arrays of LS
* structures for directory and non-directory files.
*/
dstats = rstats = NULL;
dirmax = regmax = 0;
for (dircnt = regcnt = 0; *argv; ++argv)
{
av = glob(*argv);
gav[gavi]=av;
if(!av)
{
av = av2;
av2[0] = *argv;
av2[1] = 0;
}
else gavi++;
for( ; *av; av++)
{
if (util_stat(*av, &sb)) {
if (client_intr_state < 2)
{
ls_retval = 1;
perror(*av);
if (errno == ENOENT)
continue;
}
tidyup_mem(gavi, gav, dstats, rstats);
ls_bad(1);
}
if ((S_IFDIR & sb.st_mode) && !f_listdir) {
if(dirmax == dircnt)
{
dirmax += 10;
if (!dstats)
{
dstatp = dstats = (LS *)emalloc(dirmax *
(sizeof(LS)));
} else
{
dstats = (LS *)realloc((char*)dstats,
dirmax * (sizeof(LS)));
dstatp = dstats + dircnt;
}
}
dstatp->name = *av;
dstatp->lstat = sb;
++dstatp;
++dircnt;
}
else {
if (sb.st_mtime < sincetime) continue;
if(regmax == regcnt)
{
regmax += 10;
if (!rstats)
{
blocks = 0;
maxlen = -1;
rstatp = rstats = (LS *)emalloc(regmax *
(sizeof(LS)));
} else
{
rstats = (LS *)realloc(rstats,
regmax * (sizeof(LS)));
rstatp = rstats + regcnt;
}
}
rstatp->name = *av;
rstatp->lstat = sb;
/* save name length for -C format */
rstatp->len = strlen(*av);
if (f_nonprint)
prcopy(*av, *av, rstatp->len);
/* calculate number of blocks if -l/-s formats */
if (f_longform || f_size)
blocks += (sb.st_size + 1023)/1024;
/* save max length if -C format */
if (f_column && maxlen < rstatp->len)
maxlen = rstatp->len;
++rstatp;
++regcnt;
}
}
}
/* display regular files */
if (regcnt) {
rstats[0].lst_btotal = blocks;
rstats[0].lst_maxlen = maxlen;
displaydir(rstats, regcnt);
f_newline = f_dirname = 1;
}
/* display directories */
if (dircnt) {
register char *p;
f_total = 1;
if (dircnt > 1) {
(void)util_getwd(top);
qsort((char *)dstats, dircnt, sizeof(LS), sortfcn);
f_dirname = 1;
}
for (cnt = 0, dstatp = dstats; cnt < dircnt; ++dstatp) {
for (endofpath = path, p = dstatp->name;
(*endofpath = *p++); ++endofpath);
subdir(dstatp);
f_newline = 1;
if (++cnt < dircnt && util_cd(top)) {
if (client_intr_state < 2) perror(top);
tidyup_mem(gavi, gav, dstats, rstats);
ls_bad(1);
}
}
}
tidyup_mem(gavi, gav, dstats, rstats);
}
static void
displaydir(LS *stats, unsigned int num)
{
register char *p, *savedpath;
LS *lp;
if (num > 1 && !f_nosort) {
unsigned long save1, save2;
save1 = stats[0].lst_btotal;
save2 = stats[0].lst_maxlen;
qsort((char *)stats, num, sizeof(LS), sortfcn);
stats[0].lst_btotal = save1;
stats[0].lst_maxlen = save2;
}
printfcn(stats, num);
if (f_recursive) {
savedpath = endofpath;
for (lp = stats; num--; ++lp) {
if (!(S_IFDIR & lp->lstat.st_mode))
continue;
p = lp->name;
if (p[0] == '.' && (!p[1] || (p[1] == '.' && !p[2])))
continue;
if (endofpath != path && endofpath[-1] != '/')
*endofpath++ = '/';
for (; (*endofpath = *p++); ++endofpath);
f_newline = f_dirname = f_total = 1;
subdir(lp);
*(endofpath = savedpath) = '\0';
if (client_intr_state > 1)
break;
}
}
}
static void
subdir(LS *lp)
{
LS *stats;
int num;
if (f_newline)
(void)putc('\n', STDOUT);
if (f_dirname)
ffprintf(STDOUT, "%s:\n", path);
if (util_cd(lp->name)) {
ls_retval = 1;
if (client_intr_state < 2) perror(lp->name);
return;
}
if ((num = tabdir(lp, &stats))) {
displaydir(stats, num);
(void)free((char *)stats);
}
if (!((lp->name)[0] == '.' && (lp->name)[1] == '\0'))
if (util_cd("..")) {
if (client_intr_state < 2) perror("..");
ls_bad(1);
}
}
static int
tabdir(LS *lp, LS **s_stats)
{
register RDIR *dirp;
register int cnt, maxentry, maxlen;
register char *p;
struct rdirent *dp;
unsigned long blocks;
LS *stats;
if (!(dirp = util_opendir("."))) {
ls_retval = 1;
if (client_intr_state < 2) perror(lp->name);
return(0);
}
blocks = maxentry = maxlen = 0;
stats = NULL;
for (cnt = 0; (dp = util_readdir(dirp));) {
/* this does -A and -a */
p = dp->rd_name;
if (p[0] == '.') {
if (!f_listdot)
continue;
if (!f_listalldot && (!p[1] || (p[1] == '.' && !p[2])))
continue;
}
if (cnt == maxentry) {
#define DEFNUM 256
maxentry += DEFNUM;
if(stats)
{
if (!(*s_stats = stats = (LS *)realloc((char *)stats,
(unsigned int)maxentry * sizeof(LS))))
nomem();
} else
{
if (!(*s_stats = stats = (LS *)malloc(
(unsigned int)maxentry * sizeof(LS))))
nomem();
}
}
if (f_needstat && util_stat(dp->rd_name, &stats[cnt].lstat)) {
/*
* don't exit -- this could be an NFS mount that has
* gone away. Flush STDOUT so the messages line up.
*/
(void)fflush(STDOUT);
if (client_intr_state < 2)
{
ls_retval = 1;
perror(dp->rd_name);
continue;
}
else
break;
}
if (f_needstat &&
(S_IFDIR & stats[cnt].lstat.st_mode) == 0 &&
stats[cnt].lstat.st_mtime < sincetime)
continue;
stats[cnt].name = dp->rd_name;
/*
* get the inode from the directory, so the -f flag
* works right.
*/
stats[cnt].lstat.st_ino = dp->rd_fileno;
/* save name length for -C format */
stats[cnt].len = dp->rd_namlen;
/* calculate number of blocks if -l/-s formats */
if (f_longform || f_size)
blocks += (stats[cnt].lstat.st_size + 1023)/1024;
/* save max length if -C format */
if (f_column && maxlen < (int)dp->rd_namlen)
maxlen = dp->rd_namlen;
++cnt;
}
(void)util_closedir(dirp);
if (cnt) {
stats[0].lst_btotal = blocks;
stats[0].lst_maxlen = maxlen;
} else if (stats) {
(void)free((char *)stats);
}
return(cnt);
}
syntax highlighted by Code2HTML, v. 0.9.1