ls.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	LsCacheItem

Macros
#define	kLsCacheItemLifetime   900 /* seconds */
#define	kLsCacheSize   32

Typedefs
typedef struct LsCacheItem	LsCacheItem

Functions
void	InitLsCache (void)
void	InitLsMonths (void)
void	InitLs (void)
void	FlushLsCache (void)
int	LsCacheLookup (const char *const)
void	LsDate (char *, time_t)
void	LsL (FileInfoListPtr, int, int, FILE *)
void	Ls1 (FileInfoListPtr, int, FILE *)
void	Ls (const char *const, int, const char *const, FILE *)
void	LLs (const char *const, int, const char *const, FILE *)

Macro Definition Documentation

kLsCacheItemLifetime

#define kLsCacheItemLifetime   900 /* seconds */

Definition at line 8 of file ls.h.

kLsCacheSize

#define kLsCacheSize   32

Definition at line 17 of file ls.h.

Typedef Documentation

LsCacheItem

typedef struct LsCacheItem LsCacheItem

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().

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().

LLs()

void LLs	(	const char * const	,
		int	,
		const char * const	,
		FILE *
	)

Referenced by LocalListCmd().

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().

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().