###############################################################################
#                                                                            
#                                 NOTICE                                     
#                                                                            
#                     COPYRIGHT 2008 QLOGIC CORPORATION                      
#                           ALL RIGHTS RESERVED                              
#                                                                            
# Name: libinstall
# Description:
# 	Install libqlsdm and libqsw* libraries to /usr/lib directory. 
# 	Check/update  /etc/hba.conf
# 	Cleanup temporary file in /tmp
#
#
###############################################################################
                                                                            
#!/bin/sh

# Find what platform that we are running on
PLATFORM=$(uname -m | sed "s/i.86/i386/")
KERNEL=`uname -r | awk '{print substr($1,1,3)}'`
LIBDIR="/usr/lib"
TMPDIR="/tmp"
CURDIR=`pwd`

# Libraries

CURLIBQLSDM="$LIBDIR/libqlsdm.so"
CURLIBQSW="$LIBDIR/libqsw.so"
CURLIBQSWOPENSSL="$LIBDIR/libqswopenssl.so"
CURLIBQSWSTUBSSL="$LIBDIR/libqswstubssl.so"
CURLIBHBAAPI="$LIBDIR/libHBAAPI.so"

LIBQLSDM="libqlsdm.so"
LIBQSW="libqsw.so"
LIBQSWOPENSSL="libqswopenssl.so"
LIBQSWSTUBSSL="libqswstubssl.so"
LIBHBAAPI="libHBAAPI.so"
BACKUP_DATE=`date +%m%d%y-%H_%M_%S`
LOGFILE=${TMPDIR}/scli_${BACKUP_DATE}.log
##################################################
# error_mssg                                      #
# Gives error mssg if installed lib ver is higher #
# than the new lib,which user want to install     #
#                                                 #
# Paramters:                                      #
# $1: Old Lib version                             #
# $2: New Lib version                             #                                 
##################################################
error_mssg()
{
    LIB_VER1=$1
    LIB_VER2=$2
    echo "Higher version  \"$LIB_VER1\"  library already installed"
    echo "To install this version  \"$LIB_VER2\"  use \"--force\" option"
    echo "For example # ./libinstall --force"
    exit 0
 
}
###################################################
# check_number                                    #
# Check the lib version                           #
# Paramters:                                      #
# $1 Number                                       #
# $2 Type                                         #
###################################################
check_number()
{
        NUM=$1
        TYPE=$2

        echo $NUM | grep -w "^[0-9]\+$" >& /dev/null
        if [ $? -ne 0 ]; then
                echo "${TYPE} version: ${NUM} should be numeric"
                echo "Skipping library installation"
                exit 0
        fi
}
##################################################
# comp_lib_ver                                    #
# Compares versions of already installed Library  #
# and New Library,which user want to install      #
#                                                 #
# Paramters:                                      #
# $1: Library (eg. /usr/lib64/libqlsdm.so)        #
# $2: Local copy (./lib64/libqlsdm.so)            #
##################################################
comp_lib_ver()
{
        LIB_OLD=$1
        LIB_NEW=$2
 
        LIB_VERSION1=""
        LIB_VERSION2=""
 
        OLD_MAJ=""
        OLD_MIN=""
        OLD_BUILD=""
        OLD_PRE=""
 
 
        NEW_MAJ=""
        NEW_MIN=""
        NEW_BUILD=""
        NEW_PRE=""
        if [ ! -f $LIB_OLD ]; then
                #if lib not already installed then return and install new one   
                return 1
        fi
        #check old version is greater than new version
        LIB_VERSION1=`strings $LIB_OLD | grep "library version" | sed "s/.*v//"`
 
        if [ ! -f $LIB_NEW ]; then
                echo "Cannot find $LIB_NEW, skipping Library installation."
                echo "Cannot find $LIB_NEW, skipping Library installation." >> ${LOGFILE}
                return 0
        fi
 
        LIB_VERSION2=`strings $LIB_NEW | grep "library version" | sed "s/.*v//"`
 
        OLD_MAJ=`echo $LIB_VERSION1 | sed "s/ b.*//" | cut -d . -f 1`
        if [ "$OLD_MAJ" = "" ]; then
                OLD_MAJ=0
        else
                check_number $OLD_MAJ "Major"
        fi
 
        NEW_MAJ=`echo $LIB_VERSION2 | sed "s/ b.*//" | cut -d . -f 1`
        if [ "$NEW_MAJ" = "" ]; then
                NEW_MAJ=0
        else
                check_number $NEW_MAJ "Major"
        fi
 	#compare major here
        if [ $OLD_MAJ -gt $NEW_MAJ ]; then
              error_mssg "${LIB_VERSION1}"  "${LIB_VERSION2}"
        elif [ $OLD_MAJ -lt $NEW_MAJ ]; then
                return 1
        fi
 
        OLD_MIN=`echo $LIB_VERSION1 | sed "s/ b.*//" | cut -d . -f 2`
        if [ "$OLD_MIN" = "" ]; then
                OLD_MIN=0
        else
                check_number $OLD_MIN "Minor"
        fi
 
        NEW_MIN=`echo $LIB_VERSION2 | sed "s/ b.*//" | cut -d . -f 2`
        if [ "$NEW_MIN" = "" ]; then
                NEW_MIN=0
        else
                check_number $NEW_MIN "Minor"
        fi
        #Compare min
        if [  $OLD_MIN -gt $NEW_MIN ]; then
                error_mssg "${LIB_VERSION1}"  "${LIB_VERSION2}"
        elif [ $OLD_MIN -lt $NEW_MIN ]; then
                return 1
        fi

 	OLD_BUILD=`echo $LIB_VERSION1 | sed "s/.*build//" | sed "s/.*beta//" | sed "s/-[Pp][Rr][Ee].*//"`
        if [ "$OLD_BUILD" = "" ]; then
                OLD_BUILD=0
        else
                check_number $OLD_BUILD "Build"
        fi
 
        NEW_BUILD=`echo $LIB_VERSION2 | sed "s/.*build//" | sed "s/.*beta//" | sed "s/-[Pp][Rr][Ee].*//"`
        if [ "$NEW_BUILD" = "" ]; then
                NEW_BUILD=0
        else
                check_number $NEW_BUILD "Build"
        fi
 
        #compare build
        if [  $OLD_BUILD -gt $NEW_BUILD ]; then
                error_mssg "${LIB_VERSION1}"  "${LIB_VERSION2}"
        elif [ $OLD_BUILD -lt $NEW_BUILD ]; then
                return 1
        fi

 	OLD_PRE=`echo $LIB_VERSION1 | sed "s/.*"-[Pp][Rr][Ee]"//"`
        echo $OLD_PRE | grep -w "^[0-9]\+$" >& /dev/null
        if [ $? -ne 0 ]; then
             OLD_PRE=0
        fi
 
        NEW_PRE=`echo $LIB_VERSION2 | sed "s/.*"-[Pp][Rr][Ee]"//"`
        echo $NEW_PRE | grep -w "^[0-9]\+$" >& /dev/null
        if [ $? -ne 0 ]; then
             NEW_PRE=0
        fi
 
       #Compare pre
 
        if [  $OLD_PRE -eq $NEW_PRE ]; then
               echo "Library ${LIB_VERSION1} already installed at $LIB_OLD."
               echo "Library ${LIB_VERSION1} already installed at $LIB_OLD." >> ${LOGFILE}
               return 0
        fi

	if [ $OLD_PRE -eq 0 ]; then
              error_mssg "${LIB_VERSION1}"  "${LIB_VERSION2}"
        fi
 
        if  [ $NEW_PRE -eq 0 ]; then
              return 1
        fi
 
        if [  $OLD_PRE -gt $NEW_PRE ]; then
                error_mssg "${LIB_VERSION1}"  "${LIB_VERSION2}"
        elif [ $OLD_PRE -lt $NEW_PRE]; then
                return 1
        fi
}

###################################################
# install_lib                                     #
# Installs the libqlsdm.so in /usr/lib or/and     #
# /usr/lib64                                      #
#                                                 #
# Paramters:                                      #
# $1: Library (eg. /usr/lib64/libqlsdm.so)        #
# $2: Local copy (./lib64/libqlsdm.so)            #
# $3: Destination                                 #
# $4: --force parameter                           #
###################################################
install_lib()
{
        LIB=$1
        LOCAL_LIB=$2
        DEST=$3
        FORCE=$4
 
        local INSTALL=0
 	if [ "--force" = "$FORCE" ]; then
      		INSTALL=1
 	else
        	if [ -f $LIB ]; then
                	#make sure we are not installing again
                	comp_lib_ver $LIB $LOCAL_LIB
                	INSTALL=$?
        	else
                	INSTALL=1
        	fi
 	fi
 
        if [ $INSTALL -eq 1 ]; then
                cp --suffix=.ql.bak --backup=existing $LOCAL_LIB $DEST
        fi
}

###################################################
# install_other_lib                              #
# Installs the libs in /usr/lib or/and            #
# /usr/lib64                                      #
#                                                 #
# Paramters:                                      #
# $1: Library (eg. /usr/lib/libHBAAPI.so)         #
# $2: Local copy (./lib/libHBAAPI.so)             #
# $3: Destination                                 #
###################################################
install_other_lib()
{
        LIB=$1
        LOCAL_LIB=$2
        DEST=$3
        local INSTALL=0
        if [ -f $LIB ]; then
                #make sure we are not installing again
                diff $LIB $LOCAL_LIB >& /dev/null
                if [ $? -ne 0 ]; then #different
                        INSTALL=1
                else
                        # Check to see backup already taken
                        if [ ! -f ${LIB}.no.bak ]; then
                                ls ${LIB}.*.bak >& /dev/null
                                if [ $? -ne 0 ]; then
                                        INSTALL=1
                                fi
                        fi
                fi
        else
		INSTALL=1
		echo "No original module" > ${LIB}.no.bak
        fi

        if [ $INSTALL -eq 1 ]; then
                echo -n "Installing $2 to $3..., "  >> ${LOGFILE}
                cp --suffix=.${BACKUP_DATE}.bak --backup=existing $LOCAL_LIB $DEST 
                if [ $? -eq 0 ] ; then
                	echo "Done"  >> ${LOGFILE}
                fi
        fi
}

# Check the agent/scli
ps -ef | grep -v qlremote | grep qlremote
if [ $? -eq  0 ]; then
        echo "Please shutdown qlremote and retry again"
        exit
fi

ps -ef | grep -v scli | grep scli
if [ $? -eq  0 ]; then
        echo "Please shutdown scli and retry again"
        exit
fi

# Handle different platform

echo "Setting up QLogic HBA/Switch API libraries..."  > ${LOGFILE}
echo "Architecture: $PLATFORM"  > ${LOGFILE}
echo "Kernel: $KERNEL"  > ${LOGFILE}
echo "Please make sure the /usr/lib/libqlsdm.so file is not in use."  >> ${LOGFILE}

if [ "$PLATFORM" = "i386"  ]; then
        SUP_PLATFORM="ia32"
        if [ "$KERNEL" == "2.0" ] ||
           [ "$KERNEL" == "2.1" ] ||
           [ "$KERNEL" == "2.2" ] ||
           [ "$KERNEL" == "2.3" ]; then
  		echo "Unsupported kernel version. Installation aborted!"  
               	exit
        else
		echo "Installing ia32 libraries on 2.4/2.6 kernel."  >> ${LOGFILE}
                # Use the 2.4
                KERNEL="2.4"
 	fi 
elif [ "$PLATFORM" = "i686"  ]; then
        SUP_PLATFORM="ia32"
	echo "Installing ia32 libraries on 2.6 kernel."  >> ${LOGFILE}
elif [ "$PLATFORM" = "x86_64" ]; then
        SUP_PLATFORM="ia32"
        if [ -e /usr/lib64 ]; then
		echo "Installing 64bit libraries for x86_64." >> ${LOGFILE}
        else
		echo "Installing 32bit libraries for x86_64." >> ${LOGFILE}
	fi
elif [ "$PLATFORM" = "ia64" ] ; then
	echo "Installing ia64 libraries." >> ${LOGFILE}
	echo "Installing ia64 libraries." 
        SUP_PLATFORM="ia64"
elif [ "$PLATFORM" = "ppc64" ]; then
        SUP_PLATFORM="ppc64"
	if [ "$KERNEL" = "2.6" ]; then
		echo "Installing ppc64 libraries on 2.6 kernel." >> ${LOGFILE}
	else
		echo "Installing ppc64 libraries on 2.4 kernel." >> ${LOGFILE}
	fi
else
	echo "Platform not supported. Installation aborted." 
	echo "Platform not supported. Installation aborted."  >> ${LOGFILE}
        exit
fi

# Update these variables
LIBQLSDM="${CURDIR}/${SUP_PLATFORM}/${KERNEL}/libqlsdm.so"
LIBQSW="${CURDIR}/${SUP_PLATFORM}/${KERNEL}/libqsw.so"
LIBQSWOPENSSL="${CURDIR}/${SUP_PLATFORM}/${KERNEL}/libqswopenssl.so"
LIBQSWSTUBSSL="${CURDIR}/${SUP_PLATFORM}/${KERNEL}/libqswstubssl.so"
LIBHBAAPI="${CURDIR}/${SUP_PLATFORM}/${KERNEL}/libHBAAPI.so"

# Let install_lib() function does the work 
install_lib "$CURLIBQLSDM"  "$LIBQLSDM" "$LIBDIR"  $1
install_other_lib "$CURLIBHBAAPI"  "$LIBHBAAPI" "$LIBDIR" 
install_other_lib "$CURLIBQSW"  "$LIBQSW" "$LIBDIR" 
install_other_lib "$CURLIBQSWOPENSSL"  "$LIBQSWOPENSSL" "$LIBDIR" 
install_other_lib "$CURLIBQSWSTUBSSL"  "$LIBQSWSTUBSSL" "$LIBDIR" 
ldconfig

# Now check the hba.conf file
ETC_HBA_CONF=/etc/hba.conf
ETC_NEW_HBA_CONF="${TMPDIR}/new_hba.conf"
if [ -s $ETC_HBA_CONF ]
then
 
        if [ -r $ETC_HBA_CONF ] && [ -w $ETC_HBA_CONF ]
        then
                cp $ETC_HBA_CONF $ETC_NEW_HBA_CONF
                if [ $SUP_PLATFORM == x86_64 ]
                then
                        echo "qla2xxx64 /usr/lib64/libqlsdm.so" >> ${CURDIR}/hba.conf
                        sed -e '/^[[:space:]]*qla2xxx64*/d' $ETC_NEW_HBA_CONF 2>&1 >> ${LOGFILE}
                fi
 
                sed -e '/^[[:space:]]*qla2x00*/d' $ETC_NEW_HBA_CONF 2>&1 >> ${LOGFILE}
                sed -e '/^[[:space:]]*qla2xxx*/d' $ETC_NEW_HBA_CONF 2>&1 >> ${LOGFILE}
 
                #cat ${CURDIR}/hba.conf >> $ETC_NEW_HBA_CONF
 
                #now move the new hba.conf and backup original ones
                mv -f --suffix=.${BACKUP_DATE}.bak --backup=existing $ETC_NEW_HBA_CONF $ETC_HBA_CONF
 
        else
                echo "Cannot update /etc/hba.conf. Permission denied."
                exit
        fi
 
else
        if [ $SUP_PLATFORM == x86_64 ]
        then
                echo "qla2xxx64 /usr/lib64/libqlsdm.so" >> ${CURDIR}/hba.conf
        fi
        cp ${CURDIR}/hba.conf /etc
fi

# Now check the library data file

if [ -s "${TMPDIR}/qlsdm.dat" ]
then
    if [ -r ${TMPDIR}/qlsdm.dat ] && [ -w ${TMPDIR}/qlsdm.dat ]
    then
        rm -f ${TMPDIR}/qlsdm.dat
    else
        echo "Cannot delete ${TMPDIR}/qlsdm.dat. Permission denied. Please delete it manually."
        exit
    fi
fi

echo "Done." >> ${LOGFILE}
