if {![info exists downloadUri]} then {
      set downloadUri {${baseUri}?download&ci=trunk&filename=${fileName}}
    }

    #
    # NOTE: The root directory where any persistent packages will be saved.
    #
    variable persistentDirectory; # DEFAULT: [getPersistentRootDirectory]
    variable persistentRootDirectory; # DEFAULT: [getPersistentRootDirectory]

    if {![info exists persistentDirectory]} then {
      set persistentDirectory [getPersistentRootDirectory]
    if {![info exists persistentRootDirectory]} then {
      set persistentRootDirectory [getPersistentRootDirectory]
    }

    #
    # NOTE: The root directory where any temporary packages will be written.
    #
    variable temporaryRootDirectory; # DEFAULT: [getFileTempDirectory PKGD_TEMP]

    if {![info exists temporaryRootDirectory]} then {
      set temporaryRootDirectory \
          [::PackageRepository::getFileTempDirectory PKGD_TEMP]
    }
  }

  #
  # NOTE: This procedure returns the root directory where any packages that
  #       are downloaded should be saved to permanent storage for subsequent
  #       use.  There are no arguments.

  #       the file to check, which may or may not exist.
  #
  proc isPgpSignatureFileName { fileName } {
    if {[string length $fileName] == 0} then {
      return false
    }

    set extension [file extension]
    set extension [file extension $fileName]

    if {$extension eq ".asc"} then {
      if {[file exists $fileName]} then {
        return [::PackageRepository::isPgpSignature [readFile $fileName]]
      } else {
        return true
      }

  #       of the file to check, which may or may not exist.
  #
  proc isHarpyCertificateFileName { fileName } {
    if {[string length $fileName] == 0} then {
      return false
    }

    set extension [file extension]
    set extension [file extension $fileName]

    if {$extension eq ".harpy"} then {
      if {[file exists $fileName]} then {
        return [::PackageRepository::isHarpyCertificate [readFile $fileName]]
      } else {
        return true
      }

  #
  proc downloadOneFile { language version fileName localFileName usePgp } {
    variable baseUri
    variable downloadUri
    variable quiet

    #
    # NOTE: First, build the full relative file name to download from the
    #       remote package repository.
    # NOTE: First, build the full relative file name to download from
    #       the remote package repository.
    #
    set fileName [file join $language $version $fileName]
    set uri [subst $downloadUri]

    #
    # NOTE: Then, in one step, download the file from the package file
    #       server and write it to the specified local file.
    #
    if {[isEagle]} then {
      writeFile $localFileName [interp readorgetscriptfile -- "" $uri]
    } else {
      writeFile $localFileName \
          [::PackageRepository::getFileViaHttp $uri 10 stdout $quiet]
    }

    #
    #
    # NOTE: Is use of OpenPGP for signature verification enabled?  Also,
    #       did we just download an OpenPGP signature file?
    #
    if {$usePgp && [isPgpSignatureFileName $localFileName]} then {
      #
      #
      # NOTE: Attempt to verify the OpenPGP signature.  If this fails,
      #       an error is raised.
      #
      if {![::PackageRepository::verifyPgpSignature $localFileName]} then {
        error [appendArgs \
            "bad PGP signature \"" $localFileName \"]
      }
    }
  }

  #       useAutoPath argument should be non-zero to modify the auto-path
  #       to include the temporary or persistent directories containing
  #       the downloaded files.
  #
  # <public>
  proc downloadFiles {
          language version fileNames persistent usePgp useAutoPath } {
    global env
    variable baseUri
    variable clientDirectory
    variable downloadUri
    variable persistentDirectory
    variable quiet
    variable persistentRootDirectory
    variable temporaryRootDirectory

    set client false

    if {[string length $language] == 0 || $language eq "eagle"} then {
      if {$version ne "1.0"} then {
        error "unsupported Eagle version"
      }

      }

      set client true
    } else {
      error "unsupported language"
    }

    if {[info exists env(PKGD_TEMP)]} then {
      set temporaryRootDirectory $env(PKGD_TEMP)
    } elseif {[info exists env(TEMP)]} then {
      set temporaryRootDirectory $env(TEMP)
    } elseif {[info exists env(TMP)]} then {
      set temporaryRootDirectory $env(TMP)
    } else {
      error "please set PKGD_TEMP (via environment) to temporary directory"
    }

    set temporaryDirectory [file join $temporaryRootDirectory \
        [appendArgs pkgd_ [string trim [pid] -] _ [string trim \
        [clock seconds] -]]]

    if {$persistent} then {
      if {$client} then {
        set downloadRootDirectory $clientDirectory
      } else {
        set downloadRootDirectory $persistentDirectory
    if {$client} then {
      set persistentDirectory $clientDirectory
    } else {
      set persistentDirectory $persistentRootDirectory
      }
    } else {
      set downloadRootDirectory $temporaryDirectory
    }

    set downloadedFileNames [list]

    foreach fileName $fileNames {
      if {[string length $fileName] == 0 || \
          [file pathtype $fileName] ne "relative"} then {
        error [appendArgs \
            "bad file name \"" $fileName "\", not relative"]
      }

      set directoryParts [file split [file dirname $fileName]]

      if {[llength $directoryParts] == 0} then {
        error [appendArgs \
            "bad file name \"" $fileName "\", no directory parts"]
      }

      set downloadDirectory(temporary) [file normalize [eval \
      set directory(temporary) [file normalize [eval \
          file join [list $temporaryDirectory] $directoryParts]]

      set downloadDirectory(persistent) [file normalize [eval \
          file join [list $downloadRootDirectory] $directoryParts]]
      set directory(persistent) [file normalize [eval \
          file join [list $persistentDirectory] $directoryParts]]

      set fileNameOnly [file tail $fileName]

      set downloadFileName [file normalize [file join \
          $downloadDirectory(temporary) [file tail $fileName]]]
          $directory(temporary) $fileNameOnly]]

      if {[file exists $downloadFileName]} then {
        error [appendArgs \
            "temporary file name \"" $downloadFileName \
            "\" already exists"]
      }

      file mkdir [file dirname $downloadFileName]

      downloadOneFile $language $version $fileName $downloadFileName $usePgp

      lappend downloadedFileNames $downloadFileName
      lappend downloadedFileNames [list \
          $fileNameOnly $directory(temporary) $directory(persistent)]

      if {$usePgp && ![isPgpSignatureFileName $downloadFileName] && \
      if {$usePgp && ![isPgpSignatureFileName $downloadFileName]} then {
          ![isHarpyCertificateFileName $downloadFileName]} then {
        downloadOneFile $language $version [appendArgs $fileName .asc] \
            [appendArgs $downloadFileName .asc] $usePgp

        lappend downloadedFileNames [appendArgs $downloadFileName .asc]
        lappend downloadedFileNames [list \
            [appendArgs $fileNameOnly .asc] $directory(temporary) \
            $directory(persistent)]
      }
    }

    set downloadDirectories [list]

    foreach downloadedFileName $downloadedFileNames {
      set directory(temporary) [lindex $downloadedFileName 1]

      if {$persistent} then {

        set fileNameOnly [lindex $downloadedFileName 0]
        set directory(persistent) [lindex $downloadedFileName 2]

        file mkdir $directory(persistent)

        file copy -- \
            [file join $directory(temporary) $fileNameOnly] \
            [file join $directory(persistent) $fileNameOnly]

        lappend downloadDirectories $directory(persistent)
      } else {
        lappend downloadDirectories [file dirname $downloadedFileName]
        lappend downloadDirectories $directory(temporary)
      }
    }

    set downloadDirectories [lsort -unique $downloadDirectories]

    if {$useAutoPath} then {
      foreach downloadDirectory $downloadDirectories {