path: root/distrib/miniroot/install.sub

#!/bin/sh
#	$OpenBSD: install.sub,v 1.205 2002/04/13 21:03:58 deraadt 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 install/upgrade script common subroutines and initialization code

# include machine-dependent functions
# The following functions must be provided:
#	md_get_diskdevs()	- return available disk devices
#	md_get_cddevs()		- return available CD-ROM devices
#	md_get_partition_range() - return range of valid partition letters
#	md_installboot()	- install boot-blocks on disk
#	md_prep_disklabel()	- label the root disk
#	md_welcome_banner()	- display friendly message
#	md_not_going_to_install() - display friendly message
#	md_congrats()		- display friendly message
#	md_native_fstype()	- native filesystem type for disk installs
#	md_native_fsopts()	- native filesystem options for disk installs

# include machine dependent subroutines
. install.md

getresp() {
	local _no_shell=0

	# -n option means don't try to run shell commands
	if [ "$1" = "-n" ]; then
		_no_shell=1
		shift
	fi

	set -o noglob
	valid=
	while [ -z "$valid" ]; do
		read resp
		if [ ${_no_shell} -eq 1 ]; then
			[ -z "$resp" ] && resp=$1
		else
			case $resp in
			"")	resp=$1
				;;
			!)	echo "Type 'exit' to return to install."
				sh
				continue
				;;
			!*)	eval ${resp#?}
				continue
				;;
			esac
		fi
		valid=true
	done
	set +o noglob
}

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

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

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

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

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

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

# read lines on stdin, return Nth element of each line, like cut(1)
cutword () {
	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
		[ -z "$1" ] && break
		eval echo \$$_n
	done
	IFS=$_oifs
}

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

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

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

# return first character of argument
firstchar () {
	local _a=$1

	while [ ${#_a} != 1 ]; do
		_a=${_a%?}
	done
	echo $_a
}

basename () {
	local _oifs

	[ -z "$1" ] && return
	_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
}

# return available network devices
get_ifdevs() {
	/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 [[ -n "$_l" ]] ; then
		echo -n " "
		bsort $_l
	fi
}

# return true when the list $1 contains a set also in one of $2 ... $n
list_has_sets() {
	local _list=$1 _f

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

	return 1
}

# 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
ftp_list_files() {
	ftp ${_ftp_active} -V -n "$1" << __EOT
user "$2" "$3"
cd "$4"
ls
quit
__EOT
}

# $1 is relative mountpoint
get_localdir() {
	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 list_has_sets "`ls -l ${_mp}/${_dir}`" $THESETS
		then
			local_sets_dir=$_mp/$_dir
			break
		fi

		cat << __EOT
The directory "${_mp}/${_dir}" does not exist, or does not hold any
OpenBSD ${VERSION_MAJOR}.${VERSION_MINOR} ${MODE} sets.
__EOT
		echo -n "Re-enter pathname? [y] "
		getresp y
		case $resp in
		y*|Y*)	;;
		*)	local_sets_dir=
			break
			;;
		esac
	done
}

makedev() {
	local _d=$1

	if [ ! -c /dev/r${_d}c ]; then
		if [ -r /dev/MAKEDEV ]; then
			(cd /dev; sh MAKEDEV $_d)
		else
			echo "Device nodes for $_d are missing, and MAKEDEV"
			echo "does not exist to create them with.  Sorry."
			false
		fi
	fi
}

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:

$_DKDEVS

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

getrootdisk() {
	local _defdsk

	_defdsk=`echo $_DKDEVS | cutlast`
	if [ "${_defdsk}" != "${_DKDEVS}" ]; then
		_defdsk=
	fi

	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:

$_DKDEVS

__EOT
	echo -n "Which disk is the root disk? [${_defdsk}] "
	getresp "$_defdsk"
	if isin $resp $_DKDEVS ; then
		ROOTDISK=$resp
		makedev $resp || ROOTDISK=
	else
		echo "\nThe disk '$resp' does not exist."
		ROOTDISK=
	fi
}

# Create an entry in the hosts file. If an entry with the
# same symbolic name already exists, delete it.
# $1 - IP address
# $2 - symbolic name
addhostent() {
	sed "/ $2\$/d" < /tmp/hosts > /tmp/hosts.new
	mv /tmp/hosts.new /tmp/hosts

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

# Create a hostname.* file for the interface.
# $1 - interface name
# $2 - interface symbolic name
# $3 - interface IP address
# $4 - interface netmask
# $5 - (optional) interface media directives
addifconfig() {
	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 [ -z "$_ouranswer" ]; 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 '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\n"
	else
		_dhcp_prompt=" (or 'dhcp')"
	fi

	# Get IP address
	resp=
	while [ -z "$resp" ] ; 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 [ -z "$resp" ] ; do
		echo -n "Symbolic (host) name? [$_hostname] "
		getresp "$_hostname"
		_if_symname=$resp
	done

	# Get netmask
	if [ "$_if_ip" != "dhcp" ]; then
		resp=
		if [ -z "$_if_mask" ]; then
			_if_mask=255.255.255.0
		fi
		while [ -z "$resp" ]; 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
		cat << __EOT
Your use of the network interface may require non-default
media directives. The default media is:
__EOT
		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'
		cat << __EOT
If the default is not satisfactory, and you wish to use another
media, copy that line from above (e.g. "media 100baseTX")
__EOT
		echo -n "Media directives? [$_if_extra] "
		getresp "$_if_extra"
		if [ -n "$resp" ]; 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 [ $? -ne 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=done _f _sets=$1

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

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

	# Ignore a bare '-' or '+'
	case $resp in
	+|-)	resp=
	esac
}

# Do globbing on the selection and parse +/-, sets the global 
# _get_files and _setsdone appropriately.
glob_selection() {
	local _selection=$1 _src=$2 _sets=$3
	local _action _matched _tfile _f

	if [ -z "$_selection" ]; 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 << __EOT
	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
__EOT
	set +o noglob

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

	if [ $_matched -eq 0 ]; then
		cat << __EOT
The file

    '${_src}/${_selection}'

does not exist. Check to make sure you entered the name properly.
__EOT
	fi
}

display_failure_msg() {
		cat << __EOT

The following files failed to extract correctly.
Choose which one(s) to retry or 'done' to exit selector.
You may de-select a file by prepending a '-' to its name.

__EOT
}

display_selection_msg() {
	cat << __EOT

The following sets are available. Enter a filename, 'all' to select
all the sets, or 'done'. You may de-select a set by prepending a '-'
to its name.

__EOT
}

display_extract_msg() {

	cat << __EOT

You will now be asked which sets to ${MODE}. Some of these sets are required
for your ${MODE} and some are optional. You will want at least the
base and bsd sets. Consult the installation notes if you are not sure
which sets are required!
__EOT

}

# Set global _sets to either 
#     1) a list of sets found in both $1 and $THESETS, where
#        $2 is the location that generated the list of files in $1.
# or
#     2) a list of .tgz or .tar.gz files found in $2
get_sets_list () {
	local _f _file_list=$1 _src=$2

	_sets=

	for _f in $THESETS ; do
		if [ "X${_f}" = "Xkernel" ]; then
			if isin bsd $_file_list; then
				_sets="$_sets 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

	if [ -z "$_sets" ]; then
		cat << __EOT
The directory

    '${_src}'

contains no OpenBSD ${VERSION_MAJOR}.${VERSION_MINOR} ${MODE} sets.
__EOT
		echo -n "Search for other *.tar.gz and *.tgz files? [y] "
		getresp y
		case $resp in
		n*|N*)	return ;;
		esac
		# *.tar.gz and *.tgz are possible sets
		for _f in $_file_list ; do
			case $_f in
			*.tar.gz|*.tgz)	_sets="$_sets ${_f}"
			esac
		done
	fi

	if [ -z "$_sets" ]; then
		eval echo "There are no *.tar.gz or *.tgz files in ${_src}."
		echo -n "See a directory listing? [y] "
		getresp y
		case $resp in
		n*|N*)	return ;;
		esac
		echo "\n${_file_list}\n"
		return
	fi
}

# Set global _get_files to the list of sets requested by the user
# from $1. Add this list to _setsdone after saving current value
# of _setsdone.
get_get_files_list () {
	local _src=$1

	_get_files=
	_osetsdone=$_setsdone

	# Set the default list of files
	for _f in $_sets ; do
		# $_sets contains only .tgz and .tar.gz file names and '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

		display_selection_msg

		get_selection "$_sets"

		if [ "X${resp}" = "Xdone" ]; then
			break
		fi

		glob_selection "$resp" "$_src" "$_sets"
	done
}

# Install the list of files in the global _get_files from the source
# in $1, aka $2. For mounted file system installs $1==file:$2. For URL
# installs $1 == $_url_base and $2 == $1 w/o passwords, etc.
#
# Return 0 if install was attempted, 1 if user aborted before install
# was tried.
install_get_files_list () {
	local _f _failed_files _src=$1 _public_src=$2

	echo -n "Ready to ${MODE} sets? [y] "
	getresp y
	case $resp in
	y*|Y*)	;;
	*)	_setsdone=$_osetsdone
		return 1
		;;
	esac

	# Install/Upgrade the sets one at a time. Keep track of which
	# ones fail.
	while [ -n "${_get_files}" ] ; do
		_failed_files=
		echo
		for _f in $_get_files ; do
			echo "Getting ${_f} ..."
			case $_f in
			*.tar.gz|*.tgz)
				ftp ${_ftp_active} -o - -V -m "${_src}/${_f}" | tar zxpf - -C /mnt
				;;
			*)
				ftp ${_ftp_active} -o "/mnt/${_f}" -V -m "${_src}/${_f}"
				;;
			esac
			if [ $? -ne 0 ]; then
				# Mark xfer as having failed,.
				_setsdone=`rmel $_f $_setsdone`
				_failed_files="${_failed_files} ${_f}"
			fi
		done

		# Offer the option of re-fetching failed files.
		_get_files=
		while [ -n "${_failed_files}" ] ; do
			display_failure_msg

			get_selection "$_failed_files"

			if [ "X${resp}" = X"done" ]; then
				break
			fi

			glob_selection "$resp" "$_public_src" "$_failed_files"
		done
	done
}

# 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!
encode_for_url() {
	echo "$1" | sed -e 's/:/%3a/g' -e 's/@/%40/g' -e 's/\//%2f/g'
}

# 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.
install_url() {
	local _f _file_list _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

	cat << __EOT

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

__EOT

	# Proxy the connections?
	if [ -z "$_proxy_host" ]; 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 -z "$ftp_proxy" ]; then
		# Use active mode ftp? (irrelevant if using a proxy)
		case $_ftp_active in
		-A)	resp=y ;;
		*)	resp=n ;;
		esac

		cat << __EOT
By default, ftp will attempt a passive connection and fall back to a normal
(active) connection if that does not work. However, there are some very
old ftp servers that claim to support passive mode, but really do not.
In this case, you should explicitly request an active session.
__EOT
		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
	[ -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 [ -z "$resp" ] ; 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 -z "$_ftp_server_dir" ] ; then
		# Default ftp dir
		_ftp_server_dir=pub/OpenBSD/${VERSION_MAJOR}.${VERSION_MINOR}/${ARCH}
	fi
	resp=
	while [ -z "$resp" ] ; 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 [ -z "$_ftp_server_login" ] ; then
			_ftp_server_login=anonymous
		fi
		if [ -z "$_ftp_server_password" ] ; 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 [ -z "$resp" ] ; 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 [ -z "$resp" ] ; 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 -z "$ftp_proxy" ] ; 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

	get_sets_list  "$_file_list" "`eval echo \\$_${_url_type}_server_dir`"

	[ -z "$_sets" ] && return

	display_extract_msg

	get_get_files_list "`eval echo \\$_${_url_type}_server_dir`" 

	# User may have selected no files
	[ -z "$_get_files" ] && return

	cat << __EOT

Fetching files via ${_url_type} may take a long time, especially over a slow
network connection.
__EOT

	install_get_files_list "$_url_base" "`eval echo \$_${_url_type}_server_dir`"
	if [ $? -eq 0 ] ; then
		# Stash the fact that we configured and downloaded via this url method
		eval _installed_via_${_url_type}=1
	fi
}

# $1 - directory containing installation sets
install_from_mounted_fs() {
	local _f _get_files _file_list

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

	_file_list=`ls -l ${1}`

	get_sets_list "$_file_list" "$1"

	[ -z "$_sets" ] && return

	display_extract_msg

	get_get_files_list "$1" 

	# User may have selected no files
	[ -z "$_get_files" ] && return

	install_get_files_list "file:$1" "$1"
}

install_cdrom() {
	local _drive _range _part _fstype _directory _n

	# Get the cdrom device info
	if [ -z "$_CDDEVS" ]; 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 "\nThe CD-ROM $resp does not exist.\nAborting."
			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 [ -z "$resp" ] ; 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 [ -z "$resp" ] ; 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
	resp=
	_directory=${VERSION_MAJOR}.${VERSION_MINOR}/${ARCH}
	echo "Enter the directory relative to the mount point that contains"
	echo -n "the file: [${_directory}] "

	getresp "$_directory"

	install_from_mounted_fs "/mnt2/${resp}"
	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 _md_fstype _md_fsopts

	cat << __EOT

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

$_DKDEVS

__EOT

	echo -n	"Which is the disk with the installation sets? [abort] "
	getresp abort

	case $resp in
	abort)	echo "Aborting."
		return 0
		;;
	*)	if isin $resp $_DKDEVS ; then
			_drive=$resp
		else
			echo "\nThe disk $resp does not exist.\nAborting."
			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 [ -z "$resp" ]; 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 [ -n "$_md_fstype" ]; then
		echo "	$_md_fstype"
	else
		_md_fstype=_undefined_
	fi

	resp=
	while [ -z "$resp" ]; 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() {
	if mount_a_disk ; then
		return
	fi

	# Get the directory where the file lives
	echo "Enter the directory relative to the mount point that"
	echo -n "contains the file: [.] "
	getresp "."

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

install_nfs() {
	# Get the IP address of the server
	resp=
	while [ -z "$resp" ] ; 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 [ -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
		;;
	*)	_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 [ -z "$resp" ]; do
		echo "Enter the directory relative to the mount point that"
		echo -n "contains the file: [.] "
		getresp
	done

	install_from_mounted_fs "/mnt2/${resp}"
	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 [ -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=
	while [ -z "$resp" ]; 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 [ -z "$resp" ]; 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 _zoneroot=/mnt/usr/share/zoneinfo/ _zonepath

	# If the timezone directory structure is not
	# available, return immediately.

	[ ! -d $_zoneroot ] && return

	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".

__EOT

	if [ -L /mnt/etc/localtime ]; then
		TZ=`ls -l /mnt/etc/localtime 2>/dev/null | cutlast`
		TZ=${TZ#${_zoneroot#/mnt}}
	fi

	[ -z "$TZ" ] && TZ=GMT

	while : ; do
		_zonepath=$_zoneroot

		echo -n	"What timezone are you in? ('?' for list) [$TZ] "
		getresp "$TZ"

		if [ "$resp" = "?" ]; then
			ls -F ${_zonepath}
			continue;
		fi

		_zonepath=${_zonepath}${resp}

		while [ -d "$_zonepath" ]; do
			echo -n "Select a sub-timezone of "
			echo -n "'${_zonepath#$_zoneroot}' ('?' for list): "
			getresp
			if [ "$resp" = "?" ]; then
				ls -F ${_zonepath}
			else
				_zonepath=${_zonepath}/${resp}
			fi
		done

		if [ -f "$_zonepath" ]; then
			TZ=${_zonepath#$_zoneroot}
			echo "You have selected timezone '$TZ'".
			ln -sf /usr/share/zoneinfo/$TZ /mnt/etc/localtime
			return
		fi

		echo -n "'${_zonepath#$_zoneroot}'"
		echo " is not a valid timezone on this system."
	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 [ ! -x /mnt/dev/MAKEDEV ]; then
		cat << __EOT

No /dev/MAKEDEV has been installed yet.
__EOT

	elif [ ! -d /mnt/etc -o ! -d /mnt/usr/share/zoneinfo -o ! -d /mnt/dev ]; then
		cat << __EOT

One or more of /etc, /usr/share/zoneinfo or /dev is 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?
	[ -f /sbin/mount_nfs ] && _have_nfs=true

	# Ask the user which media to load the distribution from.
	cat << __EOT

You must now specify where the ${MODE} sets you want to use are. They
must either be on a local device (disk, tape, or CD-ROM), an
accessible NFS filesystem or an accessible ftp or http network
server. You will have the chance to repeat this step or to extract
sets from several places, so you do not have to try to load all the
sets in one try and can recover from some errors.

__EOT

	if [ -n "$local_sets_dir" ]; then
		install_from_mounted_fs "${local_sets_dir}"
		[ -n "$_setsdone" ] && _yup=TRUE
	fi

	# Go on prodding for alternate locations
	resp=
	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 [ X"$_yup" = X"FALSE" ]; then
			echo -n	"Install from (f)tp, (h)ttp, (t)ape, (C)D-ROM"
			[ -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*)	[ -n "$_didnet" ] || donetconfig
				install_url -ftp
				resp=f
				;;
			h*|H*)	[ -n "$_didnet" ] || donetconfig
				install_url -http
				resp=h
				;;
			t*|T*)	install_tape
				resp=t
				;;
			c*|C*)	install_cdrom
				resp=c
				;;
			n*|N*)	[ -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 -n	"\nExtract 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
}

# Create a fstab to use for fsck'ing, mounting and unmounting all
# of the target filesystems relative to /mnt.
munge_fstab() {
	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
}

# Must mount filesystems manually, one at a time, so we can make
# sure the mount points exist.
mount_fs() {
	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
}

# Script is exiting. Clean up as much as possible.
cleanup_on_exit() {
	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
	elif [ ! "`df /`" = "`df /mnt`" ]; then
		umount -v /mnt
	fi

	echo "Done."
}

# 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.
remount_fs() {
	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
}

# Preen all filesystems in /etc/fstab, showing individual results,
# but skipping the root filesystem device given in $1. This was
# already fsck'ed successfully.
check_fs() {
	local _dev _rest _badfsck=0 _root=$1

	while read _dev _rest; do
		[ "$_dev" = "$_root" ] && continue
		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
}

# Find LAST instance of DOMAIN or SEARCH and extract first domain name
# on that line as FQDN. Then ask user, just to be sure.
# $1 = resolv.conf file to search for FQDN
# $2 = hosts file to add FQDN information to
get_fqdn() {
	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 -n "$FQDN" ]; 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 [ -z "$resp" ] ; 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

	cat << __EOT

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

__EOT

	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 [ -z "$resp" ] ; then
		resp=none
		if [ -f /tmp/mygate ]; then
			resp=`cat /etc/mygate`
			if [ -z "$resp" ]; 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 [ -z "$resp" ] ; 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 "\nThe host table is as follows:\n"
		cat /tmp/hosts
	cat << __EOT

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

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.
__EOT
	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
}

finish_up() {
	# Get timezone info
	get_timezone

	echo -n "Making all device nodes (by running /dev/MAKEDEV all) ..."
	cd /mnt/dev
	sh MAKEDEV all
	echo "... done."
	cd /

	md_installboot ${ROOTDISK}

	populateusrlocal

	# XXXXX - what is this for?
	[ -x /mnt/${MODE}.site ] && /mnt/usr/sbin/chroot /mnt /${MODE}.site

	# Unmount filesystems, etc. Disable trap that would do same on exit.
	# Do this manually rather than through the trap so md_congrats is
	# the last message printed.
	trap - HUP INT QUIT TERM EXIT
	cleanup_on_exit

	# Pat on the back.
	md_congrats

	exit 0
}

########################################################################
#
# Initial actions common to both installs and upgrades.
#
# Some may require machine dependent routines, which may
# call functions defined above, so it's safest to put this
# code here rather than at the top of the file.
#
########################################################################

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

# Use install.md routines to get lists of devices on system
_DKDEVS=`md_get_diskdevs`
_CDDEVS=`md_get_cddevs`

# extra "site" set can be provided by person doing install or
# upgrade.
THESETS="base etc misc comp man game xbase xshare xfont xserv site $MDSETS"

# Global variable using during sets installation
local_sets_dir=
_sets=
_setsdone=
_osetsdone=
_get_files=

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

# Cleanup when the script exits.
trap 'cleanup_on_exit' EXIT
trap 'exit 2' HUP INT QUIT TERM

# Good {morning,afternoon,evening,night}.
echo
md_welcome_banner

if [ -f /etc/fstab -a "${MODE}" = "install" ]; then
	cat << __EOT
You seem to be trying to restart an interrupted installation!
You can skip the disk preparation steps and continue,
or you can reboot and start over.

__EOT
	echo -n "Skip disk initialization and p"
else
	echo -n "P"
fi
	
echo -n "roceed with ${MODE}? [n] "
getresp n
case $resp in
y*|Y*)	echo "\nCool!  Let's get to it...\n"
	;;
*)	md_not_going_to_install
	exit
	;;
esac

# Deal with terminal issues
md_set_term

cat << __EOT

At any prompt except password prompts you can run a shell command by
typing '!foo', or escape to a shell by typing '!'.
__EOT