407 lines
10 KiB
C
407 lines
10 KiB
C
/* $NetBSD: target.c,v 1.7 1997/11/05 07:28:34 jonathan 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 develooped 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.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#if defined(LIBC_SCCS) && !defined(lint)
|
|
__RCSID("$NetBSD: target.c,v 1.7 1997/11/05 07:28:34 jonathan Exp $");
|
|
#endif
|
|
|
|
|
|
/*
|
|
* target.c -- path-prefixing routines to access the target installation
|
|
* filesystems. Makes the install tools more ndependent of whether
|
|
* we're installing into a separate filesystem hierarchy mounted under /mnt,
|
|
* or into the currently active root mounted on /.
|
|
*/
|
|
|
|
#include <sys/param.h> /* XXX vm_param.h always defines TRUE*/
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <unistd.h>
|
|
#include <curses.h> /* defines TRUE, but checks */
|
|
#include <errno.h>
|
|
|
|
|
|
#include "defs.h"
|
|
#include "md.h"
|
|
#include "msg_defs.h"
|
|
#include "menu_defs.h"
|
|
|
|
|
|
/*
|
|
* local prototypes
|
|
*/
|
|
static const char* getroot __P((void));
|
|
static void make_prefixed_dir __P((const char *prefix, const char *path));
|
|
const char* target_prefix __P((void));
|
|
static int do_target_chdir __P((const char *dir, int flag));
|
|
static const char* concat_paths __P((const char *prefix, const char *suffix));
|
|
int target_test(const char *test, const char *path);
|
|
|
|
|
|
/* get name of current root device from kernel via sysctl. */
|
|
const char*
|
|
getroot()
|
|
{
|
|
int mib[2];
|
|
static char rootstr[STRSIZE];
|
|
size_t varlen;
|
|
|
|
mib[0] = CTL_KERN;
|
|
mib[1] = KERN_ROOT_DEVICE;
|
|
varlen = sizeof(rootstr);
|
|
if (sysctl(mib, 2, rootstr, &varlen, NULL, 0) < 0)
|
|
return (NULL);
|
|
|
|
#ifdef DEBUG
|
|
printf("getroot(): sysctl returns %s\n", rootstr);
|
|
#endif
|
|
return (rootstr);
|
|
}
|
|
|
|
/*
|
|
* Is the root we're running from the same as the root which the
|
|
* user has selected to install/upgrade?
|
|
* FIXME -- only checks root device, not booted partition.
|
|
* disklabel-editing code assumes that partition 'a' is always root.
|
|
*/
|
|
int target_already_root()
|
|
{
|
|
register int result;
|
|
|
|
result = is_active_rootpart(diskdev);
|
|
return(result);
|
|
}
|
|
|
|
|
|
/* Is this partname (e.g., "sd0a") mounted as root? */
|
|
int is_active_rootpart(const char *partname)
|
|
{
|
|
static const char *rootstr = 0;
|
|
int result;
|
|
|
|
if (rootstr == 0)
|
|
rootstr = getroot();
|
|
|
|
result = (strcmp(partname, rootstr) == 0);
|
|
#ifdef DEBUG
|
|
printf("is_active_rootpart: root = %s, query=%s, answer=%d\n",
|
|
rootstr, partname, result);
|
|
#endif
|
|
return(result);
|
|
}
|
|
|
|
/*
|
|
* 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 /mnt and we need to prefix installed pathnames with /mnt.
|
|
* 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 instllal target disk.
|
|
*/
|
|
return(target_already_root() ? "" : "/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.
|
|
*/
|
|
static const char*
|
|
concat_paths(const char* prefix, const char *suffix)
|
|
{
|
|
static char realpath[STRSIZE];
|
|
|
|
/* 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(realpath, STRSIZE, "%s%s", prefix, suffix);
|
|
else
|
|
snprintf(realpath, STRSIZE, "%s/%s", prefix, suffix);
|
|
return realpath;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* 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 "/mnt" or possibly just "". */
|
|
static void
|
|
make_prefixed_dir(const char *prefix, const char *path)
|
|
{
|
|
run_prog_or_continue("/bin/mkdir -p %s", concat_paths(prefix, path));
|
|
}
|
|
|
|
|
|
|
|
/* Make a directory with a pathname relative to the insatllation target. */
|
|
void
|
|
make_target_dir(const char *path)
|
|
{
|
|
make_prefixed_dir(target_prefix(), path);
|
|
}
|
|
|
|
|
|
/* Make a directory with a pathname in the currently-mounted root. */
|
|
void
|
|
make_ramdisk_dir(const char *path)
|
|
{
|
|
make_prefixed_dir(path, "");
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* Append |string| to the filename |path|, where |path| is
|
|
* relative to the root of the install target.
|
|
* for example,
|
|
* echo_to_target_file( "Newbie.NetBSD.ORG", "/etc/myname");
|
|
* would set the default hostname at the next reboot of the installed-on disk.
|
|
*/
|
|
void
|
|
append_to_target_file(const char *path, const char *string)
|
|
{
|
|
run_prog_or_die("echo %s >> %s", string, target_expand(path));
|
|
}
|
|
|
|
/*
|
|
* As append_to_target_file, but with ftrunc semantics.
|
|
*/
|
|
void
|
|
echo_to_target_file(const char *path, const char *string)
|
|
{
|
|
trunc_target_file(path);
|
|
append_to_target_file(path, string);
|
|
}
|
|
|
|
void
|
|
sprintf_to_target_file(const char *path, const char *format, ...)
|
|
{
|
|
char lines[STRSIZE];
|
|
va_list ap;
|
|
|
|
trunc_target_file(path);
|
|
|
|
va_start(format, ap);
|
|
vsnprintf(lines, STRSIZE, format, ap);
|
|
va_end(ap);
|
|
|
|
append_to_target_file(path, lines);
|
|
}
|
|
|
|
|
|
void
|
|
trunc_target_file(const char *path)
|
|
{
|
|
run_prog_or_die("cat < /dev/null > %s", target_expand(path));
|
|
}
|
|
|
|
static int do_target_chdir(const char *dir, int must_succeed)
|
|
{
|
|
const char *tgt_dir;
|
|
int error = 0;
|
|
|
|
tgt_dir = target_expand(dir);
|
|
|
|
#ifndef DEBUG
|
|
/* chdir returns -1 on error and sets errno. */
|
|
if (chdir(tgt_dir) < 0) {
|
|
error = errno;
|
|
}
|
|
if (error && must_succeed) {
|
|
endwin();
|
|
fprintf(stderr, msg_string(MSG_realdir),
|
|
target_prefix(), strerror(error));
|
|
exit(1);
|
|
}
|
|
return (error);
|
|
#else
|
|
printf("target_chdir (%s)\n", tgt_dir);
|
|
return (0);
|
|
#endif
|
|
}
|
|
|
|
void target_chdir_or_die(const char *dir)
|
|
{
|
|
(void) do_target_chdir(dir, 1);
|
|
}
|
|
|
|
int target_chdir(const char *dir)
|
|
{
|
|
return(do_target_chdir(dir, 0));
|
|
}
|
|
|
|
/*
|
|
* 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()) {
|
|
const char *realpath = target_expand(filename);
|
|
run_prog ("/bin/cp %s %s", filename, realpath);
|
|
}
|
|
}
|
|
|
|
|
|
/* 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];
|
|
|
|
strncpy(realfrom, target_expand(frompath), STRSIZE);
|
|
strncpy(realto, target_expand(topath), STRSIZE);
|
|
|
|
run_prog_or_die("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)
|
|
{
|
|
char realfrom[STRSIZE];
|
|
char realto[STRSIZE];
|
|
|
|
strncpy(realfrom, target_expand(frompath), STRSIZE);
|
|
strncpy(realto, target_expand(topath), STRSIZE);
|
|
|
|
return (run_prog("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 moutpoint in the install target.
|
|
* NB: does not prefix mount-from, which probably breaks nullfs mounts.
|
|
*/
|
|
int target_mount(const char *fstype, const char *from, const char *on)
|
|
{
|
|
int error;
|
|
const char *realmount = target_expand(on);
|
|
|
|
error = run_prog("/sbin/mount %s %s %s", fstype, from, realmount);
|
|
return (error);
|
|
}
|
|
|
|
|
|
int target_collect_file(int kind, char **buffer, char *name)
|
|
{
|
|
register const char *realname =target_expand(name);
|
|
|
|
#ifdef DEBUG
|
|
printf("collect real name %s\n", realname);
|
|
#endif
|
|
return collect(kind, buffer, realname);
|
|
}
|
|
|
|
/*
|
|
* Verify a pathname already exists in the target root filesystem,
|
|
* by running test "testflag" on the expanded target pathname.
|
|
*/
|
|
|
|
int target_test(const char *test, const char *path)
|
|
{
|
|
const char *realpath = target_expand(path);
|
|
register int result;
|
|
|
|
result = run_prog ("test %s %s", test, realpath);
|
|
|
|
#if defined(DEBUG)
|
|
printf("target_test(%s %s) returning %d\n",
|
|
test, realpath, 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_verify_dir(const char *path)
|
|
{
|
|
return target_test("-d", 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_verify_file(const char *path)
|
|
{
|
|
return target_test("-f", path);
|
|
}
|