//==========================================================================
//
//      file.cxx
//
//      Fileio file operations
//
//==========================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// -------------------------------------------                              
// The contents of this file are subject to the Red Hat eCos Public License 
// Version 1.1 (the "License"); you may not use this file except in         
// compliance with the License.  You may obtain a copy of the License at    
// http://www.redhat.com/                                                   
//                                                                          
// Software distributed under the License is distributed on an "AS IS"      
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the 
// License for the specific language governing rights and limitations under 
// the License.                                                             
//                                                                          
// The Original Code is eCos - Embedded Configurable Operating System,      
// released September 30, 1998.                                             
//                                                                          
// The Initial Developer of the Original Code is Red Hat.                   
// Portions created by Red Hat are                                          
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.                             
// All Rights Reserved.                                                     
// -------------------------------------------                              
//                                                                          
//####COPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):           nickg
// Contributors:        nickg
// Date:                2000-05-25
// Purpose:             Fileio file operations
// Description:         These are the functions that operate on files as a whole,
//                      such as open(), creat(), mkdir() etc.
//              
//              
//
//####DESCRIPTIONEND####
//
//==========================================================================

#include <pkgconf/hal.h>
#include <pkgconf/kernel.h>
#include <pkgconf/io_fileio.h>

#include <cyg/kernel/ktypes.h>         // base kernel types
#include <cyg/infra/cyg_trac.h>        // tracing macros
#include <cyg/infra/cyg_ass.h>         // assertion macros

#include <string.h>                    // string functions
#include <dirent.h>

#include "fio.h"                       // Private header

#include <cyg/kernel/mutex.hxx>        // mutex definitions

//==========================================================================
// Implement filesystem locking protocol. 

#define LOCK_FS( _mte_ ) cyg_fs_lock( _mte_, (_mte_)->fs->syncmode)

#define UNLOCK_FS( _mte_ ) cyg_fs_unlock( _mte_, (_mte_)->fs->syncmode)

//==========================================================================
// A local strcpy clone that returns a pointer to the end of the copied
// string, not the beginning.

static char *my_strcpy( char *s1, const char *s2 )
{
    while( (*s1++ = *s2++) != 0);
    return s1-1;
}

//==========================================================================
// Compare a pathname fragment with an element in a pathname. This
// deals with zero or separator termination and avoids substring
// matches.

static int pathcmp( const char *path, const char *name )
{
    while( *path == *name && *path != '\0' )
        path++, name++;
    if( *name != '\0' ) return false;
    if( *path == '/' || *path == '\0' ) return true;
    return false;
}

//==========================================================================
// CWD support

#ifdef CYGPKG_IO_FILEIO_TRACK_CWD

// buffer for storing CWD path
static char cwd[PATH_MAX];
static size_t cwd_size = 0;


static void update_cwd( cyg_mtab_entry *mte, cyg_dir dir, const char *path )
{
    char *p = cwd;

    if( mte != cdir_mtab_entry || dir != cdir_dir )
    {
        // Here, the path is relative to the root of the filesystem,
        // or in a totally new filesystem, initialize the cwd with the
        // mount point name of the filesystem.

        p = my_strcpy( p, mte->name );
    }
    else p = cwd+cwd_size;

    // We must now copy the path into the cwd buffer while dealing
    // with any "." and ".."  components textually.

    while( *path != '\0' )
    {
        // skip any stray directory separators.
        if( *path == '/' ) path++;

        // Look for a "." entry and just ignore it.
        if( pathcmp( path, "." ) )
        {
            path++;
            continue;
        }

        // Look for a ".." entry. If found, chew off the last cwd
        // entry.
        if( pathcmp( path, ".." ) )
        {
            while( *(--p) != '/' );     // back up to last '/'
            path += 2;                  // skip "..".
            continue;
        }

        // Otherwise just copy the name fragment over to the cwd.

        if( *(p-1) != '/' )
            *p++ = '/';        // add a directory separator
        while( *path != '/' && *path != '\0' )
            *p++ = *path++;

    }

    // Zero terminate the cwd.
    *p = '\0';
    
    // update size
    cwd_size = p-cwd;
}

#else

static Cyg_Mutex getcwd_lock CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO);

#endif


//==========================================================================
// Open a file

__externC int open( const char *path, int oflag, ... )
{
    FILEIO_ENTRY();

    CYG_CANCELLATION_POINT;

    int ret = 0;
    int fd;
    cyg_file *file;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    fd = cyg_fd_alloc(0);

    if( fd < 0 )
        FILEIO_RETURN(EMFILE);
    
    file = cyg_file_alloc();

    if( file == NULL )
    {
        cyg_fd_free(fd);
        FILEIO_RETURN(ENFILE);
    }
    
    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
    {
        cyg_fd_free(fd);
        cyg_file_free(file);
        FILEIO_RETURN(ENOENT);
    }

    LOCK_FS( mte );
    
    ret = mte->fs->open( mte, dir, name, oflag, file );
    
    UNLOCK_FS( mte );
    
    if( 0 != ret )
    {
        cyg_fd_free(fd);
        cyg_file_free(file);
        FILEIO_RETURN(ret);
    }

    file->f_mte = mte;
    file->f_syncmode = mte->fs->syncmode;
    
    cyg_fd_assign( fd, file );

    FILEIO_RETURN_VALUE(fd);
}

//==========================================================================
// create a file

__externC int creat( const char *path, mode_t mode )
{
    return open( path, O_WRONLY | O_CREAT | O_TRUNC, mode );
}


//==========================================================================
// Unlink/remove a file

__externC int unlink( const char *path )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    LOCK_FS( mte );
        
    ret = mte->fs->unlink( mte, dir, name );
    
    UNLOCK_FS( mte );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Make a directory

__externC int mkdir( const char *path, mode_t mode )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    mode=mode;
    
    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    LOCK_FS( mte );
    
    ret = mte->fs->mkdir( mte, dir, name );
    
    UNLOCK_FS( mte );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Remove a directory

__externC int rmdir( const char *path )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    LOCK_FS( mte );
    
    ret = mte->fs->rmdir( mte, dir, name );
    
    UNLOCK_FS( mte );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Rename a file

__externC int rename( const char *path1, const char *path2 )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte1 = cdir_mtab_entry;
    cyg_mtab_entry *mte2 = cdir_mtab_entry;
    cyg_dir dir1 = cdir_dir;
    cyg_dir dir2 = cdir_dir;
    const char *name1 = path1;
    const char *name2 = path2;

    ret = cyg_mtab_lookup( &dir1, &name1, &mte1 );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    ret = cyg_mtab_lookup( &dir2, &name2, &mte2 );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    // Cannot rename between different filesystems
    if( mte1 != mte2 )
        FILEIO_RETURN(EXDEV);

    LOCK_FS( mte1 );
    
    ret = mte1->fs->rename( mte1, dir1, name1, dir2, name2 );

    UNLOCK_FS( mte1 );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Create a link from an existing file (path1) to a new one (path2)

__externC int link( const char *path1, const char *path2 )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte1 = cdir_mtab_entry;
    cyg_mtab_entry *mte2 = cdir_mtab_entry;
    cyg_dir dir1 = cdir_dir;
    cyg_dir dir2 = cdir_dir;
    const char *name1 = path1;
    const char *name2 = path2;

    ret = cyg_mtab_lookup( &dir1, &name1, &mte1 );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    ret = cyg_mtab_lookup( &dir2, &name2, &mte2 );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    // Cannot hard-link between different filesystems
    if( mte1 != mte2 )
        FILEIO_RETURN(EXDEV);

    LOCK_FS( mte1 );
    
    ret = mte1->fs->link( mte1, dir1, name1, dir2, name2, CYG_FSLINK_HARD );

    UNLOCK_FS( mte1 );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Change current directory

__externC int chdir( const char *path )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    cyg_dir newdir;
    const char *name = path;

    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    LOCK_FS(mte);
    
    ret = mte->fs->chdir( mte, dir, name, &newdir );

    UNLOCK_FS(mte);
    
    if( 0 != ret )
        FILEIO_RETURN(ret);

#ifdef CYGPKG_IO_FILEIO_TRACK_CWD
    update_cwd( mte, dir, name );
#endif
    
    if( cdir_mtab_entry != NULL )
    {
        // Now detach from current cdir. We call the current directory's
        // chdir routine with a NULL dir_out pointer.

        LOCK_FS(cdir_mtab_entry);

        ret = cdir_mtab_entry->fs->chdir( cdir_mtab_entry, cdir_dir, NULL, NULL );
    
        UNLOCK_FS(cdir_mtab_entry);

        // We really shouldn't get an error here.
        if( 0 != ret )
            FILEIO_RETURN(ret);
    }
    
    cdir_mtab_entry = mte;
    cdir_dir = newdir;
    
    FILEIO_RETURN(ENOERR);
}

//==========================================================================
// Get file statistics

__externC int stat( const char *path, struct stat *buf )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    LOCK_FS( mte );
    
    ret = mte->fs->stat( mte, dir, name, buf );
    
    UNLOCK_FS( mte );
    
    FILEIO_RETURN(ret);
}

//==========================================================================
// Get file configurable pathname variables

__externC long pathconf( const char *path, int vname )
{
    FILEIO_ENTRY();
    
    int ret = 0;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    const char *name = path;

    ret = cyg_mtab_lookup( &dir, &name, &mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ENOENT);

    struct cyg_pathconf_info info;

    info.name = vname;
    info.value = 0;
        
    LOCK_FS( mte );
    
    ret = mte->fs->getinfo( mte, dir, name,
                            FS_INFO_CONF, (char *)&info, sizeof(info) );
    
    UNLOCK_FS( mte );
    
    if( 0 != ret )
        FILEIO_RETURN(ret);

    FILEIO_RETURN_VALUE(info.value);
}

//==========================================================================
// Access() function.
// This simply piggybacks onto stat().

extern int 	access(const char *path, int amode)
{
    FILEIO_ENTRY();

    int ret;
    struct stat buf;
    
    ret = stat( path, &buf );

    // Translate not found into EACCES if the F_OK bit is
    // set.
    if( (amode & F_OK) && (ret < 0) && (errno == ENOENT) )
        FILEIO_RETURN(EACCES);

    // All other errors go straight back to the user.
    if( ret < 0 )
        FILEIO_RETURN_VALUE(ret);

    // At present we do not have any access modes, so there is nothing
    // to test.  Just return success for all access modes.
    
    FILEIO_RETURN(ENOERR);
}

//==========================================================================
// getcwd()

__externC char *getcwd( char *buf, size_t size )
{
    FILEIO_ENTRY();

    int err = ENOERR;
    cyg_mtab_entry *mte = cdir_mtab_entry;
    cyg_dir dir = cdir_dir;
    cyg_getcwd_info info;

    if( size == 0 )
    {
        errno = EINVAL;
        FILEIO_RETURN_VALUE(NULL);        
    }
        
    info.buf = buf;
    info.size = size;

    LOCK_FS( mte );
    
    err = mte->fs->getinfo( mte, dir, "",
                            FS_INFO_GETCWD, (char *)&info, sizeof(info) );
    
    UNLOCK_FS( mte );

    if( err == ENOERR )
        FILEIO_RETURN_VALUE(buf);

    // Attempting to use filesystem support for getcwd() has
    // failed.

#ifdef CYGPKG_IO_FILEIO_TRACK_CWD

    // If this option is set, the current directory path has been
    // tracked in chdir(). Just report that value here.
    
    if( size < cwd_size+1 )
    {
        errno = ERANGE;
        FILEIO_RETURN_VALUE(NULL);        
    }

    char *p = my_strcpy( buf, cwd );
    *p = '\0';

#else

    // As a fallback we try to use ".." entries in the directory tree
    // to climb back up to the root.  Because we cannot assume that
    // any filesystem can handle more than one directory pointer we
    // have to do the climbing textually, by manufacturing a path name
    // consisting of ".."s. At each level we then scan the parent
    // directory looking for the entry for the lower level directory
    // by matching st_ino values. This is not guaranteed to work at
    // all since there is no requirement on filesystems to support "."
    // and "..", or for them to report distinct inode values in
    // stat().

    static char ddbuf[PATH_MAX];
    char *p = buf+size-1;
    int ddbufpos;

    // Claim lock to serialize use of ddbuf.
    getcwd_lock.lock();

    // Initialize ddbuf with ".".
    ddbuf[0] = '.';
    ddbuf[1] = '\0';
    ddbufpos = 1;

    // Start result buffer with a zero terminator. We accumulate the
    // path name in the top end of the result buffer.
    *p = '\0';
    
    for(;;)
    {
        struct stat sdbuf;
        struct stat sddbuf;

        // Get status for "." and "..". If the filesystem does not
        // support these, then this whole function will fail here.
        
        err = stat( ddbuf, &sdbuf );
        if( err < 0 ) break;

        ddbuf[ddbufpos++] = '/';
        ddbuf[ddbufpos++] = '.';
        ddbuf[ddbufpos++] = '.';
        ddbuf[ddbufpos] = '\0';
        
        err = stat( ddbuf, &sddbuf );
        if( err < 0 ) break;

        // See whether we are at the root. This will be true when
        // the inode numbers of "." and ".." are the same.
        if( sdbuf.st_ino == sddbuf.st_ino )
            break;

        // We now need to find an entry in the ".." directory that
        // matches the inode number of ".".

        struct dirent de;
        DIR *d = opendir( ddbuf );
        if( d == NULL )
        {
            err = -1;
            break;
        }
        
        for(;;)
        {
            struct dirent *res;
            struct stat objstat;
            int i;
            
            err = readdir_r( d, &de, &res );
            if( err < 0 || res == NULL ) break;

            // Skip "." and ".." entries.
            if( pathcmp( de.d_name, "." ) || pathcmp( de.d_name, ".." ) )
                continue;
            
            // Tack the name of the directory entry on to the ddbuf
            // and stat the object.
            
            ddbuf[ddbufpos] = '/';
            for( i = 0; de.d_name[i] != '\0'; i++ )
                ddbuf[ddbufpos+i+1] = de.d_name[i];
            ddbuf[ddbufpos+i+1] = '\0';

            // Take a look at it
            err = stat( ddbuf, &objstat );
            if( err < 0 ) break;

            // Cast out directories
            if( !S_ISDIR(objstat.st_mode) )
                continue;

            // We have a directory. Compare its inode with that of "."
            // and if they are the same, we have found our entry.

            if( sdbuf.st_ino == objstat.st_ino )
                break;
        }

        ddbuf[ddbufpos] = '\0'; // reterminate ddbuf
        
        closedir( d );

        // Halt on any errors.
        if( err < 0 )
            break;

        // Here de contains the name of the directory entry in ".."
        // that has the same inode as ".". Add the name to the path we
        // are accumulating in the buffer.

        char *q = de.d_name;
        while( *q != '\0' ) q++;        // skip to end of name

        do
        {
            *--p = *--q;
        } while( q != de.d_name );

        *--p = '/';                     // add a separator
    }

    // We have finished using ddbuf now.
    getcwd_lock.unlock();
    
    if( err < 0 )
        FILEIO_RETURN_VALUE(NULL);

    // We have the directory path in the top end of the buffer.  Add
    // the mount point name at the beginning and copy the rest of the
    // name down.

    char *bp = buf;
    
    bp = my_strcpy( bp, mte->name );

    // Sort out the separators between the mount name and the
    // pathname.  This is a bit messy since we have to deal with mount
    // names of both "/" and "/foo" and pathnames that start with '/'
    // or are empty.
    if( *(bp-1) != '/' && *p != '\0' ) *bp++ = '/';
    if( *p == '/' ) p++;

    // Now copy the path over.
    while( *p )
        *bp++ = *p++;

    *bp = '\0';                         // Terminate the string

    // All done!
    
#endif
    
    FILEIO_RETURN_VALUE(buf);
}

// -------------------------------------------------------------------------
// EOF file.cxx