<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Note: To understand how this template is used, see the documentation
  at http://forrest.apache.org/howto/howto-asf-mirror.html
-->
<html>
  <head>
    <title>Obtain the Apache Forrest distribution</title>
  </head>
  <body>
    <h1><a name="how" />How to download</h1>
    <p class="note">
      Please realise that Forrest is still pre-1.0 release version. It is
      certainly usable for those who are prepared to move with it. See more
      notes about <a href="index.html#status">status</a>.
    </p>
    <p>
      Use the links below to download a distribution of Apache Forrest from one
      of our mirrors. It is good practice to <a href="[location]#verify">verify
      the integrity</a> of the distribution files.
      Apache Forrest releases are available under the
      <a href="http://www.apache.org/licenses/">Apache License, Version 2.0</a>
      - see the README.txt and LICENSE.txt and NOTICE.txt files contained in each release artifact.
    </p>
<!--
    <p>
      Apache Forrest is distributed as a <code>zip</code> archive (for Windows)
      and as a <code>tar.gz</code> archive (for UNIX). The contents are the
      same, the only difference is the line-endings of all text files.
    </p>
-->
    <p>
      The "sources" package contains all of the source code, documentation, and
      resources, together with the pre-built ready-to-run forrest binary. The "dependencies" package
      includes pre-packaged copies of relevant portions of Apache Cocoon
      and Apache Ant, and other supporting products.
    </p>
    <p>
      First unpack the "sources" to your chosen installation location, then unpack the "dependencies" over the top of that, which will install each to the appropriate location.
    </p>
    <p>
      After unpacking the distribution, follow the README.txt to see the
      Requirements (just Java 1.5+), Installation Instructions and
      Documentation, Licensing and legal issues and credits.
    </p>
    <h1><a name="closest" />Current official release (closest mirror site selected automatically)</h1>
    <p>
      You are currently using
      <b>[preferred]</b><br/>
      If you encounter a problem with this mirror, then please select another.
      If all mirrors are failing, there are backup mirrors at the end of the
      list. See <a href="http://www.apache.org/mirrors/">status</a> of mirrors.
    </p>
    <form action="[location]" method="get" id="SelectMirror">
Other mirrors: <select name="Preferred">
<!--[if-any http] [for http]-->
        <option value="[http]">[http]</option>
<!--[end] [end]-->
<!--[if-any ftp] [for ftp]-->
        <option value="[ftp]">[ftp]</option>
<!--[end] [end]-->
<!--[if-any backup] [for backup]-->
        <option value="[backup]">[backup] (backup)</option>
<!--[end] [end]-->
      </select>
      <input type="submit" value="Change" />
    </form>
    <p>
      The current release is Apache Forrest 0.9 (see the
      <a href="[preferred]/forrest/RELEASE-NOTES-0.9.txt">release notes</a>
      and the full list of <a href="site:v0.90//changes/v09">changes</a>).
    </p>
    <ul>
      <li>
<a href="[preferred]/forrest/apache-forrest-0.9-sources.tar.gz">apache-forrest-0.9-sources.tar.gz</a>
(<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-sources.tar.gz.asc">PGP</a> |
<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-sources.tar.gz.md5">MD5</a> |
<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-sources.tar.gz.sha1">SHA1</a>)</li>
      <li>
<a href="[preferred]/forrest/apache-forrest-0.9-dependencies.tar.gz">apache-forrest-0.9-dependencies.tar.gz</a>
(<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-dependencies.tar.gz.asc">PGP</a> |
<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-dependencies.tar.gz.md5">MD5</a> |
<a href="http://www.apache.org/dist/forrest/apache-forrest-0.9-dependencies.tar.gz.sha1">SHA1</a>)</li>
    </ul>
    <p>
      Note: Both packages are needed.
      See notes above regarding <a href="#how">how to download</a>.
    </p>
    <h1><a name="archive" />Archive of old releases</h1>
    <p>
      Older releases are available in the
      <a
href="http://archive.apache.org/dist/forrest/">archive</a>. Those
      releases are only provided as historical artefacts. We strongly recommend
      to not use those releases, but upgrade to the most recent release.
    </p>
    <h1><a name="verify" />Verify releases</h1>
    <p>
      It is essential that you verify the integrity of the downloaded files
      using the MD5 and PGP signatures. MD5 verification ensures the file was
      not corrupted or tampered with. PGP verification ensures that the file
      came from a certain person.
    </p>
    <h2><a name="pgp" />PGP Signature</h2>
    <p>
      The <a href="http://en.wikipedia.org/wiki/Pretty_Good_Privacy">PGP</a>
      signatures can be verified using tools such as
      <a href="http://www.gnupg.org/">GPG</a>. First download the Apache Forrest
      <a href="http://www.apache.org/dist/forrest/KEYS">KEYS</a> as well as the
      <code>*.asc</code> signature file for the particular distribution. It is
      important that you get these files from the ultimate trusted source - the
      main ASF distribution site, rather than from a mirror. Then verify the
      signatures using ...
    </p>
    <pre>
% pgpk -a KEYS
% pgpv apache-forrest-X.Y-sources.tar.gz.asc

<em>or</em>

% pgp -ka KEYS
% pgp apache-forrest-X.Y-sources.tar.gz.asc

<em>or</em>

% gpg --import KEYS
% gpg --verify apache-forrest-X.Y-sources.tar.gz.asc
</pre>

    <p>
    The files <code>apache-forrest-0.9.*</code>
    are signed by David Crossley <code>3248A46E</code> (and <code>23CB7A2A</code>)
    </p>

    <h2><a name="md5" />MD5 Checksum</h2>
    <p>
      To verify the MD5 checksum on the files, you need to use a program called
      <code>md5</code> or <code>md5sum</code>, which is included in many unix
      distributions. It is also available as part of
      <a href="http://www.gnu.org/software/textutils/textutils.html">GNU
      Textutils</a>. Windows users can get binary md5 programs from
      <a
href="http://www.fourmilab.ch/md5/">here</a>,
      <a
href="http://www.pc-tools.net/win32/freeware/console/">here</a>, or
      <a href="http://www.slavasoft.com/fsum/">here</a> or an openssl client
      from
      <a href="http://www.slproweb.com/products/Win32OpenSSL.html">here</a>.
    </p>
    <pre>
% md5sum apache-forrest-X.Y-sources.tar.gz
... output should match the string in apache-forrest-X.Y-sources.tar.gz.md5
</pre>
    <p>
      We strongly recommend you verify your downloads with both PGP and MD5.
    </p>
  </body>
</html>
