![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to virtfs-proxy-helper.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / fsdev|
Return to virtfs-proxy-helper.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / fsdev |
1.1 ! root 1: /* ! 2: * Helper for QEMU Proxy FS Driver ! 3: * Copyright IBM, Corp. 2011 ! 4: * ! 5: * Authors: ! 6: * M. Mohan Kumar <[email protected]> ! 7: * ! 8: * This work is licensed under the terms of the GNU GPL, version 2. See ! 9: * the COPYING file in the top-level directory. ! 10: */ ! 11: ! 12: #include <sys/resource.h> ! 13: #include <getopt.h> ! 14: #include <syslog.h> ! 15: #include <sys/capability.h> ! 16: #include <sys/fsuid.h> ! 17: #include <sys/vfs.h> ! 18: #include <sys/ioctl.h> ! 19: #include <linux/fs.h> ! 20: #ifdef CONFIG_LINUX_MAGIC_H ! 21: #include <linux/magic.h> ! 22: #endif ! 23: #include "qemu-common.h" ! 24: #include "qemu_socket.h" ! 25: #include "qemu-xattr.h" ! 26: #include "virtio-9p-marshal.h" ! 27: #include "hw/9pfs/virtio-9p-proxy.h" ! 28: #include "fsdev/virtio-9p-marshal.h" ! 29: ! 30: #define PROGNAME "virtfs-proxy-helper" ! 31: ! 32: #ifndef XFS_SUPER_MAGIC ! 33: #define XFS_SUPER_MAGIC 0x58465342 ! 34: #endif ! 35: #ifndef EXT2_SUPER_MAGIC ! 36: #define EXT2_SUPER_MAGIC 0xEF53 ! 37: #endif ! 38: #ifndef REISERFS_SUPER_MAGIC ! 39: #define REISERFS_SUPER_MAGIC 0x52654973 ! 40: #endif ! 41: #ifndef BTRFS_SUPER_MAGIC ! 42: #define BTRFS_SUPER_MAGIC 0x9123683E ! 43: #endif ! 44: ! 45: static struct option helper_opts[] = { ! 46: {"fd", required_argument, NULL, 'f'}, ! 47: {"path", required_argument, NULL, 'p'}, ! 48: {"nodaemon", no_argument, NULL, 'n'}, ! 49: {"socket", required_argument, NULL, 's'}, ! 50: {"uid", required_argument, NULL, 'u'}, ! 51: {"gid", required_argument, NULL, 'g'}, ! 52: }; ! 53: ! 54: static bool is_daemon; ! 55: static bool get_version; /* IOC getversion IOCTL supported */ ! 56: ! 57: static void GCC_FMT_ATTR(2, 3) do_log(int loglevel, const char *format, ...) ! 58: { ! 59: va_list ap; ! 60: ! 61: va_start(ap, format); ! 62: if (is_daemon) { ! 63: vsyslog(LOG_CRIT, format, ap); ! 64: } else { ! 65: vfprintf(stderr, format, ap); ! 66: } ! 67: va_end(ap); ! 68: } ! 69: ! 70: static void do_perror(const char *string) ! 71: { ! 72: if (is_daemon) { ! 73: syslog(LOG_CRIT, "%s:%s", string, strerror(errno)); ! 74: } else { ! 75: fprintf(stderr, "%s:%s\n", string, strerror(errno)); ! 76: } ! 77: } ! 78: ! 79: static int do_cap_set(cap_value_t *cap_value, int size, int reset) ! 80: { ! 81: cap_t caps; ! 82: if (reset) { ! 83: /* ! 84: * Start with an empty set and set permitted and effective ! 85: */ ! 86: caps = cap_init(); ! 87: if (caps == NULL) { ! 88: do_perror("cap_init"); ! 89: return -1; ! 90: } ! 91: if (cap_set_flag(caps, CAP_PERMITTED, size, cap_value, CAP_SET) < 0) { ! 92: do_perror("cap_set_flag"); ! 93: goto error; ! 94: } ! 95: } else { ! 96: caps = cap_get_proc(); ! 97: if (!caps) { ! 98: do_perror("cap_get_proc"); ! 99: return -1; ! 100: } ! 101: } ! 102: if (cap_set_flag(caps, CAP_EFFECTIVE, size, cap_value, CAP_SET) < 0) { ! 103: do_perror("cap_set_flag"); ! 104: goto error; ! 105: } ! 106: if (cap_set_proc(caps) < 0) { ! 107: do_perror("cap_set_proc"); ! 108: goto error; ! 109: } ! 110: cap_free(caps); ! 111: return 0; ! 112: ! 113: error: ! 114: cap_free(caps); ! 115: return -1; ! 116: } ! 117: ! 118: static int init_capabilities(void) ! 119: { ! 120: /* helper needs following capbabilities only */ ! 121: cap_value_t cap_list[] = { ! 122: CAP_CHOWN, ! 123: CAP_DAC_OVERRIDE, ! 124: CAP_FOWNER, ! 125: CAP_FSETID, ! 126: CAP_SETGID, ! 127: CAP_MKNOD, ! 128: CAP_SETUID, ! 129: }; ! 130: return do_cap_set(cap_list, ARRAY_SIZE(cap_list), 1); ! 131: } ! 132: ! 133: static int socket_read(int sockfd, void *buff, ssize_t size) ! 134: { ! 135: ssize_t retval, total = 0; ! 136: ! 137: while (size) { ! 138: retval = read(sockfd, buff, size); ! 139: if (retval == 0) { ! 140: return -EIO; ! 141: } ! 142: if (retval < 0) { ! 143: if (errno == EINTR) { ! 144: continue; ! 145: } ! 146: return -errno; ! 147: } ! 148: size -= retval; ! 149: buff += retval; ! 150: total += retval; ! 151: } ! 152: return total; ! 153: } ! 154: ! 155: static int socket_write(int sockfd, void *buff, ssize_t size) ! 156: { ! 157: ssize_t retval, total = 0; ! 158: ! 159: while (size) { ! 160: retval = write(sockfd, buff, size); ! 161: if (retval < 0) { ! 162: if (errno == EINTR) { ! 163: continue; ! 164: } ! 165: return -errno; ! 166: } ! 167: size -= retval; ! 168: buff += retval; ! 169: total += retval; ! 170: } ! 171: return total; ! 172: } ! 173: ! 174: static int read_request(int sockfd, struct iovec *iovec, ProxyHeader *header) ! 175: { ! 176: int retval; ! 177: ! 178: /* ! 179: * read the request header. ! 180: */ ! 181: iovec->iov_len = 0; ! 182: retval = socket_read(sockfd, iovec->iov_base, PROXY_HDR_SZ); ! 183: if (retval < 0) { ! 184: return retval; ! 185: } ! 186: iovec->iov_len = PROXY_HDR_SZ; ! 187: retval = proxy_unmarshal(iovec, 0, "dd", &header->type, &header->size); ! 188: if (retval < 0) { ! 189: return retval; ! 190: } ! 191: /* ! 192: * We can't process message.size > PROXY_MAX_IO_SZ. ! 193: * Treat it as fatal error ! 194: */ ! 195: if (header->size > PROXY_MAX_IO_SZ) { ! 196: return -ENOBUFS; ! 197: } ! 198: retval = socket_read(sockfd, iovec->iov_base + PROXY_HDR_SZ, header->size); ! 199: if (retval < 0) { ! 200: return retval; ! 201: } ! 202: iovec->iov_len += header->size; ! 203: return 0; ! 204: } ! 205: ! 206: static int send_fd(int sockfd, int fd) ! 207: { ! 208: struct msghdr msg; ! 209: struct iovec iov; ! 210: int retval, data; ! 211: struct cmsghdr *cmsg; ! 212: union MsgControl msg_control; ! 213: ! 214: iov.iov_base = &data; ! 215: iov.iov_len = sizeof(data); ! 216: ! 217: memset(&msg, 0, sizeof(msg)); ! 218: msg.msg_iov = &iov; ! 219: msg.msg_iovlen = 1; ! 220: /* No ancillary data on error */ ! 221: if (fd < 0) { ! 222: /* fd is really negative errno if the request failed */ ! 223: data = fd; ! 224: } else { ! 225: data = V9FS_FD_VALID; ! 226: msg.msg_control = &msg_control; ! 227: msg.msg_controllen = sizeof(msg_control); ! 228: ! 229: cmsg = &msg_control.cmsg; ! 230: cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); ! 231: cmsg->cmsg_level = SOL_SOCKET; ! 232: cmsg->cmsg_type = SCM_RIGHTS; ! 233: memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd)); ! 234: } ! 235: ! 236: do { ! 237: retval = sendmsg(sockfd, &msg, 0); ! 238: } while (retval < 0 && errno == EINTR); ! 239: if (fd >= 0) { ! 240: close(fd); ! 241: } ! 242: if (retval < 0) { ! 243: return retval; ! 244: } ! 245: return 0; ! 246: } ! 247: ! 248: static int send_status(int sockfd, struct iovec *iovec, int status) ! 249: { ! 250: ProxyHeader header; ! 251: int retval, msg_size;; ! 252: ! 253: if (status < 0) { ! 254: header.type = T_ERROR; ! 255: } else { ! 256: header.type = T_SUCCESS; ! 257: } ! 258: header.size = sizeof(status); ! 259: /* ! 260: * marshal the return status. We don't check error. ! 261: * because we are sure we have enough space for the status ! 262: */ ! 263: msg_size = proxy_marshal(iovec, 0, "ddd", header.type, ! 264: header.size, status); ! 265: retval = socket_write(sockfd, iovec->iov_base, msg_size); ! 266: if (retval < 0) { ! 267: return retval; ! 268: } ! 269: return 0; ! 270: } ! 271: ! 272: /* ! 273: * from man 7 capabilities, section ! 274: * Effect of User ID Changes on Capabilities: ! 275: * 4. If the file system user ID is changed from 0 to nonzero (see setfsuid(2)) ! 276: * then the following capabilities are cleared from the effective set: ! 277: * CAP_CHOWN, CAP_DAC_OVERRIDE, CAP_DAC_READ_SEARCH, CAP_FOWNER, CAP_FSETID, ! 278: * CAP_LINUX_IMMUTABLE (since Linux 2.2.30), CAP_MAC_OVERRIDE, and CAP_MKNOD ! 279: * (since Linux 2.2.30). If the file system UID is changed from nonzero to 0, ! 280: * then any of these capabilities that are enabled in the permitted set ! 281: * are enabled in the effective set. ! 282: */ ! 283: static int setfsugid(int uid, int gid) ! 284: { ! 285: /* ! 286: * We still need DAC_OVERRIDE because we don't change ! 287: * supplementary group ids, and hence may be subjected DAC rules ! 288: */ ! 289: cap_value_t cap_list[] = { ! 290: CAP_DAC_OVERRIDE, ! 291: }; ! 292: ! 293: setfsgid(gid); ! 294: setfsuid(uid); ! 295: ! 296: if (uid != 0 || gid != 0) { ! 297: return do_cap_set(cap_list, ARRAY_SIZE(cap_list), 0); ! 298: } ! 299: return 0; ! 300: } ! 301: ! 302: /* ! 303: * send response in two parts ! 304: * 1) ProxyHeader ! 305: * 2) Response or error status ! 306: * This function should be called with marshaled response ! 307: * send_response constructs header part and error part only. ! 308: * send response sends {ProxyHeader,Response} if the request was success ! 309: * otherwise sends {ProxyHeader,error status} ! 310: */ ! 311: static int send_response(int sock, struct iovec *iovec, int size) ! 312: { ! 313: int retval; ! 314: ProxyHeader header; ! 315: ! 316: /* ! 317: * If response size exceeds available iovec->iov_len, ! 318: * we return ENOBUFS ! 319: */ ! 320: if (size > PROXY_MAX_IO_SZ) { ! 321: size = -ENOBUFS; ! 322: } ! 323: ! 324: if (size < 0) { ! 325: /* ! 326: * In case of error we would not have got the error encoded ! 327: * already so encode the error here. ! 328: */ ! 329: header.type = T_ERROR; ! 330: header.size = sizeof(size); ! 331: proxy_marshal(iovec, PROXY_HDR_SZ, "d", size); ! 332: } else { ! 333: header.type = T_SUCCESS; ! 334: header.size = size; ! 335: } ! 336: proxy_marshal(iovec, 0, "dd", header.type, header.size); ! 337: retval = socket_write(sock, iovec->iov_base, header.size + PROXY_HDR_SZ); ! 338: if (retval < 0) { ! 339: return retval;; ! 340: } ! 341: return 0; ! 342: } ! 343: ! 344: /* ! 345: * gets generation number ! 346: * returns -errno on failure and sizeof(generation number) on success ! 347: */ ! 348: static int do_getversion(struct iovec *iovec, struct iovec *out_iovec) ! 349: { ! 350: uint64_t version; ! 351: int retval = -ENOTTY; ! 352: #ifdef FS_IOC_GETVERSION ! 353: int fd; ! 354: V9fsString path; ! 355: #endif ! 356: ! 357: ! 358: /* no need to issue ioctl */ ! 359: if (!get_version) { ! 360: version = 0; ! 361: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "q", version); ! 362: return retval; ! 363: } ! 364: #ifdef FS_IOC_GETVERSION ! 365: retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "s", &path); ! 366: if (retval < 0) { ! 367: return retval; ! 368: } ! 369: ! 370: fd = open(path.data, O_RDONLY); ! 371: if (fd < 0) { ! 372: retval = -errno; ! 373: goto err_out; ! 374: } ! 375: if (ioctl(fd, FS_IOC_GETVERSION, &version) < 0) { ! 376: retval = -errno; ! 377: } else { ! 378: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "q", version); ! 379: } ! 380: close(fd); ! 381: err_out: ! 382: v9fs_string_free(&path); ! 383: #endif ! 384: return retval; ! 385: } ! 386: ! 387: static int do_getxattr(int type, struct iovec *iovec, struct iovec *out_iovec) ! 388: { ! 389: int size = 0, offset, retval; ! 390: V9fsString path, name, xattr; ! 391: ! 392: v9fs_string_init(&xattr); ! 393: v9fs_string_init(&path); ! 394: retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "ds", &size, &path); ! 395: if (retval < 0) { ! 396: return retval; ! 397: } ! 398: offset = PROXY_HDR_SZ + retval; ! 399: ! 400: if (size) { ! 401: xattr.data = g_malloc(size); ! 402: xattr.size = size; ! 403: } ! 404: switch (type) { ! 405: case T_LGETXATTR: ! 406: v9fs_string_init(&name); ! 407: retval = proxy_unmarshal(iovec, offset, "s", &name); ! 408: if (retval > 0) { ! 409: retval = lgetxattr(path.data, name.data, xattr.data, size); ! 410: if (retval < 0) { ! 411: retval = -errno; ! 412: } else { ! 413: xattr.size = retval; ! 414: } ! 415: } ! 416: v9fs_string_free(&name); ! 417: break; ! 418: case T_LLISTXATTR: ! 419: retval = llistxattr(path.data, xattr.data, size); ! 420: if (retval < 0) { ! 421: retval = -errno; ! 422: } else { ! 423: xattr.size = retval; ! 424: } ! 425: break; ! 426: } ! 427: if (retval < 0) { ! 428: goto err_out; ! 429: } ! 430: ! 431: if (!size) { ! 432: proxy_marshal(out_iovec, PROXY_HDR_SZ, "d", retval); ! 433: retval = sizeof(retval); ! 434: } else { ! 435: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "s", &xattr); ! 436: } ! 437: err_out: ! 438: v9fs_string_free(&xattr); ! 439: v9fs_string_free(&path); ! 440: return retval; ! 441: } ! 442: ! 443: static void stat_to_prstat(ProxyStat *pr_stat, struct stat *stat) ! 444: { ! 445: memset(pr_stat, 0, sizeof(*pr_stat)); ! 446: pr_stat->st_dev = stat->st_dev; ! 447: pr_stat->st_ino = stat->st_ino; ! 448: pr_stat->st_nlink = stat->st_nlink; ! 449: pr_stat->st_mode = stat->st_mode; ! 450: pr_stat->st_uid = stat->st_uid; ! 451: pr_stat->st_gid = stat->st_gid; ! 452: pr_stat->st_rdev = stat->st_rdev; ! 453: pr_stat->st_size = stat->st_size; ! 454: pr_stat->st_blksize = stat->st_blksize; ! 455: pr_stat->st_blocks = stat->st_blocks; ! 456: pr_stat->st_atim_sec = stat->st_atim.tv_sec; ! 457: pr_stat->st_atim_nsec = stat->st_atim.tv_nsec; ! 458: pr_stat->st_mtim_sec = stat->st_mtim.tv_sec; ! 459: pr_stat->st_mtim_nsec = stat->st_mtim.tv_nsec; ! 460: pr_stat->st_ctim_sec = stat->st_ctim.tv_sec; ! 461: pr_stat->st_ctim_nsec = stat->st_ctim.tv_nsec; ! 462: } ! 463: ! 464: static void statfs_to_prstatfs(ProxyStatFS *pr_stfs, struct statfs *stfs) ! 465: { ! 466: memset(pr_stfs, 0, sizeof(*pr_stfs)); ! 467: pr_stfs->f_type = stfs->f_type; ! 468: pr_stfs->f_bsize = stfs->f_bsize; ! 469: pr_stfs->f_blocks = stfs->f_blocks; ! 470: pr_stfs->f_bfree = stfs->f_bfree; ! 471: pr_stfs->f_bavail = stfs->f_bavail; ! 472: pr_stfs->f_files = stfs->f_files; ! 473: pr_stfs->f_ffree = stfs->f_ffree; ! 474: pr_stfs->f_fsid[0] = stfs->f_fsid.__val[0]; ! 475: pr_stfs->f_fsid[1] = stfs->f_fsid.__val[1]; ! 476: pr_stfs->f_namelen = stfs->f_namelen; ! 477: pr_stfs->f_frsize = stfs->f_frsize; ! 478: } ! 479: ! 480: /* ! 481: * Gets stat/statfs information and packs in out_iovec structure ! 482: * on success returns number of bytes packed in out_iovec struture ! 483: * otherwise returns -errno ! 484: */ ! 485: static int do_stat(int type, struct iovec *iovec, struct iovec *out_iovec) ! 486: { ! 487: int retval; ! 488: V9fsString path; ! 489: ProxyStat pr_stat; ! 490: ProxyStatFS pr_stfs; ! 491: struct stat st_buf; ! 492: struct statfs stfs_buf; ! 493: ! 494: v9fs_string_init(&path); ! 495: retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "s", &path); ! 496: if (retval < 0) { ! 497: return retval; ! 498: } ! 499: ! 500: switch (type) { ! 501: case T_LSTAT: ! 502: retval = lstat(path.data, &st_buf); ! 503: if (retval < 0) { ! 504: retval = -errno; ! 505: } else { ! 506: stat_to_prstat(&pr_stat, &st_buf); ! 507: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, ! 508: "qqqdddqqqqqqqqqq", pr_stat.st_dev, ! 509: pr_stat.st_ino, pr_stat.st_nlink, ! 510: pr_stat.st_mode, pr_stat.st_uid, ! 511: pr_stat.st_gid, pr_stat.st_rdev, ! 512: pr_stat.st_size, pr_stat.st_blksize, ! 513: pr_stat.st_blocks, ! 514: pr_stat.st_atim_sec, pr_stat.st_atim_nsec, ! 515: pr_stat.st_mtim_sec, pr_stat.st_mtim_nsec, ! 516: pr_stat.st_ctim_sec, pr_stat.st_ctim_nsec); ! 517: } ! 518: break; ! 519: case T_STATFS: ! 520: retval = statfs(path.data, &stfs_buf); ! 521: if (retval < 0) { ! 522: retval = -errno; ! 523: } else { ! 524: statfs_to_prstatfs(&pr_stfs, &stfs_buf); ! 525: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, ! 526: "qqqqqqqqqqq", pr_stfs.f_type, ! 527: pr_stfs.f_bsize, pr_stfs.f_blocks, ! 528: pr_stfs.f_bfree, pr_stfs.f_bavail, ! 529: pr_stfs.f_files, pr_stfs.f_ffree, ! 530: pr_stfs.f_fsid[0], pr_stfs.f_fsid[1], ! 531: pr_stfs.f_namelen, pr_stfs.f_frsize); ! 532: } ! 533: break; ! 534: } ! 535: v9fs_string_free(&path); ! 536: return retval; ! 537: } ! 538: ! 539: static int do_readlink(struct iovec *iovec, struct iovec *out_iovec) ! 540: { ! 541: char *buffer; ! 542: int size, retval; ! 543: V9fsString target, path; ! 544: ! 545: v9fs_string_init(&path); ! 546: retval = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sd", &path, &size); ! 547: if (retval < 0) { ! 548: v9fs_string_free(&path); ! 549: return retval; ! 550: } ! 551: buffer = g_malloc(size); ! 552: v9fs_string_init(&target); ! 553: retval = readlink(path.data, buffer, size); ! 554: if (retval > 0) { ! 555: buffer[retval] = '\0'; ! 556: v9fs_string_sprintf(&target, "%s", buffer); ! 557: retval = proxy_marshal(out_iovec, PROXY_HDR_SZ, "s", &target); ! 558: } else { ! 559: retval = -errno; ! 560: } ! 561: g_free(buffer); ! 562: v9fs_string_free(&target); ! 563: v9fs_string_free(&path); ! 564: return retval; ! 565: } ! 566: ! 567: /* ! 568: * create other filesystem objects and send 0 on success ! 569: * return -errno on error ! 570: */ ! 571: static int do_create_others(int type, struct iovec *iovec) ! 572: { ! 573: dev_t rdev; ! 574: int retval = 0; ! 575: int offset = PROXY_HDR_SZ; ! 576: V9fsString oldpath, path; ! 577: int mode, uid, gid, cur_uid, cur_gid; ! 578: ! 579: v9fs_string_init(&path); ! 580: v9fs_string_init(&oldpath); ! 581: cur_uid = geteuid(); ! 582: cur_gid = getegid(); ! 583: ! 584: retval = proxy_unmarshal(iovec, offset, "dd", &uid, &gid); ! 585: if (retval < 0) { ! 586: return retval; ! 587: } ! 588: offset += retval; ! 589: retval = setfsugid(uid, gid); ! 590: if (retval < 0) { ! 591: retval = -errno; ! 592: goto err_out; ! 593: } ! 594: switch (type) { ! 595: case T_MKNOD: ! 596: retval = proxy_unmarshal(iovec, offset, "sdq", &path, &mode, &rdev); ! 597: if (retval < 0) { ! 598: goto err_out; ! 599: } ! 600: retval = mknod(path.data, mode, rdev); ! 601: break; ! 602: case T_MKDIR: ! 603: retval = proxy_unmarshal(iovec, offset, "sd", &path, &mode); ! 604: if (retval < 0) { ! 605: goto err_out; ! 606: } ! 607: retval = mkdir(path.data, mode); ! 608: break; ! 609: case T_SYMLINK: ! 610: retval = proxy_unmarshal(iovec, offset, "ss", &oldpath, &path); ! 611: if (retval < 0) { ! 612: goto err_out; ! 613: } ! 614: retval = symlink(oldpath.data, path.data); ! 615: break; ! 616: } ! 617: if (retval < 0) { ! 618: retval = -errno; ! 619: } ! 620: ! 621: err_out: ! 622: v9fs_string_free(&path); ! 623: v9fs_string_free(&oldpath); ! 624: setfsugid(cur_uid, cur_gid); ! 625: return retval; ! 626: } ! 627: ! 628: /* ! 629: * create a file and send fd on success ! 630: * return -errno on error ! 631: */ ! 632: static int do_create(struct iovec *iovec) ! 633: { ! 634: int ret; ! 635: V9fsString path; ! 636: int flags, mode, uid, gid, cur_uid, cur_gid; ! 637: ! 638: v9fs_string_init(&path); ! 639: ret = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sdddd", ! 640: &path, &flags, &mode, &uid, &gid); ! 641: if (ret < 0) { ! 642: goto unmarshal_err_out; ! 643: } ! 644: cur_uid = geteuid(); ! 645: cur_gid = getegid(); ! 646: ret = setfsugid(uid, gid); ! 647: if (ret < 0) { ! 648: /* ! 649: * On failure reset back to the ! 650: * old uid/gid ! 651: */ ! 652: ret = -errno; ! 653: goto err_out; ! 654: } ! 655: ret = open(path.data, flags, mode); ! 656: if (ret < 0) { ! 657: ret = -errno; ! 658: } ! 659: ! 660: err_out: ! 661: setfsugid(cur_uid, cur_gid); ! 662: unmarshal_err_out: ! 663: v9fs_string_free(&path); ! 664: return ret; ! 665: } ! 666: ! 667: /* ! 668: * open a file and send fd on success ! 669: * return -errno on error ! 670: */ ! 671: static int do_open(struct iovec *iovec) ! 672: { ! 673: int flags, ret; ! 674: V9fsString path; ! 675: ! 676: v9fs_string_init(&path); ! 677: ret = proxy_unmarshal(iovec, PROXY_HDR_SZ, "sd", &path, &flags); ! 678: if (ret < 0) { ! 679: goto err_out; ! 680: } ! 681: ret = open(path.data, flags); ! 682: if (ret < 0) { ! 683: ret = -errno; ! 684: } ! 685: err_out: ! 686: v9fs_string_free(&path); ! 687: return ret; ! 688: } ! 689: ! 690: /* create unix domain socket and return the descriptor */ ! 691: static int proxy_socket(const char *path, uid_t uid, gid_t gid) ! 692: { ! 693: int sock, client; ! 694: struct sockaddr_un proxy, qemu; ! 695: socklen_t size; ! 696: ! 697: /* requested socket already exists, refuse to start */ ! 698: if (!access(path, F_OK)) { ! 699: do_log(LOG_CRIT, "socket already exists\n"); ! 700: return -1; ! 701: } ! 702: ! 703: sock = socket(AF_UNIX, SOCK_STREAM, 0); ! 704: if (sock < 0) { ! 705: do_perror("socket"); ! 706: return -1; ! 707: } ! 708: ! 709: /* mask other part of mode bits */ ! 710: umask(7); ! 711: ! 712: proxy.sun_family = AF_UNIX; ! 713: strcpy(proxy.sun_path, path); ! 714: if (bind(sock, (struct sockaddr *)&proxy, ! 715: sizeof(struct sockaddr_un)) < 0) { ! 716: do_perror("bind"); ! 717: return -1; ! 718: } ! 719: if (chown(proxy.sun_path, uid, gid) < 0) { ! 720: do_perror("chown"); ! 721: return -1; ! 722: } ! 723: if (listen(sock, 1) < 0) { ! 724: do_perror("listen"); ! 725: return -1; ! 726: } ! 727: ! 728: client = accept(sock, (struct sockaddr *)&qemu, &size); ! 729: if (client < 0) { ! 730: do_perror("accept"); ! 731: return -1; ! 732: } ! 733: return client; ! 734: } ! 735: ! 736: static void usage(char *prog) ! 737: { ! 738: fprintf(stderr, "usage: %s\n" ! 739: " -p|--path <path> 9p path to export\n" ! 740: " {-f|--fd <socket-descriptor>} socket file descriptor to be used\n" ! 741: " {-s|--socket <socketname> socket file used for communication\n" ! 742: " \t-u|--uid <uid> -g|--gid <gid>} - uid:gid combination to give " ! 743: " access to this socket\n" ! 744: " \tNote: -s & -f can not be used together\n" ! 745: " [-n|--nodaemon] Run as a normal program\n", ! 746: basename(prog)); ! 747: } ! 748: ! 749: static int process_reply(int sock, int type, ! 750: struct iovec *out_iovec, int retval) ! 751: { ! 752: switch (type) { ! 753: case T_OPEN: ! 754: case T_CREATE: ! 755: if (send_fd(sock, retval) < 0) { ! 756: return -1; ! 757: } ! 758: break; ! 759: case T_MKNOD: ! 760: case T_MKDIR: ! 761: case T_SYMLINK: ! 762: case T_LINK: ! 763: case T_CHMOD: ! 764: case T_CHOWN: ! 765: case T_TRUNCATE: ! 766: case T_UTIME: ! 767: case T_RENAME: ! 768: case T_REMOVE: ! 769: case T_LSETXATTR: ! 770: case T_LREMOVEXATTR: ! 771: if (send_status(sock, out_iovec, retval) < 0) { ! 772: return -1; ! 773: } ! 774: break; ! 775: case T_LSTAT: ! 776: case T_STATFS: ! 777: case T_READLINK: ! 778: case T_LGETXATTR: ! 779: case T_LLISTXATTR: ! 780: case T_GETVERSION: ! 781: if (send_response(sock, out_iovec, retval) < 0) { ! 782: return -1; ! 783: } ! 784: break; ! 785: default: ! 786: return -1; ! 787: break; ! 788: } ! 789: return 0; ! 790: } ! 791: ! 792: static int process_requests(int sock) ! 793: { ! 794: int flags; ! 795: int size = 0; ! 796: int retval = 0; ! 797: uint64_t offset; ! 798: ProxyHeader header; ! 799: int mode, uid, gid; ! 800: V9fsString name, value; ! 801: struct timespec spec[2]; ! 802: V9fsString oldpath, path; ! 803: struct iovec in_iovec, out_iovec; ! 804: ! 805: in_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); ! 806: in_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; ! 807: out_iovec.iov_base = g_malloc(PROXY_MAX_IO_SZ + PROXY_HDR_SZ); ! 808: out_iovec.iov_len = PROXY_MAX_IO_SZ + PROXY_HDR_SZ; ! 809: ! 810: while (1) { ! 811: /* ! 812: * initialize the header type, so that we send ! 813: * response to proper request type. ! 814: */ ! 815: header.type = 0; ! 816: retval = read_request(sock, &in_iovec, &header); ! 817: if (retval < 0) { ! 818: goto err_out; ! 819: } ! 820: ! 821: switch (header.type) { ! 822: case T_OPEN: ! 823: retval = do_open(&in_iovec); ! 824: break; ! 825: case T_CREATE: ! 826: retval = do_create(&in_iovec); ! 827: break; ! 828: case T_MKNOD: ! 829: case T_MKDIR: ! 830: case T_SYMLINK: ! 831: retval = do_create_others(header.type, &in_iovec); ! 832: break; ! 833: case T_LINK: ! 834: v9fs_string_init(&path); ! 835: v9fs_string_init(&oldpath); ! 836: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, ! 837: "ss", &oldpath, &path); ! 838: if (retval > 0) { ! 839: retval = link(oldpath.data, path.data); ! 840: if (retval < 0) { ! 841: retval = -errno; ! 842: } ! 843: } ! 844: v9fs_string_free(&oldpath); ! 845: v9fs_string_free(&path); ! 846: break; ! 847: case T_LSTAT: ! 848: case T_STATFS: ! 849: retval = do_stat(header.type, &in_iovec, &out_iovec); ! 850: break; ! 851: case T_READLINK: ! 852: retval = do_readlink(&in_iovec, &out_iovec); ! 853: break; ! 854: case T_CHMOD: ! 855: v9fs_string_init(&path); ! 856: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, ! 857: "sd", &path, &mode); ! 858: if (retval > 0) { ! 859: retval = chmod(path.data, mode); ! 860: if (retval < 0) { ! 861: retval = -errno; ! 862: } ! 863: } ! 864: v9fs_string_free(&path); ! 865: break; ! 866: case T_CHOWN: ! 867: v9fs_string_init(&path); ! 868: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sdd", &path, ! 869: &uid, &gid); ! 870: if (retval > 0) { ! 871: retval = lchown(path.data, uid, gid); ! 872: if (retval < 0) { ! 873: retval = -errno; ! 874: } ! 875: } ! 876: v9fs_string_free(&path); ! 877: break; ! 878: case T_TRUNCATE: ! 879: v9fs_string_init(&path); ! 880: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sq", ! 881: &path, &offset); ! 882: if (retval > 0) { ! 883: retval = truncate(path.data, offset); ! 884: if (retval < 0) { ! 885: retval = -errno; ! 886: } ! 887: } ! 888: v9fs_string_free(&path); ! 889: break; ! 890: case T_UTIME: ! 891: v9fs_string_init(&path); ! 892: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sqqqq", &path, ! 893: &spec[0].tv_sec, &spec[0].tv_nsec, ! 894: &spec[1].tv_sec, &spec[1].tv_nsec); ! 895: if (retval > 0) { ! 896: retval = qemu_utimens(path.data, spec); ! 897: if (retval < 0) { ! 898: retval = -errno; ! 899: } ! 900: } ! 901: v9fs_string_free(&path); ! 902: break; ! 903: case T_RENAME: ! 904: v9fs_string_init(&path); ! 905: v9fs_string_init(&oldpath); ! 906: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, ! 907: "ss", &oldpath, &path); ! 908: if (retval > 0) { ! 909: retval = rename(oldpath.data, path.data); ! 910: if (retval < 0) { ! 911: retval = -errno; ! 912: } ! 913: } ! 914: v9fs_string_free(&oldpath); ! 915: v9fs_string_free(&path); ! 916: break; ! 917: case T_REMOVE: ! 918: v9fs_string_init(&path); ! 919: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "s", &path); ! 920: if (retval > 0) { ! 921: retval = remove(path.data); ! 922: if (retval < 0) { ! 923: retval = -errno; ! 924: } ! 925: } ! 926: v9fs_string_free(&path); ! 927: break; ! 928: case T_LGETXATTR: ! 929: case T_LLISTXATTR: ! 930: retval = do_getxattr(header.type, &in_iovec, &out_iovec); ! 931: break; ! 932: case T_LSETXATTR: ! 933: v9fs_string_init(&path); ! 934: v9fs_string_init(&name); ! 935: v9fs_string_init(&value); ! 936: retval = proxy_unmarshal(&in_iovec, PROXY_HDR_SZ, "sssdd", &path, ! 937: &name, &value, &size, &flags); ! 938: if (retval > 0) { ! 939: retval = lsetxattr(path.data, ! 940: name.data, value.data, size, flags); ! 941: if (retval < 0) { ! 942: retval = -errno; ! 943: } ! 944: } ! 945: v9fs_string_free(&path); ! 946: v9fs_string_free(&name); ! 947: v9fs_string_free(&value); ! 948: break; ! 949: case T_LREMOVEXATTR: ! 950: v9fs_string_init(&path); ! 951: v9fs_string_init(&name); ! 952: retval = proxy_unmarshal(&in_iovec, ! 953: PROXY_HDR_SZ, "ss", &path, &name); ! 954: if (retval > 0) { ! 955: retval = lremovexattr(path.data, name.data); ! 956: if (retval < 0) { ! 957: retval = -errno; ! 958: } ! 959: } ! 960: v9fs_string_free(&path); ! 961: v9fs_string_free(&name); ! 962: break; ! 963: case T_GETVERSION: ! 964: retval = do_getversion(&in_iovec, &out_iovec); ! 965: break; ! 966: default: ! 967: goto err_out; ! 968: break; ! 969: } ! 970: ! 971: if (process_reply(sock, header.type, &out_iovec, retval) < 0) { ! 972: goto err_out; ! 973: } ! 974: } ! 975: err_out: ! 976: g_free(in_iovec.iov_base); ! 977: g_free(out_iovec.iov_base); ! 978: return -1; ! 979: } ! 980: ! 981: int main(int argc, char **argv) ! 982: { ! 983: int sock; ! 984: uid_t own_u; ! 985: gid_t own_g; ! 986: char *rpath = NULL; ! 987: char *sock_name = NULL; ! 988: struct stat stbuf; ! 989: int c, option_index; ! 990: #ifdef FS_IOC_GETVERSION ! 991: int retval; ! 992: struct statfs st_fs; ! 993: #endif ! 994: ! 995: is_daemon = true; ! 996: sock = -1; ! 997: own_u = own_g = -1; ! 998: while (1) { ! 999: option_index = 0; ! 1000: c = getopt_long(argc, argv, "p:nh?f:s:u:g:", helper_opts, ! 1001: &option_index); ! 1002: if (c == -1) { ! 1003: break; ! 1004: } ! 1005: switch (c) { ! 1006: case 'p': ! 1007: rpath = strdup(optarg); ! 1008: break; ! 1009: case 'n': ! 1010: is_daemon = false; ! 1011: break; ! 1012: case 'f': ! 1013: sock = atoi(optarg); ! 1014: break; ! 1015: case 's': ! 1016: sock_name = strdup(optarg); ! 1017: break; ! 1018: case 'u': ! 1019: own_u = atoi(optarg); ! 1020: break; ! 1021: case 'g': ! 1022: own_g = atoi(optarg); ! 1023: break; ! 1024: case '?': ! 1025: case 'h': ! 1026: default: ! 1027: usage(argv[0]); ! 1028: exit(EXIT_FAILURE); ! 1029: } ! 1030: } ! 1031: ! 1032: /* Parameter validation */ ! 1033: if ((sock_name == NULL && sock == -1) || rpath == NULL) { ! 1034: fprintf(stderr, "socket, socket descriptor or path not specified\n"); ! 1035: usage(argv[0]); ! 1036: return -1; ! 1037: } ! 1038: ! 1039: if (sock_name && sock != -1) { ! 1040: fprintf(stderr, "both named socket and socket descriptor specified\n"); ! 1041: usage(argv[0]); ! 1042: exit(EXIT_FAILURE); ! 1043: } ! 1044: ! 1045: if (sock_name && (own_u == -1 || own_g == -1)) { ! 1046: fprintf(stderr, "owner uid:gid not specified, "); ! 1047: fprintf(stderr, ! 1048: "owner uid:gid specifies who can access the socket file\n"); ! 1049: usage(argv[0]); ! 1050: exit(EXIT_FAILURE); ! 1051: } ! 1052: ! 1053: if (lstat(rpath, &stbuf) < 0) { ! 1054: fprintf(stderr, "invalid path \"%s\" specified, %s\n", ! 1055: rpath, strerror(errno)); ! 1056: exit(EXIT_FAILURE); ! 1057: } ! 1058: ! 1059: if (!S_ISDIR(stbuf.st_mode)) { ! 1060: fprintf(stderr, "specified path \"%s\" is not directory\n", rpath); ! 1061: exit(EXIT_FAILURE); ! 1062: } ! 1063: ! 1064: if (is_daemon) { ! 1065: if (daemon(0, 0) < 0) { ! 1066: fprintf(stderr, "daemon call failed\n"); ! 1067: exit(EXIT_FAILURE); ! 1068: } ! 1069: openlog(PROGNAME, LOG_PID, LOG_DAEMON); ! 1070: } ! 1071: ! 1072: do_log(LOG_INFO, "Started\n"); ! 1073: if (sock_name) { ! 1074: sock = proxy_socket(sock_name, own_u, own_g); ! 1075: if (sock < 0) { ! 1076: goto error; ! 1077: } ! 1078: } ! 1079: ! 1080: get_version = false; ! 1081: #ifdef FS_IOC_GETVERSION ! 1082: /* check whether underlying FS support IOC_GETVERSION */ ! 1083: retval = statfs(rpath, &st_fs); ! 1084: if (!retval) { ! 1085: switch (st_fs.f_type) { ! 1086: case EXT2_SUPER_MAGIC: ! 1087: case BTRFS_SUPER_MAGIC: ! 1088: case REISERFS_SUPER_MAGIC: ! 1089: case XFS_SUPER_MAGIC: ! 1090: get_version = true; ! 1091: break; ! 1092: } ! 1093: } ! 1094: #endif ! 1095: ! 1096: if (chdir("/") < 0) { ! 1097: do_perror("chdir"); ! 1098: goto error; ! 1099: } ! 1100: if (chroot(rpath) < 0) { ! 1101: do_perror("chroot"); ! 1102: goto error; ! 1103: } ! 1104: umask(0); ! 1105: ! 1106: if (init_capabilities() < 0) { ! 1107: goto error; ! 1108: } ! 1109: ! 1110: process_requests(sock); ! 1111: error: ! 1112: do_log(LOG_INFO, "Done\n"); ! 1113: closelog(); ! 1114: return 0; ! 1115: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.