/*

 * Syborg Host Filesystem pseudo-device

 * Implements a set of syscalls that may look remarkably similar

 * to those used by SymbianOS.

 *

 * Copyright (c) 2009 CodeSourcery

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "hw.h"

#include "syborg.h"

#include "devtree.h"

//#define DEBUG_SYBORG_HOSTFS

#ifdef DEBUG_SYBORG_HOSTFS

#define DPRINTF(fmt, args...) \

do { printf("syborg_hostfs: " fmt , ##args); } while (0)

#define BADF(fmt, args...) \

do { fprintf(stderr, "syborg_hostfs: error: " fmt , ##args); exit(1);} while (0)

#else

#define DPRINTF(fmt, args...) do {} while(0)

#define BADF(fmt, args...) \

do { fprintf(stderr, "syborg_hostfs: error: " fmt , ##args);} while (0)

#endif

#define HOSTFS_PATH_MAX 65536

#ifdef _WIN32

#include <mbstring.h>

#include <wchar.h>

#include <io.h>

typedef wchar_t host_char;

typedef struct _stat host_stat;

typedef struct {

    int handle;

    struct  _wfinddata_t info;

} hostfs_dir;

#else

#include <iconv.h>

#include <langinfo.h>

#include <locale.h>

#include <dirent.h>

#include <fnmatch.h>

typedef char host_char;

typedef struct stat host_stat;

typedef struct {

    DIR *dir;

    char pattern[HOSTFS_PATH_MAX];

    char path[HOSTFS_PATH_MAX];

} hostfs_dir;

#endif

#define HOST_CHAR(var) host_char var[HOSTFS_PATH_MAX]

enum {

    HOSTFS_ID           = 0,

    HOSTFS_COMMAND      = 1,

    HOSTFS_RESULT       = 2,

    HOSTFS_ARG0         = 3,

    HOSTFS_ARG1         = 4,

    HOSTFS_ARG2         = 5,

    HOSTFS_ARG3         = 6

};

typedef struct hostfs_handle_cache {

    int handle;

    int is_fd;

    struct {

        int fd;

        hostfs_dir *d;

    } val;

    struct hostfs_handle_cache *next;

} hostfs_handle_cache;

typedef struct {

    QEMUDevice *qdev;

    uint32_t result;

    uint32_t arg[4];

    uint32_t command;

    char drive_letter;

    host_char *host_prefix;

    int host_prefix_len;

    int last_handle;

    hostfs_handle_cache *handle_cache;

    hostfs_handle_cache *free_handle;

#ifndef _WIN32

    iconv_t iconv_guest_to_host;

    iconv_t iconv_host_to_guest;

#endif

} syborg_hostfs_state;

#define HOSTFS_ATTR_READONLY    0x01

#define HOSTFS_ATTR_HIDDEN      0x02

#define HOSTFS_ATTR_DIRECTORY   0x10

#define HOST_FS_SUCCESS          0          // KErrNone

#define HOST_FS_NOT_FOUND       -1          // KErrNotFound=(-1

#define HOST_FS_GENERAL_ERROR   -2          // KErrGeneral=(-2);

#define HOST_FS_NO_MEMORY       -4          // KErrNoMemory=(-4)

#define HOST_FS_UNSUPPORTED     -5          // KErrNotSupported=(-5) 

#define HOST_FS_BAD_ARG         -6          // KErrArgument=(-6)    

#define HOST_FS_BAD_HANDLE      -8          // KErrBadHandle=(-8)

#define HOST_FS_EXISTS          -11         // KErrAlreadyExists=(-11)

#define HOST_FS_PATH_NOT_FOUND  -12         // KErrPathNotFound=(-12)

#define HOST_FS_IN_USE          -14         // KErrInUse=(-14)

#define HOST_FS_UNKNOWN         -19         // KErrUnknown=(-19)

#define HOST_FS_CORRUPT         -20         // KErrCorrupt=(-20)

#define HOST_FS_ACCESS_DENIED   -21         // KErrAccessDenied=(-21)

#define HOST_FS_LOCKED          -22         // KErrLocked=(-22)

#define HOST_FS_WRITE           -23         // KErrWrite=(-23)

#define HOST_FS_EOF             -25         // KErrEof=(-25)

#define HOST_FS_DISKFULL        -26         // KErrDiskFull=(-26)

#define HOST_FS_BAD_NAME        -28         // KErrBadName=(-28)

#define HOST_FS_ABORT           -39         // KErrAbort=(-39)

#define HOST_FS_TOO_BIG         -40         // KErrTooBig=(-40)

#define HOST_FS_DIR_FULL        -43         // KErrDirFull=(-43)

#define HOST_FS_PERMISSION_DENIED -46       // KErrPermissionDenied=(-46)

static int decode_error(int e)

{

    int r = HOST_FS_GENERAL_ERROR;

    switch (e) {

    case EPERM :                            /* Operation not permitted */

        r = HOST_FS_PERMISSION_DENIED;

        break;

#ifdef ENOFILE

    case ENOFILE :                          /* No such file or directory */

#endif

#ifdef ENOENT

#if !defined(ENOFILE) || (ENOFILE != ENOENT)

        case ENOENT:

#endif

#endif

        r = HOST_FS_PATH_NOT_FOUND;

        break;

    case ESRCH :                            /* No such process */

        r = HOST_FS_NOT_FOUND;

        break;

    case EINTR :                            /* Interrupted function call */

    case EIO :                              /* Input/output error */

    case ENXIO :                            /* No such device or address */

        break;

    case E2BIG :                            /* Arg list too long */

        r = HOST_FS_TOO_BIG;

        break;

    case ENOEXEC :                          /* Exec format error */

        break;

    case EBADF :                            /* Bad file descriptor */

        r = HOST_FS_BAD_ARG;

        break;

    case ECHILD :                           /* No child processes */

        break;

    case EAGAIN :                           /* Resource temporarily unavailable */

        r = HOST_FS_GENERAL_ERROR;

        break;

    case ENOMEM :                           /* Not enough space */

        r = HOST_FS_NO_MEMORY;

        break;

    case EACCES :                           /* Permission denied */

        r = HOST_FS_ACCESS_DENIED;

        break;

    case EFAULT :                           /* Bad address */

        break;

    case 15 :                               /* 15 - Unknown Error */

        r = HOST_FS_UNKNOWN;

        break;

    case EBUSY :                            /* strerror reports "Resource device" */

        r = HOST_FS_IN_USE;

        break;

    case EEXIST :                           /* File exists */

        r = HOST_FS_EXISTS;

        break;

    case EXDEV :                            /* Improper link (cross-device link?) */

        break;

    case ENODEV :                           /* No such device */

        r = HOST_FS_BAD_NAME;

        break;

    case ENOTDIR :                          /* Not a directory */

    case EISDIR :                           /* Is a directory */

    case EINVAL :                           /* Invalid argument */

        r = HOST_FS_BAD_ARG;

        break;

    case ENFILE :                           /* Too many open files in system */

    case EMFILE :                           /* Too many open files */

    case ENOTTY :                           /* Inappropriate I/O control operation */

        break;

    case 26 :                               /* 26 - Unknown Error */

        r = HOST_FS_UNKNOWN;

        break;

    case EFBIG :                            /* File too large */

        r = HOST_FS_TOO_BIG;

        break;

    case ENOSPC :                           /* No space left on device */

        r = HOST_FS_DISKFULL;

        break;

    case ESPIPE :                           /* Invalid seek (seek on a pipe?) */

    case EROFS :                            /* Read-only file system */

    case EMLINK :                           /* Too many links */

    case EPIPE :                            /* Broken pipe */

    case EDOM :                             /* Domain error (math functions) */

    case ERANGE :                           /* Result too large (possibly too small) */

        break;

    case EDEADLK :                          /* Resource deadlock avoided (non-Cyg) */

        break;

    case ENAMETOOLONG :                     /* Filename too long (91 in Cyg?) */

        r = HOST_FS_BAD_NAME;

        break;

    case ENOLCK :                           /* No locks available (46 in Cyg?) */

    case ENOSYS :                           /* Function not implemented (88 in Cyg?) */

        r = HOST_FS_UNSUPPORTED;

        break;

    case ENOTEMPTY :                        /* Directory not empty (90 in Cyg?) */

    case EILSEQ :                           /* Illegal byte sequence */

        break;

    }

    return r;

}

typedef enum hostfs_op {

    EDummy = 0,

    /*  Codes for CMountCB operations */

    EMkDir,

    ERmDir,

    EDelete,

    ERename,

    EReplace,

    EReadUid,

    EEntry,

    ESetEntry,

    EFileOpen,

    EDirOpen,

    /*  Code for CFileCB operations */

    EFileClose, 

    EFileRead,

    EFileWrite,

    EFileSetSize,

    EFileFlush,

    /*  Code for CDirCB operations */

    EDirClose, 

    EDirRead,

} syborg_hostfs_op_t;

static hostfs_handle_cache *get_new_handle(syborg_hostfs_state *s)

{

    hostfs_handle_cache *c;

    if (s->free_handle) {

        c = s->free_handle;

        s->free_handle = c->next;

    } else {

        c = qemu_malloc(sizeof(*c));

        c->handle = ++s->last_handle;

    }

    c->next = s->handle_cache;

    s->handle_cache = c;

    return c;

}

static int add_file_cache_entry(syborg_hostfs_state *s, int fd)

{

    hostfs_handle_cache *c = get_new_handle(s);

    c->is_fd = 1;

    c->val.fd = fd;

    return c->handle;

}

static int add_dir_cache_entry(syborg_hostfs_state *s, hostfs_dir *d)

{

    hostfs_handle_cache *c = get_new_handle(s);

    c->is_fd = 0;

    c->val.d = d;

    return c->handle;

}

static hostfs_handle_cache *get_handle_cache_entry(syborg_hostfs_state *s,

                                                   int handle)

{

    hostfs_handle_cache *c;

    for (c = s->handle_cache; c; c = c->next) {

        if (c->handle == handle)

            return c;

    }

    return NULL;

}

static int get_file_cache_entry(syborg_hostfs_state *s, int handle, int *fd)

{

    hostfs_handle_cache *c = get_handle_cache_entry(s, handle);

    if (!c || !c->is_fd)

        return HOST_FS_BAD_HANDLE;

    *fd = c->val.fd;

    return HOST_FS_SUCCESS;

}

static int get_dir_cache_entry(syborg_hostfs_state *s, int handle, hostfs_dir **d)

{

    hostfs_handle_cache *c = get_handle_cache_entry(s, handle);

    if (!c || c->is_fd)

        return HOST_FS_BAD_HANDLE;

    *d = c->val.d;

    return HOST_FS_SUCCESS;

}

static void remove_handle_cache_entry(syborg_hostfs_state *s, int handle)

{

    hostfs_handle_cache *c;

    hostfs_handle_cache **p;

    p = &s->handle_cache;

    c = *p;

    while (c && c->handle != handle) {

        p = &c->next;

        c = c->next;

    }

    if (!c)

        return;

    *p = c->next;

    c->next = s->free_handle;

    s->free_handle = c;

}

static void remove_file_cache_entry(syborg_hostfs_state *s, int handle)

{

    remove_handle_cache_entry(s, handle);

}

static void remove_dir_cache_entry(syborg_hostfs_state *s, int handle)

{

    remove_handle_cache_entry(s, handle);

}

static int hostfs_get_filename(syborg_hostfs_state *s, host_char *buf,

                               uint32_t addr, uint32_t len)

{

    uint8_t prefix[6];

    if (len < 3)

        return HOST_FS_BAD_NAME;

    cpu_physical_memory_read(addr, prefix, 6);

    if (prefix[1] != 0 || prefix[3] != 0 || prefix[5] != 0

        || qemu_toupper(prefix[0]) != s->drive_letter

        || prefix[2] != ':' || prefix[4] != '\\')

        return HOST_FS_BAD_NAME;

    len -= 3;

    addr += 6;

#ifdef _WIN32

    if (len + s->host_prefix_len >= HOSTFS_PATH_MAX)

        return HOST_FS_BAD_NAME;

    memcpy(buf, s->host_prefix, s->host_prefix_len * 2);

    buf += s->host_prefix_len;

    cpu_physical_memory_read(addr, (void *)buf, len * 2);

    buf[len] = 0;

#else

    uint8_t guest_path[HOSTFS_PATH_MAX];

    char *inp;

    char *outp;

    size_t inbytes;

    size_t outbytes;

    int err;

    if (len >= HOSTFS_PATH_MAX)

        return HOST_FS_BAD_NAME;

    memcpy(buf, s->host_prefix, s->host_prefix_len);

    cpu_physical_memory_read(addr, guest_path, len * 2);

    if (len > 0) {

        inp = (char *)guest_path;

        outp = buf + s->host_prefix_len;

        inbytes = len * 2;

        outbytes = HOSTFS_PATH_MAX - (s->host_prefix_len + 1);

        if (s->host_prefix_len > 0 && buf[s->host_prefix_len - 1] != '/') {

            *(outp++) = '/';

            outbytes--;

        }

        *outp = '/';

        err = iconv(s->iconv_guest_to_host, &inp, &inbytes, &outp, &outbytes);

        if (err < 0)

            return decode_error(errno);

        *outp = 0;

        for (outp = buf; *outp; outp++) {

            if (*outp == '\\')

                *outp = '/';

        }

    }

#endif

    return HOST_FS_SUCCESS;

}

typedef int (*syborg_hostfs_op_fn)(syborg_hostfs_state *);

static int hostfs_unsupported(syborg_hostfs_state *s)

{

    return HOST_FS_UNSUPPORTED;

}

static int hostfs_mkdir(syborg_hostfs_state *s)

{

    HOST_CHAR(name);

    int err;

    err = hostfs_get_filename(s, name, s->arg[0], s->arg[1]);

    if (err)

        return err;

#ifdef _WIN32

    err = _wmkdir(name);

#else

    err = mkdir(name, 0777);

#endif

    if (err < 0)

        return decode_error(errno);

    return HOST_FS_SUCCESS;

}

static int hostfs_rmdir(syborg_hostfs_state *s)

{

    HOST_CHAR(name);

    int err;

    err = hostfs_get_filename(s, name, s->arg[0], s->arg[1]);

    if (err)

        return err;

#ifdef _WIN32

    err = _wrmdir(name);

#else

    err = rmdir(name);

#endif

    if (err < 0)

        return decode_error(errno);

    return HOST_FS_SUCCESS;

}

static int hostfs_delete(syborg_hostfs_state *s)

{

    HOST_CHAR(name);

    int err;

    err = hostfs_get_filename(s, name, s->arg[0], s->arg[1]);

    if (err)

        return err;

#ifdef _WIN32

    err = _wunlink(name);

#else

    err = unlink(name);

#endif

    if (err < 0)

        return decode_error(errno);

    return HOST_FS_SUCCESS;

}

static int hostfs_rename(syborg_hostfs_state *s)

{

    HOST_CHAR(old_name);

    HOST_CHAR(new_name);

    int err;

    err = hostfs_get_filename(s, old_name, s->arg[0], s->arg[1]);

    if (err)

        return err;

    err = hostfs_get_filename(s, new_name, s->arg[2], s->arg[3]);

    if (err)

        return err;

#ifdef _WIN32

    err = _wrename(old_name, new_name);

#else

    err = rename(old_name, new_name);

#endif

    if (err < 0)

        return decode_error(errno);

    return HOST_FS_SUCCESS;

}

static int hostfs_replace(syborg_hostfs_state *s)

{

    HOST_CHAR(old_name);

    HOST_CHAR(new_name);

    int err;

    err = hostfs_get_filename(s, old_name, s->arg[0], s->arg[1]);

    if (err)

        return err;

    err = hostfs_get_filename(s, new_name, s->arg[2], s->arg[3]);

    if (err)

        return err;

#ifdef _WIN32

    if (!_waccess(new_name, F_OK)) {

        if (_wunlink(new_name)) {

            return decode_error(errno);

        }

    }

    err = _wrename(old_name, new_name);

#else

    if (!access(new_name, F_OK)) {

        if (unlink(new_name)) {

            return decode_error(errno);

        }

    }

    err = rename(old_name, new_name);

#endif

    if (err < 0)

        return decode_error(errno);

    return HOST_FS_SUCCESS;

}

static uint32 hostfs_map_file_att(uint32 val)