/*
 * Copyright 2007 The Android Open Source Project
 *
 * Syscall and library intercepts.
 */

/* don't remap open() to open64() */
#undef _FILE_OFFSET_BITS

#define CREATE_FUNC_STORAGE
#include "Common.h"

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <utime.h>
#include <limits.h>
#include <ftw.h>
#include <assert.h>


#if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
#warning "big"
#endif

//#define CALLTRACE(format, ...)   wsLog(format, ##__VA_ARGS__)
#define CALLTRACE(format, ...)   ((void)0)

//#define CALLTRACEV(format, ...)  wsLog(format, ##__VA_ARGS__)
#define CALLTRACEV(format, ...)  ((void)0)

/*
When opening certain files, we need to simulate the contents.  For example,
we can pretend to open the frame buffer, and respond to ioctl()s by
returning fake data or telling the front-end to render new data.

We want to intercept specific files in /dev.  In some cases we want to
intercept and reject, e.g. to indicate that a standard Linux device does
not exist.

Some things we're not going to intercept:
  /etc/... (e.g. /etc/timezone) -- std. Linux version should be okay
  /proc/... (e.g. /proc/stat) -- we're showing real pid, so real proc will work

For the device drivers we need to intercept:

  close(), ioctl(), mmap(), open()/open64(), read(), readv(), write(),
  writev()

May also need stat().  We don't need all fd calls, e.g. fchdir() is
not likely to succeed on a device driver.  The expected uses of mmap()
shouldn't require intercepting related calls like madvise() -- we will
provide an actual mapping of the requested size.  In some cases we will
want to return a "real" fd so the app can poll() or select() on it.


We also need to consider:
  getuid/setuid + variations -- fake out multi-user-id stuff


We also want to translate filenames, effectively performing a "chroot"
without all the baggage that comes with it.  The mapping looks like:

  /system/... --> $ANDROID_PRODUCT_OUT/system/...
  /data/... --> $ANDROID_PRODUCT_OUT/data/...

Translating pathnames requires interception of additional system calls,
substituting a new path.  Calls include:

  access(), chdir(), chmod(), chown(), creat(), execve(), getcwd(),
  lchown(), link(), lstat()/lstat64(), mkdir(), open()/open64(),
  readlink(), rename(), rmdir(), stat()/stat64(), statfs/statfs64(),
  symlink(), unlink(), utimes(),

Possibly also mknod(), mount(), umount().

The "at" family, notably openat(), should just work since the root comes
from an open directory fd.

We also need these libc calls, because LD_LIBRARY_PATH substitutes at
the libc link level, not the syscall layer:

  execl(), execlp(), execle(), execv(), execvp(), fopen(), ftw(), getwd(),
  opendir(), dlopen()

It is possible for the cwd to leak out.  Some possible leaks:
  - /proc/[self]/exe
  - /proc/[self]/cwd
  - LD_LIBRARY_PATH (which may be awkward to work around)


To provide a replacement for the dirent functions -- only required if we
want to show "fake" directory contents -- we would need:

  closedir(), dirfd() readdir(), rewinddir(), scandir(), seekdir(),
  telldir()


*/


/*
 * ===========================================================================
 *      Filename remapping
 * ===========================================================================
 */

/*
 * If appropriate, rewrite the path to point to a different location.
 *
 * Returns either "pathBuf" or "origPath" depending on whether or not we
 * chose to rewrite the path.  "origPath" must be a buffer capable of
 * holding an extended pathname; for best results use PATH_MAX.
 */
static const char* rewritePath(const char* func, char* pathBuf,
    const char* origPath)
{
    /*
     * Rewrite paths that start with "/system/" or "/data/"
     */
    if (origPath[0] != '/')
        goto skip_rewrite;
    while (origPath[1] == '/') origPath++; // some apps like to use paths like '//data/data/....'
    if (memcmp(origPath+1, "system", 6) == 0 &&
        (origPath[7] == '/' || origPath[7] == '\0'))
            goto do_rewrite;
    if (memcmp(origPath+1, "data", 4) == 0 &&
        (origPath[5] == '/' || origPath[5] == '\0'))
            goto do_rewrite;

skip_rewrite:
    /* check to see if something is side-stepping the rewrite */
    if (memcmp(origPath, gWrapSim.remapBaseDir, gWrapSim.remapBaseDirLen) == 0)
    {
        wsLog("NOTE: full path used: %s(%s)\n", func, origPath);
    }

    CALLTRACE("rewrite %s('%s') --> (not rewritten)\n", func, origPath);
    return origPath;

do_rewrite:
    memcpy(pathBuf, gWrapSim.remapBaseDir, gWrapSim.remapBaseDirLen);
    strcpy(pathBuf + gWrapSim.remapBaseDirLen, origPath);
    CALLTRACE("rewrite %s('%s') --> '%s'\n", func, origPath, pathBuf);
    return pathBuf;
}

/*
 * This works if the pathname is the first argument to the function, and
 * the function returns "int".
 */
#define PASS_THROUGH_DECL(_fname, _rtype, ...)                              \
    _rtype _fname( __VA_ARGS__ )
#define PASS_THROUGH_BODY(_fname, _patharg, ...)                            \
    {                                                                       \
        CALLTRACEV("%s(%s)\n", __FUNCTION__, _patharg);                     \
        char pathBuf[PATH_MAX];                                             \
        return _ws_##_fname(rewritePath(#_fname, pathBuf, _patharg),        \
            ##__VA_ARGS__);                                                 \
    }


PASS_THROUGH_DECL(chdir, int, const char* path)
PASS_THROUGH_BODY(chdir, path)

PASS_THROUGH_DECL(chmod, int, const char* path, mode_t mode)
PASS_THROUGH_BODY(chmod, path, mode)

PASS_THROUGH_DECL(chown, int, const char* path, uid_t owner, gid_t group)
PASS_THROUGH_BODY(chown, path, owner, group)

PASS_THROUGH_DECL(creat, int, const char* path, mode_t mode)
PASS_THROUGH_BODY(creat, path, mode)

PASS_THROUGH_DECL(execve, int, const char* path, char* const argv[],
    char* const envp[])
PASS_THROUGH_BODY(execve, path, argv, envp)

PASS_THROUGH_DECL(lchown, int, const char* path, uid_t owner, gid_t group)
PASS_THROUGH_BODY(lchown, path, owner, group)

PASS_THROUGH_DECL(lstat, int, const char* path, struct stat* buf)
PASS_THROUGH_BODY(lstat, path, buf)

PASS_THROUGH_DECL(lstat64, int, const char* path, struct stat* buf)
PASS_THROUGH_BODY(lstat64, path, buf)

PASS_THROUGH_DECL(mkdir, int, const char* path, mode_t mode)
PASS_THROUGH_BODY(mkdir, path, mode)

PASS_THROUGH_DECL(readlink, ssize_t, const char* path, char* buf, size_t bufsiz)
PASS_THROUGH_BODY(readlink, path, buf, bufsiz)

PASS_THROUGH_DECL(rmdir, int, const char* path)
PASS_THROUGH_BODY(rmdir, path)

PASS_THROUGH_DECL(stat, int, const char* path, struct stat* buf)
PASS_THROUGH_BODY(stat, path, buf)

PASS_THROUGH_DECL(stat64, int, const char* path, struct stat* buf)
PASS_THROUGH_BODY(stat64, path, buf)

PASS_THROUGH_DECL(statfs, int, const char* path, struct statfs* buf)
PASS_THROUGH_BODY(statfs, path, buf)

PASS_THROUGH_DECL(statfs64, int, const char* path, struct statfs* buf)
PASS_THROUGH_BODY(statfs64, path, buf)

PASS_THROUGH_DECL(unlink, int, const char* path)
PASS_THROUGH_BODY(unlink, path)

PASS_THROUGH_DECL(utime, int, const char* path, const struct utimbuf* buf)
PASS_THROUGH_BODY(utime, path, buf)

PASS_THROUGH_DECL(utimes, int, const char* path, const struct timeval times[2])
PASS_THROUGH_BODY(utimes, path, times)


PASS_THROUGH_DECL(fopen, FILE*, const char* path, const char* mode)
PASS_THROUGH_BODY(fopen, path, mode)

PASS_THROUGH_DECL(fopen64, FILE*, const char* path, const char* mode)
PASS_THROUGH_BODY(fopen64, path, mode)

PASS_THROUGH_DECL(freopen, FILE*, const char* path, const char* mode,
    FILE* stream)
PASS_THROUGH_BODY(freopen, path, mode, stream)

PASS_THROUGH_DECL(ftw, int, const char* dirpath,
          int (*fn) (const char* fpath, const struct stat* sb, int typeflag),
          int nopenfd)
PASS_THROUGH_BODY(ftw, dirpath, fn, nopenfd)

PASS_THROUGH_DECL(opendir, DIR*, const char* path)
PASS_THROUGH_BODY(opendir, path)

PASS_THROUGH_DECL(dlopen, void*, const char* path, int flag)
PASS_THROUGH_BODY(dlopen, path, flag)

/*
 * Opposite of path translation -- remove prefix.
 *
 * It looks like BSD allows you to pass a NULL value for "buf" to inspire
 * getcwd to allocate storage with malloc() (as an extension to the POSIX
 * definition, which doesn't specify this).  getcwd() is a system call
 * under Linux, so this doesn't work, but that doesn't stop gdb from
 * trying to use it anyway.
 */
char* getcwd(char* buf, size_t size)
{
    CALLTRACEV("%s %p %d\n", __FUNCTION__, buf, size);

    char* result = _ws_getcwd(buf, size);
    if (buf != NULL && result != NULL) {
        if (memcmp(buf, gWrapSim.remapBaseDir,
                    gWrapSim.remapBaseDirLen) == 0)
        {
            memmove(buf, buf + gWrapSim.remapBaseDirLen,
                strlen(buf + gWrapSim.remapBaseDirLen)+1);
            CALLTRACE("rewrite getcwd() -> %s\n", result);
        } else {
            CALLTRACE("not rewriting getcwd(%s)\n", result);
        }
    }
    return result;
}

/*
 * Need to tweak both pathnames.
 */
int link(const char* oldPath, const char* newPath)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf1[PATH_MAX];
    char pathBuf2[PATH_MAX];
    return _ws_link(rewritePath("link-1", pathBuf1, oldPath),
                    rewritePath("link-2", pathBuf2, newPath));
}

/*
 * Need to tweak both pathnames.
 */
int rename(const char* oldPath, const char* newPath)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf1[PATH_MAX];
    char pathBuf2[PATH_MAX];
    return _ws_rename(rewritePath("rename-1", pathBuf1, oldPath),
                      rewritePath("rename-2", pathBuf2, newPath));
}

/*
 * Need to tweak both pathnames.
 */
int symlink(const char* oldPath, const char* newPath)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf1[PATH_MAX];
    char pathBuf2[PATH_MAX];
    return _ws_symlink(rewritePath("symlink-1", pathBuf1, oldPath),
                       rewritePath("symlink-2", pathBuf2, newPath));
}

/*
 * glibc stat turns into this (32-bit).
 */
int __xstat(int version, const char* path, struct stat* sbuf)
{
    CALLTRACEV("%s\n", __FUNCTION__);
    char pathBuf[PATH_MAX];
    return _ws___xstat(version, rewritePath("__xstat", pathBuf, path),
        sbuf);
}

/*
 * glibc stat turns into this (64-bit).
 */
int __xstat64(int version, const char* path, struct stat* sbuf)
{
    CALLTRACEV("%s\n", __FUNCTION__);
    char pathBuf[PATH_MAX];
    return _ws___xstat64(version, rewritePath("__xstat64", pathBuf, path),
        sbuf);
}

/*
 * glibc lstat turns into this (32-bit).
 */
int __lxstat(int version, const char* path, struct stat* sbuf)
{
    CALLTRACEV("%s\n", __FUNCTION__);
    char pathBuf[PATH_MAX];
    return _ws___lxstat(version, rewritePath("__lxstat", pathBuf, path),
        sbuf);
}

/*
 * glibc lstat turns into this (64-bit).
 */
int __lxstat64(int version, const char* path, struct stat* sbuf)
{
    CALLTRACEV("%s\n", __FUNCTION__);
    char pathBuf[PATH_MAX];
    return _ws___lxstat64(version, rewritePath("__lxstat64", pathBuf, path),
        sbuf);
}

/*
 * Copy the argument list out of varargs for execl/execlp/execle.  This
 * leaves the argc value in _argc, and a NULL-terminated array of character
 * pointers in _argv.  We stop at the first NULL argument, so we shouldn't
 * end up copying "envp" out.
 *
 * We could use gcc __builtin_apply_args to just pass stuff through,
 * but that may not get along with the path rewriting.  It's unclear
 * whether we want to rewrite the first argument (i.e. the string that
 * becomes argv[0]); it only makes sense if the exec'ed program is also
 * getting remapped.
 */
#define COPY_EXEC_ARGLIST(_first, _argc, _argv)                             \
    int _argc = 0;                                                          \
    {                                                                       \
        va_list vargs;                                                      \
        va_start(vargs, _first);                                            \
        while (1) {                                                         \
            _argc++;                                                        \
            const char* val = va_arg(vargs, const char*);                   \
            if (val == NULL)                                                \
                break;                                                      \
        }                                                                   \
        va_end(vargs);                                                      \
    }                                                                       \
    const char* _argv[_argc+1];                                             \
    _argv[0] = _first;                                                      \
    {                                                                       \
        va_list vargs;                                                      \
        int i;                                                              \
        va_start(vargs, _first);                                            \
        for (i = 1; i < _argc; i++) {                                       \
            _argv[i] = va_arg(vargs, const char*);                          \
        }                                                                   \
        va_end(vargs);                                                      \
    }                                                                       \
    _argv[_argc] = NULL;

/*
 * Debug dump.
 */
static void dumpExecArgs(const char* callName, const char* path,
    int argc, const char* argv[], char* const envp[])
{
    int i;

    CALLTRACE("Calling %s '%s' (envp=%p)\n", callName, path, envp);
    for (i = 0; i <= argc; i++)
        CALLTRACE("  %d: %s\n", i, argv[i]);
}

/*
 * Extract varargs, convert paths, hand off to execv.
 */
int execl(const char* path, const char* arg, ...)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf[PATH_MAX];

    COPY_EXEC_ARGLIST(arg, argc, argv);
    dumpExecArgs("execl", path, argc, argv, NULL);
    path = rewritePath("execl", pathBuf, path);
    return _ws_execv(path, (char* const*) argv);
}

/*
 * Extract varargs, convert paths, hand off to execve.
 *
 * The execle prototype in the man page isn't valid C -- it shows the
 * "envp" argument after the "...".  We have to pull it out with the rest
 * of the varargs.
 */
int execle(const char* path, const char* arg, ...)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf[PATH_MAX];

    COPY_EXEC_ARGLIST(arg, argc, argv);

    /* run through again and find envp */
    char* const* envp;

    va_list vargs;
    va_start(vargs, arg);
    while (1) {
        const char* val = va_arg(vargs, const char*);
        if (val == NULL) {
            envp = va_arg(vargs, char* const*);
            break;
        }
    }
    va_end(vargs);

    dumpExecArgs("execle", path, argc, argv, envp);
    path = rewritePath("execl", pathBuf, path);

    return _ws_execve(path, (char* const*) argv, envp);
}

/*
 * Extract varargs, convert paths, hand off to execvp.
 */
int execlp(const char* file, const char* arg, ...)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf[PATH_MAX];

    COPY_EXEC_ARGLIST(arg, argc, argv);
    dumpExecArgs("execlp", file, argc, argv, NULL);
    file = rewritePath("execlp", pathBuf, file);
    return _ws_execvp(file, (char* const*) argv);
}

/*
 * Update path, forward to execv.
 */
int execv(const char* path, char* const argv[])
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf[PATH_MAX];

    path = rewritePath("execv", pathBuf, path);
    return _ws_execv(path, argv);
}

/*
 * Shouldn't need to do anything unless they specified a full path to execvp.
 */
int execvp(const char* file, char* const argv[])
{
    CALLTRACEV("%s\n", __FUNCTION__);

    char pathBuf[PATH_MAX];

    file = rewritePath("execvp", pathBuf, file);
    return _ws_execvp(file, argv);
}


/*
 * ===========================================================================
 *      Device fakery
 * ===========================================================================
 */

/*
 * Need to do filesystem translation and show fake devices.
 */
int access(const char* pathName, int mode)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    int status = wsInterceptDeviceAccess(pathName, mode);
    if (status == 0)
        return 0;
    else if (status == -2)
        return -1;          // errno already set
    else {
        char pathBuf[PATH_MAX];
        return _ws_access(rewritePath("access", pathBuf, pathName), mode);
    }
}

/*
 * Common handler for open().
 */
int openCommon(const char* pathName, int flags, mode_t mode)
{
    char pathBuf[PATH_MAX];
    int fd;

    assert(gWrapSim.initialized);

    fd = wsInterceptDeviceOpen(pathName, flags);
    if (fd >= 0) {
        return fd;
    } else if (fd == -2) {
        /* errno should be set */
        return -1;
    }

    if ((flags & O_CREAT) != 0) {
        fd = _ws_open(rewritePath("open", pathBuf, pathName), flags, mode);
        CALLTRACE("open(%s, 0x%x, 0%o) = %d\n", pathName, flags, mode, fd);
    } else {
        fd = _ws_open(rewritePath("open", pathBuf, pathName), flags, 0);
        CALLTRACE("open(%s, 0x%x) = %d\n", pathName, flags, fd);
    }
    return fd;
}

/*
 * Replacement open() and variants.
 *
 * We have to use the vararg decl for the standard call so it matches
 * the definition in fcntl.h.
 */
int open(const char* pathName, int flags, ...)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    mode_t mode = 0;
    if ((flags & O_CREAT) != 0) {
        va_list args;

        va_start(args, flags);
        mode = va_arg(args, mode_t);
        va_end(args);
    }

    return openCommon(pathName, flags, mode);
}
int __open(const char* pathName, int flags, mode_t mode)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    return openCommon(pathName, flags, mode);
}

/*
 * Common handler for open64().
 */
int open64Common(const char* pathName, int flags, mode_t mode)
{
    char pathBuf[PATH_MAX];
    int fd;

    assert(gWrapSim.initialized);

    fd = wsInterceptDeviceOpen(pathName, flags);
    if (fd >= 0) {
        return fd;
    }

    if ((flags & O_CREAT) != 0) {
        fd = _ws_open64(rewritePath("open64", pathBuf, pathName), flags, mode);
        CALLTRACE("open64(%s, 0x%x, 0%o) = %d\n", pathName, flags, mode, fd);
    } else {
        fd = _ws_open64(rewritePath("open64", pathBuf, pathName), flags, 0);
        CALLTRACE("open64(%s, 0x%x) = %d\n", pathName, flags, fd);
    }
    return fd;
}

/*
 * Replacement open64() and variants.
 *
 * We have to use the vararg decl for the standard call so it matches
 * the definition in fcntl.h.
 */
int open64(const char* pathName, int flags, ...)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    mode_t mode = 0;
    if ((flags & O_CREAT) != 0) {
        va_list args;

        va_start(args, flags);
        mode = va_arg(args, mode_t);
        va_end(args);
    }
    return open64Common(pathName, flags, mode);
}
int __open64(const char* pathName, int flags, mode_t mode)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    return open64Common(pathName, flags, mode);
}


int dup(int fd)
{
    CALLTRACEV("%s(%d)\n", __FUNCTION__, fd);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        FakeDev* newDev = dev->dup(dev, fd);
        if (newDev != NULL) {
            /*
             * Now that the device entry is ready, add it to the list.
             */
            wsLog("## dup'ed fake dev %d: '%s' %p\n",
                newDev->fd, newDev->debugName, newDev->state);
            gWrapSim.fakeFdList[newDev->fd - kFakeFdBase] = newDev;
            return newDev->fd;
        }
        return -1;
    } else {
        CALLTRACE("dup(%d)\n", fd);
        return _ws_dup(fd);
    }
}


/*
 * Close a file descriptor.
 */
int close(int fd)
{
    CALLTRACEV("%s(%d)\n", __FUNCTION__, fd);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        int result = dev->close(dev, fd);
        wsFreeFakeDev(dev);
        return result;
    } else {
        CALLTRACE("close(%d)\n", fd);
        return _ws_close(fd);
    }
}

/*
 * Map a region.
 */
void* mmap(void* start, size_t length, int prot, int flags, int fd,
    __off_t offset)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->mmap(dev, start, length, prot, flags, fd, offset);
    } else {
        CALLTRACE("mmap(%p, %d, %d, %d, %d, %d)\n",
            start, (int) length, prot, flags, fd, (int) offset);
        return _ws_mmap(start, length, prot, flags, fd, offset);
    }
}

/*
 * Map a region.
 */
void* mmap64(void* start, size_t length, int prot, int flags, int fd,
    __off64_t offset)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->mmap(dev, start, length, prot, flags, fd, (__off_t) offset);
    } else {
        CALLTRACE("mmap64(%p, %d, %d, %d, %d, %d)\n",
            start, (int) length, prot, flags, fd, (int) offset);
        return _ws_mmap(start, length, prot, flags, fd, offset);
    }
}

/*
 * The Linux headers show this with a vararg header, but as far as I can
 * tell the kernel always expects 3 args.
 */
int ioctl(int fd, int request, ...)
{
    CALLTRACEV("%s(%d, %d, ...)\n", __FUNCTION__, fd, request);

    FakeDev* dev = wsFakeDevFromFd(fd);
    va_list args;
    void* argp;

    /* extract argp from varargs */
    va_start(args, request);
    argp = va_arg(args, void*);
    va_end(args);

    if (dev != NULL) {
        return dev->ioctl(dev, fd, request, argp);
    } else {
        CALLTRACE("ioctl(%d, 0x%x, %p)\n", fd, request, argp);
        return _ws_ioctl(fd, request, argp);
    }
}

/*
 * Read data.
 */
ssize_t read(int fd, void* buf, size_t count)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->read(dev, fd, buf, count);
    } else {
        CALLTRACE("read(%d, %p, %u)\n", fd, buf, count);
        return _ws_read(fd, buf, count);
    }
}

/*
 * Write data.
 */
ssize_t write(int fd, const void* buf, size_t count)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->write(dev, fd, buf, count);
    } else {
        CALLTRACE("write(%d, %p, %u)\n", fd, buf, count);
        return _ws_write(fd, buf, count);
    }
}

/*
 * Read a data vector.
 */
ssize_t readv(int fd, const struct iovec* vector, int count)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->readv(dev, fd, vector, count);
    } else {
        CALLTRACE("readv(%d, %p, %u)\n", fd, vector, count);
        return _ws_readv(fd, vector, count);
    }
}

/*
 * Write a data vector.
 */
ssize_t writev(int fd, const struct iovec* vector, int count)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    FakeDev* dev = wsFakeDevFromFd(fd);
    if (dev != NULL) {
        return dev->writev(dev, fd, vector, count);
    } else {
        CALLTRACE("writev(%d, %p, %u)\n", fd, vector, count);
        return _ws_writev(fd, vector, count);
    }
}

/*
 * Set the scheduling priority.  The sim doesn't run as root, so we have
 * to fake this out.
 *
 * For now, do some basic verification of the which and who parameters,
 * but otherwise return success.  In the future we may want to track
 * these so getpriority works.
 */
int setpriority(__priority_which_t which, id_t who, int what)
{
    CALLTRACEV("%s\n", __FUNCTION__);

    if (which != PRIO_PROCESS &&
        which != PRIO_PGRP &&
        which != PRIO_USER) {
        return EINVAL;
    }

    if ((int)who < 0) {
        return ESRCH;
    }

    return 0;
}

/*
 * Pretend to be running as root, so the Android framework
 * doesn't complain about permission problems all over the
 * place.
 */
uid_t getuid(void)
{
    return 0;
}

#if 0
/*
 * Create a pipe.  (Only needed for debugging an fd leak.)
 */
int pipe(int filedes[2])
{
    CALLTRACEV("%s\n", __FUNCTION__);

    int result = _ws_pipe(filedes);
    if (result == 0)
        CALLTRACE("pipe(%p) -> %d,%d\n", filedes, filedes[0], filedes[1]);
    if (filedes[0] == 83)
        abort();
    return result;
}
#endif