use <program> for programs

    platforms but are disallowed by default on FreeBSD, NetBSD, and 

    OpenBSD in order to match the system-wide policy on those

    platforms.  But even on systems where it is disallowed by default, a 

    special configure parameter can change this behavior for Apache.</p>

    special <program>configure</program> parameter can change this behavior

    for Apache.</p>

    <p>On the other hand, on some platforms such as Linux and Tru64 the 

    <strong>only</strong> way to handle both IPv6 and IPv4 is to use 

    mapped addresses. If you want Apache to handle IPv4 and IPv6 connections 

    with a minimum of sockets, which requires using IPv4-mapped IPv6 

    addresses, specify the <code>--enable-v4-mapped</code> <a

      href="programs/configure.html">configure</a> option.</p>

    addresses, specify the <code>--enable-v4-mapped</code> <program>

    configure</program> option.</p>

    <p><code>--enable-v4-mapped</code> is the default on all platforms but 

    FreeBSD, NetBSD, and OpenBSD, so this is probably how your Apache was 

    <p>If your platform supports it and you want Apache to handle IPv4 and 

    IPv6  connections on separate sockets (i.e., to disable IPv4-mapped 

    addresses), specify the <code>--disable-v4-mapped</code> <a

      href="programs/configure.html">configure</a> option. 

    <code>--disable-v4-mapped</code> is the default on FreeBSD, 

    NetBSD, and OpenBSD.</p>

    addresses), specify the <code>--disable-v4-mapped</code> <program>

    configure</program> option. <code>--disable-v4-mapped</code> is the

    default on FreeBSD, NetBSD, and OpenBSD.</p>

  </section>

  <section id="virtualhost">

    <p>The addition of <a href="vhosts/name-based.html">name-based

    virtual host support</a> in Apache 1.1 requires Apache to know

    the IP address(es) of the host that httpd is running on. To get

    this address it uses either the global 

    the IP address(es) of the host that <program>httpd</program>

    is running on. To get this address it uses either the global

    <directive module="core">ServerName</directive>

    (if present) or calls the C function <code>gethostname</code>

    (which should return the same as typing "hostname" at the

    <p>The Apache HTTP Server is a modular program where the

    administrator can choose the functionality to include in the

    server by selecting a set of modules. The modules can be

    statically compiled into the <code>httpd</code> binary when the

    statically compiled into the <program>httpd</program> binary when the

    server is built. Alternatively, modules can be compiled as

    Dynamic Shared Objects (DSOs) that exist separately from the

    main <code>httpd</code> binary file. DSO modules may be

    main <program>httpd</program> binary file. DSO modules may be

    compiled at the time the server is built, or they may be

    compiled and added at a later time using the Apache Extension

    Tool (<a href="programs/apxs.html">apxs</a>).</p>

    Tool (<program>apxs</program>).</p>

    <p>This document describes how to use DSO modules as well as

    the theory behind their use.</p>

    <module>core</module> which cannot be put into a DSO

    itself. Practically all other distributed Apache modules can then

    be placed into a DSO by individually enabling the DSO build for

    them via <code>configure</code>'s

    them via <program>configure</program>'s

    <code>--enable-<em>module</em>=shared</code> option as discussed

    in the <a href="install.html">install documentation</a>. After a

    module is compiled into a DSO named <code>mod_foo.so</code> you

    <p>To simplify this creation of DSO files for Apache modules

    (especially for third-party modules) a new support program

    named <a href="programs/apxs.html">apxs</a> (<em>APache

    eXtenSion</em>) is available. It can be used to build DSO based

    named <program>apxs</program> (<dfn>APache

    eXtenSion</dfn>) is available. It can be used to build DSO based

    modules <em>outside of</em> the Apache source tree. The idea is

    simple: When installing Apache the <code>configure</code>'s

    simple: When installing Apache the <program>configure</program>'s

    <code>make install</code> procedure installs the Apache C

    header files and puts the platform-dependent compiler and

    linker flags for building DSO files into the <code>apxs</code>

    program. This way the user can use <code>apxs</code> to compile

    linker flags for building DSO files into the <program>apxs</program>

    program. This way the user can use <program>apxs</program> to compile

    his Apache module sources without the Apache distribution

    source tree and without having to fiddle with the

    platform-dependent compiler and linker flags for DSO

        <code>mod_foo.so</code>: 

<example>

$ ./configure --add-module=module_type:/path/to/3rdparty/mod_foo.c --enable-foo=shared<br />

$ ./configure --add-module=<var>module_type</var>:/path/to/3rdparty/mod_foo.c \<br />

<indent>

  --enable-foo=shared<br />

</indent>

$ make install

</example>

      </li>

        Build and install a <em>third-party</em> Apache module, say

        <code>mod_foo.c</code>, into its own DSO

        <code>mod_foo.so</code> <em>outside of</em> the Apache

        source tree using <a href="programs/apxs.html">apxs</a>: 

        source tree using <program>apxs</program>: 

<example>

$ cd /path/to/3rdparty<br />

      the actual server process can be assembled at run-time via

      <directive module="mod_so">LoadModule</directive>

      <code>httpd.conf</code> configuration commands instead of

      <code>configure</code> options at build-time. For instance

      <program>configure</program> options at build-time. For instance

      this way one is able to run different server instances

      (standard & SSL version, minimalistic & powered up

      version [mod_perl, PHP3], <em>etc.</em>) with only one Apache

      <em>etc.</em></li>

      <li>Easier Apache module prototyping because with the

      DSO/<code>apxs</code> pair you can both work outside the

      DSO/<program>apxs</program> pair you can both work outside the

      Apache source tree and only need an <code>apxs -i</code>

      command followed by an <code>apachectl restart</code> to

      bring a new version of your currently developed module into

          <li>It is not possible to override or change the standard CGI

          variables using the environment manipulation directives.</li>

          <li>When <a href="suexec.html">suexec</a> is used to launch

          <li>When <program>suexec</program> is used to launch

          CGI scripts, the environment will be cleaned down to a set of

          <em>safe</em> variables before CGI scripts are launched. The

          list of <em>safe</em> variables is defined at compile-time in

      ref="module">module</glossary> sources into Dynamic Shared Objects

      (<glossary ref="dso">DSO</glossary>s) and helps install them in the

      Apache Web server.<br />

      See: <a href="programs/apxs.html">Manual Page: apxs</a>

      See: Manual Page: <program>apxs</program>

    </dd>

    <dt><a name="authentication" id="authentication">Authentication</a></dt>

    <dt><a name="dynamicsharedobject" id="dynamicsharedobject">Dynamic

        Shared Object</a> <a name="dso" id="dso">(DSO)</a></dt>

    <dd><glossary ref="module">Modules</glossary> compiled separately from the

      Apache httpd binary that can be loaded on-demand.<br />

      Apache <program>httpd</program> binary that can be loaded on-demand.<br />

      See: <a href="dso.html">Dynamic Shared Object Support</a>

    </dd>

    <dt><a name="module" id="module">Module</a></dt>

    <dd>An independent part of a program.  Much of Apache's functionality is

      contained in modules that you can choose to include or exclude.  Modules

      that are compiled into the Apache httpd binary are called <em>static

      modules</em>, while modules that are stored separately and can be

      optionally loaded at run-time are called <em>dynamic modules</em> or

      <glossary ref="dso">DSOs</glossary>.  Modules that are included by default

      are called <em>base modules</em>.  Many modules are available for Apache

      that are compiled into the Apache <program>httpd</program> binary are

      called <dfn>static modules</dfn>, while modules that are stored

      separately and can be optionally loaded at run-time are called

      <dfn>dynamic modules</dfn> or <glossary ref="dso">DSOs</glossary>.

      Modules that are included by default

      are called <dfn>base modules</dfn>. Many modules are available for Apache

      that are not distributed as part of the Apache HTTP Server <glossary

      ref="tarball">tarball</glossary>.  These are referred to as

      <em>third-party modules</em>.<br />

      <dfn>third-party modules</dfn>.<br />

      See: <a href="mod/">Module Index</a>

    </dd>