Archipelago » qemu

    int (*lstat)(FsContext *, const char *, struct stat *);

    ssize_t (*readlink)(FsContext *, const char *, char *, size_t);

    int (*setuid)(FsContext *, uid_t);

    int (*close)(FsContext *, int);

    int (*closedir)(FsContext *, DIR *);

#include <pwd.h>

#include <grp.h>

static const char *rpath(FsContext *ctx, const char *path)

{

    /* FIXME: so wrong... */

    static char buffer[4096];

    snprintf(buffer, sizeof(buffer), "%s/%s", ctx->fs_root, path);

    return buffer;

}

static int local_lstat(FsContext *ctx, const char *path, struct stat *stbuf)

{

    return lstat(rpath(ctx, path), stbuf);

}

static int local_setuid(FsContext *ctx, uid_t uid)

{

    struct passwd *pw;

    gid_t groups[33];

    int ngroups;

    static uid_t cur_uid = -1;

    if (cur_uid == uid) {

        return 0;

    }

    if (setreuid(0, 0)) {

        return -1;

    }

    pw = getpwuid(uid);

    if (pw == NULL) {

        return -1;

    }

    ngroups = 33;

    if (getgrouplist(pw->pw_name, pw->pw_gid, groups, &ngroups) == -1) {

        return -1;

    }

    if (setgroups(ngroups, groups)) {

        return -1;

    }

    if (setregid(-1, pw->pw_gid)) {

        return -1;

    }

    if (setreuid(-1, uid)) {

        return -1;

    }

    cur_uid = uid;

    return 0;

}

static ssize_t local_readlink(FsContext *ctx, const char *path,

                                char *buf, size_t bufsz)

{

    return readlink(rpath(ctx, path), buf, bufsz);

}

static int local_close(FsContext *ctx, int fd)

{

    return close(fd);

}

static int local_closedir(FsContext *ctx, DIR *dir)

{

    return closedir(dir);

}

    .lstat = local_lstat,

    .setuid = local_setuid,

    .readlink = local_readlink,

    .close = local_close,

    .closedir = local_closedir,

static int v9fs_do_lstat(V9fsState *s, V9fsString *path, struct stat *stbuf)

{

    return s->ops->lstat(&s->ctx, path->data, stbuf);

}

static int v9fs_do_setuid(V9fsState *s, uid_t uid)

{

    return s->ops->setuid(&s->ctx, uid);

}

static ssize_t v9fs_do_readlink(V9fsState *s, V9fsString *path, V9fsString *buf)

{

    ssize_t len;

    buf->data = qemu_malloc(1024);

    len = s->ops->readlink(&s->ctx, path->data, buf->data, 1024 - 1);

    if (len > -1) {

        buf->size = len;

        buf->data[len] = 0;

    }

    return len;

}

static int v9fs_do_close(V9fsState *s, int fd)

{

    return s->ops->close(&s->ctx, fd);

}

static int v9fs_do_closedir(V9fsState *s, DIR *dir)

{

    return s->ops->closedir(&s->ctx, dir);

}

    (void) v9fs_do_lstat;

    (void) v9fs_do_setuid;

    (void) v9fs_do_readlink;

    (void) v9fs_do_close;

    (void) v9fs_do_closedir;