#!/bin/ksh
#
# Copyright 2005 Sun Microsystems, Inc.  All Rights Reserved
#
# patchscript for security components Solaris 2.8, sparc 32 and 64 bit and PC


hostname=`uname -p`
echo "${hostname}"

if [ $hostname = i386 ]; then
sparc=1
i386=0
sbc_plat="_i86pc"
else
sparc=0
i386=1
fi

platform[$sparc]="sparc"
platform[$i386]="i386"
platforms="${platform[0]}"

dir_64_sparc=sparcv9
dir_64_x86=amd64

#incompat[$i386]=
#obsolete[$i386]=
#requires[$i386]=
#incompat[$sparc]=
#obsolete[$sparc]=
#requires[$sparc]=

date=`date +"%b\/%d\/%Y"`


#
# Commands
#
CP="/usr/bin/cp"
LS="/usr/bin/ls"
CAT="/usr/bin/cat"
PWD="/usr/bin/pwd"
SED="/usr/bin/sed"
CHMOD="/usr/bin/chmod"
MKDIR="/usr/bin/mkdir"
AWK="/usr/bin/awk"
GREP="/usr/bin/grep"
RM="/usr/bin/rm"

base_dir=`${PWD}`

security_base_dir="$base_dir/../.."

patch_scripts="prepatch postpatch prebackout postbackout"

dest=${base_dir}/dist/patches

# default values
do_build_readme_only=0
do_freshbits=0

while getopts rp:b:f option
do
        case $option in
                r)      do_build_readme_only=1;;
		p)      common=$OPTARG;;
		b)      security_base_dir=$OPTARG;;
		f)      do_freshbits=1;;
        esac
done

if [ "$common" = "" ] ;
then
    echo "Usage $0 -p <patch_dir>"
    exit 1
fi

if [ ! -d $common ] ;
then
	echo "No patch description at $common"
	exit 1
fi

ADD_JSS3=0
if [ ! "${JSS3_LOCATION}" = "" ] ;
then
    echo "Using JSS3 from ${JSS3_LOCATION}"
    ADD_JSS3=1
fi

common=`cd ${common};pwd`

echo "Using directory ${common} to build patch."
security_dir=${security_base_dir}/dist
SBC_PKG=${JSS3_LOCATION}/packages/SunOS5.8${sbc_plat}_OPT.OBJ
SBCX_PKG=${JSS3_LOCATION}/packages/SunOS5.8${sbc_plat}_OPT.OBJ

# Get component versions
get_nspr_mod () {
    from_file=$1
    search_string=$2
    value=`grep ^${search_string} ${from_file} | /usr/bin/sed -e 's: *::g' -e 's|^.*=||g'`

    echo ${value}
}
get_nspr_version () {
    if [ -f  ${security_base_dir}/nspr/config/module.df ] ;
    then
      # NSPR 4.1
      search_file=${security_base_dir}/nspr/config/module.df
      nspr_mod_version=`get_nspr_mod ${search_file} MOD_VERSION`
      nspr_mod_minor=`get_nspr_mod ${search_file} MOD_MINOR`
      nspr_mod_patch=`get_nspr_mod ${search_file} MOD_PATCH`
      value=${nspr_mod_version}.${nspr_mod_minor}.${nspr_mod_patch}
    else
      # NSPR 4.4
	  value=`grep PR_VERSION ${security_base_dir}/nspr/pr/include/prinit.h | sed -e 's/"$//' -e 's/.*"//' -e 's/ .*//'`
    fi
    echo $value
}

nspr_version=`get_nspr_version`
nss_version=`grep NSS_VERSION ${security_base_dir}/nss/lib/nss/nss.h | head -1 | sed -e 's/[^"]*"//' -e 's/".*//' -e 's/ .*//' | cut -d. -f1-3`
jss_version=`grep JSS_VERSION ${security_base_dir}/jss/org/mozilla/jss/util/jssver.h | sed -e 's/"$//' -e 's/.*"//' -e 's/ .*//'`
jss_major=`echo $jss_version | cut -d . -f 1`

echo "NSPR $nspr_version"
echo "NSS $nss_version"
echo "JSS $jss_version"

# Insert architecture in version
# Example: "5.8 5.9" becomes "5.8_x86 5.9_x86"
insert_arch () {
  l_version=$1
  l_arch=$2
  
  # insert version for each blank
  result=$(echo "${l_version}" | ${SED} -e "s/ /${l_arch} /g")
  # add l_arch at the end
  result=${result}${l_arch}
  
  echo $result
} # insert_arch

build_readme () {
  otherpatchnumbase=${patch_num[! $index]}
  otherpatchnum=${otherpatchnumbase}-$patch_rev
  if [ $plat = sparc ]; then
    vermod=""
    sed_64bit='s/{UNIX}/'${vermod}'/g'
    sed_64dir='s/{dir64}/'${dir_64_sparc}'/g'
    sed_arch1='s/#SPARC_ONLY#//g'
    sed_arch2='/#X86_ONLY#/d'
    os_version_with_arch=${os_version}
    os_release_with_arch=${os_release}
  else
    vermod="_x86" 
    sed_64bit='/{UNIX}/d'
    sed_64dir='s/{dir64}/'${dir_64_x86}'/g'
    sed_arch1='s/#X86_ONLY#//g'
    sed_arch2='/#SPARC_ONLY#/d'
    os_version_with_arch=$(insert_arch "${os_version}" "${vermod}")
    os_release_with_arch=$(insert_arch "${os_release}" "${vermod}")
  fi
  echo "from template:"
  ls -l ${common}/patch.README

  ${SED} -e 's/#PATCHID#/'${thispatchnum}'/g' \
      -e 's/#PATCHID_BASE#/'${patch_base}'/g' \
      -e 's/#O_PATCHID_BASE#/'${otherpatchnumbase}'/g' \
      -e 's/_#VERMOD#/'${vermod}'/g' \
      -e 's/#DATE#/'${date}'/g' \
      -e 's/#PLAT#/'${platform[$index]}'/g' \
      -e 's/#O_PLAT#/'${platform[! $index]}'/g' \
      -e "s/#OS_VERSION#/${os_version}/g" \
      -e "s/#OS_RELEASE#/${os_release}/g" \
      -e "s/#OS_VERSION_WITH_ARCH#/${os_version_with_arch}/g" \
      -e "s/#OS_RELEASE_WITH_ARCH#/${os_release_with_arch}/g" \
      -e "s/#OBSLIST#/${obsolete[$index]}/g" \
      -e 's/#INCOMPLIST#/'${incompat[$index]}'/g' \
      -e 's/#REQLIST#/'${requires[$index]}'/g' \
      -e 's/#SECURITY_VERSION#/'${security_version}'/g' \
      -e 's/#NSPR_VERSION#/'${nspr_version}'/g' \
      -e 's/#NSS_VERSION#/'${nss_version}'/g' \
      -e 's/#JSS_VERSION#/'${jss_version}'/g' \
      -e $sed_64bit \
      -e $sed_64dir \
      -e $sed_arch1 \
      -e $sed_arch2 \
	  -e '/^#/d' \
      ${common}/patch.README > patch_files/README.${thispatchnum}
}

# get variable from patch.infos file
INFO_SEP==

get_info () {
    info_param=$1
    value=`${GREP} ^$info_param$INFO_SEP ${common}/patch.infos | ${AWK} -F$INFO_SEP '{ print $2 }'`
    echo $value
}

# Get package index from package name
get_pkgindex () {
   package=$1
   total_pkg=10
   dindex=0
   while [ $dindex -lt ${total_pkg} ]
   do
     if [ $package = ${pkg_name[$dindex]} ]; then
       break;
     fi
     let "dindex = dindex + 1"
   done
   echo $dindex
}
# parse info files for this patch

patch_rev=`get_info REV`
patch_num[$sparc]=`get_info SPARC_NUM`
patch_num[$i386]=`get_info X86_NUM`
os_version="`get_info OS_VERSION`"
build_os_version=`get_info BUILD_OS_VERSION`
pkg_os_version_sparc=`get_info PKG_OS_VERSION_SPARC`
if [ -z "$pkg_os_version_sparc" ] ;
then
  pkg_os_version_sparc=$build_os_version
fi
pkg_os_version_x86=`get_info PKG_OS_VERSION_X86`
if [ -z "$pkg_os_version_x86" ] ;
then
  pkg_os_version_x86=$build_os_version
fi
security_version=`get_info SECURITY_VERSION`
pkglist[$sparc]=`get_info SPARC_PKGLIST`
pkglist[$i386]=`get_info X86_PKGLIST`
incompat[$i386]=`get_info X86_INCOMPAT`
obsolete[$i386]=`get_info X86_OBSOLETE`
requires[$i386]=`get_info X86_REQUIRES`
patch_corrects[$i386]=`get_info X86_PATCH_CORRECTS`
incompat[$sparc]=`get_info SPARC_INCOMPAT`
obsolete[$sparc]=`get_info SPARC_OBSOLETE`
requires[$sparc]=`get_info SPARC_REQUIRES`
patch_corrects[$sparc]=`get_info SPARC_PATCH_CORRECTS`
os_release=`echo ${os_version} | ${SED} -e "s/5\.//g"`
freshbit_from_pkg=`get_info FRESHBIT_FROM_PKG`

echo "========================================"
echo "patch_rev=$patch_rev"
echo "patch_num[sparc]=${patch_num[$sparc]}"
echo "patch_num[i386]=${patch_num[$i386]}"
echo "os_version=$os_version"
echo "obsolete[sparc]=[${obsolete[$sparc]}]"
echo "obsolete[i386]=[${obsolete[$i386]}]"
echo "========================================"

index=0

     SUNWtls=0
     SUNWpr=1
     SUNWjss=2
     SUNWtlsu=3
     SUNWprd=4
     SUNWtlsd=5
     SUNWtlsx=6
     SUNWprx=7
     SUNWjssx=8
     SUNWtlsux=9
     SUNWjss3=10
     SUNWjssx3=11

     obj_sparc="SunOS${pkg_os_version_sparc}_OPT.OBJ"
     obj_sparc64="SunOS${pkg_os_version_sparc}_64_OPT.OBJ"
     obj_i386="SunOS${pkg_os_version_x86}_i86pc_OPT.OBJ"
     obj_i386_64="SunOS${pkg_os_version_x86}_i86pc_64_OPT.OBJ"

#     obj_sparc="SunOS5.8_OPT.OBJ"
#     obj_sparc64="SunOS5.8_64_OPT.OBJ"
#     obj_i386="SunOS5.8_i86pc_OPT.OBJ"

     pkg_name[$SUNWtls]="SUNWtls"
     pkg_name[$SUNWtlsx]="SUNWtlsx"
     pkg_name[$SUNWpr]="SUNWpr"
     pkg_name[$SUNWprx]="SUNWprx"
     pkg_name[$SUNWjss]="SUNWjss"
     pkg_name[$SUNWjssx]="SUNWjssx"
     pkg_name[$SUNWtlsu]="SUNWtlsu"
     pkg_name[$SUNWtlsux]="SUNWtlsux"
     pkg_name[$SUNWprd]="SUNWprd"
     pkg_name[$SUNWtlsd]="SUNWtlsd"

# Test if 64 bit packages exist in build
# Otherwise consider 32/64 bit packages merged
# Merge by default
MERGE64=1
if [ ! -d ${security_dir}/${obj_sparc64}/pkgarchive/SUNWprx ] ;
then
	MERGE64=1
     pkg_name_build[$SUNWtlsx]="SUNWtls"
     pkg_name_build[$SUNWprx]="SUNWpr"
     pkg_name_build[$SUNWjssx]="SUNWjss"
     pkg_name_build[$SUNWtlsux]="SUNWtlsu"
else
	MERGE64=0
     pkg_name_build[$SUNWtlsx]="SUNWtlsx"
     pkg_name_build[$SUNWprx]="SUNWprx"
     pkg_name_build[$SUNWjssx]="SUNWjssx"
     pkg_name_build[$SUNWtlsux]="SUNWtlsux"
fi

for plat in ${platforms}
do
  if [ $plat = sparc ]; then 
     if [ ${MERGE64} = 1 ] ;
     then
       obj_dir=$obj_sparc
       obj_dir32=$obj_sparc64
       obj_dir64=$obj_sparc64
     else
       obj_dir=$obj_sparc
       obj_dir32=$obj_sparc
       obj_dir64=$obj_sparc64
     fi
	 obj_dir32jss=$obj_dir32
	 fresh_dir32=$obj_sparc
	 fresh_dir64=$obj_sparc64
     file_plat=sparc
  else
     if [ ${MERGE64} = 1 ] ;
     then
       obj_dir=$obj_i386_64
       obj_dir32=$obj_i386_64
	   obj_dir32jss=$obj_i386_64
     else
       obj_dir=$obj_i386
       obj_dir32=$obj_i386
	   obj_dir32jss=$obj_dir32
     fi
     obj_dir64=$obj_i386_64
	 fresh_dir32=$obj_i386
	 fresh_dir64=$obj_i386_64
     file_plat=x86
  fi
    
     pkg_base[$SUNWtls]=${security_dir}/${obj_dir32}/pkgarchive/SUNWtls
     pkg_base[$SUNWpr]=${security_dir}/${obj_dir32}/pkgarchive/SUNWpr
     pkg_base[$SUNWtlsx]=${security_dir}/${obj_dir64}/pkgarchive/${pkg_name_build[${SUNWtlsx}]}
     pkg_base[$SUNWprx]=${security_dir}/${obj_dir64}/pkgarchive/${pkg_name_build[${SUNWprx}]}
     pkg_base[$SUNWjss3]=${SBC_PKG}/SUNWjss
     pkg_base[$SUNWjssx3]=${SBCX_PKG}/SUNWjssx
     pkg_base[$SUNWjss]=${security_dir}/${obj_dir32jss}/pkgarchive/SUNWjss
     pkg_base[$SUNWjssx]=${security_dir}/${obj_dir64}/pkgarchive/${pkg_name_build[${SUNWjssx}]}
     pkg_base[$SUNWtlsu]=${security_dir}/${obj_dir32}/pkgarchive/SUNWtlsu
     pkg_base[$SUNWtlsux]=${security_dir}/${obj_dir64}/pkgarchive/${pkg_name_build[${SUNWtlsux}]}
     pkg_base[$SUNWprd]=${security_dir}/${obj_dir32}/pkgarchive/SUNWprd
     pkg_base[$SUNWtlsd]=${security_dir}/${obj_dir32}/pkgarchive/SUNWtlsd

  patch_base=${patch_num[$index]}
  patch_build_dir=build/${patch_base}
  # Cleanup build dir
  rm -rf ${patch_build_dir}
  mkdir -p ${patch_build_dir}

  proto_base="/tmp/"${patch_base}
  thispatchnum=${patch_base}-${patch_rev}
  thispatch=${dest}/${thispatchnum}

  if [ do_build_readme_only -eq 1 ]; then
     cd ${patch_build_dir}
     echo "Building README.${thispatchnum}"
     build_readme
     cp -fp patch_files/README.${thispatchnum} ${dest}/${thispatchnum}
     cd ${base_dir}
     let "index = index + 1"
     continue
  fi

######################################################
# Make sure that all of the correct directories exist
#######################################################
  if [ ! -d ${patch_build_dir}/patch_files ]; then
     mkdir -p ${patch_build_dir}/patch_files
  fi
  for package in `cd ${common}; ${LS} *.prototype.${file_plat}`
  do
    pkg=${package%\.prototype*}
    if [ ! -d ${patch_build_dir}/$pkg ]; then
       mkdir -p ${patch_build_dir}/${pkg}
       echo "Made directory $(pwd)/${patch_build_dir}/${pkg}"
     fi
  done

############################
# Go to the patch directory
###########################
  cd ${patch_build_dir}

###########################
# Delete the old stuff
###########################
  if [ -d ${thispatch} ]; then
     echo "removing any previously built version of this patch"
     rm -rf ${thispatch}
  fi

###################################
# Create the patch output directory
##################################
  if [ ! -d ${dest} ]; then
     ${MKDIR} -p ${dest}
  fi

###############################
# Create the 'proto' area
################################
  echo "==== creating proto area"
  if [ -e ${proto_base} ] ;
  then
    rm -rf ${proto_base}
  fi
  ${MKDIR} -p ${proto_base}
  packages=${pkglist[$index]}
  for package in ${packages} 
  do
    dindex=`get_pkgindex $package`
    package_base=${pkg_base[$dindex]}
    echo "Copying $package from ${pkg_base[$package]}"
    (cd ${package_base}/reloc; find . -depth | cpio -pdmvu ${proto_base})
  done
 
  # add secv1 sub-dir for SunOS 5.8 and SunOS 5.9
  if [ ${build_os_version} = 5.8 ] || [ ${build_os_version} = 5.9 ] ;
  then
    if [ -e ${proto_base}/usr/lib/mps ] && [ ! -d ${proto_base}/usr/lib/mps/secv1 ] ;
    then
      echo "Add usr/lib/mps/secv1 sub-dir"
      mv ${proto_base}/usr/lib/mps ${proto_base}/usr/lib/secv1
      mkdir ${proto_base}/usr/lib/mps
      mv ${proto_base}/usr/lib/secv1 ${proto_base}/usr/lib/mps
    fi
    if [ -e ${proto_base}/usr/share/lib/mps ] && [ ! -d ${proto_base}/usr/share/lib/mps/secv1 ] ;
    then
      echo "Add usr/share/lib/mps/secv1 sub-dir"
      mv ${proto_base}/usr/share/lib/mps ${proto_base}/usr/share/lib/secv1
      mkdir ${proto_base}/usr/share/lib/mps
      mv ${proto_base}/usr/share/lib/secv1 ${proto_base}/usr/share/lib/mps
    fi
  fi # add secv1 for 5.8 and 5.9

  # Special for patch 121767 (JSS 3.x on S10)
  if [ $patch_base = 121767 ] || [ $patch_base = 121768 ];
  then
    echo "Remove secv1 for patches 121767 and 121768"
    cp ${proto_base}/usr/lib/mps/secv1/libjss3.so ${proto_base}/usr/lib/mps
    cp ${proto_base}/usr/share/lib/mps/secv1/jss3.jar ${proto_base}/usr/share/lib/mps
    if [ $plat = sparc ] ;
    then
      echo "Sparc: add 64 bit binaries from SUNWjssx"
      # Add 64 bit packages
      package=SUNWjssx
      dindex=`get_pkgindex $package`
      package_base=${pkg_base[$dindex]}
      echo "Copying $package from ${pkg_base[$package]}"
      (cd ${package_base}/reloc; find . -depth | cpio -pdmvu ${proto_base})
      mkdir -p ${proto_base}/usr/lib/mps/sparcv9
      cp ${proto_base}/usr/lib/mps/secv1/sparcv9/libjss3.so ${proto_base}/usr/lib/mps/sparcv9
      mkdir -p ${proto_base}/usr/share/lib/mps/sparcv9
      cp ${proto_base}/usr/share/lib/mps/secv1/sparcv9/jss3.jar ${proto_base}/usr/share/lib/mps/sparcv9
    fi
  fi

  # Adding JSS3
  if [ $ADD_JSS3 -eq 1 ]
  then
    echo "Copying JSS3 from ${pkg_base[$SUNWjss3]}"
    (cd ${pkg_base[$SUNWjss3]}/reloc; find . -depth | cpio -pdmvu ${proto_base})
    echo "Copying JSS3 (64) from ${pkg_base[$SUNWjssx3]}"
    (cd ${pkg_base[$SUNWjssx3]}/reloc; find . -depth | cpio -pdmvu ${proto_base})
  fi # JSS3_LOCATION

###############################
# Create README.<patchnum> file
###############################

  echo "======building readme...."
  build_readme
  echo "======done building readme...."

#######################################################
# Copy certain packaging files from the original packages
#######################################################
  for package in `${LS} -d SUNW*`
  do
    if [ ! -d ${package}/install ]; then
      mkdir -p ${package}/install
    fi
###################################################
# Copy any package 'depend' files
##################################################
  echo "------ Copy any package 'depend' files"
    dindex=`get_pkgindex $package`
    package_base=${pkg_base[$dindex]}
    if [ -r ${package_base}/install/depend ]; then
      ${CP} -fp ${package_base}/install/depend ${package}/install
    fi
    if [ -r ${package_base}/install/copyright ]; then
      ${CP} -fp ${package_base}/install/copyright ${package}/install
    fi
###################################################
# Copy any patch 'deletes' files for this package
##################################################    
    if [ -r ${common}/${package}.deletes ]; then
      ${CP} -fp ${common}/${package}.deletes ${package}/install/deletes
    fi
  done
######################################
# Copy pkginfo files
####################################
  echo "------ Copy pkginfo files ----------------------------"
pwd
  packages=${pkglist[$index]}
  for package in ${packages} 
  do
    ${RM} -f $package/pkginfo
    ${SED}  \
      -e 's/#NSPR_VERSION#/'${nspr_version}'/g' \
      -e 's/#NSS_VERSION#/'${nss_version}'/g' \
      -e 's/#JSS_VERSION#/'${jss_version}'/g' \
	  -e "s/#OBSLIST#/${obsolete[$index]}/g" \
      ${common}/${package}.pkginfo.${file_plat} > $package/pkginfo

#    cp -f ${common}/${package}.pkginfo.${file_plat} $package/pkginfo
    ${CP} -fp ${common}/${package}.prototype.${file_plat} ${package}/prototype
  done

##########################################
# Copy in the common pre/post patch files
##########################################
  echo "------ Copy in the common pre/post patch files -------"
  for script in ${patch_scripts}
  do
    if [ -r ${common}/${script} -a ! -f patch_files/${script} ]; then
	  echo "processing patch script $script..."
      ${SED}  \
        -e "s/#OS_VERSION#/${os_version}/g" \
        -e "s/#OS_RELEASE#/${os_release}/g" \
        ${common}/${script} > patch_files/${script}
#      ${CP} -fp ${common}/${script} patch_files/${script}
    fi
  done

  ${CHMOD} 644 SUNW*/pkginfo SUNW*/prototype

#  package_into_patch=""
  pkglist_os=${pkglist[$index]}
  echo "List of packages included into the patch:"
  echo $pkglist_os
  for cur_pkgname in $pkglist_os
  do
    package_into_patch=${package_into_patch}" -P ${cur_pkgname} ${proto_base} ${base_dir}/${patch_build_dir}/${cur_pkgname}"
  done

# OBSOLETES field
if [ "${obsolete[$index]}" = "" ] ;
then
  OBSOLETE_OPT=""
else
  OBSOLETE_OPT=" -o "
fi

# PATCH_CORRECTS field
if [ "${patch_corrects[$index]}" = "" ] ;
then
  PATCH_CORRECTS_OPT=""
else
  PATCH_CORRECTS_OPT="-C ${patch_corrects[$index]}"
fi

  echo "building patch" ${thispatchnum}

   set -x
  /net/pip-tools.us.oracle.com/latest/buildpatch/buildpatch \
-v \
-f directory \
-p ${thispatchnum} \
-M ${base_dir}/${patch_build_dir}/patch_files \
-d ${dest} \
-k \"\" \
-A "${plat}" \
-s "${os_version}" \
${package_into_patch} \
${PATCH_CORRECTS_OPT}\
${OBSOLETE_OPT}"${obsolete[$index]}"

  errcode=$?
  set +x

  if [ ! $errcode -eq 0 ] ;
  then
	echo "Failed to build patch ${thispatchnum} ($errcode)"
	exit $errcode
  fi

# Set the permissions on the prepatch and postpatch scripts correctly
#
  for script in ${patch_scripts}
  do
    if [ -f ${thispatch}/${script} ]; then
      ${CHMOD} 555 ${thispatch}/${script}
    fi
  done

  ${CHMOD} 444 SUNW*/pkginfo SUNW*/prototype

  echo "deleting proto area "
  rm -rf ${proto_base}

  let "index = index + 1"

  cd ${base_dir}

if [ $do_freshbits -eq 1 ] ;
then
######################
#
# Freshbits
#
#####################

  # RTM packages
  if [ -n "${freshbit_from_pkg}" ] ;
  then
  	  # from the patch.infos file
	  NSS_SPARC=${freshbit_from_pkg}
	  TLS_SPARC=${freshbit_from_pkg}
	  TLSUX_SPARC=${freshbit_from_pkg}
	  NSPR_SPARC=${freshbit_from_pkg}
	  JSS_SPARC=${freshbit_from_pkg}
	
	  NSS_X86=${freshbit_from_pkg}
	  TLS_X86=${freshbit_from_pkg}
	  NSPR_X86=${freshbit_from_pkg}
	  JSS_X86=${freshbit_from_pkg}
	
	  NSPRDEV_SPARC_X86=${freshbit_from_pkg}
	  NSSDEV_SPARC_X86=${freshbit_from_pkg}  

	  BASE_PKG32_SUBDIR=${fresh_dir32}/packages
	  BASE_PKG64_SUBDIR=${fresh_dir64}/packages
  else
	  # the old way...
	  case ${build_os_version} in
	  5.8 |  5.9)
	  NSS_SPARC=/share/builds/components/nss/NSS_3_3_2-apps-server2
	  TLS_SPARC=/share/builds/components/security/SECURITY_3_3_7_RTM
	  TLSUX_SPARC=/share/builds/components/security/SECURITY_3_3_10_RTM
	  NSPR_SPARC=/share/builds/components/nspr20/v4.1.2-apps-server2
	  JSS_SPARC=/share/builds/components/jss/JSS_3_1_2_3_RTM
	
	  NSS_X86=/share/builds/components/nss/NSS_3_3_3_RTM
	  TLS_X86=/share/builds/components/security/SECURITY_3_3_7_RTM
	  NSPR_X86=/share/builds/components/nspr20/v4.1.3
	  JSS_X86=/share/builds/components/jss/JSS_3_1_2_3_RTM
	
	  NSPRDEV_SPARC_X86=/share/builds/components/security/SECURITY_3_3_6_RTM
	  NSSDEV_SPARC_X86=/share/builds/components/security/SECURITY_3_3_6_RTM
	  ;;
	  5.10)
	  NSPR_S10=/share/builds/components/security/SECURITY_3_9_4_RTM
	  JSS_S10=/share/builds/components/security/SECURITY_3_9_4_RTM
	  NSS_S10=/share/builds/components/security/SECURITY_3_9_5_RTM
	
	  NSS_SPARC=${NSS_S10}
	  TLS_SPARC=${NSS_S10}
	  TLSUX_SPARC=${NSS_S10}
	  NSPR_SPARC=${NSPR_S10}
	  JSS_SPARC=${JSS_S10}
	
	  NSS_X86=${NSS_S10}
	  TLS_X86=${NSS_S10}
	  NSPR_X86=${NSPR_S10}
	  JSS_X86=${JSS_S10}
	
	  NSPRDEV_SPARC_X86=${NSPR_S10}
	  NSSDEV_SPARC_X86=${NSS_S10}
	  ;;
	  esac
	  BASE_PKG32_SUBDIR=packages/${fresh_dir32}
	  BASE_PKG64_SUBDIR=packages/${fresh_dir64}
  fi # if [ -n "$freshbit_from_pkg" ]

  # Security 334x patches
  SECURITY334X_PATCHES_ROOT=/share/builds/components/securitypatches
  SECURITY334X_PATCHES_REV=-12
  SECURITY334X_NUM_S8_SPARC=114045${SECURITY334X_PATCHES_REV}
  SECURITY334X_NUM_S8_X86=114046${SECURITY334X_PATCHES_REV}
  SECURITY334X_NUM_S9_SPARC=114049${SECURITY334X_PATCHES_REV}
  SECURITY334X_NUM_S9_X86=114050${SECURITY334X_PATCHES_REV}
  SECURITY334X_PATCHES_S8_SPARC=SunOS5.8/sparc/patches/${SECURITY334X_NUM_S8_SPARC}
  SECURITY334X_PATCHES_S8_X86=SunOS5.8/i386/patches/${SECURITY334X_NUM_S8_X86}
  SECURITY334X_PATCHES_S9_SPARC=SunOS5.9/sparc/patches/${SECURITY334X_NUM_S9_SPARC}
  SECURITY334X_PATCHES_S9_X86=SunOS5.9/i386/patches/${SECURITY334X_NUM_S9_X86}
  case "$os_version" in
    "5.8")
	SECURITY334X_NUM_SPARC=${SECURITY334X_NUM_S8_SPARC}
	SECURITY334X_NUM_X86=${SECURITY334X_NUM_S8_X86}
	SECURITY334X_PATCHES_SPARC=${SECURITY334X_PATCHES_S8_SPARC}
	SECURITY334X_PATCHES_X86=${SECURITY334X_PATCHES_S8_X86}
	;;
	"5.9")
	SECURITY334X_NUM_SPARC=${SECURITY334X_NUM_S9_SPARC}
	SECURITY334X_NUM_X86=${SECURITY334X_NUM_S9_X86}
	SECURITY334X_PATCHES_SPARC=${SECURITY334X_PATCHES_S9_SPARC}
	SECURITY334X_PATCHES_X86=${SECURITY334X_PATCHES_S9_X86}
	;;
  esac

  if [ ! -d ${base_dir}/dist/freshbits/${thispatchnum} ]; then
     echo "----------building freshbit directory----------"
     mkdir -p ${base_dir}/dist/freshbits/${thispatchnum}
  fi
  if [ $plat = sparc ]; then
   cp -rp ${NSPR_SPARC}/${BASE_PKG32_SUBDIR}/SUNWpr \
                ${base_dir}/dist/freshbits/${thispatchnum}
   cp -rp ${NSPRDEV_SPARC_X86}/${BASE_PKG32_SUBDIR}/SUNWprd \
                ${base_dir}/dist/freshbits/${thispatchnum}
   echo "--copied nspr 32 bit pkgs--"
   if [ -e ${NSPR_SPARC}/${BASE_PKG64_SUBDIR}/SUNWprx ] ;
   then
     cp -rp ${NSPR_SPARC}/${BASE_PKG64_SUBDIR}/SUNWprx   ${base_dir}/dist/freshbits/${thispatchnum}
     echo "--copied nspr 64 bit pkgs--"
   fi
   cp -rp ${NSS_SPARC}/${BASE_PKG32_SUBDIR}/SUNWtls ${base_dir}/dist/freshbits/${thispatchnum}
   cp -rp ${TLS_SPARC}/${BASE_PKG32_SUBDIR}/SUNWtlsu ${base_dir}/dist/freshbits/${thispatchnum}
   cp -rp ${NSSDEV_SPARC_X86}/${BASE_PKG32_SUBDIR}/SUNWtlsd \
                ${base_dir}/dist/freshbits/${thispatchnum}
   echo "--copied nss 32 bit pkgs--"
   if [ -e ${NSS_SPARC}/${BASE_PKG64_SUBDIR}/SUNWtlsx ] ;
   then
     cp -rp ${NSS_SPARC}/${BASE_PKG64_SUBDIR}/SUNWtlsx ${base_dir}/dist/freshbits/${thispatchnum}
     cp -rp ${TLSUX_SPARC}/${BASE_PKG64_SUBDIR}/SUNWtlsux ${base_dir}/dist/freshbits/${thispatchnum}
     echo "--copied nss 64 bit pkgs--"
   fi
   cp -rp ${JSS_SPARC}/${BASE_PKG32_SUBDIR}/SUNWjss ${base_dir}/dist/freshbits/${thispatchnum}
   echo "--copied jss 32 bit pkgs--"
   if [ -e ${JSS_SPARC}/${BASE_PKG64_SUBDIR}/SUNWjssx ] ;
   then
     cp -rp ${JSS_SPARC}/${BASE_PKG64_SUBDIR}/SUNWjssx ${base_dir}/dist/freshbits/${thispatchnum}
     echo "--copied jss 64 bit pkgs--"
   fi

   if [ ${build_os_version} = 5.8 ] || [ ${build_os_version} = 5.9 ] ;
   then
     # Bringing 334x patches
     (cd ${base_dir}/dist/patches; ln -s ${SECURITY334X_PATCHES_ROOT}/${SECURITY334X_PATCHES_SPARC} .)
     echo "--Using 3343x patch ${SECURITY334X_NUM_SPARC}--"
     echo "${thispatchnum}"
     /share/builds/components/SUNWcdbd/1.0/pkgpatch -d ${base_dir}/dist/patches -k ${base_dir}/dist/freshbits/${thispatchnum} ${SECURITY334X_NUM_SPARC}
    errcode=$?
    if [ ! $errcode -eq 0 ] ;
    then
      echo "Failed to build freshbits for patch ${SECURITY334X_NUM_SPARC} ($errcode)"
      exit $errcode
    fi
  fi # if 5.8 or 5.9

   /share/builds/components/SUNWcdbd/1.0/pkgpatch -d ${base_dir}/dist/patches -k ${base_dir}/dist/freshbits/${thispatchnum} ${thispatchnum}
  errcode=$?
  if [ ! $errcode -eq 0 ] ;
  then
    echo "Failed to build freshbits for patch ${thispatchnum} ($errcode)"
    exit $errcode
  fi

   echo "----------done creating freshbit packages--------------"
  else # x86
   cp -rp ${NSPR_X86}/${BASE_PKG32_SUBDIR}/SUNWpr ${base_dir}/dist/freshbits/${thispatchnum}
   cp -rp ${NSPRDEV_SPARC_X86}/${BASE_PKG32_SUBDIR}/SUNWprd \
                ${base_dir}/dist/freshbits/${thispatchnum}
   echo "--copied nspr 32 bit pkgs--"
  cp -rp ${NSS_X86}/${BASE_PKG32_SUBDIR}/SUNWtls ${base_dir}/dist/freshbits/${thispatchnum}
  cp -rp ${TLS_X86}/${BASE_PKG32_SUBDIR}/SUNWtlsu ${base_dir}/dist/freshbits/${thispatchnum}
   cp -rp ${NSSDEV_SPARC_X86}/${BASE_PKG32_SUBDIR}/SUNWtlsd \
                ${base_dir}/dist/freshbits/${thispatchnum}
   echo "--copied nss 32 bit pkgs--"
  cp -rp ${JSS_X86}/${BASE_PKG32_SUBDIR}/SUNWjss ${base_dir}/dist/freshbits/${thispatchnum} 
   echo "--copied jss 32 bit pkgs--"

   if [ ${build_os_version} = 5.8 ] || [ ${build_os_version} = 5.9 ] ;
   then
    # Bringing 334x patches
    (cd ${base_dir}/dist/patches; ln -s ${SECURITY334X_PATCHES_ROOT}/${SECURITY334X_PATCHES_X86} .)
     echo "--Using 3343x patch ${SECURITY334X_NUM_X86}--"
     /share/builds/components/SUNWcdbd/1.0/pkgpatch -d ${base_dir}/dist/patches -k ${base_dir}/dist/freshbits/${thispatchnum} ${SECURITY334X_NUM_X86}

    errcode=$?
    if [ ! $errcode -eq 0 ] ;
    then
      echo "Failed to build freshbits for patch ${SECURITY334X_NUM_X86} ($errcode)"
      exit $errcode
    fi
  fi # if 5.8 or 5.9

   /share/builds/components/SUNWcdbd/1.0/pkgpatch -d ${base_dir}/dist/patches -k ${base_dir}/dist/freshbits/${thispatchnum} ${thispatchnum}

  errcode=$?
  if [ ! $errcode -eq 0 ] ;
  then
    echo "Failed to build freshbits for patch ${thispatchnum} ($errcode)"
    exit $errcode
  fi

   echo "----------done creating freshbit packages--------------"
  fi

fi

done

