#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/iosupport.h>
#include <sys/errno.h>
#include <fcntl.h>
#include <ogcsys.h>
#include <new>
#include "ramdisk.h"

#define NAMELENMAX  0x80
#define MAXPATHLEN  0x100




class RAMDISK_PARTITION;
class RAMDISK_LINK_ENTRY;
class RAMDISK_DIR_ENTRY;
class RAMDISK_FILE_ENTRY;
class RAMDISK_BASE_ENTRY
{
    public:
        RAMDISK_BASE_ENTRY( const char *Name, RAMDISK_DIR_ENTRY *Parent );
        virtual ~RAMDISK_BASE_ENTRY();
        void Rename( const char *Name );
        RAMDISK_LINK_ENTRY *IsLink();
        RAMDISK_DIR_ENTRY *IsDir();
        RAMDISK_FILE_ENTRY *IsFile();
        RAMDISK_PARTITION *GetPartition();
        char *name;
        RAMDISK_DIR_ENTRY *parent;
        RAMDISK_BASE_ENTRY *next;
};
class RAMDISK_LINK_ENTRY : public RAMDISK_BASE_ENTRY
{
    public:
        RAMDISK_LINK_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent, RAMDISK_BASE_ENTRY *Link );
        RAMDISK_BASE_ENTRY *link;
};
class RAMDISK_DIR_ENTRY : public RAMDISK_BASE_ENTRY
{
    public:
        RAMDISK_DIR_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent );
        ~RAMDISK_DIR_ENTRY();
        RAMDISK_BASE_ENTRY *FindEntry( const char* Path );
        RAMDISK_FILE_ENTRY *CreateFile( const char *Filename );
        RAMDISK_DIR_ENTRY *CreateDir( const char *Filename );
        void RemoveEntry( RAMDISK_BASE_ENTRY *Entry );
        RAMDISK_BASE_ENTRY *first;
        RAMDISK_BASE_ENTRY *last;
};
typedef struct
{
    RAMDISK_DIR_ENTRY *dir;
    RAMDISK_BASE_ENTRY *current_entry;
} DIR_STRUCT;


class RAMDISK_PARTITION : public RAMDISK_DIR_ENTRY
{
    public:
        RAMDISK_PARTITION( const char *Mountpoint, bool AutoMount );
        RAMDISK_BASE_ENTRY *FindEntry( const char* Path );
        RAMDISK_DIR_ENTRY *FindPath( const char* Path, const char **Basename = NULL );
        RAMDISK_DIR_ENTRY *cwd;
        bool automount;
};

class FILE_DATA
{
    public:
        FILE_DATA( size_t Len );
        ~FILE_DATA();
        u8 *data;
        size_t len;
        FILE_DATA *next;
};
typedef struct
{
    RAMDISK_FILE_ENTRY *file;
    bool isLink;
    u32 current_pos;
    bool read;
    bool write;
} FILE_STRUCT;
class RAMDISK_FILE_ENTRY : public RAMDISK_BASE_ENTRY
{
    public:
        RAMDISK_FILE_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent );
        ~RAMDISK_FILE_ENTRY();
        bool Truncate( size_t newLen );
        bool AddCluster( size_t size );
        size_t Read( struct _reent *r, FILE_STRUCT *fileStruct, char *ptr, size_t len );
        size_t Write( struct _reent *r, FILE_STRUCT *fileStruct, const char *ptr, size_t len );
        size_t      file_len;
        size_t      cluster_len;
        FILE_DATA *first_cluster;
        FILE_DATA *last_cluster;
};

RAMDISK_LINK_ENTRY::RAMDISK_LINK_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent, RAMDISK_BASE_ENTRY *Link )
        :
        RAMDISK_BASE_ENTRY( Name, Parent ),
        link( Link )
{

}


RAMDISK_BASE_ENTRY::RAMDISK_BASE_ENTRY( const char *Name, RAMDISK_DIR_ENTRY *Parent )
        :
        name( strdup( Name ) ),
        parent( Parent ),
        next( NULL )
{}
RAMDISK_BASE_ENTRY::~RAMDISK_BASE_ENTRY()
{
    free( name );
    if ( parent ) parent->RemoveEntry( this );
}
void RAMDISK_BASE_ENTRY::Rename( const char *Name )
{
    free( name );
    name = strdup( Name );
}

inline RAMDISK_LINK_ENTRY *RAMDISK_BASE_ENTRY::IsLink()
{
    return dynamic_cast<RAMDISK_LINK_ENTRY*>( this );
}
inline RAMDISK_DIR_ENTRY *RAMDISK_BASE_ENTRY::IsDir()
{
    RAMDISK_LINK_ENTRY *lentry = dynamic_cast<RAMDISK_LINK_ENTRY*>( this );
    return dynamic_cast<RAMDISK_DIR_ENTRY*>( lentry ? lentry->link : this );
}
inline RAMDISK_FILE_ENTRY *RAMDISK_BASE_ENTRY::IsFile()
{
    RAMDISK_LINK_ENTRY *lentry = dynamic_cast<RAMDISK_LINK_ENTRY*>( this );
    return dynamic_cast<RAMDISK_FILE_ENTRY*>( lentry ? lentry->link : this );
}
RAMDISK_PARTITION *RAMDISK_BASE_ENTRY::GetPartition()
{
    for ( RAMDISK_BASE_ENTRY *entry = this; entry; entry = entry->parent )
        if ( entry->parent == NULL )
            return dynamic_cast<RAMDISK_PARTITION *>( entry );
    return NULL;
}


RAMDISK_DIR_ENTRY::RAMDISK_DIR_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent )
        :
        RAMDISK_BASE_ENTRY( Name, Parent )
{
    RAMDISK_BASE_ENTRY* entry = new RAMDISK_LINK_ENTRY( ".", this, this );
    first = entry;
    last = entry;
    if ( parent )
    {
        entry = new RAMDISK_LINK_ENTRY( "..", this, parent );
        first->next = entry;
        last = entry;
    }
}
RAMDISK_DIR_ENTRY::~RAMDISK_DIR_ENTRY()
{
    while ( first )
    {
        first->parent = NULL; // ~RAMDISK_BASE_ENTRY() no calls RemoveEntry()
        RAMDISK_BASE_ENTRY* next = first->next;
        delete first;
        first = next;
    }
}

RAMDISK_BASE_ENTRY *RAMDISK_DIR_ENTRY::FindEntry( const char* Path )
{
    const char* dirpath = Path;
    const char* cptr;
    while ( dirpath[0] == '/' ) dirpath++;  // move past leading '/'

    if ( dirpath[0] == '\0' )                   // this path is found
        return this;

    cptr = strchr( dirpath, '/' );          // find next '/'
    if ( cptr == NULL )
        cptr = strchr( dirpath, '\0' );         // cptr at end
    for ( RAMDISK_BASE_ENTRY *curr = first; curr; curr = curr->next )
    {
        if ( strncmp( curr->name, dirpath, cptr - dirpath ) == 0 )
        {
            if ( RAMDISK_DIR_ENTRY *dir = curr->IsDir() )
                return dir->FindEntry( cptr );
            else
                return curr;
        }
    }

    return NULL;
}
RAMDISK_FILE_ENTRY *RAMDISK_DIR_ENTRY::CreateFile( const char *Filename )
{
    try
    {
        RAMDISK_FILE_ENTRY* file = new RAMDISK_FILE_ENTRY( Filename, this );
        if ( !first ) first = file;
        last->next = file;
        last = file;
        return file;
    }
    catch ( ... ) { return NULL; }
}
RAMDISK_DIR_ENTRY *RAMDISK_DIR_ENTRY::CreateDir( const char *Filename )
{
    try
    {
        RAMDISK_DIR_ENTRY* dir = new RAMDISK_DIR_ENTRY( Filename, this );
        if ( !first ) first = dir;
        last->next = dir;
        last = dir;
        return dir;
    }
    catch ( ... ) { return NULL; }
}
void RAMDISK_DIR_ENTRY::RemoveEntry( RAMDISK_BASE_ENTRY *Entry )
{
    RAMDISK_BASE_ENTRY **p_last = NULL;
    for ( RAMDISK_BASE_ENTRY **curr = &first; *curr; curr = &( ( *curr )->next ) )
    {
        if ( *curr == Entry )
        {
            *curr = Entry->next;
            if ( Entry->next == NULL ) // entry is last
                last = *p_last;
            break;
        }
        p_last = curr;
    }
}

RAMDISK_PARTITION::RAMDISK_PARTITION( const char *Mountpoint, bool AutoMount ) :
        RAMDISK_DIR_ENTRY( Mountpoint, NULL ),
        cwd( this ),
        automount( AutoMount )
{
}

RAMDISK_BASE_ENTRY * RAMDISK_PARTITION::FindEntry( const char* path )
{
    char *cptr;
    if ( ( cptr = strchr( path, ':' ) ) )
        path = cptr + 1;        //move path past any device names
    if ( strchr( path, ':' ) != NULL )
    {
//      r->_errno = EINVAL;
        return NULL;
    }
    if ( *path == '/' )                                             // if first character is '/' use absolute root path
        return RAMDISK_DIR_ENTRY::FindEntry( path );
    else                                                                // else use current working dir
        return cwd->FindEntry( path );
}
RAMDISK_DIR_ENTRY * RAMDISK_PARTITION::FindPath( const char* path, const char **basename )
{
    int pathLen = strlen( path );
    char dirfilename[pathLen+1];                    // to hold a full path
    const char *cptr = path + pathLen;              // find the end...
    const char *filename = NULL;                    // to hold filename
    while ( cptr-- > path )                         //search till start
    {
        if ( ( *cptr == '/' ) || ( *cptr == ':' ) )     // split at either / or : (whichever comes first form the end!)
        {
            cptr++;
            strlcpy( dirfilename, path, 1 + cptr - path );    //copy string up till and including / or :
            filename = cptr;                                    //filename = now remainder of string
            break;
        }
    }

    if ( !filename )
    {
        filename        = path;             //filename = complete path
        dirfilename[0]  = 0;                //make directory path ""
    }
    RAMDISK_BASE_ENTRY *entry = FindEntry( dirfilename );
    if ( entry )
    {
        if ( basename ) *basename = filename;
        return entry->IsDir();
    }
    return NULL;
}


FILE_DATA::FILE_DATA( size_t Len ) :
        next( NULL )
{
    data = new u8[Len];
    len = Len;
    memset( data, 0, len );
}
FILE_DATA::~FILE_DATA()
{
    delete [] data;
    delete next;
}


RAMDISK_FILE_ENTRY::RAMDISK_FILE_ENTRY( const char* Name, RAMDISK_DIR_ENTRY *Parent )
        :
        RAMDISK_BASE_ENTRY( Name, Parent ),
        file_len( 0 ),
        cluster_len( 0 ),
        first_cluster( NULL ),
        last_cluster( NULL )
{}
RAMDISK_FILE_ENTRY::~RAMDISK_FILE_ENTRY()
{
    Truncate( 0 );
}
#define CLUSTER_SIZE 4*1024

bool RAMDISK_FILE_ENTRY::Truncate( size_t newSize )
{
    if ( newSize > cluster_len )
    {
        // Expanding the file over cluster_len
        return AddCluster( newSize - cluster_len );
    }
    else if ( newSize < file_len )
    {
        // Shrinking the file
        FILE_DATA *prev_cluster = NULL;
        size_t len = 0;
        for ( FILE_DATA **p_cluster = &first_cluster; *p_cluster; p_cluster = &( *p_cluster )->next )
        {
            if ( len >= newSize )
            {
                last_cluster = prev_cluster;
                delete *p_cluster;
                ( *p_cluster ) = NULL;
                break;
            }
            len += ( *p_cluster )->len;
            prev_cluster = *p_cluster;
        }
    }
    file_len = newSize;
    return true;
}



bool RAMDISK_FILE_ENTRY::AddCluster( size_t len )
{
    if ( len < CLUSTER_SIZE )
        len = CLUSTER_SIZE;
    try
    {
        *( last_cluster ? &last_cluster->next : &first_cluster ) = last_cluster = new FILE_DATA( len );
        cluster_len += len;
        return true;
    }
    catch ( ... ) { return false; }
}

size_t RAMDISK_FILE_ENTRY::Read( struct _reent *r, FILE_STRUCT *fileStruct, char *ptr, size_t len )
{
    if ( !fileStruct->read )
    {
        r->_errno = EBADF;
        return 0;
    }
    // Short circuit cases where len is 0 (or less)
    if ( len <= 0 )
        return 0;
    // Don't try to read if the read pointer is past the end of file
    if ( fileStruct->current_pos >= file_len )
    {
        r->_errno = EOVERFLOW;
        return 0;
    }

    // Don't read past end of file
    if ( len + fileStruct->current_pos > file_len )
    {
        r->_errno = EOVERFLOW;
        len = fileStruct->current_pos - file_len;
    }

    off_t pos = fileStruct->current_pos;
    size_t readed = 0;
    size_t max_len = file_len;
    for ( FILE_DATA *cluster = first_cluster; cluster; cluster = cluster->next )
    {
        if ( pos > cluster->len )
        {
            pos     -= cluster->len;
            max_len -= cluster->len;
        }
        else
        {
            size_t read = max_len;
            if ( read > cluster->len )
                read = cluster->len;
            read -= pos;
            if ( read > len )
                read = len;
            memcpy( ptr, &( cluster->data[pos] ), read );
            readed += read;
            ptr += read;
            len -= read;
            if ( len == 0 )
                break;
            pos     -= cluster->len;
            max_len -= cluster->len;

        }
    }
    fileStruct->current_pos += readed;
    return readed;
}
size_t RAMDISK_FILE_ENTRY::Write( struct _reent *r, FILE_STRUCT *fileStruct, const char *ptr, size_t len )
{

    if ( !fileStruct->write )
    {
        r->_errno = EBADF;
        return 0;
    }
    // Short circuit cases where len is 0 (or less)
    if ( len <= 0 )
        return 0;

    off_t pos = fileStruct->current_pos;
    if ( cluster_len < ( pos + len ) && !AddCluster( ( pos + len ) - cluster_len ) )
    {
        // Couldn't get a cluster, so abort
        r->_errno = ENOSPC;
        return 0;
    }
    if ( file_len < ( pos + len ) )
        file_len = ( pos + len );

    size_t written = 0;
    size_t max_len = cluster_len;
    for ( FILE_DATA *cluster = first_cluster; cluster; cluster = cluster->next )
    {
        if ( pos > cluster->len )
        {
            pos     -= cluster->len;
            max_len -= cluster->len;
        }
        else
        {
            size_t write = cluster->len - pos;
            if ( write > len ) write = len;
            memcpy( &( cluster->data[pos] ), ptr, write );
            written += write;
            ptr += write;
            len -= write;
            if ( len == 0 )
                break;
            pos     -= cluster->len;
            max_len -= cluster->len;
        }
    }
    fileStruct->current_pos += written;
    return written;
}


static int ramdiskFS_open_r( struct _reent *r, void *fileStruct, const char *path, int flags, int mode );
static int ramdiskFS_close_r( struct _reent *r, int fd );
static int ramdiskFS_write_r( struct _reent *r, int fd, const char *ptr, size_t len );
static int ramdiskFS_read_r( struct _reent *r, int fd, char *ptr, size_t len );
static off_t ramdiskFS_seek_r( struct _reent *r, int fd, off_t pos, int dir );
static int ramdiskFS_fstat_r( struct _reent *r, int fd, struct stat *st );
static int ramdiskFS_stat_r( struct _reent *r, const char *file, struct stat *st );
static int ramdiskFS_unlink_r( struct _reent *r, const char *name );
static int ramdiskFS_chdir_r( struct _reent *r, const char *name );
static int ramdiskFS_mkdir_r( struct _reent *r, const char *path, int mode );

static DIR_ITER* ramdiskFS_diropen_r( struct _reent *r, DIR_ITER *dirState, const char *path );
static int ramdiskFS_dirreset_r( struct _reent *r, DIR_ITER *dirState );
static int ramdiskFS_dirnext_r( struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *st );
static int ramdiskFS_dirclose_r( struct _reent *r, DIR_ITER *dirState );

static int ramdiskFS_ftruncate_r( struct _reent *r, int fd, off_t len );


static devoptab_t ramdiskFS_devoptab =
{
    "ramdisk",
    sizeof( FILE_STRUCT ),          //  int structSize;
    &ramdiskFS_open_r,              //  int (*open_r)(struct _reent *r, void *fileStruct, const char *path,int
    //      flags,int mode);
    &ramdiskFS_close_r,             //  int (*close_r)(struct _reent *r, int fd);
    &ramdiskFS_write_r,             //  int (*write_r)(struct _reent *r, int fd, const char *ptr, int len);
    &ramdiskFS_read_r,              //  int (*read_r)(struct _reent *r, int fd, char *ptr, int len);
    &ramdiskFS_seek_r,              //  off_t (*seek_r)(struct _reent *r, off_t fd, int pos, int dir);
    &ramdiskFS_fstat_r,             //  int (*fstat_r)(struct _reent *r, int fd, struct stat *st);
    &ramdiskFS_stat_r,              //  int (*stat_r)(struct _reent *r, const char *file, struct stat *st);
    NULL,                           //  int (*link_r)(struct _reent *r, const char *existing, const char  *newLink);
    &ramdiskFS_unlink_r,                //  int (*unlink_r)(struct _reent *r, const char *name);
    &ramdiskFS_chdir_r,             //  int (*chdir_r)(struct _reent *r, const char *name);
    NULL,                           //  int (*rename_r) (struct _reent *r, const char *oldName, const char *newName);
    ramdiskFS_mkdir_r,              //  int (*mkdir_r) (struct _reent *r, const char *path, int mode);
    sizeof( DIR_STRUCT ),           //  int dirStateSize;
    &ramdiskFS_diropen_r,               //  DIR_ITER* (*diropen_r)(struct _reent *r, DIR_ITER *dirState, const char *path);
    &ramdiskFS_dirreset_r,          //  int (*dirreset_r)(struct _reent *r, DIR_ITER *dirState);
    &ramdiskFS_dirnext_r,               //  int (*dirnext_r)(struct _reent *r, DIR_ITER *dirState, char *filename,
    //      struct stat *filestat);
    &ramdiskFS_dirclose_r,          //  int (*dirclose_r)(struct _reent *r, DIR_ITER *dirState);
    NULL,                           //  statvfs_r
    &ramdiskFS_ftruncate_r,             //  int (*ftruncate_r)(struct _reent *r, int fd, off_t len);

    NULL,                           //  fsync_r,
    NULL                            //  Device data
};

//---------------------------------------------------------------------------------
static inline RAMDISK_PARTITION* ramdiskFS_getPartitionFromPath( const char* path )
{
//---------------------------------------------------------------------------------
    const devoptab_t *devops = GetDeviceOpTab( path );
    if ( !devops )
        return NULL;
    return *( ( RAMDISK_PARTITION** )devops->deviceData );
}

//---------------------------------------------------------------------------------
// File functions
//---------------------------------------------------------------------------------
static int ramdiskFS_open_r( struct _reent *r, void *file_Struct, const char *path, int flags, int mode )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )file_Struct;


    RAMDISK_PARTITION *partition = ramdiskFS_getPartitionFromPath( path );
    if ( partition == NULL )
    {
        r->_errno = ENODEV;
        return -1;
    }

    if ( ( flags & 0x03 ) == O_RDONLY )
    {
        // Open the file for read-only access
        fileStruct->read = true;
        fileStruct->write = false;
    }
    else if ( ( flags & 0x03 ) == O_WRONLY )
    {
        // Open file for write only access
        fileStruct->read = false;
        fileStruct->write = true;
    }
    else if ( ( flags & 0x03 ) == O_RDWR )
    {
        // Open file for read/write access
        fileStruct->read = true;
        fileStruct->write = true;
    }
    else
    {
        r->_errno = EACCES;
        return -1;
    }
    RAMDISK_BASE_ENTRY *entry = partition->FindEntry( path );

    // The file shouldn't exist if we are trying to create it
    if ( entry && ( flags & O_CREAT ) && ( flags & O_EXCL ) )
    {
        r->_errno = EEXIST;
        return -1;
    }
    // It should not be a directory if we're openning a file,
    if ( entry && entry->IsDir() )
    {
        r->_errno = EISDIR;
        return -1;
    }

    fileStruct->isLink = entry ? entry->IsLink() : false;
    fileStruct->file = entry ? entry->IsFile() : NULL;
    if ( !fileStruct->file )                // entry not exists
    {
        if ( flags & O_CREAT )
        {
            const char *filename;
            RAMDISK_DIR_ENTRY *dir = partition->FindPath( path, &filename );
            if ( !dir )
            {
                r->_errno = ENOTDIR;
                return -1;
            }
            fileStruct->file = dir->CreateFile( filename );
        }
        else
        {
            // file doesn't exist, and we aren't creating it
            r->_errno = ENOENT;
            return -1;
        }
    }
    if ( fileStruct->file )
    {
        fileStruct->current_pos = 0;
        // Truncate the file if requested
        if ( ( flags & O_TRUNC ) && fileStruct->write )
            fileStruct->file->Truncate( 0 );
        if ( flags & O_APPEND )
            fileStruct->current_pos = fileStruct->file->file_len;
        return 0;
    }
    r->_errno = ENOENT;
    return( -1 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_close_r( struct _reent *r, int fd )
{
//---------------------------------------------------------------------------------
    return( 0 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_read_r( struct _reent *r, int fd, char *ptr, size_t len )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )fd;
    return fileStruct->file->Read( r, fileStruct, ptr, len );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_write_r( struct _reent *r, int fd, const char *ptr, size_t len )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )fd;
    return fileStruct->file->Write( r, fileStruct, ptr, len );
}

//---------------------------------------------------------------------------------
static off_t ramdiskFS_seek_r( struct _reent *r, int fd, off_t pos, int dir )
{
//---------------------------------------------------------------------------------
    //need check for eof here...
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )fd;

    switch ( dir )
    {
        case SEEK_SET:
            break;
        case SEEK_CUR:
            pos += fileStruct->current_pos;
            break;
        case SEEK_END:
            pos += fileStruct->file->file_len;      // set start to end of file
            break;
        default:
            r->_errno = EINVAL;
            return -1;
    }
    return fileStruct->current_pos = pos;
}

//---------------------------------------------------------------------------------
static int ramdiskFS_fstat_r( struct _reent *r, int fd, struct stat *st )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )fd;

    st->st_mode = fileStruct->isLink ? S_IFLNK : S_IFREG;
    st->st_size = fileStruct->file->file_len;
    return( 0 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_stat_r( struct _reent *r, const char *file, struct stat *st )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT fileStruct;
    DIR_STRUCT dirStruct;
    DIR_ITER dirState;
    dirState.dirStruct = &dirStruct;    //create a temp dirstruct
    int ret;

    if ( ramdiskFS_open_r( r, &fileStruct, file, 0, 0 ) == 0 )
    {
        ret = ramdiskFS_fstat_r( r, ( int ) & fileStruct, st );
        ramdiskFS_close_r( r, ( int )&fileStruct );
        return( ret );
    }
    else if ( ( ramdiskFS_diropen_r( r, &dirState, file ) != NULL ) )
    {
        st->st_mode = S_IFDIR;
        ramdiskFS_dirclose_r( r, &dirState );
        return( 0 );
    }
    r->_errno = ENOENT;
    return( -1 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_unlink_r( struct _reent *r, const char *name )
{
//---------------------------------------------------------------------------------
    RAMDISK_PARTITION *partition = ramdiskFS_getPartitionFromPath( name );
    if ( partition == NULL )
    {
        r->_errno = ENODEV;
        return -1;
    }
    RAMDISK_BASE_ENTRY *entry = partition->FindEntry( name );
    if ( !entry )
    {
        r->_errno = ENOENT;
        return -1;
    }

    if ( entry->IsLink() )
    {
        if ( entry->name[0] == '.' && ( entry->name[1] == '\0' || ( entry->name[1] == '.' && entry->name[2] == '\0' ) ) )
        {
            r->_errno = EPERM;
            return -1;
        }
        delete entry;
        return 0;
    }

    if ( RAMDISK_DIR_ENTRY *dir = entry->IsDir() )
    {
        for ( RAMDISK_BASE_ENTRY *entry = dir->first; entry; entry = entry->next )
        {
            if ( !( entry->name[0] == '.' && ( entry->name[1] == '\0'
                                               || ( entry->name[1] == '.' && entry->name[2] == '\0' ) ) ) )
            {
                r->_errno = EPERM;
                return -1;
            }
        }
    }
    delete entry;
    return 0;
}

//---------------------------------------------------------------------------------
static int ramdiskFS_chdir_r( struct _reent *r, const char *name )
{
//---------------------------------------------------------------------------------
    DIR_STRUCT dirStruct;
    DIR_ITER dirState;
    dirState.dirStruct = &dirStruct;
    if ( ( name == NULL ) )
    {
        r->_errno = ENODEV;
        return -1;
    }

    if ( ( ramdiskFS_diropen_r( r, &dirState, name ) == NULL ) )
        return -1;

    RAMDISK_PARTITION *partition = dirStruct.dir->GetPartition();
    if ( partition == NULL )
    {
        r->_errno = ENODEV;
        return -1;
    }
    partition->cwd = dirStruct.dir;
    ramdiskFS_dirclose_r( r, &dirState );
    return 0;
}

//---------------------------------------------------------------------------------
static int ramdiskFS_mkdir_r( struct _reent *r, const char *path, int mode )
{
//---------------------------------------------------------------------------------
    RAMDISK_PARTITION *partition = ramdiskFS_getPartitionFromPath( path );
    if ( partition == NULL )
    {
        r->_errno = ENODEV;
        return -1;
    }
    RAMDISK_BASE_ENTRY *entry = partition->FindEntry( path );
    if ( entry )
    {
        r->_errno = EEXIST;
        return -1;
    }
    const char *filename;
    RAMDISK_DIR_ENTRY *dir = partition->FindPath( path, &filename );
    if ( !dir )
    {
        r->_errno = ENOTDIR;
        return -1;
    }
    dir->CreateDir( filename );
    return 0;
}

//---------------------------------------------------------------------------------
// Directory functions
//---------------------------------------------------------------------------------
static DIR_ITER* ramdiskFS_diropen_r( struct _reent *r, DIR_ITER *dirState, const char *path )
{
//---------------------------------------------------------------------------------

    DIR_STRUCT *dirStruct = ( DIR_STRUCT* )dirState->dirStruct;
    char *cptr;

    RAMDISK_PARTITION *partition = ramdiskFS_getPartitionFromPath( path );
    if ( partition == NULL )
    {
        r->_errno = ENODEV;
        return NULL;
    }

    if ( ( cptr = strchr( path, ':' ) ) )
        path = cptr + 1;        //move path past any device names
    if ( strchr( path, ':' ) != NULL )
    {
        r->_errno = EINVAL;
        return NULL;
    }

    if ( *path == '/' )                 //if first character is '/' use absolute root path
        dirStruct->dir = partition; //first root dir
    else
        dirStruct->dir = partition->cwd;    //else use current working dir

    RAMDISK_BASE_ENTRY *entry = dirStruct->dir->FindEntry( path );
    if ( entry == NULL )
    {
        r->_errno = ENOENT;
        return NULL;
    }
    dirStruct->dir = entry->IsDir();
    if ( dirStruct->dir == NULL )
    {
        r->_errno = ENOTDIR;
        return NULL;
    }
    dirStruct->current_entry = dirStruct->dir->first;
    return dirState;
}

/*Consts containing relative system path strings*/
//reset dir to start of entry selected by dirStruct->cur_dir_id
//---------------------------------------------------------------------------------
static int ramdiskFS_dirreset_r( struct _reent *r, DIR_ITER *dirState )
{
//---------------------------------------------------------------------------------
    DIR_STRUCT *dirStruct = ( DIR_STRUCT* )dirState->dirStruct;
    dirStruct->current_entry = dirStruct->dir->first;
    return( 0 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_dirnext_r( struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *st )
{
//---------------------------------------------------------------------------------
    DIR_STRUCT *dirStruct = ( DIR_STRUCT* )dirState->dirStruct;
//  RAMDISK_BASE_ENTRY **dirStruct = (RAMDISK_BASE_ENTRY**)dirState->dirStruct;

    if ( dirStruct->current_entry )
    {
        strcpy( filename, dirStruct->current_entry->name );
        if ( dirStruct->current_entry->IsDir() )
        {
            if ( st ) st->st_mode = S_IFDIR;
        }
        else
        {
            if ( st ) st->st_mode = 0;
        }
        dirStruct->current_entry = dirStruct->current_entry->next;
        return( 0 );
    }
    r->_errno = ENOENT;
    return( -1 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_dirclose_r( struct _reent *r, DIR_ITER *dirState )
{
//---------------------------------------------------------------------------------
    return( 0 );
}

//---------------------------------------------------------------------------------
static int ramdiskFS_ftruncate_r( struct _reent *r, int fd, off_t len )
{
//---------------------------------------------------------------------------------
    FILE_STRUCT *fileStruct = ( FILE_STRUCT* )fd;

    if ( len < 0 )
    {
        // Trying to truncate to a negative size
        r->_errno = EINVAL;
        return -1;
    }
    /*
        if ((sizeof(len) > 4) && len > (off_t)FILE_MAX_SIZE)
        {
            // Trying to extend the file beyond what supports
            r->_errno = EFBIG;
            return -1;
        }
    */
    if ( !fileStruct->write )
    {
        // Read-only file
        r->_errno = EINVAL;
        return -1;
    }
    if ( fileStruct->file->Truncate( len ) )
        return 0;
    r->_errno = ENOSPC;
    return -1;
}

//---------------------------------------------------------------------------------
void ramdiskFS_Unmount( const char* mountpoint )
{
//---------------------------------------------------------------------------------
    RAMDISK_PARTITION *partition;
    devoptab_t *devops = ( devoptab_t* )GetDeviceOpTab( mountpoint );

    if ( !devops )
        return;

    // Perform a quick check to make sure we're dealing with a ramdiskFS_ controlled device
    if ( devops->open_r != ramdiskFS_devoptab.open_r )
        return;

    if ( RemoveDevice ( mountpoint ) == -1 )
        return;

    partition = *( ( RAMDISK_PARTITION ** )devops->deviceData );
    if ( partition->automount )
        delete partition;
    free ( devops );
}
extern "C" void ramdiskUnmount( const char *mountpoint )
{
    ramdiskFS_Unmount( mountpoint );
}
//---------------------------------------------------------------------------------
int ramdiskFS_Mount( const char *mountpoint, void *handle )
{
//---------------------------------------------------------------------------------
    devoptab_t* devops;
    char* nameCopy;
    RAMDISK_PARTITION** partition;
    char Mountpoint[100];
    char *cptr;

    strlcpy( Mountpoint, mountpoint, sizeof( Mountpoint ) );
    int len = strlen( Mountpoint );
    cptr = strchr( Mountpoint, ':' );
    if ( cptr )
    {
        len = cptr - Mountpoint;
        *++cptr = 0;
    }
    else
        strlcat( Mountpoint, ":", sizeof( Mountpoint ) );
    ramdiskFS_Unmount( Mountpoint );
    if ( handle ) ramdiskFS_Unmount( ( ( RAMDISK_PARTITION* )handle )->name );

    devops = ( devoptab_t* )malloc( sizeof( devoptab_t ) + sizeof( RAMDISK_PARTITION* ) + len + 1 );
    if ( !devops )
        return false;

    partition = ( RAMDISK_PARTITION** )( devops + 1 );    // Use the space allocated at the end of the devoptab struct
    // for storing the partition
    nameCopy = ( char* )( partition + 1 );          // Use the space allocated at the end of the partition struct
    // for storing the name

    memcpy ( devops, &ramdiskFS_devoptab, sizeof( ramdiskFS_devoptab ) ); // Add an entry for this device to the devoptab table

    strlcpy ( nameCopy, Mountpoint, len + 1 );
    devops->name = nameCopy;

    if ( handle )
    {
        *partition = ( RAMDISK_PARTITION* )handle;
        ( *partition )->Rename( Mountpoint );
    }
    else
        *partition = new RAMDISK_PARTITION( Mountpoint, true );
    devops->deviceData          = partition;

    if ( AddDevice( devops ) < 0 )
    {
        free( devops );
        return false;
    }

    return true;

}
extern "C" int ramdiskMount( const char *mountpoint, void *handle )
{
    return ramdiskFS_Mount( mountpoint, handle );
}
//---------------------------------------------------------------------------------
extern "C" void* ramdiskCreate()
{
//---------------------------------------------------------------------------------
    return new RAMDISK_PARTITION( "", false );
}
//---------------------------------------------------------------------------------
extern "C" void ramdiskDelete( void* Handle )
{
//---------------------------------------------------------------------------------
    RAMDISK_PARTITION *partition = ( RAMDISK_PARTITION* )Handle;
    if ( partition->automount == false )
        ramdiskFS_Unmount( partition->name );
    delete partition;
}