ls.c File Reference

#include "syshdrs.h"
#include "util.h"
#include "ls.h"
#include "trace.h"

Include dependency graph for ls.c:

Go to the source code of this file.

Functions
void	InitLsCache (void)
void	InitLsMonths (void)
void	InitLs (void)
static void	FlushLsCacheItem (int i)
void	FlushLsCache (void)
int	LsCacheLookup (const char *const itempath)
static void	LsCacheAdd (const char *const itempath, FileInfoListPtr files)
static void	LsC (FileInfoListPtr dirp, int endChars, FILE *stream)
void	LsDate (char *dstr, time_t ts)
void	LsL (FileInfoListPtr dirp, int endChars, int linkedTo, FILE *stream)
void	Ls1 (FileInfoListPtr dirp, int endChars, FILE *stream)
void	Ls (const char *const item, int listmode, const char *const options, FILE *stream)

Variables
time_t	gNowMinus6Mon
time_t	gNowPlus1Hr
char	gLsMon [13][4]
LsCacheItem	gLsCache [kLsCacheSize]
int	gOldestLsCacheItem
int	gLsCacheItemLifetime = kLsCacheItemLifetime
FTPConnectionInfo	gConn
char	gRemoteCWD [512]
int	gScreenColumns
int	gDebug

Function Documentation

FlushLsCache()

void FlushLsCache

(

void

)

Definition at line 94 of file ls.c.

{
    int i;
 
    for (i=0; i<kLsCacheSize; i++) {
        if (gLsCache[i].expiration != (time_t) 0) {
            FlushLsCacheItem(i);
        }
    }
}   /* FlushLsCache */

Referenced by ChmodCmd(), DeleteCmd(), GetCmd(), MkdirCmd(), OpenCmd(), PutCmd(), RenameCmd(), RmdirCmd(), and SymlinkCmd().

FlushLsCacheItem()

static void FlushLsCacheItem ( int  i )

static

Definition at line 79 of file ls.c.

{
    Trace(1, "flush ls cache item: %s\n", gLsCache[i].itempath);
    if (gLsCache[i].itempath != NULL)
        free(gLsCache[i].itempath);
    gLsCache[i].itempath = NULL;
    gLsCache[i].expiration = (time_t) 0;
    DisposeFileInfoListContents(&gLsCache[i].fil);
}   /* FlushLsCacheItem */

Referenced by FlushLsCache(), LsCacheAdd(), and LsCacheLookup().

InitLs()

void InitLs

(

void

)

Definition at line 68 of file ls.c.

{
    InitLsCache();
    InitLsMonths();
}   /* InitLs */

Referenced by PreInit().

InitLsCache()

void InitLsCache

(

void

)

Definition at line 36 of file ls.c.

{
    (void) memset(gLsCache, 0, sizeof(gLsCache));
    gOldestLsCacheItem = 0;
}   /* InitLsCache */

Referenced by InitLs().

InitLsMonths()

void InitLsMonths

(

void

)

Definition at line 47 of file ls.c.

{
    time_t now;
    struct tm *ltp;
    int i;
 
    (void) time(&now);
    ltp = localtime(&now);  /* Fill up the structure. */
    ltp->tm_mday = 15;
    ltp->tm_hour = 12;
    for (i=0; i<12; i++) {
        ltp->tm_mon = i;
        (void) strftime(gLsMon[i], sizeof(gLsMon[i]), "%b", ltp);
        gLsMon[i][sizeof(gLsMon[i]) - 1] = '\0';
    }
    (void) strcpy(gLsMon[i], "BUG");
}   /* InitLsMonths */

Referenced by InitLs().

Ls()

void Ls	(	const char *const	item,
		int	listmode,
		const char *const	options,
		FILE *	stream
	)

Definition at line 465 of file ls.c.

{
    char itempath[512];
    FileInfoList fil;
    FileInfoListPtr filp;
    LinePtr linePtr, nextLinePtr;
    LineList dirContents;
    int parsed;
    int linkedTo;
    int endChars;
    int rlisted;
    int opt;
    const char *cp;
    int sortBy;
    int sortOrder;
    int unknownOpts;
    char optstr[32];
    char unoptstr[32];
    int doNotUseCache;
    int wasInCache;
    int mlsd;
    int ci;
 
    InitLineList(&dirContents);
    InitFileInfoList(&fil);
 
    sortBy = 'n';       /* Sort by filename. */
    sortOrder = 'a';    /* Sort in ascending order. */
    linkedTo = 0;
    endChars = (listmode == 'C') ? 1 : 0;
    unknownOpts = 0;
    memset(unoptstr, 0, sizeof(unoptstr));
    unoptstr[0] = '-';
    doNotUseCache = 0;
    rlisted = 0;
 
    for (cp = options; *cp != '\0'; cp++) {
        opt = *cp;
        switch (opt) {
            case 't':
                sortBy = 't';       /* Sort by modification time. */
                break;
            case 'S':
                sortBy = 's';       /* Sort by size. */
                break;
            case 'r':
                sortOrder = 'd';    /* descending order */
                break;
            case 'L':
                linkedTo = 1;
                break;
            case 'f':
                doNotUseCache = 1;
                break;
            case 'F':
            case 'p':
                endChars = 1;
                break;
            case '1':
            case 'C':
            case 'l':
                listmode = opt;
                break;
            case '-':
                break;
            default:
                if (unknownOpts < ((int) sizeof(unoptstr) - 2))
                    unoptstr[unknownOpts + 1] = opt;
                unknownOpts++;
                break;
        }
    }
 
    /* Create a possibly relative path into an absolute path. */
    PathCat(itempath, sizeof(itempath), gRemoteCWD,
        (item == NULL) ? "." : item);
 
    if (unknownOpts > 0) {
        /* Can't handle these -- pass them through
         * to the server.
         */
 
        Trace(0, "ls caching not used because of ls flags: %s\n", unoptstr);
        optstr[0] = '-';
        optstr[1] = listmode;
        optstr[2] = '\0';
        (void) STRNCAT(optstr, options);
        if ((FTPListToMemory2(&gConn, (item == NULL) ? "" : item, &dirContents, optstr, 1, 0)) < 0) {
            if (stream != NULL)
                (void) fprintf(stderr, "List failed.\n");
            return;
        }
 
        rlisted = 1;
        parsed = -1;
        wasInCache = 0;
        filp = NULL;
    } else if ((doNotUseCache != 0) || ((ci = LsCacheLookup(itempath)) < 0)) {
        /* Not in cache. */
        wasInCache = 0;
 
        mlsd = 1;
        if ((FTPListToMemory2(&gConn, (item == NULL) ? "" : item, &dirContents, "-l", 1, &mlsd)) < 0) {
            if (stream != NULL)
                (void) fprintf(stderr, "List failed.\n");
            return;
        }
 
        rlisted = 1;
        filp = &fil;
        if (mlsd != 0) {
            parsed = UnMlsD(filp, &dirContents);
            if (parsed < 0) {
                Trace(0, "UnMlsD: %d\n", parsed);
            }
        } else {
            parsed = UnLslR(filp, &dirContents, gConn.serverType);
            if (parsed < 0) {
                Trace(0, "UnLslR: %d\n", parsed);
            }
        }
        if (parsed >= 0) {
            VectorizeFileInfoList(filp);
            if (filp->vec == NULL) {
                if (stream != NULL)
                    (void) fprintf(stderr, "List processing failed.\n");
                return;
            }
        }
    } else {
        filp = &gLsCache[ci].fil;
        wasInCache = 1;
        parsed = 1;
        Trace(0, "ls cache hit: %s\n", itempath);
    }
 
    if (rlisted != 0) {
        Trace(0, "Remote listing contents {\n");
        for (linePtr = dirContents.first;
            linePtr != NULL;
            linePtr = nextLinePtr)
        {
            nextLinePtr = linePtr->next;
            Trace(0, "    %s\n", linePtr->line);
        }
        Trace(0, "}\n");
    }
 
    if (parsed >= 0) {
        SortFileInfoList(filp, sortBy, sortOrder);
        if (stream != NULL) {
            if (listmode == 'l')
                LsL(filp, endChars, linkedTo, stream);
            else if (listmode == '1')
                Ls1(filp, endChars, stream);
            else
                LsC(filp, endChars, stream);
        }
        if (wasInCache == 0) {
            LsCacheAdd(itempath, filp);
        }
    } else if (stream != NULL) {
        for (linePtr = dirContents.first;
            linePtr != NULL;
            linePtr = nextLinePtr)
        {
            nextLinePtr = linePtr->next;
            (void) fprintf(stream, "%s\n", linePtr->line);
            Trace(0, "    %s\n", linePtr->line);
        }
    }
 
    DisposeLineListContents(&dirContents);
}   /* Ls */

Referenced by capGetDriverDescriptionW(), GetLsCacheFileList(), and ListCmd().

Ls1()

void Ls1	(	FileInfoListPtr	dirp,
		int	endChars,
		FILE *	stream
	)

Definition at line 419 of file ls.c.

{
    char fTail[2];
    int i;
    int fType;
    FileInfoVec diritemv;
    FileInfoPtr diritemp;
 
    fTail[0] = '\0';
    fTail[1] = '\0';
    diritemv = dirp->vec;
 
    for (i=0; ; i++) {
        diritemp = diritemv[i];
        if (diritemp == NULL)
            break;
 
        fType = (int) diritemp->type;
        if (endChars != 0) {
            if (fType == 'd')
                fTail[0] = '/';
            else
                fTail[0] = '\0';
        }
 
        (void) fprintf(stream, "%s%s\n",
            diritemp->relname,
            fTail
        );
 
        Trace(0, "%s%s\n",
            diritemp->relname,
            fTail
        );
    }
}   /* Ls1 */

Referenced by Ls().

LsC()

static void LsC ( FileInfoListPtr  dirp, int  endChars, FILE *  stream  )

static

Definition at line 182 of file ls.c.

{
    char buf[400];
    char buf2[400];
    int ncol, nrow;
    int i, j, k, l;
    int colw;
    int n;
    FileInfoVec itemv;
    FileInfoPtr itemp;
    char *cp1, *cp2, *lim;
    int screenColumns;
 
    screenColumns = gScreenColumns;
    if (screenColumns > 400)
        screenColumns = 400;
    ncol = (screenColumns - 1) / ((int) dirp->maxFileLen + 2 + /*1or0*/ endChars);
    if (ncol < 1)
        ncol = 1;
    colw = (screenColumns - 1) / ncol;
    n = dirp->nFileInfos;
    nrow = n / ncol;
    if ((n % ncol) != 0)
        nrow++;
 
    for (i=0; i<(int) sizeof(buf2); i++)
        buf2[i] = ' ';
 
    itemv = dirp->vec;
 
    for (j=0; j<nrow; j++) {
        (void) memcpy(buf, buf2, sizeof(buf));
        for (i=0, k=j, l=0; i<ncol; i++, k += nrow, l += colw) {
            if (k >= n)
                continue;
            itemp = itemv[k];
            cp1 = buf + l;
            lim = cp1 + (int) (itemp->relnameLen);
            cp2 = itemp->relname;
            while (cp1 < lim)
                *cp1++ = *cp2++;
            if (endChars != 0) {
                if (itemp->type == 'l') {
                    /* Regular ls always uses @
                     * for a symlink tail, even if
                     * the linked item is a directory.
                     */
                    *cp1++ = '@';
                } else if (itemp->type == 'd') {
                    *cp1++ = '/';
                }
            }
        }
        for (cp1 = buf + sizeof(buf); *--cp1 == ' '; ) {}
        ++cp1;
        *cp1++ = '\n';
        *cp1 = '\0';
        (void) fprintf(stream, "%s", buf);
        Trace(0, "%s", buf);
    }
}   /* LsC */

Referenced by Ls().

LsCacheAdd()

static void LsCacheAdd ( const char *const  itempath, FileInfoListPtr  files  )

static

Definition at line 139 of file ls.c.

{
    char *cp;
    int j;
 
    /* Never cache empty listings in case of errors */
    if (files->nFileInfos == 0)
        return;
 
    j = LsCacheLookup(itempath);
    if (j >= 0) {
        /* Directory was already in there;
         * Replace it with the new
         * contents.
         */
        FlushLsCacheItem(j);
    }
 
    cp = StrDup(itempath);
    if (cp == NULL)
        return;
 
    j = gOldestLsCacheItem;
    (void) memcpy(&gLsCache[j].fil, files, sizeof(FileInfoList));
    (void) time(&gLsCache[j].expiration);
    gLsCache[j].expiration += gLsCacheItemLifetime;
    gLsCache[j].hits = 0;
    gLsCache[j].itempath = cp;
    Trace(1, "ls cache add: %s\n", itempath);
 
    /* Increment the pointer.  This is a circular array, so if it
     * hits the end it wraps over to the other side.
     */
    gOldestLsCacheItem++;
    if (gOldestLsCacheItem >= kLsCacheSize)
        gOldestLsCacheItem = 0;
}   /* LsCacheAdd */

Referenced by Ls().

LsCacheLookup()

int LsCacheLookup

(

const char *const

itempath

)

Definition at line 110 of file ls.c.

{
    int i, j;
    time_t now;
 
    (void) time(&now);
    for (i=0, j=gOldestLsCacheItem; i<kLsCacheSize; i++) {
        if (--j < 0)
            j = kLsCacheSize - 1;
        if ((gLsCache[j].expiration != (time_t) 0) && (gLsCache[j].itempath != NULL)) {
            if (strcmp(itempath, gLsCache[j].itempath) == 0) {
                if (now > gLsCache[j].expiration) {
                    /* Found it, but it was expired. */
                    FlushLsCacheItem(j);
                    return (-1);
                }
                gLsCache[j].hits++;
                return (j);
            }
        }
    }
    return (-1);
}   /* LsCacheLookup */

Referenced by GetLsCacheFileList(), Ls(), and LsCacheAdd().

LsDate()

void LsDate	(	char *	dstr,
		time_t	ts
	)

Definition at line 250 of file ls.c.

{
    struct tm *gtp;
 
    if (ts == kModTimeUnknown) {
        (void) strcpy(dstr, "            ");
        return;
    }
    gtp = localtime(&ts);
    if (gtp == NULL) {
        (void) strcpy(dstr, "Jan  0  1900");
        return;
    }
    if ((ts > gNowPlus1Hr) || (ts < gNowMinus6Mon)) {
        (void) sprintf(dstr, "%s %2d  %4d",
            gLsMon[gtp->tm_mon],
            gtp->tm_mday,
            gtp->tm_year + 1900
        );
    } else {
        (void) sprintf(dstr, "%s %2d %02d:%02d",
            gLsMon[gtp->tm_mon],
            gtp->tm_mday,
            gtp->tm_hour,
            gtp->tm_min
        );
    }
}   /* LsDate */

Referenced by LsL().

LsL()

void LsL	(	FileInfoListPtr	dirp,
		int	endChars,
		int	linkedTo,
		FILE *	stream
	)

Definition at line 284 of file ls.c.

{
    FileInfoPtr diritemp;
    FileInfoVec diritemv;
    int i;
    char fTail[2];
    int fType;
    const char *l1, *l2;
    char datestr[16];
    char sizestr[32];
    char plugspec[16];
    char plugstr[64];
    const char *expad;
 
    fTail[0] = '\0';
    fTail[1] = '\0';
 
    (void) time(&gNowPlus1Hr);
    gNowMinus6Mon = gNowPlus1Hr - 15552000;
    gNowPlus1Hr += 3600;
 
    diritemv = dirp->vec;
#ifdef HAVE_SNPRINTF
    (void) snprintf(
        plugspec,
        sizeof(plugspec) - 1,
#else
    (void) sprintf(
        plugspec,
#endif
        "%%-%ds",
        (int) dirp->maxPlugLen
    );
 
    if (dirp->maxPlugLen < 29) {
        /* We have some extra space to work with,
         * so we can space out the columns a little.
         */
        expad = "  ";
    } else {
        expad = "";
    }
 
    for (i=0; ; i++) {
        diritemp = diritemv[i];
        if (diritemp == NULL)
            break;
 
        fType = (int) diritemp->type;
        if (endChars != 0) {
            if (fType == 'd')
                fTail[0] = '/';
            else
                fTail[0] = '\0';
        }
 
        if (diritemp->rlinkto != NULL) {
            if (linkedTo != 0) {
                l1 = "";
                l2 = "";
            } else {
                l1 = " -> ";
                l2 = diritemp->rlinkto;
            }
        } else {
            l1 = "";
            l2 = "";
        }
 
        LsDate(datestr, diritemp->mdtm);
 
        if (diritemp->size == kSizeUnknown) {
            *sizestr = '\0';
        } else {
#ifdef HAVE_SNPRINTF
            (void) snprintf(
                sizestr,
                sizeof(sizestr) - 1,
#else
            (void) sprintf(
                sizestr,
#endif
#if defined(HAVE_LONG_LONG) && defined(PRINTF_LONG_LONG)
                PRINTF_LONG_LONG,
#else
                "%ld",
#endif
                (longest_int) diritemp->size
            );
        }
 
#ifdef HAVE_SNPRINTF
        (void) snprintf(
            plugstr,
            sizeof(plugstr) - 1,
#else
        (void) sprintf(
            plugstr,
#endif
            plugspec,
            diritemp->plug
        );
 
        (void) fprintf(stream, "%s %12s %s%s %s%s%s%s%s\n",
            plugstr,
            sizestr,
            expad,
            datestr,
            expad,
            diritemp->relname,
            l1,
            l2,
            fTail
        );
        Trace(0, "%s %12s %s%s %s%s%s%s%s\n",
            plugstr,
            sizestr,
            expad,
            datestr,
            expad,
            diritemp->relname,
            l1,
            l2,
            fTail
        );
    }
}   /* LsL */

Referenced by Ls().

Variable Documentation

gConn

FTPConnectionInfo gConn

extern

Definition at line 37 of file main.c.

Referenced by Ls().

gDebug

int gDebug

Definition at line 32 of file ls.c.

gLsCache

LsCacheItem gLsCache[kLsCacheSize]

Definition at line 26 of file ls.c.

Referenced by FlushLsCache(), FlushLsCacheItem(), GetLsCacheFileList(), InitLsCache(), Ls(), LsCacheAdd(), and LsCacheLookup().

gLsCacheItemLifetime

int gLsCacheItemLifetime = kLsCacheItemLifetime

Definition at line 28 of file ls.c.

Referenced by LsCacheAdd().

gLsMon

char gLsMon[13][4]

Definition at line 21 of file ls.c.

Referenced by InitLsMonths(), and LsDate().

gNowMinus6Mon

time_t gNowMinus6Mon

Definition at line 18 of file ls.c.

Referenced by LsDate(), and LsL().

gNowPlus1Hr

time_t gNowPlus1Hr

Definition at line 18 of file ls.c.

Referenced by LsDate(), and LsL().

gOldestLsCacheItem

int gOldestLsCacheItem

Definition at line 27 of file ls.c.

Referenced by InitLsCache(), LsCacheAdd(), and LsCacheLookup().

gRemoteCWD

char gRemoteCWD[512]

extern

Definition at line 33 of file cmds.c.

Referenced by Ls().

gScreenColumns

int gScreenColumns

extern

Definition at line 78 of file cmds.c.

Referenced by LsC().