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