447 lines
11 KiB
C
447 lines
11 KiB
C
/*
|
|
* 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 */
|
|
|
|
#include "tweak.h"
|
|
#include "bsd_extern.h"
|
|
#include "client_def.h"
|
|
#include "c_extern.h"
|
|
#include <sys/ioctl.h>
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include "my-string.h"
|
|
#include "ls.h"
|
|
|
|
static char path[2*1024 + 1];
|
|
static char *endofpath = path;
|
|
|
|
typedef int (*COMPAR)(const void *, const void *);
|
|
int (*sortfcn)(LS *, LS *);
|
|
void (*printfcn)(LS *, int);
|
|
|
|
int termwidth = 80; /* default terminal width */
|
|
|
|
/* flags */
|
|
int f_accesstime; /* use time of last access */
|
|
int f_column; /* columnated format */
|
|
int f_group; /* show group ownership of a file */
|
|
int f_ignorelink; /* indirect through symbolic link operands */
|
|
int f_inode; /* print inode */
|
|
int f_kblocks; /* print size in kilobytes */
|
|
int f_listalldot; /* list . and .. as well */
|
|
int f_listdir; /* list actual directory, not contents */
|
|
int f_listdot; /* list files beginning with . */
|
|
int f_longform; /* long listing format */
|
|
int f_needstat; /* if need to stat files */
|
|
int f_newline; /* if precede with newline */
|
|
int f_nonprint; /* show unprintables as ? */
|
|
int f_nosort; /* don't sort output */
|
|
int f_recursive; /* ls subdirectories also */
|
|
int f_reversesort; /* reverse whatever sort is used */
|
|
int f_singlecol; /* use single column output */
|
|
int f_size; /* list size in short listing */
|
|
int f_statustime; /* use time of last mode change */
|
|
int f_dirname; /* if precede with directory name */
|
|
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 */
|
|
|
|
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("."))) {
|
|
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->d_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) {
|
|
*s_stats = stats = (LS *)realloc((char *)stats,
|
|
(unsigned int)maxentry * sizeof(LS));
|
|
if (!*s_stats) nomem();
|
|
} else {
|
|
*s_stats = stats = (LS *)malloc((unsigned int)maxentry * sizeof(LS));
|
|
if (!*s_stats) nomem();
|
|
}
|
|
}
|
|
if (f_needstat && util_stat(dp->d_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);
|
|
perror(dp->d_name);
|
|
continue;
|
|
}
|
|
stats[cnt].name = dp->d_name;
|
|
|
|
/*
|
|
* get the inode from the directory, so the -f flag
|
|
* works right.
|
|
*/
|
|
stats[cnt].lstat.st_ino = dp->d_fileno;
|
|
|
|
/* save name length for -C format */
|
|
stats[cnt].len = dp->d_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->d_namlen) maxlen = dp->d_namlen;
|
|
++cnt;
|
|
}
|
|
(void)util_closedir(dirp);
|
|
|
|
if (cnt) {
|
|
stats[0].lstat.st_btotal = blocks;
|
|
stats[0].lstat.st_maxlen = maxlen;
|
|
} else if (stats) {
|
|
(void)free((char *)stats);
|
|
}
|
|
return(cnt);
|
|
}
|
|
|
|
static void displaydir (LS *, register int);
|
|
|
|
static void subdir (LS * lp)
|
|
{
|
|
LS *stats;
|
|
int num;
|
|
|
|
if (f_newline) (void)putchar('\n');
|
|
if (f_dirname) (void)printf("%s:\n", path);
|
|
|
|
if (util_cd2(lp->name)) {
|
|
perror(lp->name);
|
|
return;
|
|
}
|
|
if ( (num = tabdir(lp, &stats))) {
|
|
displaydir(stats, num);
|
|
(void)free((char *)stats);
|
|
}
|
|
if (util_cd2("..")) {
|
|
perror("..");
|
|
ls_bad(1);
|
|
}
|
|
}
|
|
|
|
static void displaydir (LS * stats, register int num)
|
|
{
|
|
register char *p, *savedpath;
|
|
LS *lp;
|
|
|
|
if (num > 1 && !f_nosort) {
|
|
unsigned long save1, save2;
|
|
|
|
save1 = stats[0].lstat.st_btotal;
|
|
save2 = stats[0].lstat.st_maxlen;
|
|
qsort((char *)stats, num, sizeof(LS), (COMPAR) sortfcn);
|
|
stats[0].lstat.st_btotal = save1;
|
|
stats[0].lstat.st_maxlen = save2;
|
|
}
|
|
|
|
printfcn(stats, num);
|
|
|
|
if (f_recursive)
|
|
{
|
|
savedpath = endofpath;
|
|
for (lp = stats; num--; ++lp)
|
|
{
|
|
if (!(S_ISDIR(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';
|
|
}
|
|
}
|
|
}
|
|
|
|
static void doargs (int argc, char ** argv)
|
|
{
|
|
register LS *dstatp, *rstatp;
|
|
register int cnt, dircnt, dirmax, maxlen, regcnt, regmax;
|
|
LS *dstats, *rstats;
|
|
struct stat sb;
|
|
char top[2*1024 + 1], **av, *av2[2];
|
|
unsigned long blocks;
|
|
RDIR * dl;
|
|
|
|
/*
|
|
* walk through the operands, building separate arrays of LS
|
|
* structures for directory and non-directory files.
|
|
*/
|
|
dstats = rstats = NULL;
|
|
dirmax = regmax = 0;
|
|
/* disable use of new CC_STAT command for performance reasons */
|
|
statworks = 0;
|
|
|
|
for (dircnt = regcnt = 0; *argv; ++argv) {
|
|
if(!(av = bsdglob(*argv))) {
|
|
av = av2;
|
|
av2[0] = *argv;
|
|
av2[1] = 0;
|
|
}
|
|
|
|
for( ; *av; av++) {
|
|
if (util_stat(*av, &sb)) {
|
|
perror(*av);
|
|
if (errno == ENOENT) continue;
|
|
ls_bad(1);
|
|
}
|
|
|
|
if ((S_ISDIR(sb.st_mode)) && !f_listdir) {
|
|
if(dirmax == dircnt) {
|
|
dirmax += 10;
|
|
if (!dstats) {
|
|
dstatp = dstats = (LS *)emalloc(dirmax * (sizeof(LS)));
|
|
} else {
|
|
dstats = (LS *)realloc(dstats, dirmax * (sizeof(LS)));
|
|
dstatp = dstats + dircnt;
|
|
}
|
|
}
|
|
dstatp->name = *av;
|
|
dstatp->lstat = sb;
|
|
++dstatp;
|
|
++dircnt;
|
|
} else {
|
|
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].lstat.st_btotal = blocks;
|
|
rstats[0].lstat.st_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), (COMPAR) sortfcn);
|
|
f_dirname = 1;
|
|
}
|
|
for (cnt = 0; cnt < dircnt; ++dstats) {
|
|
for (endofpath = path, p = dstats->name;
|
|
(*endofpath = *p++); ++endofpath);
|
|
subdir(dstats);
|
|
f_newline = 1;
|
|
if (++cnt < dircnt && util_cd2(top)) {
|
|
perror(top);
|
|
ls_bad(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void fls_main (int argc, char ** argv)
|
|
{
|
|
int ch;
|
|
char *p;
|
|
|
|
/* terminal defaults to -Cq, non-terminal defaults to -1 */
|
|
if (isatty(1)) {
|
|
f_nonprint = 1;
|
|
termwidth = 80;
|
|
#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 (!getuid()) f_listdot = 1;
|
|
|
|
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;
|
|
case '?':
|
|
default:
|
|
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;
|
|
|
|
/* 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 sortfcn = revmodcmp; /* use modification time */
|
|
} else {
|
|
if (!f_timesort) sortfcn = namecmp;
|
|
else if (f_accesstime) sortfcn = acccmp;
|
|
else if (f_statustime) sortfcn = statcmp;
|
|
else sortfcn = modcmp; /* use modification time */
|
|
}
|
|
|
|
/* select a print function */
|
|
if (f_singlecol) printfcn = printscol;
|
|
else if (f_longform) printfcn = printlong;
|
|
else printfcn = printcol;
|
|
|
|
if (!argc) {
|
|
argc = 1;
|
|
argv[0] = ".";
|
|
argv[1] = NULL;
|
|
}
|
|
doargs(argc, argv);
|
|
}
|
|
|