1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2001 Dima Dorfman. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 /* 30 * mdmfs (md/MFS) is a wrapper around mdconfig(8), 31 * newfs(8), and mount(8) that mimics the command line option set of 32 * the deprecated mount_mfs(8). 33 */ 34 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include <sys/param.h> 39 #include <sys/linker.h> 40 #include <sys/mdioctl.h> 41 #include <sys/module.h> 42 #include <sys/mount.h> 43 #include <sys/stat.h> 44 #include <sys/wait.h> 45 46 #include <assert.h> 47 #include <err.h> 48 #include <errno.h> 49 #include <fcntl.h> 50 #include <grp.h> 51 #include <inttypes.h> 52 #include <paths.h> 53 #include <pwd.h> 54 #include <stdarg.h> 55 #include <stdio.h> 56 #include <stdlib.h> 57 #include <string.h> 58 #include <ctype.h> 59 #include <unistd.h> 60 61 typedef enum { false, true } bool; 62 63 struct mtpt_info { 64 uid_t mi_uid; 65 bool mi_have_uid; 66 gid_t mi_gid; 67 bool mi_have_gid; 68 mode_t mi_mode; 69 bool mi_have_mode; 70 bool mi_forced_pw; 71 }; 72 73 static bool debug; /* Emit debugging information? */ 74 static bool loudsubs; /* Suppress output from helper programs? */ 75 static bool norun; /* Actually run the helper programs? */ 76 static int unit; /* The unit we're working with. */ 77 static const char *mdname; /* Name of memory disk device (e.g., "md"). */ 78 static const char *mdsuffix; /* Suffix of memory disk device (e.g., ".uzip"). */ 79 static size_t mdnamelen; /* Length of mdname. */ 80 static const char *path_mdconfig =_PATH_MDCONFIG; 81 82 static void argappend(char **, const char *, ...) __printflike(2, 3); 83 static void debugprintf(const char *, ...) __printflike(1, 2); 84 static void do_mdconfig_attach(const char *, const enum md_types); 85 static void do_mdconfig_attach_au(const char *, const enum md_types); 86 static void do_mdconfig_detach(void); 87 static void do_mount_md(const char *, const char *); 88 static void do_mount_tmpfs(const char *, const char *); 89 static void do_mtptsetup(const char *, struct mtpt_info *); 90 static void do_newfs(const char *); 91 static void do_copy(const char *, const char *); 92 static void extract_ugid(const char *, struct mtpt_info *); 93 static int run(int *, const char *, ...) __printflike(2, 3); 94 static const char *run_exitstr(int); 95 static int run_exitnumber(int); 96 static void usage(void); 97 98 int 99 main(int argc, char **argv) 100 { 101 struct mtpt_info mi; /* Mountpoint info. */ 102 intmax_t mdsize; 103 char *mdconfig_arg, *newfs_arg, /* Args to helper programs. */ 104 *mount_arg; 105 enum md_types mdtype; /* The type of our memory disk. */ 106 bool have_mdtype, mlmac; 107 bool detach, softdep, autounit, newfs; 108 const char *mtpoint, *size_arg, *skel, *unitstr; 109 char *p; 110 int ch, idx; 111 void *set; 112 unsigned long ul; 113 114 /* Misc. initialization. */ 115 (void)memset(&mi, '\0', sizeof(mi)); 116 detach = true; 117 softdep = true; 118 autounit = false; 119 mlmac = false; 120 newfs = true; 121 have_mdtype = false; 122 skel = NULL; 123 mdtype = MD_SWAP; 124 mdname = MD_NAME; 125 mdnamelen = strlen(mdname); 126 mdsize = 0; 127 /* 128 * Can't set these to NULL. They may be passed to the 129 * respective programs without modification. I.e., we may not 130 * receive any command-line options which will caused them to 131 * be modified. 132 */ 133 mdconfig_arg = strdup(""); 134 newfs_arg = strdup(""); 135 mount_arg = strdup(""); 136 size_arg = NULL; 137 138 /* If we were started as mount_mfs or mfs, imply -C. */ 139 if (strcmp(getprogname(), "mount_mfs") == 0 || 140 strcmp(getprogname(), "mfs") == 0) { 141 /* Make compatibility assumptions. */ 142 mi.mi_mode = 01777; 143 mi.mi_have_mode = true; 144 } 145 146 while ((ch = getopt(argc, argv, 147 "a:b:Cc:Dd:E:e:F:f:hi:k:LlMm:NnO:o:Pp:Ss:tT:Uv:w:X")) != -1) 148 switch (ch) { 149 case 'a': 150 argappend(&newfs_arg, "-a %s", optarg); 151 break; 152 case 'b': 153 argappend(&newfs_arg, "-b %s", optarg); 154 break; 155 case 'C': 156 /* Ignored for compatibility. */ 157 break; 158 case 'c': 159 argappend(&newfs_arg, "-c %s", optarg); 160 break; 161 case 'D': 162 detach = false; 163 break; 164 case 'd': 165 argappend(&newfs_arg, "-d %s", optarg); 166 break; 167 case 'E': 168 path_mdconfig = optarg; 169 break; 170 case 'e': 171 argappend(&newfs_arg, "-e %s", optarg); 172 break; 173 case 'F': 174 if (have_mdtype) 175 usage(); 176 mdtype = MD_VNODE; 177 have_mdtype = true; 178 argappend(&mdconfig_arg, "-f %s", optarg); 179 break; 180 case 'f': 181 argappend(&newfs_arg, "-f %s", optarg); 182 break; 183 case 'h': 184 usage(); 185 break; 186 case 'i': 187 argappend(&newfs_arg, "-i %s", optarg); 188 break; 189 case 'k': 190 skel = optarg; 191 break; 192 case 'L': 193 loudsubs = true; 194 break; 195 case 'l': 196 mlmac = true; 197 argappend(&newfs_arg, "-l"); 198 break; 199 case 'M': 200 if (have_mdtype) 201 usage(); 202 mdtype = MD_MALLOC; 203 have_mdtype = true; 204 argappend(&mdconfig_arg, "-o reserve"); 205 break; 206 case 'm': 207 argappend(&newfs_arg, "-m %s", optarg); 208 break; 209 case 'N': 210 norun = true; 211 break; 212 case 'n': 213 argappend(&newfs_arg, "-n"); 214 break; 215 case 'O': 216 argappend(&newfs_arg, "-o %s", optarg); 217 break; 218 case 'o': 219 argappend(&mount_arg, "-o %s", optarg); 220 break; 221 case 'P': 222 newfs = false; 223 break; 224 case 'p': 225 if ((set = setmode(optarg)) == NULL) 226 usage(); 227 mi.mi_mode = getmode(set, S_IRWXU | S_IRWXG | S_IRWXO); 228 mi.mi_have_mode = true; 229 mi.mi_forced_pw = true; 230 free(set); 231 break; 232 case 'S': 233 softdep = false; 234 break; 235 case 's': 236 size_arg = optarg; 237 break; 238 case 't': 239 argappend(&newfs_arg, "-t"); 240 break; 241 case 'T': 242 argappend(&mount_arg, "-t %s", optarg); 243 break; 244 case 'U': 245 softdep = true; 246 break; 247 case 'v': 248 argappend(&newfs_arg, "-O %s", optarg); 249 break; 250 case 'w': 251 extract_ugid(optarg, &mi); 252 mi.mi_forced_pw = true; 253 break; 254 case 'X': 255 debug = true; 256 break; 257 default: 258 usage(); 259 } 260 argc -= optind; 261 argv += optind; 262 if (argc < 2) 263 usage(); 264 265 /* 266 * Historically our size arg was passed directly to mdconfig, which 267 * treats a number without a suffix as a count of 512-byte sectors; 268 * tmpfs would treat it as a count of bytes. To get predictable 269 * behavior for 'auto' we document that the size always uses mdconfig 270 * rules. To make that work, decode the size here so it can be passed 271 * to either tmpfs or mdconfig as a count of bytes. 272 */ 273 if (size_arg != NULL) { 274 mdsize = (intmax_t)strtoumax(size_arg, &p, 0); 275 if (p == size_arg || (p[0] != 0 && p[1] != 0) || mdsize < 0) 276 errx(1, "invalid size '%s'", size_arg); 277 switch (*p) { 278 case 'p': 279 case 'P': 280 mdsize *= 1024; 281 case 't': 282 case 'T': 283 mdsize *= 1024; 284 case 'g': 285 case 'G': 286 mdsize *= 1024; 287 case 'm': 288 case 'M': 289 mdsize *= 1024; 290 case 'k': 291 case 'K': 292 mdsize *= 1024; 293 case 'b': 294 case 'B': 295 break; 296 case '\0': 297 mdsize *= 512; 298 break; 299 default: 300 errx(1, "invalid size suffix on '%s'", size_arg); 301 } 302 } 303 304 /* 305 * Based on the command line 'md-device' either mount a tmpfs filesystem 306 * or configure the md device then format and mount a filesystem on it. 307 * If the device is 'auto' use tmpfs if it is available and there is no 308 * request for multilabel MAC (which tmpfs does not support). 309 */ 310 unitstr = argv[0]; 311 mtpoint = argv[1]; 312 313 if (strcmp(unitstr, "auto") == 0) { 314 if (mlmac) 315 idx = -1; /* Must use md for mlmac. */ 316 else if ((idx = modfind("tmpfs")) == -1) 317 idx = kldload("tmpfs"); 318 if (idx == -1) 319 unitstr = "md"; 320 else 321 unitstr = "tmpfs"; 322 } 323 324 if (strcmp(unitstr, "tmpfs") == 0) { 325 if (size_arg != NULL && mdsize != 0) 326 argappend(&mount_arg, "-o size=%jd", mdsize); 327 do_mount_tmpfs(mount_arg, mtpoint); 328 } else { 329 if (size_arg != NULL) 330 argappend(&mdconfig_arg, "-s %jdB", mdsize); 331 if (strncmp(unitstr, "/dev/", 5) == 0) 332 unitstr += 5; 333 if (strncmp(unitstr, mdname, mdnamelen) == 0) 334 unitstr += mdnamelen; 335 if (!isdigit(*unitstr)) { 336 autounit = true; 337 unit = -1; 338 mdsuffix = unitstr; 339 } else { 340 ul = strtoul(unitstr, &p, 10); 341 if (ul == ULONG_MAX) 342 errx(1, "bad device unit: %s", unitstr); 343 unit = ul; 344 mdsuffix = p; /* can be empty */ 345 } 346 347 if (!have_mdtype) 348 mdtype = MD_SWAP; 349 if (softdep) 350 argappend(&newfs_arg, "-U"); 351 if (mdtype != MD_VNODE && !newfs) 352 errx(1, "-P requires a vnode-backed disk"); 353 354 /* Do the work. */ 355 if (detach && !autounit) 356 do_mdconfig_detach(); 357 if (autounit) 358 do_mdconfig_attach_au(mdconfig_arg, mdtype); 359 else 360 do_mdconfig_attach(mdconfig_arg, mdtype); 361 if (newfs) 362 do_newfs(newfs_arg); 363 do_mount_md(mount_arg, mtpoint); 364 } 365 366 do_mtptsetup(mtpoint, &mi); 367 if (skel != NULL) 368 do_copy(mtpoint, skel); 369 370 return (0); 371 } 372 373 /* 374 * Append the expansion of 'fmt' to the buffer pointed to by '*dstp'; 375 * reallocate as required. 376 */ 377 static void 378 argappend(char **dstp, const char *fmt, ...) 379 { 380 char *old, *new; 381 va_list ap; 382 383 old = *dstp; 384 assert(old != NULL); 385 386 va_start(ap, fmt); 387 if (vasprintf(&new, fmt,ap) == -1) 388 errx(1, "vasprintf"); 389 va_end(ap); 390 391 *dstp = new; 392 if (asprintf(&new, "%s %s", old, new) == -1) 393 errx(1, "asprintf"); 394 free(*dstp); 395 free(old); 396 397 *dstp = new; 398 } 399 400 /* 401 * If run-time debugging is enabled, print the expansion of 'fmt'. 402 * Otherwise, do nothing. 403 */ 404 static void 405 debugprintf(const char *fmt, ...) 406 { 407 va_list ap; 408 409 if (!debug) 410 return; 411 fprintf(stderr, "DEBUG: "); 412 va_start(ap, fmt); 413 vfprintf(stderr, fmt, ap); 414 va_end(ap); 415 fprintf(stderr, "\n"); 416 fflush(stderr); 417 } 418 419 /* 420 * Attach a memory disk with a known unit. 421 */ 422 static void 423 do_mdconfig_attach(const char *args, const enum md_types mdtype) 424 { 425 int rv; 426 const char *ta; /* Type arg. */ 427 428 switch (mdtype) { 429 case MD_SWAP: 430 ta = "-t swap"; 431 break; 432 case MD_VNODE: 433 ta = "-t vnode"; 434 break; 435 case MD_MALLOC: 436 ta = "-t malloc"; 437 break; 438 default: 439 abort(); 440 } 441 rv = run(NULL, "%s -a %s%s -u %s%d", path_mdconfig, ta, args, 442 mdname, unit); 443 if (rv) 444 errx(1, "mdconfig (attach) exited %s %d", run_exitstr(rv), 445 run_exitnumber(rv)); 446 } 447 448 /* 449 * Attach a memory disk with an unknown unit; use autounit. 450 */ 451 static void 452 do_mdconfig_attach_au(const char *args, const enum md_types mdtype) 453 { 454 const char *ta; /* Type arg. */ 455 char *linep; 456 char linebuf[12]; /* 32-bit unit (10) + '\n' (1) + '\0' (1) */ 457 int fd; /* Standard output of mdconfig invocation. */ 458 FILE *sfd; 459 int rv; 460 char *p; 461 size_t linelen; 462 unsigned long ul; 463 464 switch (mdtype) { 465 case MD_SWAP: 466 ta = "-t swap"; 467 break; 468 case MD_VNODE: 469 ta = "-t vnode"; 470 break; 471 case MD_MALLOC: 472 ta = "-t malloc"; 473 break; 474 default: 475 abort(); 476 } 477 rv = run(&fd, "%s -a %s%s", path_mdconfig, ta, args); 478 if (rv) 479 errx(1, "mdconfig (attach) exited %s %d", run_exitstr(rv), 480 run_exitnumber(rv)); 481 482 /* Receive the unit number. */ 483 if (norun) { /* Since we didn't run, we can't read. Fake it. */ 484 unit = 0; 485 return; 486 } 487 sfd = fdopen(fd, "r"); 488 if (sfd == NULL) 489 err(1, "fdopen"); 490 linep = fgetln(sfd, &linelen); 491 /* If the output format changes, we want to know about it. */ 492 if (linep == NULL || linelen <= mdnamelen + 1 || 493 linelen - mdnamelen >= sizeof(linebuf) || 494 strncmp(linep, mdname, mdnamelen) != 0) 495 errx(1, "unexpected output from mdconfig (attach)"); 496 linep += mdnamelen; 497 linelen -= mdnamelen; 498 /* Can't use strlcpy because linep is not NULL-terminated. */ 499 strncpy(linebuf, linep, linelen); 500 linebuf[linelen] = '\0'; 501 ul = strtoul(linebuf, &p, 10); 502 if (ul == ULONG_MAX || *p != '\n') 503 errx(1, "unexpected output from mdconfig (attach)"); 504 unit = ul; 505 506 fclose(sfd); 507 } 508 509 /* 510 * Detach a memory disk. 511 */ 512 static void 513 do_mdconfig_detach(void) 514 { 515 int rv; 516 517 rv = run(NULL, "%s -d -u %s%d", path_mdconfig, mdname, unit); 518 if (rv && debug) /* This is allowed to fail. */ 519 warnx("mdconfig (detach) exited %s %d (ignored)", 520 run_exitstr(rv), run_exitnumber(rv)); 521 } 522 523 /* 524 * Mount the configured memory disk. 525 */ 526 static void 527 do_mount_md(const char *args, const char *mtpoint) 528 { 529 int rv; 530 531 rv = run(NULL, "%s%s /dev/%s%d%s %s", _PATH_MOUNT, args, 532 mdname, unit, mdsuffix, mtpoint); 533 if (rv) 534 errx(1, "mount exited %s %d", run_exitstr(rv), 535 run_exitnumber(rv)); 536 } 537 538 /* 539 * Mount the configured tmpfs. 540 */ 541 static void 542 do_mount_tmpfs(const char *args, const char *mtpoint) 543 { 544 int rv; 545 546 rv = run(NULL, "%s -t tmpfs %s tmp %s", _PATH_MOUNT, args, mtpoint); 547 if (rv) 548 errx(1, "tmpfs mount exited %s %d", run_exitstr(rv), 549 run_exitnumber(rv)); 550 } 551 552 /* 553 * Various configuration of the mountpoint. Mostly, enact 'mip'. 554 */ 555 static void 556 do_mtptsetup(const char *mtpoint, struct mtpt_info *mip) 557 { 558 struct statfs sfs; 559 560 if (!mip->mi_have_mode && !mip->mi_have_uid && !mip->mi_have_gid) 561 return; 562 563 if (!norun) { 564 if (statfs(mtpoint, &sfs) == -1) { 565 warn("statfs: %s", mtpoint); 566 return; 567 } 568 if ((sfs.f_flags & MNT_RDONLY) != 0) { 569 if (mip->mi_forced_pw) { 570 warnx( 571 "Not changing mode/owner of %s since it is read-only", 572 mtpoint); 573 } else { 574 debugprintf( 575 "Not changing mode/owner of %s since it is read-only", 576 mtpoint); 577 } 578 return; 579 } 580 } 581 582 if (mip->mi_have_mode) { 583 debugprintf("changing mode of %s to %o.", mtpoint, 584 mip->mi_mode); 585 if (!norun) 586 if (chmod(mtpoint, mip->mi_mode) == -1) 587 err(1, "chmod: %s", mtpoint); 588 } 589 /* 590 * We have to do these separately because the user may have 591 * only specified one of them. 592 */ 593 if (mip->mi_have_uid) { 594 debugprintf("changing owner (user) or %s to %u.", mtpoint, 595 mip->mi_uid); 596 if (!norun) 597 if (chown(mtpoint, mip->mi_uid, -1) == -1) 598 err(1, "chown %s to %u (user)", mtpoint, 599 mip->mi_uid); 600 } 601 if (mip->mi_have_gid) { 602 debugprintf("changing owner (group) or %s to %u.", mtpoint, 603 mip->mi_gid); 604 if (!norun) 605 if (chown(mtpoint, -1, mip->mi_gid) == -1) 606 err(1, "chown %s to %u (group)", mtpoint, 607 mip->mi_gid); 608 } 609 } 610 611 /* 612 * Put a file system on the memory disk. 613 */ 614 static void 615 do_newfs(const char *args) 616 { 617 int rv; 618 619 rv = run(NULL, "%s%s /dev/%s%d", _PATH_NEWFS, args, mdname, unit); 620 if (rv) 621 errx(1, "newfs exited %s %d", run_exitstr(rv), 622 run_exitnumber(rv)); 623 } 624 625 626 /* 627 * Copy skel into the mountpoint. 628 */ 629 static void 630 do_copy(const char *mtpoint, const char *skel) 631 { 632 int rv; 633 634 rv = chdir(skel); 635 if (rv != 0) 636 err(1, "chdir to %s", skel); 637 rv = run(NULL, "/bin/pax -rw -pe . %s", mtpoint); 638 if (rv != 0) 639 errx(1, "skel copy failed"); 640 } 641 642 /* 643 * 'str' should be a user and group name similar to the last argument 644 * to chown(1); i.e., a user, followed by a colon, followed by a 645 * group. The user and group in 'str' may be either a [ug]id or a 646 * name. Upon return, the uid and gid fields in 'mip' will contain 647 * the uid and gid of the user and group name in 'str', respectively. 648 * 649 * In other words, this derives a user and group id from a string 650 * formatted like the last argument to chown(1). 651 * 652 * Notice: At this point we don't support only a username or only a 653 * group name. do_mtptsetup already does, so when this feature is 654 * desired, this is the only routine that needs to be changed. 655 */ 656 static void 657 extract_ugid(const char *str, struct mtpt_info *mip) 658 { 659 char *ug; /* Writable 'str'. */ 660 char *user, *group; /* Result of extracton. */ 661 struct passwd *pw; 662 struct group *gr; 663 char *p; 664 uid_t *uid; 665 gid_t *gid; 666 667 uid = &mip->mi_uid; 668 gid = &mip->mi_gid; 669 mip->mi_have_uid = mip->mi_have_gid = false; 670 671 /* Extract the user and group from 'str'. Format above. */ 672 ug = strdup(str); 673 assert(ug != NULL); 674 group = ug; 675 user = strsep(&group, ":"); 676 if (user == NULL || group == NULL || *user == '\0' || *group == '\0') 677 usage(); 678 679 /* Derive uid. */ 680 *uid = strtoul(user, &p, 10); 681 if (*uid == (uid_t)ULONG_MAX) 682 usage(); 683 if (*p != '\0') { 684 pw = getpwnam(user); 685 if (pw == NULL) 686 errx(1, "invalid user: %s", user); 687 *uid = pw->pw_uid; 688 } 689 mip->mi_have_uid = true; 690 691 /* Derive gid. */ 692 *gid = strtoul(group, &p, 10); 693 if (*gid == (gid_t)ULONG_MAX) 694 usage(); 695 if (*p != '\0') { 696 gr = getgrnam(group); 697 if (gr == NULL) 698 errx(1, "invalid group: %s", group); 699 *gid = gr->gr_gid; 700 } 701 mip->mi_have_gid = true; 702 703 free(ug); 704 } 705 706 /* 707 * Run a process with command name and arguments pointed to by the 708 * formatted string 'cmdline'. Since system(3) is not used, the first 709 * space-delimited token of 'cmdline' must be the full pathname of the 710 * program to run. 711 * 712 * The return value is the return code of the process spawned, or a negative 713 * signal number if the process exited due to an uncaught signal. 714 * 715 * If 'ofd' is non-NULL, it is set to the standard output of 716 * the program spawned (i.e., you can read from ofd and get the output 717 * of the program). 718 */ 719 static int 720 run(int *ofd, const char *cmdline, ...) 721 { 722 char **argv, **argvp; /* Result of splitting 'cmd'. */ 723 int argc; 724 char *cmd; /* Expansion of 'cmdline'. */ 725 int pid, status; /* Child info. */ 726 int pfd[2]; /* Pipe to the child. */ 727 int nfd; /* Null (/dev/null) file descriptor. */ 728 bool dup2dn; /* Dup /dev/null to stdout? */ 729 va_list ap; 730 char *p; 731 int rv, i; 732 733 dup2dn = true; 734 va_start(ap, cmdline); 735 rv = vasprintf(&cmd, cmdline, ap); 736 if (rv == -1) 737 err(1, "vasprintf"); 738 va_end(ap); 739 740 /* Split up 'cmd' into 'argv' for use with execve. */ 741 for (argc = 1, p = cmd; (p = strchr(p, ' ')) != NULL; p++) 742 argc++; /* 'argc' generation loop. */ 743 argv = (char **)malloc(sizeof(*argv) * (argc + 1)); 744 assert(argv != NULL); 745 for (p = cmd, argvp = argv; (*argvp = strsep(&p, " ")) != NULL;) 746 if (**argvp != '\0') 747 if (++argvp >= &argv[argc]) { 748 *argvp = NULL; 749 break; 750 } 751 assert(*argv); 752 /* The argv array ends up NULL-terminated here. */ 753 754 /* Make sure the above loop works as expected. */ 755 if (debug) { 756 /* 757 * We can't, but should, use debugprintf here. First, 758 * it appends a trailing newline to the output, and 759 * second it prepends "DEBUG: " to the output. The 760 * former is a problem for this would-be first call, 761 * and the latter for the would-be call inside the 762 * loop. 763 */ 764 (void)fprintf(stderr, "DEBUG: running:"); 765 /* Should be equivalent to 'cmd' (before strsep, of course). */ 766 for (i = 0; argv[i] != NULL; i++) 767 (void)fprintf(stderr, " %s", argv[i]); 768 (void)fprintf(stderr, "\n"); 769 } 770 771 /* Create a pipe if necessary and fork the helper program. */ 772 if (ofd != NULL) { 773 if (pipe(&pfd[0]) == -1) 774 err(1, "pipe"); 775 *ofd = pfd[0]; 776 dup2dn = false; 777 } 778 pid = fork(); 779 switch (pid) { 780 case 0: 781 /* XXX can we call err() in here? */ 782 if (norun) 783 _exit(0); 784 if (ofd != NULL) 785 if (dup2(pfd[1], STDOUT_FILENO) < 0) 786 err(1, "dup2"); 787 if (!loudsubs) { 788 nfd = open(_PATH_DEVNULL, O_RDWR); 789 if (nfd == -1) 790 err(1, "open: %s", _PATH_DEVNULL); 791 if (dup2(nfd, STDIN_FILENO) < 0) 792 err(1, "dup2"); 793 if (dup2dn) 794 if (dup2(nfd, STDOUT_FILENO) < 0) 795 err(1, "dup2"); 796 if (dup2(nfd, STDERR_FILENO) < 0) 797 err(1, "dup2"); 798 } 799 800 (void)execv(argv[0], argv); 801 warn("exec: %s", argv[0]); 802 _exit(-1); 803 case -1: 804 err(1, "fork"); 805 } 806 807 free(cmd); 808 free(argv); 809 while (waitpid(pid, &status, 0) != pid) 810 ; 811 if (WIFEXITED(status)) 812 return (WEXITSTATUS(status)); 813 if (WIFSIGNALED(status)) 814 return (-WTERMSIG(status)); 815 err(1, "unexpected waitpid status: 0x%x", status); 816 } 817 818 /* 819 * If run() returns non-zero, provide a string explaining why. 820 */ 821 static const char * 822 run_exitstr(int rv) 823 { 824 if (rv > 0) 825 return ("with error code"); 826 if (rv < 0) 827 return ("with signal"); 828 return (NULL); 829 } 830 831 /* 832 * If run returns non-zero, provide a relevant number. 833 */ 834 static int 835 run_exitnumber(int rv) 836 { 837 if (rv < 0) 838 return (-rv); 839 return (rv); 840 } 841 842 static void 843 usage(void) 844 { 845 846 fprintf(stderr, 847 "usage: %s [-DLlMNnPStUX] [-a maxcontig] [-b block-size]\n" 848 "\t[-c blocks-per-cylinder-group][-d max-extent-size] [-E path-mdconfig]\n" 849 "\t[-e maxbpg] [-F file] [-f frag-size] [-i bytes] [-k skel]\n" 850 "\t[-m percent-free] [-O optimization] [-o mount-options]\n" 851 "\t[-p permissions] [-s size] [-v version] [-w user:group]\n" 852 "\tmd-device mount-point\n", getprogname()); 853 exit(1); 854 } 855