xref: /src/distrib/miniroot/install.sub

#!/bin/sh
#	$NetBSD: install.sub,v 1.57 2020/12/05 18:52:06 tsutsui Exp $
#
# Copyright (c) 1996 The NetBSD Foundation, Inc.
# All rights reserved.
#
# This code is derived from software contributed to The NetBSD Foundation
# by Jason R. Thorpe.
#
# 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.
#
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
#

#	NetBSD installation/upgrade script - common subroutines.

ROOTDISK=""				# filled in below
MACHINE=				# filled by distrib/miniroot/list
export MACHINE
VERSION=100				# updated by distrib/miniroot/list
export VERSION
RELEASE=10.0				# updated by distrib/miniroot/list
export RELEASE

ALLSETS="base comp etc games man misc modules rescue text"	# default install sets
UPGRSETS="base comp games man misc text"		# default upgrade sets
THESETS=						# one of the above

local_sets_dir=""			# Path searched for sets by install_sets
					# on the local filesystems

# decide upon an editor
if [ -z "$EDITOR" ]; then
	if [ -x /usr/bin/vi ]; then
		EDITOR=vi
	else
		EDITOR=ed
	fi
fi

getresp() {
	read resp
	if [ -z "$resp" ]; then
		resp=$1
	fi
}

isin() {
# test the first argument against the remaining ones, return succes on a match
	_a=$1; shift
	while [ $# != 0 ]; do
		if [ "$_a" = "$1" ]; then return 0; fi
		shift
	done
	return 1
}

rmel() {
# remove first argument from list formed by the remaining arguments
	local	_a

	_a=$1; shift
	while [ $# != 0 ]; do
		if [ "$_a" != "$1" ]; then
			echo "$1";
		fi
		shift
	done
}

cutword () {
# read a line of data, return Nth element.
	local _a
	local _n
	local _oifs

	# optional field separator
	_oifs="$IFS"
	case "$1" in
		-t?*) IFS=${1#-t}; shift;;
	esac

	_n=$1
	read _a; set -- $_a
	IFS="$_oifs"
	if [ "$1" = "" ]; then return; fi
	eval echo \$$_n
}

cutlast () {
# read a line of data, return last element. Equiv. of awk '{print $NF}'.
	local _a
	local _oifs

	# optional field separator
	_oifs="$IFS"
	case "$1" in
		-t?*) IFS=${1#-t}; shift;;
	esac

	read _a; set -- $_a
	IFS="$_oifs"
	if [ "$1" = "" ]; then return; fi
	eval echo '"${'"$#"'}"'
}

firstchar () {
# return first character of argument
	local _a
	_a=$1
	while [ ${#_a} != 1 ]; do
		_a=${_a%?}
	done
	echo $_a
}

basename () {
	local _oifs
	if [ "$1" = "" ]; then return; fi
	_oifs="$IFS"
	IFS="/"
	set -- $1
	IFS="$_oifs"
	eval echo '"${'"$#"'}"'
}

dir_has_sets() {
	# return true when the directory $1 contains a set for $2...$n
	local _dir
	local _file

	_dir=$1; shift
	for _file in $*
	do
		if [ -f $_dir/${_file}.tar.gz ]; then
			return 0
		fi
		# Try for stupid msdos convention
		if [ -f $_dir/${_file}.tgz ]; then
			return 0
		fi
		# Try for uncompressed files
		if [ -f $_dir/${_file}.tar ]; then
			return 0
		fi
		# Try for split files
		if [ -f $_dir/${_file}${VERSION}.aa ]; then
			return 0
		fi
	done
	return 1
}

twiddle() {
# spin the propeller so we don't get bored
	while : ; do  
		sleep 1; echo -n "/";
		sleep 1; echo -n "-";
		sleep 1; echo -n "\\";
		sleep 1; echo -n "|";
	done > /dev/tty & echo $!
}

get_localdir() {
	# $1 is relative mountpoint
	local _mp
	local _dir

	_mp=$1
	_dir=
	while : ; do
	    if [ -n "$_mp" ]; then
		cat << __get_localdir_1
Note: your filesystems are mounted under the temporary mount point \"$_mp\".
The pathname you are requested to enter below should NOT include the \"$_mp\"
prefix.
__get_localdir_1
	    fi
	    echo -n "Enter the pathname where the sets are stored [$_dir] "
	    getresp "$_dir"
	    _dir=$resp

	    # Allow break-out with empty response
	    if [ -z "$_dir" ]; then
		echo -n "Are you sure you don't want to set the pathname? [n] "
		getresp "n"
		case "$resp" in
			y*|Y*)
				break
				;;
			*)
				continue
				;;
		esac
	    fi

	    if dir_has_sets "$_mp/$_dir" $THESETS
	    then
		local_sets_dir="$_mp/$_dir"
		break
	    else
		cat << __get_localdir_2
The directory \"$_mp/$_dir\" does not exist, or does not hold any of the
upgrade sets.
__get_localdir_2
		echo -n "Re-enter pathname? [y] "
		getresp "y"
		case "$resp" in
			y*|Y*)
				;;
			*)
				local_sets_dir=""
				break
				;;
		esac
	    fi
	done
}

getrootdisk() {
	cat << \__getrootdisk_1

The installation program needs to know which disk to consider
the root disk.  Note the unit number may be different than
the unit number you used in the standalone installation
program.

Available disks are:

__getrootdisk_1
	_DKDEVS=$(md_get_diskdevs)
	echo	"$_DKDEVS"
	echo	""
	echo -n	"Which disk is the root disk? "
	getresp ""
	if isin $resp $_DKDEVS ; then
		ROOTDISK="$resp"
	else
		echo ""
		echo "The disk $resp does not exist."
		ROOTDISK=""
	fi
}

labelmoredisks() {
	cat << \__labelmoredisks_1

You may label the following disks:

__labelmoredisks_1
	echo "$_DKDEVS"
	echo	""
	echo -n	"Label which disk? [done] "
	getresp "done"
	case "$resp" in
		"done")
			;;

		*)
			if isin $resp $_DKDEVS ; then
				md_labeldisk $resp
			else
				echo ""
				echo "The disk $resp does not exist."
			fi
			;;
	esac
}

addhostent() {
	# $1 - IP address
	# $2 - symbolic name

	local fqdn

	# Create an entry in the hosts table.  If no host table
	# exists, create one.  If the IP address already exists,
	# replace its entry.
	if [ ! -f /tmp/hosts ]; then
		echo "127.0.0.1 localhost" > /tmp/hosts
	fi

	sed "/^$1 /d" < /tmp/hosts > /tmp/hosts.new
	mv /tmp/hosts.new /tmp/hosts

	if [ -n "${FQDN}" ]; then
		fqdn=$2.$FQDN
	fi
	echo "$1 $2 $fqdn" >> /tmp/hosts
}

addifconfig() {
	# $1 - interface name
	# $2 - interface symbolic name
	# $3 - interface IP address
	# $4 - interface netmask
	# $5 - (optional) interface link-layer medium, preceded by "media ", else ""
	# $6 - (optional) interface link-layer directives
	local _m

	# Create a ifconfig.* file for the interface.
	echo "inet $2 netmask $4 $5 $6" > /tmp/ifconfig.$1

	addhostent $3 $2
}

configurenetwork() {
	local _ifsdone
	local _ifs

#	_IFS=$(md_get_ifdevs)
	_IFS=$(ifconfig -l | sed '
		s/lo0//
		s/ppp[0-9]//g
		s/sl[0-9]//g
		s/tun[0-9]//g')

	_ifsdone=""
	resp=""		# force at least one iteration
	while [ "${resp}" != "done" ]; do
	cat << \__configurenetwork_1

You may configure the following network interfaces (the interfaces
marked with [X] have been successfully configured):

__configurenetwork_1

		for _ifs in $_IFS; do
			if isin $_ifs $_ifsdone ; then
				echo -n "[X] "
			else
				echo -n "    "
			fi
			echo $_ifs
		done
		echo	""
		echo -n	"Configure which interface? [done] "
		getresp "done"
		case "$resp" in
		"done")
			;;
		*)
			_ifs=$resp
			if isin $_ifs $_IFS ; then
				if configure_ifs $_ifs ; then
					_ifsdone="$_ifs $_ifsdone"
				fi
			else
				echo "Invalid response: \"$resp\" is not in list"
			fi
			;;
		esac
	done
}

configure_ifs() {

	local _up
	local _interface_name
	local _interface_ip
	local _interface_mask
	local _interface_symname
	local _interface_extra
	local _interface_mediumtype
	local _interface_supported_media
	local _m
	local _t

	_interface_name=$1
	_up=DOWN
	if isin $_interface_name $(ifconfig -l -u); then
		_up=UP
	fi

	_interface_supported_media=$(ifconfig -m $_interface_name | sed -n '
		/^[ 	]*media autoselect/d
		4,$s/[ 	]*media //p')

	# get current "media" "ip" and "netmask" ("broadcast")
	_t=$(ifconfig $_interface_name | sed -n '
		s/^[ 	]*media: [^ 	]* \([^ ][^ ]*\).*/\1/p')

	if [ "$_t" != "manual" ] && [ "$_t" != "media:" ] && [ "$_t" != "autoselect" ];
	then
		_interface_mediumtype=$1
	fi

	set -- $(ifconfig $_interface_name | sed -n '
		/^[ 	]*inet/{
		s/inet//
		s/--> [0-9.][0-9.]*//
		s/netmask//
		s/broadcast//
		p;}')

	_interface_ip=$1
	_interface_mask=$2

	# Get IP address
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "IP address? [$_interface_ip] "
		getresp "$_interface_ip"
		_interface_ip=$resp
	done

	# Get symbolic name
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Symbolic (host) name? "
		getresp ""
		_interface_symname=$resp
	done

	# Get netmask
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Netmask? [$_interface_mask] "
		getresp "$_interface_mask"
		_interface_mask=$resp
	done

	echo "Your network interface might require explicit selection"
	echo "of the type of network medium attached. Supported media:"
	echo "$_interface_supported_media"
	echo -n "Additional media type arguments (none)? [$_interface_mediumtype] "
	getresp "$_interface_mediumtype"
	_m=""
	if [ "${resp:-none}" != "none" ]; then
		_interface_mediumtype=$resp
		_m="media ${resp}"
	fi


	echo "Your network interface might require additional link-layer"
	echo "directives (like 'link0'). If this is the case you can enter"
	echo "these at the next prompt."
	echo ""
	echo -n "Additional link-layer arguments (none)? [$_interface_extra] "
	getresp "$_interface_extra"
	if [ "${resp:-none}" != "none" ]; then
		_interface_extra=$resp
	fi

	# Configure the interface.  If it
	# succeeds, add it to the permanent
	# network configuration info.
	if [ $_up != "UP" ]; then
		ifconfig ${_interface_name} down
		if ifconfig ${_interface_name} inet \
		    ${_interface_ip} \
		    netmask ${_interface_mask} \
		    ${_interface_extra} ${_m} up ; then
			addifconfig \
			    "${_interface_name}" \
			    "${_interface_symname}" \
			    "${_interface_ip}" \
			    "${_interface_mask}" \
			    "${_m}" \
			    "${_interface_extra}"
			return 0
		fi
	else
		echo "Interface ${_interface_name} is already active."
		echo "Just saving configuration on new root filesystem."
		addifconfig \
		    "${_interface_name}" \
		    "${_interface_symname}" \
		    "${_interface_ip}" \
		    "${_interface_mask}" \
		    "${_m}" \
		    "${_interface_extra}"
	fi
	return 1
}

# Much of this is gratuitously stolen from /etc/rc.d/network.
enable_network() {

	# Set up the hostname.
	if [ -f /mnt/etc/myname ]; then
		hostname=$(cat /mnt/etc/myname)
	elif [ -f /mnt/etc/rc.conf ];then
		hostname=$(sh -c '. /mnt/etc/rc.conf ; echo $hostname')
	else
		echo "ERROR: no /etc/myname!"
		return 1
	fi
	if [ -z "$hostname" ];then
		echo "ERROR: hostname not set in /etc/myname or /etc/rc.conf!"
		return 1
	fi
	hostname $hostname

	# configure all the interfaces which we know about.
if [ -f /mnt/etc/rc.conf ]; then
(
	# assume network interface configuration style 1.2D and up
	if [ -f /mnt/etc/defaults/rc.conf ]; then
		. /mnt/etc/defaults/rc.conf
	fi
	. /mnt/etc/rc.conf

	if [ "$net_interfaces" != NO ]; then
		if [ "$auto_ifconfig" = YES ]; then
			tmp="$(ifconfig -l)"
		else
			tmp="$net_interfaces"
		fi
		echo -n "configuring network interfaces:"
		for i in $tmp; do
			eval $(echo 'args=$ifconfig_'$i)
			if [ -n "$args" ]; then
				echo -n " $i"
				ifconfig $i $args
			elif [ -f /mnt/etc/ifconfig.$i ]; then
				echo -n " $i"
				(while read args; do
					ifconfig $i $args
				done) < /mnt/etc/ifconfig.$i
			elif [ "$auto_ifconfig" != YES ]; then
				echo
				echo -n "/mnt/etc/ifconfig.$i missing"
				echo -n "& ifconfig_$i not set"
				echo "; interface $i can't be configured"
			fi
		done
		echo "."
	fi
)
else
(
	tmp="$IFS"
	IFS="$IFS."
	set -- $(echo /mnt/etc/hostname*)
	IFS=$tmp
	unset tmp

	while [ $# -ge 2 ] ; do
		shift		# get rid of "hostname"
		(
			read af name mask bcaddr extras
			read dt dtaddr

			if [ -z "$name" ]; then
		    echo "/etc/hostname.$1: invalid network configuration file"
				exit
			fi

			cmd="ifconfig $1 $af $name "
			if [ "${dt}" = "dest" ]; then cmd="$cmd $dtaddr"; fi
			if [ -n "$mask" ]; then cmd="$cmd netmask $mask"; fi
			if [ "${bcaddr:-NONE}" != "NONE" ]; then
				cmd="$cmd broadcast $bcaddr";
			fi
			cmd="$cmd $extras"

			$cmd
		) < /mnt/etc/hostname.$1
		shift
	done
)
fi

	# set the address for the loopback interface
	ifconfig lo0 inet localhost

	# use loopback, not the wire
	route add $hostname localhost

	# /etc/mygate, if it exists, contains the name of my gateway host
	# that name must be in /etc/hosts.
	if [ -f /mnt/etc/mygate ]; then
		route delete default > /dev/null 2>&1
		route add default $(cat /mnt/etc/mygate)
	fi

	# enable the resolver, if appropriate.
	if [ -f /mnt/etc/resolv.conf ]; then
		_resolver_enabled="TRUE"
		cp /mnt/etc/resolv.conf /tmp/resolv.conf.shadow
	fi

	# Display results...
	echo	"Network interface configuration:"
	ifconfig -a

	echo	""

	if [ "${_resolver_enabled:-FALSE}" = "TRUE" ]; then
		netstat -r
		echo	""
		echo	"Resolver enabled."
	else
		netstat -rn
		echo	""
		echo	"Resolver not enabled."
	fi

	return 0
}

install_ftp() {
	local	_f
	local	_sets
	local	_next

	# Build a script to extract valid files from a list
	# of filenames on stdin.
	# XXX : Can we use this on more places? Leo.

	echo "#!/bin/sh" > /tmp/fname_filter.sh
	echo "while read line; do"	>> /tmp/fname_filter.sh
	echo "    case \$line in"	>> /tmp/fname_filter.sh
	for _f in $THESETS; do
		echo "    $_f.tar.gz|$_f.tgz|$_f.tar|$_f.${VERSION}.aa)" \
					>> /tmp/fname_filter.sh
		echo '        echo -n "$line ";;' \
					>> /tmp/fname_filter.sh
	done
	echo "        *) ;;"		>> /tmp/fname_filter.sh
	echo "    esac"			>> /tmp/fname_filter.sh
	echo "done"			>> /tmp/fname_filter.sh

	# Get several parameters from the user, and create
	# a shell script that directs the appropriate
	# commands into ftp.
	cat << \__install_ftp_1

This is an automated ftp-based installation process.  You will be asked
several questions.  The correct set of commands will be placed in a script
that will be fed to ftp(1).

__install_ftp_1
	# Get server IP address
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Server IP? [${_ftp_server_ip}] "
		getresp "${_ftp_server_ip}"
		_ftp_server_ip=$resp
	done

	# Get login name
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Login? [${_ftp_server_login}] "
		getresp "${_ftp_server_login}"
		_ftp_server_login=$resp 
	done

	# Get password
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Password? "
		stty -echo
		getresp ""
		echo ""
		stty echo
		_ftp_server_password=$resp
	done

	cat << \__install_ftp_2

You will be asked to enter the name of the directory that contains the
installation sets. When you enter a '?' you will see a listing of the
current directory on the server.
__install_ftp_2
	_sets=""
	while [ -z "$_sets" ]
	do
		resp=""		# force one iteration
		while [ -z "${resp}" ]; do
			echo -n "Server directory? [${_ftp_server_dir}] "
		    getresp "${_ftp_server_dir}"
		    if [ -z "$resp" ] && [ -z "$_ftp_server_dir" ]; then
			resp=""
		    fi
		done
		if [ $resp != '?' ]; then
			_ftp_server_dir=$resp
		fi

		# Build the basics of an ftp-script...
		echo "#!/bin/sh" > /tmp/ftp-script.sh
		echo "cd /mnt" >> /tmp/ftp-script.sh
		echo "ftp -e -i -n $_ftp_server_ip << \__end_commands" >> \
		    /tmp/ftp-script.sh
		echo "user $_ftp_server_login $_ftp_server_password" >> \
		    /tmp/ftp-script.sh
		echo "bin" >> /tmp/ftp-script.sh
		echo "cd $_ftp_server_dir" >> /tmp/ftp-script.sh

		# Make a copy of this script that lists the directory
		# contents, and use that to determine the files to get.
		cat /tmp/ftp-script.sh	>  /tmp/ftp-dir.sh
		echo "nlist"		>> /tmp/ftp-dir.sh
		echo "quit"		>> /tmp/ftp-dir.sh
		echo "__end_commands"	>> /tmp/ftp-dir.sh

		if [ $resp = '?' ]; then
			sh /tmp/ftp-dir.sh
		else
			_sets=$(sh /tmp/ftp-dir.sh | sort -u | sh /tmp/fname_filter.sh)
		fi
	done
	rm -f /tmp/ftp-dir.sh /tmp/fname_filter.sh

	while : ; do
		echo "The following sets are available for extraction:"
		echo "(marked sets are already on the extraction list)"
		echo ""

		_next=""
		for _f in $_sets ; do
			if isin $_f $_setsdone; then
				echo -n "[X] "
				_next=""
			else
				echo -n "    "
				if [ -z "$_next" ]; then _next=$_f; fi
			fi
			echo $_f
		done
		echo ""

		# Get name of the file and add extraction command
		# to the ftp-script.
		if [ -z "$_next" ]; then resp=n; else resp=y; fi
		echo -n "Continue to add filenames [$resp]? "
		getresp "$resp"
		if [ "$resp" = "n" ]; then
			break
		fi

		echo -n "File name [$_next]? "
		getresp "$_next"
		if isin $resp $_sets; then
			echo "get $resp |\"pax -zr${verbose_flag}pe\"" >> \
					/tmp/ftp-script.sh
			_setsdone="$resp $_setsdone"
		else
			echo "You entered an invalid filename."
			echo ""
		fi
	done

	echo "quit" >> /tmp/ftp-script.sh
	echo "__end_commands" >> /tmp/ftp-script.sh

	sh /tmp/ftp-script.sh
	rm -f /tmp/ftp-script.sh
	echo "Extraction complete."
}

install_from_mounted_fs() {
	# $1 - directory containing installation sets
	local _filename
	local _sets
	local _next
	local _all
	local _f
	local _dirname

	_dirname=$1
	_sets=""

	if ! dir_has_sets ${_dirname} $THESETS
	then

		echo ""
		echo "The directory at the mount point, \"${_dirname}\", contains: "
		echo ""
		ls -F ${_dirname}
		echo ""
		echo    "Enter the subdirectory relative to the mountpoint, that"
		echo -n "contains the savesets: [try this directory] "
		getresp ""
		if [ -n "${resp}" ]; then
			_dirname=${_dirname}/$resp
		fi

		while ! dir_has_sets ${_dirname} $THESETS; do
			echo ""
			echo -n "There are no NetBSD install sets available in "
			echo "\"${_dirname}\"."
			echo "\"${_dirname}\" contains: "
			echo ""
			ls -F ${_dirname}
			echo ""
			echo -n "Enter subdirectory: [try other install media] "
			getresp ""
			if [ -z "${resp}" ]; then
				return
			fi
			if [ ! -d ${_dirname}/${resp} ]; then
				echo "\"${resp}\" is no directory; try again."
			else
				_dirname=${_dirname}/$resp
			fi
		done
	fi

	for _f in $THESETS ; do
		if [ -f ${_dirname}/${_f}.tar.gz ]; then
			_sets="$_sets ${_f}.tar.gz"
		elif [ -f ${_dirname}/${_f}.tgz ]; then
			_sets="$_sets ${_f}.tgz"
		elif [ -f ${_dirname}/${_f}.tar ]; then
			_sets="$_sets ${_f}.tar"
		elif [ -f ${_dirname}/${_f}${VERSION}.aa ]; then
			_sets="$_sets ${_f}${VERSION}"
		fi
	done

	while : ; do
		echo "The following sets are available for extraction:"
		echo "(marked sets have already been extracted)"
		echo ""

		_next=""
		_all=""
		for _f in $_sets ; do
			if isin $_f $_setsdone; then
				echo -n "[X] "
				_next=""
			else
				echo -n "    "
				if [ -z "$_next" ]; then
					_next=$_f;
				fi
				_all="$_all $_f"
			fi
			echo $_f
		done
		echo ""

		# Get the name of the file.
		if [ -z "$_next" ]; then
			resp=n
		else
			resp=y
		fi
		echo -n "Continue extraction [$resp]?"
		getresp "$resp"
		if [ "$resp" = "n" ]; then
			break
		fi

		echo -n "File name(s) (or "all") [$_next]? "
		getresp "$_next"
		if [ "x$resp" = xall ]; then
			resp="$_all"
		fi

		for _f in $resp; do
			_filename="/${_dirname}/$_f"

			# Ensure file exists
			if [ ! -f $_filename ]; then
				if [ -f ${_filename}.aa ]; then
					_filename=${_filename}.\?\?
				else
			 echo "File $_filename does not exist.  Check to make"
			 echo "sure you entered the information properly."
			 continue 2
				fi
			fi

			# Extract file
			echo "Extracting the $_f set:"
			case "$_filename" in
			*.tar)
				(cd /mnt; pax -r${verbose_flag}pe < $_filename)
				;;
			*)
				cat $_filename | \
					(cd /mnt; pax -zr${verbose_flag}pe)
				;;
			esac
			echo "Extraction complete."
			_setsdone="$_f $_setsdone"
		done

	done
}

install_cdrom() {
	local _drive
	local _partition_range
	local _partition
	local _fstype
	local _directory

	# Get the cdrom device info
	cat << \__install_cdrom_1

The following CD-ROM devices are installed on your system; please select
the CD-ROM device containing the partition with the installation sets:

__install_cdrom_1
	_CDDEVS=$(md_get_cddevs)
	echo    "$_CDDEVS"
	echo	""
	echo -n	"Which is the CD-ROM with the installation media? [abort] "
	getresp "abort"
	case "$resp" in
		abort)
			echo "Aborting."
			return
			;;

		*)
			if isin $resp $_CDDEVS ; then
				_drive=$resp
			else
				echo ""
				echo "The CD-ROM $resp does not exist."
				echo "Aborting."
				return
			fi
			;;
	esac

	# Get partition
	_partition_range=$(md_get_partition_range)
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Partition? [a] "
		getresp "a"
		case "$resp" in
			$_partition_range)
				_partition=$resp
				;;

			*)
				echo "Invalid response: $resp"
				resp=""		# force loop to repeat
				;;
		esac
	done

	# Ask for filesystem type
	cat << \__install_cdrom_2

There are two CD-ROM filesystem types currently supported by this program:
	1) ISO-9660 (cd9660)
	2) Berkeley Fast Filesystem (ffs)

__install_cdrom_2
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Which filesystem type? [cd9660] "
		getresp "cd9660"
		case "$resp" in
			cd9660|ffs)
				_fstype=$resp
				;;

			*)
				echo "Invalid response: $resp"
				resp=""		# force loop to repeat
				;;
		esac
	done

	# Mount the CD-ROM
	if ! mount -t ${_fstype} -o ro \
	    /dev/${_drive}${_partition} /mnt2 ; then
		echo "Cannot mount CD-ROM drive.  Aborting."
		return
	fi

	install_from_mounted_fs /mnt2
	umount -f /mnt2 > /dev/null 2>&1
}

mount_a_disk() {
	# Mount a disk on /mnt2. The set of disk devices to choose from
	# is $_DKDEVS.
	# returns 0 on failure.

	local _drive
	local _partition_range
	local _partition
	local _fstype
	local _fsopts
	local _directory
	local _md_fstype
	local _md_fsopts

	getresp "abort"
	case "$resp" in
		abort)
			echo "Aborting."
			return 0
			;;

		*)
			if isin $resp $_DKDEVS ; then
				_drive=$resp
			else
				echo ""
				echo "The disk $resp does not exist."
				echo "Aborting."
				return 0
			fi
			;;
	esac

	# Get partition
	_partition_range=$(md_get_partition_range)
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Partition? [d] "
		getresp "d"
		case "$resp" in
			$_partition_range)
				_partition=$resp
				;;

			*)
				echo "Invalid response: $resp"
				resp=""		# force loop to repeat
				;;
		esac
	done

	# Ask for filesystem type
	cat << \__mount_a_disk_2

The following filesystem types are supported:
	1) ffs
	2) cd9660
__mount_a_disk_2
	_md_fstype=$(md_native_fstype)
	_md_fsopts=$(md_native_fsopts)
	if [ -n "$_md_fstype" ]; then
		echo "	3) $_md_fstype"
	else
		_md_fstype="_undefined_"
	fi
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Which filesystem type? [ffs] "
		getresp "ffs"
		case "$resp" in
			ffs|cd9660)
				_fstype=$resp
				_fsopts="ro"
				;;
			$_md_fstype)
				_fstype=$resp
				_fsopts=$_md_fsopts
				;;
			*)
				echo "Invalid response: $resp"
				resp=""		# force loop to repeat
				;;
		esac
	done

	# Mount the disk
	if ! mount -t ${_fstype} -o $_fsopts \
	    /dev/${_drive}${_partition} /mnt2 ; then
		echo "Cannot mount disk.  Aborting."
		return 0
	fi
	return 1
}

install_disk() {
	local _directory

	cat << \__install_disk_1

Ok, lets install from a disk.  The file-system the install sets on may
already mounted, or we might have to mount the filesystem to get to it.

__install_disk_1

	echo -n "Is the file-system with the install sets already mounted? [n] "
	getresp "n"
	case $resp in
	y*|Y*)
		echo "What mount point are the sets located in? [] "
		getresp ""
		if [ -d "$resp" ]; then
			install_from_mounted_fs $resp
		else
			echo "$resp: Not a directory, aborting..."
		fi
		return
		;;
	*)
		;;
	esac

	cat << \__install_disk_2

The following disk devices are installed on your system; please select
the disk device containing the partition with the installation sets:

__install_disk_2
	_DKDEVS=$(md_get_diskdevs)
	echo    "$_DKDEVS"
	echo	""
	echo -n	"Which is the disk with the installation sets? [abort] "

	if mount_a_disk ; then
		return
	fi

	install_from_mounted_fs /mnt2
	umount -f /mnt2 > /dev/null 2>&1
}

install_nfs() {
	# Get the IP address of the server
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Server IP address? [${_nfs_server_ip}] "
		getresp "${_nfs_server_ip}"
	done
	_nfs_server_ip=$resp

	# Get server path to mount
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Filesystem on server to mount? [${_nfs_server_path}] "
		getresp "${_nfs_server_path}"
	done
	_nfs_server_path=$resp

	# Determine use of TCP
	echo -n "Use TCP transport (only works with capable NFS server)? [n] "
	getresp "n"
	case "$resp" in
		y*|Y*)
			_nfs_tcp="-T"
			;;

		*)
			echo -n "Use small NFS transfers (needed when server "
			echo "or client"
			echo -n "has a slow network card)? [n] "
			getresp "n"
			case "$resp" in
			y*|Y*)
				_nfs_tcp="-r 1024 -w 1024"
				;;

			*)
				_nfs_tcp=""
				;;
			esac
			;;
	esac

	# Mount the server
	mkdir /mnt2 > /dev/null 2>&1
	if ! mount_nfs $_nfs_tcp ${_nfs_server_ip}:${_nfs_server_path} \
	    /mnt2 ; then
		echo "Cannot mount NFS server.  Aborting."
		return
	fi

	install_from_mounted_fs /mnt2
	umount -f /mnt2 > /dev/null 2>&1
}

install_tape() {
	local _xcmd

	# Get the name of the tape from the user.
	cat << \__install_tape_1

The installation program needs to know which tape device to use.  Make
sure you use a "no rewind on close" device.

__install_tape_1
	_tape=$(basename $TAPE)
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Name of tape device? [${_tape}]"
		getresp "${_tape}"
	done
	_tape=$(basename $resp)
	TAPE="/dev/${_tape}"
	if [ ! -c $TAPE ]; then
		echo "$TAPE does not exist or is not a character special file."
		echo "Aborting."
		return
	fi
	export TAPE

	# Rewind the tape device
	echo -n "Rewinding tape..."
	if ! mt rewind ; then
		echo "$TAPE may not be attached to the system or may not be"
		echo "a tape device.  Aborting."
		return
	fi
	echo "done."

	# Get the file number
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "File number? "
		getresp ""
		case "$resp" in
			[1-9]*)
				_nskip=$(expr $resp - 1)
				;;

			*)
				echo "Invalid file number ${resp}."
				resp=""		# fore loop to repeat
				;;
		esac
	done

	# Skip to correct file.
	echo -n "Skipping to source file..."
	if [ "${_nskip}" != "0" ]; then
		if ! mt fsf $_nskip ; then
			echo "Could not skip $_nskip files.  Aborting."
			return
		fi
	fi
	echo "done."

	cat << \__install_tape_2

There are 2 different ways the file can be stored on tape:

	1) an image of a gzipped tar file
	2) a standard tar image

__install_tape_2
	resp=""		# force one iteration
	while [ -z "${resp}" ]; do
		echo -n "Which way is it? [1] "
		getresp "1"
		case "$resp" in
		1)
			_xcmd="pax -zr${verbose_flag}pe"
			;;

		2)
			_xcmd="pax -r${verbose_flag}pe"
			;;

		*)
			echo "Invalid response: $resp."
			resp=""		# force loop to repeat
			;;
		esac
		( cd /mnt; dd if=$TAPE | $_xcmd )
	done
	echo "Extraction complete."
}

get_timezone() {
	local _a
	local _zonepath

	#
	# If the zoneinfo is not on the installation medium or on the
	# installed filesystem, set TZ to GMT and return immediatly.
	#
	if [ ! -e /usr/share/zoneinfo ] && [ ! -e /mnt/usr/share/zoneinfo ]; then
		TZ=GMT
		return
	fi
	if [ ! -d /usr/share/zoneinfo ]; then
		_zonepath=/mnt
	else
		_zonepath=""
	fi
		
cat << \__get_timezone_1

Select a time zone for your location. Timezones are represented on the
system by a directory structure rooted in "/usr/share/zoneinfo". Most
timezones can be selected by entering a token like "MET" or "GMT-6".
Other zones are grouped by continent, with detailed zone information
separated by a slash ("/"), e.g. "US/Pacific".

To get a listing of what's available in /usr/share/zoneinfo, enter "?"
at the prompts below.

__get_timezone_1
	if [ -z "$TZ" ]; then
		TZ=$(ls -l /mnt/etc/localtime 2>/dev/null | cutlast)
		TZ=${TZ#/usr/share/zoneinfo/}
	fi
	while :; do
		echo -n	"What timezone are you in ['?' for list] [$TZ]? "
		getresp "$TZ"
		case "$resp" in
		"")
			echo "Timezone defaults to GMT"
			TZ="GMT"
			break;
			;;
		"?")
			ls ${_zonepath}/usr/share/zoneinfo
			;;
		*)
			_a=$resp
			while [ -d ${_zonepath}/usr/share/zoneinfo/$_a ]; do
				echo -n "There are several timezones available"
				echo " within zone '$_a'"
				echo -n "Select a sub-timezone ['?' for list]: "
				getresp ""
				case "$resp" in
				"?") ls ${_zonepath}/usr/share/zoneinfo/$_a ;;
				*)	_a=${_a}/${resp}
					if [ -f ${_zonepath}/usr/share/zoneinfo/$_a ]; then
						break;
					fi
					;;
				esac
			done
			if [ -f ${_zonepath}/usr/share/zoneinfo/$_a ]; then
				TZ="$_a"
				echo "You have selected timezone \"$_a\"".
				break 2
			fi
			echo "'/usr/share/zoneinfo/$_a' is not a valid timezone on this system."
			;;
		esac
	done
}

install_sets()
{
	local _yup
	_yup="FALSE"

	# Ask the user which media to load the distribution from.
	# Ask the user if they want verbose extraction.  They might not want
	# it on, eg, SPARC frame buffer console.
	cat << \__install_sets_1

It is now time to extract the installation sets onto the hard disk.
Make sure the sets are either on a local device (i.e. tape, CD-ROM) or on a
network server.

Would you like to see each file listed during extraction (verbose) mode?
On some console hardware, such as serial consoles and Sun frame buffers,
this can extend the total extraction time.
__install_sets_1
	echo -n "Use verbose listing for extractions? [y] "
	getresp "y"
	case "$resp" in
	y*|Y*)
		verbose_flag=v
		;;
	*)
		echo "Not using verbose listing."
		verbose_flag=""
		;;
	esac

	if [ -d ${Default_sets_dir:-/dev/null} ]; then
		if dir_has_sets $Default_sets_dir $THESETS; then
			local_sets_dir=$Default_sets_dir
		fi
	fi
	if [ -n "${local_sets_dir}" ]; then
		install_from_mounted_fs ${local_sets_dir}
		if [ -n "$_setsdone" ]; then
			_yup="TRUE"
		fi
	fi

	# Go on prodding for alternate locations
	resp=""		# force at least one iteration
	while [ -z "${resp}" ]; do
		# If _yup is not FALSE, it means that we extracted sets above.
		# If that's the case, bypass the menu the first time.
		if [ "${_yup}" = "FALSE" ]; then
			echo -n	"Install from (f)tp, (t)ape, (C)D-ROM, (N)FS"
			echo -n " or local (d)isk? "
			getresp ""
			case "$resp" in
			d*|D*)
				install_disk
				;;
			f*|F*)
				install_ftp
				;;
			t*|T*)
				install_tape
				;;
			c*|C*)
				install_cdrom
				;;
			n*|N*)
				install_nfs
				;;
			*)
				echo "Invalid response: $resp"
				resp=""
				;;
			esac
		else
			_yup="FALSE"	# So we'll ask next time
		fi

		# Give the user the opportunity to extract more sets. They
		# don't necessarily have to come from the same media.
		echo	""
		echo -n	"Extract more sets? [n] "
		getresp "n"
		case "$resp" in
		y*|Y*)
			# Force loop to repeat
			resp=""
			;;

		*)
			;;
		esac
	done
}

munge_fstab()
{
	local _fstab
	local _fstab_shadow
	local _dev
	local _mp
	local _fstype
	local _rest

	# Now that the 'real' fstab is configured, we munge it into a 'shadow'
	# fstab which we'll use for mounting and unmounting all of the target
	# filesystems relative to /mnt.  Mount all filesystems.
	_fstab=$1
	_fstab_shadow=$2
	( while read _dev _mp _fstype _rest; do
		# Skip comment lines
		case "$_dev" in
			\#*)	continue;;
			*)	;;
		esac
		# and some filesystem types (like there are swap,kernfs,...)
		case "$_fstype" in
			ffs|ufs|nfs)	;;
			*)	continue;;
		esac
		if [ "$_mp" = "/" ]; then
			echo $_dev /mnt $_fstype $_rest
		else
			echo $_dev /mnt$_mp $_fstype $_rest
		fi
	    done ) < $_fstab > $_fstab_shadow
}

mount_fs()
{
	# Must mount filesystems manually, one at a time, so we can make
	# sure the mount points exist.
	# $1 is a file in fstab format
	local _fstab

	_fstab=$1

	( while read line; do
		set -- $line
		_dev=$1
		_mp=$2
		_fstype=$3
		_opt=$4

		# If not the root filesystem, make sure the mount
		# point is present.
		if [ "$_mp" != "/mnt" ]; then
			mkdir -p $_mp
		fi

		# Mount the filesystem.  If the mount fails, exit
		# with an error condition to tell the outer
		# later to bail.
		if ! mount -v -t $_fstype -o async -o $_opt $_dev $_mp ; then
			# error message displated by mount
			exit 1
		fi
	done ) < $_fstab

	if [ "$?" != "0" ]; then
		cat << \__mount_filesystems_1

FATAL ERROR:  Cannot mount filesystems.  Double-check your configuration
and restart the installation process.
__mount_filesystems_1
		exit
	fi
}

unmount_fs()
{
	# Unmount all filesystems and check their integrity.
	# Usage: [-fast] <fstab file>
	local _fast
	local _fstab
	local _pid

	if [ "$1" = "-fast" ]; then
		_fast=1
		_fstab=$2
	else
		_fast=0
		_fstab=$1
	fi

	if ! [ -f "${_fstab}" ] || ! [ -s "${_fstab}" ]; then
		echo "fstab empty" > /dev/tty
		return
	fi

	if [ $_fast = 0 ]; then
		echo -n	"Syncing disks..."
		_pid=$(twiddle)
		sync; sleep 4; sync; sleep 2; sync; sleep 2
		kill $_pid
		echo	"done."
	fi

	(
		_devs=""
		_mps=""
		# maintain reverse order
		while read line; do
			set -- $line
			_devs="$1 ${_devs}"
			_mps="$2 ${_mps}"
		done
		echo -n "Umounting filesystems... "
		for _mp in ${_mps}; do
			echo -n "${_mp} "
			umount ${_mp}
		done
		echo "Done."

		if [ $_fast = 0 ]; then
			exit
		fi
		echo "Checking filesystem integrity..."
		for _dev in ${_devs}; do
			echo  "${_dev}"
			fsck -f ${_dev}
		done
		echo "Done."
	) < $_fstab
}

check_fs()
{
	# Check filesystem integrity.
	# $1 is a file in fstab format
	local _fstab

	_fstab=$1

	(
		_devs=""
		_mps=""
		while read line; do
			set -- $line
			_devs="$1 ${_devs}"
			_mps="$2 ${_mps}"
		done

		echo "Checking filesystem integrity..."
		for _dev in ${_devs}; do
			echo  "${_dev}"
			fsck -f ${_dev}
		done
		echo "Done."
	) < $_fstab
}

mi_mount_kernfs() {
	# Make sure kernfs is mounted.
	if [ ! -d /kern ] || [ ! -e /kern/msgbuf ]; then
		mkdir /kern > /dev/null 2>&1
		/sbin/mount_kernfs /kern /kern
	fi
}

mi_filter_msgbuf() {
	# Remove timestemps, sort.
	sed -e 's/^\[[0-9. ]*\] //' < /kern/msgbuf | sort -u
}

mi_filter_dmesg() {
	# Remove timestemps, sort.
	dmesg | awk '{ h=$0; gsub("^[[0-9. ]*] ", "", h); print h; }' \
	    | sort -u
}