The Machine Perception Toolbox

[Introduction]- [News]- [Download]- [Screenshots]- [Manual (pdf)]- [Forums]- [API Reference]- [Repository ]

 

filent.c

Go to the documentation of this file.

/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*  This file is ALSO:
 *  (C) Copyright David Abrahams 2001. Permission to copy, use,
 *  modify, sell and distribute this software is granted provided this
 *  copyright notice appears in all copies. This software is provided
 *  "as is" without express or implied warranty, and with no claim as
 *  to its suitability for any purpose.
 */

# include "jam.h"
# include "filesys.h"
# include "pathsys.h"
# include "strings.h"

# ifdef OS_NT

# ifdef __BORLANDC__
# if __BORLANDC__ < 0x550
# include <dir.h>
# include <dos.h>
# endif
# undef FILENAME        /* cpp namespace collision */
# define _finddata_t ffblk
# endif

# include <io.h>
# include <sys/stat.h>

/*
 * filent.c - scan directories and archives on NT
 *
 * External routines:
 *
 *      file_dirscan() - scan a directory for files
 *      file_time() - get timestamp of file, if not done by file_dirscan()
 *      file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 07/10/95 (taylor)  Findfirst() returns the first file on NT.
 * 05/03/96 (seiwald) split apart into pathnt.c
 */

/*
 * file_dirscan() - scan a directory for files
 */

void
file_dirscan( 
        char *dir,
        scanback func,
        void *closure )
{
    PATHNAME f;
    string filespec[1];
    string filename[1];
    long handle;
    int ret;
    struct _finddata_t finfo[1];

    dir = short_path_to_long_path( dir );
        
    /* First enter directory itself */

    memset( (char *)&f, '\0', sizeof( f ) );

    f.f_dir.ptr = dir;
    f.f_dir.len = strlen(dir);

    dir = *dir ? dir : ".";

    /* Special case \ or d:\ : enter it */
 
    if( f.f_dir.len == 1 && f.f_dir.ptr[0] == '\\' )
        (*func)( closure, dir, 0 /* not stat()'ed */, (time_t)0 );
    else if( f.f_dir.len == 3 && f.f_dir.ptr[1] == ':' )
        (*func)( closure, dir, 0 /* not stat()'ed */, (time_t)0 );

    /* Now enter contents of directory */

    string_copy( filespec, dir );
    string_append( filespec, "/*" );

    if( DEBUG_BINDSCAN )
        printf( "scan directory %s\n", dir );

# if defined(__BORLANDC__) && __BORLANDC__ < 0x550
    if ( ret = findfirst( filespec->value, finfo, FA_NORMAL | FA_DIREC ) )
    {
        string_free( filespec );
        return;
    }

    string_new( filename );
    while( !ret )
    {
        time_t time_write = finfo->ff_fdate;

        time_write = (time_write << 16) | finfo->ff_ftime;
        f.f_base.ptr = finfo->ff_name;
        f.f_base.len = strlen( finfo->ff_name );

        string_truncate( filename, 0 );
        path_build( &f, filename );

        (*func)( closure, filename->value, 1 /* stat()'ed */, time_write );

        ret = findnext( finfo );
    }
# else
    handle = _findfirst( filespec->value, finfo );

    if( ret = ( handle < 0L ) )
    {
        string_free( filespec );
        return;
    }
        
    string_new( filename );
    while( !ret )
    {
        f.f_base.ptr = finfo->name;
        f.f_base.len = strlen( finfo->name );

        string_truncate( filename, 0 );
        path_build( &f, filename, 0 );

        (*func)( closure, filename->value, 1 /* stat()'ed */, finfo->time_write );
 
        ret = _findnext( handle, finfo );
    }

    _findclose( handle );
# endif
    string_free( filename );
    string_free( filespec );
}

/*
 * file_time() - get timestamp of file, if not done by file_dirscan()
 */

int
file_time(
        char    *filename,
        time_t  *time )
{
        /* On NT this is called only for C:/ */

        struct stat statbuf;

        if( stat( filename, &statbuf ) < 0 )
            return -1;

        *time = statbuf.st_mtime;

        return 0;
}

/*
 * file_archscan() - scan an archive for files
 */

/* Straight from SunOS */

#define ARMAG   "!<arch>\n"
#define SARMAG  8

#define ARFMAG  "`\n"

struct ar_hdr {
        char    ar_name[16];
        char    ar_date[12];
        char    ar_uid[6];
        char    ar_gid[6];
        char    ar_mode[8];
        char    ar_size[10];
        char    ar_fmag[2];
};

# define SARFMAG 2
# define SARHDR sizeof( struct ar_hdr )

void
file_archscan(
        char *archive,
        scanback func,
        void *closure )
{
        struct ar_hdr ar_hdr;
        char *string_table = 0;
        char buf[ MAXJPATH ];
        long offset;
        int fd;

        if( ( fd = open( archive, O_RDONLY | O_BINARY, 0 ) ) < 0 )
            return;

        if( read( fd, buf, SARMAG ) != SARMAG ||
            strncmp( ARMAG, buf, SARMAG ) )
        {
            close( fd );
            return;
        }

        offset = SARMAG;

        if( DEBUG_BINDSCAN )
            printf( "scan archive %s\n", archive );

        while( read( fd, &ar_hdr, SARHDR ) == SARHDR &&
               !memcmp( ar_hdr.ar_fmag, ARFMAG, SARFMAG ) )
        {
            long    lar_date;
            long    lar_size;
            char    *name = 0;
            char    *endname;
            char    *c;

            sscanf( ar_hdr.ar_date, "%ld", &lar_date );
            sscanf( ar_hdr.ar_size, "%ld", &lar_size );

            lar_size = ( lar_size + 1 ) & ~1;

            if (ar_hdr.ar_name[0] == '/' && ar_hdr.ar_name[1] == '/' )
            {
                /* this is the "string table" entry of the symbol table,
                ** which holds strings of filenames that are longer than
                ** 15 characters (ie. don't fit into a ar_name
                */

                string_table = malloc(lar_size);
                if (read(fd, string_table, lar_size) != lar_size)
                    printf("error reading string table\n");
                offset += SARHDR + lar_size;
                continue;
            }
            else if (ar_hdr.ar_name[0] == '/' && ar_hdr.ar_name[1] != ' ')
            {
                /* Long filenames are recognized by "/nnnn" where nnnn is
                ** the offset of the string in the string table represented
                ** in ASCII decimals.
                */

                name = string_table + atoi( ar_hdr.ar_name + 1 );
                endname = name + strlen( name );
            }
            else
            {
                /* normal name */
                name = ar_hdr.ar_name;
                endname = name + sizeof( ar_hdr.ar_name );
            }

            /* strip trailing space, slashes, and backslashes */

            while( endname-- > name )
                if( *endname != ' ' && *endname != '\\' && *endname != '/' )
                    break;
            *++endname = 0;

            /* strip leading directory names, an NT specialty */

            if( c = strrchr( name, '/' ) )
                name = c + 1;
            if( c = strrchr( name, '\\' ) )
                name = c + 1;

            sprintf( buf, "%s(%.*s)", archive, endname - name, name );
            (*func)( closure, buf, 1 /* time valid */, (time_t)lar_date );

            offset += SARHDR + lar_size;
            lseek( fd, offset, 0 );
        }

        close( fd );
}

# endif /* NT */

---