ServerRoot "/usr"

Mutex file:/tmp/WebKit
PidFile "/tmp/WebKit/httpd.pid"
ScoreBoardFile "/tmp/WebKit/httpd.scoreboard"

Timeout 300
KeepAlive On
MaxKeepAliveRequests 100
KeepAliveTimeout 15

MinSpareServers 1
MaxSpareServers 5
StartServers 1
MaxRequestWorkers 150
MaxConnectionsPerChild 100000

LoadModule autoindex_module libexec/apache2/mod_autoindex.so
LoadModule unixd_module libexec/apache2/mod_unixd.so
LoadModule access_compat_module libexec/apache2/mod_access_compat.so
LoadModule authn_core_module libexec/apache2/mod_authn_core.so
LoadModule authz_core_module libexec/apache2/mod_authz_core.so
LoadModule authz_host_module libexec/apache2/mod_authz_host.so
LoadModule include_module libexec/apache2/mod_include.so
LoadModule log_config_module libexec/apache2/mod_log_config.so
LoadModule headers_module libexec/apache2/mod_headers.so
LoadModule ssl_module libexec/apache2/mod_ssl.so
LoadModule mime_module libexec/apache2/mod_mime.so
LoadModule asis_module libexec/apache2/mod_asis.so
LoadModule cgi_module libexec/apache2/mod_cgi.so
LoadModule negotiation_module libexec/apache2/mod_negotiation.so
#LoadModule imagemap_module libexec/apache2/mod_imagemap.so
LoadModule actions_module libexec/apache2/mod_actions.so
LoadModule alias_module libexec/apache2/mod_alias.so
LoadModule rewrite_module libexec/apache2/mod_rewrite.so
LoadModule php7_module        libexec/apache2/libphp7.so

<IfModule !mpm_prefork_module>
	LoadModule mpm_prefork_module libexec/apache2/mod_mpm_prefork.so
</IfModule>

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
HostnameLookups Off

LogLevel warn

ErrorLog "/tmp/WebKit/error_log.txt"

LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %b %D" 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_php7.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>

<VirtualHost *:8443>
    ServerName 127.0.0.1
    SSLEngine On
</VirtualHost>

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