#!/bin/sh
# $NetBSD: install.sub,v 1.66 2024/05/11 06:31:59 andvar Exp $
#
# Copyright (c) 1996 The NetBSD Foundation, Inc.
# All rights reserved.
#
# This code is derived from software contributed to The NetBSD Foundation
# by Jason R. Thorpe.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# NetBSD installation/upgrade script - common subroutines.
ROOTDISK="" # filled in below
MACHINE= # filled by distrib/miniroot/list
export MACHINE
VERSION=100 # updated by distrib/miniroot/list
export VERSION
RELEASE=10.0 # updated by distrib/miniroot/list
export RELEASE
ALLSETS="base comp etc games man misc modules rescue text" # default install sets
UPGRSETS="base comp games man misc modules rescue text" # default upgrade sets
THESETS= # one of the above
local_sets_dir="" # Path searched for sets by install_sets
# on the local filesystems
# decide upon an editor
if [ -z "$EDITOR" ]; then
if [ -x /usr/bin/vi ]; then
EDITOR=vi
else
EDITOR=ed
fi
fi
getresp() {
read resp
if [ -z "$resp" ]; then
resp=$1
fi
}
isin() {
# test the first argument against the remaining ones, return success on a match
_a=$1; shift
while [ $# != 0 ]; do
if [ "$_a" = "$1" ]; then return 0; fi
shift
done
return 1
}
rmel() {
# remove first argument from list formed by the remaining arguments
local _a
_a=$1; shift
while [ $# != 0 ]; do
if [ "$_a" != "$1" ]; then
echo "$1";
fi
shift
done
}
cutword () {
# read a line of data, return Nth element.
local _a
local _n
local _oifs
# optional field separator
_oifs="$IFS"
case "$1" in
-t?*) IFS=${1#-t}; shift;;
esac
_n=$1
read _a; set -- $_a
IFS="$_oifs"
if [ "$1" = "" ]; then return; fi
eval echo \$$_n
}
cutlast () {
# read a line of data, return last element. Equiv. of awk '{print $NF}'.
local _a
local _oifs
# optional field separator
_oifs="$IFS"
case "$1" in
-t?*) IFS=${1#-t}; shift;;
esac
read _a; set -- $_a
IFS="$_oifs"
if [ "$1" = "" ]; then return; fi
eval echo '"${'"$#"'}"'
}
firstchar () {
# return first character of argument
local _a
_a=$1
while [ ${#_a} != 1 ]; do
_a=${_a%?}
done
echo $_a
}
basename () {
local _oifs
if [ "$1" = "" ]; then return; fi
_oifs="$IFS"
IFS="/"
set -- $1
IFS="$_oifs"
eval echo '"${'"$#"'}"'
}
dir_has_sets() {
# return true when the directory $1 contains a set for $2...$n
local _dir
local _file
_dir=$1; shift
for _file in $*
do
if [ -f $_dir/${_file}.tar.gz ]; then
return 0
fi
# Try for stupid msdos convention
if [ -f $_dir/${_file}.tgz ]; then
return 0
fi
# Try for uncompressed files
if [ -f $_dir/${_file}.tar ]; then
return 0
fi
# Try for split files
if [ -f $_dir/${_file}${VERSION}.aa ]; then
return 0
fi
done
return 1
}
twiddle() {
# spin the propeller so we don't get bored
while : ; do
sleep 1; echo -n "/";
sleep 1; echo -n "-";
sleep 1; echo -n "\\";
sleep 1; echo -n "|";
done > /dev/tty & echo $!
}
get_localdir() {
# $1 is relative mountpoint
local _mp
local _dir
_mp=$1
_dir=
while : ; do
if [ -n "$_mp" ]; then
cat << __get_localdir_1
Note: your filesystems are mounted under the temporary mount point \"$_mp\".
The pathname you are requested to enter below should NOT include the \"$_mp\"
prefix.
__get_localdir_1
fi
echo -n "Enter the pathname where the sets are stored [$_dir] "
getresp "$_dir"
_dir=$resp
# Allow break-out with empty response
if [ -z "$_dir" ]; then
echo -n "Are you sure you don't want to set the pathname? [n] "
getresp "n"
case "$resp" in
y*|Y*)
break
;;
*)
continue
;;
esac
fi
if dir_has_sets "$_mp/$_dir" $THESETS
then
local_sets_dir="$_mp/$_dir"
break
else
cat << __get_localdir_2
The directory \"$_mp/$_dir\" does not exist, or does not hold any of the
upgrade sets.
__get_localdir_2
echo -n "Re-enter pathname? [y] "
getresp "y"
case "$resp" in
y*|Y*)
;;
*)
local_sets_dir=""
break
;;
esac
fi
done
}
getrootdisk() {
cat << \__getrootdisk_1
The installation program needs to know which disk to consider
the root disk. Note the unit number may be different than
the unit number you used in the standalone installation
program.
Available disks are:
__getrootdisk_1
_DKDEVS=$(md_get_diskdevs)
echo "$_DKDEVS"
echo ""
echo -n "Which disk is the root disk? "
getresp ""
if isin $resp $_DKDEVS ; then
ROOTDISK="$resp"
else
echo ""
echo "The disk $resp does not exist."
ROOTDISK=""
fi
}
labelmoredisks() {
cat << \__labelmoredisks_1
You may label the following disks:
__labelmoredisks_1
echo "$_DKDEVS"
echo ""
echo -n "Label which disk? [done] "
getresp "done"
case "$resp" in
"done")
;;
*)
if isin $resp $_DKDEVS ; then
md_labeldisk $resp
else
echo ""
echo "The disk $resp does not exist."
fi
;;
esac
}
addhostent() {
# $1 - IP address
# $2 - symbolic name
local fqdn
# Create an entry in the hosts table. If no host table
# exists, create one. If the IP address already exists,
# replace its entry.
if [ ! -f /tmp/hosts ]; then
echo "127.0.0.1 localhost" > /tmp/hosts
fi
sed "/^$1 /d" < /tmp/hosts > /tmp/hosts.new
mv /tmp/hosts.new /tmp/hosts
if [ -n "${FQDN}" ]; then
fqdn=$2.$FQDN
fi
echo "$1 $2 $fqdn" >> /tmp/hosts
}
addifconfig() {
# $1 - interface name
# $2 - interface symbolic name
# $3 - interface IP address
# $4 - interface netmask
# $5 - (optional) interface link-layer medium, preceded by "media ", else ""
# $6 - (optional) interface link-layer directives
local _m
# Create a ifconfig.* file for the interface.
echo "inet $2 netmask $4 $5 $6" > /tmp/ifconfig.$1
_ifsdone=""
resp="" # force at least one iteration
while [ "${resp}" != "done" ]; do
cat << \__configurenetwork_1
You may configure the following network interfaces (the interfaces
marked with [X] have been successfully configured):
__configurenetwork_1
for _ifs in $_IFS; do
if isin $_ifs $_ifsdone ; then
echo -n "[X] "
else
echo -n " "
fi
echo $_ifs
done
echo ""
echo -n "Configure which interface? [done] "
getresp "done"
case "$resp" in
"done")
;;
*)
_ifs=$resp
if isin $_ifs $_IFS ; then
if configure_ifs $_ifs ; then
_ifsdone="$_ifs $_ifsdone"
fi
else
echo "Invalid response: \"$resp\" is not in list"
fi
;;
esac
done
}
configure_ifs() {
local _up
local _interface_name
local _interface_ip
local _interface_mask
local _interface_symname
local _interface_extra
local _interface_mediumtype
local _interface_supported_media
local _m
local _t
_interface_name=$1
_up=DOWN
if isin $_interface_name $(ifconfig -l -u); then
_up=UP
fi
# get current "media" "ip" and "netmask" ("broadcast")
_t=$(ifconfig $_interface_name | sed -n '
s/^[ ]*media: [^ ]* \([^ ][^ ]*\).*/\1/p')
if [ "$_t" != "manual" ] && [ "$_t" != "media:" ] && [ "$_t" != "autoselect" ];
then
_interface_mediumtype=$1
fi
set -- $(ifconfig $_interface_name | sed -n '
/^[ ]*inet /{
s/inet//
s,/[0-9]*,,
s/--> [0-9.][0-9.]*//
s/netmask//
s/broadcast//
p;}')
_interface_ip=$1
_interface_mask=$2
# Get IP address
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "IP address? [$_interface_ip] "
getresp "$_interface_ip"
_interface_ip=$resp
done
# Get symbolic name
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Symbolic (host) name? "
getresp ""
_interface_symname=$resp
done
# Get netmask
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Netmask? [$_interface_mask] "
getresp "$_interface_mask"
_interface_mask=$resp
done
echo "Your network interface might require explicit selection"
echo "of the type of network medium attached. Supported media:"
echo "$_interface_supported_media"
echo -n "Additional media type arguments (none)? [$_interface_mediumtype] "
getresp "$_interface_mediumtype"
_m=""
if [ "${resp:-none}" != "none" ]; then
_interface_mediumtype=$resp
_m="media ${resp}"
fi
echo "Your network interface might require additional link-layer"
echo "directives (like 'link0'). If this is the case you can enter"
echo "these at the next prompt."
echo ""
echo -n "Additional link-layer arguments (none)? [$_interface_extra] "
getresp "$_interface_extra"
if [ "${resp:-none}" != "none" ]; then
_interface_extra=$resp
fi
# Configure the interface. If it
# succeeds, add it to the permanent
# network configuration info.
if [ $_up != "UP" ]; then
ifconfig ${_interface_name} down
if ifconfig ${_interface_name} inet \
${_interface_ip} \
netmask ${_interface_mask} \
${_interface_extra} ${_m} up ; then
addifconfig \
"${_interface_name}" \
"${_interface_symname}" \
"${_interface_ip}" \
"${_interface_mask}" \
"${_m}" \
"${_interface_extra}"
return 0
fi
else
echo "Interface ${_interface_name} is already active."
echo "Just saving configuration on new root filesystem."
addifconfig \
"${_interface_name}" \
"${_interface_symname}" \
"${_interface_ip}" \
"${_interface_mask}" \
"${_m}" \
"${_interface_extra}"
fi
return 1
}
# Much of this is gratuitously stolen from /etc/rc.d/network.
enable_network() {
# Set up the hostname.
if [ -f /mnt/etc/myname ]; then
hostname=$(cat /mnt/etc/myname)
elif [ -f /mnt/etc/rc.conf ];then
hostname=$(sh -c '. /mnt/etc/rc.conf ; echo $hostname')
else
echo "ERROR: no /etc/myname!"
return 1
fi
if [ -z "$hostname" ];then
echo "ERROR: hostname not set in /etc/myname or /etc/rc.conf!"
return 1
fi
hostname $hostname
# configure all the interfaces which we know about.
if [ -f /mnt/etc/rc.conf ]; then
(
# assume network interface configuration style 1.2D and up
if [ -f /mnt/etc/defaults/rc.conf ]; then
. /mnt/etc/defaults/rc.conf
fi
. /mnt/etc/rc.conf
if [ "$net_interfaces" != NO ]; then
if [ "$auto_ifconfig" = YES ]; then
tmp="$(ifconfig -l)"
else
tmp="$net_interfaces"
fi
echo -n "configuring network interfaces:"
for i in $tmp; do
eval $(echo 'args=$ifconfig_'$i)
if [ -n "$args" ]; then
echo -n " $i"
ifconfig $i $args
elif [ -f /mnt/etc/ifconfig.$i ]; then
echo -n " $i"
(while read args; do
ifconfig $i $args
done) < /mnt/etc/ifconfig.$i
elif [ "$auto_ifconfig" != YES ]; then
echo
echo -n "/mnt/etc/ifconfig.$i missing"
echo -n "& ifconfig_$i not set"
echo "; interface $i can't be configured"
fi
done
echo "."
fi
)
else
(
tmp="$IFS"
IFS="$IFS."
set -- $(echo /mnt/etc/hostname*)
IFS=$tmp
unset tmp
while [ $# -ge 2 ] ; do
shift # get rid of "hostname"
(
read af name mask bcaddr extras
read dt dtaddr
if [ -z "$name" ]; then
echo "/etc/hostname.$1: invalid network configuration file"
exit
fi
cmd="ifconfig $1 $af $name "
if [ "${dt}" = "dest" ]; then cmd="$cmd $dtaddr"; fi
if [ -n "$mask" ]; then cmd="$cmd netmask $mask"; fi
if [ "${bcaddr:-NONE}" != "NONE" ]; then
cmd="$cmd broadcast $bcaddr";
fi
cmd="$cmd $extras"
$cmd
) < /mnt/etc/hostname.$1
shift
done
)
fi
# set the address for the loopback interface
ifconfig lo0 inet localhost
# use loopback, not the wire
route add $hostname localhost
# /etc/mygate, if it exists, contains the name of my gateway host
# that name must be in /etc/hosts.
if [ -f /mnt/etc/mygate ]; then
route delete default > /dev/null 2>&1
route add default $(cat /mnt/etc/mygate)
fi
# enable the resolver, if appropriate.
if [ -f /mnt/etc/resolv.conf ]; then
_resolver_enabled="TRUE"
cp /mnt/etc/resolv.conf /tmp/resolv.conf.shadow
fi
# Display results...
echo "Network interface configuration:"
ifconfig -a
echo ""
if [ "${_resolver_enabled:-FALSE}" = "TRUE" ]; then
echo "Resolver enabled."
else
echo "Resolver not enabled."
fi
return 0
}
install_ftp() {
local _f
local _sets
local _next
# Build a script to extract valid files from a list
# of filenames on stdin.
# XXX : Can we use this on more places? Leo.
# Get several parameters from the user, and create
# a shell script that directs the appropriate
# commands into ftp.
cat << \__install_ftp_1
This is an automated ftp-based installation process. You will be asked
several questions. The correct set of commands will be placed in a script
that will be fed to ftp(1).
__install_ftp_1
# Get server IP address
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Server IP? [${_ftp_server_ip}] "
getresp "${_ftp_server_ip}"
_ftp_server_ip=$resp
done
# Get login name
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Login? [${_ftp_server_login}] "
getresp "${_ftp_server_login}"
_ftp_server_login=$resp
done
# Get password
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Password? "
stty -echo
getresp ""
echo ""
stty echo
_ftp_server_password=$resp
done
cat << \__install_ftp_2
You will be asked to enter the name of the directory that contains the
installation sets. When you enter a '?' you will see a listing of the
current directory on the server.
__install_ftp_2
echo ""
echo "The default installation directory in the official ftp server is:"
echo "/pub/NetBSD/NetBSD-${RELEASE}/${MACHINE}/binary/sets"
_sets=""
while [ -z "$_sets" ]
do
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Server directory? [${_ftp_server_dir}] "
getresp "${_ftp_server_dir}"
if [ -z "$resp" ] && [ -z "$_ftp_server_dir" ]; then
resp=""
fi
done
if [ $resp != '?' ]; then
_ftp_server_dir=$resp
fi
# Make a copy of this script that lists the directory
# contents, and use that to determine the files to get.
cat /tmp/ftp-script.sh > /tmp/ftp-dir.sh
echo "nlist" >> /tmp/ftp-dir.sh
echo "quit" >> /tmp/ftp-dir.sh
echo "__end_commands" >> /tmp/ftp-dir.sh
if [ $resp = '?' ]; then
sh /tmp/ftp-dir.sh
else
_sets=$(sh /tmp/ftp-dir.sh | sort -u | sh /tmp/fname_filter.sh)
fi
done
rm -f /tmp/ftp-dir.sh /tmp/fname_filter.sh
rm -f /tmp/ftp-script.sh
while : ; do
echo "The following sets are available for extraction:"
echo "(marked sets are already on the extraction list)"
echo ""
_next=""
for _f in $_sets ; do
if isin $_f $_setsdone; then
echo -n "[X] "
_next=""
else
echo -n " "
if [ -z "$_next" ]; then _next=$_f; fi
fi
echo $_f
done
echo ""
# Get name of the file and add extraction command
# to the ftp-fetch script.
if [ -z "$_next" ]; then resp=n; else resp=y; fi
echo -n "Continue to add filenames [$resp]? "
getresp "$resp"
if [ "$resp" = "n" ]; then
break
fi
sh /tmp/ftp-fetch.sh
rm -f /tmp/ftp-fetch.sh
echo "Extraction complete."
}
install_from_mounted_fs() {
# $1 - directory containing installation sets
local _filename
local _sets
local _next
local _all
local _f
local _dirname
_dirname=$1
_sets=""
if ! dir_has_sets ${_dirname} $THESETS
then
echo ""
echo "The directory at the mount point, \"${_dirname}\", contains: "
echo ""
ls -F ${_dirname}
echo ""
echo "Enter the subdirectory relative to the mountpoint, that"
echo -n "contains the savesets: [try this directory] "
getresp ""
if [ -n "${resp}" ]; then
_dirname=${_dirname}/$resp
fi
while ! dir_has_sets ${_dirname} $THESETS; do
echo ""
echo -n "There are no NetBSD install sets available in "
echo "\"${_dirname}\"."
echo "\"${_dirname}\" contains: "
echo ""
ls -F ${_dirname}
echo ""
echo -n "Enter subdirectory: [try other install media] "
getresp ""
if [ -z "${resp}" ]; then
return
fi
if [ ! -d ${_dirname}/${resp} ]; then
echo "\"${resp}\" is no directory; try again."
else
_dirname=${_dirname}/$resp
fi
done
fi
for _f in $THESETS ; do
if [ -f ${_dirname}/${_f}.tar.gz ]; then
_sets="$_sets ${_f}.tar.gz"
elif [ -f ${_dirname}/${_f}.tgz ]; then
_sets="$_sets ${_f}.tgz"
elif [ -f ${_dirname}/${_f}.tar ]; then
_sets="$_sets ${_f}.tar"
elif [ -f ${_dirname}/${_f}${VERSION}.aa ]; then
_sets="$_sets ${_f}${VERSION}"
fi
done
while : ; do
echo "The following sets are available for extraction:"
echo "(marked sets have already been extracted)"
echo ""
_next=""
_all=""
for _f in $_sets ; do
if isin $_f $_setsdone; then
echo -n "[X] "
_next=""
else
echo -n " "
if [ -z "$_next" ]; then
_next=$_f;
fi
_all="$_all $_f"
fi
echo $_f
done
echo ""
# Get the name of the file.
if [ -z "$_next" ]; then
resp=n
else
resp=y
fi
echo -n "Continue extraction [$resp]?"
getresp "$resp"
if [ "$resp" = "n" ]; then
break
fi
echo -n "File name(s) (or "all") [$_next]? "
getresp "$_next"
if [ "x$resp" = xall ]; then
resp="$_all"
fi
for _f in $resp; do
_filename="/${_dirname}/$_f"
# Ensure file exists
if [ ! -f $_filename ]; then
if [ -f ${_filename}.aa ]; then
_filename=${_filename}.\?\?
else
echo "File $_filename does not exist. Check to make"
echo "sure you entered the information properly."
continue 2
fi
fi
install_cdrom() {
local _drive
local _partition_range
local _partition
local _fstype
local _directory
# Get the cdrom device info
cat << \__install_cdrom_1
The following CD-ROM devices are installed on your system; please select
the CD-ROM device containing the partition with the installation sets:
__install_cdrom_1
_CDDEVS=$(md_get_cddevs)
echo "$_CDDEVS"
echo ""
echo -n "Which is the CD-ROM with the installation media? [abort] "
getresp "abort"
case "$resp" in
abort)
echo "Aborting."
return
;;
*)
if isin $resp $_CDDEVS ; then
_drive=$resp
else
echo ""
echo "The CD-ROM $resp does not exist."
echo "Aborting."
return
fi
;;
esac
# Get partition
_partition_range=$(md_get_partition_range)
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Partition? [a] "
getresp "a"
case "$resp" in
$_partition_range)
_partition=$resp
;;
*)
echo "Invalid response: $resp"
resp="" # force loop to repeat
;;
esac
done
# Ask for filesystem type
cat << \__install_cdrom_2
There are two CD-ROM filesystem types currently supported by this program:
1) ISO-9660 (cd9660)
2) Berkeley Fast Filesystem (ffs)
__install_cdrom_2
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Which filesystem type? [cd9660] "
getresp "cd9660"
case "$resp" in
cd9660|ffs)
_fstype=$resp
;;
*)
echo "Invalid response: $resp"
resp="" # force loop to repeat
;;
esac
done
# Mount the CD-ROM
if ! mount -t ${_fstype} -o ro \
/dev/${_drive}${_partition} /mnt2 ; then
echo "Cannot mount CD-ROM drive. Aborting."
return
fi
mount_a_disk() {
# Mount a disk on /mnt2. The set of disk devices to choose from
# is $_DKDEVS.
# returns 0 on failure.
local _drive
local _partition_range
local _partition
local _fstype
local _fsopts
local _directory
local _md_fstype
local _md_fsopts
getresp "abort"
case "$resp" in
abort)
echo "Aborting."
return 0
;;
*)
if isin $resp $_DKDEVS ; then
_drive=$resp
else
echo ""
echo "The disk $resp does not exist."
echo "Aborting."
return 0
fi
;;
esac
# Get partition
_partition_range=$(md_get_partition_range)
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Partition? [d] "
getresp "d"
case "$resp" in
$_partition_range)
_partition=$resp
;;
*)
echo "Invalid response: $resp"
resp="" # force loop to repeat
;;
esac
done
# Ask for filesystem type
cat << \__mount_a_disk_2
The following filesystem types are supported:
1) ffs
2) cd9660
__mount_a_disk_2
_md_fstype=$(md_native_fstype)
_md_fsopts=$(md_native_fsopts)
if [ -n "$_md_fstype" ]; then
echo " 3) $_md_fstype"
else
_md_fstype="_undefined_"
fi
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Which filesystem type? [ffs] "
getresp "ffs"
case "$resp" in
ffs|cd9660)
_fstype=$resp
_fsopts="ro"
;;
$_md_fstype)
_fstype=$resp
_fsopts=$_md_fsopts
;;
*)
echo "Invalid response: $resp"
resp="" # force loop to repeat
;;
esac
done
# Mount the disk
if ! mount -t ${_fstype} -o $_fsopts \
/dev/${_drive}${_partition} /mnt2 ; then
echo "Cannot mount disk. Aborting."
return 0
fi
return 1
}
install_disk() {
local _directory
cat << \__install_disk_1
Ok, lets install from a disk. The file-system the install sets on may
already mounted, or we might have to mount the filesystem to get to it.
__install_disk_1
echo -n "Is the file-system with the install sets already mounted? [n] "
getresp "n"
case $resp in
y*|Y*)
echo "What mount point are the sets located in? [] "
getresp ""
if [ -d "$resp" ]; then
install_from_mounted_fs $resp
else
echo "$resp: Not a directory, aborting..."
fi
return
;;
*)
;;
esac
cat << \__install_disk_2
The following disk devices are installed on your system; please select
the disk device containing the partition with the installation sets:
__install_disk_2
_DKDEVS=$(md_get_diskdevs)
echo "$_DKDEVS"
echo ""
echo -n "Which is the disk with the installation sets? [abort] "
install_nfs() {
# Get the IP address of the server
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Server IP address? [${_nfs_server_ip}] "
getresp "${_nfs_server_ip}"
done
_nfs_server_ip=$resp
# Get server path to mount
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Filesystem on server to mount? [${_nfs_server_path}] "
getresp "${_nfs_server_path}"
done
_nfs_server_path=$resp
# Check mount_nfs(8) options
echo "Use small NFS transfers (needed when server or client"
echo -n "has a slow network card)? [n] "
getresp "n"
case "$resp" in
y*|Y*)
_nfs_tcp="-r 1024 -w 1024"
;;
*)
_nfs_tcp=""
;;
esac
# 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 name of the tape from the user.
cat << \__install_tape_1
The installation program needs to know which tape device to use. Make
sure you use a "no rewind on close" device.
__install_tape_1
_tape=$(basename $TAPE)
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Name of tape device? [${_tape}]"
getresp "${_tape}"
done
_tape=$(basename $resp)
TAPE="/dev/${_tape}"
if [ ! -c $TAPE ]; then
echo "$TAPE does not exist or is not a character special file."
echo "Aborting."
return
fi
export TAPE
# Rewind the tape device
echo -n "Rewinding tape..."
if ! mt rewind ; then
echo "$TAPE may not be attached to the system or may not be"
echo "a tape device. Aborting."
return
fi
echo "done."
# Get the file number
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "File number? "
getresp ""
case "$resp" in
[1-9]*)
_nskip=$(expr $resp - 1)
;;
*)
echo "Invalid file number ${resp}."
resp="" # fore loop to repeat
;;
esac
done
# Skip to correct file.
echo -n "Skipping to source file..."
if [ "${_nskip}" != "0" ]; then
if ! mt fsf $_nskip ; then
echo "Could not skip $_nskip files. Aborting."
return
fi
fi
echo "done."
cat << \__install_tape_2
There are 2 different ways the file can be stored on tape:
1) an image of a gzipped tar file
2) a standard tar image
__install_tape_2
resp="" # force one iteration
while [ -z "${resp}" ]; do
echo -n "Which way is it? [1] "
getresp "1"
case "$resp" in
1)
_xcmd="pax -zr${verbose_flag}pe"
;;
2)
_xcmd="pax -r${verbose_flag}pe"
;;
*)
echo "Invalid response: $resp."
resp="" # force loop to repeat
;;
esac
( cd /mnt; dd if=$TAPE | $_xcmd )
done
echo "Extraction complete."
}
get_timezone() {
local _a
local _zonepath
#
# If the zoneinfo is not on the installation medium or on the
# installed filesystem, set TZ to GMT and return immediately.
#
if [ ! -e /usr/share/zoneinfo ] && [ ! -e /mnt/usr/share/zoneinfo ]; then
TZ=GMT
return
fi
if [ ! -d /usr/share/zoneinfo ]; then
_zonepath=/mnt
else
_zonepath=""
fi
cat << \__get_timezone_1
Select a time zone for your location. Timezones are represented on the
system by a directory structure rooted in "/usr/share/zoneinfo". Most
timezones can be selected by entering a token like "MET" or "GMT-6".
Other zones are grouped by continent, with detailed zone information
separated by a slash ("/"), e.g. "US/Pacific".
To get a listing of what's available in /usr/share/zoneinfo, enter "?"
at the prompts below.
__get_timezone_1
if [ -z "$TZ" ]; then
TZ=$(ls -l /mnt/etc/localtime 2>/dev/null | cutlast)
TZ=${TZ#/usr/share/zoneinfo/}
fi
while :; do
echo -n "What timezone are you in ['?' for list] [$TZ]? "
getresp "$TZ"
case "$resp" in
"")
echo "Timezone defaults to GMT"
TZ="GMT"
break;
;;
"?")
ls ${_zonepath}/usr/share/zoneinfo
;;
*)
_a=$resp
while [ -d ${_zonepath}/usr/share/zoneinfo/$_a ]; do
echo -n "There are several timezones available"
echo " within zone '$_a'"
echo -n "Select a sub-timezone ['?' for list]: "
getresp ""
case "$resp" in
"?") ls ${_zonepath}/usr/share/zoneinfo/$_a ;;
*) _a=${_a}/${resp}
if [ -f ${_zonepath}/usr/share/zoneinfo/$_a ]; then
break;
fi
;;
esac
done
if [ -f ${_zonepath}/usr/share/zoneinfo/$_a ]; then
TZ="$_a"
echo "You have selected timezone \"$_a\"".
break 2
fi
echo "'/usr/share/zoneinfo/$_a' is not a valid timezone on this system."
;;
esac
done
}
install_sets()
{
local _yup
_yup="FALSE"
# Ask the user which media to load the distribution from.
# Ask the user if they want verbose extraction. They might not want
# it on, eg, SPARC frame buffer console.
cat << \__install_sets_1
It is now time to extract the installation sets onto the hard disk.
Make sure the sets are either on a local device (i.e. tape, CD-ROM) or on a
network server.
Would you like to see each file listed during extraction (verbose) mode?
On some console hardware, such as serial consoles and Sun frame buffers,
this can extend the total extraction time.
__install_sets_1
echo -n "Use verbose listing for extractions? [y] "
getresp "y"
case "$resp" in
y*|Y*)
verbose_flag=v
;;
*)
echo "Not using verbose listing."
verbose_flag=""
;;
esac
if [ -d ${Default_sets_dir:-/dev/null} ]; then
if dir_has_sets $Default_sets_dir $THESETS; then
local_sets_dir=$Default_sets_dir
fi
fi
if [ -n "${local_sets_dir}" ]; then
install_from_mounted_fs ${local_sets_dir}
if [ -n "$_setsdone" ]; then
_yup="TRUE"
fi
fi
# Go on prodding for alternate locations
resp="" # force at least one iteration
while [ -z "${resp}" ]; do
# If _yup is not FALSE, it means that we extracted sets above.
# If that's the case, bypass the menu the first time.
if [ "${_yup}" = "FALSE" ]; then
echo -n "Install from (f)tp, (t)ape, (C)D-ROM, (N)FS"
echo -n " or local (d)isk? "
getresp ""
case "$resp" in
d*|D*)
install_disk
;;
f*|F*)
install_ftp
;;
t*|T*)
install_tape
;;
c*|C*)
install_cdrom
;;
n*|N*)
install_nfs
;;
*)
echo "Invalid response: $resp"
resp=""
;;
esac
else
_yup="FALSE" # So we'll ask next time
fi
# Give the user the opportunity to extract more sets. They
# don't necessarily have to come from the same media.
echo ""
echo -n "Extract more sets? [n] "
getresp "n"
case "$resp" in
y*|Y*)
# Force loop to repeat
resp=""
;;
*)
;;
esac
done
}
munge_fstab()
{
local _fstab
local _fstab_shadow
local _dev
local _mp
local _fstype
local _rest
# Now that the 'real' fstab is configured, we munge it into a 'shadow'
# fstab which we'll use for mounting and unmounting all of the target
# filesystems relative to /mnt. Mount all filesystems.
_fstab=$1
_fstab_shadow=$2
( while read _dev _mp _fstype _rest; do
# Skip comment lines
case "$_dev" in
\#*) continue;;
*) ;;
esac
# and some filesystem types (like there are swap,kernfs,...)
case "$_fstype" in
ffs|ufs|nfs) ;;
*) continue;;
esac
if [ "$_mp" = "/" ]; then
echo $_dev /mnt $_fstype $_rest
else
echo $_dev /mnt$_mp $_fstype $_rest
fi
done ) < $_fstab > $_fstab_shadow
}
mount_fs()
{
# Must mount filesystems manually, one at a time, so we can make
# sure the mount points exist.
# $1 is a file in fstab format
local _fstab
_fstab=$1
( while read line; do
set -- $line
_dev=$1
_mp=$2
_fstype=$3
_opt=$4
# If not the root filesystem, make sure the mount
# point is present.
if [ "$_mp" != "/mnt" ]; then
mkdir -p $_mp
fi
# Mount the filesystem. If the mount fails, exit
# with an error condition to tell the outer
# later to bail.
if ! mount -v -t $_fstype -o async -o $_opt $_dev $_mp ; then
# error message displayed by mount
exit 1
fi
done ) < $_fstab
if [ "$?" != "0" ]; then
cat << \__mount_filesystems_1
FATAL ERROR: Cannot mount filesystems. Double-check your configuration
and restart the installation process.
__mount_filesystems_1
exit
fi
}
unmount_fs()
{
# Unmount all filesystems and check their integrity.
# Usage: [-fast] <fstab file>
local _fast
local _fstab
local _pid
if [ "$1" = "-fast" ]; then
_fast=1
_fstab=$2
else
_fast=0
_fstab=$1
fi
if ! [ -f "${_fstab}" ] || ! [ -s "${_fstab}" ]; then
echo "fstab empty" > /dev/tty
return
fi
if [ $_fast = 0 ]; then
echo -n "Syncing disks..."
_pid=$(twiddle)
sync; sleep 4; sync; sleep 2; sync; sleep 2
kill $_pid
echo "done."
fi
(
_devs=""
_mps=""
# maintain reverse order
while read line; do
set -- $line
_devs="$1 ${_devs}"
_mps="$2 ${_mps}"
done
echo -n "Unmounting filesystems... "
for _mp in ${_mps}; do
echo -n "${_mp} "
umount ${_mp}
done
echo "Done."
if [ $_fast = 0 ]; then
exit
fi
echo "Checking filesystem integrity..."
for _dev in ${_devs}; do
echo "${_dev}"
fsck -f ${_dev}
done
echo "Done."
) < $_fstab
}
check_fs()
{
# Check filesystem integrity.
# $1 is a file in fstab format
local _fstab
_fstab=$1
(
_devs=""
_mps=""
while read line; do
set -- $line
_devs="$1 ${_devs}"
_mps="$2 ${_mps}"
done
echo "Checking filesystem integrity..."
for _dev in ${_devs}; do
echo "${_dev}"
fsck -f ${_dev}
done
echo "Done."
) < $_fstab
}
mi_mount_kernfs() {
# Make sure kernfs is mounted.
if [ ! -d /kern ] || [ ! -e /kern/msgbuf ]; then
mkdir /kern > /dev/null 2>&1
/sbin/mount_kernfs /kern /kern
fi
}
