usbloadergx/source/ramdisk/ramdisk.cpp

#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;
}