use <program>

    directive, the server

    listens to the given port on all interfaces. If an IP address

    is given as well as a port, the server will listen on the given

    port and interface. Multiple Listen directives may be used to

    port and interface. Multiple <directive module="mpm_common"

    >Listen</directive> directives may be used to

    specify a number of addresses and ports to listen on. The

    server will respond to requests from any of the listed

    addresses and ports.</p>

    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>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> configure option and use 

    generic Listen directives like the following:</p>

    specify the <code>--enable-v4-mapped</code> <program>configure</program>

    option and use generic <directive module="mpm_common">Listen</directive>

    directives like the following:</p>

    <example>

      Listen 80

    <p>If you want Apache to handle IPv4 connections only, regardless of 

    what your platform and APR will support, specify an IPv4 address on all 

    Listen directives, as in the following examples:</p>

    <directive module="mpm_common">Listen</directive> directives, as in the

    following examples:</p>

    <example>

      Listen 0.0.0.0:80<br />

    <p>If 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> configure option and use specific Listen 

    directives like the following:</p>

    <code>--disable-v4-mapped</code> <program>configure</program> option and

    use specific Listen directives like the following:</p>

    <example>

      Listen [::]:80<br />

  <section id="virtualhost">

    <title>How This Works With Virtual Hosts</title>

    <p>Listen does not implement Virtual Hosts. It only tells the

    main server what addresses and ports to listen to. If no

    <directive module="core" type="section">VirtualHost</directive>

    directives are used, the server will behave

    <p><directive module="mpm_common">Listen</directive> does not implement

    Virtual Hosts. It only tells the main server what addresses and ports to

    listen to. If no <directive module="core" type="section"

    >VirtualHost</directive> directives are used, the server will behave

    the same for all accepted requests. However,

    <directive module="core" type="section">VirtualHost</directive>

    can be used to specify a different behavior

    <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

        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

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