827 lines
17 KiB
Plaintext
827 lines
17 KiB
Plaintext
#! /bin/sh
|
|
#
|
|
# INSTALL: script to add diskless architecture support and add clients
|
|
#
|
|
# @(#)INSTALL 1.1 88/06/08 4.0NFSSRC; from 1.22 88/03/11 D/NFS
|
|
#
|
|
# Copyright (c) 1987 by Sun Microsystems, Inc.
|
|
#
|
|
if id | grep -v root > /dev/null; then
|
|
echo "You must become superuser to run $0"
|
|
exit 1
|
|
fi
|
|
|
|
HOME=/; export HOME
|
|
PATH=/bin:/usr/bin:/etc:/usr/etc:/usr/etc/netdisk:/usr/bsd
|
|
|
|
CMDNAME=$0
|
|
RELEASE="1.0"
|
|
HOSTS="/etc/hosts"
|
|
BOOTPARAMS="/etc/bootparams"
|
|
YPMASTERPATH="/var/yp"
|
|
|
|
# If $TAPE starts with /dev/ then $TAPEDEV will be that name. Otherwise
|
|
# tape device name $TAPEDEV constructed from ${NRTAPE}${TAPE}${DEVNO}
|
|
# NRTAPE is the prefix (including rooted path name)
|
|
# TAPE is the driver type taken from input prompt
|
|
# DEVNO is the suffix
|
|
# The device name should be the non-rewinding tape device to use.
|
|
NRTAPE="/dev/nr"
|
|
DEVNO="0"
|
|
|
|
# Specify default values for various paths here
|
|
ROOTPATHDEF=/export/root
|
|
SWAPPATHDEF=/export/swap
|
|
DUMPPATHDEF=none
|
|
HOMEPATHDEF=/home
|
|
EXECDEF=""
|
|
SWAPDEF=""
|
|
CLIENTYPDEF=""
|
|
|
|
echo
|
|
echo " >>> Sun Diskless Client Installation Tool <<<"
|
|
echo " >>> (for non-Sun Servers) <<<"
|
|
echo " >>> Release $RELEASE <<<"
|
|
#
|
|
# Get system hostname and YP domain name
|
|
#
|
|
HOST=`hostname`
|
|
DOMAIN=`domainname`
|
|
#
|
|
# Specify tape drive type : local or remote
|
|
# If remote, specify tape host name
|
|
#
|
|
while :; do
|
|
echo
|
|
echo "Enter tape drive type ? [local | remote]: \c"
|
|
read DRIVE;
|
|
case "$DRIVE" in
|
|
"local"|"l" )
|
|
TAPEHOST=""
|
|
TAPE="/dev/nrtapens"
|
|
break ;;
|
|
"remote"|"r" )
|
|
while :; do
|
|
echo;echo "Enter host of remote drive ? \c"
|
|
read TAPEHOST;
|
|
case "$TAPEHOST" in
|
|
"" )
|
|
echo; echo "${CMDNAME}: invalid tape host."
|
|
;;
|
|
* )
|
|
if [ "$DOMAIN" = "noname" -o "$DOMAIN" = "" ];
|
|
then
|
|
grep "[ ]$TAPEHOST[ ]" /etc/hosts \
|
|
>/dev/null
|
|
else
|
|
ypmatch $TAPEHOST hosts >/dev/null
|
|
fi
|
|
case $? in
|
|
1)
|
|
echo
|
|
echo "${CMDNAME}: invalid tapehost."
|
|
;;
|
|
*)
|
|
break ;;
|
|
esac ;;
|
|
esac
|
|
done
|
|
#
|
|
# Specify tape type : ar, st, mt, xt or /dev/something
|
|
#
|
|
while :; do
|
|
echo \
|
|
"\nEnter remote tape type ? [ar[08] | st[08] | mt[08] | xt[08] | /dev/???]: \c"
|
|
read TAPE;
|
|
case "$TAPE" in
|
|
ar | ar0 | nrar0 )
|
|
TAPE=ar
|
|
break ;;
|
|
ar8 | nrar8 )
|
|
TAPE=ar
|
|
DEVNO=8
|
|
break ;;
|
|
st | st0 | nrst0 )
|
|
TAPE=st
|
|
break ;;
|
|
st8 | nrst8 )
|
|
TAPE=st
|
|
DEVNO=8
|
|
break ;;
|
|
/dev/* )
|
|
break ;;
|
|
mt | mt0 | nrmt0 | xt | xt0 | nrxt0 )
|
|
TAPE=mt
|
|
break ;;
|
|
mt8 | nrmt8 | xt8 | nrxt8 )
|
|
TAPE=mt
|
|
DEVNO=8
|
|
break ;;
|
|
* )
|
|
echo "${CMDNAME}: invalid tape type \"${TAPE}\"." ;;
|
|
esac
|
|
done
|
|
break ;;
|
|
* )
|
|
echo "${CMDNAME}: invalid tape drive type \"${DRIVE}\"." ;;
|
|
esac
|
|
done
|
|
case $TAPE in
|
|
/dev/* )
|
|
TAPEDEV=$TAPE
|
|
;;
|
|
* )
|
|
TAPEDEV=${NRTAPE}${TAPE}${DEVNO}
|
|
;;
|
|
esac
|
|
#
|
|
# Create a list of architecture types. Valid types are determined
|
|
# from the release tapes.
|
|
#
|
|
ARCHLIST=""
|
|
PATHLIST=""
|
|
while :; do
|
|
while :; do
|
|
echo "
|
|
Enter next architecture type to load
|
|
[ sun4 | sun3 | ... | continue | done ]: \c"
|
|
read ARCH;
|
|
for i in ${ARCHLIST}; do
|
|
case "$i" in
|
|
"$ARCH")
|
|
echo "\"${ARCH}\" already specified."
|
|
break ;;
|
|
esac
|
|
done
|
|
case "$i" in
|
|
"$ARCH")
|
|
;;
|
|
*)
|
|
break ;;
|
|
esac
|
|
done
|
|
case "$ARCH" in
|
|
"" | "execs" | "clients" | "share" | "noshare" )
|
|
echo "${CMDNAME}: invalid architecture \"${ARCH}\"."
|
|
;;
|
|
"done" )
|
|
break ;;
|
|
"continue" | "c" )
|
|
# continue with setup_exec with data already gathered
|
|
ARCH=continue
|
|
case "$ARCHLIST" in
|
|
"")
|
|
if [ -f /tmp/ARCHLIST ]; then
|
|
ARCHLIST=`cat /tmp/ARCHLIST`
|
|
case "$ARCHLIST" in
|
|
"")
|
|
echo "No current architectures to use."
|
|
;;
|
|
*)
|
|
if [ -f /tmp/PATHLIST ]; then
|
|
PATHLIST=`cat /tmp/PATHLIST`
|
|
case "$PATHLIST" in
|
|
"")
|
|
;;
|
|
*)
|
|
echo "Continuing with architecture(s)\c"
|
|
for i in $ARCHLIST
|
|
do
|
|
case $i in
|
|
execs | clients | share | noshare )
|
|
;;
|
|
* )
|
|
echo " $i\c"
|
|
;;
|
|
esac
|
|
done
|
|
echo ""
|
|
break ;;
|
|
esac
|
|
fi
|
|
echo "No current pathlist to use."
|
|
;;
|
|
esac
|
|
else
|
|
echo "No current architectures to use."
|
|
fi ;;
|
|
*)
|
|
echo "
|
|
Cannot continue after specifying additional architectures."
|
|
;;
|
|
esac ;;
|
|
* )
|
|
while :; do
|
|
echo
|
|
echo "Enter pathname for $ARCH executables ? \c"
|
|
read EXEC;
|
|
case "$EXEC" in
|
|
"" )
|
|
case "$EXECDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
EXEC=$EXECDEF
|
|
echo "Using default \"$EXEC\""
|
|
;;
|
|
esac ;;
|
|
esac
|
|
case "$EXEC" in
|
|
"" )
|
|
;;
|
|
*/$ARCH | */$ARCH/* )
|
|
echo \
|
|
"Please give pathname without \"$ARCH\" at end."
|
|
;;
|
|
/* )
|
|
rm -rf /tmp/*.${ARCH}
|
|
if [ -d ${EXEC}/${ARCH}/bin ]; then
|
|
echo "
|
|
${CMDNAME}: exec tree ${EXEC}/${ARCH} appears to exist already.
|
|
You may select one of the following options:
|
|
ignore continue as if this architecture had not been specified
|
|
remove remove existing exec tree, then continue
|
|
use continue, loading any new optional software specified
|
|
clients continue with $ARCH clients, but use existing exec tree
|
|
? \c"
|
|
while :; do
|
|
read ans
|
|
case "$ans" in
|
|
"ignore" | "use" | "clients" )
|
|
break ;;
|
|
"remove" )
|
|
echo "Removing ${EXEC}/${ARCH}..."
|
|
rm -rf ${EXEC}/${ARCH}
|
|
if [ -d ${EXEC}/${ARCH} ]; then
|
|
echo \
|
|
" ${EXEC}/${ARCH} not removed; architecture ${ARCH} ignored"
|
|
ans=ignore
|
|
else
|
|
ans=use
|
|
fi
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Please enter \"ignore\" \"remove\" \"use\" or \"clients\" : \c"
|
|
;;
|
|
esac
|
|
done
|
|
else
|
|
ans=use
|
|
fi
|
|
# ans is one of ignore, use, or clients
|
|
case "$ans" in
|
|
"use" )
|
|
STATUS=error
|
|
opt_software ${ARCH} ${TAPEDEV} ${TAPEHOST}
|
|
case $? in
|
|
0 )
|
|
if [ -f /tmp/EXTRACTLIST.${ARCH} ]; then
|
|
set `head -1 /tmp/EXTRACTLIST.${ARCH}`
|
|
# args "IDENT <title> <release>
|
|
if [ $# = 3 -a "$1" = IDENT ]; then
|
|
EXECDEF=$EXEC
|
|
PATHLIST="${PATHLIST} ${EXEC}"
|
|
while :; do
|
|
echo "
|
|
Load sharable objects in shared location ? [y/n] :\c"
|
|
read ans
|
|
case "$ans" in
|
|
"y" | "yes" )
|
|
ans=share
|
|
break ;;
|
|
"n" | "no" )
|
|
ans=noshare
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Please answer yes or no."
|
|
;;
|
|
esac
|
|
done
|
|
ARCHLIST="${ARCHLIST} $ans ${ARCH}"
|
|
STATUS=ok
|
|
fi
|
|
fi ;;
|
|
esac
|
|
case $STATUS in
|
|
error)
|
|
echo "
|
|
${CMDNAME}: extraction error; $ARCH architecture entry ignored."
|
|
;;
|
|
esac
|
|
;;
|
|
"clients" )
|
|
EXECDEF=$EXEC
|
|
PATHLIST="${PATHLIST} ${EXEC}"
|
|
ARCHLIST="${ARCHLIST} clients ${ARCH}"
|
|
;;
|
|
* )
|
|
# ignore
|
|
echo "$ARCH architecture entry ignored."
|
|
;;
|
|
esac
|
|
break
|
|
;;
|
|
|
|
* )
|
|
echo "Exec pathname must start with \"/\""
|
|
;;
|
|
esac
|
|
done
|
|
;;
|
|
esac
|
|
done
|
|
rm -rf /tmp/PATHLIST /tmp/ARCHLIST
|
|
echo "$ARCHLIST" > /tmp/ARCHLIST
|
|
echo "$PATHLIST" > /tmp/PATHLIST
|
|
#
|
|
# Gather client info
|
|
# $RESET on input causes current client info to be reset and ignored
|
|
#
|
|
RESET="^"
|
|
case $ARCH in
|
|
continue)
|
|
# already have client info. Skip to setup_exec.
|
|
;;
|
|
*)
|
|
# get client info for all ARCHSTATES (execs and clients)
|
|
for ARCH in ${ARCHLIST}; do
|
|
case $ARCH in
|
|
share | noshare | execs | clients )
|
|
# ignore keywords
|
|
;;
|
|
* )
|
|
while :; do
|
|
case "$STATE" in
|
|
reset)
|
|
echo ">> $CLIENT entries ignored"
|
|
;;
|
|
esac
|
|
STATE=ok
|
|
echo
|
|
echo "Enter a $ARCH client name ? [ name | done ]: \c"
|
|
read CLIENT;
|
|
case "$CLIENT" in
|
|
"" )
|
|
;;
|
|
"none" | "done" )
|
|
break ;;
|
|
* )
|
|
#
|
|
# Verify that host and ether entries are present
|
|
#
|
|
echo
|
|
echo "Verifying Internet address..."
|
|
rm -rf /tmp/ipaddr
|
|
if [ "$DOMAIN" = "noname" -o "$DOMAIN" = "" ]; then
|
|
grep "[ ]$CLIENT[ ]" /etc/hosts |
|
|
grep -v "^#"
|
|
else
|
|
ypmatch $CLIENT hosts
|
|
fi | awk '{ print $1 }' > /tmp/ipaddr
|
|
IPADDR=`cat /tmp/ipaddr`
|
|
rm -rf /tmp/ipaddr
|
|
case "$IPADDR" in
|
|
"")
|
|
echo "
|
|
${CMDNAME}: can't find Internet address in /etc/hosts for \"${CLIENT}\""
|
|
echo
|
|
STATE=reset
|
|
;;
|
|
*)
|
|
echo " $IPADDR $CLIENT"
|
|
;;
|
|
esac
|
|
#
|
|
# Verify Ethernet address
|
|
#
|
|
echo
|
|
echo "Verifying Ethernet address..."
|
|
rm -rf /tmp/etheraddr
|
|
if [ "$DOMAIN" = "noname" -o "$DOMAIN" = "" ]; then
|
|
grep "[ ]$CLIENT[ ]" /etc/ethers |
|
|
grep -v "^#"
|
|
else
|
|
ypmatch $CLIENT ethers
|
|
fi | awk '{ print $1 }' > /tmp/etheraddr
|
|
ETHERADDR=`cat /tmp/etheraddr`
|
|
rm -rf /tmp/etheraddr
|
|
case "$ETHERADDR" in
|
|
"")
|
|
echo "
|
|
${CMDNAME}: can't find Ethernet address in /etc/ethers for \"${CLIENT}\"\n"
|
|
echo
|
|
STATE=reset
|
|
;;
|
|
*)
|
|
echo " $ETHERADDR $CLIENT"
|
|
;;
|
|
esac
|
|
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo \
|
|
"Enter YP mode of $CLIENT ? [ master | slave | client | none ]: \c"
|
|
read CLIENTYP;
|
|
case "$CLIENTYP" in
|
|
"")
|
|
case "$CLIENTYPDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
CLIENTYP=$CLIENTYPDEF
|
|
echo "Using default \"$CLIENTYP\""
|
|
break ;;
|
|
esac ;;
|
|
"master" | "slave" | "client" | "none" )
|
|
CLIENTYPDEF=$CLIENTYP
|
|
break ;;
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
* )
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Enter swap size of $CLIENT ? \c"
|
|
read SWAP;
|
|
case "$SWAP" in
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
[0-9]* )
|
|
SWAPDEF=$SWAP
|
|
break ;;
|
|
*)
|
|
if [ "$SWAP" = "" -a "$SWAPDEF" != "" ]; then
|
|
SWAP=$SWAPDEF
|
|
echo "Using default \"$SWAP\""
|
|
break
|
|
fi
|
|
echo "
|
|
Swap size must start with a digit (\"$SWAP\" is not valid)
|
|
Examples: 16M or 16m ==> 16 * 1048576 bytes
|
|
16K or 16k ==> 16 * 1000 bytes
|
|
16B or 16b ==> 16 * 512 bytes
|
|
16 ==> 16 bytes )"
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Enter root pathname of $CLIENT ? \c"
|
|
read ROOTPATH;
|
|
case "$ROOTPATH" in
|
|
"" )
|
|
case "$ROOTPATHDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
ROOTPATH=$ROOTPATHDEF
|
|
echo "Using default \"$ROOTPATH\""
|
|
break ;;
|
|
esac ;;
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
*/$CLIENT )
|
|
echo \
|
|
"Please give pathname without \"$CLIENT\" at end."
|
|
;;
|
|
/* )
|
|
ROOTPATHDEF=$ROOTPATH
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Root pathname must start with \"/\""
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Enter swap pathname of $CLIENT ? \c"
|
|
read SWAPPATH;
|
|
case "$SWAPPATH" in
|
|
"" )
|
|
case "$SWAPPATHDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
SWAPPATH=$SWAPPATHDEF
|
|
echo "Using default \"$SWAPPATH\""
|
|
break ;;
|
|
esac ;;
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
*/$CLIENT )
|
|
echo \
|
|
"Please give pathname without \"$CLIENT\" at end."
|
|
;;
|
|
/* )
|
|
SWAPPATHDEF=$SWAPPATH
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Swap pathname must start with \"/\""
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Enter dump pathname of $CLIENT (or \"none\") ? \c"
|
|
read DUMPPATH;
|
|
case "$DUMPPATH" in
|
|
"" )
|
|
case "$DUMPPATHDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
DUMPPATH=$DUMPPATHDEF
|
|
echo "Using default \"$DUMPPATH\""
|
|
break ;;
|
|
esac ;;
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
*/$CLIENT )
|
|
echo \
|
|
"Please give pathname without \"$CLIENT\" at end."
|
|
;;
|
|
/* | none )
|
|
DUMPPATHDEF=$DUMPPATH
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Dump pathname must start with \"/\""
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Enter home pathname of $CLIENT (or \"none\") ? \c"
|
|
read HOMEPATH;
|
|
case "$HOMEPATH" in
|
|
"" )
|
|
case "$HOMEPATHDEF" in
|
|
"")
|
|
;;
|
|
*)
|
|
HOMEPATH=$HOMEPATHDEF
|
|
echo "Using default \"$HOMEPATH\""
|
|
break ;;
|
|
esac ;;
|
|
"$RESET")
|
|
STATE=reset
|
|
break ;;
|
|
/* | none )
|
|
HOMEPATHDEF=$HOMEPATH
|
|
break ;;
|
|
* )
|
|
echo \
|
|
"Home pathname must start with \"/\""
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
while :; do
|
|
echo
|
|
echo "Information for $CLIENT ok ? [y/n] : \c"
|
|
read ans
|
|
case "$ans" in
|
|
"y" | "yes" )
|
|
break ;;
|
|
"n" | "no" )
|
|
STATE=reset
|
|
break ;;
|
|
* )
|
|
echo "Please answer yes or no."
|
|
;;
|
|
esac
|
|
done ;;
|
|
esac
|
|
case $STATE in
|
|
ok)
|
|
echo "$CLIENT" >> /tmp/CLIENT.${ARCH}
|
|
echo "$IPADDR" >> /tmp/CLIENTIP.${ARCH}
|
|
echo "$ETHERADDR" >> /tmp/CLIENTETHER.${ARCH}
|
|
echo "$CLIENTYP" >> /tmp/CLIENTYP.${ARCH}
|
|
echo "$SWAP" >> /tmp/SWAP.${ARCH}
|
|
echo "$ROOTPATH" >> /tmp/ROOTPATH.${ARCH}
|
|
echo "$SWAPPATH" >> /tmp/SWAPPATH.${ARCH}
|
|
echo "$DUMPPATH" >> /tmp/DUMPPATH.${ARCH}
|
|
echo "$HOMEPATH" >> /tmp/HOMEPATH.${ARCH}
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
done
|
|
;;
|
|
esac
|
|
done
|
|
;;
|
|
esac
|
|
#
|
|
# Prompt user attention last time before starting to build
|
|
#
|
|
while :; do
|
|
echo;echo "Are you ready to start the installation ? [y/n] : \c"
|
|
read READY;
|
|
case "${READY}" in
|
|
"y" | "yes" )
|
|
break ;;
|
|
"n" | "no" )
|
|
echo "
|
|
Installation procedure terminates.
|
|
You may continue by running this script and entering \"continue\" at the
|
|
first prompt for architecture type."
|
|
exit 1 ;;
|
|
* )
|
|
echo;echo "Please answer only yes or no."
|
|
esac
|
|
done
|
|
|
|
#
|
|
# Installation starts
|
|
#
|
|
ARCHSTATE=execs
|
|
for CURRENTARCH in ${ARCHLIST}; do
|
|
case $CURRENTARCH in
|
|
execs | clients | share | noshare )
|
|
ARCHSTATE=$CURRENTARCH
|
|
;;
|
|
* )
|
|
echo
|
|
echo "Beginning Installation for the ${CURRENTARCH} architecture."
|
|
#
|
|
# get path and read in release tape
|
|
#
|
|
set $PATHLIST
|
|
CURRENTPATH=$1
|
|
shift
|
|
PATHLIST="$*"
|
|
case "$ARCHSTATE" in
|
|
execs | share )
|
|
SHAREPATH=${CURRENTPATH}/share
|
|
;;
|
|
noshare )
|
|
SHAREPATH=none
|
|
;;
|
|
* )
|
|
# if share directory exists, use it for clients
|
|
if [ -d ${CURRENTPATH}/share ]; then
|
|
SHAREPATH=${CURRENTPATH}/share
|
|
else
|
|
SHAREPATH=none
|
|
fi
|
|
;;
|
|
esac
|
|
EXECPATH=${CURRENTPATH}/${CURRENTARCH}
|
|
case "$ARCHSTATE" in
|
|
execs | share | noshare )
|
|
setup_exec $CURRENTARCH $EXECPATH $DRIVE $TAPEHOST $TAPEDEV \
|
|
$SHAREPATH
|
|
STATUS=$?
|
|
;;
|
|
* )
|
|
# do not setup these execs
|
|
echo
|
|
echo "[${CURRENTARCH} executables already installed]"
|
|
STATUS=0
|
|
;;
|
|
esac
|
|
case ${STATUS} in
|
|
0)
|
|
echo
|
|
echo "Starting installation of ${CURRENTARCH} clients..."
|
|
echo
|
|
if [ -f /tmp/CLIENT.${CURRENTARCH} ]; then
|
|
#
|
|
# Read these files just once.
|
|
# The 'set' hacks are used to avoid using 'expr'
|
|
# counters, which are not built-in and take awhile
|
|
# to do as the loops get bigger.
|
|
#
|
|
IPLIST=`cat /tmp/CLIENTIP.${CURRENTARCH}`
|
|
ETHERLIST=`cat /tmp/CLIENTETHER.${CURRENTARCH}`
|
|
YPLIST=`cat /tmp/CLIENTYP.${CURRENTARCH}`
|
|
SWAPLIST=`cat /tmp/SWAP.${CURRENTARCH}`
|
|
ROOTPATHLIST=`cat /tmp/ROOTPATH.${CURRENTARCH}`
|
|
SWAPPATHLIST=`cat /tmp/SWAPPATH.${CURRENTARCH}`
|
|
DUMPPATHLIST=`cat /tmp/DUMPPATH.${CURRENTARCH}`
|
|
HOMEPATHLIST=`cat /tmp/HOMEPATH.${CURRENTARCH}`
|
|
for i in `cat /tmp/CLIENT.${CURRENTARCH}`; do
|
|
set $IPLIST
|
|
IP=$1
|
|
shift
|
|
IPLIST="$*"
|
|
|
|
set $ETHERLIST
|
|
ETHER=$1
|
|
shift
|
|
ETHERLIST="$*"
|
|
|
|
set $YPLIST
|
|
YP=$1
|
|
shift
|
|
YPLIST="$*"
|
|
|
|
set $SWAPLIST
|
|
SWAP=$1
|
|
shift
|
|
SWAPLIST="$*"
|
|
|
|
set $ROOTPATHLIST
|
|
ROOTPATH=$1
|
|
shift
|
|
ROOTPATHLIST="$*"
|
|
|
|
set $SWAPPATHLIST
|
|
SWAPPATH=$1
|
|
shift
|
|
SWAPPATHLIST="$*"
|
|
|
|
set $DUMPPATHLIST
|
|
DUMPPATH=$1
|
|
shift
|
|
DUMPPATHLIST="$*"
|
|
|
|
set $HOMEPATHLIST
|
|
HOMEPATH=$1
|
|
shift
|
|
HOMEPATHLIST="$*"
|
|
#
|
|
# Create client
|
|
#
|
|
setup_client add/noYP $i $YP $SWAP \
|
|
$ROOTPATH $SWAPPATH $DUMPPATH \
|
|
$HOMEPATH $EXECPATH $SHAREPATH $CURRENTARCH
|
|
case $? in
|
|
0)
|
|
DIDACLIENT=yes
|
|
;;
|
|
*)
|
|
echo "
|
|
ATTENTION: $CURRENTARCH client $i not installed."
|
|
echo
|
|
;;
|
|
esac
|
|
done
|
|
fi
|
|
;;
|
|
*)
|
|
echo
|
|
echo "ATTENTION: exec installation for $CURRENTARCH failed."
|
|
echo " $CURRENTARCH clients not installed."
|
|
;;
|
|
esac
|
|
;;
|
|
esac
|
|
done
|
|
case "$DIDACLIENT" in
|
|
yes)
|
|
if [ "$DOMAIN" != "noname" -a "$DOMAIN" != "" -a -f ${YPMASTERPATH}/bootparams.time ]; then
|
|
echo
|
|
echo "Updating bootparams YP map..."
|
|
cd ${YPMASTERPATH}
|
|
make bootparams
|
|
elif [ "$DOMAIN" != "noname" -a "$DOMAIN" != "" -a ! -f ${YPMASTERPATH}/bootparams.time ]; then
|
|
if [ ! -f ${YPMASTERPATH}/bootparams.time- ]; then
|
|
echo "
|
|
ATTENTION: /etc/bootparams on the yp master needs to be updated."
|
|
fi
|
|
fi ;;
|
|
esac
|
|
echo
|
|
case "$ARCHLIST" in
|
|
"")
|
|
echo "Nothing to install!"
|
|
;;
|
|
*)
|
|
echo "Diskless Client Installation Completed."
|
|
;;
|
|
esac
|
|
exit 0
|