home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / acp / root.2 / etc / serialize / serialize~
Text File  |  1998-08-19  |  13KB  |  466 lines
  1. # Copyright (c) 1998 The Santa Cruz Operation, Inc.. All Rights Reserved. 
  2. #                                                                         
  3. #        THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF THE               
  4. #                   SANTA CRUZ OPERATION INC.                             
  5. #                                                                         
  6. #   The copyright notice above does not evidence any actual or intended   
  7. #   publication of such source code.                                      
  8.  
  9. :
  10. #ident    "@(#)xcpxinstall:common/xcpcmd/xinstall/serialize.sh    1.1"
  11. #    @(#) serialize 23.12 91/11/03 
  12. #
  13. #    Copyright (C) 1989-1991 The Santa Cruz Operation, Inc.
  14. #        All Rights Reserved.
  15. #    The information in this file is provided for the exclusive use of
  16. #    the licensees of The Santa Cruz Operation, Inc.  Such users have the
  17. #    right to use, modify, and incorporate this code into other products
  18. #    for purposes authorized by the license agreement provided they include
  19. #    this notice and the associated copyright notice with any such product.
  20. #    The information in this file is provided "AS IS" without warranty.
  21. #
  22. #    /etc/serialize <permsfile>
  23. #        -serializes a list of files obtained from a perms list
  24. #
  25.  
  26. # set the environment variables
  27. PATH=/etc:/bin:/usr/bin
  28. workingdir=/
  29. formdir=/etc
  30.  
  31. # set variables
  32. remap=
  33. use_super=
  34. _serial= 
  35. _key=
  36.  
  37. # set the standard exit values
  38. : ${OK=0} ${FAIL=1} ${STOP=10}
  39.  
  40. # Standard functions
  41.  
  42. cleanup()
  43. {
  44.     [ $OASH ] && {
  45.         oadeinit
  46.         clear
  47.     }
  48.     exit $1
  49. }
  50.  
  51. # print restricted rights legend on user screen
  52. rights()
  53. {
  54.     [ $OASH ] && echo "
  55.                          RESTRICTED RIGHTS LEGEND                         
  56.                                                                           
  57.      Use, duplication, or disclosure by the U.S. Government is subject    
  58.      to the restrictions as set forth in subparagraph (c)(1) of           
  59.      FAR 52.227-19 - Commercial Computer Software -- Restricted Rights,   
  60.      or  subparagraph (c)(1)(ii)  of  DFAR 52.227-7013 - Rights in        
  61.      Technical Data and Computer Software. \"Contractor/Manufacturer\" is 
  62.                         The Santa Cruz Operation, Inc.                   
  63.                         400 Encinal Street                              
  64.                         Santa Cruz, CA                                 
  65.                         95061, USA.                                   
  66.  
  67.     " || echo "
  68.  
  69.   +------------------------------------------------------------------------+
  70.   |                                                                        |
  71.   |                       RESTRICTED RIGHTS LEGEND                         |
  72.   |                                                                        |
  73.   |   Use, duplication, or disclosure by the U.S. Government is subject    |
  74.   |   to the restrictions as set forth in subparagraph (c)(1) of           |
  75.   |   FAR 52.227-19 - Commercial Computer Software -- Restricted Rights,   |
  76.   |   or  subparagraph (c)(1)(ii)  of  DFAR 52.227-7013 - Rights in        |
  77.   |   Technical Data and Computer Software. \"Contractor/Manufacturer\" is   |
  78.   |                      The Santa Cruz Operation, Inc.                    |
  79.   |                      400 Encinal Street                                |
  80.   |                      Santa Cruz, CA                                    |
  81.   |                      95061, USA.                                       |
  82.   |                                                                        |
  83.   +------------------------------------------------------------------------+
  84.  
  85. "
  86. }
  87.  
  88. # Prompt with mesg, return non-zero on q
  89. prompt() {
  90.     [ $OASH ] && {
  91.         wmopen 2 4 50 19 15 
  92.         wmtitle "Serialization"
  93.         form $formdir/ser.form "((ser_form"
  94.         [ "$FIELD0" = "q" -o "$FIELD0" = "Q" ] && return $FAIL    
  95.         [ "$FIELD1" = "q" -o "$FIELD1" = "Q" ] && return $FAIL    
  96.         wmove 1
  97.         werase 2 
  98.         wmclose 2
  99.         _serial="$FIELD0"
  100.         _key="$FIELD1"
  101.         return $OK
  102.     } || {
  103.     while    echo "\n${mesg}or enter q to quit: \c" >&2
  104.     do    read cmd
  105.         case $cmd in
  106.         +x|-x)    set $cmd                    ;;
  107.         Q|q)    return $FAIL                    ;;
  108.         !*)    eval `expr "$cmd" : "!\(.*\)"`            ;;
  109.         "")    # If there is an argument use it as the default
  110.             # else loop until 'cmd' is set
  111.             [ "$1" ] && { 
  112.                 cmd=$1
  113.                 return $OK
  114.             }
  115.             : continue
  116.             ;;
  117.         *)    return $OK                    ;;
  118.         esac
  119.     done
  120.     }
  121. }
  122.  
  123. # Prompt for yes or no answer - returns non-zero for no
  124. getyn() {
  125.     while    echo "\n$* (y/n) \c">&2
  126.     do    read yn rest
  127.         case $yn in
  128.         [yY])    return $OK             ;;
  129.         [nN])    return $FAIL            ;;
  130.         *)    echo "Please answer y or n" >&2    ;;
  131.         esac
  132.     done
  133. }
  134.  
  135. # Print an error message
  136. error() {
  137.     echo "\nError: $*" >&2
  138.     return 1
  139. }
  140.  
  141. #update the system serialization log
  142. serlog() {
  143. LOGSERNUMBER=$1
  144. LOGPRD=$2
  145. LOGFILE=/etc/serialno
  146.     echo "Date: \c" >> $LOGFILE
  147.     date >> $LOGFILE
  148.     echo "Product prd value: $LOGPRD" >> $LOGFILE
  149.     echo "Serialization: Standard" >> $LOGFILE
  150.     echo "Serial Number: $LOGSERNUMBER" >> $LOGFILE
  151.     echo " " >> $LOGFILE
  152.     return 0
  153. }
  154.     
  155. # /etc/serialize functions
  156.  
  157. # build a variable $serfiles, from /etc/perms/this_product
  158. set_serfiles () {
  159.     eval `sed -n '/^#ser=/s/#//p' $permsfile` 2> /dev/null || {
  160.         echo "\nError. Failed to get list of files to serialize from \
  161. $permsfile" 
  162.         cleanup $FAIL
  163.         }
  164.     [  "$ser" = "" ] && {
  165.         echo "$permsfile does not have any files that require \
  166. serialization."
  167.         return 1
  168.     }
  169.     for i in $ser
  170.     do
  171.         [ -f "$i" ] && serfiles="$serfiles $i"
  172.     done
  173.     
  174.     # make sure there are files to serialize on the hard disk
  175.     [ "$serfiles" ] || cleanup $OK
  176.  
  177.     return 0
  178. }
  179.  
  180. # return 0 if bundle;  return 1 if not bundle 
  181. is_bundle () {
  182.     [ -d /etc/perms/bundle ] || return 1
  183.  
  184.     cd /etc/perms/bundle
  185.     bundle_files=`echo *`
  186.     cd $workingdir
  187.     [ "$bundle_files" = "*" ] && return 1
  188.  
  189.     # grep for /tmp/perms/[product] in bundle list
  190.     bund_perm=`basename $permsfile`
  191.     case $bund_perm in
  192.     inst|extmd)    bund_perm=./tmp/perms/ext        ;;
  193.     *)        bund_perm=./tmp/perms/$bund_perm    ;;
  194.     esac
  195.  
  196.     for i in $bundle_files
  197.     do
  198.         if grep "perms=$bund_perm[:     ]" /etc/perms/bundle/$i > /dev/null 2>&1
  199.         then
  200.             # this product is part of a bundle product
  201.             this_bundle=/etc/perms/bundle/$i
  202.             tmppermsflag=true
  203.             # $set gets bundle= value, for use by brand
  204.             get_bundle_set
  205.             return 0
  206.         fi
  207.     done
  208.     # check for any mdperms 
  209.     for i in $bundle_files
  210.     do
  211.         if grep "mdperms=$permsfile" /etc/perms/bundle/$i > /dev/null 2>&1
  212.         then
  213.             this_bundle=/etc/perms/bundle/$i
  214.             get_bundle_set
  215.             return 0
  216.         fi
  217.     done
  218.     # product is not in any bundle list
  219.     return 1
  220. }
  221.  
  222. # set $compprd value. Return 0 is serialization is remapped; return 1 if not
  223. is_serial () {
  224.     permsrch=".$permsfile"
  225.     [ $tmppermsflag ] && permsrch="$bund_perm"
  226.  
  227.     # join together the separate lines of each entry
  228.     while read bline
  229.     do    echo $bline
  230.     done < $this_bundle > /tmp/serial1.$$
  231.  
  232.     # set compprd= to prd= field in record containing $permsrch
  233.     bline=`grep -s "$permsrch[:     ]" /tmp/serial1.$$`
  234.            compprd=`expr "$bline" : ".*prd=\([^:     ]*\)"`
  235.     rm -f /tmp/serial1.$$
  236.  
  237.     # Return 0 if serialization is remapped
  238.     serial=`expr "$bline" : ".*serial=.*"`
  239.     [ $serial -ne 0 ] && return 0
  240.     return 1
  241. }
  242.     
  243. # parse the fields in the bundle record, determine if supercede= is set
  244. # returns 0 if a) supercede= is found, and b) if the file it refers to 
  245. # is installed, c) the component is referenced in the superceding bundle
  246. # list.  Otherwise, returns 1. 
  247. #
  248. is_supercede () {
  249.     if sup_record=`grep -s "supercede=" $this_bundle` 
  250.     then
  251.         supercede=`expr "$sup_record" : ".*supercede=\([^:     ]*\)"`
  252.         [ -f /etc/perms/bundle/$supercede ] || return 1
  253.  
  254.         super_bundle=/etc/perms/bundle/$supercede
  255.         super_perms=$permsfile
  256.         [ $tmppermsflag ] && super_perms=$bund_perm
  257.         return 0
  258.     else
  259.         # no bundle lists supercede this bundle list
  260.         return 1
  261.     fi
  262. }
  263.  
  264. # check the bundle list to determine whether it is tape, ie. mediatype=T
  265. # returns 0 if present, returns 1 if not
  266. is_tape () {
  267.     grep mediatype=T $this_bundle > /dev/null 2>&1
  268.     return $?
  269. }
  270.  
  271. # get the prd= & set= value out of the bundle= line in the bundle list
  272. get_bundle_set () {
  273.     srch_bundle=$this_bundle
  274.     [ $use_super ] && srch_bundle=$super_bundle
  275.  
  276.     # join together the separate lines of each entry
  277.     while read bline
  278.     do    echo $bline
  279.     done < $srch_bundle > /tmp/serial2.$$
  280.  
  281.     bline=`grep -s "bundle=" /tmp/serial2.$$`
  282.         set=`expr "$bline" : ".*bundle=\"\([^\"]*\)"`
  283.     prd=`expr "$bline" : ".*prd=\([^:     ]*\)"`
  284.     rm -f /tmp/serial2.$$
  285. }
  286.  
  287. # this function used when product is not part of a bundle list
  288. get_set_prd () {
  289.     eval `grep "#prd=" $permsfile | sed "s/#//"`
  290.     eval `grep "#set=" $permsfile | sed "s/#//"`
  291. }
  292.  
  293. # Brand files, checking for already-defined serialno/actkey in /tmp/$prd.ser
  294. # Usage: serialize filename...
  295. # Dependencies: prompt(), getyn(), rights(), error() 
  296. # Returns 0 if the files are successfully branded or 1 upon failure
  297. #
  298. serialize () {
  299.     MANUALSERIAL=no
  300.     _file="$*"
  301.     if    [ -s ./tmp/$prd.ser ]     # serialization occurred previously
  302.     then    . ./tmp/$prd.ser     # so, find out old serialization values
  303.     else    
  304.         [ $OASH ] || {
  305.         rights
  306.         echo "${set:-Product} Serialization.
  307.  
  308. When prompted, use the serial number and activation key included 
  309. with the ${set:-Product} distribution."
  310.         }
  311.     fi
  312.     until    [ "$_serial" -a "$_key" ] || {
  313.  
  314.             [ $OASH ] && {
  315.                 rights && prompt || return 1
  316.             } || {
  317.                 mesg="Enter your serial number "
  318.                 prompt || return 1
  319.                 _serial=$cmd
  320.                 mesg="Enter your activation key " 
  321.                 prompt || return 1
  322.                 _key=$cmd
  323.             }
  324.  
  325.             MANUALSERIAL=yes
  326.         }
  327.         if [ "$remap" ]
  328.         then
  329.              /etc/brand -b $compprd $bundlelist $_serial $_key $_file \
  330.                 >/dev/null 2>/dev/null
  331.         else
  332.              /etc/brand -q $_serial $_key $_file >/dev/null 2>/dev/null
  333.         fi
  334.  
  335.     do    stat=$?    
  336.         
  337.         case $stat in
  338.         1)    error "please try again"    ;;
  339.         2)    error "Invalid activation key"    ;;
  340.         3)    error "$_file is already serialized"
  341.             break                 ;;
  342.         esac
  343.         
  344.         [ $OASH ] && {
  345.             wmopen 2 4 50 19 15 
  346.             wmtitle "Serialization"
  347.         }
  348.         _serial= _key=
  349.         getyn "Do you wish to try activation again?" && continue
  350.         [ $OASH ] && {
  351.             error "This product will not work correctly without proper serialization."
  352.             return 1
  353.         } || {
  354.             error "
  355.     ${set:-This product} will not work correctly without
  356.     proper serialization.  Contact your support center
  357.     to obtain a valid activation key and re-install."
  358.         return 1
  359.         }
  360.     done
  361.  
  362.     # Code added for 3.2.4 OS cuts, whose M01 may contain fixes to
  363.     # /etc/conf/pack.d/kernel/io.a and /etc/conf/pack.d/kernel/os.a.
  364.     # The entire archives are too big to fit, so the variant objects
  365.     # must be archived in now that os.a has been serialized; io.a should
  366.     # really be updated within custom, but safer not to do that just now.
  367.     #
  368.     fix=/usr/lib/custom/fix
  369.     ker=./etc/conf/pack.d/kernel
  370.     for f in $_file
  371.     do    [ "$f" = "$ker/os.a" ] && {
  372.             [ -x /bin/idar ] && AR=/bin/idar || AR=ar
  373.             for d in io.a os.a
  374.             do [ -d $fix/$ker/$d ] &&
  375.                ( cd $fix/$ker/$d && $AR ru $workingdir/$ker/$d *.o )
  376.             done
  377.             break
  378.         }
  379.     done >/dev/null 2>&1
  380.     unset fix
  381.     unset ker
  382.  
  383.     unset _file
  384.     echo "_serial=$_serial _key=$_key" > ./tmp/$prd.ser 
  385. #if serialization is manual then update the serialization log 
  386.     [ "$MANUALSERIAL" = "yes" ] && serlog $_serial $prd
  387.     MANUALSERIAL="no"
  388.     return 0
  389. }
  390.  
  391. usage () {
  392.     echo "\n\tUsage:\t/etc/serialize <permsfile>\n\t\
  393. <permsfile> is the permissions file (e.g. /etc/perms/rtsmd)\n\tthat \
  394. contains a list of files to be serialized.\n"
  395.     cleanup $FAIL
  396. }
  397.  
  398.  
  399. ####  begin main  ####
  400.  
  401. cd $workingdir
  402.  
  403. [ $# -ne 1 ] && usage
  404.  
  405. # permsfile is expected to be "/etc/perms/[product]"
  406. permsfile=$1
  407. [ -f "$permsfile" ] || {
  408.     echo "Error. $permsfile does not exist."
  409.     cleanup $FAIL
  410. }
  411.  
  412. # this is an environment variable that means delay serialization 
  413. [ "$_SERIALIZE" ] && cleanup $OK
  414.  
  415. # if there are files to serialize, proceed; otherwise exit
  416. set_serfiles || cleanup $OK
  417.  
  418. # determine if this product is part of a bundle
  419. if is_bundle 
  420. then
  421.     # set $compprd & determine if remapping is necessary
  422.     if is_serial
  423.     then
  424.         remap=yes
  425.         # is this bundle list superceded by any other bundle list?
  426.         if is_supercede
  427.         then
  428.             # $set gets the bundle= value from the supercede bundle 
  429.             use_super=true
  430.             # reset $compprd (likely to be identical)
  431.             is_serial
  432.         fi
  433.  
  434.         # $set gets bundle= value from appropriate bundle list
  435.         # $prd gets bundle prd= value from appropriate bundle list
  436.         get_bundle_set
  437.  
  438.         # set $bundlelist for use by brand
  439.         bundlelist=$this_bundle
  440.     else
  441.         # bundle, but no remapping; get set= & prd= from perms list 
  442.         get_set_prd
  443.         compprd=$prd
  444.     fi
  445.  
  446. else
  447.     # product is not part of a bundle; get set & prd from product perms file
  448.     get_set_prd
  449. fi
  450.  
  451. # serialize the files
  452. # find out if this script is run via oash
  453. eval oainit 2>/dev/null && OASH=1 || OASH=
  454.  
  455. [ $OASH ] && {
  456.     werase
  457.     wrefresh
  458.     dateline $0
  459.     # open main window
  460.     wmopen 1 21 80 4 0
  461. }
  462.  
  463. serialize $serfiles || cleanup $FAIL
  464.  
  465. cleanup $OK
  466.