<!-- $LastChangedRevision$ -->
<!--
- Copyright 2002-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
+ 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
<summary>
<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 <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 <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 (<program>apxs</program>).</p>
+ server by selecting a set of modules.
+ Modules will be compiled as Dynamic Shared Objects (DSOs)
+ that exist separately from the 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 (<program>apxs</program>).</p>
+ <p>Alternatively, the modules can be statically compiled into
+ the <program>httpd</program> binary when the server is built.</p>
<p>This document describes how to use DSO modules as well as
the theory behind their use.</p>
</directivelist>
</related>
- <p>The DSO support for loading individual Apache modules is based
+ <p>The DSO support for loading individual Apache httpd modules is based
on a module named <module>mod_so</module> which must be statically
- compiled into the Apache core. It is the only module besides
+ compiled into the Apache httpd core. It is the only module besides
<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 <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
- can use <module>mod_so</module>'s <directive
- module="mod_so">LoadModule</directive> command in your
+ itself. Practically all other distributed Apache httpd modules will then
+ be placed into a DSO. After a module is compiled into a DSO named
+ <code>mod_foo.so</code> you can use <module>mod_so</module>'s <directive
+ module="mod_so">LoadModule</directive> directive in your
<code>httpd.conf</code> file to load this module at server startup
or restart.</p>
+ <p>The DSO builds for individual modules can be disabled via
+ <program>configure</program>'s <code>--enable-mods-static</code>
+ option as discussed in the <a href="install.html">install
+ documentation</a>.</p>
- <p>To simplify this creation of DSO files for Apache modules
- (especially for third-party modules) a new support program
+ <p>To simplify this creation of DSO files for Apache httpd modules
+ (especially for third-party modules) a support program
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 <program>configure</program>'s
- <code>make install</code> procedure installs the Apache C
+ modules <em>outside of</em> the Apache httpd source tree. The idea is
+ simple: When installing Apache
HTTP Server the <program>configure</program>'s
+ <code>make install</code> procedure installs the Apache httpd C
header files and puts the platform-dependent compiler and
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
+ his Apache httpd module sources without the Apache httpd distribution
source tree and without having to fiddle with the
platform-dependent compiler and linker flags for DSO
support.</p>
<section id="usage"><title>Usage Summary</title>
- <p>To give you an overview of the DSO features of Apache 2.0,
+ <p>To give you an overview of the DSO features of Apache HTTP Server 2.x,
here is a short and concise summary:</p>
<ol>
<li>
- Build and install a <em>distributed</em> Apache module, say
+ <p>Build and install a <em>distributed</em> Apache httpd module, say
<code>mod_foo.c</code>, into its own DSO
- <code>mod_foo.so</code>:
+ <code>mod_foo.so</code>:</p>
<example>
-$ ./configure --prefix=/path/to/install --enable-foo=shared<br />
+$ ./configure --prefix=/path/to/install --enable-foo<br />
$ make install
</example>
</li>
<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>:
+ <p>Configure Apache HTTP Server with all modules enabled. Only a basic
+ set will be loaded during server startup. You can change the set of loaded
+ modules by activating or deactivating the <directive
+ module="mod_so">LoadModule</directive> directives in
+ <code>httpd.conf</code>.</p>
<example>
-$ ./configure --add-module=<var>module_type</var>:/path/to/3rdparty/mod_foo.c \<br />
-<indent>
- --enable-foo=shared<br />
-</indent>
+$ ./configure --enable-mods-shared=all<br />
$ make install
</example>
</li>
<li>
- Configure Apache for <em>later installation</em> of shared
- modules:
+ <p>Some modules are only useful for developers and will not be build.
+ when using the module set <em>all</em>. To build all available modules
+ including developer modules use <em>reallyall</em>. In addition the
+ <directive module="mod_so">LoadModule</directive> directives for all
+ built modules can be activated via the configure option
+ <code>--enable-load-all-modules</code>.</p>
<example>
-$ ./configure --enable-so<br />
+$ ./configure --enable-mods-shared=reallyall --enable-load-all-modules<br />
$ make install
</example>
</li>
<li>
- Build and install a <em>third-party</em> Apache module, say
+ Build and install a <em>third-party</em> Apache httpd 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 <program>apxs</program>:
+ <code>mod_foo.so</code> <em>outside of</em> the Apache httpd
+ source tree using <program>apxs</program>:
<example>
$ cd /path/to/3rdparty<br />
-$ apxs -c mod_foo.c<br />
-$ apxs -i -a -n foo mod_foo.la
+$ apxs -cia mod_foo.c
</example>
</li>
</ol>
<p>In all cases, once the shared module is compiled, you must
use a <directive module="mod_so">LoadModule</directive>
- directive in <code>httpd.conf</code> to tell Apache to activate
+ directive in <code>httpd.conf</code> to tell Apache httpd to activate
the module.</p>
+
+ <p>See the <a href="programs/apxs.html">apxs documentation</a> for more details.</p>
</section>
<section id="background"><title>Background</title>
- <p>On modern Unix derivatives there exists a nifty mechanism
- usually called dynamic linking/loading of <em>Dynamic Shared
+ <p>On modern Unix derivatives there exists a mechanism
+ called dynamic linking/loading of <em>Dynamic Shared
Objects</em> (DSO) which provides a way to build a piece of
program code in a special format for loading it at run-time
into the address space of an executable program.</p>
- <p>This loading can usually be done in two ways: Automatically
+ <p>This loading can usually be done in two ways: automatically
by a system program called <code>ld.so</code> when an
executable program is started or manually from within the
executing program via a programmatic system interface to the
<p>The shared library approach is the typical one, because it
is what the DSO mechanism was designed for, hence it is used
for nearly all types of libraries the operating system
- provides. On the other hand using shared objects for extending
- a program is not used by a lot of programs.</p>
-
- <p>As of 1998 there are only a few software packages available
- which use the DSO mechanism to actually extend their
- functionality at run-time: Perl 5 (via its XS mechanism and the
- DynaLoader module), Netscape Server, <em>etc.</em> Starting
- with version 1.3, Apache joined the crew, because Apache
- already uses a module concept to extend its functionality and
- internally uses a dispatch-list-based approach to link external
- modules into the Apache core functionality. So, Apache is
- really predestined for using DSO to load its modules at
- run-time.</p>
+ provides.</p>
+
</section>
<section id="advantages"><title>Advantages and Disadvantages</title>
<ul>
<li>The server package is more flexible at run-time because
- the actual server process can be assembled at run-time via
+ the server process can be assembled at run-time via
<directive module="mod_so">LoadModule</directive>
- <code>httpd.conf</code> configuration commands instead of
- <program>configure</program> options at build-time. For instance
+ <code>httpd.conf</code> configuration directives instead of
+ <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
+ (standard & SSL version, minimalistic & dynamic
+ version [mod_perl, mod_php], <em>etc.</em>) with only one Apache httpd
installation.</li>
<li>The server package can be easily extended with
- third-party modules even after installation. This is at least
- a great benefit for vendor package maintainers who can create
- a Apache core package and additional packages containing
- extensions like PHP3, mod_perl, mod_fastcgi,
- <em>etc.</em></li>
+ third-party modules even after installation. This is
+ a great benefit for vendor package maintainers, who can create
+ an Apache httpd core package and additional packages containing
+ extensions like PHP, mod_perl, mod_security, <em>etc.</em></li>
- <li>Easier Apache module prototyping because with the
+ <li>Easier Apache httpd module prototyping, because with the
DSO/<program>apxs</program> pair you can both work outside the
- Apache source tree and only need an <code>apxs -i</code>
+ Apache httpd 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
- the running Apache server.</li>
+ the running Apache HTTP Server.</li>
</ul>
<p>DSO has the following disadvantages:</p>
<ul>
- <li>The DSO mechanism cannot be used on every platform
- because not all operating systems support dynamic loading of
- code into the address space of a program.</li>
-
<li>The server is approximately 20% slower at startup time
because of the symbol resolving overhead the Unix loader now
has to do.</li>
<li>The server is approximately 5% slower at execution time
- under some platforms because position independent code (PIC)
+ under some platforms, because position independent code (PIC)
sometimes needs complicated assembler tricks for relative
- addressing which are not necessarily as fast as absolute
+ addressing, which are not necessarily as fast as absolute
addressing.</li>
<li>Because DSO modules cannot be linked against other
this functionality while ELF-based platforms do) you cannot
use the DSO mechanism for all types of modules. Or in other
words, modules compiled as DSO files are restricted to only
- use symbols from the Apache core, from the C library
+ use symbols from the Apache httpd core, from the C library
(<code>libc</code>) and all other dynamic or static libraries
- used by the Apache core, or from static library archives
+ used by the Apache httpd core, or from static library archives
(<code>libfoo.a</code>) containing position independent code.
The only chances to use other code is to either make sure the
- Apache core itself already contains a reference to it or
+ httpd core itself already contains a reference to it or
loading the code yourself via <code>dlopen()</code>.</li>
</ul>
projects / apache / blobdiff