xref: /src/usr.sbin/sysinst/target.c

/*	$NetBSD: target.c,v 1.18 2022/02/10 16:11:41 martin Exp $	*/

/*
 * Copyright 1997 Jonathan Stone
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed for the NetBSD Project by
 *      Jonathan Stone.
 * 4. The name of Jonathan Stone may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY JONATHAN STONE ``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 PIERMONT INFORMATION SYSTEMS INC. 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.
 *
 */

/* Copyright below applies to the realpath() code */

/*
 * Copyright (c) 1989, 1991, 1993, 1995
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry.
 *
 * 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>
#if defined(LIBC_SCCS) && !defined(lint)
__RCSID("$NetBSD: target.c,v 1.18 2022/02/10 16:11:41 martin Exp $");
#endif

/*
 * target.c -- path-prefixing routines to access the target installation
 *  filesystems. Makes the install tools more independent of whether
 *  we're installing into a separate filesystem hierarchy mounted under
 * /targetroot, or into the currently active root mounted on /.
 */

#include <sys/param.h>			/* XXX vm_param.h always defines TRUE*/
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/sysctl.h>
#include <sys/stat.h>			/* stat() */
#include <sys/mount.h>			/* statfs() */

#include <fcntl.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
#include <curses.h>			/* defines TRUE, but checks  */
#include <errno.h>
#include <util.h>

#include "defs.h"
#include "md.h"
#include "msg_defs.h"
#include "menu_defs.h"

/*
 * local  prototypes
 */

static void make_prefixed_dir (const char *prefix, const char *path);
static int do_target_chdir (const char *dir, int flag);
int	target_test(unsigned int mode, const char *path);
int	target_test_dir (const char *path);	/* deprecated */
int	target_test_file (const char *path);	/* deprecated */
int	target_test_symlink (const char *path);	/* deprecated */

void unwind_mounts(void);

/* Record a mount for later unwinding of target mounts. */
struct unwind_mount {
	struct unwind_mount *um_prev;
	char um_mountpoint[4];		/* Allocated longer... */
};

/* Record a wedge for later deletion after all file systems have been unmounted */
struct umount_delwedge {
	struct umount_delwedge *next;
	char disk[DISKNAMESIZE], wedge[DISKNAMESIZE];
};
struct umount_delwedge *post_umount_dwlist = NULL;

/* Unwind-mount stack */
struct unwind_mount *unwind_mountlist = NULL;

/*
 * Debugging options
 */
/*#define DEBUG_ROOT*/		/* turn on what-is-root? debugging. */
/*#define DEBUG_UNWIND*/	/* turn on unwind-target-mount debugging. */

/*
 * debugging helper. curses...
 */
#if defined(DEBUG)  ||	defined(DEBUG_ROOT)
void
backtowin(void)
{

	fflush(stdout);	/* curses does not leave stdout linebuffered. */
	getchar();	/* wait for user to press return */
	wrefresh(stdscr);
}
#endif


/*
 * Is the root partition we're running from the same as the root
 * which the user has selected to install/upgrade?
 * Uses global variable "pm->diskdev" to find the selected device for
 * install/upgrade.
 */
int
target_already_root(void)
{
	char dev[PATH_MAX];
	int rootpart = -1;
	static struct pm_devs *last_pm;
	static int last_res;
	part_id ptn;
	struct disk_partitions *parts, *inner;
	struct disk_part_info info;

	if (pm == NULL)
		return 1;

	if (pm == last_pm)
		return last_res;

	if (pm->cur_system)
		return 1;

	last_pm = pm;
	last_res = 0;

	parts = pm->parts;
	if (parts == NULL) {
		last_res = 0;
		return 0;
	}

	if (pm->no_part) {
		last_res = is_active_rootpart(pm->diskdev, -1);
		return last_res;
	}

	if (pm->parts->pscheme->secondary_partitions != NULL) {
		inner = pm->parts->pscheme->secondary_partitions(parts,
		    pm->ptstart, false);
		if (inner != NULL)
			parts = inner;
	}

	for (ptn = 0; ptn < parts->num_part; ptn++) {
		if (!parts->pscheme->get_part_info(parts, ptn, &info))
			continue;
		if (info.nat_type->generic_ptype != PT_root)
			continue;
		if (!is_root_part_mount(info.last_mounted))
			continue;
		if (!parts->pscheme->get_part_device(parts, ptn,
		    dev, sizeof dev, &rootpart, plain_name, false, true))
			continue;

		last_res = is_active_rootpart(dev, rootpart);
		break;
 	}

	return last_res;
}

/*
 * Could something with this "last mounted on" information be a potential
 * root partition?
 */
bool
is_root_part_mount(const char *last_mounted)
{
	if (last_mounted == NULL)
		return false;

	return strcmp(last_mounted, "/") == 0 ||
	    strcmp(last_mounted, "/targetroot") == 0 ||
	    strcmp(last_mounted, "/altroot") == 0;
}

/*
 * Is this device partition (e.g., "sd0a") mounted as root?
 */
int
is_active_rootpart(const char *dev, int ptn)
{
	int mib[2];
	char rootdev[SSTRSIZE];
	int rootptn;
	size_t varlen;

	mib[0] = CTL_KERN;
	mib[1] = KERN_ROOT_DEVICE;
	varlen = sizeof(rootdev);
	if (sysctl(mib, 2, rootdev, &varlen, NULL, 0) < 0)
		return 1;

	if (strcmp(dev, rootdev) != 0)
		return 0;

	if (ptn < 0)
		return 1;	/* device only check, or wedge */

	mib[1] = KERN_ROOT_PARTITION;
	varlen = sizeof rootptn;
	rootptn = -1;
	if (sysctl(mib, 2, &rootptn, &varlen, NULL, 0) < 0)
		return 1;

	return ptn == rootptn;
}

/*
 * Pathname  prefixing glue to support installation either
 * from in-ramdisk miniroots or on-disk diskimages.
 * If our root is on the target disk, the install target is mounted
 * on /targetroot and we need to prefix installed pathnames with /targetroot.
 * otherwise we are installing to the currently-active root and
 * no prefix is needed.
 */
const char *
target_prefix(void)
{
	/*
	 * XXX fetch sysctl variable for current root, and compare
	 * to the devicename of the install target disk.
	 */
	return(target_already_root() ? "" : targetroot_mnt);
}

/*
 * concatenate two pathnames.
 * XXX returns either input args or result in a static buffer.
 * The caller must copy if it wants to use the pathname past the
 * next call to a target-prefixing function, or to modify the inputs.
 * Used only internally so this is probably safe.
 */
const char *
concat_paths(const char *prefix, const char *suffix)
{
	static char real_path[MAXPATHLEN];

	/* absolute prefix and null suffix? */
	if (prefix[0] == '/' && suffix[0] == 0)
		return prefix;

	/* null prefix and absolute suffix? */
	if (prefix[0] == 0 && suffix[0] == '/')
		return suffix;

	/* avoid "//" */
	if (suffix[0] == '/' || suffix[0] == 0)
		snprintf(real_path, sizeof(real_path), "%s%s", prefix, suffix);
	else
		snprintf(real_path, sizeof(real_path), "%s/%s",
		    prefix, suffix);
	return (real_path);
}

/*
 * Do target prefix expansion on a pathname.
 * XXX uses concat_paths and so returns result in a static buffer.
 * The caller must copy if it wants to use the pathname past the
 * next call to a target-prefixing function, or to modify the inputs.
 * Used only internally so this is probably safe.
 *
 * Not static so other functions can generate target related file names.
 */
const char *
target_expand(const char *tgtpath)
{

	return concat_paths(target_prefix(), tgtpath);
}

/* Make a directory, with a prefix like "/targetroot" or possibly just "". */
static void
make_prefixed_dir(const char *prefix, const char *path)
{

	run_program(0, "/bin/mkdir -p %s", concat_paths(prefix, path));
}

/* Make a directory with a pathname relative to the installation target. */
void
make_target_dir(const char *path)
{

	make_prefixed_dir(target_prefix(), path);
}


static int
do_target_chdir(const char *dir, int must_succeed)
{
	const char *tgt_dir;
	int error;

	error = 0;
	tgt_dir = target_expand(dir);

#ifdef DEBUG
	printf("target_chdir (%s)\n", tgt_dir);
	//return (0);
#endif
	/* chdir returns -1 on error and sets errno. */
	if (chdir(tgt_dir) < 0)
		error = errno;
	if (logfp) {
		fprintf(logfp, "cd to %s\n", tgt_dir);
		fflush(logfp);
	}
	if (script) {
		scripting_fprintf(NULL, "cd %s\n", tgt_dir);
		fflush(script);
	}

	if (error && must_succeed) {
		const char *args[] = { target_prefix(), strerror(error) };
		char *err = str_arg_subst(msg_string(MSG_realdir),
		    __arraycount(args), args);
		fprintf(stderr, "%s\n", err);
		if (logfp)
			fprintf(logfp, "%s\n", err);
		free(err);
		exit(1);
	}
	errno = error;
	return (error);
}

void
target_chdir_or_die(const char *dir)
{

	(void)do_target_chdir(dir, 1);
}

#ifdef notdef
int
target_chdir(const char *dir)
{

	return do_target_chdir(dir, 0);
}
#endif

/*
 * Copy a file from the current root into the target system,
 * where the  destination pathname is relative to the target root.
 * Does not check for copy-to-self when target is  current root.
 */
int
cp_to_target(const char *srcpath, const char *tgt_path)
{
	const char *real_path = target_expand(tgt_path);

	return run_program(0, "/bin/cp %s %s", srcpath, real_path);
}

/*
 * Duplicate a file from the current root to the same pathname
 * in the target system.  Pathname must be an absolute pathname.
 * If we're running in the target, do nothing.
 */
void
dup_file_into_target(const char *filename)
{

	if (!target_already_root())
		cp_to_target(filename, filename);
}


/*
 * Do a mv where both pathnames are within the target filesystem.
 */
void
mv_within_target_or_die(const char *frompath, const char *topath)
{
	char realfrom[STRSIZE];
	char realto[STRSIZE];

	strlcpy(realfrom, target_expand(frompath), sizeof realfrom);
	strlcpy(realto, target_expand(topath), sizeof realto);

	run_program(RUN_FATAL, "mv %s %s", realfrom, realto);
}

/* Do a cp where both pathnames are within the target filesystem. */
int
cp_within_target(const char *frompath, const char *topath, int optional)
{
	char realfrom[STRSIZE];
	char realto[STRSIZE];

	strlcpy(realfrom, target_expand(frompath), sizeof realfrom);
	strlcpy(realto, target_expand(topath), sizeof realto);

	if (access(realfrom, R_OK) == -1 && optional)
		return 0;
	return (run_program(0, "cp -p %s %s", realfrom, realto));
}

/* fopen a pathname in the target. */
FILE *
target_fopen(const char *filename, const char *type)
{

	return fopen(target_expand(filename), type);
}

/*
 * Do a mount onto a mountpoint in the install target.
 * Record mountpoint so we can unmount when finished.
 * NB: does not prefix mount-from, which probably breaks nullfs mounts.
 */
int
target_mount_do(const char *opts, const char *from, const char *on)
{
	struct unwind_mount *m;
	int error;
	int len;

	len = strlen(on);
	m = malloc(sizeof *m + len);
	if (m == 0)
		return (ENOMEM);	/* XXX */

	memcpy(m->um_mountpoint, on, len + 1);

#ifdef DEBUG_UNWIND
	endwin();
	fprintf(stderr, "mounting %s with unwind\n", on);
	backtowin();
#endif

	error = run_program(0, "/sbin/mount %s %s %s%s",
			opts, from, target_prefix(), on);
	if (error) {
		free(m);
		return error;
	}
	m->um_prev = unwind_mountlist;
	unwind_mountlist = m;
	return 0;
}

/*
 * Special case - we have mounted the target / readonly
 * to peek at etc/fstab, and now want it undone.
 */
void
umount_root(void)
{

	/* verify this is the only mount */
	if (unwind_mountlist == NULL)
		return;
	if (unwind_mountlist->um_prev != NULL)
		return;

	if (run_program(0, "/sbin/umount %s", target_prefix()) != 0)
		return;

	free(unwind_mountlist);
	unwind_mountlist = NULL;
}


int
target_mount(const char *opts, const char *from, const char *on)
{
	return target_mount_do(opts, from, on);
}

int
target_unmount(const char *mount_point)
{
	struct unwind_mount *m, *prev = NULL;
	int error;

	for (m = unwind_mountlist; m != NULL; prev = m, m = m->um_prev)
		if (strcmp(m->um_mountpoint, mount_point) == 0)
			break;

	if (m == NULL)
		return ENOTDIR;

	error = run_program(0, "/sbin/umount %s%s",
		    target_prefix(), m->um_mountpoint);
	if (error)
		return error;

	if (m == unwind_mountlist)
		unwind_mountlist = m->um_prev;
	else
		prev->um_prev = m->um_prev;
	free(m);

	return 0;
}

static bool
delete_wedge(const char *disk, const char *wedge)
{
	struct dkwedge_info dkw;
	char diskpath[MAXPATHLEN];
	int fd, error;

	fd = opendisk(disk, O_RDWR, diskpath, sizeof(diskpath), 0);
	if (fd < 0)
		return false;
	memset(&dkw, 0, sizeof(dkw));
	strlcpy(dkw.dkw_devname, wedge, sizeof(dkw.dkw_devname));
	error = ioctl(fd, DIOCDWEDGE, &dkw);
	close(fd);
	return error == 0;
}

void
register_post_umount_delwedge(const char *disk, const char *wedge)
{
	struct umount_delwedge *dw;

	if (unwind_mountlist == NULL) {
		/* we have nothing mounted, can delete it right now */
		delete_wedge(disk, wedge);
		return;
	}

	dw = calloc(1, sizeof(*dw));
	dw->next = post_umount_dwlist;
	strlcpy(dw->disk, disk, sizeof(dw->disk));
	strlcpy(dw->wedge, wedge, sizeof(dw->wedge));
	post_umount_dwlist = dw;
}

/*
 * unwind the mount stack, unmounting mounted filesystems.
 * For now, ignore any errors in unmount.
 * (Why would we be unable to unmount?  The user has suspended
 *  us and forked shell sitting somewhere in the target root?)
 */
void
unwind_mounts(void)
{
	struct unwind_mount *m;
	struct umount_delwedge *dw;
	static volatile int unwind_in_progress = 0;

	/* signal safety */
	if (unwind_in_progress)
		return;
	unwind_in_progress = 1;

	while ((m = unwind_mountlist) != NULL) {
		unwind_mountlist = m->um_prev;
#ifdef DEBUG_UNWIND
		endwin();
		fprintf(stderr, "unmounting %s\n", m->um_mountpoint);
		backtowin();
#endif
		run_program(0, "/sbin/umount %s%s",
			target_prefix(), m->um_mountpoint);
		free(m);
	}
	while ((dw = post_umount_dwlist) != NULL) {
		post_umount_dwlist = dw->next;
		delete_wedge(dw->disk, dw->wedge);
		free(dw);
	}
	unwind_in_progress = 0;
}

int
target_collect_file(int kind, char **buffer, const char *name)
{
	const char *realname = target_expand(name);

#ifdef	DEBUG
	printf("collect real name %s\n", realname);
#endif
	return collect(kind, buffer, "%s", realname);
}

/*
 * Verify a pathname already exists in the target root filesystem,
 * by running  test "testflag" on the expanded target pathname.
 */
int
target_test(unsigned int mode, const char *path)
{
	const char *real_path = target_expand(path);
	register int result;

	result = !file_mode_match(real_path, mode);
	scripting_fprintf(NULL, "if [ $? != 0 ]; then echo \"%s does not exist!\"; fi\n", real_path);

#if defined(DEBUG)
	printf("target_test(%o, %s) returning %d\n", mode, real_path, result);
#endif
	return (result);
}

/*
 * Verify a directory already exists in the target root
 * filesystem. Do not create the directory if it doesn't  exist.
 * Assumes that sysinst has already mounted the target root.
 */
int
target_test_dir(const char *path)
{

 	return target_test(S_IFDIR, path);
}

/*
 * Verify an ordinary file already exists in the target root
 * filesystem. Do not create the directory if it doesn't  exist.
 * Assumes that sysinst has already mounted the target root.
 */
int
target_test_file(const char *path)
{

 	return target_test(S_IFREG, path);
}

int
target_test_symlink(const char *path)
{

 	return target_test(S_IFLNK, path);
}

int
target_file_exists_p(const char *path)
{

	return (target_test_file(path) == 0);
}

int
target_dir_exists_p(const char *path)
{

	return (target_test_dir(path) == 0);
}

int
target_symlink_exists_p(const char *path)
{

	return (target_test_symlink(path) == 0);
}

int
target_mounted(void)
{
	return (unwind_mountlist != NULL);
}