#!/bin/sh
#	$OpenBSD: install.sub,v 1.186 2002/03/04 13:59:52 krw Exp $
#	$NetBSD: install.sub,v 1.5.2.8 1996/09/02 23:25:02 pk Exp $
#
# Copyright (c) 1997-2002 Todd Miller, Theo de Raadt, Ken Westerback
# 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 by Todd Miller and
#	Theo de Raadt
# 4. The name of the author may not be used to endorse or promote products
#    derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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 (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.
# 3. All advertising materials mentioning features or use of this software
#    must display the following acknowledgement:
#        This product includes software developed by the NetBSD
#        Foundation, Inc. and its contributors.
# 4. Neither the name of The NetBSD Foundation 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 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 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.
#

#	OpenBSD installation/upgrade script - common subroutines.

ROOTDISK=
VERSION=30
VERSION_MAJOR=$(( $VERSION / 10 ))
VERSION_MINOR=$(( $VERSION % 10 ))
export VERSION VERSION_MAJOR VERSION_MINOR

# extra "site" set can be provided by person doing install or
# upgrade. THESETS is set to ALLSETS for installs and UPGRSETS
# for upgrades.
ALLSETS="base etc misc comp man game xbase xshare xfont xserv site"
UPGRSETS="base misc comp man game xbase xshare xfont xserv site"
THESETS=

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

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

# Please don't use the 1 of n form below, good idea, wrong implementation!
# get a reponse with default[s]
getresp() {
	local _shell_aware=0
	local _no_shell=0

	# -s option means exit after a shell (caller is shell-aware)
	if [ "$1" = "-s" ]; then
		_shell_aware=1
		shift
	fi
	# -n option means don't try to run shell commands
	if [ "$1" = "-n" ]; then
		_no_shell=1
		shift
	fi

	set -o noglob
	valid="false"
	while [ "X$valid" = "Xfalse" ]; do
		read resp
		if [ ${_no_shell} -eq 1 ]; then
			test -z "$resp" && resp="$1"
		else
			case "$resp" in
				"")	resp="$1"
					;;
				!)	echo "Type 'exit' to return to install."
					sh
					test $_shell_aware -eq 0 && continue
					;;
				!*)
					eval ${resp#?}
					test $_shell_aware -eq 0 && continue
					;;
			esac
		fi
		if [ $# -gt 1 ]; then
			for i in $@; do
				if [ "X$resp" = "X$i" ]; then
					valid="true"
				fi
			done
		else
			valid="true"
		fi
		if [ "X$valid" = "Xfalse" ]; then
			echo "Try again: Enter one of [$@]"
		fi
	done
	set +o noglob
}

isin() {
# test the first argument against the remaining ones, return success on a match
	local	_a=$1

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

addel() {
# add first argument to list formed by the remaining arguments
# adds to the tail if the element does not already exist
	local	_a=$1 _seen=

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

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

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

cutword () {
# read lines on stdin, return Nth element of each line, like cut(1)
	local _a _n _oifs="$IFS"

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

	_n=$1
	while read _a; do
		set -- $_a
		test "$1" = "" && break
		eval echo \$$_n
	done
	IFS="$_oifs"
}

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

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

	read _a; set -- $_a
	IFS="$_oifs"
	if [ "$1" = "" ]; then return; fi
	while [ "$#" -gt 10 ]; do shift 10; done
	eval echo \$$#
}

firstchar () {
# return first character of argument
	local _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"
	while [ "$#" -gt 10 ]; do shift 10; done
	eval echo \$$#
}

isnumeric() {
	local _a=$1

	while [ ${#_a} != 0 ]; do
		case $_a in
			[0-9]*) ;;
			*)	echo 0; return;;
		esac
		_a=${_a#?}
	done
	echo 1; return
}

get_ifdevs() {
	# return available network devices
	/sbin/ifconfig -a | egrep -v '^([[:space:]]|(lo|enc|gre|ppp|sl|tun|bridge)[[:digit:]])' | cutword -t: 1
}

bsort() {
	local _l _a=$1

	if [ $# == 0 ]; then
		return
	fi

	if [ $# == 1 ]; then
		echo $1; return
	fi

	shift
	while [ $# != 0 ]; do
		local _b=$1
		if [[ "$_a" != "$_b" ]] ; then
			if [[ "$_a" > "$_b" ]] ; then
				_l="$_a $_l"; _a=$_b
			else
				_l="$_b $_l"
			fi
		fi
		shift
	done

	echo -n $_a

	# Prevent a trailing blank on the output, and thus a bad value
	# for cutlast or cutword, by outputting blanks only when $_l
	# has values to sort.

	if [[ "X$_l" != "X" ]] ; then
		echo -n " "
		bsort $_l
	fi
}

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

	shift
	for _file in $*
	do
		if [ -f $_dir/${_file}${VERSION}.tar.gz ]; then
			return 0
		fi
		# Try for stupid msdos convention
		if [ -f $_dir/${_file}${VERSION}.tgz ]; then
			return 0
		fi
		# Special check for kernel
		if [ $_file = "kernel" -a -f $_dir/bsd ]; then
			return 0
		fi
	done
	return 1
}

list_has_sets() {
	# return true when the list $1 contains a set, given dir $2 for $3...$n
	local _list=$1 _file

	shift
	for _file in $*
	do
		if isin ${_file}${VERSION}.tar.gz $_list; then
			return 0
		fi
		# Try for stupid msdos convention
		if isin ${_file}${VERSION}.tgz $_list; then
			return 0
		fi
		# Special check for kernel
		if test $_file = "kernel" && isin bsd $_list; then
			return 0
		fi
	done
	return 1
}

ftp_list_files() {
	# log in via ftp to host $1 as user $2 with password $3
	# and return a list of all files in the directory $4 on stdout
	local _host=$1 _user="$2" _pass="$3" _dir=$4

	shift; shift; shift; shift

	ftp ${_ftp_active} -V -n $_host  << __ptf
user "$_user" "$_pass"
cd $_dir
ls
quit
__ptf
}

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

	while : ; do
		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 << __EOT
The directory \"$local_sets_dir\" does not exist, or does not hold any of the
upgrade sets.
__EOT
			echo -n "Re-enter pathname? [y] "
			getresp "y"
			case "$resp" in
				y*|Y*)
					;;
				*)
					local_sets_dir=
					break
					;;
			esac
		fi
	done
}

getanotherdisk() {
	cat << __EOT

Now you can select another disk to initialize.  (Do not re-select a disk
you have already entered information for).  Available disks are:

__EOT
	_DKDEVS=`md_get_diskdevs`
	echo	"$_DKDEVS"
	echo
	echo -n	"Which one? [done] "
	getresp ""
	if [ "X${resp}" = "X" ]; then
		DISK=done
	elif [ "X${resp}" = "Xdone" ]; then
		DISK=done
	elif isin $resp $_DKDEVS ; then
		DISK="$resp"
	else
		echo
		echo "The disk $resp does not exist."
		DISK=
	fi
}

getrootdisk() {
	cat << __EOT

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
boot program (especially on a PC with multiple disk controllers).
Available disks are:

__EOT
	local _defdsk

	_DKDEVS=`md_get_diskdevs`
	_defdsk=`echo $_DKDEVS | cutlast`
	if [ "${_defdsk}" != "${_DKDEVS}" ]; then
		_defdsk=
	fi
	echo	"$_DKDEVS"
	echo
	echo -n "Which disk is the root disk? [${_defdsk}] "
	getresp "${_defdsk}"
	if isin $resp $_DKDEVS ; then
		ROOTDISK="$resp"
	else
		echo
		echo "The disk $resp does not exist."
		ROOTDISK=
	fi
}

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

	# Create an entry in the hosts file.  If an entry with the
	# same symbolic name already exists, delete it.

	sed "/ $2\$/d" < /tmp/hosts > /tmp/hosts.new
	mv /tmp/hosts.new /tmp/hosts

	echo "$1 $2" >> /tmp/hosts
}

addifconfig() {
	# $1 - interface name
	# $2 - interface symbolic name
	# $3 - interface IP address
	# $4 - interface netmask
	# $5 - (optional) interface media directives

	# Create a hostname.* file for the interface.
	if [ "$3" = "dhcp" ]; then
		echo "dhcp NONE NONE NONE $5" > /tmp/hostname.$1
		addhostent 127.0.0.1 $2
	else
		echo "inet $3 $4 NONE $5" > /tmp/hostname.$1
		addhostent $3 $2
	fi
}

configure_all_interfaces() {
	local _ifsdone= _ifs _ouranswer= _reprompt=1

	_IFS=`get_ifdevs`

	resp=
	while [ "X${resp}" != X"done" ]; do
		if [ $_reprompt = 1 ]; then
			cat << __EOT

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

__EOT

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

	done
}

configure_ifs() {
	local _up _if_name=$1 _if_ip _if_mask
	local _if_symname _if_extra _hostname
	local _dhcp_prompt

	set -- `ifconfig $_if_name | sed -n '
		1s/.*<UP,.*$/UP/p
		1s/.*<.*>*$/DOWN/p
		/media:/s/^.*$//
		/status:/s/^.*$//
		/inet/s/--> [0-9.][0-9.]*//
		/inet/s/netmask//
		/inet/s/broadcast//
		/inet/s/inet// p'`

	_up=$1
	_if_ip=$2
	_if_mask=$3

	if [ $_up = "UP" ]; then
		ifconfig $_if_name delete down
	fi

	if [ ! -x /sbin/dhclient ]; then
		echo "DHCP install not supported"
		echo
	else
		_dhcp_prompt=" (or 'dhcp')"
	fi

	# Get IP address
	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n "IP address${_dhcp_prompt} ? [$_if_ip] "
		getresp "$_if_ip"
		if [ ! -x /sbin/dhclient -a "X$resp" == "Xdhcp" ]; then
			resp=
		fi
		_if_ip=$resp
	done

	# Get symbolic name
	_hostname=`hostname`
	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n "Symbolic (host) name? [$_hostname] "
		getresp "$_hostname"
		_if_symname=$resp
	done

	# Get netmask
	if [ "$_if_ip" != "dhcp" ]; then
		resp=
		if [ "X${_if_mask}" = X"" ]; then
			_if_mask=255.255.255.0
		fi
		while [ "X${resp}" = X"" ]; do
			echo -n "Netmask ? [$_if_mask] "
			getresp "$_if_mask"
			_if_mask=$resp
		done
	fi

	if [ -n "`ifconfig -m ${_if_name} | sed -n '/media/p'`" ]; then
		echo "Your use of the network interface may require non-default"
		echo "media directives.  The default media is:"
		ifconfig -m ${_if_name} | sed -n '
			/supported/D
			/media:/p'
		echo "This is a list of supported media:"
		ifconfig -m ${_if_name} | sed -n '
			/media:/D
			s/^	//
			/media/p'
		echo "If the default is not satisfactory, and you wish to use another"
		echo "media, copy that line from above (e.g. \"media 100baseTX\")"
		echo -n "Media directives? [$_if_extra] "
		getresp "$_if_extra"
		if [ "X${resp}" != X"" ]; then
			_if_extra=$resp
		fi
	fi

	# Configure the interface.  If it
	# succeeds, add it to the permanent
	# network configuration info.
	if [ "$_if_ip" = "dhcp" ]; then
		ifconfig ${_if_name} down ${_if_extra}
cat > /etc/dhclient.conf << __EOT
initial-interval 1;
send host-name "$_hostname";
request subnet-mask, broadcast-address, routers,
	domain-name, domain-name-servers, host-name;
__EOT
		dhclient -1 ${_if_name}

		set -- `ifconfig $_if_name | sed -n '
			1s/.*<UP,.*$/UP/p
			1s/.*<.*>*$/DOWN/p
			/media:/s/^.*$//
			/status:/s/^.*$//
			/inet/s/--> [0-9.][0-9.]*//
			/inet/s/netmask//
			/inet/s/broadcast//
			/inet/s/inet// p'`

		if [ $1 = "UP" -a $2 = "0.0.0.0" ]; then
			echo "hostname-associated DHCP attempt for $_if_name failed..."
			ifconfig $_if_name delete down

			cat > /etc/dhclient.conf << __EOT
initial-interval 1;
request subnet-mask, broadcast-address, routers,
	domain-name, domain-name-servers, host-name;
__EOT
			dhclient -1 ${_if_name}
			set -- `ifconfig $_if_name | sed -n '
				1s/.*<UP,.*$/UP/p
				1s/.*<.*>*$/DOWN/p
				/media:/s/^.*$//
				/status:/s/^.*$//
				/inet/s/--> [0-9.][0-9.]*//
				/inet/s/netmask//
				/inet/s/broadcast//
				/inet/s/inet// p'`

			if [ $1 = "UP" -a $2 = "0.0.0.0" ]; then
				echo "free-roaming DHCP attempt for $_if_name failed."
				ifconfig $_if_name delete down
				return 1
			else
				echo "DHCP attempt for $_if_name successful."
				addifconfig ${_if_name} ${_if_symname} ${_if_ip}
				return 0
			fi
		else
			echo "DHCP configuration of $_if_name successful."
			addifconfig ${_if_name} ${_if_symname} ${_if_ip}
			return 0
		fi
	else
		ifconfig ${_if_name} down
		if ifconfig ${_if_name} inet \
			${_if_ip} \
			netmask ${_if_mask} ${_if_extra} up
			then
			addifconfig ${_if_name} ${_if_symname} ${_if_ip} ${_if_mask} "${_if_extra}"
			return 0
		fi
	fi
	return 1
}

# Returns true if $1 contains only alphanumerics
isalphanumeric() {
	local _n
	_n=$1
	while [ ${#_n} != 0 ]; do
		case $_n in
			[A-Za-z0-9]*)	;;
			*)		return 1;;
		esac
		_n=${_n#?}
	done
	return 0
}

# Much of this is gratuitously stolen from /etc/netstart.
enable_network() {
	# Check for required network related files
	for _netfile in hosts myname; do
		if [ ! -f /mnt/etc/${_netfile} ]; then
			echo "ERROR: no /mnt/etc/${_netfile}!"
			return 1
		fi
	done

	# Copy any required or optional files found
	for _netfile in hosts myname dhclient.conf resolv.conf resolv.conf.tail protocols services; do
		if [ -f /mnt/etc/${_netfile} ]; then
			cp /mnt/etc/${_netfile} /etc/${_netfile}
		fi
	done

	hostname=`cat /etc/myname`
	hostname $hostname

	_didnet=1

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

	# use loopback, not the wire
	route -n add -host $hostname localhost > /dev/null
	route -n add -net 127 127.0.0.1 -reject > /dev/null

	# configure all of the non-loopback interfaces which we know about.
	# refer to hostname.if(5)
	for hn in /mnt/etc/hostname.*; do
		# Strip off /mnt/etc/hostname. prefix
		if=${hn#/mnt/etc/hostname.}

		# Interface names must be alphanumeric only.  We check to avoid
		# configuring backup or temp files, and to catch the "*" case.
		if ! isalphanumeric "$if"; then
			continue
		fi
		ifconfig $if > /dev/null 2>&1
		if [ "$?" != "0" ]; then
			continue
		fi

		# Now parse the hostname.* file
		while :; do
			if [ "$cmd2" ]; then
				# we are carrying over from the 'read dt dtaddr' last time
				set -- $cmd2
				af="$1" name="$2" mask="$3" bcaddr="$4" ext1="$5" cmd2=
				# make sure and get any remaining args in ext2, like the read below
				i=1; while [ i -lt 6 -a -n "$1" ]; do shift; let i=i+1; done
				ext2="$@"
			else
				# read the next line or exit the while loop
				read af name mask bcaddr ext1 ext2 || break
			fi
			# $af can be "dhcp", "up", "rtsol", an address family, commands, or
			# a comment.
			case "$af" in
			"#"*|"!"*|"bridge"|""|"rtsol")
				# skip comments, user commands, bridges,
				# IPv6 rtsol and empty lines
				continue
				;;
			"dhcp")
				[ "$name" = "NONE" ] && name=
				[ "$mask" = "NONE" ] && mask=
				[ "$bcaddr" = "NONE" ] && bcaddr=
				ifconfig $if $name $mask $bcaddr $ext1 $ext2 down
				cmd="dhclient $if"
				;;
			"up")
				# The only one of these guaranteed to be set is $if
				# the remaining ones exist so that media controls work
				cmd="ifconfig $if $name $mask $bcaddr $ext1 $ext2 up"
				;;
			*)
				read dt dtaddr
				if [ "$name"  = "alias" ]; then
					# perform a 'shift' of sorts
					alias=$name
					name=$mask
					mask=$bcaddr
					bcaddr=$ext1
					ext1=$ext2
					ext2=
				else
					alias=
				fi
				cmd="ifconfig $if $af $alias $name "
				case "$dt" in
				dest)
					cmd="$cmd $dtaddr"
					;;
				[a-z!]*)
					cmd2="$dt $dtaddr"
					;;
				esac
				if [ ! -n "$name" ]; then
					echo "/mnt/etc/hostname.$if: invalid network configuration file"
					return
				fi
				case $af in
				inet)
					[ "$mask" ] && cmd="$cmd netmask $mask"
					if [ "$bcaddr" -a "X$bcaddr" != "XNONE" ]; then
						cmd="$cmd broadcast $bcaddr"
					fi
					[ "$alias" ] && rtcmd="; route -n add -host $name 127.0.0.1"
					;;
				inet6)
					# Ignore IPv6 setup
					continue
					;;
				*)	cmd="$cmd $mask $bcaddr"
				esac
				cmd="$cmd $ext1 $ext2$rtcmd" rtcmd=
				;;
			esac
			eval "$cmd"
		done < /mnt/etc/hostname.$if
	done

	# /mnt/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 -n add -host default `cat /mnt/etc/mygate`
	fi

	# Get FQDN after any DHCP manipulation of resolv.conf is done
	get_fqdn /etc/resolv.conf

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

	# enable the resolver if resolv.conf is available
	if [ -f /etc/resolv.conf ]; then
		route show
		echo "\nResolver enabled."
	else
		route -n show
		echo "\nResolver not enabled."
	fi

	return 0
}

# Print the selector and get a response
# The list of sets is passed in as $1, sets $resp
get_selection() {
	local _next= _f _sets=$1

	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

	# Get the name of the file.
	echo -n "File name? [$_next] "
	getresp "$_next"
}

# Do globbing on the selection and parse +/-, sets _get_files and _setsdone
# (which must exist in the local namespace) as side effects.
glob_selection() {
	local _selection="$1" _parent_dir="$2" _sets="$3"
	local _action _matched _tfile _f

	if [ "X${_selection}" = X"" ]; then
		return
	fi

	# Change +/- into add/remove
	_action=add
	case "$_selection" in
		+*)	_selection="${_selection#?}"
			;;
		-*)	_selection="${_selection#?}"
			_action=remove
			;;
	esac

	# Major hack to allow the user to select globbing patterns
	set -o noglob
	if [ X"$_selection" = X"all" ]; then
		_selection=*
	fi
	# This is safe in single user mode.
	_tfile=/tmp/install_case.$$
	cat >$_tfile << OOF
	case \$_f in
		$_selection)
			# Add/remove file to extraction list
			if [ "\$_action" = "add" ]; then
				_get_files=\`addel \${_f} \${_get_files}\`
				_setsdone=\`addel \${_f} \${_setsdone}\`
			elif [ "\$_action" = "remove" ]; then
				_get_files=\`rmel \${_f} \${_get_files}\`
				_setsdone=\`rmel \${_f} \${_setsdone}\`
			else
				echo "Unknown action: \$_action"
			fi
			_matched=\$(( \$_matched + 1 ))
			;;
	esac
OOF
	set +o noglob

	# Eww.
	_matched=0
	for _f in $_sets; do
		. $_tfile
	done
	rm -f $_tfile

	if [ $_matched -eq 0 ]; then
		echo "File $_parent_dir/$_selection does not exist.  Check to make"
		echo "sure you entered the information properly or enter 'list' for a file list."
	fi
}

encode_for_url() {
	# Encode $1 as specified for usercodes and passwords in RFC 1738
	# section 3.1, and now supported by our in-tree ftp:
	#
	#    ':' -> '%3a'
	#    '@' -> '%40'
	#    '/' -> '%2f'
	#
	# *NOTE* quotes around $1 are required to preserve trailing or
	# embeddded blanks in usercodes and passwords!
    
	echo "$1" | sed -e 's/:/%3a/g' -e 's/@/%40/g' -e 's/\//%2f/g'
}

install_url() {
# Get several parameters from the user, and xfer
# files from the server.
# Note:	_ftp_server_ip, _ftp_server_dir, _ftp_server_login,
#	_ftp_server_password, and _ftp_active must be global.

local _sets _kernel _f _file_list _get_files _failed_files _osetsdone
local _url_type _url_base _url_login _url_pass _oifs

# Parse arguments, shell style
case "$1" in
	-ftp)	_url_type=ftp  ;;
	-http)	_url_type=http ;;
esac

echo
echo "This is an automated ${_url_type}-based installation process.  You will be asked"
echo "questions and then the files will be retrieved iteratively via ${_url_type}."
echo

# Proxy the connections?
if [ "X${_proxy_host}" = X"" ]; then
	_proxy_host=none
fi
echo -n "HTTP/FTP proxy URL? (e.g. \"http://proxy:8080\", or \"none\") [${_proxy_host}] "
getresp "${_proxy_host}"
if [ "X${resp}" = X"none" ]; then
	unset _proxy_host ftp_proxy http_proxy
else
	_proxy_host=$resp
	export ftp_proxy=${_proxy_host}
	export http_proxy=${_proxy_host}
fi
if [ "${_url_type}" = "ftp" -a "X$ftp_proxy" = "X" ]; then
	# Use active mode ftp? (irrelevant if using a proxy)
	case "${_ftp_active}" in
		-A)	resp=y ;;
		*)	resp=n ;;
	esac
	echo "By default, ftp will attempt a passive connection and fall back to a normal"
	echo "(active) connection if that doesn't work.  However, there are some very"
	echo "old ftp servers that claim to support passive mode, but really do not."
	echo "In this case, you should explicitly request an active session."
	echo -n "Do you want to use active ftp? [${resp}] "
	getresp "${resp}"
	case "$resp" in
		y*|Y*)	_ftp_active=-A ;;
		*)	unset _ftp_active ;;
	esac
fi

# Provide a list of possible servers
test -z "$_ftp_getlist" && _ftp_getlist=y
echo -n "Do you want a list of potential ${_url_type} servers? [${_ftp_getlist}] "
getresp $_ftp_getlist
case "$resp" in
	n*|N*)	_ftp_getlist=n
		;;
	*)
		_ftp_getlist=y
		ftphost=129.128.5.191
		if [ "X${_resolver_enabled}" = X"TRUE" ]; then
			ftphost=ftp.openbsd.org
		fi
		ftp ${_ftp_active} -V -a -o /tmp/ftplist ftp://${ftphost}/pub/OpenBSD/${VERSION_MAJOR}.${VERSION_MINOR}/ftplist > /dev/null
		cat /tmp/ftplist | grep "^${_url_type}:" | cat -n | less -XE
		;;
esac

# Get server IP address
resp=
while [ "X${resp}" = X"" ]; do
	if [ -f /tmp/ftplist ]; then
		eval echo -n "Server IP address, hostname, or list#? [\$_${_url_type}_server_ip]\ "
	else
		eval echo -n "Server IP address, or hostname? [\$_${_url_type}_server_ip]\ "
	fi
	eval getresp "\$_${_url_type}_server_ip"
	if [ "X$resp" = "X?" -a -f /tmp/ftplist ]; then
		cat /tmp/ftplist | grep "^${_url_type}:" | cat -n | less -XE
		resp=
	elif [ -n "$resp" \
		-a `isnumeric $resp` -eq 1 \
		-a ${resp:-0} -ge 1 \
		-a -f /tmp/ftplist ]
		then
		maxlines=`grep "^${_url_type}:" /tmp/ftplist | cat -n |
			sed -n -e '$p' | cutword 1`
		if [ $maxlines -lt $resp ]; then
			echo "There is no ${resp}th line in the list."
			resp=
			continue
		fi
		tline=`grep "^${_url_type}:" /tmp/ftplist | sed -n -e "${resp}p"`
		url=`echo $tline | sed -e "s/^${_url_type}:\/\///" |
			cutword -t' ' 1 | cutword -t' ' 1`
		host=`echo $url | cutword -t/ 1`
		path=`echo $url | sed -e "s/^${host}\///"`
		path="${path}/${VERSION_MAJOR}.${VERSION_MINOR}/${ARCH}"
		eval _${_url_type}_server_ip=$host
		eval _${_url_type}_server_dir=$path
		# do it again, just to double check
		resp=
		echo "Using	$tline"
	else
		eval _${_url_type}_server_ip="$resp"
	fi
done

# Get server directory
if [ "${_url_type}" = "ftp" -a "X${_ftp_server_dir}" = X"" ]; then
	# Default ftp dir
	_ftp_server_dir="pub/OpenBSD/${VERSION_MAJOR}.${VERSION_MINOR}/${ARCH}"
fi
resp=
while [ "X${resp}" = X"" ]; do
	eval echo -n "Server directory? [\$_${_url_type}_server_dir]\ "
	eval getresp "\$_${_url_type}_server_dir"
	eval _${_url_type}_server_dir=$resp
done

if [ "${_url_type}" = "ftp" ]; then
	# Need default values even if we proxy ftp...
	if [ "X${_ftp_server_login}" = X"" ]; then
		_ftp_server_login=anonymous
	fi
	if [ "X${_ftp_server_password}" = X"" ]; then
		_ftp_server_password=root@`hostname`.${FQDN}
	fi

	# Get login name, setting IFS to nothing so trailing or
	# embedded blanks are preserved!
	_oifs="$IFS"
	IFS=
	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n "Login? [${_ftp_server_login}] "
		getresp "${_ftp_server_login}"
		_ftp_server_login="$resp"
	done

	# Get password unless anonymous
	if [ "${_ftp_server_login}" != "anonymous" ]; then
		resp=
		while [ "X${resp}" = X"" ]; do
			echo -n "Password (will not echo): "
			stty -echo
			getresp -n "${_ftp_server_password}"
			stty echo
			echo
			_ftp_server_password="$resp"
		done
	else
		# only used by ftp_list_files()
		_ftp_server_password=root@`hostname`.${FQDN}
	fi
	IFS="$_oifs"
fi

# Build up the base url since it is so nasty...
if [ "${_url_type}" = "ftp" -a "${_ftp_server_login}" != "anonymous" ]; then
	_url_login=`encode_for_url "${_ftp_server_login}"`
	_url_pass=`encode_for_url "${_ftp_server_password}"`
	_url_base="ftp://${_url_login}:${_url_pass}@${_ftp_server_ip}/${_ftp_server_dir}"
else
	eval _url_base=${_url_type}://\$_${_url_type}_server_ip/\$_${_url_type}_server_dir
fi

# Get list of files from the server.
# XXX - check for nil $_file_list and deal
if [ "${_url_type}" = "ftp" -a "X${ftp_proxy}" = X"" ]; then
	_file_list=`ftp_list_files "$_ftp_server_ip" "$_ftp_server_login" "$_ftp_server_password" "$_ftp_server_dir"`
else
	# Assumes index file is "index.txt" for http (or proxy)
	# We can't use index.html since the format is server-dependent
	_file_list=`ftp -o - -V "${_url_base}/index.txt" | sed 's/
//'`
fi

_sets=
if list_has_sets "$_file_list" $THESETS; then
	for _f in $THESETS ; do
		if [ "X${_f}" = "Xkernel" ]; then
			if isin bsd $_file_list; then
				_kernel=bsd
			fi
		elif isin ${_f}${VERSION}.tar.gz $_file_list; then
			_sets="$_sets ${_f}${VERSION}.tar.gz"
		elif isin ${_f}${VERSION}.tgz $_file_list; then
			_sets="$_sets ${_f}${VERSION}.tgz"
		fi
	done
else
	eval echo "There are no OpenBSD install sets available in \"\$_${_url_type}_server_dir\"."
	echo -n "Search for *.tar.gz and *.tgz files? [y] "
	getresp "y"
	case "$resp" in
		n*|N*)	return ;;
		*)	;;
	esac
	# *.tar.gz and *.tgz are possible sets
	_sets=
	_kernel=
	for _f in ${_file_list} ; do
		case "$_f" in
			*.tar.gz|*.tgz)	_sets="$_sets ${_f}"
		esac
	done
	if [ "X${_sets}" = X"" ]; then
		echo "There are no *.tar.gz or *.tgz files in that dir."
		echo -n "See a directory listing? [y] "
		getresp "y"
		case "$resp" in
			n*|N*)	return ;;
			*)	;;
		esac
		echo
		echo "${_file_list}"
		echo
		return
	else
		echo "Adding *.tar.gz and *.tgz files to selector."
	fi
fi

# Yes, all those blackslashes really are necessary...
eval echo "\\\\n"\
"You will now be asked for files to extract. In addition to the files listed,\\\\n"\
"you may select any file located at\\\\n"\
"	\$_${_url_type}_server_ip:\$_${_url_type}_server_dir\\\\n"\
"You can also enter \'all\' to install all the standard sets, or \'list\' to list\\\\n"\
"the files available.  When you are done selecting files, enter \'done\'. Some of\\\\n"\
"these sets are required for your ${MODE} and some are optional -- you will want\\\\n"\
"at least the base and bsd sets.  Consult the installation notes if you are not\\\\n"\
"sure which sets are required!"
_osetsdone="$_setsdone"
# Set the minimal default
for _f in $_sets $_kernel; do
	# From logic above, $_sets contains only .tgz and .tar.gz
	# file names, and $_kernel is empty or 'bsd'.
	case "$_f" in
		base*|bsd|comp*|etc*|game*|man*|misc*)
			if ! isin ${_f} ${_setsdone}; then
				_get_files=`addel ${_f} ${_get_files}`
				_setsdone=`addel ${_f} ${_setsdone}`
			fi
			;;
	esac
done

# Allow the user to select/de-select additional sets
while : ; do
	echo
	echo "The following sets are available for extraction."
	echo "Enter filename, \`list', \`all', or \`done'."
	echo "You may de-select a set by prepending a '-' to its name."
	echo
	get_selection "$_sets $_kernel"

	if [ "X${resp}" = X"done" ]; then
		break
	elif [ "X${resp}" = X"list" ]; then
		echo
		eval echo "\$_${_url_type}_server_dir:"
		echo "${_file_list}"
		continue
	fi

	eval glob_selection \"$resp\" \$_${_url_type}_server_dir \"$_sets $_kernel\"
done

# User may have said "done" without selecting any files
if [ "X${_get_files}" = X"" ]; then
	return
fi

# Stash the fact that we configured and downloaded via this url method
eval _installed_via_${_url_type}=1

echo
echo "Fetching files via ${_url_type} may take a long time, especially over a slow network"
echo -n "connection.  Ready to download files? [y] "
getresp "y"
case "$resp" in
	y*|Y*)
		;;
	*)
		_setsdone="$_osetsdone"
		return
		;;
esac

# Download the files one at a time and keep track of which ones failed
while test -n "${_get_files}" ; do
	_failed_files=
	echo
	for _f in $_get_files ; do
		echo "Getting ${_f} ..."
		if [ "X${_f}" = "X${_kernel}" ]; then
			( cd /mnt ; ftp ${_ftp_active} -V -m "${_url_base}/${_f}" )
		else
			( cd /mnt ; ftp ${_ftp_active} -o - -V -m "${_url_base}/${_f}" | tar zxpf - )
		fi
		if [ $? -ne 0 ]; then
			# Mark xfer as having failed,.
			_setsdone=`rmel $_f $_setsdone`
			_failed_files="${_failed_files} ${_f}"
		fi
	done

	# Give them the option of refetching failed files.
	_get_files=
	while test -n "${_failed_files}" ; do
		echo
		echo "The following files failed to transfer and extract correctly:"
		echo "Choose which one(s) to refetch or 'done' to exit selector."
		echo "You may de-select a file by prepending a '-' to its name."
		echo
		get_selection "$_failed_files"

		if [ "X${resp}" = X"done" ]; then
			break
		elif [ "X${resp}" = X"list" ]; then
			echo
			eval echo "\$_${_url_type}_server_dir:"
			echo "${_file_list}"
			echo
			continue
		fi

		eval glob_selection \"$resp\" \$_${_url_type}_server_dir \"$_failed_files\"
	done
done
}

install_from_mounted_fs() {
# $1 - directory containing installation sets
local _sets= _kernel _f _get_files _failed_files _osetsdone

if [ ! -d $1 ]; then
	echo "No such directory: $1"
	return
fi

if dir_has_sets $1 $THESETS; then
	for _f in $THESETS ; do
		if [ "X${_f}" = "Xkernel" ]; then
			if [ -f $1/bsd ]; then
				_kernel=bsd
			fi
		elif [ -f $1/${_f}${VERSION}.tar.gz ]; then
			_sets="$_sets ${_f}${VERSION}.tar.gz"
		elif [ -f $1/${_f}${VERSION}.tgz ]; then
			_sets="$_sets ${_f}${VERSION}.tgz"
		fi
	done
else
	echo "There are no OpenBSD install sets available in \"$1\"."
	echo -n "Search for *.tar.gz and *.tgz files? [y] "
	getresp "y"
	case "$resp" in
		n*|N*)	return ;;
		*)	;;
	esac
	# *.tar.gz and *.tgz are possible sets
	_sets=
	_kernel=
	_sets=`cd $1 ; echo *.tar.gz *.tgz`
	if [ "X${_sets}" = X'*.tar.gz *.tgz' ]; then
		echo "There are no *.tar.gz or *.tgz files in that dir."
		echo -n "See a directory listing? [y] "
		getresp "y"
		case "$resp" in
			n*|N*)	return ;;
			*)	;;
		esac
		echo
		( cd $1 && ls )
		echo
		return
	else
		echo "Adding *.tar.gz and *.tgz files to selector."
	fi
fi

echo "\n"\
"You will now be asked for files to extract.  In addition to the\n"\
"files listed in the selector you may enter any file located in\n"\
"$1.  You can also enter 'all' to install all the standard\n"\
"sets, or 'list' to list the files avilable in $1.\n"\
"When you are done selecting files, enter 'done'.\n"\
"Some of these sets are required for your ${MODE} and some are optional --\n"\
"You will want at least the base and bsd sets.\n"\
"Consult the installation notes if you are not sure which sets are required!"
_osetsdone="$_setsdone"
# Set a minimal default
for _f in $_sets $_kernel; do
	case "$_f" in
	# From logic above, $_sets contains only .tgz and .tar.gz
	# file names, and $_kernel is empty or 'bsd'.
		base*|bsd|comp*|etc*|game*|man*|misc*)
			if ! isin ${_f} ${_setsdone}; then
				_get_files=`addel ${_f} ${_get_files}`
				_setsdone=`addel ${_f} ${_setsdone}`
			fi
			;;
	esac
done

# Allow the user to select/de-select additional sets
while : ; do
	echo
	echo "The following sets are available for extraction."
	echo "Enter filename, \`list', \`all', or \`done'."
	echo "You may de-select a set by prepending a '-' to its name."
	echo
	get_selection "$_sets $_kernel"

	if [ "X${resp}" = X"done" ]; then
		break
	elif [ "X${resp}" = X"list" ]; then
		echo
		echo "${1}:"
		( cd $1 && ls )
		continue
	fi

	glob_selection "$resp" "$1" "$_sets $_kernel"
done

# User may have said "done" without selecting any files
if [ "X${_get_files}" = X"" ]; then
	return
fi

echo
echo -n "Ready to extract selected file sets? [y] "
getresp "y"
case "$resp" in
	y*|Y*)
		;;
	*)
		_setsdone="$_osetsdone"
		return
		;;
esac

# Extract the files one at a time and keep track of which ones failed
while test -n "${_get_files}" ; do
	_failed_files=
	echo
	for _f in $_get_files ; do
		echo "$1/${_f}:"
		if [ "X${_f}" = "X${_kernel}" ]; then
			ftp -V -m -o /mnt/$_f file:$1/$_f
		else
			ftp -V -m -o - file:$1/$_f | (cd /mnt; tar -zxpf -)
		fi
		if [ $? -ne 0 ]; then
			# Mark xfer as having failed,.
			_setsdone=`rmel $_f $_setsdone`
			_failed_files="${_failed_files} ${_f}"
		fi
	done

	# Give them the option of retrying failed files.
	_get_files=
	while test -n "${_failed_files}" ; do
		echo
		echo "The following files failed to extract correctly:"
		echo "Choose which one(s) to retry or 'done' to exit selector."
		echo "You may de-select a file by prepending a '-' to its name."
		echo
		get_selection "$_failed_files"

		if [ "X${resp}" = X"done" ]; then
			break
		elif [ "X${resp}" = X"list" ]; then
			echo
			echo "${1}:"
			( cd $1 && ls )
			echo
			continue
		fi

		glob_selection "$resp" "$1" "$_failed_files"
	done
done
}

install_cdrom() {
local _drive _range _part _fstype _directory _n

# Get the cdrom device info
_CDDEVS=`md_get_cddevs`
if [ "X${_CDDEVS}" = X"" ]; then
	echo "No CD-ROM devices were found.  Aborting."
	return
fi

cat << __EOT

The following CD-ROM devices are installed on your system.
Please make sure the CD is in the CD-ROM drive and select
the device containing the CD with the installation sets:

$_CDDEVS

__EOT
_drive=`echo $_CDDEVS | cutword 1`
echo -n	"Which CD-ROM contains the installation media? [$_drive] "
getresp "$_drive"
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

# If it is an ISO9660 CD-ROM, we don't need to ask any other questions
_n=0
until disklabel $_drive >/tmp/label.$_drive 2>&1; do
	# Try up to 6 times to access the CD
	if egrep -q '(Input/output error)|(sector size 0)' /tmp/label.$_drive; then
		_n=$(( $_n + 1 ))
		if [ _n -le 5 ]; then
			echo "I/O error accessing $_drive; retrying"
			sleep 10
		else
			echo "Cannot access $_drive.  Aborting."
			return
		fi
	else
		break
	fi
done
echo
if grep -q '^ *c: .*ISO9660' /tmp/label.$_drive; then
	_fstype=cd9660
	_part=c
else
	# Get partition from user
	_range=`md_get_partition_range`
	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n 'CD-ROM partition to mount (normally "c")? [c] '
		getresp c
		case "$resp" in
			$_range)
				_part=$resp
				;;

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

	# Ask for filesystem type
	cat << __EOT

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

__EOT
	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n "Which filesystem type? [cd9660] "
		getresp "cd9660"
		case "$resp" in
			cd9660|ffs)
				_fstype=$resp
				;;

			*)
				echo "Invalid response: $resp"
				# force loop to repeat
				resp=
				;;
		esac
	done
fi
rm -f /tmp/label.$_drive

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

# Get the directory where the file lives
if [ "X${_directory}" = X"" ]; then
	_directory="/${VERSION_MAJOR}.${VERSION_MINOR}/${ARCH}"
fi
resp=
while [ "X${resp}" = X"" ]; do
	echo "Enter the directory relative to the mount point that"
	echo -n "contains the file. [${_directory}] "
	getresp "${_directory}"
done
_directory=$resp

install_from_mounted_fs /mnt2/${_directory}
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 _def_partition _partition_range _partition _fstype
local _fsopts _directory _md_fstype _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
cat << __EOT

The following partitions have been found on $_drive:

__EOT
disklabel $_drive 2>/dev/null | grep '^  .:'
echo
_likely_partition_range=`disklabel $_drive 2>/dev/null | \
    sed -n -e '/swap/s/.*//' -e '/unused/s/.*//' \
	-e '/^  .:/{s/^  \(.\).*/\1/;H;}' \
	-e '${g;s/\n//g;s/^/[/;s/$/]/p;}'`
_partition_range=`disklabel $_drive 2>/dev/null | \
    sed -n -e '/^  .:/{s/^  \(.\).*/\1/;H;}' \
	-e '${g;s/\n//g;s/^/[/;s/$/]/p;}'`
_def_partition=`echo $_likely_partition_range | \
    sed -n 's/^\[\(.\).*\]/\1/p'`
if [ -z "$_def_partition" ]; then
	_def_partition=`echo $_partition_range | \
		sed -n 's/^\[\(.\).*\]/\1/p'`
	if [ -z "$_def_partition" ]; then
		echo "There are no usable partitions on that disk"
		return 0
	fi
fi
resp=
while [ "X${resp}" = X"" ]; do
	echo -n "Partition? [$_def_partition] "
	getresp "$_def_partition"
	case "$resp" in
		$_partition_range)
			_partition=$resp
			;;

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

# Ask for filesystem type
cat << __EOT

The following filesystem types are supported:
default		(deduced from the disklabel)
ffs
__EOT
_md_fstype=`md_native_fstype`
_md_fsopts=`md_native_fsopts`
if [ ! -z "$_md_fstype" ]; then
	echo "	$_md_fstype"
else
	_md_fstype="_undefined_"
fi
resp=
while [ "X${resp}" = X"" ]; do
	echo -n "Which filesystem type? [default] "
	getresp "default"
	case "$resp" in
		default)
			_fstype=
			_fsopts="ro"
			;;
		ffs)
			_fstype="-t $resp"
			_fsopts="async,ro"
			;;
		$_md_fstype)
			_fstype="-t $resp"
			_fsopts=$_md_fsopts
			;;
		*)
			echo "Invalid response: $resp"
			# force loop to repeat
			resp=
			;;
	esac
done

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

install_disk() {
local _directory

cat << __EOT

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

__EOT
_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

# Get the directory where the file lives
resp=
while [ "X${resp}" = X"" ]; do
	echo "Enter the directory relative to the mount point that"
	echo -n "contains the file. [${_directory}] "
	getresp "${_directory}"
done
_directory=$resp

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

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

# Get server path to mount
resp=
while [ "X${resp}" = X"" ]; 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"
		;;

	*)
		_nfs_tcp=
		;;
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

# Get the directory where the file lives
resp=
while [ "X${resp}" = X"" ]; do
	echo "Enter the directory relative to the mount point that"
	echo -n "contains the file. [${_nfs_directory}] "
	getresp "${_nfs_directory}"
done
_nfs_directory=$resp

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

install_tape() {
local _xcmd

# Get the name of the tape from the user.
cat << __EOT

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

__EOT
_tape=`basename $TAPE`
resp=
while [ "X${resp}" = X"" ]; 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=
while [ "X${resp}" = X"" ]; do
	echo -n "File number? "
	getresp ""
	case "$resp" in
		[1-9]*)
			_nskip=$(( $resp - 1 ))
			;;

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

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

cat << __EOT

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

__EOT
resp=
while [ "X${resp}" = X"" ]; do
	echo -n "Which way is it? [1] "
	getresp "1"
	case "$resp" in
	1)
		_xcmd="tar -zxvpf -"
		;;

	2)
		_xcmd="tar -xvpf -"
		;;

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

get_timezone() {
local _a _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 -a ! -e /mnt/usr/share/zoneinfo ]; then
	TZ=GMT
	return
fi
if [ ! -d /usr/share/zoneinfo ]; then
	_zonepath=/mnt
else
	_zonepath=
fi

cat << __EOT

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

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

__EOT
if [ X$TZ = X ]; 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 -F ${_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 -F ${_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\"".
			return
		fi
		echo "'/usr/share/zoneinfo/$_a' is not a valid timezone on this system."
		;;
	esac
done
}

sane_install() {
	if [ ! -s /mnt/bsd ]; then
		cat << __EOT

Warning, no kernel (/mnt/bsd) installed!  You did not unpack a file set
containing a kernel--this is needed to boot.  Please note that the install
kernel is *not* suitable for general use.
__EOT
	elif [ ! -f /mnt/bin/cat ]; then
		cat << __EOT

You still do not have a /bin/cat in your filesystem (i.e. a sample random file
which you probably want).  This seems to indicate that you are still missing
important distribution files.
__EOT
	elif [ ! -d /mnt/etc -o ! -d /mnt/usr/share/zoneinfo -o ! -d /mnt/dev ]; then
		cat << __EOT

Something needed to complete the installation seems to be missing, did you
forget to extract a required set?
__EOT
	else
		return 0
	fi

	cat << __EOT

You will now be given the chance to install the missing set(s).  You can
enter '!' at the prompt to escape to a shell and fix things by hand if you wish.

__EOT

	return 1
}

install_sets() {
local _yup="FALSE" _have_nfs

# Can we do an NFS install?
test -f /sbin/mount_nfs && _have_nfs=true

# Ask the user which media to load the distribution from.
cat << __EOT
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.  You will have the chance to repeat this step or to extract sets from
several places, so you don't have to try to load all the sets in one try and
can recover from some errors.

__EOT

if [ "X$local_sets_dir" != "X" ]; then
	install_from_mounted_fs ${local_sets_dir}
	if [ X"$_setsdone" != X ]; then
		_yup="TRUE"
	fi
fi

# Go on prodding for alternate locations
resp=
while [ X"${resp}" = X ]; 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 [ X"$_yup" = X"FALSE" ]; then
		echo -n	"Install from (f)tp, (h)ttp, (t)ape, (C)D-ROM"
		test -n "$_have_nfs" && echo -n ", (N)FS"
		echo -n " or local (d)isk? "
		getresp ""
		case "$resp" in
		d*|D*)
			install_disk
			resp=d
			;;
		f*|F*)
			test -n "$_didnet" || donetconfig
			install_url -ftp
			resp=f
			;;
		h*|H*)
			test -n "$_didnet" || donetconfig
			install_url -http
			resp=h
			;;
		t*|T*)
			install_tape
			resp=t
			;;
		c*|C*)
			install_cdrom
			resp=c
			;;
		n*|N*)
			test -n "$_didnet" || donetconfig
			if [ -n "$_have_nfs" ]; then
				install_nfs
				resp=n
			else
				echo "Invalid response: $resp"
				resp=
			fi
			;;
		*)
			echo "Invalid response: $resp"
			resp=
			;;
		esac
	else
		# So we'll ask next time
		_yup="FALSE"
	fi

	# Perform sanity checks...
	if sane_install; then
		# 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
	else
		# Not sane, don't exit loop.
		resp=
	fi
done
}

munge_fstab() {
	# Create a fstab to use for fsck'ing, mounting and unmounting all
	# of the target filesystems relative to /mnt.

	local _dev _mp _fstype _opt _rest

	while read _dev _mp _fstype _opt _rest; do
		# Skip comment lines, non-ffs filesystems and
		# 'noauto' filesystems.
		case "$_dev" in
			\#*)	continue;;
			*)	;;
		esac
		case "$_fstype" in
			ffs)	;;
			*)	continue;;
		esac
		case "$_opt" in
			*noauto*)    continue;;
			*)	;;
		esac

		# Don't use soft updates
		_opt="$(echo ${_opt} | sed 's/,softdep,/,/; s/,softdep//; s/softdep,//')"

		if [ "$_mp" = "/" ]; then
			_mp=""
		fi

		echo $_dev /mnt$_mp $_fstype $_opt $_rest
	    done > /etc/fstab
}

mount_fs() {
	# Must mount filesystems manually, one at a time, so we can make
	# sure the mount points exist.
	local _async=$1 _dev _mp _fstype _opt _rest

	while read _dev _mp _fstype _opt _rest; do
		# If not the root filesystem, make sure the mount
		# point is present.
		if [ "X{$_mp}" != X"/mnt" ]; then
			mkdir -p $_mp
		fi

		# Mount the filesystem. If the mount fails, exit.
		if ! mount -v -t $_fstype $_async -o $_opt $_dev $_mp ; then
			# In addition to the error message displayed by mount ...
			cat << __EOT

FATAL ERROR:	Cannot mount filesystems.  Double-check your configuration
		and restart the ${MODE}.

__EOT
			exit
		fi
	done < /etc/fstab
}

cleanup_on_exit() {
	# Script is exiting. Clean up as much as possible.
	local _bad_devs

	echo "\nCleaning up..."

	# Kill any running dhclient, so a restart will not
	# find /dev/bpf0 busy. Do this first so a user who
	# interrupts out of any fsck'ing will not be stuck
	# with an active dhclient.

	if [ -f /var/run/dhclient.pid ]; then
		echo "Stopping dhclient"
		kill -HUP `sed -ne "1p" /var/run/dhclient.pid` > /dev/null 2>&1
		rm -f /var/run/dhclient.pid
	fi

	if [ -f /etc/fstab ]; then
		umount -av
		check_fs
	elif [ ! "`df /`" = "`df /mnt`" ]; then
		umount -v /mnt
	fi

	echo "Done."
}

remount_fs() {
	# Remount all filesystems in /etc/fstab with the options from
	# /etc/fstab, i.e. without any options such as async which
	# may have been used in the first mount.
	local _dev _mp _fstype _opt _rest

	while read _dev _mp _fstype _opt _rest; do
		if ! mount -u -o $_opt $_dev $_mp ; then
			# error message displayed by mount
			exit 1
		fi
	done < /etc/fstab
}

check_fs() {
	# Preen all filesystems in /etc/fstab, showing individual results.
	local _dev _rest _badfsck=0

	while read _dev _rest; do
		echo -n "fsck -p ${_dev}..."
		if ! fsck -fp ${_dev} > /dev/null 2>&1; then
			echo "FAILED. You must fsck this device manually."
			_badfsck=1
		else
			echo "OK."
		fi
	done < /etc/fstab

	return $_badfsck
}

get_fqdn() {
	# $1 = resolv.conf file to search for FQDN
	# $2 = hosts file to add FQDN information to

	# Find LAST instance of DOMAIN or SEARCH and extract first domain name
	# on that line as FQDN. Then ask user, just to be sure.

	if [ -f "$1" ]; then
		FQDN=`sed -n \
			-e '/^domain[[:space:]][[:space:]]*/{s///;s/\([^[:space:]]*\).*$/\1/;h;}' \
			-e '/^search[[:space:]][[:space:]]*/{s///;s/\([^[:space:]]*\).*$/\1/;h;}' \
			-e '${g;p;}' $1`
	fi

	if [ -f "$2" -a "X$FQDN" != "X" ]; then
		# Add FQDN to hosts file entries created by addhostent, changing
		# lines like
		#    1.2.3.4 hostname
		# to
		#    1.2.3.4 hostname.$FQDN hostname
		sed "s/\\(.*\\)[[:space:]]\\(.*\\)\$/\\1 \\2.$FQDN \\2/" < $2 > $2.new
		mv $2.new $2
	else
		echo -n "Enter DNS domain name (e.g. \"bar.com\"): [$FQDN] "
		getresp "$FQDN"
		FQDN=$resp
	fi
}

donetconfig() {
	_didnet=1

	_nam=
	if [ -f /tmp/myname ]; then
		_nam=`cat /tmp/myname`
	fi

	resp=
	while [ "X${resp}" = X"" ]; do
		echo -n "Enter system hostname (short form, e.g. \"foo\"): [$_nam] "
		getresp "$_nam"
	done
	hostname $resp
	echo $resp > /tmp/myname

	# Always create new hosts file. If install.sh has been
	# restarted, an existing one may contain information which
	# will conflict with the information about to be entered.
	# Also ensures logic to put FQDN in hosts file will create
	# hosts file lines in correct format.
	echo "::1 localhost\n127.0.0.1 localhost" > /tmp/hosts

	# Remove any existing hostname.* files. If install.sh has
	# been restarted, this ensures a correct list of configured
	# interfaces is displayed, and gives the user a chance to
	# change which interfaces are to be configured.
	rm -f /tmp/hostname.*

	# Revoke any previous decision on whether or not to use
	# a nameserver during installation.
	rm -f /tmp/resolv.conf.shadow

	echo
	echo "If any interfaces will be configured using a DHCP server"
	echo "it is recommended that you do not enter a DNS domain name,"
	echo "a default route, or any name servers."
	echo

	FQDN=""
	get_fqdn /tmp/resolv.conf

	configure_all_interfaces

	# As dhclient will populate /etc/resolv.conf, a symbolic link to
	# /tmp/resolv.conf.shadow, mv any such file to /tmp/resolv.conf
	# so it will eventually be copied to /mnt/etc/resolv.conf and will
	# not in the meantime remove the user's ability to choose to use it
	# or not, during the rest of the install.
	if [ -f /tmp/resolv.conf.shadow ]; then
		mv /tmp/resolv.conf.shadow /tmp/resolv.conf
	fi

	# Get any DHCP supplied FQDN, and in any case apply FQDN to
	# the host names in /tmp/hosts, all without asking for any more
	# user confirmation. This means DHCP supplied information will
	# override a user supplied (or previous DHCP supplied) FQDN.
	get_fqdn /tmp/resolv.conf /tmp/hosts

	resp=`route -n show |
		grep '^default' |
		sed -e 's/^default          //' -e 's/ .*//'`
	if [ "X${resp}" = "X" ]; then
		resp=none
		if [ -f /tmp/mygate ]; then
			resp=`cat /etc/mygate`
			if [ "X${resp}" = "X" ]; then
				resp=none
			fi
		fi
	fi
	echo -n "Enter IP address of default route: [$resp] "
	getresp "$resp"
	if [ "X${resp}" != X"none" ]; then
		route delete default > /dev/null 2>&1
		if route add default $resp > /dev/null ; then
			echo $resp > /tmp/mygate
		fi
	fi

	resp=none
	if [ -f /tmp/resolv.conf ]; then
		resp=
		for n in `grep '^nameserver ' /tmp/resolv.conf | \
			sed -e 's/^nameserver //'`
			do
			if [ "X${resp}" = "X" ]; then
				resp="$n"
			else
				resp="$resp $n"
			fi
		done
	fi
	echo -n	"Enter IP address of primary nameserver: [$resp] "
	getresp "$resp"
	if [ "X${resp}" != X"none" ]; then
		echo "search $FQDN" > /tmp/resolv.conf
		for n in `echo ${resp}`; do
			echo "nameserver $n" >> /tmp/resolv.conf
		done
		echo "lookup file bind" >> /tmp/resolv.conf

		echo -n "Would you like to use the nameserver now? [y] "
		getresp "y"
		case "$resp" in
			y*|Y*)
				cp /tmp/resolv.conf \
					/tmp/resolv.conf.shadow
				;;

			*)
				;;
		esac
	fi

	if [ ! -f /tmp/resolv.conf.shadow ]; then
		echo
		echo "The host table is as follows:"
		echo
		cat /tmp/hosts
	cat << __hosts_table_1

You may want to edit the host table in the event that you are doing an
NFS installation or an FTP installation without a name server and want
to refer to the server by name rather than by its numeric ip address.
__hosts_table_1
		echo -n "Would you like to edit the host table with ${EDITOR}? [n] "
		getresp "n"
		case "$resp" in
			y*|Y*)
				${EDITOR} /tmp/hosts
				;;

			*)
				;;
		esac
	fi

	cat << \__network_config_2

You will now be given the opportunity to escape to the command shell to do
any additional network configuration you may need.  This may include adding
additional routes, if needed.  In addition, you might take this opportunity
to redo the default route in the event that it failed above.
__network_config_2
	echo -n "Escape to shell? [n] "
	getresp "n"
	case "$resp" in
		y*|Y*)
			echo "Type 'exit' to return to install."
			sh
			;;

		*)
			;;
	esac
}

populateusrlocal() {
	if [ -f /mnt/etc/mtree/BSD.local.dist ]; then
		/mnt/usr/sbin/chroot /mnt /usr/sbin/mtree -Uedqn -p /usr/local -f /etc/mtree/BSD.local.dist >/dev/null
	fi
}