1208 lines
25 KiB
Bash
1208 lines
25 KiB
Bash
#!/bin/sh
|
||
# $NetBSD: install.sub,v 1.6 1996/05/27 12:39:04 leo 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.
|
||
# 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.
|
||
#
|
||
|
||
# NetBSD installation/upgrade script - common subroutines.
|
||
|
||
ROOTDISK="" # filled in below
|
||
|
||
ALLSETS="base comp etc games man misc text" # default install sets
|
||
UPGRSETS="base comp games man misc text" # default upgrade sets
|
||
|
||
getresp() {
|
||
read resp
|
||
if [ "X$resp" = "X" ]; then
|
||
resp=$1
|
||
fi
|
||
}
|
||
|
||
isin() {
|
||
# test the first argument against the remaining ones, return succes on a match
|
||
_a=$1; shift
|
||
while [ $# != 0 ]; do
|
||
if [ "$_a" = "$1" ]; then return 0; fi
|
||
shift
|
||
done
|
||
return 1
|
||
}
|
||
|
||
rmel() {
|
||
# remove first argument from list formed by the remaining arguments
|
||
local _a
|
||
|
||
_a=$1; shift
|
||
while [ $# != 0 ]; do
|
||
if [ "$_a" != "$1" ]; then
|
||
echo "$1";
|
||
fi
|
||
shift
|
||
done
|
||
}
|
||
|
||
cutword () {
|
||
# read a line of data, return Nth element.
|
||
local _a
|
||
local _n
|
||
local _oifs
|
||
|
||
# optional field separator
|
||
_oifs="$IFS"
|
||
case "$1" in
|
||
-t?*) IFS=${1#-t}; shift;;
|
||
esac
|
||
|
||
_n=$1
|
||
read _a; set -- $_a
|
||
IFS="$_oifs"
|
||
if [ "$1" = "" ]; then return; fi
|
||
eval echo \$$_n
|
||
}
|
||
|
||
cutlast () {
|
||
# read a line of data, return last element. Equiv. of awk '{print $NF}'.
|
||
local _a
|
||
local _oifs
|
||
|
||
# optional field separator
|
||
_oifs="$IFS"
|
||
case "$1" in
|
||
-t?*) IFS=${1#-t}; shift;;
|
||
esac
|
||
|
||
read _a; set -- $_a
|
||
IFS="$_oifs"
|
||
if [ "$1" = "" ]; then return; fi
|
||
while [ "$#" -gt 10 ]; do shift 10; done
|
||
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"
|
||
while [ "$#" -gt 10 ]; do shift 10; done
|
||
eval echo \$$#
|
||
}
|
||
|
||
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 $!
|
||
}
|
||
|
||
do_mfs_mount() {
|
||
# $1 is the mount point
|
||
# $2 is the size in DEV_BIZE blocks
|
||
|
||
umount $1 > /dev/null 2>&1
|
||
if ! mount_mfs -s $2 swap $1 ; then
|
||
cat << \__mfs_failed_1
|
||
|
||
FATAL ERROR: Can't mount the memory filesystem.
|
||
|
||
__mfs_failed_1
|
||
exit
|
||
fi
|
||
|
||
# Bleh. Give mount_mfs a chance to DTRT.
|
||
sleep 2
|
||
}
|
||
|
||
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
|
||
|
||
# Create an entry in the hosts table. If no host table
|
||
# exists, create one. If the IP address already exists,
|
||
# replace it's 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
|
||
|
||
echo "$1 $2 $2.$FQDN" >> /tmp/hosts
|
||
}
|
||
|
||
addifconfig() {
|
||
# $1 - interface name
|
||
# $2 - interface symbolic name
|
||
# $3 - interface IP address
|
||
# $4 - interface netmask
|
||
|
||
# Create a hostname.* file for the interface.
|
||
echo "inet $2 $4" > /tmp/hostname.$1
|
||
|
||
addhostent $3 $2
|
||
}
|
||
|
||
configurenetwork() {
|
||
local _ifsdone
|
||
local _ifs
|
||
|
||
_IFS=`md_get_ifdevs`
|
||
_ifsdone=""
|
||
resp="" # force at least one iteration
|
||
while [ "X${resp}" != X"done" ]; do
|
||
cat << \__configurenetwork_1
|
||
|
||
You may configure the following network interfaces (the interfaces
|
||
marked with [X] have been succesfully 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() {
|
||
|
||
_interface_name=$1
|
||
|
||
# Get IP address
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "IP address? "
|
||
getresp ""
|
||
_interface_ip=$resp
|
||
done
|
||
|
||
# Get symbolic name
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Symbolic (host) name? "
|
||
getresp ""
|
||
_interface_symname=$resp
|
||
done
|
||
|
||
# Get netmask
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Netmask? "
|
||
getresp ""
|
||
_interface_mask=$resp
|
||
done
|
||
|
||
# Configure the interface. If it
|
||
# succeeds, add it to the permanent
|
||
# network configuration info.
|
||
ifconfig ${_interface_name} down
|
||
if ifconfig ${_interface_name} inet \
|
||
${_interface_ip} \
|
||
netmask ${_interface_mask} up ; then
|
||
addifconfig \
|
||
${_interface_name} \
|
||
${_interface_symname} \
|
||
${_interface_ip} \
|
||
${_interface_mask}
|
||
return 0
|
||
fi
|
||
return 1
|
||
}
|
||
|
||
# Much of this is gratuitously stolen from /etc/netstart.
|
||
enable_network() {
|
||
|
||
# Set up the hostname.
|
||
if [ ! -f /mnt/etc/myname ]; then
|
||
echo "ERROR: no /etc/myname!"
|
||
return 1
|
||
fi
|
||
hostname=`cat /mnt/etc/myname`
|
||
hostname $hostname
|
||
|
||
# configure all the interfaces which we know about.
|
||
(
|
||
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 [ ! -n "$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 [ -n "$bcaddr" -a "X$bcaddr" != "XNONE" ]; then
|
||
cmd="$cmd broadcast $bcaddr";
|
||
fi
|
||
cmd="$cmd $extras"
|
||
|
||
$cmd
|
||
) < /mnt/etc/hostname.$1
|
||
shift
|
||
done
|
||
)
|
||
|
||
# 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 [ "X${_resolver_enabled}" = X"TRUE" ]; then
|
||
netstat -r
|
||
echo ""
|
||
echo "Resolver enabled."
|
||
else
|
||
netstat -rn
|
||
echo ""
|
||
echo "Resolver not enabled."
|
||
fi
|
||
|
||
return 0
|
||
}
|
||
|
||
install_ftp() {
|
||
# 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 [ "X${resp}" = X"" ]; do
|
||
echo -n "Server IP? [${_ftp_server_ip}] "
|
||
getresp "${_ftp_server_ip}"
|
||
_ftp_server_ip=$resp
|
||
done
|
||
|
||
# Get server directory
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Server directory? [${_ftp_server_dir}] "
|
||
getresp "${_ftp_server_dir}"
|
||
_ftp_server_dir=$resp
|
||
done
|
||
|
||
# Get login name
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Login? [${_ftp_server_login}] "
|
||
getresp "${_ftp_server_login}"
|
||
_ftp_server_login=$resp
|
||
done
|
||
|
||
# Get password
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Password? [${_ftp_server_password}] "
|
||
getresp "${_ftp_server_password}"
|
||
_ftp_server_password=$resp
|
||
done
|
||
|
||
# Get list of files for mget.
|
||
cat << \__install_ftp_2
|
||
|
||
You will now be asked for files to extract. Enter one file at a time.
|
||
When you are done entering files, enter 'done'.
|
||
|
||
__install_ftp_2
|
||
echo "#!/bin/sh" > /tmp/ftp-script.sh
|
||
echo "cd /mnt" >> /tmp/ftp-script.sh
|
||
echo "ftp -i -n $_ftp_server_ip << \__end_commands" >> \
|
||
/tmp/ftp-script.sh
|
||
echo "user $_ftp_server_login $_ftp_server_password" >> \
|
||
/tmp/ftp-script.sh
|
||
echo "bin" >> /tmp/ftp-script.sh
|
||
echo "cd $_ftp_server_dir" >> /tmp/ftp-script.sh
|
||
|
||
resp="" # force one interation
|
||
while [ "X${resp}" != X"done" ]; do
|
||
echo -n "File? [done] "
|
||
getresp "done"
|
||
if [ "X${resp}" = X"done" ]; then
|
||
break
|
||
fi
|
||
|
||
_ftp_file=`echo ${resp} | cutword 1'`
|
||
echo "get ${_ftp_file} |\"tar --unlink -zxvpf -\"" >> \
|
||
/tmp/ftp-script.sh
|
||
done
|
||
|
||
echo "quit" >> /tmp/ftp-script.sh
|
||
echo "__end_commands" >> /tmp/ftp-script.sh
|
||
|
||
sh /tmp/ftp-script.sh
|
||
rm -f /tmp/ftp-script.sh
|
||
echo "Extraction complete."
|
||
}
|
||
|
||
install_common_nfs_cdrom() {
|
||
# $1 - directory containing file
|
||
local _filename
|
||
local _setsdone
|
||
local _prev
|
||
local _f
|
||
|
||
_sets=`(cd /mnt2/$1; ls *.tar.gz 2> /dev/null)`
|
||
if [ -z "$_sets" ]; then
|
||
# Try for stupid msdos convention
|
||
_sets=`(cd /mnt2/$1; ls *.tgz 2> /dev/null)`
|
||
fi
|
||
if [ -z "$_sets" ]; then
|
||
echo "There are no NetBSD install sets available in \"$1\""
|
||
return
|
||
fi
|
||
|
||
_setsdone=""
|
||
while : ; do
|
||
echo "The following sets are available for extraction:"
|
||
echo "(marked sets have already been extracted)"
|
||
echo ""
|
||
|
||
_prev=""
|
||
for _f in $_sets ; do
|
||
if isin $_f $_setsdone; then
|
||
echo -n "[X] "
|
||
else
|
||
echo -n " "
|
||
if [ -z "$_prev" ]; then _prev=$_f; fi
|
||
fi
|
||
echo $_f
|
||
done
|
||
echo ""
|
||
|
||
# Get the name of the file.
|
||
if [ "X$_prev" = "X" ]; then resp=n; else resp=y; fi
|
||
echo -n "Continue extraction [$resp]?"
|
||
getresp "$resp"
|
||
if [ "$resp" = "n" ]; then
|
||
break
|
||
fi
|
||
|
||
echo -n "File name [$_prev]? "
|
||
getresp "$_prev"
|
||
_f=$resp
|
||
_filename="/mnt2/$1/$_f"
|
||
|
||
# Ensure file exists
|
||
if [ ! -f $_filename ]; then
|
||
echo "File $_filename does not exist. Check to make"
|
||
echo "sure you entered the information properly."
|
||
continue
|
||
fi
|
||
|
||
# Extract file
|
||
cat $_filename | (cd /mnt; tar --unlink -zxvpf -)
|
||
echo "Extraction complete."
|
||
_setsdone="$_f $_setsdone"
|
||
|
||
done
|
||
}
|
||
|
||
install_cdrom() {
|
||
local _drive
|
||
local _partition_range
|
||
local _partition
|
||
local _fstype
|
||
local _directory
|
||
|
||
# Get the cdrom device info
|
||
cat << \__install_cdrom_1
|
||
|
||
The following CD-ROM devices are installed on your system; please select
|
||
the CD-ROM device containing the partition with the installation sets:
|
||
|
||
__install_cdrom_1
|
||
_CDDEVS=`md_get_cddevs`
|
||
echo "$_CDDEVS"
|
||
echo ""
|
||
echo -n "Which is the CD-ROM with the installation media? [abort] "
|
||
getresp "abort"
|
||
case "$resp" in
|
||
abort)
|
||
echo "Aborting."
|
||
return
|
||
;;
|
||
|
||
*)
|
||
if isin $resp $_CDDEVS ; then
|
||
_drive=$resp
|
||
else
|
||
echo ""
|
||
echo "The CD-ROM $resp does not exist."
|
||
echo "Aborting."
|
||
return
|
||
fi
|
||
;;
|
||
esac
|
||
|
||
# Get partition
|
||
_partition_range=`md_get_partition_range`
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Partition? [c] "
|
||
getresp "c"
|
||
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 [ "X${resp}" = X"" ]; 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 ${_filesystem} -o ro \
|
||
/dev/${_drive}${_partition} /mnt2 ; then
|
||
echo "Cannot mount CD-ROM drive. Aborting."
|
||
return
|
||
fi
|
||
|
||
# Get the directory where the file lives
|
||
resp="" # force one iteration
|
||
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_common_nfs_cdrom ${_directory}
|
||
umount -f /mnt2 > /dev/null 2>&1
|
||
}
|
||
|
||
install_disk() {
|
||
# Get the disk device info
|
||
local _drive
|
||
local _partition_range
|
||
local _partition
|
||
local _fstype
|
||
local _fsopts
|
||
local _directory
|
||
local _md_fstype
|
||
local _md_fsopts
|
||
|
||
cat << \__install_disk_1
|
||
|
||
The following disk devices are installed on your system; please select
|
||
the disk device containing the partition with the installation sets:
|
||
|
||
__install_disk_1
|
||
_DKDEVS=`md_get_diskdevs`
|
||
echo "$_DKDEVS"
|
||
echo ""
|
||
echo -n "Which is the disk with the installation sets? [abort] "
|
||
getresp "abort"
|
||
case "$resp" in
|
||
abort)
|
||
echo "Aborting."
|
||
return
|
||
;;
|
||
|
||
*)
|
||
if isin $resp $_DKDEVS ; then
|
||
_drive=$resp
|
||
else
|
||
echo ""
|
||
echo "The disk $resp does not exist."
|
||
echo "Aborting."
|
||
return
|
||
fi
|
||
;;
|
||
esac
|
||
|
||
# Get partition
|
||
_partition_range=`md_get_partition_range`
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; 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 << \__install_disk_2
|
||
|
||
The following filesystem types are supported:
|
||
1) ffs
|
||
__install_disk_2
|
||
_md_fstype=`md_native_fstype`
|
||
_md_fsopts=`md_native_fsopts`
|
||
if [ ! -z "$_md_fstype" ]; then
|
||
echo " 2) $_md_fstype"
|
||
else
|
||
_md_fstype="_undefined_"
|
||
fi
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; do
|
||
echo -n "Which filesystem type? [ffs] "
|
||
getresp "ffs"
|
||
case "$resp" in
|
||
ffs)
|
||
_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
|
||
fi
|
||
|
||
# Get the directory where the file lives
|
||
resp="" # force one iteration
|
||
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_common_nfs_cdrom ${_directory}
|
||
umount -f /mnt2 > /dev/null 2>&1
|
||
}
|
||
|
||
install_nfs() {
|
||
# Get the IP address of the server
|
||
resp="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; 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 [ "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="" # force one iteration
|
||
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_common_nfs_cdrom ${_nfs_directory}
|
||
umount -f /mnt2 > /dev/null 2>&1
|
||
}
|
||
|
||
install_tape() {
|
||
# 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 [ "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="" # force one iteration
|
||
while [ "X${resp}" = X"" ]; 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 [ "X${_nskip}" != X"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 [ "X${resp}" = X"" ]; do
|
||
echo -n "Which way is it? [1] "
|
||
getresp "1"
|
||
case "$resp" in
|
||
1)
|
||
(
|
||
cd /mnt
|
||
dd if=$TAPE | tar --unlink -zxvpf -
|
||
)
|
||
;;
|
||
|
||
2)
|
||
(
|
||
cd /mnt
|
||
dd if=$TAPE | tar --unlink -xvpf -
|
||
)
|
||
;;
|
||
|
||
*)
|
||
echo "Invalid response: $resp."
|
||
resp="" # force loop to repeat
|
||
;;
|
||
esac
|
||
done
|
||
echo "Extraction complete."
|
||
}
|
||
|
||
get_timezone() {
|
||
local _a
|
||
local _zonepath
|
||
|
||
#
|
||
# If the zoneinfo is not on the installation medium or on the
|
||
# installed filesystem, set TZ to GMT and return immediatly.
|
||
#
|
||
if [ ! -e /etc/timezone -a ! -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/timezone". 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 [ X$TZ = X ]; then
|
||
TZ=`ls -l /etc/timezone 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()
|
||
{
|
||
# arguments: the base names of the distribution sets to consider
|
||
# Ask the user which media to load the distribution from.
|
||
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.
|
||
|
||
__install_sets_1
|
||
if [ -f /mnt/$RELDIR/$1.tar.gz ]; then
|
||
echo -n "Are you sure to install sets from $RELDIR ? [y] "
|
||
getresp "y"
|
||
case "$resp" in
|
||
y*|Y*)
|
||
for _f do
|
||
if [ ! -f /mnt/$RELDIR/${_f}.tar.gz ]; then
|
||
continue
|
||
fi
|
||
echo -n "Install \"$_f\" ? [y]"
|
||
getresp "y"
|
||
case "$resp" in
|
||
y*|Y*)
|
||
cat /mnt/$RELDIR/${_f}.tar.gz |
|
||
(cd /mnt; tar --unlink -zxvpf -)
|
||
_yup="TRUE"
|
||
echo "Extraction complete."
|
||
;;
|
||
*)
|
||
echo "Skipping \"$_f\"."
|
||
;;
|
||
esac
|
||
done
|
||
;;
|
||
*)
|
||
_yup="FALSE"
|
||
;;
|
||
esac
|
||
else
|
||
_yup="FALSE"
|
||
fi
|
||
|
||
# Go on prodding for alternate locations
|
||
resp="" # force at least one iteration
|
||
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, (t)ape, (C)D-ROM, or (N)FS? [f] "
|
||
echo -n "(d)isk [d] "
|
||
getresp "f"
|
||
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 _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 _rest; do
|
||
if [ "$_mp" = "/" ]; then
|
||
echo $_dev /mnt $_rest
|
||
else
|
||
echo $_dev /mnt$_mp $_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 [ "X{$_mp}" != X"/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 $_opt $_dev $_mp ; then
|
||
# error message displated by mount
|
||
exit 1
|
||
fi
|
||
done ) < $_fstab
|
||
|
||
if [ "X${?}" != X"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.
|
||
# $1 is a file in fstab format
|
||
local _fstab
|
||
|
||
_fstab=$1
|
||
|
||
echo -n "Syncing disks..."
|
||
pid=`twiddle`
|
||
sync; sleep 4; sync; sleep 2; sync; sleep 2
|
||
kill $pid
|
||
echo "done."
|
||
|
||
(
|
||
_devs=""
|
||
_mps=""
|
||
# maintain reverse order
|
||
while read line; do
|
||
set -- $line
|
||
_devs="$1 ${_devs}"
|
||
_mps="$2 ${_mps}"
|
||
done
|
||
echo -n "Umounting filesystems... "
|
||
for _mp in ${_mps}; do
|
||
echo -n "${_mp} "
|
||
umount ${_mp}
|
||
done
|
||
echo "Done."
|
||
|
||
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
|
||
}
|