| /* | |
| * 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. | |
| */ | |
| /* | |
| * NOTE: The 9p 'proxy' backend is deprecated (since QEMU 8.1) and will be | |
| * removed in a future version of QEMU! | |
| */ | |
| #include "qemu/osdep.h" | |
| #include <glib/gstdio.h> | |
| #include <sys/resource.h> | |
| #include <getopt.h> | |
| #include <syslog.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 <cap-ng.h> | |
| #include "qemu/sockets.h" | |
| #include "qemu/xattr.h" | |
| #include "9p-iov-marshal.h" | |
| #include "hw/9pfs/9p-proxy.h" | |
| #include "hw/9pfs/9p-util.h" | |
| #include "fsdev/9p-iov-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 const 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 char *prog_name; | |
| static void G_GNUC_PRINTF(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 init_capabilities(void) | |
| { | |
| /* helper needs following capabilities only */ | |
| int cap_list[] = { | |
| CAP_CHOWN, | |
| CAP_DAC_OVERRIDE, | |
| CAP_FOWNER, | |
| CAP_FSETID, | |
| CAP_SETGID, | |
| CAP_MKNOD, | |
| CAP_SETUID, | |
| }; | |
| int i; | |
| capng_clear(CAPNG_SELECT_BOTH); | |
| for (i = 0; i < ARRAY_SIZE(cap_list); i++) { | |
| if (capng_update(CAPNG_ADD, CAPNG_EFFECTIVE | CAPNG_PERMITTED, | |
| cap_list[i]) < 0) { | |
| do_perror("capng_update"); | |
| return -1; | |
| } | |
| } | |
| if (capng_apply(CAPNG_SELECT_BOTH) < 0) { | |
| do_perror("capng_apply"); | |
| return -1; | |
| } | |
| /* Prepare effective set for setugid. */ | |
| for (i = 0; i < ARRAY_SIZE(cap_list); i++) { | |
| if (cap_list[i] == CAP_DAC_OVERRIDE) { | |
| continue; | |
| } | |
| if (capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, | |
| cap_list[i]) < 0) { | |
| do_perror("capng_update"); | |
| return -1; | |
| } | |
| } | |
| return 0; | |
| } | |
| 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); | |
| if (msg_size < 0) { | |
| return msg_size; | |
| } | |
| 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; | |
| *suid = geteuid(); | |
| *sgid = getegid(); | |
| if (setresgid(-1, gid, *sgid) == -1) { | |
| return -errno; | |
| } | |
| if (setresuid(-1, uid, *suid) == -1) { | |
| retval = -errno; | |
| goto err_sgid; | |
| } | |
| if (uid == 0 && gid == 0) { | |
| /* Linux has already copied the permitted set to the effective set. */ | |
| return 0; | |
| } | |
| /* | |
| * All capabilities have been cleared from the effective set. However | |
| * we still need DAC_OVERRIDE because we don't change supplementary | |
| * group ids, and hence may be subject to DAC rules. init_capabilities | |
| * left the set of capabilities that we want in libcap-ng's state. | |
| */ | |
| if (capng_apply(CAPNG_SELECT_CAPS) < 0) { | |
| retval = -errno; | |
| do_perror("capng_apply"); | |
| goto err_suid; | |
| } | |
| return 0; | |
| err_suid: | |
| if (setresuid(-1, *suid, *suid) == -1) { | |
| abort(); | |
| } | |
| err_sgid: | |
| if (setresgid(-1, *sgid, *sgid) == -1) { | |
| abort(); | |
| } | |
| 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(); | |
| } | |
| } | |
| /* | |
| * Open regular file or directory. Attempts to open any special file are | |
| * rejected. | |
| * | |
| * returns file descriptor or -1 on error | |
| */ | |
| static int open_regular(const char *pathname, int flags, mode_t mode) | |
| { | |
| int fd; | |
| fd = open(pathname, flags, mode); | |
| if (fd < 0) { | |
| return fd; | |
| } | |
| if (close_if_special_file(fd) < 0) { | |
| return -1; | |
| } | |
| return fd; | |
| } | |
| /* | |
| * 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 structure | |
| * 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 - 1); | |
| 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 = g_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_regular(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_regular(path.data, flags, 0); | |
| 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; | |
| } | |
| if (strlen(path) >= sizeof(proxy.sun_path)) { | |
| do_log(LOG_CRIT, "UNIX domain socket path exceeds %zu characters\n", | |
| sizeof(proxy.sun_path)); | |
| 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"); | |
| goto error; | |
| } | |
| if (chown(proxy.sun_path, uid, gid) < 0) { | |
| do_perror("chown"); | |
| goto error; | |
| } | |
| if (listen(sock, 1) < 0) { | |
| do_perror("listen"); | |
| goto error; | |
| } | |
| size = sizeof(qemu); | |
| client = accept(sock, (struct sockaddr *)&qemu, &size); | |
| if (client < 0) { | |
| do_perror("accept"); | |
| goto error; | |
| } | |
| close(sock); | |
| return client; | |
| error: | |
| close(sock); | |
| return -1; | |
| } | |
| static void usage(void) | |
| { | |
| 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", | |
| prog_name); | |
| } | |
| 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 = utimensat(AT_FDCWD, path.data, spec, | |
| AT_SYMLINK_NOFOLLOW); | |
| 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 | |
| fprintf(stderr, "NOTE: The 9p 'proxy' backend is deprecated (since " | |
| "QEMU 8.1) and will be removed in a future version of " | |
| "QEMU!\n"); | |
| prog_name = g_path_get_basename(argv[0]); | |
| 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(); | |
| exit(EXIT_FAILURE); | |
| } | |
| } | |
| /* Parameter validation */ | |
| if ((sock_name == NULL && sock == -1) || rpath == NULL) { | |
| fprintf(stderr, "socket, socket descriptor or path not specified\n"); | |
| usage(); | |
| return -1; | |
| } | |
| if (sock_name && sock != -1) { | |
| fprintf(stderr, "both named socket and socket descriptor specified\n"); | |
| usage(); | |
| 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(); | |
| 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; | |
| } | |
| } | |
| if (chroot(rpath) < 0) { | |
| do_perror("chroot"); | |
| goto error; | |
| } | |
| if (chdir("/") < 0) { | |
| do_perror("chdir"); | |
| goto error; | |
| } | |
| get_version = false; | |
| #ifdef FS_IOC_GETVERSION | |
| /* check whether underlying FS support IOC_GETVERSION */ | |
| retval = statfs("/", &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 | |
| umask(0); | |
| if (init_capabilities() < 0) { | |
| goto error; | |
| } | |
| process_requests(sock); | |
| error: | |
| g_free(rpath); | |
| g_free(sock_name); | |
| do_log(LOG_INFO, "Done\n"); | |
| closelog(); | |
| return 0; | |
| } |