inf.tcl

vxworks下MV5500的BSP支持包。是支持tornad221下的版本。

        for {set i $num_patches_installed} {$i > 0 && $patch_installed == 0} {incr i -1} {
            regexp "$patchid-\[0-9\]+" $showrev patch_compare
            regexp {\-[0-9]+} $patch_compare installed_patch_version
            regexp {[0-9]+} $installed_patch_version installed_patch_version
            if {$installed_patch_version >= $patchversion} {
                set patch_installed 1
                infputs "INF Processing: CheckPatch: $patch_compare installed for $patchnumber requirement"
            }
            regsub "$patchid-\[0-9\]+" $showrev {} showrev
        }
       
        # if patch is not installed, append patch number and description
        # to global string uninstalledPatches, which will be displayed
        # later 
        if {$patch_installed == 0} {
            infputs "INF Processing: CheckPatch: $requirements patch $patchnumber not installed"
            if {$requirements == "required"} {
                append setupVals(uninstalledPatches_required) "$patchnumber\t$description\n"     
            } else {
                append setupVals(uninstalledPatches_recommended) "$patchnumber\t$description\n"     
            }
        }
    }
}

#############################################################################
#
# checkSolarisPatch_for_t3 - checks to make sure the specified patch is 
#                            installed for a Solaris machine.
#
# This procedure is used in T3 only
#
# This is the actual routine for Solaris that checks whether the required
# patch specified by <line> is installed on the user's machine.  Information
# about the user's machine is first gathered, then the list of conditions
# is iterated through to determine whether to actually check for the installed
# patch.
#
# The list of conditions is a tcl style list.  If no conditions are specified,
# the patch will automatically be checked to determine if it has been installed.
# If any of the conditions specified do not match the information gathered about
# the user's machine, installation of the patch is NOT checked.
# The following conditions are supported:
#
# 5.7 | 2.7: operating system is Solaris 2.7
# configuration-specific:
# PGX (M64 Graphics card): for patch 106146-06
# Creator/Creator3D graphics card: for patch 106145-04
# Elite3D graphics card: for patch 106144-06
#
# An example condition list: 2.7 m640
# specifies to check for the patch only if the user's machine has 
# m640 graphics card and is running on Solaris 2.7
#
# Any patches that are not found to be installed are appended
# to the global string setupVals(uninstalledPatches_required) or
# setupVals(uninstalledPatches_recommended).  This string is used
# in INSTW32.TCL to display to the user a messageBox detailing the required
# patches.
#
#
# SYNOPSIS
# checkSolarisPatch <line>
#
# PARAMETERS:
#   line : a comma delimited line containing required patches to be checked.
#
# RETURNS: N/A
#
# ERRORS: N/A
#

proc checkSolarisPatch_for_T3 {line} {
    global setupVals

    set patchnumber [nthValueFromCommaDelimitedLine $line 1]
    set description [nthValueFromCommaDelimitedLine $line 2]
    set os          [nthValueFromCommaDelimitedLine $line 3]
    set conditions  [nthValueFromCommaDelimitedLine $line 4]
    set requirements [nthValueFromCommaDelimitedLine $line 5]

    if {$requirements == "no_value" || $requirements != "required"} {
        set requirements "recommended"
    }

    # os version
    catch {exec /bin/uname -r} user_osversion
    infputs "INF Processing: CheckPatch: osversion = $user_osversion"

    # graphics cards
    catch {exec /bin/ls /dev/fbs} user_graphicsCard

    # For Solaris 2.7, specifically check for "5.7".  This means that
    # only version 2.7 of the OS is checked for, not 2.7.x.

    if {$user_osversion == "5.7"} {
        set solaris27 1
    } else {
        set solaris27 0
    }

    # check for patch conditions
    set check_for_patch 1
    if {$conditions == "no_value"} {
        set conditions ""
    }
    foreach condition $conditions {
        switch -- $condition {
            5.7 -
                2.7 {
                if {$solaris27 == 0} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch:\
                             will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch:\
                             condition user machine not Solaris 2.7"
                }
            }
            m640 -
                M640 {
                if {$user_graphicsCard != "m640"} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch:\
                             will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch:\
                                     condition user machine not M640 graphics card"
                }
            }
            ffb -
                FFB {
                if {$user_graphicsCard != "ffb"} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch:\
                             will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch:\
                             condition user machine not FFB graphics card"
                }
            }
            afb -
                AFB {
                if {$user_graphicsCard != "afb"} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch:\
                             will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch:\
                             condition user machine AFB graphics card"
                }
            }
            default {
                infputs "INF Processing: CheckPatch:\
                         condition $condition not supported"
            }
        }
    }

    if {$check_for_patch == 1} {
        infputs "INF Processing: CheckPatch: checking for patch $patchnumber"
            regexp {[0-9]+} $patchnumber patchid
        regexp {\-[0-9]+} $patchnumber patchversion
        regexp {[0-9]+} $patchversion patchversion
        infputs "INF Processing: CheckPatch: required patch level: $patchversion"
        catch { exec /bin/showrev -p | /bin/grep $patchid } showrev        

        # count the number of patch versions installed
            set num_patches_installed [regsub -all "$patchid-\[0-9\]+" $showrev {} ignore]

        # check the patches are equivalent or higher version
        set patch_installed 0

        for {set i $num_patches_installed} {$i > 0 && $patch_installed == 0} {incr i -1} {
            regexp "$patchid-\[0-9\]+" $showrev patch_compare
            regexp {\-[0-9]+} $patch_compare installed_patch_version
            regexp {[0-9]+} $installed_patch_version installed_patch_version
            if {$installed_patch_version >= $patchversion} {
                set patch_installed 1
                infputs "INF Processing: CheckPatch: $patch_compare installed for $patchnumber requirement"
            }
            regsub "$patchid-\[0-9\]+" $showrev {} showrev
        }

        # if patch is not installed, append patch number and description
        # to global string uninstalledPatches, which will be displayed
        # later
        if {$patch_installed == 0} {
            infputs "INF Processing: CheckPatch:\
                     $requirements patch $patchnumber not installed"
                if {$requirements == "required"} {
                append setupVals(uninstalledPatches_required)\
                           "$patchnumber\t$description\n"
                } else {
                append setupVals(uninstalledPatches_recommended)\
                           "$patchnumber\t$description\n"
            }
        }
    }
}


#############################################################################
#
# checkHPUXPatch - checks to make sure the specified patch is installed
#                     for an HPUX machine.
#
# This is the actual routine for HPUX that checks whether the required
# patch specified by <line> is installed on the user's machine.
#
# Currently there are no special conditions to check for HPUX.
# The condition list is ignored.
#
# Any patches that are not found to be installed are appended
# to the global string uninstalledPatches.  This string is used
# in INSTW32.TCL to display to the user a messageBox detailing the required
# patches.
#
# SYNOPSIS
# checkHPUXPatch <line>
#
# PARAMETERS:
#   line : a comma delimited line containing required patches to be checked.
#
# RETURNS: N/A
#
# ERRORS: N/A
#

proc checkHPUXPatch {line} {
    global setupVals
    global ctrlVals
    global env

    set patchlist    [nthValueFromCommaDelimitedLine $line 1]
    set description  [nthValueFromCommaDelimitedLine $line 2]
    set os           [nthValueFromCommaDelimitedLine $line 3]
    set conditions   [nthValueFromCommaDelimitedLine $line 4]
    set requirements [nthValueFromCommaDelimitedLine $line 5]

    if {$requirements == "no_value" || $requirements != "required"} {
        set requirements "recommended"
    }

    set check_for_patch 1

    #
    # check for any necessary conditions here.
    #

    if {$check_for_patch == 1} {
        infputs "INF Processing: CheckPatch: checking for patch $patchlist"

        # run swlist once to save time.
        if {![info exists ctrlVals(swlist)]} {
            catch { exec /usr/sbin/swlist -l product | /bin/grep PH } ctrlVals(swlist)
            if {[catch {open $env(TMP)/swlist w} swlist_fileid]} {
                # Cannot open the file
                puts "Cannot open $env(TMP)/swlist"
            } else {
                puts $swlist_fileid $ctrlVals(swlist)
                close $swlist_fileid
            }
        }
        # this should be the minimum patch version required to be installed.
        set minimum_patch_version [lindex $patchlist end]

        # this should be the latest patch version we know of and will
        # be used in the message displayed to the user.
        set patchnumber [lindex $patchlist 0]

        # check if the patch is installed.
        set patch_installed 0

        # first use the patch list directly to check for the patch.
        foreach patch $patchlist {
            if {[regsub -all $patch $ctrlVals(swlist) {} ignore]} {
                set patch_installed 1
            }
        }

        # if using the patch list is unsucessful, use the description
        # to check for the patch.  The last value in $patchlist is the
        # minimum patch version to check for as well.

        if { $patch_installed == 0 } {
            # if a version of the patch is installed, the following command
            # should return the patch version and the description of the
            # patch.
            catch { exec /bin/fgrep -i "$description" $env(TMP)/swlist } grep_result

            # now check to see if $description is part of $grep_result.
            # If it is, check to make sure the version installed is the
            # minimum required.  If both criterias are true, a valid
            # version of the patch has been installed.
            if {[string last [string toupper $description] [string toupper $grep_result]] > -1} {
                set user_patch_version [lindex $grep_result 0]

                # extract the prefix portion of the patch version
                # e.g. extract PHSS_ from PHSS_15043
                regexp {[^0-9]+} $user_patch_version user_patch_version_prefix

                # extract the prefix portion of the minimum patch version
                regexp {[^0-9]+} $minimum_patch_version minimum_patch_version_prefix

                # make sure the prefixes match
                if {$user_patch_version_prefix == $minimum_patch_version_prefix} {
                    # extract the number portion of the patch version
                    # e.g. extract 15043 from PHSS_15043
                    regexp {[0-9]+} $user_patch_version user_patch_version_number

                    # extract the number portion of the minimum patch version
                    regexp {[0-9]+} $minimum_patch_version minimum_patch_version_number
                    if { $user_patch_version_number >= $minimum_patch_version_number } {
                        set patch_installed 1
                    }
                }
            }
        }

        # if patch is not installed, append patch number and description
        # to global string uninstalledPatches, which will be displayed
        # later
        if {$patch_installed == 0} {
            infputs "INF Processing: CheckPatch: $requirements patch $patchnumber not installed"
            if {$requirements == "required"} {
                append setupVals(uninstalledPatches_required) "$patchnumber\t$description\n"
            } else {
                append setupVals(uninstalledPatches_recommended) "$patchnumber\t$description\n"
            }
        }
    }
}

#############################################################################
#
# checkPatchLine - checks to make sure the specified patch is installed.
#
# Checks that the required patch specified is installed on the user's
# machine.  Any required patches that are not found to be installed are
# appended to the global string uninstalledPatches.  This string is used
# in INSTW32.TCL to display to the user a messageBox detailing the required
# patches.  Currently Solaris and HPUX10 is supported.
#
# The format of the line read from the inf file is as follows (optional
# parameters in brackets):
#
#   patch number, patch description, os version (wind host type), conditions, [requirements]
#
#   patch number : number and version of patch to be checked
#   patch description : string description of required patch
#   os version/wind host type: sun4-solaris2 | parisc-hpux10
#   conditions : a list of required conditions that specify whether to check
#                if the patch is installed.  See checkSolarisPatch and
#                and checkHPUXPatch for more details.
#   requirements: required | recommended
#             if the patch is required to be installed, Setup will inform
#             the user and not allow installation to continue.  Default
#             is recommended, in which case Setup will inform the user that
#             it is recommended to install the patch, but will allow
#             installation to continue.
#
# SYNOPSIS
# checkPatchLine <line>
#
# PARAMETERS:
#   line : a comma delimited line containing required patches to be checked.
#
# RETURNS: N/A
#
# ERRORS: N/A
#

proc checkPatchLine {line} {
    global env
    global infVals
    global setupVals

    set os [nthValueFromCommaDelimitedLine $line 3]

    if {![info exists setupVals(uninstalledPatches_required)]} {
        set setupVals(uninstalledPatches_required) ""
    }