ServerType standalone

ServerRoot "/usr"
LockFile "/tmp/WebKit/httpd.lock"
PidFile "/tmp/WebKit/httpd.pid"
ScoreBoardFile "/tmp/WebKit/httpd.scoreboard"

ResourceConfig /dev/null
AccessConfig /dev/null

Timeout 300
KeepAlive On
MaxKeepAliveRequests 100
KeepAliveTimeout 15

MinSpareServers 1
MaxSpareServers 5
StartServers 1
MaxClients 150
MaxRequestsPerChild 100000

LoadModule config_log_module  lib/apache/mod_log_config.dll
LoadModule mime_module        lib/apache/mod_mime.dll
LoadModule negotiation_module lib/apache/mod_negotiation.dll
LoadModule includes_module    lib/apache/mod_include.dll
LoadModule cgi_module         lib/apache/mod_cgi.dll
LoadModule asis_module        lib/apache/mod_asis.dll
LoadModule imap_module        lib/apache/mod_imap.dll
LoadModule action_module      lib/apache/mod_actions.dll
LoadModule alias_module       lib/apache/mod_alias.dll
LoadModule rewrite_module     lib/apache/mod_rewrite.dll
LoadModule access_module      lib/apache/mod_access.dll
LoadModule auth_module        lib/apache/mod_auth.dll
LoadModule headers_module     lib/apache/mod_headers.dll
LoadModule php4_module        lib/apache/libphp4.dll

#  Reconstruction of the complete module list from all available modules
#  (static and shared ones) to achieve correct module execution order.
#  [WHENEVER YOU CHANGE THE LOADMODULE SECTION ABOVE UPDATE THIS, TOO]
ClearModuleList
AddModule mod_log_config.c
AddModule mod_mime.c
AddModule mod_negotiation.c
AddModule mod_include.c
AddModule mod_cgi.c
AddModule mod_asis.c
AddModule mod_imap.c
AddModule mod_actions.c
AddModule mod_alias.c
AddModule mod_rewrite.c
AddModule mod_access.c
AddModule mod_auth.c
AddModule mod_headers.c
AddModule mod_so.c
AddModule mod_php4.c

ServerName 127.0.0.1

<Directory />
    Options Indexes FollowSymLinks MultiViews ExecCGI Includes
    AllowOverride All
    Order allow,deny
    Allow from all
</Directory>

AccessFileName .htaccess

<Files ~ "^\.([Hh][Tt]|[Dd][Ss]_[Ss])">
    Order allow,deny
    Deny from all
    Satisfy All
</Files>

UseCanonicalName On
DefaultType text/plain
HostnameLookups Off

LogLevel warn
LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %b" common
LogFormat "%{Referer}i -> %U" referer
LogFormat "%{User-agent}i" agent

ServerSignature On

<IfModule mod_alias.c>
</IfModule>

<IfModule mod_mime.c>
    AddLanguage da .dk
    AddLanguage nl .nl
    AddLanguage en .en
    AddLanguage et .ee
    AddLanguage fr .fr
    AddLanguage de .de
    AddLanguage el .el
    AddLanguage he .he
    AddCharset ISO-8859-8 .iso8859-8
    AddLanguage it .it
    AddLanguage ja .ja
    AddCharset ISO-2022-JP .jis
    AddLanguage kr .kr
    AddCharset ISO-2022-KR .iso-kr
    AddLanguage nn .nn
    AddLanguage no .no
    AddLanguage pl .po
    AddCharset ISO-8859-2 .iso-pl
    AddLanguage pt .pt
    AddLanguage pt-br .pt-br
    AddLanguage ltz .lu
    AddLanguage ca .ca
    AddLanguage es .es
    AddLanguage sv .sv
    AddLanguage cs .cz .cs
    AddLanguage ru .ru
    AddLanguage zh-TW .zh-tw
    AddCharset Big5         .Big5    .big5
    AddCharset WINDOWS-1251 .cp-1251
    AddCharset CP866        .cp866
    AddCharset ISO-8859-5   .iso-ru
    AddCharset KOI8-R       .koi8-r
    AddCharset UCS-2        .ucs2
    AddCharset UCS-4        .ucs4
    AddCharset UTF-8        .utf8

    <IfModule mod_negotiation.c>
        LanguagePriority en da nl et fr de el it ja kr no pl pt pt-br ru ltz ca es sv tw
    </IfModule>

    AddType application/x-tar .tgz

    AddEncoding x-compress .Z
    AddEncoding x-gzip .gz .tgz

    AddHandler cgi-script .cgi .pl

    AddType text/html .shtml
    AddHandler server-parsed .shtml

    AddHandler send-as-is asis
</IfModule>

<IfModule mod_php4.c>
    AddType application/x-httpd-php .php
    AddType application/x-httpd-php .bat
    AddType application/x-httpd-php-source .phps

    <IfModule mod_dir.c>
        DirectoryIndex index.html index.php
    </IfModule>

    php_flag log_errors on
    php_flag short_open_tag on
</IfModule>

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{REQUEST_METHOD} ^TRACE
    RewriteRule .* - [F]
</IfModule>

#
# Apple-specific filesystem protection.
#
<Files "rsrc">
    Order allow,deny
    Deny from all
    Satisfy All
</Files>

<Directory  ~ ".*\.\.namedfork">
    Order allow,deny
    Deny from all
    Satisfy All
</Directory>
