Esempio n. 1
0
/*
 * chown(2)
 *
 */
    ssize_t
alcove_sys_chown(alcove_state_t *ap, const char *arg, size_t len,
        char *reply, size_t rlen)
{
    int index = 0;

    char path[PATH_MAX] = {0};
    size_t plen = sizeof(path)-1;
    uid_t owner = {0};
    gid_t group = {0};
    int rv = 0;

    /* path */
    if (alcove_decode_iolist(arg, len, &index, path, &plen) < 0 ||
            plen == 0)
        return -1;

    /* owner */
    if (alcove_decode_uint(arg, len, &index, &owner) < 0)
        return -1;

    /* group */
    if (alcove_decode_uint(arg, len, &index, &group) < 0)
        return -1;

    rv = chown(path, owner, group);

    return (rv < 0)
        ? alcove_mk_errno(reply, rlen, errno)
        : alcove_mk_atom(reply, rlen, "ok");
}
Esempio n. 2
0
    static int
alcove_list_to_groups(const char *arg, size_t len, int *index,
        int type, gid_t *list, int arity)
{
    int n = 0;

    switch (type) {
        case ERL_STRING_EXT: {
            char *tmp = NULL;

            tmp = calloc(arity+1, 1);
            if (tmp == NULL)
                return -1;

            if (alcove_decode_string(arg, len, index, tmp, arity+1) < 0) {
                free(tmp);
                return -1;
            }

            for (n = 0; n < arity; n++)
                list[n] = tmp[n];

            free(tmp);
            }
            break;

        case ERL_LIST_EXT:
            if ( (alcove_decode_list_header(arg, len, index, &n) < 0)
                    || n != arity)
                return -1;

            for (n = 0; n < arity; n++) {
                gid_t gid = 0;

                if (alcove_decode_uint(arg, len, index, &gid) < 0)
                    return -1;

                list[n] = gid;
            }

            /* ignore the list tail */
            break;

        case ERL_NIL_EXT:
            break;

        default:
            return -1;
    }

    return 0;
}