inf.tcl

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

        # add the icon
        if {[string compare $iconPath no_value]==0} {
            # iconPath not specified, use default executable for icon
            infputs "INF Processing: \
                  adding Icon: $group $item $exe $args $completeDirName"
            linkCreateLog $group $item "$destinationDir$exe" $args \
                          $completeDirName $ctrlVals(admin) $fmin $iconIndex
        } else {
            infputs "INF Processing: \
                  adding Icon: $group $item $exe $args $completeDirName \
                               $destinationDir$iconPath"
            linkCreateLog $group $item "$destinationDir$exe" $args \
                          $completeDirName $ctrlVals(admin) $fmin \
                          $iconIndex "$destinationDir$iconPath"
        }
    }
}

#############################################################################
#
# completeDestinationDirName - returns a directory path based on
#                              the user selected destination directory
#
# Prepends the destination directory specified by [destDirGet] to
# the directory value.  Slashes are correctly handled.
#
# SYNOPSIS
# completeDestinationDirName <dir>
#
# PARAMETERS:
#   dir : directory path to prepend the destination directory path
#
# RETURNS:
#   directory path with destination directory prepended
#
# ERRORS: N/A
#


proc completeDestinationDirName {dir} {
    set destinationDir [destDirGet]

    # add trailing slash to destinationDir if it does not exist
    set lastCharacter [string index $destinationDir [expr [string length $destinationDir]-1]]
    if {[string compare $lastCharacter \\] != 0} {
        append destinationDir \\
    }

    # remove beginning slash from dir if it exists
    set firstCharacter [string index $dir 0]
    if {[string compare $firstCharacter \\] == 0} {
        set dir [string range $dir 1 [expr [string length $dir]-1]]
    }

    # dir might be equal to no_value.  Set it to an empty string if this is the case.
    if {[string compare $dir no_value]==0} {
        set dir ""
    }

    return "$destinationDir$dir"
}

#############################################################################
#
# fullPathName - returns a full path to the specified executable.
#
# Returns a complete pathname given, including the destination directory
# prepended to the path, given an executable or file and the path to the executable.
#
# SYNOPSIS
# fullPathName <path> <exe>
#
# PARAMETERS:
#   path : directory path to the executable
#   exe : executable or file
#
# RETURNS:
#   complete directory path to the executable, including the destination
#   directory prepended to the path.
#
# ERRORS: N/A
#

proc fullPathName {path exe} {
    set completeDirName [completeDestinationDirName $path]

    set endStringIndex [expr [string length $completeDirName]-1]
    set lastCharacter [string index $completeDirName $endStringIndex]

    # add the trailing slash to completeDirName if it does not exist
    if {[string compare $lastCharacter \\] != 0} {
        append completeDirName \\
    }

    # append the executable name to completeDirName
    append completeDirName $exe
    return $completeDirName
}

#############################################################################
#
# addServiceLine - adds a service to Windows NT from the values read from
#                  a line from an inf file
#
# Adds and starts the specified service if the OS is Windows NT.  If the OS
# is not Windows NT the procedure simply returns.  The format of the line read
# from the inf file is as follows (optional parameters in brackets):
#
#   service name, executable, path, [dependency], [control var]
#
#   service name : name of the service to be added to Windows NT
#   executable : filename of the service executable
#   path : directory path to the executable
#   dependency : any dependencies that must be started before this service
#   [control var] : conditional control variable allowing service to be added.
#                   infVals(control var) must exist and be set to any value other
#                   than 0.
#
# If [control var] is specified, the global variable infVars(control var)
# must exist and be set to a value other than 0.  Otherwise the service will not
# be added.  This allows for conditional control of adding the service.
#
# SYNOPSIS
# addServiceLine <line>
#
# PARAMETERS:
#   line : a comma delimited line containing values to be added as a service to
#          Windows NT.
#
# RETURNS: N/A
#
# ERRORS: N/A
#

proc addServiceLine {line} {
    global ctrlVals
    global infVals

    if {$ctrlVals(NT) != 1} {
        infputs "INF Processing: will not add service: OS is not NT"
        return
    }

    set serviceName [nthValueFromCommaDelimitedLine $line 1]
    set serviceExe  [nthValueFromCommaDelimitedLine $line 2]
    set servicePath [nthValueFromCommaDelimitedLine $line 3]
    set dependency  [nthValueFromCommaDelimitedLine $line 4]
    set controlvar  [nthValueFromCommaDelimitedLine $line 5]



    if {[string compare $dependency no_value]==0} {
        set dependency ""
    }
    if {[string compare $servicePath no_value]==0} {
        set servicePath ""
    }

    # check the control variable
    set addservice 1
    if {[string compare $controlvar no_value] != 0} {
        if {![info exists infVals($controlvar)]} {
            # control variable is specified but does not exist
            set addservice 0
            infputs "INF Processing: will not add service $serviceName: $controlvar specified but infVals($controlvar) not set"
        } elseif {$infVals($controlvar)==0} {
            # control variable is set to 0
            set addservice 0
            infputs "INF Processing: will not add service $serviceName: $controlvar specified but infVals($controlvar) = 0"
        }
    }

        if {$addservice != 0} {
        infputs "INF processing: adding service: $serviceName $servicePath $serviceExe $dependency"

        if {![catch {setupServiceInstall $serviceName \
                                [fullPathName $servicePath $serviceExe] $dependency} error]} {
            uninstLog resource "service\t$serviceName"
                        dbgputs "service installed: $serviceName"

        } else {
            # NT service registry data
            set rootKey  HKEY_LOCAL_MACHINE
            set key "SYSTEM\\CurrentControlSet\\Services\\$serviceName"
            set valueName ImagePath
            set value [fullPathName $servicePath $serviceExe] 

            # check if "Tornado Registry" exists in the service registry
            # if exists, that means the service has already been installed
            # and we only have to overwrite the wtxregds.exe path and restart
            # the service

            if {[regValueExists $rootKey $key $valueName]} {
                if {![catch {sysRegistryValueWrite \
                        $rootKey $key $valueName $value} error2]} {
                    dbgputs "New registry value written. Service Installed."
                    uninstLog resource "service\t$serviceName"
                 } else {
                    infputs "Unable to install service $serviceName: $error2"
                    uninstLog setuplog \
                        "\tFailed to install service $serviceName: $error2"
                    dbgputs "Failed to install $serviceName: $error2"
                 }
             } else {
                 infputs "Unable to install service $serviceName: $error"
                 uninstLog setuplog \
                    "\tUnable to install service $serviceName: $error"
                 dbgputs "Unable to install $serviceName: $error"
             }
        }

        if {[catch {setupServiceStart $serviceName} error]} {
            dbgputs "Unable to confirm that $serviceName was started."
            uninstLog setupLog \
                "\tUnable to confirm that $serviceName was started."
        } else {
            dbgputs "service started: $serviceName"
        }
    }
}

#############################################################################
#
# checkSolarisPatch - checks to make sure the specified patch is installed
#                     for a Solaris machine.
#
# 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.6 | 2.6: operating system is Solaris 2.6
# 5.5 | 2.5: operating system is Solaris 2.5 
# ultra:     user's machine model is an Ultra
# pci:       user's machine uses a PCI bus 
#
# An example condition list: 2.6 ultra pci  
# specifies to check for the patch only if the user's machine is an Ultra with a
# PCI bus running Solaris 2.6.
#
# 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 {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
    set user_osversion [catch {exec /bin/uname -r}]
    infputs "INF Processing: CheckPatch: osversion = $user_osversion"

    # For Solaris 2.6, specifically check for "5.6".  This means that 
    # only version 2.6 of the OS is checked for, not 2.6.x.  If in 
    # the future we need to check for 2.6.x, do a regsub check as 
    # with the 5.5 check done below.  The reason this has been done is
    # for the required XServer patch for Solaris 2.6(.0) machines that
    # will crash without the required patch, for which 2.6.1 most likely
    # will fix.  
    if {$user_osversion == "5.6"} {
        set solaris26 1
    } else {
        set solaris26 0
    }
    
    if {[regsub 5\.5 $user_osversion {} ignore]} {
        set solaris25 1
    } else {
        set solaris25 0
    }

    # model (e.g. Ultra)
    set user_machinemodel [catch {exec /bin/uname -i}] 
    if {[regsub -nocase Ultra $user_machinemodel {} ignore]} {
        set user_machinemodel ultra
    } else {
        set user_machinemodel sparcstation
    }            
            
    infputs "INF Processing: CheckPatch: model = $user_machinemodel"
            
    # check for pci
    catch { exec /bin/ls /devices | /bin/grep -i pci } pci_check
    if {[regsub -nocase pci $pci_check {} ignore]} {
        set user_pci 1
        infputs "INF Processing: CheckPatch: pci present"
    } else {
        set user_pci 0
        infputs "INF Processing: CheckPatch: pci not present"
    }  

    
    # check for patch conditions
    set check_for_patch 1
    if {$conditions == "no_value"} {
        set conditions ""
    }
    foreach condition $conditions {
        switch -- $condition {
            5.6 -
            2.6 {
                if {$solaris26 == 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.6"
                }
            } 
            5.5 -
            2.5 {
                if {$solaris25 == 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.5"
                }
            } 
            Ultra -
            ultra {
                if {$user_machinemodel != "ultra"} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch: will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch: condition user machine not Ultra"
                }
            }
            pci -
            PCI {
                if {$user_pci != 1} {
                    set check_for_patch 0
                    infputs "INF Processing: CheckPatch: will not check for patch $patchnumber:"
                    infputs "INF Processing: CheckPatch: condition user machine not pci"
                }
            }
            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