#!/bin/ksh
#
# $Log: get_sysinfo,v $
# Revision 5.7  2010/02/08 23:26:00  mbaker
# completed phase I of sections
#
# Revision 5.6  2009/12/21 22:26:24  mbaker
# parsing changes to the msinfo32_parser function, changed DATE, changed final IF in main
#
# Revision 5.5  2009/12/02 06:19:48  mbaker
# fixed some minor parses for -win
#
# Revision 5.4  2009/12/02 06:11:36  mbaker
# finished phase I of -win parsing
#
# Revision 5.3  2009/11/04 16:29:06  mbaker
# update
#
# Revision 5.2  2009/07/13 22:39:12  mbaker
# changes to HBA area and windows file read in
#
# Revision 5.1  2008/12/09 12:38:11  mbaker
# new release
#
#
################################################################################
#DOCBEGIN
#
#  Script to gather system configureation information.
#
#  Data is output to a colon delimited file for future processing,
#  either import into a database, or process to an HTML file via
#  the script sysinfo_convert_html.
#
#  This could be run from each system's root cron.
#  Output should be gathered (either use NFS to write to a common
#     place, or rcp/scp/ftp the files in).  If you have DMZ servers,
#     setup the DMZ_HOSTS variable and get those file to your common
#     location by whatever site secure method(s) you have.
#
#  Can use sysinfo_convert_html to take the output of this command
#     and turn it into a html web page.
#
#  Files called: 
#
# 	precendence for config variables: 
#  	 lowest:   settings directly in this file
#  	 next:     CFGFILE settings
#  	 highest:  CLI argurments
#
#       /etc/get_sysinfo.cfg  -  OPTIONAL FILE
#       	Allws for overriding some variables, per system, without having to do CLI args 
#       	Overridding for: 
#              BINDIR
#              OUTPUTDIR
#              OUTPUTFILE
#
#       /etc/companyinfo
#			Allows you to set static info not available via OS commands, 
#			but unique to the server.
#           /etc/companyinfo is not required to exist or to be used.
#
#       Possible fields (you can enter any or all of them):
#
#           Serial Number  = ABC123456
#           Business Unit  = Purchasing
#           Server Usage   = prod|dev|test
#           Location       = datacenter X
#           Server Purpose = purchaseing database
#           Lease Number   = xyz123456abc
#           OldNames       = system1 system2
#           Maintenance    = platinum|gold|silver|bronze
#           Page           = yes|no
#           VirtualMachine = LPAR|NPAR|domains
#           Asset Number   = ABC123456
#           Miscellaneous  = free field
#
#
#
#  Variables:
#       All are set in this script (none from the environment).
#       Some can be overridden via the CFGFILE (def: /etc/get_sysinfo.cfg)
#       The highest overridding is via arguments on the CLI.
#       
#       Overridding for: 
#              BINDIR
#              OUTPUTDIR
#              OUTPUTFILE
#
#  Programs called:
#
#       /$BINDIR/get_dbms            #get oracle databases
#       /$BINDIR/get_emc             #get EMC disk types
#       /$BINDIR/get_rup             #get UPTIME of servers
#       /$BINDIR/get_printers        #get printer queues and their devices
#
#  Runs on:
#
#       SOLARIS (all newer versions), and many varied Sun h/w types
#       AIX (4.3.3, 5.x)
#       HP-UX (10 & 11)
#       LINUX: RedHat, Suse, others?  Hard to tell, too many to try.
#       Windows: gets some basic info **Must have cygwin installed to work***
#                UNLESS you just want it to parse an already made msinfo32.txt file
#                www.cygwin.com (Redhat dlls to give unix for windows)
#                                       
#       To run on Windows or Linux, you must have /bin/ksh.  This is normally
#       accomplished by doing a "ln -s /bin/bash /bin/ksh", otherwise, this 
#       script, and the others called scripts will fail as they use ksh (korn shell). 
# 
#                                       
#  REQUIREMENTS, ISSUES, BUGS, ENHANCEMENTS                                       
#  
#  Solaris 
#   doesn't get any of the newer array info (3xxx, T3, ...), just older ones
#   prtconf is not consistent, it reports different types of devices with 
#           different output (somtimes it has name:, model:, manufacturer:)
#           so, in the script, it should always give a count for a device
#           that is, not miss any, but it may give a larger count than really exits
#           NOTE: this is more of an issue in zones and x86 than with sparc
#
#  AIX 
#   doesn't get any array info
#
#  HP-UX
#   does some adb commands that don't always get good/expected response
#   does some swlist on pkgs that aren't always there
#   the NPAR section is untested
#
#  Linux
#   must have /bin/ksh soft linked to /bin/bash
#
#  Windows
#    must have cygwin to work
#   OR 
#    do a msinfo32 and save to file and run this script against that file
#
#  DISLAIMER: 
#    Use at your own risk.  It should not effect/corrupt/crash a running system.
#    It just queries the system.
#    No guarantee that it will report correctly/accurately, but should.
#    Has NOT necessarily been tested on each version and/or type of hardware.
#    That is, it may know report all hardware types/cards.
#
#  Matt Baker - mbaker@computeranddata.com
#  Latest copy available at www.computeranddata.com/scripts
#
################################################################################
#
#	Variable  Descriptions
#   NODE        --  Hostname of server
#   HOSTID      --  Server hostid
#   SERNUM      --  Server serialnumber
#   ARCH        --  Server platform (sparc,i386)
#   ARCHTYPE    --  Server architecture (sun4u)
#   MODEL       --  Server model 
#   OS          --  Version of Operating System
#   PATCH       --  Version of Kernel Patch
#   FIRMWARE    --  Version of System Firmware
#   CPU         --  Number of CPUs
#   CPUMHZ      --  Speed in Mhz of CPU(s)
#   MEM         --  Amount of memory in MB
#   SWAP        --  Amount of swap 
#   DOMAIN      --  DNS domainname
#   VIRTUAL     --  Zones or VIO
#   VNAMES      --  VIPs/VNAMES
#   VIRTUALMACHINE --  LPAR, NPAR, Sun Domains
#   BRD         --  Number of System and I/O Boards
#   DGS         --  Diskgroup names
#   ZPOOLS      --  ZFS Pool names
#   SSA         --  Number of Sun Storage Arrays
#   PHOTON      --  Number of Photon Disk Arrays
#   ARRAYLIST   --  List of photon/a5000 arryas w/ number disks in array
#   NETRA       --  Number of Netra Disk Arrays
#   RAIDL       --  Number of Internal LSI and/or STK controllers
#   TOTDSK      --  Total number of disks
#   DSKSML      --  Number of disks >=    0 <    2 GB
#   DSK2GB      --  Number of disks >=    2 <    4 GB
#   DSK4GB      --  Number of disks >=    4 <    8 GB
#   DSK8GB      --  Number of disks >=    8 <   18 GB
#   DSK18GB     --  Number of disks >=   18 <   36 GB
#   DSK36GB     --  Number of disks >=   36 <   73 GB
#   DSK73GB     --  Number of disks >=   73 <  100 GB
#   DSK100GB    --  Number of disks >=  100 <  150 GB
#   DSK150GB    --  Number of disks >=  150 <  200 GB
#   DSK200GB    --  Number of disks >=  200 <  300 GB
#   DSK300GB    --  Number of disks >=  300 <  500 GB
#   DSK500GB    --  Number of disks >=  500 < 1000 GB
#   DSKBIG      --  Number of disks >= 1000 < upperlimit
#   DSKEMC      --  Number of EMC SAN disks
#   DSKBCV      --  Number of EMC BCV disks
#   DSKIBM      --  Number of IBM SAN disks
#   DSKHDS      --  Number of HDS SAN disks
#   CDDVD       --  Number of CDROM & DVDs
#   TAPE        --  Number of Tape drives on system: SCSI or FC, can include robots
#   SOC         --  Number of FC/OM modules
#   SCSI        --  Number of SCSI Diff cards
#   N100B       --  Number of 10/100 Network cards
#   GBNIC       --  Number of GB Network cards
#   GBIC        --  Number of GBIC modules
#   HBA         --  Number of HBA cards
#   HBA_TYPE    --  Type of HBA cards (assume same type on a system)
#   HBA_DRV     --  Driver version of HBA cards
#   HBA_FIRM    --  Firmware version of HBA cards
#   HBA_FC      --  FCode version of HBA cards
#   FDD         --  Number of FDDI cards
#   HSI         --  Number of High speed interfaces
#   VIDEO       --  Number of video adapters
#   NET         --  Networks
#   VXVM        --  Veritas VM (or SUNW)
#   VXFS        --  Veritas VXFS
#   VCS         --  Veritas VCS
#   PWRPTH      --  EMC PWRPTH
#   ECC         --  EMC ECC
#   ESN         --  EMC ESN Manager
#   VOLLOG      --  EMC Volume Logix
#   FZ	        --  EMC Fibre Zone
#   NETBACKUP   --  Veritas Netbackup
#   TSM         --  Tivoli Storage Manager (backup)
#   VC          --  Vendor Cluster: SunCluster, HACMP, ServiceGuard
#   PATROL      --  Patrol
#   SCHEDULER   --  Autosys
#   APACHE      --  Apache
#   FORTE       --  Forte
#   NETSCAPE    --  Netscape
#   WEBLOGIC    --  WebLogic
#   WEBSPHERE   --  Websphere
#   BROADVISION --  Broadvision
#   SQL_BKTRK   --  SQL Backtrack
#   PERL        --  Perl
#   JAVA        --  Java
#   TRIPWIRE    --  TRIPWIRE
#
#   BUSUNIT        --  /etc/companyinfo field
#   USAGE          --  /etc/companyinfo field
#   LOCATION       --  /etc/companyinfo field
#   SRVPURP        --  /etc/companyinfo field
#   LSENUM         --  /etc/companyinfo field
#   OLDNAMES       --  /etc/companyinfo field
#   MAINTENANCE    --  /etc/companyinfo field
#   PAGE           --  /etc/companyinfo field
#   VIRTUALMACHINE --  /etc/companyinfo field
#   ASSETNUMBER    --  /etc/companyinfo field
#   MISCELLANEOUS  --  /etc/companyinfo field
#
#DOCEND
###################################################

if [[ -n "$(echo $* | grep '\-debug')" ]]
then
	DEBUG=1
	set -x
fi

OSTYPE=$(uname 2> /dev/null)

if [[ $OSTYPE = SunOS ]]
then
	PATH=/sbin:/usr/sbin:/opt/VRTS/bin:/opt/VRTSvcs/bin:$PATH
	if [[ -f /usr/ucb/echo ]]
	then
		ECHO="/usr/ucb/echo"
	else
		#use ksh print
		ECHO="print"
		#ECHO="/usr/bin/echo"
	fi

elif [[ $OSTYPE = AIX ]]
then
	PATH=/usr/sbin:/opt/VRTS/bin:/opt/VRTSvcs/bin:$PATH
	#use ksh print
	ECHO="print"
	#ECHO="/usr/bin/echo"

elif [[ $OSTYPE = HP-UX ]]
then
	PATH=/usr/sbin:/opt/VRTS/bin:/opt/VRTSvcs/bin:/opt/hpsmc/common/bin:$PATH
	#use ksh print
	ECHO="print"
	#ECHO="/usr/bin/echo"

elif [[ $OSTYPE = Linux ]]
then
	PATH=.:/sbin:/usr/sbin:/usr/bin:/bin:/opt/VRTS/bin:/opt/VRTSvcs/bin:$PATH
	ECHO="/bin/echo"

elif [[ -n $(echo $OSTYPE | grep ^CYGWIN) ]]
then
	PATH=.:/sbin:/usr/sbin:/usr/bin:/bin:$PATH
	ECHO="/usr/bin/echo"
fi

export PATH

###################################################
# Functions
###################################################

###################################################
# make directories
f_cgywin_mkdir_cdrive ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Setting up C drive directories for cygwin"
	fi

	if [[ ! -d $C_DRIVE/temp ]]
	then
		mkdir $C_DRIVE/temp  > /dev/null 2>&1
	fi

	if [[ ! -d $C_DRIVE/stage ]]
	then
		mkdir $C_DRIVE/stage > /dev/null 2>&1
	fi
}

###################################################
# make directories
f_cygwin_prtconf ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Running PRTCONF for cygwin"
	fi

	PRTCONF_FILE="$C_DRIVE/temp/cygwin.systeminfo.out.$$"
	$C_DRIVE/Windows/system32/systeminfo 2> /dev/null > $PRTCONF_FILE
}


###################################################
# run msinfo32 in cygwin style
f_cygwin_msinfo32 ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Prep'ing msinfo32 batch files"
	fi

	#
	# convert the windowsfile to pure text
	#
	MSINFO32_BAT="$C_DRIVE/stage/msinfo32.bat"
	RUNCMD_BAT="$C_DRIVE/stage/runcmd.bat"
	MSINFO32_NFO_FILE=$C_DRIVE/temp/msinfo32-output.nfo
	
	cat <<-EOF > $RUNCMD_BAT
	cmd /C c:\stage\msinfo32.bat
	EOF
			
	if [[ -n $WINDOWSFILE ]]
	then
		cp $WINDOWSFILE $C_DRIVE/temp/msinfo32-output.nfo

		WINDOWSFILE_ORIG=$WINDOWSFILE
		WINDOWSFILE=$C_DRIVE/temp/msinfo32.txt
	else
		WINSYSTEM_OUT="$C_DRIVE/temp/msinfo32.txt"
	fi

	#
	# Note: the "type" command here is a DOS command that "strings" a file
	#
	# Either do a "type" or do a "iconv"
	# Note: the "type" command here is a DOS command that "strings" a file
	# iconv -f UTF-16 -t utf-8 msinfo32.txt > newfile
	#
	if [[ -n $WINDOWSFILE ]]
	then
		if (( VERBOSE ))
		then
			$ECHO "Setting up for nfo to txt convert for $WINDOWSFILE"
		fi

		cat <<-EOF > $MSINFO32_BAT
		cd c:\temp
		type msinfo32-output.nfo > msinfo32.txt
		EOF
	else
		if (( VERBOSE ))
		then
			$ECHO "Setting up for run of msinfo32 then txt convert for $WINDOWSFILE"
		fi
		cat <<-EOF > $MSINFO32_BAT
		cd c:\temp
		c:\WINDOWS\system32\msinfo32.exe /report msinfo32-output.nfo
		type msinfo32-output.nfo > msinfo32.txt
		EOF
	fi	

	chmod 755 $RUNCMD_BAT
	chmod 755 $MSINFO32_BAT
	
	if (( VERBOSE ))
	then
		$ECHO "Running $RUNCMD_BAT"
	fi

	$RUNCMD_BAT > /dev/null
}


###################################################
# get system type/model
f_get_sys_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: main get_sysinfo"
	fi

	ARCHTYPE=$(uname -m)

	if [[ $OSTYPE = "SunOS" ]]
	then
		ARCH=$(uname -p)

		if [[ $ARCHTYPE = "sun4u" ]]
		then
			#
			# CPU is used here, but is not really "set" here for final value
			# It is set in psr section
			#
			CPU="$(grep banner-name: $PRTCONF_FILE \
					| awk -F: '{print $2}' \
					| sed -e "s/\'//g" \
					| awk '{print $NF}' \
					| sed -e 's/)//' \
					| sed -n 1p)"

			if [[ -z $CPU ]]
			then
				if (( ZONEGLOBAL ))
				then
					CPU="$(sed -n 1p $PRTDIAG_FILE \
						| awk '{print $NF}' \
						| sed -e 's/)//' )"
				else
					CPU="unknown"
				fi
			fi

			ARCH="$(uname -p) $CPU"

			MODEL="$(grep banner-name: $PRTCONF_FILE \
					| awk -F: '{print $2}' \
					| cut -c4- \
					| sed -e 's/(.*)//' \
					| sed -e "s/\'//g" \
					| sed -n 1p)"

			if [[ -z $MODEL ]]
			then
				if (( ZONEGLOBAL ))
				then
					MODEL="$(sed -n 1p $PRTDIAG_FILE \
						| awk -F: '{print $2}' )"
				else
					MODEL="unknown"
				fi
			fi


		elif [[ $ARCHTYPE = "i86pc" ]]
		then
			ARCH="$(uname -p) $(grep -i cpu $PRTDIAG_FILE \
									| sed -e 's/ CPU [0-9]*$//' | sort -u)"

			MODEL="$(grep "^System Configuration:" $PRTDIAG_FILE \
					| awk -F: '{print $2}' \
					| sed -e "s/ * / /g" )"

		elif [[ $ARCHTYPE = "sun4m" ]]
		then
			MODEL="$(sed -n 1p $PRTDIAG_FILE \
					| awk '{print $7" "$8" "$9}')"

		else
			MODEL="sun model unknown"
		fi
	
	elif [[ $OSTYPE = AIX ]]
	then
		#
		# CPU is used here, but is not really "set" here for final value
		# It is set in psr section
		#
		CPU="$(awk -F: '/Processor Type:/ {print $2}' $PRTCONF_FILE \
				| sed -e 's/ //g')"

		if (( $(oslevel | sed -e 's/\.//g') >= 5000 ))
		then
			ARCH="$(uname -p) $CPU"
		else
			ARCH="$(awk -F: '/Model Architecture:/  {print $2}' $PRTCONF_FILE \
					| sed -e 's/ //g') $CPU"
		fi
		
		ARCHTYPE=$(uname -m)

		MODEL="$(uname -M)"
		if [[ -z $MODEL ]]
		then
			MODEL="$(awk -F: '/System Model:/ {print $2}' $PRTCONF_FILE \
					| sed -e 's/ //g')"
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		ARCH=$(uname -m)

		if [[ -x /usr/contrib/bin/machinfo ]]
		then
			ARCHTYPE=$(/usr/contrib/bin/machinfo -v \
						| awk -F: '/processor family:/ {print $2}' \
						| sed -e 's/ * / /g')
		else
			ARCHTYPE="unknown"
		fi

		MODEL="$(/usr/bin/model)"

		if [[ -z $ARCH ]]
		then
			ARCH="unknown"
		fi

		if [[ -z $MODEL ]]
		then
			MODEL="unknown"
		fi


	elif [[ $OSTYPE = Linux ]]
	then
		ARCH=$(uname -m)
		ARCHTYPE=$(uname -p)
		MODEL="$(cat /proc/cpuinfo \
					| awk -F: '/^model name/ {print $2}' \
					| sed -n 1p \
					| sed -e 's/ * / /g')"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		ARCH="$(grep -i "System Type:" $PRTCONF_FILE \
							| awk -F: '{print $2}' \
							| sed -e 's/^. *//')"

		MODEL="$(awk -F: '/^System Model:/ {print $2}' $PRTCONF_FILE \
							| sed -e 's/^. *//' \
							| sed -e 's/ . *$//')"

	else
		ARCH="unknown"
		ARCHTYPE="unknown"
		MODEL="unknown"
	fi
}

###################################################
# Gather processor information
f_get_psr_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: psr_info"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		OUTFILE=/tmp/psrinfo.sunos.out.$$
		psrinfo -v > $OUTFILE
		CPU=$(grep -c "Status" $OUTFILE)
		CPUMHZ=$(grep "operates" $OUTFILE | awk '{print $6" "$7}' \
							| sort -u | sed -e 's/,//g')
		rm $OUTFILE

		if [[ "$(which isainfo 2> /dev/null | cut -c 1)" = '/' ]]
		then
			KERNELBIT="$(isainfo -kv | awk -F- '{print $1}')"
		else
			KERNELBIT="32 assumed"
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		CPU="$(grep "Number Of Processors" $PRTCONF_FILE \
						| awk -F: '{print $2}')"

		if (( $(oslevel | sed -e 's/\.//g') >= 5000 ))
		then
			CPUMHZ="$(grep "Processor Clock Speed" $PRTCONF_FILE \
						| awk -F: '{print $2}')"
			KERNELBIT="$(prtconf -k | awk -F: '{print $2}')"
		else
			CPUMHZ="Lookup in IBM model/cpu matrix - $(uname -m)"
			KERNELBIT="$(bootinfo -K)-bit"
		fi	

	elif [[ $OSTYPE = HP-UX ]]
	then
		if [[ -x /usr/contrib/bin/machinfo ]]
		then
			CPU=$(/usr/contrib/bin/machinfo -v \
					| awk -F= '/Number of CPUs/ {print $2}'\
					| sed -e 's/ //g')

			CPUMHZ=$(/usr/contrib/bin/machinfo -v \
					| awk -F= '/Clock speed/ {print $2}')
		else
			CPU="$(ioscan -kfnC processor | grep -c ^processor)"

			#CPU="$(echo runningprocs/d \
			#		| /usr/bin/adb -k /stand/vmunix /dev/kmem \
			#		| sed -n \$p \
			#		| sed -e 's/ //g')"

			CPUMHZ="$(echo itick_per_tick/d \
				| /usr/bin/adb -k /stand/vmunix /dev/kmem 2> /dev/null \
				| sed -n \$p \
				| awk -F: '{print $2 * 1000}' \
				| sed -e 's/ //g') MHz"

			#
			# check if adb errors
			#
			if [[ -z $CPUMHZ ]]
			then
				CPUMHZ="$(echo itick_per_usec/d \
					| /usr/bin/adb -k /stand/vmunix /dev/kmem 2> /dev/null \
					| sed -n \$p \
					| awk -F: '{print $2}' \
					| sed -e 's/ //g') MHz"

				if [[ -z $CPUMHZ ]]
				then
					CPUMHZ="unknown"
				fi
			fi
		fi

		KERNELBIT=$(getconf KERNEL_BITS 2> /dev/null | grep [0-9][0-9])

		if [[ -z $CPU ]]
		then
			CPU="unknown"
		fi

		if [[ -z $CPUMHZ ]]
		then
			CPUMHZ="unknown"
		fi

		if [[ -z $KERNELBIT ]]
		then
			KERNELBIT="unknown"
		fi

	elif [[ $OSTYPE = Linux ]]
	then
		CPU="$(cat /proc/cpuinfo | grep -c ^processor)"
		CPUMHZ="$(cat /proc/cpuinfo \
					| awk -F: '/cpu MHz/ {print $2}' | sed -n 1p)"
		KERNELBIT="$(getconf WORD_BIT)"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		CPU="$(awk -F: '/Processor/ {print $2}' $PRTCONF_FILE \
						| awk '{print $1}' | sed -e 's/ //g')"
		#
		#assume all procecssor same speed
		#
		#very messy code
		#
		LINENUM=$(grep -n Processor $PRTCONF_FILE | awk -F: '{print $1}')
		let LINENUM=$LINENUM+1
		CPUSTRING=$(sed -n ${LINENUM}p $PRTCONF_FILE)
		CPUNUM=$($ECHO $CPUSTRING | awk '{print NF}')
		let CPUNUM1=$CPUNUM-1
		CPUMHZ="$($ECHO $CPUSTRING| awk '{print $'$CPUNUM1'}') MHZ"

		ARCHTYPE="$($ECHO "$CPUSTRING" | awk -F: '{print $2}')"

		KERNELBIT="unknown"

	else
		CPU="unknown"
		CPUMHZ="unknown"
		KERNELBIT="unknown"
	fi
}

###################################################
# Gather memory information
f_get_mem_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: mem_info"
	fi

	# Memory size
	if [[ $OSTYPE = SunOS ]]
	then
		MEM=$(grep "Memory size" $PRTCONF_FILE | awk '{print $3" "$4}')
		SWAP=$(swap -s | awk '{print $2}')
		PAGESIZE=$(pagesize)

	elif [[ $OSTYPE = AIX ]]
	then
		MEM=$(grep "^Memory Size" $PRTCONF_FILE | awk -F: '{print $2}' \
							| sed -e 's/ //g')
		PAGESIZE=$(pagesize)

		SWAP="$(swap -l 2> /dev/null | sed -n 2p | awk '{print $4}')"
		if [[ -z $SWAP ]]
		then
			SWAP="$(lsps -a | sed -n 2p | awk '{print $4}')"
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		if [[ -x /usr/contrib/bin/machinfo ]]
		then
			MEM="$(/usr/contrib/bin/machinfo -v \
					| awk -F= '/^Memory/ {print $2}' \
					| awk '{print $1" "$2}')"
		else
			MEM1="$(echo phys_mem_pages/D \
					| /usr/bin/adb -k /stand/vmunix /dev/kmem 2> /dev/null \
					| awk -F: '{print $2}' \
					| sed -n \$p \
					| sed -e 's/ //g')"

			MEM2="$(echo getphysmem/d \
					| /usr/bin/2> /dev/null adb -k /stand/vmunix /dev/kmem 2> /dev/null \
					| awk -F: '{print $2}' \
					| sed -n \$p \
					| sed -e 's/ //g')"

			if [[ -n "$($ECHO $MEM1 | grep [0-9][0-9][0-9][0-9])" ]]
			then
				MEM="$MEM1 MB"
			elif [[ -n "$($ECHO $MEM2 | grep [0-9][0-9][0-9][0-9])" ]]
			then
				MEM="$MEM2 MB"
			else
				MEM="unknown"
			fi
		fi

		PAGESIZE="$($ECHO get_page_sizes_supported/d \
					| /usr/bin/adb -k /stand/vmunix /dev/kmem 2> /dev/null \
					| awk -F: '{print $2}' \
					| sed -n \$p \
					| grep [0-9][0-9][0-9] \
					| sed -e 's/ //g')"

		if [[ -z $PAGESIZE ]]
		then
			MYTMPFILE_RUN=/tmp/mem_run.$$
			MYTMPFILE_OUT=/tmp/mem_out.$$
			cat <<-EOF > $MYTMPFILE_RUN
				gop confirmation no
				SelClass type memory
				Information ; wait
				InfoLog
					SaveAs
					$MYTMPFILE_OUT
				Done
				Exit
				OK
				EOF

			/usr/sbin/cstm -f $MYTMPFILE_RUN > /dev/null 2>&1

			PAGESIZE="$(cat $MYTMPFILE_OUT \
							| awk -F: '/Page Size:/ {print $2}' \
							| awk '{print $1}')"

			if [[ -z $PAGESIZE ]]
			then
				PAGESIZE="unknown"
			fi
		fi

		SWAP="$(swapinfo -d | awk '/^dev/ {print $2}') KB"

	elif [[ $OSTYPE = Linux ]]
	then
		MEM="$(cat /proc/meminfo | awk -F: '/MemTotal:/ {print $2" "$3}' \
							| sed -e 's/ * //' )"
		SWAP="$(cat /proc/meminfo | awk -F: '/SwapTotal:/ {print $2" "$3}' \
							| sed -e 's/ * //' )"
		PAGESIZE="$(getconf PAGESIZE)"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		MEM="$(awk -F: '/^Total Physical Memory:/ {print $2}' $PRTCONF_FILE \
							| sed -e 's/^. *//' | sed -e 's/,//g')"
		SWAP="$(awk -F: '/^Page File: Max Size:/ {print $3}' $PRTCONF_FILE \
							| sed -e 's/^. *//' | sed -e 's/,//g')"
		PAGESIZE="unknown"

		if [[ -z $SWAP ]]
		then
			SWAP="unknown"
		fi

	else
		MEM="unknown"
		SWAP="unknown"
		PAGESIZE="unknown"
	fi
}

###################################################
# Gather virtual information
f_get_virt_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: virt_info"
	fi

	# Virtual info - varies by OS type
	if [[ $OSTYPE = SunOS ]]
	then
		DOMAIN="$(domainname)"
		if [[ -z $DOMAIN ]]
		then
			DOMAIN="unknown"
		fi

		#	
		# parse out the 5.x as .10 looks like .1 in numeric test	
		#	
		MYOS_VER=$(uname -r)
		if [[ $($ECHO $MYOS_VER | awk -F. '{print $1}') = 5 ]]
		then
			MYOS_VER_SUB=$($ECHO $MYOS_VER | awk -F. '{print $2}')
		else
			$ECHO "ERROR: unknown release of Solaris."
		fi

		#
		# version 5.10 started the zone/containers built-in feature
		#
		if (( $MYOS_VER_SUB >= 10 ))
		then
			ZONETMP=/tmp/zoneinfo.$$
			zoneadm list -civ > $ZONETMP
			RUNNING="running=$(sed 1p $ZONETMP \
				| awk '/running/ {print $2}' \
				| grep -v global \
				| tr '\012' ',')"
			CONFIGURED="configured=$(sed 1p $ZONETMP \
				| awk '/configured/ {print $2}' \
				| grep -v global \
				| tr '\012' ',')"
			INSTALLED="installed=$(sed 1p $ZONETMP \
				| awk '/installed/ {print $2}' \
				| grep -v global \
				| tr '\012' ',')"
			VIRTUAL="$RUNNING $CONFIGURED $INSTALLED"
			rm $ZONETMP
		else
			VIRTUAL="none"
		fi

		if [[ -f $BINDIR/vnames ]]
		then
			VNAMES="$($BINDIR/vnames -A | sed -e 's/:/=/g' | tr '\012' ',')"
		else
			VNAMES="unknown"
		fi

		VIRTUALMACHINE="unknown"

	elif [[ $OSTYPE = AIX ]]
	then
		DOMAIN="$(domainname)"
		if [[ -z $DOMAIN ]]
		then
			DOMAIN="unknown"
		fi

		if [[ -f /usr/ios/cli/ioscli ]]
		then
			VIRTUAL="$(/usr/ios/cli/ioscli lsdev -virtual \
							| sed -e 1d \
							| awk '/Available/ {print $1}' \
							| tr '\012' ',')"

			if [[ -z $VIRTUAL ]]
			then
					VIRTUAL="none"
			fi
		else
				VIRTUAL="none"
		fi

		if [[ -f $BINDIR/vnames ]]
		then
			VNAMES="$($BINDIR/vnames -A | sed -e 's/:/=/g' | tr '\012' ',')"
		else
			VNAMES="unknown"
		fi

		#VIRTUALMACHINE="$(uname -L | grep -i $NODE)"
		VIRTUALMACHINE="$(uname -L)"
		if [[ -z $VIRTUALMACHINE ]]
		then
			VIRTUALMACHINE="unknown"
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		DOMAIN="$(domainname)"
		if [[ -z $DOMAIN ]]
		then
			DOMAIN="unknown"
		fi

		VIRTUAL="unknown"

		if [[ -f $BINDIR/vnames ]]
		then
			VNAMES="$($BINDIR/vnames -A | sed -e 's/:/=/g' | tr '\012' ',')"
		else
			VNAMES="unknown"
		fi

		OUTFILE=/tmp/parstatus.hpux.out.$$
		parstatus > $OUTFILE 2> /dev/null

		VIRTUALMACHINE="complex = \
			$(awk -F: '/Complex Name/ {print $2}' $OUTFILE),\
			partitions = $(awk -F: '/partitions present/ {print $2}' $OUTFILE)"

		VIRTUALMACHINE="$($ECHO $VIRTUALMACHINE \
			| sed -e 's/	/ /g' \
			| sed -e 's/ * / /g')"

		rm $OUTFILE

	elif [[ $OSTYPE = Linux ]]
	then
		DOMAIN="$(domainname)"
		if [[ -z $DOMAIN ]]
		then
			DOMAIN="unknown"
		fi

		VIRTUAL="unknown"
		if [[ -f $BINDIR/vnames ]]
		then
			VNAMES="$($BINDIR/vnames -A | sed -e 's/:/=/g' | tr '\012' ',')"
		else
			VNAMES="unknown"
		fi
		VIRTUALMACHINE="unknown"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		DOMAIN="$(awk -F: '/^Domain:/ {print $2}' $PRTCONF_FILE\
						| sed -e 's/^. *//')"
		if [[ -z $DOMAIN ]]
		then
			DOMAIN="unknown"
		fi

		VIRTUAL="unknown"
		VNAMES="unknown"
		VIRTUALMACHINE="unknown"

	else
		DOMAIN="unknown"
		VIRTUAL="unknown"
		VNAMES="unknown"
		VIRTUALMACHINE="unknown"
	fi
}

###################################################
# Gather array information
f_get_array_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: array_info"
	fi

	#
	# Sun only arrays, and limited at that.
	# Gets small arrays and A5X00
	# Doesn't get info on newer arrays (T3 and newer).
	# Needs to be updated.
	#

	if [[ $OSTYPE = SunOS ]]
	then
		if (( ZONEGLOBAL ))
		then
			############################################################
			# Number of Sun Storage Arrays
			SSA=$(ls -l /dev/dsk/c*s2 | grep pln | \
					awk '{print substr($11,length($11)-15,6)}' | \
					sort -u | wc -l | awk '{print $1}')
		
			############################################################
			# Number of Netra disk arrays
			if [[ -x /opt/SUNWssmu/bin/ssmadmin ]]
			then
				/opt/SUNWssmu/bin/ssmadmin > /tmp/netra.$$ 2>&1
				NETRA=$(awk '/^Number/ {print $5}' /tmp/netra.$$ )
				rm /tmp/netra.$$
			fi
		
			if [[ -z $NETRA ]]
			then
				NETRA=0
			fi
		
			############################################################
			LUXADM_THERE="$(ls -l /dev/dsk/c*s2 2> /dev/null | grep '/sf@')"
	
			if [ -n "$LUXADM_THERE" ]
			then
				# Number of Photon disk arrays
				PHOTON=$(luxadm probe | grep -c SENA)
				
				# Output PHOTON Array WWN 
				# get a list of each array, then the number of slots they each have
				ARRAYLIST=""
				for ARRAY in $(luxadm probe | \
						awk '$1 == "SENA" {print $2}' | \
						awk -F: '{print $2}' | sort)
				do
					# use awk because not all slots are necessarily used
					# get disks (ID - 2000), get O.K. lines, get number of O.K.s via awk
					NUM_DISK=$(luxadm display $ARRAY \
						| grep O\.K\. | grep 2000 | \
						awk '{
							for (i=1; i <= NF; i++)
								if ( $i == "(O.K.)")
									count++
									}
									END {
									print count
								}')
			
					ARRAYLIST="$ARRAYLIST ${ARRAY}-${NUM_DISK}"
				done
			fi
		
			if [[ -z $PHOTON ]]
			then
				PHOTON=0
			fi
		
			if [[ -z $ARRAYLIST ]]
			then
				ARRAYLIST="none"
			fi
	
			############################################################
			RAIDLSI=""
			if [[ -x /usr/sbin/raidctl ]]
			then
				if [[ -n $(raidctl | grep -v "No RAID volumes found") ]]
				then
					RAIDLSI="LSI-$(raidctl | awk '$0 ~ /^Cont/ {printf "%s ", $0 }
								$0 ~ /Disk:/ {sum++} END {print " Disks-" sum}' \
									| sed -e 's/:/-/g' \
									| tr '\012' ' ' )"
				else
					RAIDLSI="LSI-none"
				fi
			else
				RAIDLSI="LSI-none"
			fi
	
			RAIDSTK=""
			if [[ -x /usr/StorMan/arcconf ]]
			then
				FOUND=$(/usr/StorMan/arcconf getconfig 1 \
							| awk -F:  '/^Controllers found/ {print $2}')
	
				#need to loop on each controller, assumes numbers max of 10
				CNT=1
				while (( $CNT <= $FOUND ))
				do
					/usr/StorMan/arcconf getconfig $CNT pd 2>&1 > /dev/null
	
					if (( ! $? ))
					then
						RAIDSTK="$RAIDSTK Controller-${CNT} Disks-$(/usr/StorMan/arcconf \
								getconfig $CNT pd | grep -c Size), "
					fi
					CNT=$CNT+1
				done
	
				if (( $FOUND ))
				then
					RAIDSTK="STK $RAIDSTK"
				else
					RAIDSTK="STK-none"
				fi
			else
				RAIDSTK="STK-none"
			fi
	
			RAIDL="$($ECHO $RAIDLSI, $RAIDSTK | tr '\012' ' ' )"
	
			############################################################
		else
			SSA="unknown"
			NETRA="unknown"
			PHOTON="unknown"
			ARRAYLIST="unknown"
			RAIDL="unknown"
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		SSA="none"
		NETRA="none"
		PHOTON="none"
		ARRAYLIST="none"
		RAIDL="none"
	elif [[ $OSTYPE = HP-UX ]]
	then
		SSA="none"
		NETRA="none"
		PHOTON="none"
		ARRAYLIST="none"
		RAIDL="none"
	elif [[ $OSTYPE = Linux ]]
	then
		SSA="none"
		NETRA="none"
		PHOTON="none"
		ARRAYLIST="none"
		RAIDL="none"
	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		SSA="none"
		NETRA="none"
		PHOTON="none"
		ARRAYLIST="none"
		RAIDL="none"
	else	
		SSA="none"
		NETRA="none"
		PHOTON="none"
		ARRAYLIST="none"
		RAIDL="none"
	fi
}

###################################################
# Gather vol group information
f_get_vol_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: vol_info"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list 2> /dev/null \
						| awk '/enabled/ {print $1}' \
						| tr '\012' ',')"
			DGS="$($ECHO $DGS |  sed -e 's/,, /,/g' | sed -e 's/,$//')"

			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi

		ZPOOLS="na"
		if [[ -f $BINDIR/vnames ]]
		then
			ZPOOLS="$($BINDIR/vnames -Z | sed -e 's/:/=/g' | tr '\012' ',')"
			if [[ -z $ZPOOLS ]]
			then
				ZPOOLS="unknown"
			fi
		else
			ZPOOLS="$(zpool list 2> /dev/null | grep SIZE | awk '{print $1}')"
			if [[ -z $ZPOOLS ]]
			then
				ZPOOLS="unknown"
			fi
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list 2> /dev/null \
							| awk '/enabled/ {print $1}' \
							| tr '\012' ',')"

			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi

		DGS="${DGS}, $(lsvg | tr '\012' ',')"
		DGS="$($ECHO $DGS |  sed -e 's/,, /,/g' | sed -e 's/,$//')"

		ZPOOLS="unknown"

	elif [[ $OSTYPE = HP-UX ]]
	then
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list 2> /dev/null \
						| awk '/enabled/ {print $1}' \
						| tr '\012' ',')"
			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi

		DGS="${DGS}, $(vgdisplay | awk -F/ '/VG Name/ {print $3}')"
		DGS="$($ECHO $DGS |  sed -e 's/,, /,/g' | sed -e 's/,$//')"

		ZPOOLS="unknown"

	elif [[ $OSTYPE = Linux ]]
	then
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list  2> /dev/null \
							| awk '/enabled/ {print $1}' \
							| tr '\012' ',')"

			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi
		ZPOOLS="unknown"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list | grep '.*Name.*:' \
					| awk '{print $NF}' \
					| tr '\012' ',' \
					| tr "\015" " " \
					| sed -e 's/ //g')"

			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi
		ZPOOLS="unknown"

	else
		if [[ "$(which vxdg 2> /dev/null | cut -c 1)" = '/' ]]
		then
			DGS="$(vxdg list | awk '/enabled/ {print $1}' | tr '\012' ',')"

			if [[ -z $DGS ]]
			then
					DGS="none"
			fi
		else
			DGS="unknown"
		fi
		ZPOOLS="unknown"
	fi
}
	
###################################################
# Gather disk information
f_get_disk_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: disk_info"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		OUTFILE=/tmp/iostat.out.$$
		#
		# Remove duplicate entries based on disk world wide number
		# one version changed the iostat -En fields
		#
		if [[ $(uname -r) != 5.6 ]]
		then
			SIZE_FIELD=2
		else 
			SIZE_FIELD=6
		fi
	
		#
		# Some disks have serial numbers, others don't.  If a serial number is 
		# there, then we need to check if it multipathed disks (same disks, 
		# with two different CTD numbers).
		#
		# This is messy, but wanted something that always works (iostat -En), 
		# and is gives what we need (but needs a lot of parsing).
		#
		# Some fixes are for x86 iostat inconsistencies
		#
		TMPFILE=/tmp/iostat-prep.out.$$
		TMPFILE1=/tmp/iostat-prep.out.1.$$
		TMPFILE2=/tmp/iostat-prep.out.2.$$
		
		if (( ZONEGLOBAL ))
		then
			iostat -En \
				| sed -e 's/.* Size/& #Size/' \
				| tr '#' '\012' \
				| sed -e 's/ Size $//' \
				| awk '$0 ~ /^c/ {printf "%s ",$1}
					$0 ~ /Serial/ {printf "%s ",$NF}
					$0 ~ /Size/ {printf "%s \n",$'$SIZE_FIELD'}' \
				| grep -v 0.00GB \
				| grep GB \
				| sed -e 's/GB//' \
				| sort -u > $TMPFILE
		else
			#
			# zones don't see device names the same
			#
			iostat -E \
				| sed -e 's/.* Size/& #Size/' \
				| tr '#' '\012' \
				| sed -e 's/ Size $//' \
				| awk '$0 ~ /^s/ {printf "%s ",$1}
					$0 ~ /Serial/ {printf "%s ",$NF}
					$0 ~ /Size/ {printf "%s \n",$'$SIZE_FIELD'}' \
				| grep -v 0.00GB \
				| grep GB \
				| sed -e 's/GB//' \
				| sort -u > $TMPFILE
		fi

		#non-serial number disks
		cat $TMPFILE | awk '{if ($2 == "No:") print $0}' > $TMPFILE1

		#serial number disks
		#remove duplicates (from multipathing)
		cat $TMPFILE | awk '{if ($2 != "No:") print $0}' \
						| grep -v \/ \
						| sort -u -k 2,2 \
						| awk '$2 !~ /\// && $2 !~ /No:/ {print $0}'\
							> $TMPFILE2

		#combine both outputs into the new OUTFILE with duplicated being taken of the
		#serial number list
		cat $TMPFILE1 $TMPFILE2 > $OUTFILE

		rm $TMPFILE $TMPFILE1 $TMPFILE2
	
		#
		# awk: add a 0 to $0 so you get an interger and not a string test
		#
		# Total number of disks
		TOTDSK=$(wc -l $OUTFILE | awk '{print $1}')
	
		# Total disks under 2GB
		DSKSML=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 < 2) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 2GB and 4GB
		DSK2GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 2  && $0 < 4) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 4GB and 8GB
		DSK4GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 4  && $0 < 8) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 8GB and 18GB
		DSK8GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 8  && $0 < 18) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 18GB and 36GB
		DSK18GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 18  && $0 < 36) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 36GB and 73GB
		DSK36GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 36  && $0 < 73) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 73GB and 100GB
		DSK73GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 73  && $0 < 100) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 100GB and 150GB
		DSK100GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 100  && $0 < 150) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 150GB and 200GB
		DSK150GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 150  && $0 < 200) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 200GB and 300GB
		DSK200GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 200  && $0 < 300) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 300GB and 500GB
		DSK300GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 300  && $0 < 500) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 500GB and 1TB
		DSK500GB=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 500  && $0 < 1000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks bigger than 1TB
		DSKBIG=$(awk '{print $3}' $OUTFILE | awk  -F. '{print $1}' \
					| awk  '{$0+0; if ($0 >= 1000) print $0}' \
					| wc -l | awk '{print $1}')
	
		rm $OUTFILE
	
		# Total disks of EMC 
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		DSKIBM=$(iostat -E | egrep -ic "IBM FC|SAN Volume Controller" )
		DSKHDS=$(iostat -E | grep  -c  "OPEN-" )
		CDDVD=$(iostat -E  | egrep -ic "CD-ROM|DVD" )
		TAPE=$(iostat -En  | grep  -c  ^rmt)
	
	elif [[ $OSTYPE = AIX ]]
	then
		OUTFILE=/tmp/lspv.out.$$

		#get all disks
		#for DISK in $(lspv | awk '/^hdisk/ {print $1}')
		#get all disks that are "good"
		#for DISK in $(lspv | grep -v None | awk '/^hdisk/ {print $1}')

		#get only active disks
		for DISK in $(lsvg -o | lsvg -i -p | grep -iw active | awk '/^hdisk/ {print $1}')
		do
			bootinfo -s $DISK
		done >> $OUTFILE

		# Total number of disks
		TOTDSK=$(wc -l $OUTFILE | awk '{print $1}')
	
		# Total disks under 2Gb
		DSKSML=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 < 2000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 2Gb and 4Gb
		DSK2GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 2000  && $0 < 4000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 4Gb and 8Gb
		DSK4GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 4000  && $0 < 8000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 8Gb and 18Gb
		DSK8GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 8000  && $0 < 18000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 18Gb and 36Gb
		DSK18GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 18000  && $0 < 36000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 36Gb and 73Gb
		DSK36GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 36000  && $0 < 73000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 73Gb and 100Gb
		DSK73GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 73000  && $0 < 100000) print $0}'\
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK100GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 100000  && $0 < 150000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK150GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 150000  && $0 < 200000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 200Gb and 300Gb
		DSK200GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 200000  && $0 < 300000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 300Gb and 500Gb
		DSK300GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 300000  && $0 < 500000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 500Gb and 1TB
		DSK500GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 500000  && $0 < 1000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks bigger than 1TB
		DSKBIG=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 1000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		rm $OUTFILE

		# Total disks of EMC
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		DSKIBM=$(lsdev -Cc disk \
				| egrep -ic "IBM FC|LVD|SAN Volume Controller|DS..00 Disk Array Device" )
		DSKHDS=$(lscfg -vp    | grep  -c  "OPEN-" )
		CDDVD=$(lsdev -C      | egrep -ic "CD-ROM|DVD" )
		TAPE=$(lsdev -Cc tape | grep -ic "^rmt" )


	elif [[ $OSTYPE = HP-UX ]]
	then
		OUTFILE=/tmp/hpdisktmp.$$

		for DISK in $(ioscan -funC disk \
						| awk '/rdsk/ {print $2}' \
						| sed -e 's@/dsk/@/rdsk/@g' \
						| sort -u)
		do
			diskinfo -v $DISK \
						| awk -F: '/size:/ {print $2}' \
						| awk '{print $1}'
		done > $OUTFILE


		# Total number of disks
		TOTDSK=$(grep -vc rdsk $OUTFILE)
	
		# Total disks under 2Gb
		DSKSML=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 < 2000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 2Gb and 4Gb
		DSK2GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 2000  && $0 < 4000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 4Gb and 8Gb
		DSK4GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 4000  && $0 < 8000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 8Gb and 18Gb
		DSK8GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 8000  && $0 < 18000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 18Gb and 36Gb
		DSK18GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 18000  && $0 < 36000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 36Gb and 73Gb
		DSK36GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 36000  && $0 < 73000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 73Gb and 100Gb
		DSK73GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 73000  && $0 < 100000) print $0}'\
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK100GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 100000  && $0 < 150000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK150GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 150000  && $0 < 200000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 200Gb and 300Gb
		DSK200GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 200000  && $0 < 300000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 300Gb and 500Gb
		DSK300GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 300000  && $0 < 500000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 500Gb and 1TB
		DSK500GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 500000  && $0 < 1000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks bigger than 1TB
		DSKBIG=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 1000000) print $0}' \
					| wc -l | awk '{print $1}')


		# Total disks of EMC
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		DSKIBM=$(egrep -ic "IBM FC|SAN Volume Controller"  $OUTFILE)
		DSKHDS=$(grep  -c  "OPEN-"  $OUTFILE)
		CDDVD=$(ioscan -funC disk | egrep -iec "CD-ROM|DVD" )
		TAPE=$(ioscan -fun | grep -ic "tape" )

		rm $OUTFILE
	
	elif [[ $OSTYPE = Linux ]]
	then
		OUTFILE=/tmp/fdisk.out.$$

		fdisk -l 2> /dev/null | grep ^Disk \
					| grep bytes$ \
					| awk '{print $5}' > $OUTFILE

		# Total number of disks
		TOTDSK=$(wc -l $OUTFILE | awk '{print $1}')

		# Total disks under 2Gb
		DSKSML=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 < 2000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 2Gb and 4Gb
		DSK2GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 2000000000  && $0 < 4000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 4Gb and 8Gb
		DSK4GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 4000000000  && $0 < 8000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 8Gb and 18Gb
		DSK8GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 8000000000  && $0 < 18000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 18Gb and 36Gb
		DSK18GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 18000000000  && $0 < 36000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 36Gb and 73Gb
		DSK36GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 36000000000  && $0 < 73000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 73Gb and 100Gb
		DSK73GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 73000000000  && $0 < 100000000000) print $0}'\
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK100GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 100000000000  && $0 < 150000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK150GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 150000000000  && $0 < 200000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 200Gb and 300Gb
		DSK200GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 200000000000  && $0 < 300000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 300Gb and 500Gb
		DSK300GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 300000000000  && $0 < 500000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 500Gb and 1TB
		DSK500GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 500000000000  && $0 < 1000000000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks bigger than 1TB
		DSKBIG=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 1000000000000) print $0}' \
					| wc -l | awk '{print $1}')


		# Total disks of EMC
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		#DSKIBM=$(egrep -ic "IBM FC|SAN Volume Controller"  $OUTFILE)
		#DSKHDS=$(grep -c "OPEN-"  $OUTFILE)
		DSKIBM="unknown"
		DSKHDS="unknown"
		CDDVD="unknown"
		TAPE="unknown"
	
	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		OUTFILE="$C_DRIVE/temp/cygwin.diskinfo.out.$$"

		#
		# get disk list from diskpart command, then paginate
		#
		# diskpart seems to need RUNME to be in the CWD
		#
		#RUNME="$C_DRIVE/temp/runme.txt.$$"

		RUNME="runme.txt"
		echo "list disk" > $RUNME

		$C_DRIVE/Windows/system32/diskpart /s $RUNME \
						| grep 'Disk [0-9]' \
						| awk '{print $4" "$5}' \
						| sed -e 's/MB//g' \
						| sed -e 's/GB/000/g' \
						| sed -e 's/ //g' \
							> $OUTFILE 2> /dev/null 

		rm $RUNME

		# Total number of disks
		TOTDSK=$(wc -l $OUTFILE | awk '{print $1}')
	
		# Total disks under 2Gb
		DSKSML=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 < 2000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 2Gb and 4Gb
		DSK2GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 2000  && $0 < 4000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 4Gb and 8Gb
		DSK4GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 4000  && $0 < 8000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 8Gb and 18Gb
		DSK8GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 8000  && $0 < 18000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 18Gb and 36Gb
		DSK18GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 18000  && $0 < 36000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 36Gb and 73Gb
		DSK36GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 36000  && $0 < 73000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 73Gb and 100Gb
		DSK73GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 73000  && $0 < 100000) print $0}'\
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK100GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 100000  && $0 < 150000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 100Gb and 150Gb
		DSK150GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 150000  && $0 < 200000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 200Gb and 300Gb
		DSK200GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 200000  && $0 < 300000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 300GB and 500GB
		DSK300GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 300000  && $0 < 500000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks between 500GB and 1TB
		DSK500GB=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 500000  && $0 < 1000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		# Total disks bigger than 1TB
		DSKBIG=$(cat $OUTFILE \
					| awk  '{$0+0; if ($0 >= 1000000) print $0}' \
					| wc -l | awk '{print $1}')
	
		rm $OUTFILE

		# Total disks of EMC
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		DSKIBM="unknown"
		DSKHDS="unknown"
		CDDVD="$(awk '/^\[CD-ROM/, /^\[S/' $WINSYSTEM_OUT | grep -wc ^Drive)"
		if [[ -z CDDVD ]]
		then
			CDDVD=0
		fi

		TAPE="unknown"

	else
		TOTDSK="unknown"
		DSKSML="unknown"
		DSK2GB="unknown"
		DSK4GB="unknown"
		DSK8GB="unknown"
		DSK18GB="unknown"
		DSK36GB="unknown"
		DSK73GB="unknown"
		DSK100GB="unknown"
		DSK150GB="unknown"
		DSK200GB="unknown"
		DSK300GB="unknown"
		DSK500GB="unknown"
		DSKBIG="unknown"

		# Total disks of EMC
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKEMC=$( /usr/symcli/bin/sympd list \
					| awk '/RW/ {if ($NF > 100) print $2}' \
					| sort -u \
					| wc -l \
					| sed -e 's/ //g')
		fi
	
		if [[ -n $DSKEMC ]]
		then
			if (( $DSKEMC > 1 ))
			then
				let DSKEMC=$DSKEMC-1
			fi
		else
			DSKEMC=0
		fi
	
		if  [[ -f /usr/symcli/bin/sympd ]]
		then
			DSKBCV=$(/usr/symcli/bin/sympd list | sort -u -k 2,2 | grep -c BCV)
		else
			DSKBCV=0
		fi

		DSKIBM="unknown"
		DSKHDS="unknown"
		CDDVD="unknown"
		TAPE="unknown"
	fi
}
	
###################################################
# Get system and I/O board information
f_get_brd_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: brd_info"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		if [[ -s $PRTCONF_FILE ]]
		then
			# Number of Serial Optical Converter (SOC) cards
			SOC=$(grep -wc soc $PRTCONF_FILE)
		fi
	
		if [ -d /devices/fhc* ]
		then
			BRD=$(ls -d /devices/fhc* | wc -l | awk '{print $1}')
		elif [ -d /devices/io-unit* ]
		then
			BRD=$(ls -d /devices/io-unit* | wc -l | awk '{print $1}')
		elif [ -d /devices/iommu* ]
		then
			BRD=$(ls -d /devices/iommu* | wc -l | awk '{print $1}')
		elif [ -d /devices/sbus@* ]
		then
			BRD=$(ls -d /devices/sbus@* | wc -l | awk '{print $1}')
		else
			BRD=0
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		SOC="unknown"
		BRD="unknown"
	elif [[ $OSTYPE = HP-UX ]]
	then
		SOC="unknown"
		BRD="unknown"
	elif [[ $OSTYPE = Linux ]]
	then
		SOC="unknown"
		BRD="unknown"
	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		SOC="unknown"
		BRD="unknown"
	else
		SOC="unknown"
		BRD="unknown"
	fi
}

###################################################
# Get board information
f_get_slot_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: slot_info"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		# if it has prtdiag
		# else there is only prtconf (ultra 1 and 2, sparcstations, zones)
	
		if [[ -s $PRTDIAG_FILE ]]
		then
			#
			# PRTDIG & PRTCONF mix
			#

			# Number of Serial Optical Converter (SOC) cards
			SOC=$(grep -wc soc $PRTCONF_FILE)
	
			# Number of SCSI Diff cards
			SCSI=$(egrep -ce "qlgc|fas" $PRTDIAG_FILE)
	
			# Number of 10/100 network cards
			NIC100=$(egrep -ce "hme|qfe|qec|qge|nge|bge" $PRTDIAG_FILE)
	
			# Number of GB network cards
			GBNIC=$(egrep -ce 'be|ce|ge|gem' $PRTDIAG_FILE)
	
			# Number of GBIC cards
			GBIC=$(grep -cw socal $PRTCONF_FILE)
	
			# Number of HBA cards
			# get either sbus or PCI (fibre-channel)
			HBA=$(egrep -ce "fibre-channel|FC|fcw|fce|qlc|pf|lpfc|LP" $PRTDIAG_FILE)
	
			# Number of FDDI interfaces
			FDDI=$(grep -v Configuration $PRTCONF_FILE | grep -c nf)
	
			# Number of High Speed Interfaces
			HSI=$(grep -c HSI $PRTCONF_FILE)
	
			# Number of video adapters
			VIDEO=$(egrep -ce "vga|m64|cg|ffb" $PRTCONF_FILE)
	
		else
			#
			# PRTCONF only
			#

			# Number of Serial Optical Converter (SOC) cards
			SOC=$(grep -cw soc $PRTCONF_FILE)
	
			# Number of SCSI Diff cards
			SCSI=$(grep -ci "qlgc" $PRTCONF_FILE)
	
			# Number of 10/100 network cards
			NIC100=$(egrep -ce "hme|qec|nge|bge|qfe|qge" $PRTCONF_FILE)
	
			# Number of GBIC cards
			GBIC=$(grep -cw socal $PRTCONF_FILE)
	
			# Number of GB network cards
			# cannot easily get this out of prtconf
			GBNIC=0
	
			# Number of HBA cards
			# get either sbus (fcaw) or PCI (fibre-channel)
			HBA=$(egrep -e "fibre-channel|fcaw|fce|fce|qlc|pf|lpfc|LP" $PRTCONF_FILE | grep -c instance)
	
			# Number of FDDI interfaces
			FDDI=$(grep -v Configuration $PRTCONF_FILE | grep -c nf)
		
			# Number of High Speed Interfaces
			HSI=$(grep -c "HSI" $PRTCONF_FILE)
	
			# Number of video adapters
			VIDEO=$(egrep -ce "vga|m64|cg|ffb" $PRTCONF_FILE)
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		SOC="unknown"
		SCSI=$(lsdev -Cc adapter | grep -ic scsi)
		NIC100=$(lsdev -Cc adapter | grep ent | grep -v EtherChannel \
										| grep -vc 1000)
		GBNIC=$(lsdev -Cc adapter | grep ent | grep -c 1000)
		GBIC="unknown"
		HBA=$(lsdev -Cc adapter | grep -ic fcs)
		FDDI=$(lsdev -Cc adapter | grep -ic fddi)
		HSI="unknown"
		VIDEO=$(lsdev -Cc adapter | grep -ic vga)

	elif [[ $OSTYPE = HP-UX ]]
	then
		SOC="unknown"
		SCSI=$(ioscan -funC scsi | grep -c INTERFACE)
		NIC100=$(ioscan -funC lan | sed 1,2d | grep -vc "1000Base")
		GBNIC=$(ioscan -funC lan | sed 1,2d | grep -c "1000Base")
		GBIC="unknown"
		HBA=$(ioscan -funC fc | grep -c INTERFACE)
		FDDI=$(ioscan -fun | grep -ic fddi)
		HSI="unknown"
		VIDEO=$(ioscan -fun | grep -ic vga)

	elif [[ $OSTYPE = Linux ]]
	then
		SOC="unknown"
		SCSI="$(lspci | grep -ci scsi)"
		NIC100="$(lspci | grep -i Ethernet | grep -ivc Gig)"
		GBNIC="$(lspci | grep -i Ethernet | grep -ic Gig)"
		GBIC="unknown"
		HBA="$(lspci | grep -i "Host Adapter" | grep -ic Fibre)"
		FDDI="$(lspci | grep -i "Host Adapter" | grep -ic fddi)"
		HSI="unknown"
		VIDEO="$(lspci | egrep -ci "vga|nvidia|ati")"
	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		SOC="unknown"
		SCSI="unknown"
		NIC100=$(awk '/^\[IRQ/, /^\[Memory/' $WINSYSTEM_OUT | grep -c ^Network)
		GBNIC="unknown"
		GBIC="unknown"
		HBA="unknown"
		FDDI="unknown"
		HSI="unknown"
		VIDEO=$(awk '/^\[DISPLAY/, /^\[I/' $WINSYSTEM_OUT | grep -c ^Name)
	else
		SOC="unknown"
		SCSI="unknown"
		NIC100="unknown"
		GBNIC="unknown"
		GBIC="unknown"
		HBA="unknown"
		FDDI="unknown"
		HSI="unknown"
		VIDEO="unknown"
	fi
}

###################################################
# Get the HBA's type and version
f_get_hba_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: hba_info"
	fi

	HBA_TYPE=""
	HBA_DRV=""
	HBA_FIRM=""
	HBA_FC=""

	if [[ $OSTYPE = SunOS ]]
	then

		#
		# Note: Solaris has now provided a consistent command utility - fcinfo, 
		# but only in the later versions and releases of Solaris.  Before that, it
		# was a hunt-and-peck via a number of vendor utiltities (if loaded) or by some
		# other means (messages file, prtconf, prtdiag) all with varied info/results.
		# 
		# That is why this section is so "messy".  :) 
		# 
		# First, we use fcinfo to build the list. If fcinfo is not available, we fall
		# back to the older methods.
		# 

		if [[ -f /usr/sbin/fcinfo ]]
		then	
			HBAINFO_FILE=/tmp/fcinfo.$$
			HBAINFO_TEMP_FILE=/tmp/fcinfo.temp.$$
			fcinfo hba-port > $HBAINFO_FILE
			MYFILE=$HBAINFO_FILE

			# Number of HBA cards
			# get either sbus (fcaw) or PCI (fibre-channel)
			HBA=$(grep -c "^HBA Port WWN" $MYFILE)
			if (( $HBA ))
			then

				HBA_WWNS="$(awk -F: '/"^HBA Port WWN/" {print $2}' $MYFILE)"

					#
					# old discrete way
					#
					#
					#	HBA_TYPE="$HBA_TYPE $(fcinfo hba-port $MY_WWN \
					#			| awk -F: '/Model:/ {print $2}'), "
					#	HBA_FIRM="$HBA_FIRM $(fcinfo hba-port $MY_WWN \
					#			| awk -F: '/Firmware Version:/ {print $2}'), "
					#	HBA_FC="$HBA_FC $(fcinfo hba-port $MY_WWN \
					#			| grep "FCode/BIOS Version:" \
					#			| sed -e 's@FCode/BIOS Version:@@' \
					#			| sed -e 's/ * / /g' \
					#			| sed -e 's/://g'), "


				for MY_WWN in $HBA_WWNS
				do
					fcinfo hba-port $MY_WWN \
							| sed -e 's/FC-AL Host Adapter Driver: //' \
							| sed -e 's/ BIOS://'\
							| egrep -e 'Manufacturer:|Model:|Firmware Version:|FCode/BIOS Version:|Driver Version:' \
							| awk -F: '{print $2}' \
							| sed -e 's/;//'\
							| tr '\012' ' '
					echo
				done >> $MYFILE

				sort -u -o $MYFILE $MYFILE

				cat $MYFILE | sed -e 's@FCode/BIOS Version:@@' \
							| sed -e 's/ * / /g' \
							| sed -e 's/://g' > /tmp/fcinfo.tmp.$$    

				mv /tmp/fcinfo.tmp.$$ $MYFILE

				EMULEXPKG=$(pkginfo | grep -i emulex \
											| grep root \
											| sed -n 1p \
											| awk '{print $2}')
	
				if [[ -n $EMULEXPKG ]]
				then
					MYHBA_DRV="$(pkginfo -l $EMULEXPKG 2> /dev/null \
									| awk '/VERSION:/ {print $2}' \
									| awk -F, '{print $1}')"
				fi

				if [[ -n "$MYHBA_DRV" ]]
				then
					HBA_DRV="$HBA_DRV $MYHBA_DRV, "
				else
					HBA_DRV="$HBA_DRV unknown, "
				fi
	
				if [[ -z "$($ECHO $HBA_FC | grep [0-9,a-z,A-Z])" ]]
				then
					HBA_FC="$HBA_FC unknown, "
				fi

				QLOGICPKG="$(pkginfo -l SUNWqlc 2> /dev/null \
								| awk -F '/VERSION:/ {print $2}' )"

				if [[ -n $QLOGICPKG ]]
				then
					MYHBA_DRV="$(grep -i qlogic /var/adm/messages* \
							| grep -i driver \
							| sed -n \$p \
							| awk '{print $NF}' \
							| awk -F, '{print $1}')"

				fi

				if [[ -n "$MYHBA_DRV" ]]
				then
					HBA_DRV="$HBA_DRV $MYHBA_DRV, "
				else
					HBA_DRV="$HBA_DRV unknown, "
				fi


				if [[ -z "$($ECHO $HBA_FIRM | grep [0-9,a-z,A-Z])" ]]
				then
					HBA_FIRM="unknown, "
				fi

				if [[ -z "$($ECHO $HBA_FC | grep [0-9,a-z,A-Z])" ]]
				then
					HBA_FC="unknown, "
				fi

				if [[ -n $JNIPKG ]]
				then
					HBA_DRV="$HBA_DRV $(pkginfo -l $JNIPKG 2> /dev/null \
								| awk '/VERSION:/ {print $2}' \
								| awk -F, '{print $1}')"
				fi
						

				if [[ -e $HBAINFO_FILE ]]
				then
					rm $HBAINFO_FILE
				fi
			fi

		#
		# no fcinfo - must use old ways
		#
		else
			if [[ -s $PRTDIAG_FILE ]]
			then
				HBA=$(egrep -cie "fibre-channel|fc|fcw|fce|qlc|pf|lpfc|LP" $PRTDIAG_FILE)
				MYFILE=$PRTDIAG_FILE
			else
				HBA=$(egrep -ie "fibre-channel|fc|fcw|fce|qlc|pf|lpfc|LP" $PRTCONF_FILE \
							| grep -c name:)
				MYFILE=$PRTCONF_FILE
			fi


			if (( $HBA ))
			then
				HBA_TYPE=""
	
				#based on type, get info
	
				######################
				# Emulex lpfc
				######################
				if [[ -n $(egrep -e "LP|fibre" $MYFILE) ]]
				then
					HBA_TYPE="Emulex"
					LPFC_CMD=/usr/sbin/lpfc/lputil
					DFC_CMD=/usr/sbin/lpfc/dfc
	
					#
					# else use LPUTIL
					#
					if [[ -f $LPFC_CMD ]]
					then
						CNT=0
	
						HBA_NUM=$($LPFC_CMD count)
					
						# we will loop for each one as you can mix different
						# types but this is probably not the best thing to do
						while (( CNT < $HBA_NUM ))
						do
							if [[ -f $LPFC_CMD ]]
							then
								HBA_TYPE="$HBA_TYPE $($LPFC_CMD model $CNT), "
								HBA_FIRM="$HBA_FIRM $($LPFC_CMD rev $CNT \
											| awk -F: '/Initial Firmware/ {print $2}'), "
								HBA_DRV="$HBA_DRV $($LPFC_CMD rev $CNT \
											| awk -F: '/Kernel/ {print $2}' \
											| awk -F, '{print $1}'), "
								if [[ -z $HBA_FIRM ]]
								then
									HBA_FIRM="unknown"
								fi
							else
								HBA_TYPE="$HBA_TYPE unknown"
								HBA_FIRM="$HBA_FIRM unknown"
							fi
		
							if [[ -f $DFC_CMD ]]
							then
								$DFC_CMD <<-EOF | grep lpfc > /tmp/lpfc.$$
								exit
								EOF
			
								HBA_FC="$HBA_FC $(grep lpfc /tmp/lpfc.$$ | \
											grep -w ${CNT}: | \
											sed -n \$p | \
											awk '{print $NF}'), "
			
							elif [[ -f /var/adm/dmesg.output ]]
							then
								# you should run a "dmesg > /var/adm/dmesg.output" on 
								# bootup (rc script) because many messages from boot 
								# don't # get written out before they get 
								# flushed/overwritten in the dmesg buffer
								HBA_FC="$HBA_FC $(grep lpfc /var/adm/dmesg.output | \
											grep Fcode | \
											sed -n \$p | \
											awk '{print $NF}'), "
							else
								# hope we catch them in the messages file
								MYHBA_FC="$(grep lpfc /var/adm/messages* | \
											grep Fcode | \
											sed -n \$p | \
											awk '{print $NF}')"
	
								if [[ -n $MYHBA_FC ]]
								then
									HBA_FC="$HBA_FC $MYHBA_FC, "
								else
									HBA_FC="$HBA_FC unknown, "
								fi
							fi
				
							let CNT=$CNT+1
						done


						EMULEXPKG=$(pkginfo | grep -i emulex \
											| grep root \
											| sed -n 1p \
											| awk '{print $2}')
	
						if [[ -n $EMULEXPKG ]]
						then
							MYHBA_DRV="$(pkginfo -l $EMULEXPKG 2> /dev/null \
											| awk '/VERSION:/ {print $2}' \
											| awk -F, '{print $1}')"
						fi
	
						if [[ -n "$MYHBA_DRV" ]]
						then
							HBA_DRV="$HBA_DRV $MYHBA_DRV, "
						else
							HBA_DRV="$HBA_DRV unknown, "
						fi
			
						if [[ -z "$($ECHO $HBA_FC | grep [0-9,a-z,A-Z])" ]]
						then
							HBA_FC="$HBA_FC unknown, "
						fi

					else
						MYHBA_TYPE=$(egrep -ie "fibre-channel|fc|lpfc|LP" $MYFILE \
								| awk '{print $NF}')
						if [[ -n $MYHBA_TYPE ]]
						then
							HBA_TYPE="$HBA_TYPE $MYHBA_TYPE, "
						else
							HBA_TYPE="$HBA_TYPE unknown, "
						fi
						HBA_FIRM="$HBA_FIRM unknown, "
						HBA_FC="$HBA_FC unknown, "
					fi
	
				fi

	
				######################
				# QLOGIC - only use fcinfo for it - done above
				######################
				if [[ -n $(egrep -ie "qlc" $PRTDIAG_FILE) ]]
				then
					if [[ -n $HBA_TYPE ]]
					then
						HBA_TYPE="$HBA_TYPE, QLC"
					else
						HBA_TYPE="QLC"
					fi
		
					QLCPKG=$(pkginfo 2> /dev/null \
										| grep qlc \
										| sed -n 1p \
										| awk '/Driver/ {print $2}')
	
					if [[ -n $QLCPKG ]]
					then
						HBA_TYPE="$HBA_TYPE $(awk '/SUNW,qlc/ {print $NF}' $PRTDIAG_FILE \
										| grep -v SUNW \
										| sed -n 1p), "
		
						HBA_DRV="$HBA_DRV $(pkginfo -l $QLCPKG 2> /dev/null \
									| awk '/VERSION:/ {print $2}' \
									| awk -F, '{print $1}'), "
					else
						MYHBA_TYPE=$(egrep -ie 'qlc' $PRTDIAG_FILE \
										| awk '{print $NF}' | sed -n 1p)
						if [[ -n $MYHBA_TYPE ]]
						then
							HBA_TYPE="$HBA_TYPE $MYHBA_TYPE, "
						else
							HBA_TYPE="$HBA_TYPE unknown, "
						fi
						HBA_DRV="$HBA_DRV unknown, "
					fi
	
					HBA_FIRM="$HBA_FIRM unknown, "
					HBA_FC="$HBA_FC na"
				fi

				######################
				# JNI fca (old stuff, no longer made, but were once very popular)
				######################
				if [[ -n $(egrep -ie "fce|fcw" $PRTDIAG_FILE) ]]
				then
					if [[ -n $HBA_TYPE ]]
					then
						HBA_TYPE="$HBA_TYPE, JNI"
					else
						HBA_TYPE="JNI"
					fi
		
					JNIPKG=$(pkginfo 2> /dev/null \
										| grep JNI \
										| grep -v usr \
										| sed -n 1p \
										| awk '/Driver/ {print $2}')
	
					if [[ -n $JNIPKG ]]
					then
						HBA_TYPE="$HBA_TYPE $(awk '/JNI,FC/ {print $NF}' $PRTDIAG_FILE \
										| sed -n 1p), "
		
						HBA_DRV="$HBA_DRV $(pkginfo -l $JNIPKG 2> /dev/null \
									| awk '/VERSION:/ {print $2}' \
									| awk -F, '{print $1}'), "
					else
						MYHBA_TYPE=$(egrep -ie 'fce|fcw' $PRTDIAG_FILE \
										| awk '{print $NF}' | sed -n 1p)
						if [[ -n $MYHBA_TYPE ]]
						then
							HBA_TYPE="$HBA_TYPE $MYHBA_TYPE, "
						else
							HBA_TYPE="$HBA_TYPE unknown, "
						fi
						HBA_DRV="$HBA_DRV unknown, "
					fi
	
					HBA_FIRM="$HBA_FIRM unknown, "
					HBA_FC="$HBA_FC na"
				fi
			fi
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		#
		#  BUG?  Assumes only one type of HBA on a system, and that all would be
		#        the same version.
		#

		HBA=$(lsdev -Cc adapter | grep -c ^fcs)
		
		if (( $HBA ))
		then
			HBA_VAR=$(lsdev -Cc adapter \
						| grep ^fcs \
						| sed -n 1p \
						| awk '{print $1}')

			HBA_TYPE="$(lscfg -vl $HBA_VAR \
						| grep 'Part Number'  \
						| sed -e 's/\.\./ /g' \
						| awk '{print $NF}' \
						| sed -e 's/\.//g' )"

			HBA_DRV="$(lsdev -C -Ftype,name \
						| grep -i fcs \
						| awk -F, '{print $1}' \
						| sed -n 1p)"

			HBA_FIRM="$(lscfg -vl $HBA_VAR \
						| grep -w '(Z9)' \
						| sed -e 's/\.\./ /g' \
						| awk '{print $NF}')"

			HBA_FC="$(lsmcode -cd $HBA_VAR \
						| awk '{print $NF}' \
						| sed -e 's/\.//g' )"

		else
			HBA_TYPE="none"
			HBA_DRV="none"
			HBA_FIRM="none"
			HBA_FC="none"
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		#
		#  BUG?  Assumes only one type of HBA on a system, and that all would be
		#        of the same version.
		#

		HBA=$(ioscan -funC fc | grep -c INTERFACE)
		HBAINSTANCE=$(ioscan -funC fc \
							| grep dev \
							| awk '{print $NF}' \
							| sed -n 1p)

		if (( $HBA ))
		then
			HBA_VAR="$(/opt/fcms/bin/fcdutil $HBAINSTANCE)"

			HBA_TYPE="$(ioscan -funC fc \
						| grep INTERFACE \
						| sed -n 1p \
						| awk -F"INTERFACE" '{print $2}' \
						| awk '{print $1" "$2}')"

			HBA_DRV="$(/opt/fcms/bin/fcdutil $HBAINSTANCE \
						| awk -F= '/Driver Version/ {print $2}' \
						| awk -F"Driver" '{print $2}'\
						| awk '{print $1}')"

			HBA_FIRM="unknown"
			HBA_FC="unknown"
		else
			HBA_TYPE="none"
			HBA_DRV="none"
			HBA_FIRM="none"
			HBA_FC="none"
		fi

	elif [[ $OSTYPE = Linux ]]
	then
		HBA="$(lspci | grep -i "Host Adapter" | grep -ic "Fibre")"

		#
		# if there are HBAs
		# 
		#  Limitation:  Assumes only EMULEX type cards.
		# 
		if (( $HBA ))
		then
			#based on type, get info - ONLY EMULEX coded here

			HBA_TYPE="$(lspci | grep -i "Host Adapter" \
						| grep -i "Fibre" \
						| awk '{print $4" "$5" "$6" "$7}' \
						| sed -n 1p)"


			# Emulex lpfc
			CNT=0
			LPFC_CMD=/usr/sbin/lpfc/lputil
			DFC_CMD=/usr/sbin/lpfc/dfc

			if [[ -f $LPFC_CMD ]]
			then
				HBA_NUM=$($LPFC_CMD count)
			else
				HBA_NUM=$(grep -ciw lpfc $MYFILE)
			fi
				
			# we will loop for each one as you can mix different
			# types but this is probably not the best thing to do
			while (( CNT < $HBA_NUM ))
			do
				if [[ -f $LPFC_CMD ]]
				then
					HBA_TYPE="$HBA_TYPE $($LPFC_CMD model $CNT), "
					HBA_FIRM="$HBA_FIRM $($LPFC_CMD rev $CNT \
								| awk -F: '/Initial Firmware/ {print $2}'), "
					HBA_DRV="$HBA_DRV $($LPFC_CMD rev $CNT \
								| awk -F: '/Kernel/ {print $2}'), "
				else
					HBA_TYPE="$HBA_TYPE unknown, "
					HBA_FIRM="$HBA_FIRM unknown, "
				fi

				if [[ -f $DFC_CMD ]]
				then
					$DFC_CMD <<-EOF | grep lpfc > /tmp/lpfc.$$
					exit
					EOF
	
					HBA_FC="$HBA_FC $(grep lpfc /tmp/lpfc.$$ | \
								grep -w ${CNT}: | \
								sed -n \$p | \
								awk '{print $NF}'), "

				fi
	
			let CNT=$CNT+1
			done
		
			MYHBA_DRV="$(rpm -qa | grep -i emulex | sed -n 1p)"

			if [[ -n "$MYHBA_DRV" ]]
			then
				HBA_DRV="$HBA_DRV $MYHBA_DRV, "
			else
				HBA_DRV="$HBA_DRV unknown, "
			fi
	
			if [[ -z "$($ECHO $HBA_FC | grep [0-9,a-z,A-Z])" ]]
			then
				HBA_FC="$HBA_FC unknown, "
			fi
		else
			HBA_TYPE="none"
			HBA_DRV="none"
			HBA_FIRM="none"
			HBA_FC="none"
		fi

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
			HBA_TYPE="unknown"
			HBA_DRV="unknown"
			HBA_FIRM="unknown"
			HBA_FC="unknown"

	else
			HBA_TYPE="unknown"
			HBA_DRV="unknown"
			HBA_FIRM="unknown"
			HBA_FC="unknown"
	fi
}

###################################################
# List the networks the system is on
f_get_net_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: net_info"
	fi

	if [[ $OSTYPE = HP-UX ]]
	then
		#
		# HP is a little different, in both NIC mgt and KSH
		#
		NICS=$(lanscan -i | awk '{print $1}')
		NET=""

		for NIC in $NICS
		do
			NET="$NET $(ifconfig $NIC \
					| grep -w inet \
					| grep -v 127.0.0.1 \
					| awk '{print $2}')"
		done 2> /dev/null

		NET=$($ECHO $NET | sort -n | tr "\n" "," )
		NET=$($ECHO $NET | sed -e 's/ //g')

	elif [[ $OSTYPE = Linux ]]
	then
		NET="$(ifconfig -a \
					| grep -w inet \
					| grep -v 127.0.0.1 \
					| awk '{print $2}' \
					| awk -F: '{print $2}' \
					| sort -n \
					| tr "\n" "," )"

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		NET="$(ipconfig  /all \
					| grep -i "IP.*Address"  \
					| awk '{print $NF}' \
					| sed -e 's/(Preferred)//' \
					| grep -v :: \
					| sort -n \
					| tr "\n" "," \
					| tr "\015" " " \
					| sed -e 's/ //g')"

	else
		NET="$(ifconfig -a \
					| grep -w inet \
					| grep -v 127.0.0.1 \
					| awk '{print $2}' \
					| sort -n \
					| tr "\n" "," )"
	fi
}

###################################################
# List the sw pkgs
f_get_sw_info()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: sw_info"
	fi

	#####################################################################
	#
	#common commands (but may be overridden in specific OS types)
	#

		#some EMC software
		if [ -d /usr/emc/ECC ]
		then
			ECC=1
		else
			ECC="na"
		fi
		
		if [ -d /usr/emc/ESN_Manager ]
		then
			ESN=1
		else
			ESN="na"
		fi
		
		if [ -d /usr/emc/VolumeLogix ]
		then
			VOLLOG=1
		else
			VOLLOG="na"
		fi
	
		if [ -d /usr/emc/FibreZone ]
		then
			FZ=1
		else
			FZ="na"
		fi
	
		#PATROL
		if [[ -L /opt/patrol ]]
		then
			if [[ -f  /opt/patrol/PatrolAgent ]]
			then
				/opt/patrol/PatrolAgent -v 2> /tmp/Patrol_out.$$
				# must sleep to get file output - Patrol messes with this
				sleep 3
				PATROL=$(awk '{print $2}' /tmp/Patrol_out.$$)
			fi
		else
			PATROL="na"
		fi
	
		#FORTE
		if [[ -n $(ls -d /opt/forte* 2> /dev/null ) ]]
		then
			cd /opt
			for i in $(ls -d forte*)
			do
				INST=$(cat $i/FORTE.VER)
				FORTE="$FORTE ${i}-${INST}"
			done
		else
			FORTE="na"
		fi
	
		#NETSCAPE
		if [[ -x /opt/netscape/bin/https/bin/ns-httpd ]]
		then
			NETSCAPE=$(awk '/Version/ {print $2}' /opt/netscape/setup/setup.inf  )
			#NETSCAPE=$(/opt/netscape/bin/https/bin/ns-httpd -v \
						#| sed -n 2p | awk -F/ '{print $2}')
		else
		NETSCAPE="na"
		fi
	
		#WEBLOGIC
		#
		# should be better, but this works for now
		#
		DIRS="/opt/appserver/weblogic /opt/rtp/weblogic /opt/apps401k/weblogic /opt/weblogic /opt/bea /opt/jdk1.1.7B/weblogic /opt/netscape/weblogic"
	
		WEBLOGIC=""
		for DIR in $DIRS
		do
			#	
			# This is spastic, but works.  Later version of weblogics will
			# be installed in a consistent set of dirs and this will go away.
			#	
			# get the version dirs, if any	
			#	
			DIRVIR=$(ls -d $DIR/[1-9]* 2> /dev/null | awk -F/ '{print $NF}')
	
			#if any dirs found
			if [[ -n $DIRVIR ]]
			then
					WEBLOGIC="$WEBLOGIC $DIRVIR"
			fi
		done
	
		if [[ -z $WEBLOGIC ]]
		then
			WEBLOGIC="na"
		else
			WEBLOGIC=$($ECHO $WEBLOGIC | sort -u)
			#WEBLOGIC=$($ECHO $WEBLOGIC | tr ' ' '\015' | sort -u)
		fi
	
		#BROADVISION
		if [[ -L /opt/bv1to1 ]]
		then
			BROADVISION=$(ls -l /opt/bv1to1 | awk '{print $NF}'| cut -c8- )
		else
			BROADVISION="na"
		fi
	
		#SQL_BKTRK
		if [[ -x /opt/datatools/sbacktrack/VERSION ]]
		then
			SQL_BKTRK=$(awk '{print $5}' /opt/datatools/sbacktrack/VERSION )
		else
			SQL_BKTRK="na"
		fi

	
		#APACHE
		#
		# NOTE: Grep out oracle (may be a BAD thing) as oracle can wrap
		#       up apache in their own world and they break apachectl.
		#
		APACHPROCESS=$(ps -elf \
					| grep -vw oracle \
					| grep -v grep \
					| grep -w httpd \
					| sort -u \
					| egrep -iv "xterm|vnc|desktop" \
					| awk '{print $NF}' \
					| sed -n 1p )

		if [[ -n $APACHPROCESS ]]
		then
			if [[ -n $(dirname $APACHPROCESS | grep conf) ]]
			then
				#
				# get rid of conf and add bin
				#
				# /usr/IBMHttpServer/conf
				#
				APACHDIR=$(dirname $(dirname $APACHPROCESS))
				APACHDIR="$APACHDIR/bin"
			else
				APACHDIR=$(dirname $APACHPROCESS)
			fi
				  
			if [[ -x $APACHDIR/apachectl ]]
			then
				#
				# Some version of apachectl don't support
				#  the version option (without lynx & stuff)
				#
				APACHE=$($APACHDIR/apachectl -version \
						| grep version: \
						| awk '{print $3}')

				if [[ -z $APACHE ]]
				then
					#
					# needs lynx loaded to work
					#
					APACHE=$($APACHDIR/apachectl status \
						| grep Apache \
						| awk -F/ '{print $2}' \
						| awk '{print $1}' )

					if [[ -z $APACHE ]]
					then
						APACHE="unknown"
					fi
				fi
			else
				APACHE="unknown"
			fi
		else
			APACHE="na"
		fi

	
		#WEBSPHERE
		if [[ $OSTYPE = SunOS || $OSTYPE = AIX ]]
		then
			WEBSPDIR=$(ps -elfo args \
				| grep -i websphere \
				| grep -v grep \
				| awk '{print $1}' \
				| sed -n 1p )

		elif [[ $OSTYPE = HP-UX || $OSTYPE = Linux ]]
		then
			WEBSPDIR=$(ps -ef \
				| cut -c49- \
				| grep -i websphere \
				| grep -v grep \
				| awk '{print $1}' \
				| sed -n 1p )
		else
			WEBSPDIR=""
		fi
		
		if [[ -n $WEBSPDIR ]]
		then

			WEBSPDIR=$($ECHO $WEBSPDIR \
						| awk -F/ '{print "/",$2,"/",$3}' \
						| sed -e 's/ //g')

			#
			# use tmp file to capture stderr output that pipe doesn't
			#
			WEBTMP=/tmp/webspdir.$$

			WEBEXE=$(find $WEBSPDIR -name versionInfo.sh | sed -n 1p)

			#$WEBSPDIR/bin/versionInfo.sh > $WEBTMP 2>&1
			$WEBEXE > $WEBTMP 2>&1

			WEBSPHERE=$(cat $WEBTMP \
				| sed -n '/Installed Product/,/^End/p' \
				| egrep '^Version|Build Level' \
				| awk '{print $NF}' \
				| tr '\012' ' ' )

			rm $WEBTMP
		fi

		if [[ -z $WEBSPHERE ]]
		then
			WEBSPHERE="na"
		fi
	

		#
		# SCHEDULER
		#
		#  Many more can be added here.
		#  So far: Autosys, Controlm, Tidal.
		#
		#  ASSUME only ONE scheduler on a system (safe bet?).
		#

		#AUTOSYS
		if [[ -x /opt/autosys/bin/autoflags ]]
		then
			AUTO1=$(/opt/autosys/bin/autoflags -v)
			AUTO2=$(/opt/autosys/bin/autoflags -r )
			SCHEDULER="autosys = ${AUTO1}-R${AUTO2}"

		#Tidal
		elif [[ -n $(ps -ef | grep -w tidal | grep -v grep) ]]
		then
			#
			# try and pick up tidal path from process, otherwise hardcode
			#
			TIDALPATH=$(ps -ef | grep tidal | grep -v grep \
								| tr ' ' '\012' \
								| awk -F= '/path=/ {print $2}')

			if [[ -n $TIDALPATH  ]]
			then
				TIDALINI=$(awk -F= '/agents/ {print $2}' \
								$TIDALPATH/bin/tagent.ini)

				SCHEDULER="tidal = $($TIDALPATH/bin/tagent $TIDALINI status \
							| awk '/Release/ {print $2}' \
							| sed -e 's/,//')"
			else
				TIDALPATH="/app/tidal/tdladm/agent"

				TIDALINI=$(awk -F= '/agents/ {print $2}' \
								$TIDALPATH/bin/tagent.ini)

				SCHEDULER="tidal = $($TIDALPATH/bin/tagent $TIDALINI status \
							| awk '/Release/ {print $2}' \
							| sed -e 's/,//')"
			fi


		#Control-M (BMC)
		elif [[ -n $(ps -ef | grep -w ctm | grep -v grep) ]]
		then
			#CONTROLM
			# Get path to VERSION file.
			# Triple basename - want to go up two dirs from where I am
			# at, and remove the executable name too - 3 basename's
			TMPDIR=$(ps -elf \
					| grep -v grep \
					| grep -w ctm \
					| grep -v java \
					| sed -n 1p \
					| awk '{print $NF}')
	
			if [[ -n $TMPDIR ]]
			then
				CONTMDIR=$(dirname \
							$(dirname \
								$(dirname $TMPDIR) \
							) \
							| sed -n 1p \
						)
			fi
	
			if [[ -z $CONTMDIR || $CONTMDIR = "." ||  $CONTMDIR = "/" ]]
			then
				SCHEDULER="na"
			else
				if [[ -x $CONTMDIR/VERSION ]]
				then
					SCHEDULER="controlm = $(sed 1,2d $CONTMDIR/VERSION \
							| awk '{print $5}' \
							| tr '\012' ' ')"
					if [[ -z $CONTROLM ]]
					then
						SCHEDULER="na"
					fi
				fi
			fi
		else
			SCHEDULER="na"
		fi


		#TSM
		if [[ -f /usr/tivoli/tsm/client/ba/bin/dsm.sys ]]
		then
			TSMCLT=$(grep -v '^*' /usr/tivoli/tsm/client/ba/bin/dsm.sys \
								| grep -i ^nodename \
								| awk '{print $2}' )

			TSMSRV=$(grep -v '^*' /usr/tivoli/tsm/client/ba/bin/dsm.sys \
								| grep -i tcpserveraddress \
								| awk '{print $2}' )
		fi

		if [[ -e /usr/tivoli/tsm/client/ba/bin/dsmc ]]
		then
			TMPTSM=/tmp/mysn.$$
			/usr/tivoli/tsm/client/ba/bin/dsmc <<-EOF > $TMPTSM
				quit
			EOF

			if [[ -s $TMPTSM ]]
			then

				TSMCLTVER=$(grep "Client Version" $TMPTSM)
				if [[ -z $TSMCLTVER ]]
				then
					TSMCLTVER=$(grep "Archive Client Interface" $TMPTSM)
				fi

				TSMSRVVER=$(grep "Server Version" $TMPTSM)
				TSMSERVER=$(grep "Session established with server" $TMPTSM \
								| grep -vw SERVER1: )

				if [[ -z $TSMCLTVER ]]
				then
					TSMCLTVER="unknown"
				fi

				if [[ -z $TSMSRVVER ]]
				then
					TSMSRVVER="unknown"
				fi

			else
				TSMSRVVER="unknown"
				TSMCLTVER="unknown"
			fi

			# server and client the same - this is a TSM server, 
			# otherwise, just a client
			if [[ -z $TSMSERVER ]]
			then
				TSMSRVVER="Server Version - is not a TSM server"
			fi

			rm $TMPTSM
		else
			TSMSRVVER="na"
			TSMCLTVER="na"
		fi

		# server and client the same - this is a TSM server,
		# otherwise, just a client
		if [[ -z $TSMSERVER ]]
		then
			TSMSRVVER="Server Version is unknown"
		fi

		TSM="$TSMSRVVER, $TSMCLTVER"

		if [[ -z $TSM ]]
		then
			TSM="na"
		fi



		#TRIPWIRE
		if [[ -f /usr/local/tripwire/tfs/README ]]
		then
			TRIPWIRE=$(sed -n 2p /usr/local/tripwire/tfs/README \
					| awk '/Tripwire for Servers/ {print $4}')
		else
			TRIPWIRE="na"
		fi

		#NETBACKUP
		if [[ -x /usr/openv/netbackup/bin/version ]]
		then
			NETBACKUP=$(awk '{print $2}' /usr/openv/netbackup/bin/version)
		else
			NETBACKUP="na"
		fi
		
		#PERL
		if [[ -x /usr/bin/perl ]]
		then
			#
			# different OS and version print by different fields - so we
			# must get both and get rid of extraneous text
			#
			PERL=$(/usr/bin/perl -v \
					| awk '/This is perl/ {print $4" "$5}' \
					| sed -e 's/built//' \
					| sed -e 's/version//' \
					| sed -e 's/ //g')
		else
			PERL="na"
		fi
	
		#SSH
		if [[ "$(which ssh 2> /dev/null | cut -c 1)" = '/' ]]
		then
			#
			# different OS and version print by different fields - so we
			# must get both and get rid of extraneous text
			#
			SSH_FILE=/tmp/ssh.$$

			ssh -V > $SSH_FILE 2>&1

			if [[ -s $SSH_FILE ]]
			then
				SSH=$(cat $SSH_FILE)
			else
				SSH="unknown"
			fi
			rm $SSH_FILE
		else
			SSH="unknown"
		fi
	
	#####################################################################
	#
	#OS specific - may override common commands
	#

	if [[ $OSTYPE = SunOS ]]
	then
		#
		# Veritas area
		#
		VXVM=$(pkginfo -l VRTSvxvm 2> /dev/null | \
				awk '/VERSION/ {print $2}'| \
				awk -F, '{print $1}')
	
		if [[ -z $VXVM ]]
		then
			VXVM="na"
		fi
	
		VXFS=$(pkginfo -l VRTSvxfs 2> /dev/null | \
				awk '/VERSION/ {print $2}' | \
				awk -F, '{print $1}')
	
		if [[ -z $VXFS ]]
		then
			VXFS="na"
		fi
	
		VCS=$(pkginfo -l VRTSvcs 2> /dev/null | \
				awk '/VERSION/ {print $2}' | \
				awk -F, '{print $1}')
	
		if [[ -z $VCS ]]
		then
			VCS="na"
		fi
	
		VC=$(pkginfo -l SUNWccon 2> /dev/null | \
					awk '/VERSION/ {print $2}' | \
					awk -F, '{print $1}')
		if [[ -z $VC ]]
		then
			VC="na"
		else
			VC="SunCluster $VC"
		fi

		#
		# EMC area
		#
		PWRPTH=$(pkginfo -l EMCpower 2> /dev/null | \
					awk '/VERSION/ {print $2}' | \
					awk -F, '{print $1}')

		if [[ -z $PWRPTH ]]
		then
			PWRPTH="na"
		fi
	
		JAVA_FILE=/tmp/java.$$

		if [[ "$(which java 2> /dev/null | cut -c 1)" = '/' ]]
		then
			java -version 2> $JAVA_FILE
		else
			NONPATHJAVAFOUND=$(find /opt -name java | grep bin | sed -n 1p)
			if [[ -n $NONPATHJAVAFOUND ]]
			then
				$NONPATHJAVAFOUND -version 2> $JAVA_FILE
			fi
		fi

		#
		#some older versions of java have issue with getting version
		#
		if (( ! $? ))
		then
			if	[[ -s $JAVA_FILE ]]
			then
				JAVA="$(awk '/java version/ {print $3}' $JAVA_FILE\
								| sed -e 's/"//g')"
	
				JAVABLD="$(grep build $JAVA_FILE \
								| sed -n 1p \
								| sed -e 's/.*(build/ /' \
								| sed -e 's/)//')"
	
				JAVA="$($ECHO $JAVA $JAVABLD | sed -e 's/ * / /g')"
	
			else
				JAVA="unknown"
			fi
		else
			JAVA="unknown"
		fi

		if [[  -f $JAVA_FILE ]]
		then
			rm $JAVA_FILE
		fi

	elif [[ $OSTYPE = AIX ]]
	then

		#
		# Veritas area
		#
		VXVM=$(lslpp -l VRTSvxvm 2> /dev/null \
				| awk '/VRTSvxvm/ {print $2}'\
				| sed -n 1p)
	
		if [[ -z $VXVM ]]
		then
			VXVM="na"
		fi
	
		VXFS=$(lslpp -l VRTSvxfs 2> /dev/null \
				| awk '/VRTSvxfs/ {print $2}' \
				| sed -n 1p)
	
		if [[ -z $VXFS ]]
		then
			VXFS="na"
		fi
	
		VCS=$(lslpp -l VRTSvcs.rte 2> /dev/null \
					| awk '/VRTSvcs.rte/ {print $2}' \
					| sed -n 1p)
	
		if [[ -z $VCS ]]
		then
			VCS="na"
		fi
	
		VC=$(lslpp -l \
					| awk '/rsct.basic.hacmp/ {print $2}' \
					| sed -n 1p)
		if [[ -z $VC ]]
		then
			VC="na"
		else
			VC="HACMP $VC"
		fi

		PWRPTH=$(lslpp -l \
					| awk '/EMCpower.base/ {print $2}' \
					| sed -n 1p)

		if [[ -z $PWRPTH ]]
		then
			PWRPTH="na"
		fi

		#Java
		JAVA_FILE=/tmp/java.$$

		if [[ "$(which java 2> /dev/null | cut -c 1)" = '/' ]]
		then
			java -version 2> $JAVA_FILE
		else
			NONPATHJAVAFOUND=$(ls -d /usr/*java* | sed -n \1p)
			if [[ -f $NONPATHJAVAFOUND/bin/java ]]
			then
				$NONPATHJAVAFOUND/bin/java -version 2> $JAVA_FILE
			fi
		fi

		if	[[ -s $JAVA_FILE ]]
		then
			JAVA=$(awk '/java version/ {print $3}' $JAVA_FILE\
							| sed -e 's/"//g')

			JAVABLD=$(grep build $JAVA_FILE \
							| sed -n 2p \
							| sed -e 's/.*build ca/ca/' \
							| awk '{print $1}')
			JAVA="$JAVA $JAVABLD"
		else
			JAVA="unknown"
		fi
		
		if [[  -f $JAVA_FILE ]]
		then
			rm $JAVA_FILE
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		VXVM="$(swlist VRTSvxvm 2> /dev/null | grep -w VRTSvxvm \
						| sed -n 1p | awk '{print $3}')"

		if [[ -z $VXVM ]]
		then
			VXVM="na"
		fi

		VXFS="$(swlist VRTSvxfs 2> /dev/null | grep -w VRTSvxfs \
						| sed -n 1p | awk '{print $3}')"

		if [[ -z $VXFS ]]
		then
			VXFS="na"
		fi

		VCS="$(swlist VRTSvcs 2> /dev/null | grep -w VRTSvcs \
						| sed -n 1p | awk '{print $3}')"

		if [[ -z $VCS ]]
		then
			VCS="na"
		fi

		VC="$(swlist ServiceGuard  2> /dev/null | grep -w ServiceGuard  \
						| sed -n 1p | awk '{print $3}')"
		if [[ -z $VC ]]
		then
			VC="na"
		else
			VC="ServiceGuard $VC"
		fi

		PWRPTH="$(swlist EMCpower 2> /dev/null | grep -w EMCpower \
						| sed -n 1p | awk '{print $3}')"

		if [[ -z $PWRPTH ]]
		then
			PWRPTH="na"
		fi

		JAVA="$(swlist | grep  Java | grep -v VRTS \
						| awk '{print $2}' | sort -n | sed -n \$p)"


		if [[ -z $JAVA ]]
		then
			JAVA="na"
		fi

	elif [[ $OSTYPE = Linux ]]
	then
		VXVM="$(rpm -qa | grep VRTSvxvm | sed -n 1p)"
		if [[ -z $VXVM ]]
		then
			VXVM="na"
		fi

		VXFS="$(rpm -qa | grep VRTSvxfs | sed -n 1p)"
		if [[ -z $VXFS ]]
		then
			VXFS="na"
		fi

		if [[ -f /opt/VRTSvcs/bin/had ]]
		then
			PWRPTH="$(/opt/VRTSvcs/bin/had -v)"
		else
			PWRPTH="na"
		fi
		VCS="na"

		VC="na"

		if [[ -f /sbin/powermt ]]
		then
			PWRPTH="$(/sbin/powermt version | awk -FVersion '{print $2}')"
		else
			PWRPTH="na"
		fi

		#Java
		JAVA_FILE=/tmp/java.$$

		if [[ "$(which java 2> /dev/null | cut -c 1)" = '/' ]]
		then
			java -version 2> $JAVA_FILE
		else
			NONPATHJAVAFOUND=$(find /opt -name java | grep bin | sed -n 1p)
			if [[ -n $NONPATHJAVAFOUND ]]
			then
				$NONPATHJAVAFOUND -version 2> $JAVA_FILE
			fi
		fi

		if	[[ -s $JAVA_FILE ]]
		then
			JAVA="$(awk '/java version/ {print $3}' $JAVA_FILE\
							| sed -e 's/"//g')"

			JAVABLD="$(grep build $JAVA_FILE \
							| sed -n 1p \
							| sed -e 's/.*(build/ /' \
							| sed -e 's/)//')"

			JAVA="$($ECHO $JAVA $JAVABLD | sed -e 's/ * / /g')"

		else
			JAVA="unknown"
		fi
		
		if [[  -f $JAVA_FILE ]]
		then
			rm $JAVA_FILE
		fi

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		VXVM="na"
		VXFS="na"
		VCS="na"
		VC="na"
		PWRPTH="na"

		#Java
		JAVA_FILE="$C_DRIVE/temp/cygwin.java.out.$$"

		if [[ "$(which java 2> /dev/null | cut -c 1)" = '/' ]]
		then
			java -version 2> $JAVA_FILE
		else
			NONPATHJAVAFOUND=$(find /opt -name java | grep bin | sed -n 1p)
			if [[ -n $NONPATHJAVAFOUND ]]
			then
				$NONPATHJAVAFOUND -version 2> $JAVA_FILE
			fi
		fi

		if	[[ -s $JAVA_FILE ]]
		then
			JAVA="$(awk '/java version/ {print $3}' $JAVA_FILE\
							| sed -e 's/"//g')"

			JAVABLD="$(grep build $JAVA_FILE \
							| sed -n 1p \
							| sed -e 's/.*(build/ /' \
							| sed -e 's/)//')"

			JAVA="$($ECHO $JAVA $JAVABLD | sed -e 's/ * / /g')"

		else
			JAVA="unknown"
		fi

		if [[  -f $JAVA_FILE ]]
		then
			rm $JAVA_FILE
		fi

		VC="$(awk '/Cluster/ {print $2}' $WINSYSTEM_OUT)"
		if [[ -z $VC ]]
		then
			VC="na"
		else
			VC="MicrosoftCluster $VC"
		fi

	else
		VXVM="na"
		VXFS="na"
		VCS="na"
		PWRPTH="na"
		JAVA="na"
	fi
}
	

###################################################
# see if global solaris zone
f_checkIfGlobalZone ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if  [[ $OSTYPE = SunOS ]]
	then
		if  (( $(uname -r | awk -F. '{print $2}') >= 10 && $(uname -r | awk -F. '{print $1}') == 5 ))
		then
			if [[ $(zonename) = global ]]
			then
				ZONEGLOBAL=1
			else
				ZONEGLOBAL=0
			fi
		else
			ZONEGLOBAL=0
		fi
	fi
}
	
###################################################
# Get release and firmware
f_get_release ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: release"
	fi


	if [[ $OSTYPE = SunOS ]]
	then
		#
		# if this program is run in a solaris zone, many things will not work
		#
		f_checkIfGlobalZone
	
	
		OSVER=$(uname -r)
		FIRMWARE=$(prtconf -V | awk '{print $2}')
		PATCH=$(uname -a | awk '{print $4}')
	
		if [[ -f /etc/release ]]
		then
			# the reason for the sed is there is preceeding white space in the line
			RELEASE=$(sed -n 1p /etc/release | sed 's/.* Solaris/Solaris/')
		else
			RELEASE="unknown"
		fi
		
		PRTCONF_FILE=/tmp/prtconf.sunos.out.$$
		/usr/sbin/prtconf -vp > $PRTCONF_FILE

		#
		# prtdiag has moved to /usr/sbin, (wrapper), 
		# but is always here in this real location for all versions
		#
		# note: this will not work in a solaris zone, but we would have
		# to change so many tests that we leave it.  we check to see if 
		# this file has a size in bytes in the test, in a zone it will not
		# so that takes care of the issue.
		#
		PRTDIAG_FILE=/tmp/prtdiag.sunos.out.$$
		/usr/platform/$(uname -m)/sbin/prtdiag 2> /dev/null > $PRTDIAG_FILE
		
		if (( ZONEGLOBAL ))
		then
			if [[ $(uname -m) = "i86pc" ]]
			then
				FIRMWARE="OBP $FIRMWARE BIOS \
						$(grep "^BIOS Configuration:" $PRTDIAG_FILE \
							| awk -F: '{print $2}')"
				FIRMWARE="$($ECHO $FIRMWARE | sed -e "s/ * / /g" )"
			fi
		fi
		
	
	elif [[ $OSTYPE = AIX ]]
	then
		OSVER="$(oslevel)"
		PRTCONF_FILE=/tmp/prtconf.aix.out.$$
	
		/usr/sbin/prtconf > $PRTCONF_FILE 2> /dev/null
	
		TMPFIRM="$(lsmcode -c | egrep -e 'current permanent|current temporary')"
	
		if [[ -n "$TMPFIRM" ]]
		then
			FIRMWARE=$(lsmcode -c | egrep -e 'current permanent|current temporary' \
							| awk '{print $3" "$NF}' \
							| tr "\012" "," )
		else
			FIRMWARE=$(lsmcode -c | grep "Firmware level" \
							| awk '{print $1" "$NF}' \
							| tr "\012" "," )
		fi
	
		if [[ -z $FIRMWARE ]]
		then
			if (( $(oslevel | sed -e 's/\.//g') >= 5000 ))
			then
				FIRMWARE=$(lscfg -vp | grep -p "System VPD:" \
						| grep "(YL)" \
						| sed -n 1p \
						| awk -F\) '{print $2}' \
						| sed -e 's/^\.*\.//g')
			else
				FIRMWARE=$(lscfg -vp | grep -p "Firmware:" \
						| grep "(YL)" \
						| sed -n 1p \
						| awk -F\) '{print $2}' \
						| sed -e 's/^\.*\.//g')
			fi	
		fi	
	
	
		#
		# use tmp file to capture stderr output that pipe doesn't
		#
		PATCHTMP=/tmp/oslevel.$$
		oslevel -g > $PATCHTMP 2>&1
		PATCH=$(cat $PATCHTMP | sed -n \$p | awk '{print $2}')
		rm $PATCHTMP
	
		oslevel -s > /dev/null 2>&1
		RET=$?
	
		if (( ! $RET ))
		then
			PATCH="$PATCH $(oslevel -s)"
		else
			PATCH="$PATCH $(oslevel -r)"
		fi
	
		if [[ -z $PATCH ]]
		then
			PATCH="unknown"
		fi
	
		RELEASE=$(oslevel -r)
		if [[ -z $RELEASE ]]
		then
			RELEASE="unknown"
		fi
	
	
	elif [[ $OSTYPE = HP-UX ]]
	then
		OSVER="$(uname -r)"
	
		if [[ -x /usr/contrib/bin/machinfo ]]
		then
			FIRMWARE="$(/usr/contrib/bin/machinfo -v \
							| awk -F= '/Firmware revision/ {print $2}' \
							| sed -e 's/ //g')"
		else
			FIRMWARE="unknown"
		fi
	
		PATCH=$(uname -a | awk '{print $3}')
		RELEASE="$(swlist -l bundle HPUX11i-OE* 2> /dev/null \
						| awk '/HP-UX/ {print $2}')"
	
		if [[ -z $RELEASE ]]
		then
			RELEASE="$(swlist -l product | grep "HP-UX OS" \
						| awk '{print $2}' \
						| sed -e 's/. *//')"
	
			if [[ -z $RELEASE ]]
			then
				RELEASE="unknown"
			fi
		fi
	
		if [[ -z $PATCH ]]
		then
			PATCH="unknown"
		fi
	
	elif [[ $OSTYPE = Linux ]]
	then
		OSVER="$(uname -r)"
		FIRMWARE="unknown"
		PATCH="$(rpm -qa | grep kernel-[0-9]  | sed -e 's/kernel-//')"
		if [[ -z $PATCH ]]
		then
			#
			#get whatever is there
			#
			PATCH="$(rpm -qa | grep kernel  | sed -n 1p)"
		fi
		RELEASE="$(cat /proc/version | awk '{print $3}')"
	
	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		#
		# don't run this if we are doing -win on the CLI
		#
		if [[ -z $WINDOWSFILE ]]
		then
			f_cgywin_mkdir_cdrive
			f_cygwin_prtconf
		
			NODE="$(awk -F: '/^Host Name:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"

			OSVER="$(awk -F: '/^OS Version:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"

			FIRMWARE="$(awk -F: '/^BIOS Version:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/ * / /g')"

			PATCH="$(awk -F: '/^Hotfix/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"

			RELEASE="$(awk -F: '/^Product ID:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"

			#
			# hopefully find msinfo32, if not, then settle for others in descending
			# preference, will loose/miss finding data in the other commands
			#
			if [[ -e $C_DRIVE/Windows/system32/msinfo32 ]]
			then
				f_cygwin_msinfo32

			elif [[ -e $C_DRIVE/Windows/system32/systeminfo ]]
			then
				WINSYSTEM_OUT="$C_DRIVE/temp/systeminfo.txt"
	
				$C_DRIVE/Windows/system32/systeminfo > $WINSYSTEM_OUT
				
			elif [[ -e $C_DRIVE/Windows/system32/dxdiag ]]
			then
				WINSYSTEM_OUT="$C_DRIVE/temp/dxdiag.txt"
	
				$C_DRIVE/Windows/system32/dxdiag /t > $WINSYSTEM_OUT
			fi
		fi
	fi
}

###################################################
# Get companyinfo config file contents
f_get_companyinfo ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: companyinfo"
	fi


	if [[ -s $COMPANYINFO ]]
	then
		#
		# Things that it contains:
		#
		#  Serial Number  = abc123456
		#  Business Unit  = Purchasing
		#  Server Usage   = prod|dev|test
		#  Location       = datacenter X
		#  Server Purpose = purchaseing database
		#  Lease Number   = xyz123456abc
		#  OldNames       = system1 system2
		#  Maintenance    = platinum|gold|silver|bronze
		#  Page           = yes|no
		#
	
		#
		# does NOT overwrite a DYNAMIC serial number
		#
		if [[ -z $SERNUM || $SERNUM = "unknown" || $SERNUM = "nc" ]]
		then
			SERNUM=$(grep -v ^# $COMPANYINFO   \
							| grep  -i "Serial.*Number" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )
		fi
	
		BUSUNIT=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Business.*Unit" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		USAGE=$(grep -v ^# $COMPANYINFO    \
							| grep  -i "Server.*Usage" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		LOCATION=$(grep -v ^# $COMPANYINFO \
							| grep  -i "Location" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		SRVPURP=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Server.*Purpose" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		LSENUM=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Lease.*Number" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		OLDNAMES=$(grep -v ^# $COMPANYINFO \
							| grep  -i "Old.*Names" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		MAINTENANCE=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Maintenance" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		PAGE=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Page" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		VIRTUALMACHINE=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Virtual.*Machine" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		ASSETNUMBER=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Asset.*Number" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )

		MISCELLANEOUS=$(grep -v ^# $COMPANYINFO  \
							| grep  -i "Miscellaneous" \
							| awk -F= '{print $2}' \
							| sed 's/ * //' )
	fi
}

###################################################
# Get serialnumber
f_get_serialnumber ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: serialnumber"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		if [[ -f /opt/SUNWsneep/bin/sneep ]]
		then
			SERNUM=$(/opt/SUNWsneep/bin/sneep)
		else
			SERNUM="unknown"
		fi

	elif [[ $OSTYPE = AIX ]]
	then
		SERNUM=$(grep "Machine Serial Number:" $PRTCONF_FILE \
					| awk -F:  '{print $2}')

		if [[ -z $SERNUM ]]
		then
			SERNUM="unknown"
		fi

	elif [[ $OSTYPE = HP-UX ]]
	then
		if [[ -x /usr/contrib/bin/machinfo ]]
		then
				SERNUM="$(/usr/contrib/bin/machinfo -v \
							| awk -F= '/machine serial number/ {print $2}')"

		else
			SERNUM=$(getconf MACHINE_SERIAL 2> /dev/null)

			if [[ -z $SERNUM ]]
			then
				SERNUM=$(getconf CS_MACHINE_SERIAL 2> /dev/null)

				if [[ -z $SERNUM ]]
				then
					#set in $PATH
					#/opt/hpsmc/common/bin/getsn
					SERNUM=$(getsn 2> /dev/null)

					if [[ $SERNUM = "Serial Number: Not Available" ]]
					then

						TMPSN=/tmp/mysn.$$
						cstm <<-EOF > $TMPSN
							map
							sel dev 1
							info
							il
							q
							usal
							q
						EOF
	
						if [[ -s $TMPSN ]]
						then
							SERNUM=$(awk '/^Product Number/ {print $3}' $TMPSN)
						else
							SETNUM="unknown"
						fi

						rm $TMPSN
					fi
				fi
			fi
		fi

	elif [[ $OSTYPE = Linux ]]
	then
		#
		# Should be able to do: dmidecode --type 1 | grep ... ,
		#  but not all dmidcodes are the same
		#
		if [[ -f /usr/sbin/dmidecode ]]
		then
			SERNUM="$(dmidecode \
							| awk -F: '/Serial Number:/ {print $2}'\
						| sed -n 1p \
						| sed -e 's/ //g')"
		else
			SERNUM="hostid: $(hostid)"
		fi

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		f_cgywin_mkdir_cdrive
		f_cygwin_prtconf

		SERNUM="$($C_DRIVE/Windows/system32/Wbem/wmic bios get serialnumber \
						| tr -d '\015' \
						| grep -v ^$ \
						| grep -v SerialNumber )"

		if [[ -z $SERNUM ]]
		then
			SERNUM="$(awk -F: '/^Product ID:/ {print $2}' $PRTCONF_FILE\
							| sed -e 's/^. *//')"
		fi

	else
		SERNUM=$HOSTID
	fi

	#
	#get rid of space in SERNUM
	#
	SERNUM=$($ECHO "$SERNUM" | sed -e 's/ //g')
}

###################################################
# Get hostid
f_get_hostid ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: hostid"
	fi

	if [[ $OSTYPE = SunOS ]]
	then
		HOSTID=$(hostid)

	elif [[ $OSTYPE = AIX ]]
	then
		HOSTID="$(uname -u)"

	elif [[ $OSTYPE = HP-UX ]]
	then
		HOSTID="$(uname -i)"

	elif [[ $OSTYPE = Linux ]]
	then
		HOSTID=$(hostid)
		if [[ -n $($ECHO $HOSTID | grep Error) ]]
		then
			HOSTID=$(ifconfig -a \
						| grep -iw hwaddr \
						| sed -n 1p \
						| awk -Faddr '{print $2}' \
							| sed -e 's/ //g' \
						| sed -e 's/://g' )
		fi

	elif [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		if [[ "$(which hosid 2> /dev/null | cut -c 1)" = '/' ]]
		then
			HOSTID=$(hostid)
		else
			#
			# if hostid command not found, turn the first MAC address into hostid
			#
			HOSTID=$(ipconfig /all \
					| grep "Physical Address" \
					| sed -n 1p \
					| awk '{print $NF}' \
					| sed -e 's/-//g')
		fi

	else
		HOSTID="unknown"
	fi
}

###################################################
# init variable
#
# get passed in a value to set to
#
f_variable_init ()
{
	#
	# This parses the file given for the -win CLI argument (static input file)
	#

	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: init variables"
	fi

	if [[ -n "$1" ]]
	then
		INIT_VALUE=$1
	else
		INIT_VALUE="unknown"
	fi

	NODE="$INIT_VALUE"
	HOSTID="$INIT_VALUE"
	SERNUM="$INIT_VALUE"
	ARCH="$INIT_VALUE"
	ARCHTYPE="$INIT_VALUE"
	MODEL="$INIT_VALUE"
	#OSTYPE="$INIT_VALUE"
	OSVER="$INIT_VALUE"
	PATCH="$INIT_VALUE"
	FIRMWARE="$INIT_VALUE"
	CPU="$INIT_VALUE"
	CPUMHZ="$INIT_VALUE"
	SWAP="$INIT_VALUE"
	DOMAIN="$INIT_VALUE"
	KERNELBIT="$INIT_VALUE"
	CPUSTRING="$INIT_VALUE"
	MEM="$INIT_VALUE"
	PAGESIZE="$INIT_VALUE"
	NET="$INIT_VALUE"
	RELEASE="$INIT_VALUE"
	CDDVD="$INIT_VALUE"
	NIC100="$INIT_VALUE"
	VIDEO="$INIT_VALUE"
	NIC100="$INIT_VALUE"
	VIDEO="$INIT_VALUE"
	CDDVD="$INIT_VALUE"
	VC="$INIT_VALUE"
	DSKVALUES="$INIT_VALUE"
	TOTDSK="$INIT_VALUE"
	DSKSML="$INIT_VALUE"
	DSK2GB="$INIT_VALUE"
	DSK4GB="$INIT_VALUE"
	DSK8GB="$INIT_VALUE"
	DSK18GB="$INIT_VALUE"
	DSK36GB="$INIT_VALUE"
	DSK73GB="$INIT_VALUE"
	DSK100GB="$INIT_VALUE"
	DSK150GB="$INIT_VALUE"
	DSK200GB="$INIT_VALUE"
	DSK300GB="$INIT_VALUE"
	DSK500GB="$INIT_VALUE"
	DSKBIG="$INIT_VALUE"
	#
	# HARDWARE
	#
	# Fill these with unknown until I find a good way to parse, if ever.
	#
	DSKEMC="$INIT_VALUE"
	DSKBCV="$INIT_VALUE"
	DSKIBM="$INIT_VALUE"
	DSKHDS="$INIT_VALUE"
	VNAMES="$INIT_VALUE"
	VIRTUAL="$INIT_VALUE"
	VIRTUALMACHINE="$INIT_VALUE"
	SSA="$INIT_VALUE"
	NETRA="$INIT_VALUE"
	PHOTON="$INIT_VALUE"
	ARRAYLIST="$INIT_VALUE"
	RAIDL="$INIT_VALUE"
	DGS="$INIT_VALUE"
	ZPOOLS="$INIT_VALUE"
	TAPE="$INIT_VALUE"
	SOC="$INIT_VALUE"
	BRD="$INIT_VALUE"
	SOC="$INIT_VALUE"
	SCSI="$INIT_VALUE"
	GBNIC="$INIT_VALUE"
	GBIC="$INIT_VALUE"
	HBA="$INIT_VALUE"
	FDDI="$INIT_VALUE"
	HSI="$INIT_VALUE"
	HBA_TYPE="$INIT_VALUE"
	HBA_DRV="$INIT_VALUE"
	HBA_FIRM="$INIT_VALUE"
	HBA_FC="$INIT_VALUE"
	#
	# SOFTWARE
	#
	# Fill these with unknown until I find a good way to parse, if ever.
	#
	VXVM="$INIT_VALUE"
	VXFS="$INIT_VALUE"
	VCS="$INIT_VALUE"
	PWRPTH="$INIT_VALUE"
	JAVA="$INIT_VALUE"
	PERL="$INIT_VALUE"
	VXVM="$INIT_VALUE"
	VXFS="$INIT_VALUE"
	VCS="$INIT_VALUE"
	NETBACKUP="$INIT_VALUE"
	TSM="$INIT_VALUE"
	VC="$INIT_VALUE"
	PWRPTH="$INIT_VALUE"
	ECC="$INIT_VALUE"
	ESN="$INIT_VALUE"
	VOLLOG="$INIT_VALUE"
	FZ="$INIT_VALUE"
	PATROL="$INIT_VALUE"
	SCHEDULER="$INIT_VALUE"
	FORTE="$INIT_VALUE"
	APACHE="$INIT_VALUE"
	NETSCAPE="$INIT_VALUE"
	WEBSPHERE="$INIT_VALUE"
	WEBLOGIC="$INIT_VALUE"
	BROADVISION="$INIT_VALUE"
	SQL_BKTRK="$INIT_VALUE"
	TRIPWIRE="$INIT_VALUE"
	SSH="$INIT_VALUE"
	#
	# Company Info
	#
	USAGE="$INIT_VALUE"
	LOCATION="$INIT_VALUE"
	BUSUNIT="$INIT_VALUE"
	SRVPURP="$INIT_VALUE"
	LSENUM="$INIT_VALUE"
	OLDNAMES="$INIT_VALUE"
	PAGE="$INIT_VALUE"
	MAINTENANCE="$INIT_VALUE"
	ASSETNUMBER="$INIT_VALUE"
	MISCELLANEOUS="$INIT_VALUE"

}

###################################################
# Get windows info from msinfo32 file
f_cygwin_msinfo32_parser ()
{
	#
	# This parses the file given for the -win CLI argument (static input file)
	#

	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: window msinfo32 parser - parsing the $WINDOWSFILE file"
	fi

	#
	# initialize all variables
	#
	f_variable_init unknown

	#
	# See if the output file is still a nfo/report file or not.
	# If so, convert it.
	#
	#if [[ -n $(file $WINDOWSFILE | awk -F: '{print $2}'| grep Unicode) ]]
	#then
	#	f_cygwin_msinfo32
	#fi

	#
	# Note: the text file is TAB delimited.  
	# Seperating the description field from the info field.
	#
	# I changed the TAB to an "@" (at) because cygwin's awk isn't always 
	# "smart" w/ TABs.
	#


	NODE="$(sed -n 1,3p $WINDOWSFILE \
						| grep '^System Name:' \
						| awk -F: '{print $2}' )"

	CPUSTRING="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep ^Processor \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	ARCH="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^System Type' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	#MODEL="$($C_DRIVE/Windows/system32/Wbem/wmic csproduct get name\
	#						| grep -vw Name )"

	MODEL="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^System Model' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	ARCHTYPE="$($ECHO $CPUSTRING | awk -F, '{print $1}')"

	CPU="$($ECHO $CPUSTRING | awk -F" Core" '{print $1}' | awk '{print $NF}')"

	CPUMHZ="$($ECHO $CPUSTRING | awk -FMhz '{print $1}' | awk '{print $NF}') MHZ"

	KERNELBIT="$($ECHO $CPUSTRING | awk '{print $3}')"

	MEM="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^Installed Physical Memory' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	SWAP="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^Page File Space' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	PAGESIZE="unknown"

	NET="$(awk '/^\[Adapter]/, /^\[Protocol]/' $WINDOWSFILE \
						| grep '^IP Address' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' \
						| grep -v 'Not Available' \
						| awk -F, '{print $1}' \
						| tr '\012' ',')"

	OSTYPE="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^OS Name' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	OSVER="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^Version' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	PATCH="Service Pack $(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^Version' \
						| sed -e 's/	/@/g' \
						| awk -FPack '{print $2}' \
						| awk '{print $1}')"

	FIRMWARE="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^BIOS Version\/Date' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' )"

	RELEASE="Build $(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $WINDOWSFILE \
						| grep '^Version' \
						| sed -e 's/	/@/g' \
						| awk -F@ '{print $2}' \
						| awk -FBuild '{print $2}')"

	HOSTID=$(awk '/^\[IRQ/, /^\[Memory/' $WINDOWSFILE \
					| grep ^MAC \
					| sed -n 1p \
					| awk '{print $NF}' \
					| sed -e 's/-//g')
	
	CDDVD="$(awk '/^\[CD-ROM/, /^\[S/'   $WINDOWSFILE | grep -wc ^Drive)"
	NIC100=$(awk '/^\[IRQ/, /^\[Memory/' $WINDOWSFILE | grep -c  ^Network)
	VIDEO=$(awk '/^\[DISPLAY/, /^\[I/'   $WINDOWSFILE | grep -c  ^Name)
	NIC100=$(awk '/^\[IRQ/, /^\[Memory/' $WINDOWSFILE | grep -c  ^Network)
	VIDEO=$(awk '/^\[DISPLAY/, /^\[I/'   $WINDOWSFILE | grep -c  ^Name)
	CDDVD="$(awk '/^\[CD-ROM/, /^\[S/'   $WINDOWSFILE | grep -wc ^Drive)"
	VC="$(awk '/Cluster/ {print $2}'     $WINDOWSFILE)"

	if [[ -z $VC ]]
	then
		VC="na"
	else
		VC="MicrosoftCluster $VC"
	fi

	DOMAIN="$(awk '/^Domain/ {print $2}' $WINDOWSFILE)"

	if [[ -z $DOMAIN ]]
	then
		DOMAIN="unknown"
	fi

	#
	# get sizes of each disk
	#
	DSKVALUES=$(sed -n '/^\[Disks\]$/,/^\[SCSI\]$/p' $WINDOWSFILE \
				| awk '/^Size/ {print $4}' \
				| sed -e 's/(//' \
				| sed -e 's/,[0-9][0-9][0-9],[0-9][0-9][0-9]$//' \
				| sed -e 's/,//' \
				| tr '#' '\012')

	# Total number of disks
	TOTDSK=$($ECHO $DSKVALUES | wc -l | awk '{print $1}')

	# Total disks under 2Gb
	DSKSML=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 < 2000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 2Gb and 4Gb
	DSK2GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 2000  && $0 < 4000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 4Gb and 8Gb
	DSK4GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 4000  && $0 < 8000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 8Gb and 18Gb
	DSK8GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 8000  && $0 < 18000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 18Gb and 36Gb
	DSK18GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 18000  && $0 < 36000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 36Gb and 73Gb
	DSK36GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 36000  && $0 < 73000) print $0}' \
			| wc -l | awk '{print $1}')
	# Total disks between 73Gb and 100Gb
	DSK73GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 73000  && $0 < 100000) print $0}'\
				| wc -l | awk '{print $1}')
	# Total disks between 100Gb and 150Gb
	DSK100GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 100000  && $0 < 150000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 100Gb and 150Gb
	DSK150GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 150000  && $0 < 200000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 200Gb and 300Gb
	DSK200GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 200000  && $0 < 300000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 300GB and 500GB
	DSK300GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 300000  && $0 < 500000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks between 500GB and 1TB
	DSK500GB=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 500000  && $0 < 1000000) print $0}' \
				| wc -l | awk '{print $1}')
	# Total disks bigger than 1TB
	DSKBIG=$($ECHO $DSKVALUES \
				| awk  '{$0+0; if ($0 >= 1000000) print $0}' \
				| wc -l | awk '{print $1}')
}

###################################################
# setup output files
f_output_setup ()
{
	if (( DEBUG ))
	then
		set -x
	fi

	if (( VERBOSE ))
	then
		$ECHO "Doing: outfile setup"
	fi

	PRG_VERSION="$(grep "^#.*Revision" $0 | sed -n 1p | awk '{print $3}' )"

	THIS_OUTPUTFILE=$OUTPUTDIR/$NODE.$THIS_SECTION.sysinfo.db

	touch $THIS_OUTPUTFILE
	chmod 666 $THIS_OUTPUTFILE

	$ECHO "#" \
							                     > $THIS_OUTPUTFILE

	$ECHO "#DO NOT REMOVE THIS LINE get_sysinfo: $PRG_VERSION" \
							                     >> $THIS_OUTPUTFILE

	$ECHO "#" \
							                     >> $THIS_OUTPUTFILE

	$ECHO "# SECTION: $THIS_SECTION" \
							                     >> $THIS_OUTPUTFILE
}

f_usage ()
{

cat << EOF

Usage for $0
Usage: 
Usage: [-debug] [-v] [-b binDIR] [ [-d outputDIR], [-f outputFILE] | -stdout ]
Usage:    <aboveopts> -sec (def=all) [sys,hard,virt,hba,disk,card,soft,comp]
Usage:    <aboveopts> -win [/path/to/]msinfo32.[txt,nfo]
Usage: -info | -doc
Usage: -V
Usage: -h

  no args: defaults to oputput to a file, echoed at end of program run
       -b: where to find bin's (like vname).  i.e. /usr/local/bin, or /tmp
       -d: where to put the output file
       -f: name for the output file

     -win: do ONLY windows parsing AGAINST an already products msinfo32 file
           use this if you want to pull the msinfo32 from a number of systems
           and parse them on a specific destination server
              c:\WINDOWS\system32\msinfo32.exe /report msinfo32-output.nfo
              type msinfo32-output.nfo > msinfo32.txt

           Note: You CANNOT select reporting sections with the winfile.
		         You get them all. 

     -sec: uses comma delimited list, any order, if it is given, it is set to 
	   TRUE and then that section is run.  Default is to do all sections.
       i.e. hard=hardware, virt=virtual, soft=software, comp=company

  -stdout: print the output to stdout

   -debug: debug mode, does a 'set -x' 
       -v: verbose mode

-info|doc: print out header documentation of program
       -V: Version - prints version of program
       -h: help - command synopsis/usage (this listing)
EOF
}

##########################################################################
##########################################################################
##########################################################################
#MAIN
#
#
#                                 MAIN
#
#
#
##########################################################################
##########################################################################
##########################################################################

#
# check for user in all BUT not in Cygwin
#
if [[ -z $($ECHO $OSTYPE | grep ^CYGWIN) ]]
then
	if (( $(id | awk '{print $1}' | sed -e 's/(.*)//' | awk -F= '{print $2}') != 0 ))
	then
		$ECHO "${DATE}:$(hostname):ERROR:7: you must be root (UID of 0) to run this command option"
		exit 7
	fi
fi

################################################################################
# Variables
#
# precendence: 
#   lowest:   settings directly in this file
#   next:     CFGFILE settings
#   highest:  CLI argurments
################################################################################

set -o allexport
#
#Make short hostname.  'hostname -s' doesn't work for all unix flavors
#
NODE=$(hostname | awk -F. '{print $1}' )
OSTYPE=$(uname 2> /dev/null)
HOSTID="unknown"
STDOUT=0

DATE=$(date +%Y.%m.%d.%H.%M)

DMZ_SERVERS=""

CFGFILE=/etc/get_sysinfo.cfg
BINDIR=/usr/local/bin
OUTPUTDIR=/tmp
OUTPUTFILE=$NODE.all.sysinfo.db
COMPANYINFO=/etc/companyinfo
WINDOWSFILE=""
SECTIONS="all"
C_DRIVE=/cygdrive/c

DEBUG=0
VERBOSE=0
ZONEGLOBAL=0

set +o allexport



################################################################################
# read in variables from CFGFILE
################################################################################
#
if [[ -f $CFGFILE ]]
then
	######################################
	BINDIRTMP="$(grep -v ^# $CFGFILE | awk '/BINDIR/ {print $2}' )"

	if [[ -n $BINDIRTMP ]]
	then
		BINDIR=$BINDIRTMP
	fi

	######################################

	OUTPUTDIRTMP="$(grep -v ^# $CFGFILE | awk '/OUTPUTDIR/ {print $2}' )"

	if [[ -n $OUTPUTDIRTMP ]]
	then
		OUTPUTDIR=$OUTPUTDIRTMP
	fi

	######################################
	OUTPUTFILETMP="$(grep -v ^# $CFGFILE | awk '/OUTPUTFILE/ {print $2}' )"

	if [[ -n $OUTPUTFILETMP ]]
	then
		OUTPUTFILE=$OUTPUTFILETMP
	fi
fi


###########
# PARSING: read in options & arguments 
###########

while (( $# ))
do
	case $1 in

		-b) shift

			if (( $# ))
			then
				BINDIR=$1
				shift
				if [[ ! -d $BINDIR ]]
				then
					$ECHO "ERROR:4: bindir $BINDIR doesn't exist"
					exit 4
				fi
			else
				$ECHO "ERROR:1: bindir (-b) needs an argument" 
				f_usage
				exit 1
			fi
			;;


		-d) shift

			if (( $# ))
			then
				OUTPUTDIR=$1
				shift
				if [[ ! -d $OUTPUTDIR ]]
				then
					$ECHO "ERROR:4: outputdir $OUTPUTDIR doesn't exist"
					exit 4
				fi
			else
				$ECHO "ERROR:1: outputdir (-d) needs an argument"
				f_usage
				exit 1
			fi
			;;


		-f) shift

			if (( $# ))
			then
				OUTPUTFILE=$1
				shift
				touch $OUTPUTFILE
				if [[ ! -f $OUTPUTFILE ]]
				then
					$ECHO "ERROR:5: outputfile $OUTPUTFILE cannot create"
					exit 5
				fi
			else
				$ECHO "ERROR:1: outputfile (-f) needs an argument"
				f_usage
				exit 1
			fi
			;;

		-win) shift
		
			if (( $# ))
			then
				WINDOWSFILE=$1
				shift
				if [[ ! -f $WINDOWSFILE ]]
				then
					$ECHO "ERROR:6: WINDOWSFILE $WINDOWSFILE not found"
					exit 6
				fi
			else
				$ECHO "ERROR:1: WINDOWSFILE (-win) needs a file argument"
				f_usage
				exit 1
			fi
			;;

		-sec) shift
		
			if (( $# ))
			then
				SECTIONS=$(echo $1 | sed -e 's/,/ /g')
				shift

				for SEC in $SECTIONS
				do
					if [[ -z $(echo "all sys hard virt disk hba card soft comp" | grep -w $SEC) ]]
					then
						$ECHO "ERROR:6: Section $SEC is invalid"
						exit 6
					fi
				done
			else
				$ECHO "ERROR:1: SECTIONS (-sec) needs at least one argument"
				f_usage
				exit 1
			fi
			;;

		-stdout) STDOUT=1
			shift
			;;

		-debug) DEBUG=1
			shift
			;;

		-v) VERBOSE=1
			shift
			;;

		-V) $ECHO "$0 is at version $(grep "^#.*Revision" $0 | sed -n 1p | awk '{print $3}' )"
			
			exit 0
			;;

		-info | -doc) 
			awk '/DOCBEGIN/, /DOCEND/' $0 \
						| sed -e 's/^#//' \
						| sed -e '/DOCBEGIN/d' \
						| sed -e '/DOCEND/d' \
						|  more
			exit 0
			;;

		-h|*) if [[ $1 != -h ]]
			then
				$ECHO ""
				$ECHO "   OPTION: $1 is invalid."
			else
				$ECHO ""
			fi

	   		f_usage
			exit 1
			;;
	esac
done

if (( DEBUG ))
then
	$ECHO "Command line option settings"
	$ECHO "...BINDIR:$BINDIR"
	$ECHO "...HOSTNAME:$NODE"
	$ECHO "...OSTYPE:$OSTYPE"
	$ECHO "...OUTPUTDIR:$OUTPUTDIR"
	$ECHO "...OUTPUTFILE:$OUTPUTFILE"
	$ECHO "...STDOUT:$STDOUT"
	$ECHO "...VERBOSE:$VERBOSE"
	$ECHO "...ZONEGLOBAL:$ZONEGLOBAL"

	set -x
fi



###################################################
# For DMZ nodes (nodes that do not normally have NFS access)
#     write to local file
#     have another program that uses scp/sftp to grab the files
#     normally need a: trusted server/gateway server/portal/jump_to_node
#
# Non-DMZ
#     write to NFS 
#   --OR-- 
#     local
#        have another program that uses scp/rcp/ftp/sftp to grab the files
#
if [[ -n $DMZ_SERVERS && -n $($ECHO $DMZ_SERVERS | grep -w $NODE) ]]
then
	#
	# for local path
	#
	OUTPUTDIR=/tmp
	OUTPUTFILE=$NODE.all.sysinfo.db
fi

################################################################################

if (( DEBUG ))
then
	set -x
fi

if (( VERBOSE ))
then
	$ECHO "Running $0"
fi

if [[ ! -d $OUTPUTDIR ]]
then
	if (( VERBOSE ))
	then
		$ECHO "Making DIR $OUTPUTDIR"
	fi
	mkdir -m 755 -p $OUTPUTDIR
fi

#
# initialize all variables
#
f_variable_init unknown

#
# no windows file on CLI, do normal stuff
#
# else, just parse the windows file
#
if [[ -z $WINDOWSFILE ]]
then
	# 
	# always call these functions 
	# 
	# this is really the "sys" functions, so if "sys" is selected, we already get it done
	# and the following if falls through.  Mabye not the best readable code - suggestions?
	# 
	f_get_hostid
	f_get_release

	# NOTE: f_get_serialnumber MUST be run BEORE f_get_companyinfo to keep SERNUM right

	f_get_serialnumber
	f_get_sys_info

	# default mode is to do all
	# SECTIONS: all sys hard virt disk hba card soft comp
	#
	if [[ $SECTIONS = all  ]]
	then
		f_get_psr_info
		f_get_mem_info
		f_get_virt_info
		f_get_disk_info
		f_get_array_info
		f_get_vol_info
		f_get_brd_info
		f_get_slot_info
		f_get_net_info
		f_get_hba_info
		f_get_sw_info

		# NOTE: f_get_serialnumber MUST be run BEORE f_get_companyinfo to keep SERNUM right
		f_get_companyinfo

	elif [[ -n $($ECHO $SECTIONS | grep -w sys) ]]
	then
		f_variable_init nc

		f_get_sys_info

	elif [[ -n $($ECHO $SECTIONS | grep -w hard) ]]
	then
		f_variable_init nc

		f_get_psr_info
		f_get_mem_info

	elif [[ -n $($ECHO $SECTIONS | grep -w virt) ]]
	then
		f_variable_init nc

		f_get_virt_info

	elif [[ -n $($ECHO $SECTIONS | grep -w disk) ]]
	then
		f_variable_init nc

		f_get_disk_info
		f_get_array_info
		f_get_vol_info

	elif [[ -n $($ECHO $SECTIONS | grep -w hba) ]]
	then
		f_variable_init nc

		f_get_hba_info

	elif [[ -n $($ECHO $SECTIONS | grep -w card) ]]
	then
		f_variable_init nc

		f_get_brd_info
		f_get_slot_info
		f_get_net_info
		f_get_hba_info

	elif [[ -n $($ECHO $SECTIONS | grep -w soft) ]]
	then
		f_variable_init nc

		f_get_sw_info

	elif [[ -n $($ECHO $SECTIONS | grep -w comp) ]]
	then
		f_variable_init nc

		# NOTE: f_get_serialnumber MUST be run BEORE f_get_companyinfo to keep SERNUM right
		f_get_companyinfo
	fi

	#
	# translate real windows name (varies too much) from cygwin uname
	#
	if [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		OSTYPE="$(awk -F: '/^OS Name:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"
		#OSTYPE="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $PRTCONF_FILE \
		#				| grep '^OS Name' \
		#				| sed -e 's/	/@/g' \
		#				| awk -F@ '{print $2}' )"
	fi

#
# windows file only
#
else
	#
	# windows file on CLI
	# work on an already existing windowsfile (msinfo32)
	#
	f_cygwin_msinfo32
	f_cygwin_msinfo32_parser
fi


#
# Populate each section, regardless of what we will be outputting later
#
O_SYS="$NODE:$HOSTID:$SERNUM:$OSTYPE:$OSVER:$RELEASE:$PATCH:"
O_HARD="$ARCH:$ARCHTYPE:$MODEL:$KERNELBIT:$FIRMWARE:$CPU:$CPUMHZ:$MEM:$PAGESIZE:$SWAP:$DOMAIN:$DGS:$ZPOOLS:"
O_VIRT="$VIRTUAL:$VNAMES:$VIRTUALMACHINE:"
O_DISK="$TOTDSK:$DSKSML:$DSK2GB:$DSK4GB:$DSK8GB:$DSK18GB:$DSK36GB:$DSK73GB:$DSK100GB:$DSK150GB:$DSK200GB:$DSK300GB:$DSK500GB:$DSKBIG:$DSKEMC:$DSKBCV:$DSKIBM:$DSKHDS:$CDDVD:$TAPE:$SSA:$PHOTON:$ARRAYLIST:$NETRA:$RAIDL:"
O_HBA="$HBA:$HBA_TYPE:$HBA_DRV:$HBA_FIRM:$HBA_FC:"
O_CARD="$NET:$NIC100:$GBNIC:$BRD:$GBIC:$SOC:$SCSI:$FDDI:$HSI:$VIDEO:"
O_SOFT="$JAVA:$PERL:$VXVM:$VXFS:$VCS:$NETBACKUP:$TSM:$VC:$PWRPTH:$ECC:$ESN:$VOLLOG:$FZ:$PATROL:$SCHEDULER:$FORTE:$APACHE:$NETSCAPE:$WEBSPHERE:$WEBLOGIC:$BROADVISION:$SQL_BKTRK:$TRIPWIRE:$SSH:"
O_COMP="$USAGE:$LOCATION:$BUSUNIT:$SRVPURP:$LSENUM:$OLDNAMES:$PAGE:$MAINTENANCE:$ASSETNUMBER:$MISCELLANEOUS:"


#
# SECTIONS: all sys hard virt disk hba card soft comp
#

if [[ $SECTIONS = all  ]]
then
	THIS_SECTION=all

	f_output_setup

	$ECHO "${O_SYS}${O_HARD}${O_VIRT}${O_DISK}${O_HBA}${O_CARD}${O_SOFT}${O_COMP}" \
				>>$OUTPUTDIR/$OUTPUTFILE

elif [[ -n $($ECHO $SECTIONS | grep -w sys) ]]
then
	THIS_SECTION=sys

	f_output_setup

	$ECHO " $O_SYS" >> $THIS_OUTPUTFILE

elif [[ -n $($ECHO $SECTIONS | grep -w hard) ]]
then
	THIS_SECTION=hard

	f_output_setup

	$ECHO " $O_HARD"

elif [[ -n $($ECHO $SECTIONS | grep -w virt) ]]
then
	THIS_SECTION=virt

	f_output_setup

	$ECHO " $O_VIRT"

elif [[ -n $($ECHO $SECTIONS | grep -w disk) ]]
then
	THIS_SECTION=disk

	f_output_setup

	$ECHO " $O_DISK"

elif [[ -n $($ECHO $SECTIONS | grep -w hba) ]]
then
	THIS_SECTION=hba

	f_output_setup

	$ECHO " $O_HBA"

elif [[ -n $($ECHO $SECTIONS | grep -w card) ]]
then
	THIS_SECTION=card

	f_output_setup

	$ECHO " $O_CARD"

elif [[ -n $($ECHO $SECTIONS | grep -w soft) ]]
then
	THIS_SECTION=soft

	f_output_setup

	$ECHO " $O_SOFT"

elif [[ -n $($ECHO $SECTIONS | grep -w comp) ]]
then
	THIS_SECTION=comp

	f_output_setup

	$ECHO " $O_COMP"

fi


#
# oputput to stdout or just list output filename
#
if (( $STDOUT ))
then
	cat $OUTPUTDIR/$OUTPUTFILE
else
	$ECHO "Output saved in: $OUTPUTDIR/$OUTPUTFILE"
fi

$ECHO "$0: Starting POST steps..."

#
# no windows file on CLI, do normal stuff
#
if [[ -z $WINDOWSFILE ]]
then
	#
	# UNtranslate real windows name
	#
	if [[ -n $($ECHO $OSTYPE | grep ^CYGWIN) ]]
	then
		OSTYPE="$(awk -F: '/^OS Name:/ {print $2}' $PRTCONF_FILE\
								| sed -e 's/^. *//')"

		#OSTYPE="$(awk '/^\[System Summary]/, /^\[Hardware Resources]/' $PRTCONF_FILE \
		#				| grep '^OS Name' \
		#				| sed -e 's/	/@/g' \
		#				| awk -F@ '{print $2}' )"
	fi

	#
	# Call other program.  Saves having more cron entries.
	#
	if [[ -f $BINDIR/get_dbms ]]
	then
		if (( VERBOSE ))
		then
			$ECHO "Doing: get_dbms"
		fi
	
		$BINDIR/get_dbms
	fi
	
	if [[ -f $BINDIR/get_emc ]]
	then
		if (( VERBOSE ))
		then
			$ECHO "Doing: get_emc"
		fi
	
		$BINDIR/get_emc
	fi
	
	if [[ -f $BINDIR/get_rup ]]
	then
		if (( VERBOSE ))
		then
			$ECHO "Doing: get_rup"
		fi
	
		$BINDIR/get_rup
	fi
	
	if [[ -f $BINDIR/get_printers ]]
	then
		if (( VERBOSE ))
		then
			$ECHO "Doing: get_printers"
		fi
	
		$BINDIR/get_printers
	fi
	
	
	#
	# remove temp files
	#
	DELETE_TMP_FILES="$PRTDIAG_FILE $PRTCONF_FILE $MSINFO32_BAT $RUNCMD_BAT $WINSYSTEM_OUT $MSINFO32_NFO_FILE"

	for FILE in $DELETE_TMP_FILES
	do
		if [[ -e $FILE ]]
		then
			rm $FILE
		fi
	done
fi

$ECHO "$0: Completed POST steps."