<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE faq SYSTEM "../style/faq.dtd">
<?xml-stylesheet type="text/xsl" href="../style/manual.en.xsl"?>
<!-- $LastChangedRevision$ -->

<!--
 Copyright 2003-2005 The Apache Software Foundation or its licensors, as
 applicable.

 Licensed 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.
-->

<faq metafile="support.xml.meta">
<parentdocument href="./">FAQ</parentdocument>

<title>Support - Frequently Asked Questions</title>
<description>What do I do when I have problems?</description>

<section id="support"><title>Support</title>
    <ul>
    <li><a href="#support.what2do">"Why can't I ...? Why won't ... work?" What
    to do in case of problems</a></li>

    <li><a href="#support.support">Whom do I contact for support?</a></li>
    </ul>

    <section id="support.what2do">
    <title>"Why can't I ...? Why won't ... work?" What to do in case of
    problems</title>

      <p>If you are having trouble with your Apache server software, you should
      take the following steps:</p>

      <dl>
      <dt>Check the ErrorLog!</dt>
      <dd>Apache tries to be helpful when it encounters a problem. In many
      cases, it will provide some details by writing one or more messages to the
      server error log. Sometimes this is enough for you to diagnose &amp; fix
      the problem yourself (such as file permissions or the like). The default
      location of the error log is
      <code>/usr/local/apache2/logs/error_log</code>, but see the <directive
      module="core">ErrorLog</directive> directive in your config files for the
      location on your server.</dd>

      <dt>Check the ErrorLog again!</dt>
      <dd>Nearly all problems can be solved by reading the error log.</dd>
      
      <dt>Check the <a
      href="http://httpd.apache.org/docs/&httpd.docs;/faq/">FAQ</a>!</dt>
      <dd>The latest version of the Apache Frequently-Asked Questions list can
      always be found at the main Apache web site.</dd>

      <dt>Check the Apache bug database</dt>
      <dd>Most problems that get reported to The Apache Group are recorded in
      the <a href="http://httpd.apache.org/bug_report.html">bug database</a>.
      <strong>Please</strong> check the existing reports, open
      <strong>and</strong> closed, before adding one. If you find that your
      issue has already been reported, please <em>don't</em> add a "me, too"
      report. If the original report isn't closed yet, we suggest that you
      check it periodically. You might also consider contacting the original
      submitter, because there may be an email exchange going on about the
      issue that isn't getting recorded in the database.</dd>

      <dt><a id="support.what2do.user-support"
      name="support.what2do.user-support">Ask in a user support forum</a></dt>
      <dd><p>Apache has an active community of users who are willing to share
      their knowledge. Participating in this community is usually the best and
      fastest way to get answers to your questions and problems.</p>

      <p><a href="http://httpd.apache.org/userslist.html">Users
      mailing list</a></p>

      <p><a href="irc://irc.freenode.net/#apache">#apache</a> on 
      <a href="http://freenode.net">Freenode IRC</a> is also available for 
      user support issues.</p>
      </dd>
      
      <dt>Please use the bug database for bugs!</dt>
      <dd><p>If you've gone through those steps above that are appropriate and
      have obtained no relief, then please <em>do</em> let the httpd developers
      know about the problem by <a
      href="http://httpd.apache.org/bug_report.html">logging a bug
      report</a>.</p>

      <p>If your problem involves the server crashing and generating a core
      dump, please <a href="http://httpd.apache.org/dev/debugging.html">
      include a backtrace</a> (if possible).</p>
      </dd>
      </dl>
    </section>

    <section id="support.support"><title>Whom do I contact for support?</title>
      <p>With millions of users and fewer than sixty volunteer developers,
      we cannot provide personal support for Apache. For free support, we
      suggest participating in a <a href="#support.what2do.user-support"
      >user forum</a>.</p>

      <p>Professional, commercial support for Apache is available from
      <a href="http://www.apache.org/info/support.cgi">a number of
      companies</a>.</p>
    </section>
</section>

</faq>

