bin/cpdup/hcproto.c - DragonflyBSD

root/bin/cpdup/hcproto.c
/*
 * HCPROTO.C
 *
 * This module implements a simple remote control protocol
 */

#include "cpdup.h"
#include "hclink.h"
#include "hcproto.h"

static int hc_decode_stat(hctransaction_t trans, struct stat *, struct HCHead *);
static int hc_decode_stat_item(struct stat *st, struct HCLeaf *item);
static int rc_encode_stat(hctransaction_t trans, struct stat *);

static int rc_hello(hctransaction_t trans, struct HCHead *);
static int rc_stat(hctransaction_t trans, struct HCHead *);
static int rc_lstat(hctransaction_t trans, struct HCHead *);
static int rc_opendir(hctransaction_t trans, struct HCHead *);
static int rc_readdir(hctransaction_t trans, struct HCHead *);
static int rc_closedir(hctransaction_t trans, struct HCHead *);
static int rc_scandir(hctransaction_t trans, struct HCHead *);
static int rc_open(hctransaction_t trans, struct HCHead *);
static int rc_close(hctransaction_t trans, struct HCHead *);
static int rc_read(hctransaction_t trans, struct HCHead *);
static int rc_readfile(hctransaction_t trans, struct HCHead *);
static int rc_write(hctransaction_t trans, struct HCHead *);
static int rc_remove(hctransaction_t trans, struct HCHead *);
static int rc_mkdir(hctransaction_t trans, struct HCHead *);
static int rc_rmdir(hctransaction_t trans, struct HCHead *);
static int rc_chown(hctransaction_t trans, struct HCHead *);
static int rc_lchown(hctransaction_t trans, struct HCHead *);
static int rc_chmod(hctransaction_t trans, struct HCHead *);
static int rc_mknod(hctransaction_t trans, struct HCHead *);
static int rc_link(hctransaction_t trans, struct HCHead *);
#ifdef _ST_FLAGS_PRESENT_
static int rc_chflags(hctransaction_t trans, struct HCHead *);
#endif
static int rc_readlink(hctransaction_t trans, struct HCHead *);
static int rc_umask(hctransaction_t trans, struct HCHead *);
static int rc_symlink(hctransaction_t trans, struct HCHead *);
static int rc_rename(hctransaction_t trans, struct HCHead *);
static int rc_utimes(hctransaction_t trans, struct HCHead *);
static int rc_geteuid(hctransaction_t trans, struct HCHead *);
static int rc_getgroups(hctransaction_t trans, struct HCHead *);

static int getmygroups(gid_t **gidlist);

static int silentwarning(int *, const char *, ...) __printflike(2, 3);

static struct HCDesc HCDispatchTable[] = {
    { HC_HELLO,         rc_hello },
    { HC_STAT,          rc_stat },
    { HC_LSTAT,         rc_lstat },
    { HC_OPENDIR,       rc_opendir },
    { HC_READDIR,       rc_readdir },
    { HC_CLOSEDIR,      rc_closedir },
    { HC_OPEN,          rc_open },
    { HC_CLOSE,         rc_close },
    { HC_READ,          rc_read },
    { HC_WRITE,         rc_write },
    { HC_REMOVE,        rc_remove },
    { HC_MKDIR,         rc_mkdir },
    { HC_RMDIR,         rc_rmdir },
    { HC_CHOWN,         rc_chown },
    { HC_LCHOWN,        rc_lchown },
    { HC_CHMOD,         rc_chmod },
    { HC_MKNOD,         rc_mknod },
    { HC_LINK,          rc_link },
#ifdef _ST_FLAGS_PRESENT_
    { HC_CHFLAGS,       rc_chflags },
#endif
    { HC_READLINK,      rc_readlink },
    { HC_UMASK,         rc_umask },
    { HC_SYMLINK,       rc_symlink },
    { HC_RENAME,        rc_rename },
    { HC_UTIMES,        rc_utimes },
    { HC_GETEUID,       rc_geteuid },
    { HC_GETGROUPS,     rc_getgroups },
    { HC_SCANDIR,       rc_scandir },
    { HC_READFILE,      rc_readfile },
    { HC_LUTIMES,       rc_utimes },
#ifdef _ST_FLAGS_PRESENT_
    { HC_LCHFLAGS,      rc_chflags },
#endif
    { HC_LCHMOD,        rc_chmod },
};

static int chown_warning;
#ifdef _ST_FLAGS_PRESENT_
static int chflags_warning;
#endif

/*
 * If not running as root generate a silent warning and return no error.
 *
 * If running as root return an error.
 */
static int
silentwarning(int *didwarn, const char *ctl, ...)
{
    va_list va;

    if (DstRootPrivs)
        return(-1);
    if (*didwarn == 0 && QuietOpt == 0) {
        *didwarn = 1;
        fprintf(stderr, "WARNING: Not running as root, ");
        va_start(va, ctl);
        vfprintf(stderr, ctl, va);
        va_end(va);
    }
    return(0);
}

int
hc_connect(struct HostConf *hc, int readonly)
{
    if (hcc_connect(hc, readonly) < 0) {
        fprintf(stderr, "Unable to connect to %s\n", hc->host);
        return(-1);
    }
    return(hc_hello(hc));
}

void
hc_slave(int fdin, int fdout)
{
    hcc_slave(fdin, fdout, HCDispatchTable,
              sizeof(HCDispatchTable) / sizeof(HCDispatchTable[0]));
}

/*
 * A HELLO RPC is sent on the initial connect.
 */
int
hc_hello(struct HostConf *hc)
{
    struct HCHead *head;
    struct HCLeaf *item;
    hctransaction_t trans;
    char hostbuf[256];
    int error;

    bzero(hostbuf, sizeof(hostbuf));
    if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
        return(-1);
    if (hostbuf[0] == 0)
        hostbuf[0] = '?';

    trans = hcc_start_command(hc, HC_HELLO);
    hcc_leaf_string(trans, LC_HELLOSTR, hostbuf);
    hcc_leaf_int32(trans, LC_VERSION, HCPROTO_VERSION);
    if (UseCpFile)
        hcc_leaf_string(trans, LC_PATH1, UseCpFile);
    if ((head = hcc_finish_command(trans)) == NULL) {
        fprintf(stderr, "Connected to %s but remote failed to complete hello\n",
                hc->host);
        return(-1);
    }

    if (head->error) {
        fprintf(stderr, "Connected to %s but remote returned error %d\n",
                hc->host, head->error);
        return(-1);
    }

    error = -1;
    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_HELLOSTR:
            if (QuietOpt == 0)
                fprintf(stderr, "Handshaked with %s\n", HCC_STRING(item));
            error = 0;
            break;
        case LC_VERSION:
            hc->version = HCC_INT32(item);
            break;
        }
    }
    if (hc->version < HCPROTO_VERSION_COMPAT) {
        fprintf(stderr, "Remote cpdup at %s has an incompatible version\n",
                hc->host);
        error = -1;
    } else if (hc->version < HCPROTO_VERSION && QuietOpt == 0) {
        fprintf(stderr,
                "WARNING: Remote cpdup at %s has a lower version,\n"
                "expect reduced speed and/or functionality\n", hc->host);
    }
    if (error < 0)
        fprintf(stderr, "Handshake failed with %s\n", hc->host);
    return (error);
}

static int
rc_hello(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    char hostbuf[256];

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            UseCpFile = strdup(HCC_STRING(item));
    }

    bzero(hostbuf, sizeof(hostbuf));
    if (gethostname(hostbuf, sizeof(hostbuf) - 1) < 0)
        return(-1);
    if (hostbuf[0] == 0)
        hostbuf[0] = '?';

    hcc_leaf_string(trans, LC_HELLOSTR, hostbuf);
    hcc_leaf_int32(trans, LC_VERSION, HCPROTO_VERSION);
    return(0);
}

/*
 * STAT, LSTAT
 */
int
hc_stat(struct HostConf *hc, const char *path, struct stat *st)
{
    struct HCHead *head;
    hctransaction_t trans;

    if (hc == NULL || hc->host == NULL)
        return(stat(path, st));

    trans = hcc_start_command(hc, HC_STAT);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(hc_decode_stat(trans, st, head));
}

int
hc_lstat(struct HostConf *hc, const char *path, struct stat *st)
{
    struct HCHead *head;
    hctransaction_t trans;

    if (hc == NULL || hc->host == NULL)
        return(lstat(path, st));

    trans = hcc_start_command(hc, HC_LSTAT);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(hc_decode_stat(trans, st, head));
}

static int
hc_decode_stat(hctransaction_t trans, struct stat *st, struct HCHead *head)
{
    struct HCLeaf *item;

    bzero(st, sizeof(*st));
    FOR_EACH_ITEM(item, trans, head)
        hc_decode_stat_item(st, item);
    return(0);
}

static int
hc_decode_stat_item(struct stat *st, struct HCLeaf *item)
{
    switch(item->leafid) {
    case LC_DEV:
        st->st_dev = HCC_INT32(item);
        break;
    case LC_INO:
        st->st_ino = HCC_INT64(item);
        break;
    case LC_MODE:
        st->st_mode = HCC_INT32(item);
        break;
    case LC_NLINK:
        st->st_nlink = HCC_INT32(item);
        break;
    case LC_UID:
        st->st_uid = HCC_INT32(item);
        break;
    case LC_GID:
        st->st_gid = HCC_INT32(item);
        break;
    case LC_RDEV:
        st->st_rdev = HCC_INT32(item);
        break;
    case LC_ATIME:
        st->st_atime = (time_t)HCC_INT64(item);
        break;
    case LC_MTIME:
        st->st_mtime = (time_t)HCC_INT64(item);
        break;
    case LC_CTIME:
        st->st_ctime = (time_t)HCC_INT64(item);
        break;
#if defined(st_atime)  /* A macro, so very likely on modern POSIX */
    case LC_ATIMENSEC:
        st->st_atim.tv_nsec = HCC_INT32(item);
        break;
    case LC_MTIMENSEC:
        st->st_mtim.tv_nsec = HCC_INT32(item);
        break;
    case LC_CTIMENSEC:
        st->st_ctim.tv_nsec = HCC_INT32(item);
        break;
#endif
    case LC_FILESIZE:
        st->st_size = HCC_INT64(item);
        break;
    case LC_FILEBLKS:
        st->st_blocks = HCC_INT64(item);
        break;
    case LC_BLKSIZE:
        st->st_blksize = HCC_INT32(item);
        break;
#ifdef _ST_FLAGS_PRESENT_
    case LC_FILEFLAGS:
        st->st_flags = (uint32_t)HCC_INT64(item);
        break;
#endif
    }
    return(0);
}

static int
rc_stat(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    struct stat st;
    const char *path = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return(-2);
    if (stat(path, &st) < 0)
        return(-1);
    return (rc_encode_stat(trans, &st));
}

static int
rc_lstat(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    struct stat st;
    const char *path = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return(-2);
    if (lstat(path, &st) < 0)
        return(-1);
    return (rc_encode_stat(trans, &st));
}

/*
 * Encode all entries of a stat structure.
 *
 * CAUTION:  If you add any more entries here, be sure to
 *           increase the STAT_MAX_NUM_ENTRIES value!
 */
#define STAT_MAX_NUM_ENTRIES 18
static int
rc_encode_stat(hctransaction_t trans, struct stat *st)
{
    hcc_leaf_int32(trans, LC_DEV, st->st_dev);
    hcc_leaf_int64(trans, LC_INO, st->st_ino);
    hcc_leaf_int32(trans, LC_MODE, st->st_mode);
    hcc_leaf_int32(trans, LC_NLINK, st->st_nlink);
    hcc_leaf_int32(trans, LC_UID, st->st_uid);
    hcc_leaf_int32(trans, LC_GID, st->st_gid);
    hcc_leaf_int32(trans, LC_RDEV, st->st_rdev);
    hcc_leaf_int64(trans, LC_ATIME, st->st_atime);
    hcc_leaf_int64(trans, LC_MTIME, st->st_mtime);
    hcc_leaf_int64(trans, LC_CTIME, st->st_ctime);
#if defined(st_atime)
    hcc_leaf_int32(trans, LC_ATIMENSEC, st->st_atim.tv_nsec);
    hcc_leaf_int32(trans, LC_MTIMENSEC, st->st_mtim.tv_nsec);
    hcc_leaf_int32(trans, LC_CTIMENSEC, st->st_ctim.tv_nsec);
#endif
    hcc_leaf_int64(trans, LC_FILESIZE, st->st_size);
    hcc_leaf_int64(trans, LC_FILEBLKS, st->st_blocks);
    hcc_leaf_int32(trans, LC_BLKSIZE, st->st_blksize);
#ifdef _ST_FLAGS_PRESENT_
    hcc_leaf_int64(trans, LC_FILEFLAGS, st->st_flags);
#endif
    return(0);
}

/*
 * OPENDIR
 */
DIR *
hc_opendir(struct HostConf *hc, const char *path)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (hc == NULL || hc->host == NULL)
        return(opendir(path));

    if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
        struct HCLeaf *item;
        struct HCDirEntry *den;
        intptr_t desc = 0;

        trans = hcc_start_command(hc, HC_OPENDIR);
        hcc_leaf_string(trans, LC_PATH1, path);
        if ((head = hcc_finish_command(trans)) == NULL)
            return (NULL);
        if (head->error)
            return (NULL);
        FOR_EACH_ITEM(item, trans, head) {
            if (item->leafid == LC_DESCRIPTOR)
                desc = HCC_INT32(item);
        }
        if (hcc_get_descriptor(hc, desc, HC_DESC_DIR)) {
            fprintf(stderr, "hc_opendir: remote reused active descriptor %jd\n",
                (intmax_t)desc);
            return (NULL);
        }
        den = malloc(sizeof(*den));
        hcc_set_descriptor(hc, desc, den, HC_DESC_DIR);
        return ((void *)desc);
    }

    /* hc->version >= 4: use HC_SCANDIR */
    trans = hcc_start_command(hc, HC_SCANDIR);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL || head->error)
        return (NULL);
    return ((void *)head);
}

static int
rc_opendir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    DIR *dir;
    int desc;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return(-2);
    if ((dir = opendir(path)) == NULL) {
        head->error = errno;
    } else {
        desc = hcc_alloc_descriptor(trans->hc, dir, HC_DESC_DIR);
        hcc_leaf_int32(trans, LC_DESCRIPTOR, desc);
    }
    return(0);
}

/*
 * READDIR
 */
struct HCDirEntry *
hc_readdir(struct HostConf *hc, DIR *dir, struct stat **statpp)
{
    int stat_ok = 0;
    struct HCHead *head;
    struct HCLeaf *item;
    static struct HCDirEntry denbuf;

    *statpp = NULL;
    if (hc == NULL || hc->host == NULL) {
        struct dirent *sysden;

        if ((sysden = readdir(dir)) == NULL)
            return (NULL);
        strlcpy(denbuf.d_name, sysden->d_name, MAXNAMLEN + 1);
        return (&denbuf);
    }

    if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
        hctransaction_t trans;
        struct HCDirEntry *den;

        trans = hcc_start_command(hc, HC_READDIR);
        hcc_leaf_int32(trans, LC_DESCRIPTOR, (intptr_t)dir);
        if ((head = hcc_finish_command(trans)) == NULL)
            return (NULL);
        if (head->error)
            return (NULL);      /* XXX errno */
        den = hcc_get_descriptor(hc, (intptr_t)dir, HC_DESC_DIR);
        if (den == NULL)
            return (NULL);      /* XXX errno */
        den->d_name[0] = 0;
        FOR_EACH_ITEM(item, trans, head) {
            if (item->leafid == LC_PATH1)
                strlcpy(den->d_name, HCC_STRING(item), MAXNAMLEN + 1);
        }
        return (den->d_name[0] ? den : NULL);
    }

    /* hc->version >= 4: using HC_SCANDIR */
    denbuf.d_name[0] = 0;
    head = (void *)dir;
    *statpp = malloc(sizeof(struct stat));
    bzero(*statpp, sizeof(struct stat));
    while ((item = hcc_nextchaineditem(hc, head)) != NULL) {
        if (item->leafid == LC_PATH1) {  /* this must be the last item */
            strlcpy(denbuf.d_name, HCC_STRING(item), MAXNAMLEN + 1);
            break;
        } else {
            stat_ok = 1;
            hc_decode_stat_item(*statpp, item);
        }
    }
    if (!stat_ok) {
        free(*statpp);
        *statpp = NULL;
    }
    if (hc->trans.state == HCT_FAIL)
        return NULL;
    return (denbuf.d_name[0] ? &denbuf : NULL);
}

static int
rc_readdir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    struct dirent *den;
    DIR *dir = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_DESCRIPTOR)
            dir = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_DIR);
    }
    if (dir == NULL)
        return(-2);
    if ((den = readdir(dir)) != NULL)
        hcc_leaf_string(trans, LC_PATH1, den->d_name);
    return(0);
}

/*
 * CLOSEDIR
 *
 * XXX cpdup needs to check error code to avoid truncated dirs?
 */
int
hc_closedir(struct HostConf *hc, DIR *dir)
{
    struct HCHead *head;

    if (hc == NULL || hc->host == NULL)
        return(closedir(dir));

    if (hc->version <= 3) { /* compatibility: HC_SCANDIR not supported */
        hctransaction_t trans;
        struct dirent *den;

        if ((den = hcc_get_descriptor(hc, (intptr_t)dir, HC_DESC_DIR)) != NULL) {
            free(den);
            hcc_set_descriptor(hc, (intptr_t)dir, NULL, HC_DESC_DIR);
            trans = hcc_start_command(hc, HC_CLOSEDIR);
            hcc_leaf_int32(trans, LC_DESCRIPTOR, (intptr_t)dir);
            if ((head = hcc_finish_command(trans)) == NULL)
                return (-1);
            if (head->error)
                return (-1);            /* XXX errno */
            return (0);
        } else {
            /* errno */
            return(-1);
        }
    }

    /* hc->version >= 4: using HC_SCANDIR */
    head = (void *)dir;
    /* skip any remaining items if the directory is closed prematurely */
    while (hcc_nextchaineditem(hc, head) != NULL)
        /*nothing*/ ;
    if (hc->trans.state == HCT_FAIL || head->error)
        return (-1);
    return (0);
}

static int
rc_closedir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    DIR *dir = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_DESCRIPTOR) {
            dir = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_DIR);
            if (dir != NULL) {
                    hcc_set_descriptor(trans->hc, HCC_INT32(item),
                                       NULL, HC_DESC_DIR);
            }
        }
    }
    if (dir == NULL)
        return(-2);
    return(closedir(dir));
}

/*
 * SCANDIR
 */
static int
rc_scandir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    struct dirent *den;
    DIR *dir;
    char *fpath;
    struct stat st;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return (-2);
    if ((dir = opendir(path)) == NULL)
        return (-1);
    while ((den = readdir(dir)) != NULL) {
        if (den->d_name[0] == '.' && (den->d_name[1] == '\0' ||
                (den->d_name[1] == '.' && den->d_name[2] == '\0')))
            continue;   /* skip "." and ".." */
        /*
         * Check if there's enough space left in the current packet.
         * We have at most STAT_MAX_NUM_ENTRIES pieces of data, of which
         * one is a string, so we use strlen() + 1 (terminating zero).
         * The remaining ones are numbers; we assume sizeof(int64_t) so
         * we're on the safe side.
         */
        if (!hcc_check_space(trans, head, STAT_MAX_NUM_ENTRIES,
                (STAT_MAX_NUM_ENTRIES - 1) * sizeof(int64_t) +
                strlen(den->d_name) + 1)) {
            closedir(dir);
            return (-1);
        }
        fpath = mprintf("%s/%s", path, den->d_name);
        if (lstat(fpath, &st) == 0)
            rc_encode_stat(trans, &st);
        /* The name must be the last item! */
        hcc_leaf_string(trans, LC_PATH1, den->d_name);
        free(fpath);
    }
    return (closedir(dir));
}

/*
 * OPEN
 */
int
hc_open(struct HostConf *hc, const char *path, int flags, mode_t mode)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;
    int *fdp;
    int desc = 0;
    int nflags;

    if (NotForRealOpt && (flags & O_CREAT))
        return(0x7FFFFFFF);

    if (hc == NULL || hc->host == NULL) {
#ifdef O_LARGEFILE
        flags |= O_LARGEFILE;
#endif
        return(open(path, flags, mode));
    }

    if ((flags & (O_WRONLY | O_RDWR)) == 0 && hc->version >= 4) {
        trans = hcc_start_command(hc, HC_READFILE);
        hcc_leaf_string(trans, LC_PATH1, path);
        if ((head = hcc_finish_command(trans)) == NULL || head->error)
            return (-1);
        head->magic = 0; /* used to indicate offset within buffer */
        return (1); /* dummy */
    }

    nflags = flags & XO_NATIVEMASK;
    if (flags & O_CREAT)
        nflags |= XO_CREAT;
    if (flags & O_EXCL)
        nflags |= XO_EXCL;
    if (flags & O_TRUNC)
        nflags |= XO_TRUNC;

    trans = hcc_start_command(hc, HC_OPEN);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_OFLAGS, nflags);
    hcc_leaf_int32(trans, LC_MODE, mode);

    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_DESCRIPTOR)
            desc = HCC_INT32(item);
    }
    if (hcc_get_descriptor(hc, desc, HC_DESC_FD)) {
        fprintf(stderr, "hc_open: remote reused active descriptor %d\n",
                desc);
        return(-1);
    }
    fdp = malloc(sizeof(int));
    *fdp = desc;        /* really just a dummy */
    hcc_set_descriptor(hc, desc, fdp, HC_DESC_FD);
    return(desc);
}

static int
rc_open(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    int nflags = 0;
    int flags;
    mode_t mode = 0666;
    int desc;
    int *fdp;
    int fd;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_OFLAGS:
            nflags = HCC_INT32(item);
            break;
        case LC_MODE:
            mode = HCC_INT32(item);
            break;
        }
    }
    if (path == NULL)
        return(-2);

    flags = nflags & XO_NATIVEMASK;
    if (nflags & XO_CREAT)
        flags |= O_CREAT;
    if (nflags & XO_EXCL)
        flags |= O_EXCL;
    if (nflags & XO_TRUNC)
        flags |= O_TRUNC;

    if (ReadOnlyOpt) {
        if (flags & (O_WRONLY | O_RDWR | O_CREAT | O_TRUNC)) {
            head->error = EACCES;
            return (0);
        }
        flags |= O_RDONLY;
    }

#ifdef O_LARGEFILE
    flags |= O_LARGEFILE;
#endif
    if ((fd = open(path, flags, mode)) < 0)
        return(-1);
    fdp = malloc(sizeof(int));
    *fdp = fd;
    desc = hcc_alloc_descriptor(trans->hc, fdp, HC_DESC_FD);
    hcc_leaf_int32(trans, LC_DESCRIPTOR, desc);
    return(0);
}

/*
 * CLOSE
 */
int
hc_close(struct HostConf *hc, int fd)
{
    hctransaction_t trans;
    struct HCHead *head;
    int *fdp;

    if (NotForRealOpt && fd == 0x7FFFFFFF)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(close(fd));

    if (fd == 1 && hc->version >= 4) {  /* using HC_READFILE */
        head = (void *)hc->trans.rbuf;
        /* skip any remaining items if the file is closed prematurely */
        while (hcc_nextchaineditem(hc, head) != NULL)
            /*nothing*/ ;
        if (hc->trans.state == HCT_FAIL || head->error)
            return (-1);
        return (0);
    }

    fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
    if (fdp) {
        free(fdp);
        hcc_set_descriptor(hc, fd, NULL, HC_DESC_FD);

        trans = hcc_start_command(hc, HC_CLOSE);
        hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
        if ((head = hcc_finish_command(trans)) == NULL)
            return(-1);
        if (head->error)
            return(-1);
        return(0);
    } else {
        return(-1);
    }
}

static int
rc_close(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    int *fdp = NULL;
    int fd;
    int desc = -1;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_DESCRIPTOR)
            desc = HCC_INT32(item);
    }
    if (desc < 0)
        return(-2);
    if ((fdp = hcc_get_descriptor(trans->hc, desc, HC_DESC_FD)) == NULL)
        return(-2);
    fd = *fdp;
    free(fdp);
    hcc_set_descriptor(trans->hc, desc, NULL, HC_DESC_FD);
    return(close(fd));
}

static int
getiolimit(void)
{
    return(32768);
}

/*
 * READ
 */
ssize_t
hc_read(struct HostConf *hc, int fd, void *buf, size_t bytes)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;
    int *fdp;
    int offset;
    int r = 0;
    int x = 0;

    if (hc == NULL || hc->host == NULL)
        return(read(fd, buf, bytes));

    if (fd == 1 && hc->version >= 4) {  /* using HC_READFILE */
        head = (void *)hc->trans.rbuf;
        while (bytes) {
            if ((offset = head->magic) != 0) {
                item = hcc_currentchaineditem(hc, head);
            } else {
                item = hcc_nextchaineditem(hc, head);
            }
            if (item == NULL) {
                if (hc->trans.state == HCT_FAIL)
                        r = -1;
                return (r);
            }
            if (item->leafid != LC_DATA)
                return (-1);
            x = item->bytes - sizeof(*item) - offset;
            if (x > (int)bytes) {
                x = (int)bytes;
                head->magic += x;  /* leave bytes in the buffer */
            }
            else
                head->magic = 0;  /* all bytes used up */
            bcopy((char *)HCC_BINARYDATA(item) + offset, buf, x);
            buf = (char *)buf + x;
            bytes -= (size_t)x;
            r += x;
        }
        return (r);
    }

    fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
    if (fdp) {
        while (bytes) {
            size_t limit = getiolimit();
            int n = (bytes > limit) ? limit : bytes;

            trans = hcc_start_command(hc, HC_READ);
            hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
            hcc_leaf_int32(trans, LC_BYTES, n);
            if ((head = hcc_finish_command(trans)) == NULL)
                return(-1);
            if (head->error)
                return(-1);
            FOR_EACH_ITEM(item, trans, head) {
                if (item->leafid == LC_DATA) {
                    x = item->bytes - sizeof(*item);
                    if (x > (int)bytes)
                        x = (int)bytes;
                    bcopy(HCC_BINARYDATA(item), buf, x);
                    buf = (char *)buf + x;
                    bytes -= (size_t)x;
                    r += x;
                }
            }
            if (x < n)
                break;
        }
        return(r);
    } else {
        return(-1);
    }
}

static int
rc_read(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    int *fdp = NULL;
    char buf[32768];
    int bytes = -1;
    int n;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_DESCRIPTOR:
            fdp = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_FD);
            break;
        case LC_BYTES:
            bytes = HCC_INT32(item);
            break;
        }
    }
    if (fdp == NULL)
        return(-2);
    if (bytes < 0 || bytes > 32768)
        return(-2);
    n = read(*fdp, buf, bytes);
    if (n < 0)
        return(-1);
    hcc_leaf_data(trans, LC_DATA, buf, n);
    return(0);
}

/*
 * READFILE
 */
static int
rc_readfile(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    char buf[32768];
    int n;
    int fd;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return (-2);
    if ((fd = open(path, O_RDONLY)) < 0)
        return(-1);
    while ((n = read(fd, buf, 32768)) >= 0) {
        if (!hcc_check_space(trans, head, 1, n)) {
            close(fd);
            return (-1);
        }
        hcc_leaf_data(trans, LC_DATA, buf, n);
        if (n == 0)
                break;
    }
    if (n < 0) {
        close(fd);
        return (-1);
    }
    return (close(fd));
}

/*
 * WRITE
 */
ssize_t
hc_write(struct HostConf *hc, int fd, const void *buf, size_t bytes)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;
    int *fdp;
    int r;

    if (NotForRealOpt)
        return(bytes);

    if (hc == NULL || hc->host == NULL)
        return(write(fd, buf, bytes));

    fdp = hcc_get_descriptor(hc, fd, HC_DESC_FD);
    if (fdp) {
        r = 0;
        while (bytes) {
            size_t limit = getiolimit();
            int n = (bytes > limit) ? limit : bytes;
            int x = 0;

            trans = hcc_start_command(hc, HC_WRITE);
            hcc_leaf_int32(trans, LC_DESCRIPTOR, fd);
            hcc_leaf_data(trans, LC_DATA, buf, n);
            if ((head = hcc_finish_command(trans)) == NULL)
                return(-1);
            if (head->error)
                return(-1);
            FOR_EACH_ITEM(item, trans, head) {
                if (item->leafid == LC_BYTES)
                    x = HCC_INT32(item);
            }
            if (x < 0 || x > n)
                return(-1);
            r += x;
            buf = (const char *)buf + x;
            bytes -= x;
            if (x < n)
                break;
        }
        return(r);
    } else {
        return(-1);
    }
}

static int
rc_write(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    int *fdp = NULL;
    void *buf = NULL;
    int n = -1;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_DESCRIPTOR:
            fdp = hcc_get_descriptor(trans->hc, HCC_INT32(item), HC_DESC_FD);
            break;
        case LC_DATA:
            buf = HCC_BINARYDATA(item);
            n = item->bytes - sizeof(*item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (fdp == NULL)
        return(-2);
    if (n < 0 || n > 32768)
        return(-2);
    n = write(*fdp, buf, n);
    if (n < 0)
        return (-1);
    hcc_leaf_int32(trans, LC_BYTES, n);
    return(0);
}

/*
 * REMOVE
 *
 * NOTE: This function returns -errno if an error occured.
 */
int
hc_remove(struct HostConf *hc, const char *path)
{
    hctransaction_t trans;
    struct HCHead *head;
    int res;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL) {
        res = remove(path);
        if (res < 0)
                res = -errno;
        return(res);
    }

    trans = hcc_start_command(hc, HC_REMOVE);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-EIO);
    if (head->error)
        return(-(int)head->error);
    return(0);
}

static int
rc_remove(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return(-2);
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    return(remove(path));
}

/*
 * MKDIR
 */
int
hc_mkdir(struct HostConf *hc, const char *path, mode_t mode)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(mkdir(path, mode));

    trans = hcc_start_command(hc, HC_MKDIR);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_MODE, mode);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_mkdir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    mode_t mode = 0777;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_MODE:
            mode = HCC_INT32(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    return(mkdir(path, mode));
}

/*
 * RMDIR
 */
int
hc_rmdir(struct HostConf *hc, const char *path)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(rmdir(path));

    trans = hcc_start_command(hc, HC_RMDIR);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_rmdir(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    return(rmdir(path));
}

/*
 * CHOWN
 *
 * Almost silently ignore chowns that fail if we are not root.
 */
int
hc_chown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
{
    hctransaction_t trans;
    struct HCHead *head;
    int rc;

    if (NotForRealOpt)
        return(0);
    if (!DstRootPrivs)
        owner = -1;

    if (hc == NULL || hc->host == NULL) {
        rc = chown(path, owner, group);
        if (rc < 0)
            rc = silentwarning(&chown_warning, "file ownership may differ\n");
        return(rc);
    }

    trans = hcc_start_command(hc, HC_CHOWN);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_UID, owner);
    hcc_leaf_int32(trans, LC_GID, group);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_chown(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    uid_t uid = (uid_t)-1;
    gid_t gid = (gid_t)-1;
    int rc;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_UID:
            uid = HCC_INT32(item);
            break;
        case LC_GID:
            gid = HCC_INT32(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    rc = chown(path, uid, gid);
    if (rc < 0)
        rc = silentwarning(&chown_warning, "file ownership may differ\n");
    return(rc);
}

/*
 * LCHOWN
 */
int
hc_lchown(struct HostConf *hc, const char *path, uid_t owner, gid_t group)
{
    hctransaction_t trans;
    struct HCHead *head;
    int rc;

    if (NotForRealOpt)
        return(0);
    if (!DstRootPrivs)
        owner = -1;

    if (hc == NULL || hc->host == NULL) {
        rc = lchown(path, owner, group);
        if (rc < 0)
            rc = silentwarning(&chown_warning, "file ownership may differ\n");
        return(rc);
    }

    trans = hcc_start_command(hc, HC_LCHOWN);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_UID, owner);
    hcc_leaf_int32(trans, LC_GID, group);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_lchown(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    uid_t uid = (uid_t)-1;
    gid_t gid = (gid_t)-1;
    int rc;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_UID:
            uid = HCC_INT32(item);
            break;
        case LC_GID:
            gid = HCC_INT32(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    rc = lchown(path, uid, gid);
    if (rc < 0)
        rc = silentwarning(&chown_warning, "file ownership may differ\n");
    return(rc);
}

/*
 * CHMOD
 */
int
hc_chmod(struct HostConf *hc, const char *path, mode_t mode)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(chmod(path, mode));

    trans = hcc_start_command(hc, HC_CHMOD);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_MODE, mode);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

int
hc_lchmod(struct HostConf *hc, const char *path, mode_t mode)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(lchmod(path, mode));

    trans = hcc_start_command(hc, HC_LCHMOD);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_MODE, mode);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_chmod(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    mode_t mode = 0666;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_MODE:
            mode = HCC_INT32(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    if (head->cmd == HC_LCHMOD)
            return(lchmod(path, mode));
    else
            return(chmod(path, mode));
}

/*
 * MKNOD
 */
int
hc_mknod(struct HostConf *hc, const char *path, mode_t mode, dev_t rdev)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (!DstRootPrivs) {
        /* mknod() requires root privs, so don't bother. */
        errno = EPERM;
        return (-1);
    }

    if (hc == NULL || hc->host == NULL)
        return(mknod(path, mode, rdev));

    trans = hcc_start_command(hc, HC_MKNOD);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int32(trans, LC_MODE, mode);
    hcc_leaf_int32(trans, LC_RDEV, rdev);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_mknod(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    mode_t mode = 0666;
    dev_t rdev = 0;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_MODE:
            mode = HCC_INT32(item);
            break;
        case LC_RDEV:
            rdev = HCC_INT32(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    return(mknod(path, mode, rdev));
}

/*
 * LINK
 */
int
hc_link(struct HostConf *hc, const char *name1, const char *name2)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(link(name1, name2));

    trans = hcc_start_command(hc, HC_LINK);
    hcc_leaf_string(trans, LC_PATH1, name1);
    hcc_leaf_string(trans, LC_PATH2, name2);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_link(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *name1 = NULL;
    const char *name2 = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            name1 = HCC_STRING(item);
            break;
        case LC_PATH2:
            name2 = HCC_STRING(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (-0);
    }
    if (name1 == NULL || name2 == NULL)
        return(-2);
    return(link(name1, name2));
}

#ifdef _ST_FLAGS_PRESENT_
/*
 * CHFLAGS
 */
int
hc_chflags(struct HostConf *hc, const char *path, u_long flags)
{
    hctransaction_t trans;
    struct HCHead *head;
    int rc;

    if (NotForRealOpt)
        return(0);
    if (!DstRootPrivs)
        flags &= UF_SETTABLE;

    if (hc == NULL || hc->host == NULL) {
        if ((rc = chflags(path, flags)) < 0)
            rc = silentwarning(&chflags_warning, "file flags may differ\n");
        return (rc);
    }

    trans = hcc_start_command(hc, HC_CHFLAGS);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int64(trans, LC_FILEFLAGS, flags);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

int
hc_lchflags(struct HostConf *hc, const char *path, u_long flags)
{
    hctransaction_t trans;
    struct HCHead *head;
    int rc;

    if (NotForRealOpt)
        return(0);
    if (!DstRootPrivs)
        flags &= UF_SETTABLE;

    if (hc == NULL || hc->host == NULL) {
        if ((rc = lchflags(path, flags)) < 0)
            rc = silentwarning(&chflags_warning, "file flags may differ\n");
        return (rc);
    }

    trans = hcc_start_command(hc, HC_LCHFLAGS);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int64(trans, LC_FILEFLAGS, flags);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_chflags(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    u_long flags = 0;
    int rc;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_FILEFLAGS:
            flags = (u_long)HCC_INT64(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    if (head->cmd == HC_LCHFLAGS)
        rc = lchflags(path, flags);
    else
        rc = chflags(path, flags);
    if (rc < 0)
        rc = silentwarning(&chflags_warning, "file flags may differ\n");
    return(rc);
}

#endif

/*
 * READLINK
 */
int
hc_readlink(struct HostConf *hc, const char *path, char *buf, int bufsiz)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;
    int r;

    if (hc == NULL || hc->host == NULL)
        return(readlink(path, buf, bufsiz));

    trans = hcc_start_command(hc, HC_READLINK);
    hcc_leaf_string(trans, LC_PATH1, path);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);

    r = 0;
    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_DATA) {
            r = item->bytes - sizeof(*item);
            if (r < 0)
                r = 0;
            if (r > bufsiz)
                r = bufsiz;
            bcopy(HCC_BINARYDATA(item), buf, r);
        }
    }
    return(r);
}

static int
rc_readlink(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *path = NULL;
    char buf[1024];
    int r;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_PATH1)
            path = HCC_STRING(item);
    }
    if (path == NULL)
        return(-2);
    r = readlink(path, buf, sizeof(buf));
    if (r < 0)
        return(-1);
    hcc_leaf_data(trans, LC_DATA, buf, r);
    return(0);
}

/*
 * UMASK
 */
mode_t
hc_umask(struct HostConf *hc, mode_t numask)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;

    if (NotForRealOpt)
        return(umask(numask));
    if (hc == NULL || hc->host == NULL)
        return(umask(numask));

    trans = hcc_start_command(hc, HC_UMASK);
    hcc_leaf_int32(trans, LC_MODE, numask);
    if ((head = hcc_finish_command(trans)) == NULL)
        return((mode_t)-1);
    if (head->error)
        return((mode_t)-1);

    numask = (mode_t) ~0666U;
    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_MODE)
            numask = HCC_INT32(item);
    }
    return(numask);
}

static int
rc_umask(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    mode_t numask = (mode_t) ~0666U;

    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_MODE)
            numask = HCC_INT32(item);
    }
    numask = umask(numask);
    hcc_leaf_int32(trans, LC_MODE, numask);
    return(0);
}

/*
 * SYMLINK
 */
int
hc_symlink(struct HostConf *hc, const char *name1, const char *name2)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(symlink(name1, name2));

    trans = hcc_start_command(hc, HC_SYMLINK);
    hcc_leaf_string(trans, LC_PATH1, name1);
    hcc_leaf_string(trans, LC_PATH2, name2);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_symlink(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *name1 = NULL;
    const char *name2 = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            name1 = HCC_STRING(item);
            break;
        case LC_PATH2:
            name2 = HCC_STRING(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (name1 == NULL || name2 == NULL)
        return(-2);
    return(symlink(name1, name2));
}

/*
 * RENAME
 */
int
hc_rename(struct HostConf *hc, const char *name1, const char *name2)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL)
        return(rename(name1, name2));

    trans = hcc_start_command(hc, HC_RENAME);
    hcc_leaf_string(trans, LC_PATH1, name1);
    hcc_leaf_string(trans, LC_PATH2, name2);
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_rename(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    const char *name1 = NULL;
    const char *name2 = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            name1 = HCC_STRING(item);
            break;
        case LC_PATH2:
            name2 = HCC_STRING(item);
            break;
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (name1 == NULL || name2 == NULL)
        return(-2);
    return(rename(name1, name2));
}

/*
 * UTIMES
 */
int
hc_utimes(struct HostConf *hc, const char *path, const struct timeval *times)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL) {
        return(utimes(path, times));
    }

    trans = hcc_start_command(hc, HC_UTIMES);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int64(trans, LC_ATIME, times[0].tv_sec);
    hcc_leaf_int64(trans, LC_MTIME, times[1].tv_sec);
#if defined(st_atime)
    hcc_leaf_int32(trans, LC_ATIMENSEC, times[0].tv_usec * 1000);
    hcc_leaf_int32(trans, LC_MTIMENSEC, times[1].tv_usec * 1000);
#endif
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

int
hc_lutimes(struct HostConf *hc, const char *path, const struct timeval *times)
{
    hctransaction_t trans;
    struct HCHead *head;

    if (NotForRealOpt)
        return(0);
    if (hc == NULL || hc->host == NULL) {
        return(lutimes(path, times));
    }

    trans = hcc_start_command(hc, HC_LUTIMES);
    hcc_leaf_string(trans, LC_PATH1, path);
    hcc_leaf_int64(trans, LC_ATIME, times[0].tv_sec);
    hcc_leaf_int64(trans, LC_MTIME, times[1].tv_sec);
#if defined(st_atime)
    hcc_leaf_int32(trans, LC_ATIMENSEC, times[0].tv_usec * 1000);
    hcc_leaf_int32(trans, LC_MTIMENSEC, times[1].tv_usec * 1000);
#endif
    if ((head = hcc_finish_command(trans)) == NULL)
        return(-1);
    if (head->error)
        return(-1);
    return(0);
}

static int
rc_utimes(hctransaction_t trans, struct HCHead *head)
{
    struct HCLeaf *item;
    struct timeval times[2];
    const char *path;

    bzero(times, sizeof(times));
    path = NULL;

    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_PATH1:
            path = HCC_STRING(item);
            break;
        case LC_ATIME:
            times[0].tv_sec = HCC_INT64(item);
            break;
        case LC_MTIME:
            times[1].tv_sec = HCC_INT64(item);
            break;
#if defined(st_atimespec) || defined(_STATBUF_ST_NSEC)
        case LC_ATIMENSEC:
            times[0].tv_usec = HCC_INT32(item) / 1000;
            break;
        case LC_MTIMENSEC:
            times[1].tv_usec = HCC_INT32(item) / 1000;
            break;
#endif
        }
    }
    if (ReadOnlyOpt) {
        head->error = EACCES;
        return (0);
    }
    if (path == NULL)
        return(-2);
    if (head->cmd == HC_LUTIMES)
            return(lutimes(path, times));
    else
            return(utimes(path, times));
}

uid_t
hc_geteuid(struct HostConf *hc)
{
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;

    if (hc == NULL || hc->host == NULL)
        return (geteuid());

    if (hc->version < 3) {
        fprintf(stderr, "WARNING: Remote client uses old protocol version\n");
        /* Return 0 on error, so the caller assumes root privileges. */
        return (0);
    }

    trans = hcc_start_command(hc, HC_GETEUID);
    if ((head = hcc_finish_command(trans)) == NULL || head->error)
        return(0);
    FOR_EACH_ITEM(item, trans, head) {
        if (item->leafid == LC_UID)
            return (HCC_INT32(item));
    }
    return(0); /* shouldn't happen */
}

static int
rc_geteuid(hctransaction_t trans, struct HCHead *head __unused)
{
    hcc_leaf_int32(trans, LC_UID, geteuid());
    return (0);
}

static int
getmygroups(gid_t **gidlist)
{
    int count;

    if ((count = getgroups(0, *gidlist)) > 0) {
        if ((*gidlist = malloc(count * sizeof(gid_t))) != NULL) {
            if ((count = getgroups(count, *gidlist)) <= 0)
                free(*gidlist);
        }
        else
            count = -1;
    }
    else
        *gidlist = NULL;
    return (count);
}

int
hc_getgroups(struct HostConf *hc, gid_t **gidlist)
{
    int count, i;
    hctransaction_t trans;
    struct HCHead *head;
    struct HCLeaf *item;

    if (hc == NULL || hc->host == NULL)
        return (getmygroups(gidlist));

    i = 0;
    count = 0;
    *gidlist = NULL;

    if (hc->version < 3) {
        fprintf(stderr, "WARNING: Remote client uses old protocol version\n");
        return (-1);
    }

    trans = hcc_start_command(hc, HC_GETGROUPS);
    if ((head = hcc_finish_command(trans)) == NULL || head->error)
        return(-1);
    FOR_EACH_ITEM(item, trans, head) {
        switch(item->leafid) {
        case LC_COUNT:
            count = HCC_INT32(item);
            if (*gidlist != NULL) { /* protocol error */
                free(*gidlist);
                *gidlist = NULL;
                return (-1);
            }
            if ((*gidlist = malloc(count * sizeof(gid_t))) == NULL)
                return (-1);
            break;
        case LC_GID:
            if (*gidlist == NULL || i >= count) { /* protocol error */
                if (*gidlist != NULL)
                    free(*gidlist);
                *gidlist = NULL;
                return (-1);
            }
            (*gidlist)[i++] = HCC_INT32(item);
            break;
        }
    }
    return (count);
}

static int
rc_getgroups(hctransaction_t trans, struct HCHead *head __unused)
{
    int count, i;
    gid_t *gidlist;

    if ((count = getmygroups(&gidlist)) < 0)
        return (-1);
    hcc_leaf_int32(trans, LC_COUNT, count);
    for (i = 0; i < count; i++)
        hcc_leaf_int32(trans, LC_GID, gidlist[i]);
    if (gidlist != NULL)
        free(gidlist);
    return (0);
}