/*	$NetBSD: mount.c,v 1.108 2025/07/01 17:55:05 kre Exp $	*/

/*
 * Copyright (c) 1980, 1989, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1980, 1989, 1993, 1994\
 The Regents of the University of California.  All rights reserved.");
#endif /* not lint */

#ifndef lint
#if 0
static char sccsid[] = "@(#)mount.c	8.25 (Berkeley) 5/8/95";
#else
__RCSID("$NetBSD: mount.c,v 1.108 2025/07/01 17:55:05 kre Exp $");
#endif
#endif /* not lint */

#include <sys/param.h>
#include <sys/mount.h>
#include <sys/wait.h>

#include <fs/puffs/puffs_msgif.h>

#include <err.h>
#include <errno.h>
#include <fstab.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#define MOUNTNAMES
#include <fcntl.h>
#include <sys/disk.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>

#include "pathnames.h"
#include "mountprog.h"

static int	debug, verbose, noise;

static void	catopt(char **, const char *);
static const char *
		getfslab(const char *str);
static struct statvfs *
		getmntpt(const char *);
static int 	getmntargs(struct statvfs *, char *, size_t);
static int	hasopt(const char *, const char *);
static void	mangle(char *, int *, const char ** volatile *, int *);
static int	mountfs(const char *, const char *, const char *,
		    int, const char *, const char *, int, char *, size_t);
static void	prmount(struct statvfs *);
__dead static void	usage(void);


/* Map from mount options to printable formats. */
static const struct opt {
	int o_opt;
	int o_silent;
	const char *o_name;
} optnames[] = {
	__MNT_FLAGS
};

#define FLG_UPDATE	1
#define FLG_RDONLY	2
#define FLG_RDWRITE	4
#define FLG_FORCE	8

static const char ffs_fstype[] = "ffs";

int
main(int argc, char *argv[])
{
	const char *mntfromname, *mntonname, **vfslist, *vfstype;
	struct fstab *fs;
	struct statvfs *mntbuf;
#if 0
	FILE *mountdfp;
#endif
	int all, ch, forceall, i, init_flags, mntsize, rval;
	char *options;
	const char *mountopts, *fstypename;
	char canonical_path_buf[MAXPATHLEN], buf[MAXPATHLEN];
	char *canonical_path;

	/* started as "mount" */
	all = forceall = init_flags = 0;
	options = NULL;
	vfslist = NULL;
	vfstype = ffs_fstype;
	while ((ch = getopt(argc, argv, "Aadfo:rwt:uv")) != -1)
		switch (ch) {
		case 'A':
			all = forceall = 1;
			break;
		case 'a':
			all = 1;
			break;
		case 'd':
			debug = 1;
			break;
		case 'f':
			init_flags |= FLG_FORCE;
			break;
		case 'o':
			if (*optarg)
				catopt(&options, optarg);
			break;
		case 'r':
			init_flags |= FLG_RDONLY;
			break;
		case 't':
			if (vfslist != NULL)
				errx(EXIT_FAILURE,
				    "Only one -t option may be specified.");
			vfslist = makevfslist(optarg);
			vfstype = optarg;
			break;
		case 'u':
			init_flags |= FLG_UPDATE;
			break;
		case 'v':
			verbose++;
			break;
		case 'w':
			init_flags |= FLG_RDWRITE;
			break;
		case '?':
		default:
			usage();
			/* NOTREACHED */
		}
	argc -= optind;
	argv += optind;

#define	BADTYPE(type)							\
	(strcmp(type, FSTAB_RO) &&					\
	    strcmp(type, FSTAB_RW) && strcmp(type, FSTAB_RQ))

	noise = 0;
	if (argc > 0 && verbose) {
		noise = 1;
		verbose--;
	}

	rval = 0;
	switch (argc) {
	case 0:
		if (all) {
			while ((fs = getfsent()) != NULL) {
				if (BADTYPE(fs->fs_type))
					continue;
				if (checkvfsname(fs->fs_vfstype, vfslist))
					continue;
				if (hasopt(fs->fs_mntops, "noauto"))
					continue;
				if (strcmp(fs->fs_spec, "from_mount") == 0) {
					if ((mntbuf = getmntpt(fs->fs_file))
					    == NULL)
						errx(EXIT_FAILURE,
						    "Unknown file system %s",
						    fs->fs_file);
					mntfromname = mntbuf->f_mntfromname;
				} else
					mntfromname = fs->fs_spec;
				mntfromname = getfsspecname(buf, sizeof(buf),
				    mntfromname);
				if (mntfromname == NULL)
					err(EXIT_FAILURE, "%s", buf);
				if (mountfs(fs->fs_vfstype, mntfromname,
				    fs->fs_file, init_flags, options,
				    fs->fs_mntops, !forceall, NULL, 0))
					rval = 1;
			}
		} else {
			if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0)
				err(EXIT_FAILURE, "getmntinfo");
			for (i = 0; i < mntsize; i++) {
				if (checkvfsname(mntbuf[i].f_fstypename,
				    vfslist))
					continue;
				prmount(&mntbuf[i]);
			}
		}
		return rval;
	case 1:
		if (vfslist != NULL) {
			usage();
			/* NOTREACHED */
		}

		/*
		 * Create a canonical version of the device or mount path
		 * passed to us.  It's ok for this to fail.  It's also ok
		 * for the result to be exactly the same as the original.
		 */
		canonical_path = realpath(*argv, canonical_path_buf);

		if (init_flags & FLG_UPDATE) {
			/*
			 * Try looking up the canonical path first,
			 * then try exactly what the user entered.
			 */
			if ((canonical_path == NULL ||
			    (mntbuf = getmntpt(canonical_path)) == NULL) &&
			    (mntbuf = getmntpt(*argv)) == NULL) {
out:
				errx(EXIT_FAILURE,
				    "Unknown special file or file system `%s'",
				    *argv);
			}
			mntfromname = mntbuf->f_mntfromname;
			if ((fs = getfsfile(mntbuf->f_mntonname)) != NULL) {
				if (strcmp(fs->fs_spec, "from_mount") != 0)
					mntfromname = fs->fs_spec;
				/* ignore the fstab file options.  */
				fs->fs_mntops = NULL;
			}
			mntonname  = mntbuf->f_mntonname;
			fstypename = mntbuf->f_fstypename;
			mountopts  = NULL;
		} else {
			/*
			 * Try looking up the canonical path first,
			 * then try exactly what the user entered.
			 */
			if (canonical_path == NULL ||
			    ((fs = getfsfile(canonical_path)) == NULL &&
			     (fs = getfsspec(canonical_path)) == NULL))
			{
				if ((fs = getfsfile(*argv)) == NULL &&
				    (fs = getfsspec(*argv)) == NULL) {
					goto out;
				}
			}
			if (BADTYPE(fs->fs_type))
				errx(EXIT_FAILURE,
				    "Unknown file system type for `%s'",
				    *argv);
			if (strcmp(fs->fs_spec, "from_mount") == 0) {
				if ((canonical_path == NULL ||
				    (mntbuf = getmntpt(canonical_path))
				     == NULL) &&
				    (mntbuf = getmntpt(*argv)) == NULL)
					goto out;
				mntfromname = mntbuf->f_mntfromname;
			} else
				mntfromname = fs->fs_spec;
			mntonname   = fs->fs_file;
			fstypename  = fs->fs_vfstype;
			mountopts   = fs->fs_mntops;
		}
		mntfromname = getfsspecname(buf, sizeof(buf), mntfromname);
		if (mntfromname == NULL)
			err(EXIT_FAILURE, "%s", buf);
		rval = mountfs(fstypename, mntfromname,
		    mntonname, init_flags, options, mountopts, 0, NULL, 0);
		break;
	case 2:
		/*
		 * If -t flag has not been specified, and spec contains either
		 * a ':' or a '@' then assume that an NFS filesystem is being
		 * specified ala Sun.
		 */
		mntfromname = getfsspecname(buf, sizeof(buf), argv[0]);
		if (mntfromname == NULL)
			err(EXIT_FAILURE, "%s", buf);
		if (vfslist == NULL) {
			if (strpbrk(argv[0], ":@") != NULL) {
				vfstype = "nfs";
			} else {
				vfstype = getfslab(mntfromname);
				if (vfstype == NULL)
					vfstype = ffs_fstype;
			}
		}
		rval = mountfs(vfstype, mntfromname, argv[1], init_flags,
		    options, NULL, 0, NULL, 0);
		break;
	default:
		usage();
	}

#if 0	/* disabled because it interferes the service. */
	/*
	 * If the mount was successfully, and done by root, tell mountd the
	 * good news.  Pid checks are probably unnecessary, but don't hurt.
	 */
	if (rval == 0 && getuid() == 0 &&
	    (mountdfp = fopen(_PATH_MOUNTDPID, "r")) != NULL) {
		int pid;

		if (fscanf(mountdfp, "%d", &pid) == 1 &&
		    pid > 0 && kill(pid, SIGHUP) == -1 && errno != ESRCH)
			err(EXIT_FAILURE, "signal mountd");
		(void)fclose(mountdfp);
	}
#endif

	return rval;
}

int
hasopt(const char *mntopts, const char *option)
{
	int negative, found;
	char *opt, *optbuf;

	if (option[0] == 'n' && option[1] == 'o') {
		negative = 1;
		option += 2;
	} else
		negative = 0;
	optbuf = estrdup(mntopts);
	found = 0;
	for (opt = optbuf; (opt = strtok(opt, ",")) != NULL; opt = NULL) {
		if (opt[0] == 'n' && opt[1] == 'o') {
			if (!strcasecmp(opt + 2, option))
				found = negative;
		} else if (!strcasecmp(opt, option))
			found = !negative;
	}
	free(optbuf);
	return found;
}

static int
mountfs(const char *vfstype, const char *spec, const char *name,
    int flags, const char *options, const char *mntopts,
    int skipmounted, char *buf, size_t buflen)
{
	/* List of directories containing mount_xxx subcommands. */
	static const char *edirs[] = {
#ifdef RESCUEDIR
		RESCUEDIR,
#endif
		_PATH_SBIN,
		_PATH_USRSBIN,
		NULL
	};
	const char ** volatile argv, **edir;
	struct statvfs *sfp, sf;
	pid_t pid;
	int pfd[2];
	int argc, numfs, i, status, maxargc;
	char *optbuf, execname[MAXPATHLEN + 1], execbase[MAXPATHLEN],
	    mntpath[MAXPATHLEN];
	volatile int getargs;

	if (realpath(name, mntpath) == NULL) {
		warn("realpath `%s'", name);
		return 1;
	}

	name = mntpath;

	optbuf = NULL;
	if (mntopts)
		catopt(&optbuf, mntopts);

	if (options) {
		catopt(&optbuf, options);
		getargs = strstr(options, "getargs") != NULL;
	} else
		getargs = 0;

	if (!mntopts && !options)
		catopt(&optbuf, "rw");

	if (getargs == 0 && strcmp(name, "/") == 0 && !hasopt(optbuf, "union"))
		flags |= FLG_UPDATE;
	else if (skipmounted) {
		if ((numfs = getmntinfo(&sfp, MNT_WAIT)) == 0) {
			warn("getmntinfo");
			return 1;
		}
		for(i = 0; i < numfs; i++) {
			const char *mountedtype = sfp[i].f_fstypename;
			size_t cmplen = sizeof(sfp[i].f_fstypename);

			/* remove "puffs|" from comparisons, if present */
#define TYPESIZE (sizeof(PUFFS_TYPEPREFIX)-1)
			if (strncmp(mountedtype,
			    PUFFS_TYPEPREFIX, TYPESIZE) == 0) {
				mountedtype += TYPESIZE;
				cmplen -= TYPESIZE;
			}

			/*
			 * XXX can't check f_mntfromname,
			 * thanks to mfs, union, etc.
			 */
			if (strncmp(name, sfp[i].f_mntonname, MNAMELEN) == 0 &&
			    strncmp(vfstype, mountedtype, cmplen) == 0) {
				if (noise || verbose)
					(void)printf("%s on %s type %.*s: "
					    "%s\n",
					    sfp[i].f_mntfromname,
					    sfp[i].f_mntonname,
					    (int)sizeof(sfp[i].f_fstypename),
					    sfp[i].f_fstypename,
					    "already mounted");
				return 0;
			}
		}
	}
	if (flags & FLG_FORCE)
		catopt(&optbuf, "force");
	if (flags & FLG_RDONLY)
		catopt(&optbuf, "ro");
	/* make -w override -r */
	if (flags & FLG_RDWRITE)
		catopt(&optbuf, "rw");

	if (flags & FLG_UPDATE) {
		catopt(&optbuf, "update");
		/* Figure out the fstype only if we defaulted to ffs */
		if (vfstype == ffs_fstype && statvfs(name, &sf) != -1)
			vfstype = sf.f_fstypename;
	}

	maxargc = 64;
	argv = ecalloc(maxargc, sizeof(*argv));

	if (getargs &&
	    strncmp(vfstype, PUFFS_TYPEPREFIX, sizeof(PUFFS_TYPEPREFIX)-1) == 0)
		(void)snprintf(execbase, sizeof(execbase), "mount_puffs");
	else if (hasopt(optbuf, "rump"))
		(void)snprintf(execbase, sizeof(execbase), "rump_%s", vfstype);
	else
		(void)snprintf(execbase, sizeof(execbase), "mount_%s", vfstype);
	argc = 0;
	argv[argc++] = execbase;
	if (optbuf)
		mangle(optbuf, &argc, &argv, &maxargc);
	argv[argc++] = spec;
	argv[argc++] = name;
	argv[argc] = NULL;

	if ((verbose && buf == NULL) || debug) {
		(void)printf("exec:");
		for (i = 0; i < argc; i++)
			(void)printf(" %s", argv[i]);
		(void)printf("\n");
		if (debug) {
			/*
			 * Don't proceed to attempt to
			 * print fs data, nothing has been
			 * mounted, anything printed would
			 * be for some other filesystem.
			 */
			return 0;
		}
	}

	if (buf) {
		if (pipe(pfd) == -1)
			warn("Cannot create pipe");
	}

	switch (pid = fork()) {
	case -1:				/* Error. */
		warn("fork");
		if (optbuf)
			free(optbuf);
		free(argv);
		return 1;

	case 0:					/* Child. */
		if (debug)
			_exit(0);

		if (buf) {
			(void)close(pfd[0]);
			(void)close(STDOUT_FILENO);
			if (dup2(pfd[1], STDOUT_FILENO) == -1)
				warn("Cannot open fd to mount program");
		}

		/* Go find an executable. */
		edir = edirs;
		do {
			(void)snprintf(execname,
			    sizeof(execname), "%s/%s", *edir, execbase);
			(void)execv(execname, __UNCONST(argv));
			if (errno != ENOENT)
				warn("exec %s for %s", execname, name);
		} while (*++edir != NULL);

		if (errno == ENOENT)
			warn("exec %s for %s: %s", execbase, name, execbase);
		_exit(1);
		/* NOTREACHED */

	default:				/* Parent. */
		if (optbuf)
			free(optbuf);
		free(argv);

		if (buf || getargs) {
			char tbuf[1024], *ptr;
			int nread;

			if (buf == NULL) {
				ptr = tbuf;
				buflen = sizeof(tbuf) - 1;
			} else {
				ptr = buf;
				buflen--;
			}
			(void)close(pfd[1]);
			(void)signal(SIGPIPE, SIG_IGN);
			while ((nread = read(pfd[0], ptr, buflen)) > 0) {
				buflen -= nread;
				ptr += nread;
			}
			*ptr = '\0';
			if (buflen == 0) {
				while (read(pfd[0], &nread, sizeof(nread)) > 0)
					continue;
			}
			if (buf == NULL)
				(void)fprintf(stdout, "%s", tbuf);
		}

		if (waitpid(pid, &status, 0) == -1) {
			warn("waitpid");
			return 1;
		}

		if (WIFEXITED(status)) {
			if (WEXITSTATUS(status) != 0)
				return WEXITSTATUS(status);
		} else if (WIFSIGNALED(status)) {
			warnx("%s: %s", name, strsignal(WTERMSIG(status)));
			return 1;
		}

		if (buf == NULL) {
			if (verbose || noise) {
				if (statvfs(name, &sf) == -1) {
					warn("statvfs %s", name);
					return 1;
				}
				prmount(&sf);
			}
		}
		break;
	}

	return 0;
}

static void
prmount(struct statvfs *sfp)
{
	int flags;
	const struct opt *o;
	struct passwd *pw;
	int f;

	(void)printf("%s on %s type %.*s", sfp->f_mntfromname,
	    sfp->f_mntonname, (int)sizeof(sfp->f_fstypename),
	    sfp->f_fstypename);

	flags = sfp->f_flag & MNT_VISFLAGMASK;
	for (f = 0, o = optnames; flags && o <
	    &optnames[sizeof(optnames)/sizeof(optnames[0])]; o++)
		if (flags & o->o_opt) {
			if (!o->o_silent || verbose)
				(void)printf("%s%s", !f++ ? " (" : ", ",
				    o->o_name);
			flags &= ~o->o_opt;
		}
	if (flags)
		(void)printf("%sunknown flag%s %#x", !f++ ? " (" : ", ",
		    flags & (flags - 1) ? "s" : "", flags);
	if (sfp->f_owner) {
		(void)printf("%smounted by ", !f++ ? " (" : ", ");
		if ((pw = getpwuid(sfp->f_owner)) != NULL)
			(void)printf("%s", pw->pw_name);
		else
			(void)printf("%d", sfp->f_owner);
	}
	if (verbose)
		(void)printf("%sfsid: 0x%x/0x%x",
		    !f++ ? " (" /* ) */: ", ",
		    sfp->f_fsidx.__fsid_val[0], sfp->f_fsidx.__fsid_val[1]);

	if (verbose) {
		(void)printf("%s", !f++ ? " (" : ", ");
		(void)printf("reads: sync %" PRIu64 " async %" PRIu64 "",
		    sfp->f_syncreads, sfp->f_asyncreads);
		(void)printf(", writes: sync %" PRIu64 " async %" PRIu64 "",
		    sfp->f_syncwrites, sfp->f_asyncwrites);
		if (verbose > 1) {
			char buf[2048];

			if (getmntargs(sfp, buf, sizeof(buf)))
				printf(", [%s: %s]", sfp->f_fstypename, buf);
		}
		printf(")\n");
	} else
		(void)printf("%s", f ? ")\n" : "\n");
}

static int
getmntargs(struct statvfs *sfs, char *buf, size_t buflen)
{

	if (mountfs(sfs->f_fstypename, sfs->f_mntfromname, sfs->f_mntonname, 0,
	    "getargs", NULL, 0, buf, buflen))
		return 0;
	else {
		if (*buf == '\0')
			return 0;
		if ((buf = strchr(buf, '\n')) != NULL)
			*buf = '\0';
		return 1;
	}
}

static struct statvfs *
getmntpt(const char *name)
{
	struct statvfs *mntbuf;
	int i, mntsize;

	mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
	for (i = 0; i < mntsize; i++)
		if (strcmp(mntbuf[i].f_mntfromname, name) == 0 ||
		    strcmp(mntbuf[i].f_mntonname, name) == 0)
			return &mntbuf[i];
	return NULL;
}

static void
catopt(char **sp, const char *o)
{
	char *s, *n;

	s = *sp;
	if (s) {
		easprintf(&n, "%s,%s", s, o);
		free(s);
		s = n;
	} else
		s = estrdup(o);
	*sp = s;
}

static void
mangle(char *options, int *argcp, const char ** volatile *argvp, int *maxargcp)
{
	char *p, *s;
	int argc, maxargc;
	const char **argv, **nargv;

	argc = *argcp;
	argv = *argvp;
	maxargc = *maxargcp;

	for (s = options; (p = strsep(&s, ",")) != NULL;) {
		/* Always leave space for one more argument and the NULL. */
		if (argc >= maxargc - 4) {
			nargv = erealloc(argv, (maxargc << 1) * sizeof(nargv));
			argv = nargv;
			maxargc <<= 1;
		}
		if (*p != '\0') {
			if (*p == '-') {
				argv[argc++] = p;
				p = strchr(p, '=');
				if (p) {
					*p = '\0';
					argv[argc++] = p+1;
				}
			} else {
				argv[argc++] = "-o";
				argv[argc++] = p;
			}
		}
	}

	*argcp = argc;
	*argvp = argv;
	*maxargcp = maxargc;
}

/* Deduce the filesystem type from the disk label. */
static const char *
getfslab(const char *str)
{
	static struct dkwedge_info dkw;
	struct disklabel dl;
	int fd;
	int part;
	const char *vfstype;
	u_char fstype;
	char buf[MAXPATHLEN + 1];
	char *sp, *ep;

	if ((fd = open(str, O_RDONLY)) == -1) {
		/*
		 * Iff we get EBUSY try the raw device. Since mount always uses
		 * the block device we know we are never passed a raw device.
		 */
		if (errno != EBUSY)
			err(EXIT_FAILURE, "cannot open `%s'", str);
		strlcpy(buf, str, MAXPATHLEN);
		if ((sp = strrchr(buf, '/')) != NULL)
			++sp;
		else
			sp = buf;
		for (ep = sp + strlen(sp) + 1;  ep > sp; ep--)
			*ep = *(ep - 1);
		*sp = 'r';

		/* Silently fail here - mount call can display error */
		if ((fd = open(buf, O_RDONLY)) == -1)
			return NULL;
	}

	/* Check to see if this is a wedge. */
	if (ioctl(fd, DIOCGWEDGEINFO, &dkw) == 0) {
		/* Yup, this is easy. */
		close(fd);
		if (*dkw.dkw_ptype)
			return dkw.dkw_ptype;
		return NULL;
	}

	if (ioctl(fd, DIOCGDINFO, &dl) == -1) {
		(void) close(fd);
		return NULL;
	}

	(void) close(fd);

	part = str[strlen(str) - 1] - 'a';

	if (part < 0 || part >= dl.d_npartitions)
		return NULL;

	/* Return NULL for unknown types - caller can fall back to ffs */
	if ((fstype = dl.d_partitions[part].p_fstype) >= FSMAXMOUNTNAMES)
		vfstype = NULL;
	else
		vfstype = mountnames[fstype];

	return vfstype;
}

static void
usage(void)
{

	(void)fprintf(stderr, "Usage: %s [-Aadfruvw] [-t type]\n"
	    "\t%s [-dfruvw] special | node\n"
	    "\t%s [-dfruvw] [-o options] [-t type] special node\n",
	    getprogname(), getprogname(), getprogname());
	exit(1);
}
