home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / LocalDoc / install / request < prev    next >
Encoding:
Text File  |  1998-08-19  |  29.7 KB  |  1,144 lines
  1. #ident    "@(#)request    16.1    98/03/03"
  2. # set installation package (SIP) request script
  3.  
  4. PKGMSG=${SETINST}.pkg
  5. LOCALE=${LC_ALL:-${LC_MESSAGES:-${LANG:-"C"}}}
  6. MAX_MENU_FIELD_LEN="42"
  7.  
  8. #
  9. #  If this script exits normally or if DEL is pressed, clean up /tmp
  10. #  If DEL is pressed, make sure we exit 77 so pkgadd knows no packages
  11. #  were selected.
  12. #
  13. trap `rm /tmp/*$$ > /dev/null 2>&1; EXITCODE=77; exit` 2
  14. trap `rm /tmp/*$$ > /dev/null 2>&1; exit $EXITCODE` 0
  15.  
  16. #
  17. #  Definitions of files we're going to use.  They all end in $$ for
  18. #  easy cleanup (see trap stmt, above)
  19. #
  20. DEP_SUCC=/tmp/succ$$
  21. DEP_FAIL=/tmp/fail$$
  22. MENU_OUT=/tmp/out$$
  23. MENU_FILE=/tmp/menu$$
  24. PKGS_FILE=/tmp/pkglist$$
  25. PKG_RM=/tmp/pkgrm$$
  26. TAB='    '
  27.  
  28. if [ ! -f /usr/lib/locale/${LOCALE}/LC_MESSAGES/${PKGMSG} ]
  29. then
  30.    if [ -f ${REQDIR}/inst/locale/${LOCALE}/${PKGMSG} -a \
  31.     -d /usr/lib/locale/${LOCALE}/LC_MESSAGES ]
  32.    then
  33.     cp ${REQDIR}/inst/locale/${LOCALE}/${PKGMSG} \
  34.        /usr/lib/locale/${LOCALE}/LC_MESSAGES
  35.    fi
  36. fi
  37. #
  38. #  Set up the menu directory to be locale specific
  39. #
  40. MENU_DIR=/etc/inst/locale/${LOCALE}/menus/${PKG}
  41. [ -d ${MENU_DIR} ] || mkdir -p ${MENU_DIR}
  42.  
  43. MENUS="set.1 set.2 set.3 set.4 set.5 set.6 set.7 set.8 set.9"
  44.  
  45. for i in $MENUS
  46. do
  47.    if [ ! -f ${MENU_DIR}/$i ]
  48.    then
  49.       if [ -f ${REQDIR}/inst/locale/${LOCALE}/${PKG}/$i ]
  50.       then
  51.            cp ${REQDIR}/inst/locale/${LOCALE}/${PKG}/$i ${MENU_DIR}
  52.       else
  53.            cp ${REQDIR}/$i ${MENU_DIR}
  54.       fi
  55.    fi
  56. done
  57. #
  58. #  Set up to use menu_colors; default to C-locale if ${LOCALE}'s dir has
  59. #  no menu_colors.sh
  60. #
  61. if [ -f /etc/inst/locale/${LOCALE}/menus/menu_colors.sh ]
  62. then
  63.     . /etc/inst/locale/${LOCALE}/menus/menu_colors.sh
  64. else
  65.     . /etc/inst/locale/C/menus/menu_colors.sh
  66. fi
  67.  
  68. #####    Begin UPNOVER    ######
  69.  
  70. SCRIPTSDIR=/usr/sbin/pkginst
  71. . ${SCRIPTSDIR}/updebug
  72. [ "$UPDEBUG" = YES ] && set -x
  73.  
  74. # chk_upnover <resp_file> <pkginst>
  75. #
  76. # This routine returns 1 if AUTO/CUSTOM question is asked
  77. #              returns 0 if AUTO/CUSTOM question not to be asked
  78. chk_upnover () {
  79.     # $1 is the response file
  80.     # $2 is the pkgabbrev.  (a.k.a PKGINST)
  81.  
  82.     # chkpkgrel needs to know the VERSION being installed.
  83.     # grep VERSION from pkginfo for this pkg and export it.
  84.  
  85.     # save current VERSION if set.
  86.     [ "$VERSION" ] && O_VERSION=$VERSION
  87.     
  88.     grep "^VERSION=" $REQDIR/${2}/pkginfo >/tmp/$$.ver
  89.     [ -s /tmp/$$.ver ] && . /tmp/$$.ver
  90.     rm -f /tmp/$$.ver
  91.     export VERSION
  92.  
  93.  
  94.     [ "$UPDEBUG" = YES ] && goany
  95.  
  96.     # Set CALLED_FROM_SET and export it. When chkpkgrel finds a newer 
  97.     # version of a package already installed, it will not do the warning
  98.     # screen to tell the user to pkgrm the pkg, before the older version is
  99.     # installed, if CALLED_FFROM_SET is set. In this case a single warning
  100.     # screen 'set.8' is done in this request screen for all such packages.
  101.  
  102.     CALLED_FROM_SET=YES
  103.     export CALLED_FROM_SET
  104.  
  105.     ${SCRIPTSDIR}/chkpkgrel $2
  106.     PKGVERSION=$?
  107.     unset CALLED_FROM_SET
  108.  
  109.     unset VERSION
  110.     [ "$O_VERSION" ] && {
  111.         VERSION=$O_VERSION
  112.         unset O_VERSION
  113.     }
  114.  
  115.     # chkpkgrel returns 0: if pkg not installed
  116.     #                1: if pkg installed is neither SVR4.0 V4 nor SVR4.2
  117.     #            2: if SVR4.2 pkg installed
  118.     #                4: if SVR4.0 V4 pkg installed
  119.     #                9: if a newer version of SVR4.2 pkg is installed, 
  120.     #            in which case, tell'm to pkgrm it.
  121.  
  122.     [ "$UPDEBUG" = YES ] && goany
  123.  
  124.     # If AUTOMERGE is the only question to be asked, then AUTO/CUSTOM
  125.     # question should only be displayed for non-destructive installation.
  126.     # The response file for such a package must define ONLYVAR=UPNOVER.
  127.  
  128.     [ $PKGVERSION -lt 2 ] && {
  129.         grep "^ONLYVAR=UPNOVER" $1 >/dev/null 2>&1 || return 1
  130.         return 0
  131.     }
  132.  
  133.     # chkpkgrel exits with code, 9 they have to pkgrm this pkg.
  134.     [ $PKGVERSION -eq 9 ] && {
  135.         # list the pkg name in the file $PKG_RM. 
  136.         # It will be used in set.8 screen.
  137.  
  138.         echo $2 >>$PKG_RM
  139.         return 0
  140.     }
  141.     return 1
  142. }
  143.  
  144. check_oam_version ()
  145. { 
  146.     # check_oam_version $RESPDIR/${1}
  147.     # This procedure is run for packages run in AUTOMATIC install mode.
  148.     # It checks the version of oam package installed.
  149.     # If an OAM package other than SVR4.2 OAM is installed, it
  150.     # removes OAMadmin from the CLASSES defined in the response file.
  151.     # This should happen for nfs and inet packages. 
  152.     # The reason is that OAM interface will not be installed 
  153.     # for these packages, if non-SVR4.2 OAM is installed.
  154.     # This will be done by excluding OAMadmin from CLASSES.
  155.     #
  156.     # This is done here, because CLASSES can only be reset
  157.     # in the request script and request script is not run in 
  158.     # AUTOMATIC mode.
  159.  
  160.     # $1 is the response in which CLASSES may have OAMadmin defined
  161.  
  162.     # return codes: 0 if  non-SVR4.2 OAM was not detected
  163.     #               1 if  non-SVR4.2 OAM was detected.
  164.     #               2 if  non-SVR4.2 was detected and CLASSES for reset
  165.     #                     in the response file to eliminate OAMadmin
  166.  
  167.     #        9 if a newer oam was detected than the version of 
  168.     #          this set, in which chkpkgrel shows warning screen
  169.     #          if CALLED_FROM_SET in not set.
  170.  
  171.     RESPFL=$1
  172.  
  173.     # Set CALLED_FROM_SET and export it. When chkpkgrel finds a newer 
  174.     # version of a package already installed, it will not do the warning
  175.     # screen to tell the user to pkgrm the pkg, before the older version is
  176.     # installed, if CALLED_FFROM_SET is set. In this case a single warning
  177.     # screen 'set.8' is done in this request screen for all such packages.
  178.  
  179.     CALLED_FROM_SET=YES
  180.     export CALLED_FROM_SET
  181.  
  182.     ${SCRIPTSDIR}/chkpkgrel oam
  183.     PKGVERSION=$?
  184.  
  185.     unset CALLED_FROM_SET
  186.  
  187.     # chkpkgrel returns 0: if pkg not installed
  188.     #                1: if pkg installed is neither SVR4.0 V4 nor SVR4.2
  189.     #            2: if SVR4.2 pkg installed
  190.     #                4: if SVR4.0 V4 pkg installed
  191.     #                9: if a newer version of SVR4.2 pkg is installed, 
  192.     #            in which case, tell'm to pkgrm it.
  193.  
  194.     [ "$UPDEBUG" = YES ] && goany
  195.  
  196.     [ $PKGVERSION -eq 0 -o $PKGVERSION -eq 2 ] && return 0
  197.  
  198.     grep  "^CLASSES=.*OAMadmin" $RESPFL >/tmp/$$.newresp 2>&1 || return 1
  199.  
  200.     . /tmp/$$.newresp
  201.  
  202.     for i in `echo $CLASSES`
  203.     do 
  204.         [ "$i" = OAMadmin ] && continue
  205.  
  206.         NCLASSES="$NCLASSES$i "
  207.     done
  208.  
  209.     grep  -v "^CLASSES=.*OAMadmin" $RESPFL >/tmp/$$.newresp
  210.  
  211.     echo CLASSES="\"$NCLASSES\"" >>/tmp/$$.newresp
  212.  
  213.     mv /tmp/$$.newresp $RESPFL
  214.  
  215.     [ "$UPDEBUG" = YES ] && goany
  216.  
  217.     return 2
  218. }
  219.  
  220. #####    End UPNOVER    ######
  221. #
  222. #  This routine creates the business end of the first menu, where the
  223. #  user selects Yes (install) ir No (don't install) for each pkg in set.
  224. #
  225. mk_pkgs_menu1() {
  226.  
  227.     exec 3<&0
  228.     #
  229.     #  Create the form section of the first set menu.
  230.     #
  231.     echo ".form"
  232.  
  233.     #
  234.     #  First, get the list of pkgs installed by default
  235.     #  The first one-choice ENUM TYPE fields are used as labels for
  236.     #  the form.  The variable FOO is just a dummy so that the line
  237.     #  parses correctly.
  238.     #
  239.     MSGBUF1=`pfmt -s nostd -g ${PKGMSG}:51 "Install?" 2>&1`
  240.     MSGBUF2=`pfmt -s nostd -g ${PKGMSG}:52 "Package Name" 2>&1`
  241.     echo "//6//${MSGBUF1}//${MSGBUF2}//FOO//"
  242.     echo "//  //"
  243.     echo "//6//--------//------------------------------------------//FOO//"
  244.     echo "//  //"
  245.     i=0
  246.     PKGS_PER_SCREEN=8
  247.     last=`expr $start + $PKGS_PER_SCREEN`
  248.     exec </tmp/name_dflt_y
  249.     while read PKGABBREV PKGNAME && [ "$i" -lt "$last" ]
  250.     do
  251.         if [ "$i" -ge $start ]
  252.         then
  253.             PKGNAME=`echo $PKGNAME | cut -c1-$MAX_MENU_FIELD_LEN`
  254.             #
  255.             #  Set up the choice field for this package.
  256.             #
  257.             MSGBUF1=`pfmt -s nostd -g ${PKGMSG}:53 "Right" 2>&1`
  258.             MSGBUF2=`pfmt -s nostd -g ${PKGMSG}:54 "Left arrow keys for new choice (2 choices)" 2>&1`
  259.             YES_MSG=`pfmt -s nostd -g ${PKGMSG}:57 "Yes" 2>&1`
  260.             NO_MSG=`pfmt -s nostd -g ${PKGMSG}:58 "No" 2>&1`
  261.  
  262.             # If PKGABBREV is "c++", we cannot construct environment variable name.
  263.             # Use cplusplus instead.
  264.             if [ "$PKGABBREV" = "c++" ]; then PKGABBREV=cplusplus; fi
  265.  
  266.             echo "//2 2//YES::${YES_MSG}//NO::${NO_MSG}//${PKGNAME}://TAG_${PKGABBREV}//"
  267.             echo "//${MSGBUF1}/${MSGBUF2}//"
  268.  
  269.             #
  270.             #  We're going to set the default for this package to
  271.             #  "Yes" (install), so we echo to a file and source it
  272.             #  in after this routine is finished, so the TAG_'s don't
  273.             #  vanish with this subshell.
  274.             #
  275.             echo eval TAG_${PKGABBREV}=\"YES\" export TAG_${PKGABBREV} >> ${MENU_OUT}
  276.         fi
  277.         i=`expr $i + 1`
  278.     done
  279.  
  280.  
  281.     #
  282.     #  Now, get the list of pkgs NOT installed by default
  283.     #  The first one-choice ENUM TYPE fields are used as labels for
  284.     #  the form.  The variable FOO is just a dummy so that the line
  285.     #  parses correctly.
  286.     #
  287.     exec </tmp/name_dflt_n
  288.     while read PKGABBREV PKGNAME && [ "$i" -lt "$last" ]
  289.     do
  290.         if [ "$PKGABBREV" = "base" ]
  291.         then 
  292.             # Do not list base in menu since it cannot be reinstalled.
  293.             echo eval TAG_${PKGABBREV}=\"NO\" export TAG_${PKGABBREV} >> ${MENU_OUT}
  294.             continue
  295.         fi
  296.  
  297.         if [ "$i" -ge $start ]
  298.         then
  299.             PKGNAME=`echo $PKGNAME | cut -c1-$MAX_MENU_FIELD_LEN`
  300.             #
  301.             #  Set up the choice field for this package.
  302.             #
  303.             MSGBUF1=`pfmt -s nostd -g ${PKGMSG}:53 "Right" 2>&1`
  304.             MSGBUF2=`pfmt -s nostd -g ${PKGMSG}:54 "Left arrow keys for new choice (2 choices)" 2>&1`
  305.             YES_MSG=`pfmt -s nostd -g ${PKGMSG}:57 "Yes" 2>&1`
  306.             NO_MSG=`pfmt -s nostd -g ${PKGMSG}:58 "No" 2>&1`
  307.  
  308.             # If PKGABBREV is "c++", we cannot construct environment variable name.
  309.             # Use cplusplus instead.
  310.             if [ "$PKGABBREV" = "c++" ]; then PKGABBREV=cplusplus; fi
  311.  
  312.             echo "//2 2//YES::${YES_MSG}//NO::${NO_MSG}//${PKGNAME}://TAG_${PKGABBREV}//"
  313.             echo "//${MSGBUF1}/${MSGBUF2}//"
  314.  
  315.             #
  316.             #  We're going to set the default for this package to
  317.             #  "No" (don't install), so we echo to a file and source it
  318.             #  in after this routine is finished, so the TAG_'s don't
  319.             #  vanish with this subshell.
  320.             #  Se
  321.             #
  322.             echo eval TAG_${PKGABBREV}=\"NO\" export TAG_${PKGABBREV} >> ${MENU_OUT}
  323.         fi
  324.         i=`expr $i + 1`
  325.     done
  326.     exec <&3
  327.     exec 3<&-
  328.     echo start=$i >> ${MENU_OUT}
  329.  
  330. }
  331.  
  332. #
  333. #  This routine creates the business end of the second menu, where the
  334. #  user selects Automatic or Custom installation for any package that
  335. #  has both a request script and a response file.
  336. #
  337. mk_pkgs_menu2()
  338. {
  339.     #
  340.     #  Create the form section of the first set menu.
  341.     #
  342.     echo ".form"
  343.  
  344.     #
  345.     #  First, get the list of pkgs installed by default
  346.     #  The first one-choice ENUM TYPE fields are used as labels for
  347.     #  the form.  The variable FOO is just a dummy so that the line
  348.     #  parses correctly.
  349.     #
  350.     MSGBUF1=`pfmt -s nostd -g ${PKGMSG}:55 "Options" 2>&1`
  351.     MSGBUF2=`pfmt -s nostd -g ${PKGMSG}:56 "Package Name" 2>&1`
  352.     echo "//6//${MSGBUF1}//${MSGBUF2}//FOO//"
  353.     echo "//  //"
  354.     echo "//6//--------//----------------------------------------//FOO//"
  355.     echo "//  //"
  356.     while read PKGABBREV PKGNAME
  357.     do
  358.  
  359.         #
  360.         #  If there are both a request and response file for this
  361.         #  pkg, give option of Auto or Custom install.
  362.         #
  363.         if [ -f ${REQDIR}/${PKGABBREV}/response -a -f ${REQDIR}/${PKGABBREV}/request ]
  364.         then
  365.             #####    Begin UPNOVER    ######
  366.             # chk_upnover returns 0 to skip AUTO/CUSTOM question
  367.  
  368.             chk_upnover ${REQDIR}/${PKGABBREV}/response $PKGABBREV
  369.             [ $? = 0 ] && continue
  370.  
  371.             #####    End UPNOVER    ######
  372.  
  373.             PKGNAME=`echo $PKGNAME | cut -c1-$MAX_MENU_FIELD_LEN`
  374.             #
  375.             #  Create the form field for this package.
  376.             #
  377.             MSGBUF1=`pfmt -s nostd -g ${PKGMSG}:53 "Right" 2>&1`
  378.             MSGBUF2=`pfmt -s nostd -g ${PKGMSG}:54 "Left arrow keys for new choice (2 choices)" 2>&1`
  379.             AUTO=`pfmt -s nostd -g ${PKGMSG}:59 "Automatic" 2>&1`
  380.             CUST=`pfmt -s nostd -g ${PKGMSG}:60 "Custom" 2>&1`
  381.  
  382.             # If PKGABBREV is "c++", we cannot construct environment variable name.
  383.             # Use cplusplus instead.
  384.             if [ "$PKGABBREV" = "c++" ]; then PKGABBREV=cplusplus; fi
  385.  
  386.             echo "//2 2//AUTO::${AUTO}//CUST::${CUST}//${PKGNAME}://TAG_${PKGABBREV}//"
  387.             echo "//${MSGBUF1}/${MSGBUF2}//"
  388.  
  389.             #
  390.             #  We're going to set the default for this package to
  391.             #  "Automatic", so we echo to a file and source it
  392.             #  in after this routine is finished, so the TAG_'s
  393.             #  don't vanish with this subshell.
  394.             #
  395.             echo eval TAG_${PKGABBREV}=\"AUTO\" export TAG_${PKGABBREV} >> ${MENU_OUT}
  396.         fi
  397.     done < /tmp/name_final_y
  398.  
  399. }
  400.  
  401. #
  402. #  This is where we actually run request scripts for each package,
  403. #  unless the user selected AUTO for this pkgs installation or
  404. #  there is no response file.
  405. #
  406. process_default_install () {
  407.  
  408.     [ "$UPDEBUG" = YES ] && set -x
  409.     #
  410.     #  If there's a request script...
  411.     #
  412.     if [ -f $REQDIR/${1}/request ]
  413.     then
  414.  
  415.         # If argument is "c++", environment variable is TAG_cplusplus.
  416.         if [ "$1" = "c++" ] 
  417.         then RANS=`eval echo $"TAG_cplusplus"`
  418.         else RANS=`eval echo $"TAG_${1}"`
  419.         fi
  420.  
  421.         #
  422.         #  ...and the user selected AUTOMATIC install, then...
  423.         #
  424.         if [ "$RANS" = "AUTO" ]
  425.         then
  426.  
  427.             #
  428.             #  ...if there's a response file, use that.
  429.             #
  430.             if [ -f $REQDIR/${1}/response ]
  431.             then
  432.                 cp $REQDIR/${1}/response $RESPDIR/${1} 
  433.  
  434.                 # delete OAMadmin from CLASSES in $RESPDIR/$1
  435.                 # if non-SVR4.2 OAM is installed
  436.  
  437.                 check_oam_version $RESPDIR/${1}
  438.  
  439.                 check_oam_rc=$?
  440.  
  441.                 [ "$UPDEBUG" = YES ] && {
  442.                     echo check_oam_rc=$check_oam_rc >/dev/console
  443.                     goany
  444.                 }
  445.             #
  446.             #  Otherwise, run the request script.
  447.             #
  448.             else
  449.                 # This section takes care of using the set member package's
  450.                    # pkginfo file to set up its own environment.  So that these
  451.                    # values are not used to overwrite the SIPs, we do this in
  452.                    # a subshell.
  453.                    (
  454.                    # Mark vars yet to be set to be automatically exported
  455.                    set -a
  456.                    pkgparam -v -f $REQDIR/${1}/pkginfo >/tmp/params.$$
  457.                    . /tmp/params.$$
  458.                    PKGINST=$PKG  # Reset PKGINST to set member PKG inst
  459.                    sh $REQDIR/${1}/request $RESPDIR/${1} </dev/tty >/dev/tty 2>/dev/tty
  460.  
  461.                 [ $? != 0 ] && {
  462.                     echo 1>/tmp/req.rc
  463.                     return 1
  464.                 }
  465.  
  466.                    )
  467.                    rm -f /tmp/params.$$
  468.                fi
  469.  
  470.         #
  471.         #  If the user selected CUSTOM, run the request script.
  472.         #
  473.         else
  474.             # This section takes care of using the set member package's
  475.                # pkginfo file to set up its own environment.  So that these
  476.                # values are not used to overwrite the SIPs, we do this in
  477.                # a subshell.
  478.                (
  479.                # Mark vars yet to be set to be automatically exported
  480.                set -a
  481.                pkgparam -v -f $REQDIR/${1}/pkginfo >/tmp/params.$$
  482.                . /tmp/params.$$
  483.                PKGINST=$PKG  # Reset PKGINST to set member PKG inst
  484.                sh $REQDIR/${1}/request $RESPDIR/${1} </dev/tty >/dev/tty 2>/dev/tty
  485.             [ $? != 0 ] && {
  486.                 echo 1 >/tmp/req.rc
  487.                 return 1
  488.             }
  489.                )
  490.                rm -f /tmp/params.$$
  491.         fi
  492.     #
  493.     #  If there's no request script and just a response file, use that.
  494.     #
  495.     else
  496.         if [ -f $REQDIR/${1}/response ]
  497.         then
  498.             cp $REQDIR/${1}/response $RESPDIR/${1} 
  499.         fi
  500.     fi
  501.  
  502.     #
  503.     # create an empty response file if one doesn't exist
  504.     # ul97-20008.
  505.     #
  506.     [ ! -f ${RESPDIR}/${1} ] && > ${RESPDIR}/${1}
  507.  
  508.     retcode=0
  509.     [ -f /tmp/req.rc ] && {
  510.         read retcode </tmp/req.rc
  511.         rm -f /tmp/req.rc
  512.     }
  513.     [ "$UPDEBUG" = YES ] && goany "retcode for process_default=$retcode"
  514.     return $retcode
  515.  
  516. }
  517.  
  518. #
  519. #  Read in initial information about the set.  Creates files for later
  520. #  use.
  521. #
  522. read_setinfo() {
  523.     # ALL_OFF is set to true if any packages from this
  524.     # set are already installed. If any packages are
  525.     # installed, then the default selections in the set's 
  526.     # package selection menu will be "all off".
  527.  
  528.     ALL_OFF=false
  529.     > /tmp/name_dflt_y
  530.     > /tmp/name_dflt_n
  531.     if [ -d /var/sadm/pkg/$SETINST ]
  532.     then
  533.         # A package was installed previously by installing
  534.         # this set?
  535.         ALL_OFF=true
  536.     else
  537.         # Check if at least one package from this set was 
  538.         # previously installed. In this case, the package 
  539.         # would have been installed directly, not via the set.
  540.  
  541.         ls /var/sadm/pkg >/tmp/avail_pkgs
  542.         cut -f1 $SETINFO|sed -e '/^[     ]*$/d' -e '/^#/d' >>/tmp/avail_pkgs
  543.         sort /tmp/avail_pkgs|uniq -d - /tmp/non_uniq_pkgs
  544.         [ -s /tmp/non_uniq_pkgs ] && ALL_OFF=true
  545.     fi 
  546.     while read pkginst parts default category package_name
  547.     do
  548.         [ "$ALL_OFF" = "true" ] && default="no"
  549.           case ${pkginst} in
  550.         '#'*) continue ;;
  551.         [a-zA-Z+]*)         
  552.             if [ "${default}" = "y" -o "${default}" = "yes" ]
  553.             then    echo $pkginst >>/tmp/dflt_y$$ 
  554.                 echo "${TAB}${pkginst}${TAB}${package_name}              " >>/tmp/name_dflt_y
  555.             else    echo $pkginst >>/tmp/dflt_n$$
  556.                 echo "${TAB}${pkginst}${TAB}${package_name}              " >>/tmp/name_dflt_n
  557.             fi
  558.             ;;
  559.         *)    continue ;;
  560.         esac 
  561.     done <$SETINFO
  562. }
  563.  
  564. #
  565. #  This recursive routine does dependency checking.  It doesn't let any
  566. #  dependency go unchecked, and if a dependency was already checked, it
  567. #  won't check it again (avoids multiple prompts for same packages).
  568. do_dependencies() {
  569.     PKG=$1
  570.  
  571.     #
  572.     #  If we've already succeeded, don't bother checking again
  573.     #
  574.     grep $PKG $DEP_SUCC > /dev/null 2>&1
  575.     if [ $? = 0 ]
  576.     then
  577.         return 0
  578.     fi
  579.  
  580.     #
  581.     #  If we've already failed, don't bother checking again
  582.     #
  583.     grep $PKG $DEP_FAIL > /dev/null 2>&1
  584.     if [ $? = 0 ]
  585.     then
  586.         return 1
  587.     fi
  588.  
  589.  
  590.     #
  591.     #  first make the list of dependencies
  592.     #  If there are none, return success.
  593.     #
  594.  
  595.     if [ ! -f ${REQDIR}/${PKG}/depend ]
  596.     then
  597.         return 0
  598.     fi
  599.     rm -rf /tmp/dependlist$$ 
  600.  
  601.     while read prerequisite abbreviation full_name
  602.     do
  603.         case ${prerequisite} in
  604.         '#'*) continue ;;
  605.         P) 
  606.             echo ${abbreviation} >> /tmp/dependlist$$
  607.             ;;
  608.         *)   continue;;
  609.         esac
  610.     done <${REQDIR}/${PKG}/depend
  611.  
  612.     #
  613.     #  For every dependency there is,
  614.     #
  615.     if [ ! -f /tmp/dependlist$$ ]
  616.     then
  617.         #  If only I's in depend file, then there will be no dependList
  618.         #  file, and that's okay:
  619.         return 0
  620.     else
  621.         LIST=`cat /tmp/dependlist$$`
  622.         for  DEPENDENCY  in ${LIST}
  623.         do
  624.             pkginfo -i ${DEPENDENCY} > /dev/null 2>&1
  625.             if [ $? -eq 0 ] 
  626.             then
  627.                 continue
  628.             fi
  629.             #
  630.             #  Check if we're installing it in this pkglist.
  631.             #
  632.             grep "^${DEPENDENCY}${TAB}" /tmp/name_selected_y > /dev/null 2>&1
  633.             INSTALLING=$?
  634.  
  635.             #
  636.             #  And check if it's in this set.
  637.             #
  638.             grep "\<${DEPENDENCY}\>" /tmp/name_dflt_y > /dev/null 2>&1
  639.             INSET=$?
  640.  
  641.             #
  642.             #  We haven't yet selected it, and it is in the set.
  643.             #  Give the option to install.
  644.             #
  645.             if [ $INSTALLING != 0 -a $INSET = 0 ]
  646.             then
  647.                 INST_DEP="YES"
  648.                 export PKG DEPENDENCY INST_DEP
  649.                 menu_colors warn
  650.                 menu -f ${MENU_DIR}/set.4 -o ${MENU_OUT} < /dev/tty >/dev/tty
  651.                 . ${MENU_OUT}
  652.  
  653.                 #
  654.                 #  If we chose to install a package we hadn't
  655.                 #  yet selected, we had better check IT'S 
  656.                 #  dependencies so we know if we can install 
  657.                 #  any of this.
  658.                 #
  659.                 if [ "${INST_DEP}" = "YES" ]
  660.                 then
  661.                     ( do_dependencies $DEPENDENCY )
  662.                     if [ $? = 0 ]
  663.                     then
  664.                         echo $DEPENDENCY >> ${PKGS_FILE}
  665.                         echo $DEPENDENCY$TAB$DEPENDENCY >> /tmp/name_selected_y
  666.                         echo $DEPENDENCY >> $DEP_SUCC
  667.                         continue 
  668.                     else
  669.                         echo $DEPENDENCY >> $DEP_FAIL
  670.                         return 1
  671.                     fi
  672.                 else
  673.                     echo $DEPENDENCY >> $DEP_FAIL
  674.                     return 1
  675.                 fi
  676.             else
  677.                 #
  678.                 #  It is not in this set.  If it is not 
  679.                 #  installed already, give the option.
  680.                 #
  681.                 if [ $INSET = 1 ]
  682.                 then
  683.                     #
  684.                     #  Check if it's installed already.
  685.                     #
  686.                     pkginfo -i ${DEPENDENCY} > /dev/null 2>&1
  687.                     if [ $? -ne 0 ] 
  688.                     then
  689.                         #
  690.                         #  If not, warn user.  Otherwise
  691.                         #  go on.
  692.                         #
  693.                         export PKG DEPENDENCY
  694.                         menu_colors warn
  695.                         menu -f ${MENU_DIR}/set.5 -o ${MENU_OUT} < /dev/tty >/dev/tty
  696.                         echo $DEPENDENCY >> $DEP_FAIL
  697.                         return 1;
  698.                     else
  699.                         echo $DEPENDENCY >> $DEP_SUCC
  700.                         continue ;
  701.                     fi
  702.                 fi
  703.             fi
  704.         done
  705.     fi
  706.  
  707.     #
  708.     #  The dependency was not a problem for the package we wanted to
  709.     #  install, so before we let ourselves out of here, we make sure
  710.     #  that this dependency is really installable, else we can;t install
  711.     #  the package we came here to check dependencies for.
  712.     #
  713.     return 0
  714. }
  715.  
  716. # MAIN starts here
  717.  
  718. #
  719. #  Zero out files we're going to use in this script.
  720. #
  721. > ${PKGS_FILE}
  722. > ${DEP_SUCC}
  723. > ${DEP_FAIL}
  724. > ${PKGS_FILE}
  725.  
  726. ############## Begin UPGRADE/OVERLAY Support ####################
  727.  
  728. #
  729. #  If the user is upgrading and this is the ADMIN set, then if they
  730. #  have the V4 OA&M package installed, we have to tell them to remove
  731. #  it, and then exit.
  732. #  
  733.  
  734. [ "${PKGINST}" = "admin" ] && {
  735.  
  736.     SCRIPTS=/usr/sbin/pkginst
  737.     ${SCRIPTS}/chkpkgrel oam
  738.     PKGVERSION=$?
  739.     [ $PKGVERSION != 2 -a $PKGVERSION != 0 ] && {
  740.  
  741.         #
  742.         #  Send the menus out to the correct directory
  743.         #
  744.         [ -d ${MENU_DIR} ] || mkdir -p ${MENU_DIR}
  745.         if [ ! -f ${MENU_DIR}/menu.remove ]
  746.         then
  747.            if [ -f ${REQDIR}/inst/locale/${LOCALE}/${PKG}/menu.remove ]
  748.            then
  749.                 cp ${REQDIR}/inst/locale/${LOCALE}/${PKG}/menu.remove ${MENU_DIR}
  750.            else
  751.                 cp ${REQDIR}/menu.remove ${MENU_DIR}
  752.            fi
  753.         fi
  754.  
  755.         menu -f ${MENU_DIR}/menu.remove -o /dev/null >/dev/tty 2>/dev/null < /dev/tty
  756.         exit 3
  757.     }
  758. }
  759.  
  760. #
  761. # We need to enforce the assumption that if they currently have nsu
  762. # and/or acp installed on their Version 4 box, they MUST upgrade them.
  763. #
  764. # If the Version 4 nsu and/or acp packages are installed and they
  765. # don't chose them.  We'll warn them and then install them anyhow.
  766. #
  767. # The file /tmp/upgrade.sh will only exist if we're installing via
  768. # the boot floppies.
  769. #
  770.  
  771. [ -f /tmp/upgrade.sh ] && . /tmp/upgrade.sh
  772.  
  773. [ "$PKGINSTALL_TYPE" = "UPGRADE" ] && {
  774.  
  775.     NSUNAME="Network Support Utilities"
  776.     ACPNAME="Enhanced Application Compatibility"
  777.  
  778.     $SCRIPTSDIR/chkpkgrel nsu
  779.     [ "$?" = "4" ] && NSU=Y
  780.  
  781.     $SCRIPTSDIR/chkpkgrel acp
  782.     [ "$?" = "4" ] && ACP=Y
  783.  
  784.     [ "$UPDEBUG" = "YES" ] && goany
  785.  
  786.     export NSU ACP NSUNAME ACPNAME
  787. }
  788.  
  789. read_setinfo
  790.  
  791. DFLT_Y=`cat /tmp/dflt_y$$ 2>/dev/null`
  792. DFLT_N=`cat /tmp/dflt_n$$ 2>/dev/null`
  793. ALL_PKGS="${DFLT_Y} ${DFLT_N}"
  794.  
  795. cp ${MENU_DIR}/set.1 ${MENU_FILE}
  796.  
  797. #
  798. #  $MENU_OUT is going to get a list of eval stmts in mk_pkgs_menu1
  799. #  about how to set defaults and will then be sourced back into this shell
  800. #  (There's a comment up in mk_pkgs_menu1 about this...)
  801. #
  802. start=0
  803. while :
  804. do
  805.     ostart=$start
  806.     > ${MENU_OUT}
  807.     mk_pkgs_menu1 >> ${MENU_FILE}
  808.     . ${MENU_OUT}
  809.  
  810.     #
  811.     # No more packages left
  812.     #
  813.     if [ "$ostart" = "$start" ]
  814.     then
  815.         break
  816.     fi
  817.     #
  818.     #  We actually run the first menu, where the user chooses what packages
  819.     #  to install, then source the answers back in.
  820.     #
  821.     menu_colors regular
  822.     menu -f ${MENU_FILE} -o ${MENU_OUT} 2> /dev/null </dev/tty >/dev/tty
  823.     . ${MENU_OUT}
  824. done
  825.  
  826. #
  827. #  Get all the package names into /tmp/name_dflt_y, and zero out
  828. #  the file of selected packages.
  829. #
  830. cat /tmp/name_dflt_n >> /tmp/name_dflt_y
  831. > /tmp/name_selected_y
  832. > /tmp/name_final_y
  833.  
  834. #
  835. #  For every package that was selected for installation, place
  836. #  the pkg abbreviation and the name into the selected file.
  837. #
  838. while read PKGABBREV PKGNAME
  839. do
  840.     # For "c++", the environment variable name is TAG_cplusplus.
  841.     if [ "$PKGABBREV" = "c++" ]
  842.     then eval [ $"TAG_cplusplus" = "YES" ]
  843.     else eval [ $"TAG_${PKGABBREV}" = "YES" ]
  844.     fi
  845.     if [ $? = 0 ]
  846.     then
  847.         echo "${PKGABBREV}    ${PKGNAME}" >> /tmp/name_selected_y
  848.     fi
  849. done < /tmp/name_dflt_y
  850.  
  851. #
  852. # If the user is upgrading and they have either nsu and/or acp installed
  853. # on there system AND they failed to select these packages to be upgrades,
  854. # we're going to warn them and add them to the list of packages to
  855. # upgrade anyhow.
  856. #
  857.  
  858. [ "$PKGINSTALL_TYPE" = "UPGRADE" ] && {
  859.  
  860.     TAB='    '
  861.     SPACE=' '
  862.     unset WARNEM
  863.     grep "^nsu[${TAB}${SPACE}]*" /tmp/name_selected_y >/dev/null 2>&1
  864.     rc=$?
  865.  
  866.     [ $rc != 0 -a "$NSU" = "Y" ] && {
  867.  
  868.         echo "nsu    ${NSUNAME}" >> /tmp/name_selected_y
  869.         WARNEM=Y
  870.     }
  871.  
  872.     [ $rc = 0 ] && NSU=N        # Eliminate it from warning message
  873.  
  874.     grep "^acp[${TAB}${SPACE}]*" /tmp/name_selected_y >/dev/null 2>&1
  875.     rc=$?
  876.  
  877.     [ $rc != 0 -a "$ACP" = "Y" ] && {
  878.  
  879.         echo "acp    ${ACPNAME}" >> /tmp/name_selected_y
  880.         WARNEM=Y
  881.     }
  882.  
  883.     [ $rc = 0 ] && ACP=N        # Eliminate it from warning message
  884.  
  885.     [ "$WARNEM" ] && menu -f ${MENU_DIR}/set.7 -o ${MENU_OUT} < /dev/tty >/dev/tty
  886. }
  887.  
  888. #
  889. #  If no package was selected, then let the user know and exit.
  890. #
  891. if [ ! -s /tmp/name_selected_y ]
  892. then
  893.     menu_colors regular
  894.     menu -f ${MENU_DIR}/set.3 -o ${MENU_OUT} 2>/dev/null < /dev/tty > /dev/tty
  895.     EXITCODE=77; export EXITCODE
  896.     exit 77
  897. fi
  898.  
  899.  
  900. #
  901. #  For each package selected, check dependencies until there are none left
  902. #
  903. while read PKGABBREV PKGNAME
  904. do
  905.     do_dependencies $PKGABBREV
  906.     if [ $? = 0 ] 
  907.     then
  908.         echo $PKGABBREV >> ${PKGS_FILE}
  909.         echo $PKGABBREV $PKGNAME >> /tmp/name_final_y
  910.     fi
  911. done < /tmp/name_selected_y
  912.  
  913. #
  914. #  Reorder PKGLIST so that it accurately reflects the order of the
  915. #  packages as listed in the setinfo file. Create two versions:
  916. #  one where entries are separated by new-lines (this will be used
  917. #  internally to this script and is called PKGLIST), and one
  918. #  where entries are separated by spaces called NPKG_LIST.
  919. #  PKGLIST will ultimately be set to NPKG_LIST for preinstall and
  920. #  postinstall scripts since they "." the response file, and hence
  921. #  a PKGLIST in the format below will not be viable:
  922. #  PKGLIST=pkg1
  923. #  pkg2
  924. #  pkg3
  925. #
  926. #  Rather, PKGLIST should be set PKGLIST=pkg1 pkg2 pkg3.
  927. #  This code should be cleaned up for the next load and
  928. #  was implemented this way to reduce the amt of change.
  929.  
  930.  
  931. PKGLIST=`cat ${PKGS_FILE}`
  932. export PKGLIST
  933. > ${PKGS_FILE}
  934. NPKG_FILE=/tmp/npkglist.$$
  935. > ${NPKG_FILE}
  936.  
  937. NPKG_SEP=""    # 1st entry in NPKGFILE should not have space 
  938.         # in front of it.
  939. NPKG_SPACE=" "
  940.  
  941. > /tmp/name_final_y
  942.  
  943. while read pkginst parts default category package_name
  944. do
  945.     case ${pkginst} in
  946.     '#'*) continue ;;
  947.     [a-zA-Z+]*)         
  948.         echo ${PKGLIST} | grep "\<${pkginst}\>" > /dev/null 2>&1
  949.         if [ $? -eq 0 ]
  950.         then
  951.             echo "${pkginst}${TAB}${package_name}" >> /tmp/name_final_y
  952.             echo "${pkginst}" >> ${PKGS_FILE}
  953.             echo -n "${NPKG_SEP}${pkginst}" >> ${NPKG_FILE}
  954.             # after 1st time through, make sure NPKG_SEP is " "
  955.             NPKG_SEP="${NPKG_SPACE}"
  956.         fi
  957.         ;;
  958.     *)    continue ;;
  959.     esac 
  960. done < ${SETINFO}
  961.  
  962. #
  963. #  $MENU_OUT is going to get a list of eval stmts in mk_pkgs_menu2
  964. #  about how to set defaults and will then be sourced back into this shell
  965. #  (There's a comment up in mk_pkgs_menu1 about this...)
  966. #
  967. cp ${MENU_DIR}/set.2 ${MENU_FILE}
  968. mk_pkgs_menu2 >> ${MENU_FILE}
  969. . ${MENU_OUT}
  970.  
  971.  
  972. # Delete pkgs that are listed in the file $PKG_RM from the list
  973. # of the selected packages in the file $PKGS_FILE. Newer version of the packages
  974. # listed in $PKG_RM is already installed. The user must pkgrm these packages.
  975.  
  976. [ -f "$PKG_RM" ] && {
  977.     TMP_PKGS_FILE=/tmp/pkg.$$
  978.     while read P
  979.     do
  980.         grep $P $PKG_RM >/dev/null 2>&1
  981.         [ $? -eq 0 ] || {
  982.             echo $P >>$TMP_PKGS_FILE #temp file with selected pkgs
  983.         } 
  984.     done <$PKGS_FILE
  985.     [ -f $TMP_PKGS_FILE ] && cp $TMP_PKGS_FILE $PKGS_FILE
  986.  
  987.     # Warn the user that some or all packages have newer versions already
  988.     # installed. These pkgs must be pkgrm'ed to install older version.
  989.  
  990.     [ -f $TMP_PKGS_FILE ] || {
  991.         ALL_NEW=YES        # ALL_NEW is set when all pkgs selected
  992.         export ALL_NEW        # have older versions installed.
  993.     }
  994.     export PKG_RM
  995.     menu_colors warn
  996.     menu -f ${MENU_DIR}/set.8 -o /dev/null 2>/dev/null </dev/tty >/dev/tty
  997.     
  998.     # If ALL_NEW is set, there is nothing to install. Exit with code 77
  999.  
  1000.     [ "$ALL_NEW" ] && {
  1001.         EXITCODE=77; export EXITCODE
  1002.         rm -f $PKG_RM $TMP_PKGS_FILE
  1003.         exit 77
  1004.     }
  1005.  
  1006.     rm -f $PKG_RM $TMP_PKGS_FILE
  1007. }
  1008.  
  1009. #
  1010. #  Check to see if we actually created a menu for selecting Custom vs
  1011. #  Automatic installation.  There may be no response files in this
  1012. #  whole set, thus no possibility for Auto install.
  1013. #  If we did create a menu, execute it.
  1014. #
  1015. grep TAG_ ${MENU_FILE} > /dev/null 2>&1
  1016. if [ $? = 0 ]
  1017. then
  1018.     menu_colors regular
  1019.     menu -f ${MENU_FILE} -o ${MENU_OUT} 2> /dev/null </dev/tty >/dev/tty
  1020.     . ${MENU_OUT}
  1021. fi
  1022.  
  1023. PKGLIST=`cat ${PKGS_FILE}`
  1024. export PKGLIST
  1025.  
  1026.  
  1027. ############################################
  1028. # Display copyright messages for the selected packages 
  1029. # up front and all at once. Also, eliminate duplicate copyrights 
  1030. # being displayed. 
  1031. # Advanced tools like (n)awk cannot be used as they
  1032. # will not be available yet for installing the foundation set.
  1033. # We like to keep set/request scripts identical for all sets. 
  1034.  
  1035. if [ -f ${REQDIR}/copyright ] 
  1036. then
  1037.     cp ${REQDIR}/copyright /tmp/setcopyright
  1038. else
  1039.     > /tmp/setcopyright
  1040. fi
  1041. for i in ${PKGLIST}
  1042. do 
  1043.     while read LINE 
  1044.     do
  1045.         case ${LINE} in
  1046.         '#'*) continue ;;
  1047.         [a-zA-Z]*) 
  1048.             grep "${LINE}" /tmp/setcopyright > /dev/null 2>&1
  1049.             if [ ${?} -ne 0 ]
  1050.             then 
  1051.                 echo ${LINE} >> /tmp/setcopyright 2> /dev/null
  1052.             fi
  1053.             ;;
  1054.         *) continue ;;
  1055.         esac
  1056.     done < ${REQDIR}/${i}/copyright
  1057. done
  1058. ############################################
  1059. #
  1060. #  If no package was selected, then let the user know and exit.
  1061. #
  1062. if [ -z "${PKGLIST}" ]
  1063. then
  1064.     menu_colors regular
  1065.     menu -f ${MENU_DIR}/set.3 -o ${MENU_OUT} 2>/dev/null </dev/tty >/dev/tty
  1066.     EXITCODE=77; export EXITCODE
  1067.     exit 77
  1068. fi
  1069.  
  1070. #
  1071. #  Now that we have a complete list of packages to install, and all
  1072. #  the dependencies have been weeded out, go ahead and do the request
  1073. #  scripts if appropriate.
  1074. #
  1075. [ "$UPDEBUG" = YES ] && set -x
  1076. for PKG in ${PKGLIST}
  1077. do
  1078.     # If !I-Lock! exists for a pkg, it is partially installed.
  1079.     # Create a lock file  in /tmp to indicate this fact.
  1080.     # chkpkgrel, an upnover tool, will return the code for
  1081.     # newinstall, if the lock file /tmp is detected.
  1082.     # The lock file in /tmp is needed, because in automatic
  1083.     # install mode, by the time chkpkgrel looks for the lock
  1084.     # file in /var/sadm/pkg/$PKG, pkgadd has already dropped
  1085.     # one for the current installation.
  1086.     # chkpkgrel will clean the lock file in /tmp. 
  1087.     # Oherwise, for pkgs for which chkpkgrel is not run, this
  1088.     # file will be blown away when the system is rebooted.
  1089.  
  1090.     [ -f /var/sadm/pkg/$PKG/!I-Lock! ] && >/tmp/$PKG.Lock
  1091.  
  1092.     # Remove the file /var/sadm/upgrade/$PKG.env, which is around
  1093.     # if the user del'ed out before a pkg installation completed. 
  1094.     # This file should not exist when pkg. installation begins.
  1095.  
  1096.     rm -f /var/sadm/upgrade/$PKG.env
  1097.  
  1098.     process_default_install ${PKG}
  1099.  
  1100.     ## if rtn code is non-zero, remove that pkg from PKGLIST
  1101.      ## we do this by creating another pkglist.
  1102.     ## (if sed is available this would be simpr)
  1103.  
  1104.     [ "$?" = "0" ] && {
  1105.  
  1106.         NEWPKGLIST="${NEWPKGLIST}${PKG} "
  1107.  
  1108.     }
  1109. done
  1110. [ "$UPDEBUG" = YES ] && goany
  1111. [ "$NEWPKGLIST" ] || {
  1112.     exit 77
  1113. }
  1114. PKGLIST=${NEWPKGLIST}
  1115. echo $PKGLIST >$NPKG_FILE
  1116. unset NEWPKGLIST
  1117.  
  1118. # update /tmp/name_final_y to match updated PKGLIST. Grep for 
  1119. # "^${PKG}[<space><TAB>]" in /tmp/name_final_y  to remove any pkg from
  1120. # /tmp/name_final_y for which request script returned a non-zero code. 
  1121.  
  1122. rm -f /tmp/$$.y
  1123. for PKG in ${PKGLIST}
  1124. do
  1125.     grep "^${PKG}[     ]" /tmp/name_final_y >>/tmp/$$.y
  1126. done
  1127. mv /tmp/$$.y /tmp/name_final_y
  1128.  
  1129. #
  1130. #  Make sure correctly ordered PKGLIST is exported to the environment,
  1131. #  the shell statment to assign the PKGLIST is written to the response
  1132. #  file, and setsizecvt is run, which creates a file of the format of
  1133. #  a pkg's space(4) file, so the packaging tools can take care of 
  1134. #  space checking for us.
  1135. #
  1136. #  Exit cleanly when we're done.
  1137. #
  1138. NPKG_LIST=`cat ${NPKG_FILE}`
  1139. export PKGLIST NPKG_LIST
  1140. echo "PKGLIST=${NPKG_LIST}" >> $1 
  1141. [ ! -f /etc/inst/scripts/sgauge.sh ] || . /etc/inst/scripts/sgauge.sh
  1142. /usr/sadm/install/bin/setsizecvt
  1143. exit 0
  1144.