#       it already appeared to be available for use. 
  # 
  # <internal> 
  proc probeForOpenPgpInstallation {} { 
    global env 
    variable openPgpInstalledDirectory 
    variable openPgpInstalledFileName 
    variable openPgpFileNameOnly 
    variable openPgpInstalledDirectory 
 
    if {[catch {openPgpMustBeInstalled}] == 0} then { 
      return true 
    } 
 
    if {![info exists openPgpFileNameOnly]} then { 
      return false 
    } 
 
    if {![info exists openPgpInstalledDirectory]} then { 
      return false 
    } 
 
    if {[isWindows]} then { 
      if {[info exists env(ProgramFiles(x86))]} then { 
        set programFiles $env(ProgramFiles\(x86\)) 
      } elseif {[info exists env(ProgramFiles)]} then { 

 
    if {![file isdirectory $directory]} then { 
      return false 
    } 
 
    set fileName [file join $directory $openPgpInstalledFileName] 
    set fileName [file join $directory $openPgpFileNameOnly] 
 
    if {[file exists $fileName] && [file isfile $fileName]} then { 
      return [addToPath $directory] 
    } 
 

  #       errors are raised if any problems are found.  The return value is 
  #       undefined. 
  # 
  # <public> 
  proc openPgpMustBeInstalled {} { 
    variable openPgpFileNameOnly 
    variable openPgpFileNamesOnly 
    variable openPgpInstalledCommand 
    variable openPgpInstalledPattern 
 
    set message { 
      Cannot use OpenPGP: it does not appear to be installed. 
 
      GNU Privacy Guard (GPG) may be downloaded from "https://www.gnupg.org/" 
      and then installed.  Signed binaries for Windows may be available from 
      "https://www.gpg4win.org/". 
 
      Alternatively, it may be possible to install GNU Privacy Guard (GPG) via 
      the package management subsystem included with your operating system. 
    } 
 
    set found false 
 
    foreach fileName $openPgpFileNamesOnly { 
    if {[isEagle]} then { 
      if {[catch { 
        eval exec -success Success $openPgpInstalledCommand 
      } result]} then { 
      if {[isEagle]} then { 
        if {[catch { 
          eval exec -success Success [subst $openPgpInstalledCommand] 
        } result] == 0} then { 
        error $message 
      } 
    } else { 
      if {[catch { 
        eval exec $openPgpInstalledCommand 
      } result]} then { 
        error $message 
      } 
          set found true; break 
        } 
      } else { 
        if {[catch { 
          eval exec [subst $openPgpInstalledCommand] 
        } result] == 0} then { 
          set found true; break 
        } 
      } 
    } 
 
    if {$found} then { 
      # 
      # NOTE: Was this procedure already run -AND- did it actually find a 
      #       viable OpenPGP file name? 
      # 
      if {[info exists openPgpFileNameOnly]} then { 
        # 
        # NOTE: If the OpenPGP file name that we found before (?) does not 
        #       match what we already have, issue a log message. 
        # 
        if {$fileName ne $openPgpFileNameOnly} then { 
          pkgLog [appendArgs \ 
              "the OpenPGP file name is being changed from \"" \ 
              $openPgpFileNameOnly "\" to \"" $fileName \"] 
 
          set openPgpFileNameOnly $fileName 
        } 
      } else { 
        # 
        # NOTE: Configure the OpenPGP file name to the one that was just 
        #       found. 
        # 
        set openPgpFileNameOnly $fileName 
      } 
    } else { 
      # 
      # NOTE: If no viable OpenPGP file name was found, raise the error 
      #       message. 
      # 
      error $message 
    } 
 
    if {![info exists result] || \ 
        ![regexp -- $openPgpInstalledPattern $result]} then { 
      error "cannot use OpenPGP: unknown or unsupported version" 

  #       the fully qualified path and file name of the OpenPGP signature 
  #       file to verify. 
  # 
  # <public> 
  proc verifyOpenPgpSignature { fileName } { 
    variable openPgpFileNameOnly 
    variable openPgpVerifyCommand 
 
    if {![info exists openPgpFileNameOnly]} then { 
      return false 
    } 
 
    if {[isEagle]} then { 
      set fileName [formatExecArgument $fileName] 
 
      if {[catch { 

  #       qualified path and file name of the file to be signed. 
  # 
  # <public> 
  proc createOpenPgpSignature { fileName } { 
    global env 
    variable openPgpFileNameOnly 
    variable openPgpSignCommand 
 
    if {![info exists openPgpFileNameOnly]} then { 
      return false 
    } 
 
    if {[isEagle]} then { 
      set fileName [formatExecArgument $fileName] 
 
      if {[catch { 

  #       "pkgr_setup.eagle" tool script and may go away in later versions 
  #       of this package. 
  # 
  # <internal> 
  proc importOpenPgpKeyFile { fileName varName } { 
    variable openPgpFileNameOnly 
    variable openPgpImportCommand 
    variable openPgpImportPattern 
 
    if {![info exists openPgpFileNameOnly]} then { 
      return false 
    } 
 
    if {[string length $varName] > 0} then { 
      upvar 1 $varName result 
    } 
 

        uplevel 1 [list source $fileName] 
      } 
    } 
  } 
 
  # 
  # NOTE: This procedure sets up the default values for all configuration 
  #       parameters used to interact with the OpenPGP implementation. 
  #       There are no arguments. 
  # 
  proc setupRepositoryOpenPgpVars {} { 
    # 
    # NOTE: This is the name of the sub-directory containing the OpenPGP 
    #       implementation.  It is platform-specific.  On Windows, this 
    #       sub-directory is relative to the "Program Files" directory. 
    # 
    variable openPgpInstalledDirectory; # DEFAULT: [file join GNU GnuPG] 
 
    if {![info exists openPgpInstalledDirectory]} then { 
      if {[isWindows]} then { 
        set openPgpInstalledDirectory [file join GNU GnuPG] 
      } else { 
        set openPgpInstalledDirectory [file join / usr bin] 
      } 
    } 
 
    # 
    # NOTE: These are the candidate names of the executable file used to 
    #       invoke the OpenPGP implementation, possibly without a file 
    #       extension. 
    # 
    variable openPgpFileNamesOnly; # DEFAULT: [list gpg2 gpg] 
 
    if {![info exists openPgpFileNamesOnly]} then { 
      if {[isWindows]} then { 
        set openPgpFileNamesOnly [list gpg2.exe gpg.exe] 
      } else { 
        set openPgpFileNamesOnly [list gpg2 gpg] 
      } 
    } 
 
    # 
    # NOTE: This is the name of the executable file used to invoke the 
    #       OpenPGP implementation, possibly without a file extension. 
    # 
    variable openPgpFileNameOnly; # DEFAULT: <unset> 
 
    # 
    # NOTE: The command to use when attempting to import an OpenPGP key 
    #       file.  This must be configured according to the implementation 
    #       of OpenPGP in use. 
    # 
    variable openPgpImportCommand; # DEFAULT: gpg2 --import 
 
    if {![info exists openPgpImportCommand]} then { 
      set openPgpImportCommand \ 
          {{${openPgpFileNameOnly}} --import {${fileName}}} 
    } 
 
    # 
    # NOTE: The regular expression pattern used when attempting to verify 
    #       that OpenPGP successfully imported one or more keys.  This must 
    #       be configured according to the implementation of OpenPGP in use. 
    # 
    variable openPgpImportPattern; # DEFAULT: ^gpg: Total number processed: 1$ 
 
    if {![info exists openPgpImportPattern]} then { 
      set openPgpImportPattern {^gpg: Total number processed: 1$} 
    } 
 
    # 
    # NOTE: The command to use when attempting to verify that OpenPGP is 
    #       installed locally.  This must be configured according to the 
    #       implementation of OpenPGP in use. 
    # 
    variable openPgpInstalledCommand; # DEFAULT: gpg2 --version 
 
    if {![info exists openPgpInstalledCommand]} then { 
      set openPgpInstalledCommand {{${fileName}} --version} 
    } 
 
    # 
    # NOTE: The regular expression pattern used when attempting to verify 
    #       that OpenPGP is installed locally.  This must be configured 
    #       according to the implementation of OpenPGP in use. 
    # 
    variable openPgpInstalledPattern; # DEFAULT: ^gpg \(GnuPG\) 2\.[012]\. 
 
    if {![info exists openPgpInstalledPattern]} then { 
      set openPgpInstalledPattern {^gpg \(GnuPG\) 2\.[012]\.} 
    } 
 
    # 
    # NOTE: The command to use when verifying OpenPGP signatures for the 
    #       downloaded package scripts.  This must be configured according 
    #       to the implementation of OpenPGP in use. 
    # 
    variable openPgpVerifyCommand; # DEFAULT: gpg2 --verify {${fileName}} 
 
    if {![info exists openPgpVerifyCommand]} then { 
      set openPgpVerifyCommand \ 
          {{${openPgpFileNameOnly}} --verify {${fileName}}} 
    } 
 
    # 
    # NOTE: The command to use when creating OpenPGP signatures for the 
    #       downloaded package scripts.  This must be configured according 
    #       to the implementation of OpenPGP in use. 
    # 
    variable openPgpSignCommand; # DEFAULT: gpg2 --detach-sign ... 
 
    if {![info exists openPgpSignCommand]} then { 
      set openPgpSignCommand "" 
 
      append openPgpSignCommand \ 
          {{${openPgpFileNameOnly}} --detach-sign --armor} 
 
      append openPgpSignCommand \ 
          { --passphrase-file [formatExecArgument [getOpenPgpPassphraseFile]]} 
 
      append openPgpSignCommand { --batch --yes {${fileName}}} 
    } 
  } 
 
  # 
  # NOTE: This procedure sets up the default values for all configuration 
  #       parameters used by the package repository client.  There are no 
  #       arguments. 
  # 

      } else { 
        set autoRequireGaruda false 
      } 
    } 
 
    # 
    # NOTE: This is the name of the sub-directory containing the OpenPGP 
    #       implementation.  It is platform-specific.  On Windows, this 
    #       sub-directory is relative to the "Program Files" directory. 
    # 
    variable openPgpInstalledDirectory; # DEFAULT: [file join GNU GnuPG] 
 
    if {![info exists openPgpInstalledDirectory]} then { 
      if {[isWindows]} then { 
        set openPgpInstalledDirectory [file join GNU GnuPG] 
      } else { 
        set openPgpInstalledDirectory [file join / usr bin] 
      } 
    } 
 
    # 
    # NOTE: This is the name of the executable file used to invoke the 
    #       OpenPGP implementation, without an extension. 
    # 
    variable openPgpInstalledFileName; # DEFAULT: gpg2 
 
    if {![info exists openPgpInstalledFileName]} then { 
      if {[isWindows]} then { 
        set openPgpInstalledFileName gpg2.exe 
      } else { 
        set openPgpInstalledFileName gpg2 
      } 
    } 
 
    # 
    # NOTE: The command to use when attempting to import an OpenPGP key 
    #       file.  This must be configured according to the implementation 
    #       of OpenPGP in use. 
    # 
    variable openPgpImportCommand; # DEFAULT: gpg2 --import 
 
    if {![info exists openPgpImportCommand]} then { 
      set openPgpImportCommand {gpg2 --import {${fileName}}} 
    } 
 
    # 
    # NOTE: The regular expression pattern used when attempting to verify 
    #       that OpenPGP successfully imported one or more keys.  This must 
    #       be configured according to the implementation of OpenPGP in use. 
    # 
    variable openPgpImportPattern; # DEFAULT: ^gpg: Total number processed: 1$ 
 
    if {![info exists openPgpImportPattern]} then { 
      set openPgpImportPattern {^gpg: Total number processed: 1$} 
    } 
 
    # 
    # NOTE: The command to use when attempting to verify that OpenPGP is 
    #       installed locally.  This must be configured according to the 
    #       implementation of OpenPGP in use. 
    # 
    variable openPgpInstalledCommand; # DEFAULT: gpg2 --version 
 
    if {![info exists openPgpInstalledCommand]} then { 
      set openPgpInstalledCommand {gpg2 --version} 
    } 
 
    # 
    # NOTE: The regular expression pattern used when attempting to verify 
    #       that OpenPGP is installed locally.  This must be configured 
    #       according to the implementation of OpenPGP in use. 
    # 
    variable openPgpInstalledPattern; # DEFAULT: ^gpg \(GnuPG\) 2\.[01]\. 
 
    if {![info exists openPgpInstalledPattern]} then { 
      set openPgpInstalledPattern {^gpg \(GnuPG\) 2\.[01]\.} 
    } 
 
    # 
    # NOTE: The command to use when verifying OpenPGP signatures for the 
    #       downloaded package scripts.  This must be configured according 
    #       to the implementation of OpenPGP in use. 
    # 
    variable openPgpVerifyCommand; # DEFAULT: gpg2 --verify {${fileName}} 
 
    if {![info exists openPgpVerifyCommand]} then { 
      set openPgpVerifyCommand {gpg2 --verify {${fileName}}} 
    } 
 
    # 
    # NOTE: The command to use when creating OpenPGP signatures for the 
    #       downloaded package scripts.  This must be configured according 
    #       to the implementation of OpenPGP in use. 
    # 
    variable openPgpSignCommand; # DEFAULT: gpg2 --detach-sign ... 
 
    if {![info exists openPgpSignCommand]} then { 
      set openPgpSignCommand "" 
 
      append openPgpSignCommand {gpg2 --detach-sign --armor} 
 
      append openPgpSignCommand \ 
          { --passphrase-file [formatExecArgument [getOpenPgpPassphraseFile]]} 
 
      append openPgpSignCommand { --batch --yes {${fileName}}} 
    } 
 
    # 
    # NOTE: The command to use when creating Harpy signatures for downloaded 
    #       package scripts. 
    # 
    variable harpySignCommand; # DEFAULT: {${shellFileName}} -file ... 

  #       used by this script. 
  # 
  setupRepositoryServerVars false 
  setupRepositoryUriVars false 
 
  # 
  # NOTE: Setup the OpenPGP implementation related variables, in this 
  #       namespace, that are used by this script. 
  # 
  setupRepositoryOpenPgpVars 
 
  # 
  # NOTE: Setup the variables, within this namespace, used by this script. 
  # 
  setupPackageUnknownVars