| /* |
| * Helper for QEMU Proxy FS Driver |
| * Copyright IBM, Corp. 2011 |
| * |
| * Authors: |
| * M. Mohan Kumar <mohan@in.ibm.com> |
| * |
| * This work is licensed under the terms of the GNU GPL, version 2. See |
| * the COPYING file in the top-level directory. |
| */ |
| |
| #include <sys/resource.h> |
| #include <getopt.h> |
| #include <syslog.h> |
| #include <sys/capability.h> |
| #include <sys/fsuid.h> |
| #include <sys/vfs.h> |
| #include <sys/ioctl.h> |
| #include <linux/fs.h> |
| #ifdef CONFIG_LINUX_MAGIC_H |
| #include <linux/magic.h> |
| #endif |
| #include "qemu-common.h" |
| #include "qemu/sockets.h" |
| #include "qemu/xattr.h" |
| #include "virtio-9p-marshal.h" |
| #include "hw/9pfs/virtio-9p-proxy.h" |
| #include "fsdev/virtio-9p-marshal.h" |
| |
| #define PROGNAME "virtfs-proxy-helper" |
| |
| #ifndef XFS_SUPER_MAGIC |
| #define XFS_SUPER_MAGIC 0x58465342 |
| #endif |
| #ifndef EXT2_SUPER_MAGIC |
| #define EXT2_SUPER_MAGIC 0xEF53 |
| #endif |
| #ifndef REISERFS_SUPER_MAGIC |
| #define REISERFS_SUPER_MAGIC 0x52654973 |
| #endif |
| #ifndef BTRFS_SUPER_MAGIC |
| #define BTRFS_SUPER_MAGIC 0x9123683E |
| #endif |
| |
| static struct option helper_opts[] = { |
| {"fd", required_argument, NULL, 'f'}, |
| {"path", required_argument, NULL, 'p'}, |
| {"nodaemon", no_argument, NULL, 'n'}, |
| {"socket", required_argument, NULL, 's'}, |
| {"uid", required_argument, NULL, 'u'}, |
| {"gid", required_argument, NULL, 'g'}, |
| }; |
| |
| static bool is_daemon; |
| static bool get_version; /* IOC getversion IOCTL supported */ |
| |
| static void GCC_FMT_ATTR(2, 3) do_log(int loglevel, const char *format, ...) |
| { |
| va_list ap; |
| |
| va_start(ap, format); |
| if (is_daemon) { |
| vsyslog(LOG_CRIT, format, ap); |
| } else { |
| vfprintf(stderr, format, ap); |
| } |
| va_end(ap); |
| } |
| |
| static void do_perror(const char *string) |
| { |
| if (is_daemon) { |
| syslog(LOG_CRIT, "%s:%s", string, strerror(errno)); |
| } else { |
| fprintf(stderr, "%s:%s\n", string, strerror(errno)); |
| } |
| } |
| |
| static int do_cap_set(cap_value_t *cap_value, int size, int reset) |
| { |
| cap_t caps; |
| if (reset) { |
| /* |
| * Start with an empty set and set permitted and effective |
| */ |
| caps = cap_init(); |
| if (caps == NULL) { |
| do_perror("cap_init"); |
| return -1; |
| } |
| if (cap_set_flag(caps, CAP_PERMITTED, size, cap_value, CAP_SET) < 0) { |
| do_perror("cap_set_flag"); |
| goto error; |
| } |
| } else { |
| caps = cap_get_proc(); |
| if (!caps) { |
| do_perror("cap_get_proc"); |
| return -1; |
| } |
| } |
| if (cap_set_flag(caps, CAP_EFFECTIVE, size, cap_value, CAP_SET) < 0) { |
| do_perror("cap_set_flag"); |
| goto error; |
| } |
| if (cap_set_proc(caps) < 0) { |
| do_perror("cap_set_proc"); |
| goto error; |
| } |
| cap_free(caps); |
| return 0; |
| |
| error: |
| cap_free(caps); |
| return -1; |
| } |
| |
| static int init_capabilities(void) |
| { |
| /* helper needs following capbabilities only */ |
| cap_value_t cap_list[] = { |
| CAP_CHOWN, |
| CAP_DAC_OVERRIDE, |
| CAP_FOWNER, |
| CAP_FSETID, |
| CAP_SETGID, |
| CAP_MKNOD, |
| CAP_SETUID, |
| }; |
| return do_cap_set(cap_list, ARRAY_SIZE(cap_list), 1); |
| } |
| |
| static int socket_read(int sockfd, void *buff, ssize_t size) |
| { |
| ssize_t retval, total = 0; |
| |
| while (size) { |
| retval = read(sockfd, buff, size); |
| if (retval == 0) { |
| return -EIO; |
| } |
| if (retval < 0) { |
| if (errno == EINTR) { |
| continue; |
| } |
| return -errno; |
| } |
| size -= retval; |
| buff += retval; |
| total += retval; |
| } |
| return total; |
| } |
| |
| static int socket_write(int sockfd, void *buff, ssize_t size) |
| { |
| ssize_t retval, total = 0; |
| |
| while (size) { |
| retval = write(sockfd, buff, size); |
| if (retval < 0) { |
| if (errno == EINTR) { |
| continue; |
| } |
| return -errno; |
| } |
| size -= retval; |
| buff += retval; |
| total += retval; |
| } |
| return total; |
| } |
| |
| static int read_request(int sockfd, struct iovec *iovec, ProxyHeader *header) |
| { |
| int retval; |
| |
| /* |
| * read the request header. |
| */ |
| iovec->iov_len = 0; |
| retval = socket_read(sockfd, iovec->iov_base, PROXY_HDR_SZ); |
| if (retval < 0) { |
| return retval; |
| } |
| iovec->iov_len = PROXY_HDR_SZ; |
| retval = proxy_unmarshal(iovec, 0, "dd", &header->type, &header->size); |
| if (retval < 0) { |
| return retval; |
| } |
| /* |
| * We can't process message.size > PROXY_MAX_IO_SZ. |
| * Treat it as fatal error |
| */ |
| if (header->size > PROXY_MAX_IO_SZ) { |
| return -ENOBUFS; |
| } |
| retval = socket_read(sockfd, iovec->iov_base + PROXY_HDR_SZ, header->size); |
| if (retval < 0) { |
| return retval; |
| } |
| iovec->iov_len += header->size; |
| return 0; |
| } |
| |
| static int send_fd(int sockfd, int fd) |
| { |
| struct msghdr msg; |
| struct iovec iov; |
| int retval, data; |
| struct cmsghdr *cmsg; |
| union MsgControl msg_control; |
| |
| iov.iov_base = &data; |
| iov.iov_len = sizeof(data); |
| |
| memset(&msg, 0, sizeof(msg)); |
| msg.msg_iov = &iov; |
| msg.msg_iovlen = 1; |
| /* No ancillary data on error */ |
| if (fd < 0) { |
| /* fd is really negative errno if the request failed */ |
| data = fd; |
| } else { |
| data = V9FS_FD_VALID; |
| msg.msg_control = &msg_control; |
| msg.msg_controllen = sizeof(msg_control); |
| |
| cmsg = &msg_control.cmsg; |
| cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); |
| cmsg->cmsg_level = SOL_SOCKET; |
| cmsg->cmsg_type = SCM_RIGHTS; |
| memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); |
| } |
| |
| do { |
| retval = sendmsg(sockfd, &msg, 0); |
| } while (retval < 0 && errno == EINTR); |
| if (fd >= 0) { |
| close(fd); |
| } |
| if (retval < 0) { |
| return retval; |
| } |
| return 0; |
| } |
| |
| static int send_status(int sockfd, struct iovec *iovec, int status) |
| { |
| ProxyHeader header; |
| int retval, msg_size;; |
| |
| if (status < 0) { |
| header.type = T_ERROR; |
| } else { |
| header.type = T_SUCCESS; |
| } |
| header.size = sizeof(status); |
| /* |
| * marshal the return status. We don't check error. |
| * because we are sure we have enough space for the status |
| */ |
| msg_size = proxy_marshal(iovec, 0, "ddd", header.type, |
| header.size, status); |
| retval = socket_write(sockfd, iovec->iov_base, msg_size); |
| if (retval < 0) { |
| return retval; |
| } |
| return 0; |
| } |
| |
| /* |
| * from man 7 capabilities, section |
| * Effect of User ID Changes on Capabilities: |
| * If the effective user ID is changed from nonzero to 0, then the permitted |
| * set is copied to the effective set. If the effective user ID is changed |
| * from 0 to nonzero, then all capabilities are are cleared from the effective |
| * set. |
| * |
| * The setfsuid/setfsgid man pages warn that changing the effective user ID may |
| * expose the program to unwanted signals, but this is not true anymore: for an |
| * unprivileged (without CAP_KILL) program to send a signal, the real or |
| * effective user ID of the sending process must equal the real or saved user |
| * ID of the target process. Even when dropping privileges, it is enough to |
| * keep the saved UID to a "privileged" value and virtfs-proxy-helper won't |
| * be exposed to signals. So just use setresuid/setresgid. |
| */ |
| static int setugid(int uid, int gid, int *suid, int *sgid) |
| { |
| int retval; |
| |
| /* |
| * We still need DAC_OVERRIDE because we don't change |
| * supplementary group ids, and hence may be subjected DAC rules |
| */ |
| cap_value_t cap_list[] = { |
| CAP_DAC_OVERRIDE, |
| }; |
| |
| *suid = geteuid(); |
| *sgid = getegid(); |
| |
| if (setresgid(-1, gid, *sgid) == -1) { |
| retval = -errno; |
| goto err_out; |
| } |
| |
| if (setresuid(-1, uid, *suid) == -1) { |
| retval = -errno; |
| goto err_sgid; |
| } |
| |
| if (uid != 0 || gid != 0) { |
| if (do_cap_set(cap_list, ARRAY_SIZE(cap_list), 0) < 0) { |
| retval = -errno; |
| goto err_suid; |
| } |
| } |
| return 0; |
| |
| err_suid: |
| if (setresuid(-1, *suid, *suid) == -1) { |
| abort(); |
| } |
| err_sgid: |
| if (setresgid(-1, *sgid, *sgid) == -1) { |
| abort(); |
| } |
| err_out: |
| return retval; |
| } |
| |
| /* |
| * This is used to reset the ugid back with the saved values |
| * There is nothing much we can do checking error values here. |
| */ |
| static void resetugid(int suid, int sgid) |
| { |
| if (setresgid(-1, sgid, sgid) == -1) { |
| abort(); |
| } |
| if (setresuid(-1, suid, suid) == -1) { |
| abort(); |
| } |
| } |
| |
| /* |
| * send response in two parts |
| * 1) ProxyHeader |
| * 2) Response or error status |
| * This function should be called with marshaled response |
| * send_response constructs header part and error part only. |
| * send response sends {ProxyHeader,Response} if the request was success |
| * otherwise sends {ProxyHeader,error status} |
| */ |
| static int send_response(int sock, struct iovec *iovec, int size) |
| { |
| int retval; |
| ProxyHeader header; |
| |
| /* |
| * If response size exceeds available iovec->iov_len, |
| * we return ENOBUFS |
| */ |
| if (size > PROXY_MAX_IO_SZ) { |
| size = -ENOBUFS; |
| } |
| |
| if (size < 0) { |
| /* |
| * In case of error we would not have got the error encoded |
| * already so encode the error here. |
| */ |
| header.type = T_ERROR; |
| header.size = sizeof(size); |
| proxy_marshal(iovec, PROXY_HDR_SZ, "d", size); |
| } else { |
| header.type = T_SUCCESS; |
| header.size = size; |
| } |
| proxy_marshal(iovec, 0, "dd", header.type, header.size); |
| retval = socket_write(sock, iovec->iov_base, header.size + PROXY_HDR_SZ); |
| if (retval < 0) { |
| return retval;; |
| } |
| return 0; |
| } |
| |
| /* |
| * gets generation number |
| * returns -errno on failure and sizeof(generation number) on success |
| */ |
| static int do_getversion(struct iovec *iovec, struct iovec *out_iovec) |
| { |
| uint64_t version; |
| int retval = -ENOTTY; |
| #ifdef FS_IOC_GETVERSION |
| int fd; |
| V9fsString path; |
| #endif |
| |
| |
| /* no need to issue ioctl */ |
| if (!get_version) { |
| version = 0; |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "q", version); |
| return retval; |
| } |
| #ifdef FS_IOC_GETVERSION |
| retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "s", &path); |
| if (retval < 0) { |
| return retval; |
| } |
| |
| fd = open(path.data, O_RDONLY); |
| if (fd < 0) { |
| retval = -errno; |
| goto err_out; |
| } |
| if (ioctl(fd, FS_IOC_GETVERSION, &version) < 0) { |
| retval = -errno; |
| } else { |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "q", version); |
| } |
| close(fd); |
| err_out: |
| v9fs_string_free(&path); |
| #endif |
| return retval; |
| } |
| |
| static int do_getxattr(int type, struct iovec *iovec, struct iovec *out_iovec) |
| { |
| int size = 0, offset, retval; |
| V9fsString path, name, xattr; |
| |
| v9fs_string_init(&xattr); |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "ds", &size, &path); |
| if (retval < 0) { |
| return retval; |
| } |
| offset = PROXY_HDR_SZ + retval; |
| |
| if (size) { |
| xattr.data = g_malloc(size); |
| xattr.size = size; |
| } |
| switch (type) { |
| case T_LGETXATTR: |
| v9fs_string_init(&name); |
| retval = proxy_unmarshal(iovec, offset, "s", &name); |
| if (retval > 0) { |
| retval = lgetxattr(path.data, name.data, xattr.data, size); |
| if (retval < 0) { |
| retval = -errno; |
| } else { |
| xattr.size = retval; |
| } |
| } |
| v9fs_string_free(&name); |
| break; |
| case T_LLISTXATTR: |
| retval = llistxattr(path.data, xattr.data, size); |
| if (retval < 0) { |
| retval = -errno; |
| } else { |
| xattr.size = retval; |
| } |
| break; |
| } |
| if (retval < 0) { |
| goto err_out; |
| } |
| |
| if (!size) { |
| proxy_marshal(out_iovec, PROXY_HDR_SZ, "d", retval); |
| retval = sizeof(retval); |
| } else { |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "s", &xattr); |
| } |
| err_out: |
| v9fs_string_free(&xattr); |
| v9fs_string_free(&path); |
| return retval; |
| } |
| |
| static void stat_to_prstat(ProxyStat *pr_stat, struct stat *stat) |
| { |
| memset(pr_stat, 0, sizeof(*pr_stat)); |
| pr_stat->st_dev = stat->st_dev; |
| pr_stat->st_ino = stat->st_ino; |
| pr_stat->st_nlink = stat->st_nlink; |
| pr_stat->st_mode = stat->st_mode; |
| pr_stat->st_uid = stat->st_uid; |
| pr_stat->st_gid = stat->st_gid; |
| pr_stat->st_rdev = stat->st_rdev; |
| pr_stat->st_size = stat->st_size; |
| pr_stat->st_blksize = stat->st_blksize; |
| pr_stat->st_blocks = stat->st_blocks; |
| pr_stat->st_atim_sec = stat->st_atim.tv_sec; |
| pr_stat->st_atim_nsec = stat->st_atim.tv_nsec; |
| pr_stat->st_mtim_sec = stat->st_mtim.tv_sec; |
| pr_stat->st_mtim_nsec = stat->st_mtim.tv_nsec; |
| pr_stat->st_ctim_sec = stat->st_ctim.tv_sec; |
| pr_stat->st_ctim_nsec = stat->st_ctim.tv_nsec; |
| } |
| |
| static void statfs_to_prstatfs(ProxyStatFS *pr_stfs, struct statfs *stfs) |
| { |
| memset(pr_stfs, 0, sizeof(*pr_stfs)); |
| pr_stfs->f_type = stfs->f_type; |
| pr_stfs->f_bsize = stfs->f_bsize; |
| pr_stfs->f_blocks = stfs->f_blocks; |
| pr_stfs->f_bfree = stfs->f_bfree; |
| pr_stfs->f_bavail = stfs->f_bavail; |
| pr_stfs->f_files = stfs->f_files; |
| pr_stfs->f_ffree = stfs->f_ffree; |
| pr_stfs->f_fsid[0] = stfs->f_fsid.__val[0]; |
| pr_stfs->f_fsid[1] = stfs->f_fsid.__val[1]; |
| pr_stfs->f_namelen = stfs->f_namelen; |
| pr_stfs->f_frsize = stfs->f_frsize; |
| } |
| |
| /* |
| * Gets stat/statfs information and packs in out_iovec structure |
| * on success returns number of bytes packed in out_iovec struture |
| * otherwise returns -errno |
| */ |
| static int do_stat(int type, struct iovec *iovec, struct iovec *out_iovec) |
| { |
| int retval; |
| V9fsString path; |
| ProxyStat pr_stat; |
| ProxyStatFS pr_stfs; |
| struct stat st_buf; |
| struct statfs stfs_buf; |
| |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "s", &path); |
| if (retval < 0) { |
| return retval; |
| } |
| |
| switch (type) { |
| case T_LSTAT: |
| retval = lstat(path.data, &st_buf); |
| if (retval < 0) { |
| retval = -errno; |
| } else { |
| stat_to_prstat(&pr_stat, &st_buf); |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, |
| "qqqdddqqqqqqqqqq", pr_stat.st_dev, |
| pr_stat.st_ino, pr_stat.st_nlink, |
| pr_stat.st_mode, pr_stat.st_uid, |
| pr_stat.st_gid, pr_stat.st_rdev, |
| pr_stat.st_size, pr_stat.st_blksize, |
| pr_stat.st_blocks, |
| pr_stat.st_atim_sec, pr_stat.st_atim_nsec, |
| pr_stat.st_mtim_sec, pr_stat.st_mtim_nsec, |
| pr_stat.st_ctim_sec, pr_stat.st_ctim_nsec); |
| } |
| break; |
| case T_STATFS: |
| retval = statfs(path.data, &stfs_buf); |
| if (retval < 0) { |
| retval = -errno; |
| } else { |
| statfs_to_prstatfs(&pr_stfs, &stfs_buf); |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, |
| "qqqqqqqqqqq", pr_stfs.f_type, |
| pr_stfs.f_bsize, pr_stfs.f_blocks, |
| pr_stfs.f_bfree, pr_stfs.f_bavail, |
| pr_stfs.f_files, pr_stfs.f_ffree, |
| pr_stfs.f_fsid[0], pr_stfs.f_fsid[1], |
| pr_stfs.f_namelen, pr_stfs.f_frsize); |
| } |
| break; |
| } |
| v9fs_string_free(&path); |
| return retval; |
| } |
| |
| static int do_readlink(struct iovec *iovec, struct iovec *out_iovec) |
| { |
| char *buffer; |
| int size, retval; |
| V9fsString target, path; |
| |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sd", &path, &size); |
| if (retval < 0) { |
| v9fs_string_free(&path); |
| return retval; |
| } |
| buffer = g_malloc(size); |
| v9fs_string_init(&target); |
| retval = readlink(path.data, buffer, size); |
| if (retval > 0) { |
| buffer[retval] = '\0'; |
| v9fs_string_sprintf(&target, "%s", buffer); |
| retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "s", &target); |
| } else { |
| retval = -errno; |
| } |
| g_free(buffer); |
| v9fs_string_free(&target); |
| v9fs_string_free(&path); |
| return retval; |
| } |
| |
| /* |
| * create other filesystem objects and send 0 on success |
| * return -errno on error |
| */ |
| static int do_create_others(int type, struct iovec *iovec) |
| { |
| dev_t rdev; |
| int retval = 0; |
| int offset = PROXY_HDR_SZ; |
| V9fsString oldpath, path; |
| int mode, uid, gid, cur_uid, cur_gid; |
| |
| v9fs_string_init(&path); |
| v9fs_string_init(&oldpath); |
| |
| retval = proxy_unmarshal(iovec, offset, "dd", &uid, &gid); |
| if (retval < 0) { |
| return retval; |
| } |
| offset += retval; |
| retval = setugid(uid, gid, &cur_uid, &cur_gid); |
| if (retval < 0) { |
| goto unmarshal_err_out; |
| } |
| switch (type) { |
| case T_MKNOD: |
| retval = proxy_unmarshal(iovec, offset, "sdq", &path, &mode, &rdev); |
| if (retval < 0) { |
| goto err_out; |
| } |
| retval = mknod(path.data, mode, rdev); |
| break; |
| case T_MKDIR: |
| retval = proxy_unmarshal(iovec, offset, "sd", &path, &mode); |
| if (retval < 0) { |
| goto err_out; |
| } |
| retval = mkdir(path.data, mode); |
| break; |
| case T_SYMLINK: |
| retval = proxy_unmarshal(iovec, offset, "ss", &oldpath, &path); |
| if (retval < 0) { |
| goto err_out; |
| } |
| retval = symlink(oldpath.data, path.data); |
| break; |
| } |
| if (retval < 0) { |
| retval = -errno; |
| } |
| |
| err_out: |
| resetugid(cur_uid, cur_gid); |
| unmarshal_err_out: |
| v9fs_string_free(&path); |
| v9fs_string_free(&oldpath); |
| return retval; |
| } |
| |
| /* |
| * create a file and send fd on success |
| * return -errno on error |
| */ |
| static int do_create(struct iovec *iovec) |
| { |
| int ret; |
| V9fsString path; |
| int flags, mode, uid, gid, cur_uid, cur_gid; |
| |
| v9fs_string_init(&path); |
| ret = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sdddd", |
| &path, &flags, &mode, &uid, &gid); |
| if (ret < 0) { |
| goto unmarshal_err_out; |
| } |
| ret = setugid(uid, gid, &cur_uid, &cur_gid); |
| if (ret < 0) { |
| goto unmarshal_err_out; |
| } |
| ret = open(path.data, flags, mode); |
| if (ret < 0) { |
| ret = -errno; |
| } |
| |
| resetugid(cur_uid, cur_gid); |
| unmarshal_err_out: |
| v9fs_string_free(&path); |
| return ret; |
| } |
| |
| /* |
| * open a file and send fd on success |
| * return -errno on error |
| */ |
| static int do_open(struct iovec *iovec) |
| { |
| int flags, ret; |
| V9fsString path; |
| |
| v9fs_string_init(&path); |
| ret = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sd", &path, &flags); |
| if (ret < 0) { |
| goto err_out; |
| } |
| ret = open(path.data, flags); |
| if (ret < 0) { |
| ret = -errno; |
| } |
| err_out: |
| v9fs_string_free(&path); |
| return ret; |
| } |
| |
| /* create unix domain socket and return the descriptor */ |
| static int proxy_socket(const char *path, uid_t uid, gid_t gid) |
| { |
| int sock, client; |
| struct sockaddr_un proxy, qemu; |
| socklen_t size; |
| |
| /* requested socket already exists, refuse to start */ |
| if (!access(path, F_OK)) { |
| do_log(LOG_CRIT, "socket already exists\n"); |
| return -1; |
| } |
| |
| sock = socket(AF_UNIX, SOCK_STREAM, 0); |
| if (sock < 0) { |
| do_perror("socket"); |
| return -1; |
| } |
| |
| /* mask other part of mode bits */ |
| umask(7); |
| |
| proxy.sun_family = AF_UNIX; |
| strcpy(proxy.sun_path, path); |
| if (bind(sock, (struct sockaddr *)&proxy, |
| sizeof(struct sockaddr_un)) < 0) { |
| do_perror("bind"); |
| return -1; |
| } |
| if (chown(proxy.sun_path, uid, gid) < 0) { |
| do_perror("chown"); |
| return -1; |
| } |
| if (listen(sock, 1) < 0) { |
| do_perror("listen"); |
| return -1; |
| } |
| |
| client = accept(sock, (struct sockaddr *)&qemu, &size); |
| if (client < 0) { |
| do_perror("accept"); |
| return -1; |
| } |
| return client; |
| } |
| |
| static void usage(char *prog) |
| { |
| fprintf(stderr, "usage: %s\n" |
| " -p|--path <path> 9p path to export\n" |
| " {-f|--fd <socket-descriptor>} socket file descriptor to be used\n" |
| " {-s|--socket <socketname> socket file used for communication\n" |
| " \t-u|--uid <uid> -g|--gid <gid>} - uid:gid combination to give " |
| " access to this socket\n" |
| " \tNote: -s & -f can not be used together\n" |
| " [-n|--nodaemon] Run as a normal program\n", |
| basename(prog)); |
| } |
| |
| static int process_reply(int sock, int type, |
| struct iovec *out_iovec, int retval) |
| { |
| switch (type) { |
| case T_OPEN: |
| case T_CREATE: |
| if (send_fd(sock, retval) < 0) { |
| return -1; |
| } |
| break; |
| case T_MKNOD: |
| case T_MKDIR: |
| case T_SYMLINK: |
| case T_LINK: |
| case T_CHMOD: |
| case T_CHOWN: |
| case T_TRUNCATE: |
| case T_UTIME: |
| case T_RENAME: |
| case T_REMOVE: |
| case T_LSETXATTR: |
| case T_LREMOVEXATTR: |
| if (send_status(sock, out_iovec, retval) < 0) { |
| return -1; |
| } |
| break; |
| case T_LSTAT: |
| case T_STATFS: |
| case T_READLINK: |
| case T_LGETXATTR: |
| case T_LLISTXATTR: |
| case T_GETVERSION: |
| if (send_response(sock, out_iovec, retval) < 0) { |
| return -1; |
| } |
| break; |
| default: |
| return -1; |
| break; |
| } |
| return 0; |
| } |
| |
| static int process_requests(int sock) |
| { |
| int flags; |
| int size = 0; |
| int retval = 0; |
| uint64_t offset; |
| ProxyHeader header; |
| int mode, uid, gid; |
| V9fsString name, value; |
| struct timespec spec[2]; |
| V9fsString oldpath, path; |
| struct iovec in_iovec, out_iovec; |
| |
| in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); |
| in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; |
| out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); |
| out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; |
| |
| while (1) { |
| /* |
| * initialize the header type, so that we send |
| * response to proper request type. |
| */ |
| header.type = 0; |
| retval = read_request(sock, &in_iovec, &header); |
| if (retval < 0) { |
| goto err_out; |
| } |
| |
| switch (header.type) { |
| case T_OPEN: |
| retval = do_open(&in_iovec); |
| break; |
| case T_CREATE: |
| retval = do_create(&in_iovec); |
| break; |
| case T_MKNOD: |
| case T_MKDIR: |
| case T_SYMLINK: |
| retval = do_create_others(header.type, &in_iovec); |
| break; |
| case T_LINK: |
| v9fs_string_init(&path); |
| v9fs_string_init(&oldpath); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, |
| "ss", &oldpath, &path); |
| if (retval > 0) { |
| retval = link(oldpath.data, path.data); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&oldpath); |
| v9fs_string_free(&path); |
| break; |
| case T_LSTAT: |
| case T_STATFS: |
| retval = do_stat(header.type, &in_iovec, &out_iovec); |
| break; |
| case T_READLINK: |
| retval = do_readlink(&in_iovec, &out_iovec); |
| break; |
| case T_CHMOD: |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, |
| "sd", &path, &mode); |
| if (retval > 0) { |
| retval = chmod(path.data, mode); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| break; |
| case T_CHOWN: |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sdd", &path, |
| &uid, &gid); |
| if (retval > 0) { |
| retval = lchown(path.data, uid, gid); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| break; |
| case T_TRUNCATE: |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sq", |
| &path, &offset); |
| if (retval > 0) { |
| retval = truncate(path.data, offset); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| break; |
| case T_UTIME: |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sqqqq", &path, |
| &spec[0].tv_sec, &spec[0].tv_nsec, |
| &spec[1].tv_sec, &spec[1].tv_nsec); |
| if (retval > 0) { |
| retval = qemu_utimens(path.data, spec); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| break; |
| case T_RENAME: |
| v9fs_string_init(&path); |
| v9fs_string_init(&oldpath); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, |
| "ss", &oldpath, &path); |
| if (retval > 0) { |
| retval = rename(oldpath.data, path.data); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&oldpath); |
| v9fs_string_free(&path); |
| break; |
| case T_REMOVE: |
| v9fs_string_init(&path); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "s", &path); |
| if (retval > 0) { |
| retval = remove(path.data); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| break; |
| case T_LGETXATTR: |
| case T_LLISTXATTR: |
| retval = do_getxattr(header.type, &in_iovec, &out_iovec); |
| break; |
| case T_LSETXATTR: |
| v9fs_string_init(&path); |
| v9fs_string_init(&name); |
| v9fs_string_init(&value); |
| retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sssdd", &path, |
| &name, &value, &size, &flags); |
| if (retval > 0) { |
| retval = lsetxattr(path.data, |
| name.data, value.data, size, flags); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| v9fs_string_free(&name); |
| v9fs_string_free(&value); |
| break; |
| case T_LREMOVEXATTR: |
| v9fs_string_init(&path); |
| v9fs_string_init(&name); |
| retval = proxy_unmarshal(&in_iovec, |
| PROXY_HDR_SZ, "ss", &path, &name); |
| if (retval > 0) { |
| retval = lremovexattr(path.data, name.data); |
| if (retval < 0) { |
| retval = -errno; |
| } |
| } |
| v9fs_string_free(&path); |
| v9fs_string_free(&name); |
| break; |
| case T_GETVERSION: |
| retval = do_getversion(&in_iovec, &out_iovec); |
| break; |
| default: |
| goto err_out; |
| break; |
| } |
| |
| if (process_reply(sock, header.type, &out_iovec, retval) < 0) { |
| goto err_out; |
| } |
| } |
| err_out: |
| g_free(in_iovec.iov_base); |
| g_free(out_iovec.iov_base); |
| return -1; |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int sock; |
| uid_t own_u; |
| gid_t own_g; |
| char *rpath = NULL; |
| char *sock_name = NULL; |
| struct stat stbuf; |
| int c, option_index; |
| #ifdef FS_IOC_GETVERSION |
| int retval; |
| struct statfs st_fs; |
| #endif |
| |
| is_daemon = true; |
| sock = -1; |
| own_u = own_g = -1; |
| while (1) { |
| option_index = 0; |
| c = getopt_long(argc, argv, "p:nh?f:s:u:g:", helper_opts, |
| &option_index); |
| if (c == -1) { |
| break; |
| } |
| switch (c) { |
| case 'p': |
| rpath = g_strdup(optarg); |
| break; |
| case 'n': |
| is_daemon = false; |
| break; |
| case 'f': |
| sock = atoi(optarg); |
| break; |
| case 's': |
| sock_name = g_strdup(optarg); |
| break; |
| case 'u': |
| own_u = atoi(optarg); |
| break; |
| case 'g': |
| own_g = atoi(optarg); |
| break; |
| case '?': |
| case 'h': |
| default: |
| usage(argv[0]); |
| exit(EXIT_FAILURE); |
| } |
| } |
| |
| /* Parameter validation */ |
| if ((sock_name == NULL && sock == -1) || rpath == NULL) { |
| fprintf(stderr, "socket, socket descriptor or path not specified\n"); |
| usage(argv[0]); |
| return -1; |
| } |
| |
| if (sock_name && sock != -1) { |
| fprintf(stderr, "both named socket and socket descriptor specified\n"); |
| usage(argv[0]); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (sock_name && (own_u == -1 || own_g == -1)) { |
| fprintf(stderr, "owner uid:gid not specified, "); |
| fprintf(stderr, |
| "owner uid:gid specifies who can access the socket file\n"); |
| usage(argv[0]); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (lstat(rpath, &stbuf) < 0) { |
| fprintf(stderr, "invalid path \"%s\" specified, %s\n", |
| rpath, strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (!S_ISDIR(stbuf.st_mode)) { |
| fprintf(stderr, "specified path \"%s\" is not directory\n", rpath); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (is_daemon) { |
| if (daemon(0, 0) < 0) { |
| fprintf(stderr, "daemon call failed\n"); |
| exit(EXIT_FAILURE); |
| } |
| openlog(PROGNAME, LOG_PID, LOG_DAEMON); |
| } |
| |
| do_log(LOG_INFO, "Started\n"); |
| if (sock_name) { |
| sock = proxy_socket(sock_name, own_u, own_g); |
| if (sock < 0) { |
| goto error; |
| } |
| } |
| |
| get_version = false; |
| #ifdef FS_IOC_GETVERSION |
| /* check whether underlying FS support IOC_GETVERSION */ |
| retval = statfs(rpath, &st_fs); |
| if (!retval) { |
| switch (st_fs.f_type) { |
| case EXT2_SUPER_MAGIC: |
| case BTRFS_SUPER_MAGIC: |
| case REISERFS_SUPER_MAGIC: |
| case XFS_SUPER_MAGIC: |
| get_version = true; |
| break; |
| } |
| } |
| #endif |
| |
| if (chdir("/") < 0) { |
| do_perror("chdir"); |
| goto error; |
| } |
| if (chroot(rpath) < 0) { |
| do_perror("chroot"); |
| goto error; |
| } |
| umask(0); |
| |
| if (init_capabilities() < 0) { |
| goto error; |
| } |
| |
| process_requests(sock); |
| error: |
| do_log(LOG_INFO, "Done\n"); |
| closelog(); |
| return 0; |
| } |
