modules/loggers/mod_log_config.c

	mod_log_config.c revision 49dacedb6c387b786b7911082ff35121a45f414b
f743002678eb67b99bbc29fee116b65d9530fec0wrowe/* Licensed to the Apache Software Foundation (ASF) under one or more
80833bb9a1bf25dcf19e814438a4b311d2e1f4cffuankg * contributor license agreements.  See the NOTICE file distributed with
5c43d2fb853f84497b5ece2d414ef9484aa87e5fsf * this work for additional information regarding copyright ownership.
5c43d2fb853f84497b5ece2d414ef9484aa87e5fsf * The ASF licenses this file to You under the Apache License, Version 2.0
5c43d2fb853f84497b5ece2d414ef9484aa87e5fsf * (the "License"); you may not use this file except in compliance with
5c43d2fb853f84497b5ece2d414ef9484aa87e5fsf * the License.  You may obtain a copy of the License at
5c43d2fb853f84497b5ece2d414ef9484aa87e5fsf *
4f517d09c93a552f177f49ff97e93aa44eb127ebcovener *     http://www.apache.org/licenses/LICENSE-2.0
4f517d09c93a552f177f49ff97e93aa44eb127ebcovener *
4f517d09c93a552f177f49ff97e93aa44eb127ebcovener * Unless required by applicable law or agreed to in writing, software
4f517d09c93a552f177f49ff97e93aa44eb127ebcovener * distributed under the License is distributed on an "AS IS" BASIS,
6736c640e65e06990ef33af71ee81fac4df4ff5fjim * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20eead0b01d51fce0cc17d04b8f98ec38eac68aejim * See the License for the specific language governing permissions and
20eead0b01d51fce0cc17d04b8f98ec38eac68aejim * limitations under the License.
20eead0b01d51fce0cc17d04b8f98ec38eac68aejim */
cc45ee60ddfb8380b3703455098475eb72625ca8jim
20eead0b01d51fce0cc17d04b8f98ec38eac68aejim/*
cc45ee60ddfb8380b3703455098475eb72625ca8jim * Modified by djm@va.pubnix.com:
cc45ee60ddfb8380b3703455098475eb72625ca8jim * If no TransferLog is given explicitly, decline to log.
46e5dfe0899face9346d6711e4f2ba873d526991sf *
46e5dfe0899face9346d6711e4f2ba873d526991sf * This is module implements the TransferLog directive (same as the
46e5dfe0899face9346d6711e4f2ba873d526991sf * common log module), and additional directives, LogFormat and CustomLog.
aee831691bb9ecd96dea63d35bc8bdd21c0f0b1fsf *
aee831691bb9ecd96dea63d35bc8bdd21c0f0b1fsf *
aee831691bb9ecd96dea63d35bc8bdd21c0f0b1fsf * Syntax:
aee831691bb9ecd96dea63d35bc8bdd21c0f0b1fsf *
79ccc75d7de4e14e5add1fa73aaabda0f5d33fe6trawick *    TransferLog fn      Logs transfers to fn in standard log format, unless
79ccc75d7de4e14e5add1fa73aaabda0f5d33fe6trawick *                        a custom format is set with LogFormat
79ccc75d7de4e14e5add1fa73aaabda0f5d33fe6trawick *    LogFormat format    Set a log format from TransferLog files
fc1459657a1fde206a847f9028930725d715f8b4trawick *    CustomLog fn format
fc1459657a1fde206a847f9028930725d715f8b4trawick *                        Log to file fn with format given by the format
fc1459657a1fde206a847f9028930725d715f8b4trawick *                        argument
e758971371df73b097609b2fd62bc14ad935e096trawick *
e758971371df73b097609b2fd62bc14ad935e096trawick * There can be any number of TransferLog and CustomLog
e758971371df73b097609b2fd62bc14ad935e096trawick * commands. Each request will be logged to _ALL_ the
1dd5136d67e0164e4afd723a471b86a1b7eb1874sf * named files, in the appropriate format.
1dd5136d67e0164e4afd723a471b86a1b7eb1874sf *
1dd5136d67e0164e4afd723a471b86a1b7eb1874sf * If no TransferLog or CustomLog directive appears in a VirtualHost,
1dd5136d67e0164e4afd723a471b86a1b7eb1874sf * the request will be logged to the log file(s) defined outside
e39eb98e3ad3fbf5c34b2fa1d16861f95143e22esf * the virtual host section. If a TransferLog or CustomLog directive
e39eb98e3ad3fbf5c34b2fa1d16861f95143e22esf * appears in the VirtualHost section, the log files defined outside
e39eb98e3ad3fbf5c34b2fa1d16861f95143e22esf * the VirtualHost will _not_ be used. This makes this module compatable
d6fc66efa723db8b3ee5e9fd32579bed884e4e58sf * with the CLF and config log modules, where the use of TransferLog
d6fc66efa723db8b3ee5e9fd32579bed884e4e58sf * inside the VirtualHost section overrides its use outside.
d6fc66efa723db8b3ee5e9fd32579bed884e4e58sf *
d6fc66efa723db8b3ee5e9fd32579bed884e4e58sf * Examples:
f00cb80197f824c3ff00dd4fdff3b2c267a519d1kbrand *
f00cb80197f824c3ff00dd4fdff3b2c267a519d1kbrand *    TransferLog    logs/access_log
f00cb80197f824c3ff00dd4fdff3b2c267a519d1kbrand *    <VirtualHost>
f00cb80197f824c3ff00dd4fdff3b2c267a519d1kbrand *    LogFormat      "... custom format ..."
85eacfc96a04547ef25aabbc06440039715084c2jorton *    TransferLog    log/virtual_only
85eacfc96a04547ef25aabbc06440039715084c2jorton *    CustomLog      log/virtual_useragents "%t %{user-agent}i"
85eacfc96a04547ef25aabbc06440039715084c2jorton *    </VirtualHost>
1d8d7e58e1d31d7b6fb7a518e09649a4dbb315e9trawick *
1d8d7e58e1d31d7b6fb7a518e09649a4dbb315e9trawick * This will log using CLF to access_log any requests handled by the
1d8d7e58e1d31d7b6fb7a518e09649a4dbb315e9trawick * main server, while any requests to the virtual host will be logged
f34da68471f256dca0ff770257c3e1f982f74cf1trawick * with the "... custom format..." to virtual_only _AND_ using
f34da68471f256dca0ff770257c3e1f982f74cf1trawick * the custom user-agent log to virtual_useragents.
f34da68471f256dca0ff770257c3e1f982f74cf1trawick *
8b645fd3c950da73513b546366c7cfa7476c5c06jim * Note that the NCSA referer and user-agent logs are easily added with
8b645fd3c950da73513b546366c7cfa7476c5c06jim * CustomLog:
8b645fd3c950da73513b546366c7cfa7476c5c06jim *   CustomLog   logs/referer  "%{referer}i -> %U"
8b645fd3c950da73513b546366c7cfa7476c5c06jim *   CustomLog   logs/agent    "%{user-agent}i"
193f0bb6057d67593ed652fbf58f043def51c642jim *
193f0bb6057d67593ed652fbf58f043def51c642jim * RefererIgnore functionality can be obtained with conditional
193f0bb6057d67593ed652fbf58f043def51c642jim * logging (SetEnvIf and CustomLog ... env=!VAR).
68ba377fc3b124baa759662077c48077ebadb186minfrin *
68ba377fc3b124baa759662077c48077ebadb186minfrin * But using this method allows much easier modification of the
68ba377fc3b124baa759662077c48077ebadb186minfrin * log format, e.g. to log hosts along with UA:
68ba377fc3b124baa759662077c48077ebadb186minfrin *   CustomLog   logs/referer "%{referer}i %U %h"
00566fb187849626180724394a21ddcd28419fb2minfrin *
00566fb187849626180724394a21ddcd28419fb2minfrin * The argument to LogFormat and CustomLog is a string, which can include
00566fb187849626180724394a21ddcd28419fb2minfrin * literal characters copied into the log files, and '%' directives as
00566fb187849626180724394a21ddcd28419fb2minfrin * follows:
d776b0a2d2889ce1d13494873368f34327a2e1bbtrawick *
d776b0a2d2889ce1d13494873368f34327a2e1bbtrawick * %...B:  bytes sent, excluding HTTP headers.
f4ca9f6f002fece336168a16355434ca966f96a9trawick * %...b:  bytes sent, excluding HTTP headers in CLF format, i.e. a '-'
57db302f0875a6c93a79333b8941cea4c1827272jim *         when no bytes where sent (rather than a '0'.
57db302f0875a6c93a79333b8941cea4c1827272jim * %...{FOOBAR}C:  The contents of the HTTP cookie FOOBAR
57db302f0875a6c93a79333b8941cea4c1827272jim * %...{FOOBAR}e:  The contents of the environment variable FOOBAR
57db302f0875a6c93a79333b8941cea4c1827272jim * %...f:  filename
92b1631880b0bf43fe8b2663a03c8571eb04e433jim * %...h:  remote host
92b1631880b0bf43fe8b2663a03c8571eb04e433jim * %...a:  remote IP-address
92b1631880b0bf43fe8b2663a03c8571eb04e433jim * %...A:  local IP-address
89225e8e84d38b07a8335922497997e83d872e75jim * %...{Foobar}i:  The contents of Foobar: header line(s) in the request
89225e8e84d38b07a8335922497997e83d872e75jim *                 sent to the client.
89225e8e84d38b07a8335922497997e83d872e75jim * %...k:  number of keepalive requests served over this connection
78f94f1d06c4e6828ce04d618221e0fcecb57849humbedooh * %...l:  remote logname (from identd, if supplied)
78f94f1d06c4e6828ce04d618221e0fcecb57849humbedooh * %...{Foobar}n:  The contents of note "Foobar" from another module.
78f94f1d06c4e6828ce04d618221e0fcecb57849humbedooh * %...{Foobar}o:  The contents of Foobar: header line(s) in the reply.
f5e28c78424d2f71c61ba457009f100bba38bc68chrisd * %...p:  the canonical port for the server
f5e28c78424d2f71c61ba457009f100bba38bc68chrisd * %...{format}p: the canonical port for the server, or the actual local
f5e28c78424d2f71c61ba457009f100bba38bc68chrisd *                or remote port
f4a715f904b014060ea6237fe29481ed21f5c7d0jorton * %...P:  the process ID of the child that serviced the request.
f4a715f904b014060ea6237fe29481ed21f5c7d0jorton * %...{format}P: the process ID or thread ID of the child/thread that
f4a715f904b014060ea6237fe29481ed21f5c7d0jorton *                serviced the request
536d2e7cd1fdec1255b8c3bdf41fdc714c506a54trawick * %...r:  first line of request
536d2e7cd1fdec1255b8c3bdf41fdc714c506a54trawick * %...s:  status.  For requests that got internally redirected, this
536d2e7cd1fdec1255b8c3bdf41fdc714c506a54trawick *         is status of the *original* request --- %...>s for the last.
536d2e7cd1fdec1255b8c3bdf41fdc714c506a54trawick * %...t:  time, in common log format time format
70caa242e6b90e0d6f0fabb56b8c5c2fb51717b3jorton * %...{format}t:  The time, in the form given by format, which should
985a4368b93c3e9171a57897ad9454c8dbf4cdf6jorton *                 be in strftime(3) format.
70caa242e6b90e0d6f0fabb56b8c5c2fb51717b3jorton * %...T:  the time taken to serve the request, in seconds.
70caa242e6b90e0d6f0fabb56b8c5c2fb51717b3jorton * %...D:  the time taken to serve the request, in micro seconds.
109e2a09790de3fb315d36d6232a14ab66c8eb0ahumbedooh * %...u:  remote user (from auth; may be bogus if return status (%s) is 401)
109e2a09790de3fb315d36d6232a14ab66c8eb0ahumbedooh * %...U:  the URL path requested.
109e2a09790de3fb315d36d6232a14ab66c8eb0ahumbedooh * %...v:  the configured name of the server (i.e. which virtual host?)
4be250c774bdac977eef29a02183ca78de29fb41rjung * %...V:  the server name according to the UseCanonicalName setting
4be250c774bdac977eef29a02183ca78de29fb41rjung * %...m:  the request method
4be250c774bdac977eef29a02183ca78de29fb41rjung * %...H:  the request protocol
12b5dc9afa1844df5ac8acab98fb538432a2fa1crjung * %...q:  the query string prepended by "?", or empty if no query string
12b5dc9afa1844df5ac8acab98fb538432a2fa1crjung * %...X:  Status of the connection.
12b5dc9afa1844df5ac8acab98fb538432a2fa1crjung *         'X' = connection aborted before the response completed.
12b5dc9afa1844df5ac8acab98fb538432a2fa1crjung *         '+' = connection may be kept alive after the response is sent.
74e7a30182af5e68f14ccb8d57918b22b982db8bhumbedooh *         '-' = connection will be closed after the response is sent.
74e7a30182af5e68f14ccb8d57918b22b982db8bhumbedooh *         (This directive was %...c in late versions of Apache 1.3, but
74e7a30182af5e68f14ccb8d57918b22b982db8bhumbedooh *          this conflicted with the historical ssl %...{var}c syntax.)
10961a2f60207cb873d889bb28b1f0ef707a4311humbedooh * %...L:  Log-Id of the Request (or '-' if none)
10961a2f60207cb873d889bb28b1f0ef707a4311humbedooh * %...{c}L:  Log-Id of the Connection (or '-' if none)
10961a2f60207cb873d889bb28b1f0ef707a4311humbedooh *
0448378b899e8df0c060360f17c0af692adf17bchumbedooh * The '...' can be nothing at all (e.g. "%h %u %r %s %b"), or it can
0448378b899e8df0c060360f17c0af692adf17bchumbedooh * indicate conditions for inclusion of the item (which will cause it
0448378b899e8df0c060360f17c0af692adf17bchumbedooh * to be replaced with '-' if the condition is not met).  Note that
60a765cccbd3f3b5997b65b0034220c79f78369etrawick * there is no escaping performed on the strings from %r, %...i and
60a765cccbd3f3b5997b65b0034220c79f78369etrawick * %...o; some with long memories may remember that I thought this was
60a765cccbd3f3b5997b65b0034220c79f78369etrawick * a bad idea, once upon a time, and I'm still not comfortable with
e7ca863b04ee2a7aea7738cadbf51ce5e6c5245dhumbedooh * it, but it is difficult to see how to "do the right thing" with all
e7ca863b04ee2a7aea7738cadbf51ce5e6c5245dhumbedooh * of '%..i', unless we URL-escape everything and break with CLF.
e7ca863b04ee2a7aea7738cadbf51ce5e6c5245dhumbedooh *
e7ca863b04ee2a7aea7738cadbf51ce5e6c5245dhumbedooh * The forms of condition are a list of HTTP status codes, which may
91654e263480f0fdc2a03d782ff23f8dad07cf79humbedooh * or may not be preceded by '!'.  Thus, '%400,501{User-agent}i' logs
91814c869ca39ce45dfe147307d2a831cac6ecbehumbedooh * User-agent: on 400 errors and 501 errors (Bad Request, Not
91654e263480f0fdc2a03d782ff23f8dad07cf79humbedooh * Implemented) only; '%!200,304,302{Referer}i' logs Referer: on all
79c5787b92ac5f0e1cc82393816c77a006399316trawick * requests which did *not* return some sort of normal status.
79c5787b92ac5f0e1cc82393816c77a006399316trawick *
79c5787b92ac5f0e1cc82393816c77a006399316trawick * The default LogFormat reproduces CLF; see below.
79c5787b92ac5f0e1cc82393816c77a006399316trawick *
79c5787b92ac5f0e1cc82393816c77a006399316trawick * The way this is supposed to work with virtual hosts is as follows:
79c5787b92ac5f0e1cc82393816c77a006399316trawick * a virtual host can have its own LogFormat, or its own TransferLog.
79c5787b92ac5f0e1cc82393816c77a006399316trawick * If it doesn't have its own LogFormat, it inherits from the main
79c5787b92ac5f0e1cc82393816c77a006399316trawick * server.  If it doesn't have its own TransferLog, it writes to the
79c5787b92ac5f0e1cc82393816c77a006399316trawick * same descriptor (meaning the same process for "| ...").
12b987b969f03ef98d9175a53d849ab62f5684fecovener *
12b987b969f03ef98d9175a53d849ab62f5684fecovener * --- rst */
099c357f282d4aebf2b32264f7dce6ffc0497c37sf
099c357f282d4aebf2b32264f7dce6ffc0497c37sf#include "apr_strings.h"
099c357f282d4aebf2b32264f7dce6ffc0497c37sf#include "apr_lib.h"
099c357f282d4aebf2b32264f7dce6ffc0497c37sf#include "apr_hash.h"
50f8c80eb4d3989ebf3f1341aeef4d2d302af162sf#include "apr_optional.h"
50f8c80eb4d3989ebf3f1341aeef4d2d302af162sf#include "apr_anylock.h"
4bb0a88a01fb7b494bb02a8b881b5eab0308bda6sf
50f8c80eb4d3989ebf3f1341aeef4d2d302af162sf#define APR_WANT_STRFUNC
7b395e4e878c28a4784919cfd2e704ddd14a3390jorton#include "apr_want.h"
7b395e4e878c28a4784919cfd2e704ddd14a3390jorton
7b395e4e878c28a4784919cfd2e704ddd14a3390jorton#include "ap_config.h"
7b395e4e878c28a4784919cfd2e704ddd14a3390jorton#include "mod_log_config.h"
536e48c08d674acac5d44929318f2ad928edc361jorton#include "httpd.h"
536e48c08d674acac5d44929318f2ad928edc361jorton#include "http_config.h"
e81785da447b469da66f218b3f0244aab507958djorton#include "http_core.h"          /* For REMOTE_NAME */
e81785da447b469da66f218b3f0244aab507958djorton#include "http_log.h"
3e4e54d4e3fc0123c63d57aa84ac7ad7a8c73ff8jorton#include "http_protocol.h"
3e4e54d4e3fc0123c63d57aa84ac7ad7a8c73ff8jorton#include "util_time.h"
3e4e54d4e3fc0123c63d57aa84ac7ad7a8c73ff8jorton#include "ap_mpm.h"
459eaf0826f995b73a0dc066f59ea10d2824e72dsf
459eaf0826f995b73a0dc066f59ea10d2824e72dsf#if APR_HAVE_UNISTD_H
459eaf0826f995b73a0dc066f59ea10d2824e72dsf#include <unistd.h>
459eaf0826f995b73a0dc066f59ea10d2824e72dsf#endif
53e9b27aba029b18be814df40bcf6f0428771d1efuankg#ifdef HAVE_LIMITS_H
53e9b27aba029b18be814df40bcf6f0428771d1efuankg#include <limits.h>
53e9b27aba029b18be814df40bcf6f0428771d1efuankg#endif
53e9b27aba029b18be814df40bcf6f0428771d1efuankg
53e9b27aba029b18be814df40bcf6f0428771d1efuankg#define DEFAULT_LOG_FORMAT "%h %l %u %t \"%r\" %>s %b"
6bb524f1895f30265a1431afc460977d391cb36bsf
6bb524f1895f30265a1431afc460977d391cb36bsfmodule AP_MODULE_DECLARE_DATA log_config_module;
ca61ccd0c306c2c72df153688ba1b49f3eceed80sf
6bb524f1895f30265a1431afc460977d391cb36bsf
e6dd71992459d05a676b98b7963423dc5dc1e24aminfrinstatic int xfer_flags = (APR_WRITE | APR_APPEND | APR_CREATE | APR_LARGEFILE);
e6dd71992459d05a676b98b7963423dc5dc1e24aminfrinstatic apr_fileperms_t xfer_perms = APR_OS_DEFAULT;
e6dd71992459d05a676b98b7963423dc5dc1e24aminfrinstatic apr_hash_t *log_hash;
e6dd71992459d05a676b98b7963423dc5dc1e24aminfrinstatic apr_status_t ap_default_log_writer(request_rec *r,
23f1535d6a60817d2846bac0aea230ea475d7dccminfrin                           void *handle,
23f1535d6a60817d2846bac0aea230ea475d7dccminfrin                           const char **strs,
23f1535d6a60817d2846bac0aea230ea475d7dccminfrin                           int *strl,
23f1535d6a60817d2846bac0aea230ea475d7dccminfrin                           int nelts,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           apr_size_t len);
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjungstatic apr_status_t ap_buffered_log_writer(request_rec *r,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           void *handle,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           const char **strs,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           int *strl,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           int nelts,
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjung                           apr_size_t len);
ec7520b24cd80d34d82bbcaca153cbb23cc04bc0rjungstatic void *ap_default_log_writer_init(apr_pool_t *p, server_rec *s,
6249dfa569d3b4f1f539665b979a80c6e335d93etrawick                                        const char* name);
6249dfa569d3b4f1f539665b979a80c6e335d93etrawickstatic void *ap_buffered_log_writer_init(apr_pool_t *p, server_rec *s,
0827cb14e550f6f65018431c22c2c913631c8f25kbrand                                        const char* name);
6249dfa569d3b4f1f539665b979a80c6e335d93etrawick
ae600ca541efc686b34f8b1f21bd3d0741d37674covenerstatic ap_log_writer_init *ap_log_set_writer_init(ap_log_writer_init *handle);
6249dfa569d3b4f1f539665b979a80c6e335d93etrawickstatic ap_log_writer *ap_log_set_writer(ap_log_writer *handle);
cfa64348224b66dd1c9979b809406c4d15b1c137fieldingstatic ap_log_writer *log_writer = ap_default_log_writer;
74499a117b3b2cd9666715a14f90c0e5d1a4ee8ajimstatic ap_log_writer_init *log_writer_init = ap_default_log_writer_init;
cfa64348224b66dd1c9979b809406c4d15b1c137fieldingstatic int buffered_logs = 0; /* default unbuffered */
74499a117b3b2cd9666715a14f90c0e5d1a4ee8ajimstatic apr_array_header_t *all_buffered_logs = NULL;
cfa64348224b66dd1c9979b809406c4d15b1c137fielding
74499a117b3b2cd9666715a14f90c0e5d1a4ee8ajim/* POSIX.1 defines PIPE_BUF as the maximum number of bytes that is
cfa64348224b66dd1c9979b809406c4d15b1c137fielding * guaranteed to be atomic when writing a pipe.  And PIPE_BUF >= 512
74499a117b3b2cd9666715a14f90c0e5d1a4ee8ajim * is guaranteed.  So we'll just guess 512 in the event the system
cfa64348224b66dd1c9979b809406c4d15b1c137fielding * doesn't have this.  Now, for file writes there is actually no limit,
 * the entire write is atomic.  Whether all systems implement this
 * correctly is another question entirely ... so we'll just use PIPE_BUF
 * because it's probably a good guess as to what is implemented correctly
 * everywhere.
 */
#ifdef PIPE_BUF
#define LOG_BUFSIZE     PIPE_BUF
#else
#define LOG_BUFSIZE     (512)
#endif

/*
 * multi_log_state is our per-(virtual)-server configuration. We store
 * an array of the logs we are going to use, each of type config_log_state.
 * If a default log format is given by LogFormat, store in default_format
 * (backward compat. with mod_log_config).  We also store for each virtual
 * server a pointer to the logs specified for the main server, so that if this
 * vhost has no logs defined, we can use the main server's logs instead.
 *
 * So, for the main server, config_logs contains a list of the log files
 * and server_config_logs is empty. For a vhost, server_config_logs
 * points to the same array as config_logs in the main server, and
 * config_logs points to the array of logs defined inside this vhost,
 * which might be empty.
 */

typedef struct {
    const char *default_format_string;
    apr_array_header_t *default_format;
    apr_array_header_t *config_logs;
    apr_array_header_t *server_config_logs;
    apr_table_t *formats;
} multi_log_state;

/*
 * config_log_state holds the status of a single log file. fname might
 * be NULL, which means this module does no logging for this
 * request. format might be NULL, in which case the default_format
 * from the multi_log_state should be used, or if that is NULL as
 * well, use the CLF.
 * log_writer is NULL before the log file is opened and is
 * set to a opaque structure (usually a fd) after it is opened.

 */
typedef struct {
    apr_file_t *handle;
    apr_size_t outcnt;
    char outbuf[LOG_BUFSIZE];
    apr_anylock_t mutex;
} buffered_log;

typedef struct {
    const char *fname;
    const char *format_string;
    apr_array_header_t *format;
    void *log_writer;
    char *condition_var;
    int inherit;
    ap_expr_info_t *condition_expr;
    /** place of definition or NULL if already checked */
    const ap_directive_t *directive;
} config_log_state;

/*
 * log_request_state holds request specific log data that is not
 * part of the request_rec.
 */
typedef struct {
    apr_time_t request_end_time;
} log_request_state;

/*
 * Format items...
 * Note that many of these could have ap_sprintfs replaced with static buffers.
 */

typedef struct {
    ap_log_handler_fn_t *func;
    char *arg;
    int condition_sense;
    int want_orig;
    apr_array_header_t *conditions;
} log_format_item;

static char *pfmt(apr_pool_t *p, int i)
{
    if (i <= 0) {
        return "-";
    }
    else {
        return apr_itoa(p, i);
    }
}

static const char *constant_item(request_rec *dummy, char *stuff)
{
    return stuff;
}

static const char *log_remote_host(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, ap_get_remote_host(r->connection,
                                                         r->per_dir_config,
                                                         REMOTE_NAME, NULL));
}

static const char *log_remote_address(request_rec *r, char *a)
{
    if (a && !strcmp(a, "c")) {
        return r->connection->client_ip;
    }
    else {
        return r->useragent_ip;
    }
}

static const char *log_local_address(request_rec *r, char *a)
{
    return r->connection->local_ip;
}

static const char *log_remote_logname(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, ap_get_remote_logname(r));
}

static const char *log_remote_user(request_rec *r, char *a)
{
    char *rvalue = r->user;

    if (rvalue == NULL) {
        rvalue = "-";
    }
    else if (strlen(rvalue) == 0) {
        rvalue = "\"\"";
    }
    else {
        rvalue = ap_escape_logitem(r->pool, rvalue);
    }

    return rvalue;
}

static const char *log_request_line(request_rec *r, char *a)
{
    /* NOTE: If the original request contained a password, we
     * re-write the request line here to contain XXXXXX instead:
     * (note the truncation before the protocol string for HTTP/0.9 requests)
     * (note also that r->the_request contains the unmodified request)
     */
    return ap_escape_logitem(r->pool,
                             (r->parsed_uri.password)
                               ? apr_pstrcat(r->pool, r->method, " ",
                                             apr_uri_unparse(r->pool,
                                                             &r->parsed_uri, 0),
                                             r->assbackwards ? NULL : " ",
                                             r->protocol, NULL)
                               : r->the_request);
}

static const char *log_request_file(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->filename);
}
static const char *log_request_uri(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->uri);
}
static const char *log_request_method(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->method);
}
static const char *log_log_id(request_rec *r, char *a)
{
    if (a && !strcmp(a, "c")) {
        return r->connection->log_id ? r->connection->log_id : "-";
    }
    else {
        return r->log_id ? r->log_id : "-";
    }
}
static const char *log_request_protocol(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->protocol);
}
static const char *log_request_query(request_rec *r, char *a)
{
    return (r->args) ? apr_pstrcat(r->pool, "?",
                                   ap_escape_logitem(r->pool, r->args), NULL)
                     : "";
}
static const char *log_status(request_rec *r, char *a)
{
    return pfmt(r->pool, r->status);
}

static const char *log_handler(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->handler);
}

static const char *clf_log_bytes_sent(request_rec *r, char *a)
{
    if (!r->sent_bodyct || !r->bytes_sent) {
        return "-";
    }
    else {
        return apr_off_t_toa(r->pool, r->bytes_sent);
    }
}

static const char *log_bytes_sent(request_rec *r, char *a)
{
    if (!r->sent_bodyct || !r->bytes_sent) {
        return "0";
    }
    else {
        return apr_off_t_toa(r->pool, r->bytes_sent);
    }
}


static const char *log_header_in(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, apr_table_get(r->headers_in, a));
}

static APR_INLINE char *find_multiple_headers(apr_pool_t *pool,
                                              const apr_table_t *table,
                                              const char *key)
{
    const apr_array_header_t *elts;
    const apr_table_entry_t *t_elt;
    const apr_table_entry_t *t_end;
    apr_size_t len;
    struct sle {
        struct sle *next;
        const char *value;
        apr_size_t len;
    } *result_list, *rp;

    elts = apr_table_elts(table);

    if (!elts->nelts) {
        return NULL;
    }

    t_elt = (const apr_table_entry_t *)elts->elts;
    t_end = t_elt + elts->nelts;
    len = 1; /* \0 */
    result_list = rp = NULL;

    do {
        if (!strcasecmp(t_elt->key, key)) {
            if (!result_list) {
                result_list = rp = apr_palloc(pool, sizeof(*rp));
            }
            else {
                rp = rp->next = apr_palloc(pool, sizeof(*rp));
                len += 2; /* ", " */
            }

            rp->next = NULL;
            rp->value = t_elt->val;
            rp->len = strlen(rp->value);

            len += rp->len;
        }
        ++t_elt;
    } while (t_elt < t_end);

    if (result_list) {
        char *result = apr_palloc(pool, len);
        char *cp = result;

        rp = result_list;
        while (rp) {
            if (rp != result_list) {
                *cp++ = ',';
                *cp++ = ' ';
            }
            memcpy(cp, rp->value, rp->len);
            cp += rp->len;
            rp = rp->next;
        }
        *cp = '\0';

        return result;
    }

    return NULL;
}

static const char *log_header_out(request_rec *r, char *a)
{
    const char *cp = NULL;

    if (!strcasecmp(a, "Content-type") && r->content_type) {
        cp = ap_field_noparam(r->pool, r->content_type);
    }
    else if (!strcasecmp(a, "Set-Cookie")) {
        cp = find_multiple_headers(r->pool, r->headers_out, a);
    }
    else {
        cp = apr_table_get(r->headers_out, a);
    }

    return ap_escape_logitem(r->pool, cp);
}

static const char *log_note(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, apr_table_get(r->notes, a));
}
static const char *log_env_var(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, apr_table_get(r->subprocess_env, a));
}

static const char *log_cookie(request_rec *r, char *a)
{
    const char *cookies_entry;

    /*
     * This supports Netscape version 0 cookies while being tolerant to
     * some properties of RFC2109/2965 version 1 cookies:
     * - case-insensitive match of cookie names
     * - white space between the tokens
     * It does not support the following version 1 features:
     * - quoted strings as cookie values
     * - commas to separate cookies
     */

    if ((cookies_entry = apr_table_get(r->headers_in, "Cookie"))) {
        char *cookie, *last1, *last2;
        char *cookies = apr_pstrdup(r->pool, cookies_entry);

        while ((cookie = apr_strtok(cookies, ";", &last1))) {
            char *name = apr_strtok(cookie, "=", &last2);
            /* last2 points to the next char following an '=' delim,
               or the trailing NUL char of the string */
            char *value = last2;
            if (name && *name &&  value && *value) {
                char *last = value - 2;
                /* Move past leading WS */
                name += strspn(name, " \t");
                while (last >= name && apr_isspace(*last)) {
                    *last = '\0';
                    --last;
                }

                if (!strcasecmp(name, a)) {
                    /* last1 points to the next char following the ';' delim,
                       or the trailing NUL char of the string */
                    last = last1 - (*last1 ? 2 : 1);
                    /* Move past leading WS */
                    value += strspn(value, " \t");
                    while (last >= value && apr_isspace(*last)) {
                       *last = '\0';
                       --last;
                    }

                    return ap_escape_logitem(r->pool, value);
                }
            }
            /* Iterate the remaining tokens using apr_strtok(NULL, ...) */
            cookies = NULL;
        }
    }
    return NULL;
}

static const char *log_request_time_custom(request_rec *r, char *a,
                                           apr_time_exp_t *xt)
{
    apr_size_t retcode;
    char tstr[MAX_STRING_LEN];
    apr_strftime(tstr, &retcode, sizeof(tstr), a, xt);
    return apr_pstrdup(r->pool, tstr);
}

#define DEFAULT_REQUEST_TIME_SIZE 32
typedef struct {
    unsigned t;
    char timestr[DEFAULT_REQUEST_TIME_SIZE];
    unsigned t_validate;
} cached_request_time;

#define TIME_FMT_CUSTOM          0
#define TIME_FMT_CLF             1
#define TIME_FMT_ABS_SEC         2
#define TIME_FMT_ABS_MSEC        3
#define TIME_FMT_ABS_USEC        4
#define TIME_FMT_ABS_MSEC_FRAC   5
#define TIME_FMT_ABS_USEC_FRAC   6

#define TIME_CACHE_SIZE 4
#define TIME_CACHE_MASK 3
static cached_request_time request_time_cache[TIME_CACHE_SIZE];

static apr_time_t get_request_end_time(request_rec *r)
{
    log_request_state *state = (log_request_state *)ap_get_module_config(r->request_config,
                                                                         &log_config_module);
    if (!state) {
        state = apr_pcalloc(r->pool, sizeof(log_request_state));
        ap_set_module_config(r->request_config, &log_config_module, state);
    }
    if (state->request_end_time == 0) {
        state->request_end_time = apr_time_now();
    }
    return state->request_end_time;
}


static const char *log_request_time(request_rec *r, char *a)
{
    apr_time_exp_t xt;
    apr_time_t request_time = r->request_time;
    int fmt_type = TIME_FMT_CUSTOM;
    char *fmt = a;

    if (fmt && *fmt) {
        if (!strncmp(fmt, "begin", 5)) {
            fmt += 5;
            if (!*fmt) {
                fmt_type = TIME_FMT_CLF;
            }
            else if (*fmt == ':') {
                fmt++;
                a = fmt;
            }
        }
        else if (!strncmp(fmt, "end", 3)) {
            fmt += 3;
            if (!*fmt) {
                request_time = get_request_end_time(r);
                fmt_type = TIME_FMT_CLF;
            }
            else if (*fmt == ':') {
                fmt++;
                a = fmt;
                request_time = get_request_end_time(r);
            }
        }
        if (!strncmp(fmt, "msec", 4)) {
            fmt += 4;
            if (!*fmt) {
                fmt_type = TIME_FMT_ABS_MSEC;
            }
            else if (!strcmp(fmt, "_frac")) {
                fmt_type = TIME_FMT_ABS_MSEC_FRAC;
            }
        }
        else if (!strncmp(fmt, "usec", 4)) {
            fmt += 4;
            if (!*fmt) {
                fmt_type = TIME_FMT_ABS_USEC;
            }
            else if (!strcmp(fmt, "_frac")) {
                fmt_type = TIME_FMT_ABS_USEC_FRAC;
            }
        }
        else if (!strcmp(fmt, "sec")) {
            fmt_type = TIME_FMT_ABS_SEC;
        }
        else if (!*fmt) {
            fmt_type = TIME_FMT_CLF;
        }
    }
    else {
        fmt_type = TIME_FMT_CLF;
    }

    if (fmt_type >= TIME_FMT_ABS_SEC) {      /* Absolute (micro-/milli-)second time
                                              * or msec/usec fraction
                                              */
        char* buf = apr_palloc(r->pool, 20);
        switch (fmt_type) {
        case TIME_FMT_ABS_SEC:
            apr_snprintf(buf, 20, "%" APR_TIME_T_FMT, apr_time_sec(request_time));
            break;
        case TIME_FMT_ABS_MSEC:
            apr_snprintf(buf, 20, "%" APR_TIME_T_FMT, apr_time_as_msec(request_time));
            break;
        case TIME_FMT_ABS_USEC:
            apr_snprintf(buf, 20, "%" APR_TIME_T_FMT, request_time);
            break;
        case TIME_FMT_ABS_MSEC_FRAC:
            apr_snprintf(buf, 20, "%03" APR_TIME_T_FMT, apr_time_msec(request_time));
            break;
        case TIME_FMT_ABS_USEC_FRAC:
            apr_snprintf(buf, 20, "%06" APR_TIME_T_FMT, apr_time_usec(request_time));
            break;
        default:
            return "-";
        }
        return buf;
    }
    else if (fmt_type == TIME_FMT_CUSTOM) {  /* Custom format */
        /* The custom time formatting uses a very large temp buffer
         * on the stack.  To avoid using so much stack space in the
         * common case where we're not using a custom format, the code
         * for the custom format in a separate function.  (That's why
         * log_request_time_custom is not inlined right here.)
         */
        ap_explode_recent_localtime(&xt, request_time);
        return log_request_time_custom(r, a, &xt);
    }
    else {                                   /* CLF format */
        /* This code uses the same technique as ap_explode_recent_localtime():
         * optimistic caching with logic to detect and correct race conditions.
         * See the comments in server/util_time.c for more information.
         */
        cached_request_time* cached_time = apr_palloc(r->pool,
                                                      sizeof(*cached_time));
        unsigned t_seconds = (unsigned)apr_time_sec(request_time);
        unsigned i = t_seconds & TIME_CACHE_MASK;
        *cached_time = request_time_cache[i];
        if ((t_seconds != cached_time->t) ||
            (t_seconds != cached_time->t_validate)) {

            /* Invalid or old snapshot, so compute the proper time string
             * and store it in the cache
             */
            char sign;
            int timz;

            ap_explode_recent_localtime(&xt, request_time);
            timz = xt.tm_gmtoff;
            if (timz < 0) {
                timz = -timz;
                sign = '-';
            }
            else {
                sign = '+';
            }
            cached_time->t = t_seconds;
            apr_snprintf(cached_time->timestr, DEFAULT_REQUEST_TIME_SIZE,
                         "[%02d/%s/%d:%02d:%02d:%02d %c%.2d%.2d]",
                         xt.tm_mday, apr_month_snames[xt.tm_mon],
                         xt.tm_year+1900, xt.tm_hour, xt.tm_min, xt.tm_sec,
                         sign, timz / (60*60), (timz % (60*60)) / 60);
            cached_time->t_validate = t_seconds;
            request_time_cache[i] = *cached_time;
        }
        return cached_time->timestr;
    }
}

static const char *log_request_duration(request_rec *r, char *a)
{
    apr_time_t duration = get_request_end_time(r) - r->request_time;
    return apr_psprintf(r->pool, "%" APR_TIME_T_FMT, apr_time_sec(duration));
}

static const char *log_request_duration_microseconds(request_rec *r, char *a)
{
    return apr_psprintf(r->pool, "%" APR_TIME_T_FMT,
                        (get_request_end_time(r) - r->request_time));
}

/* These next two routines use the canonical name:port so that log
 * parsers don't need to duplicate all the vhost parsing crud.
 */
static const char *log_virtual_host(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, r->server->server_hostname);
}

static const char *log_server_port(request_rec *r, char *a)
{
    apr_port_t port;

    if (*a == '\0' || !strcasecmp(a, "canonical")) {
        port = r->server->port ? r->server->port : ap_default_port(r);
    }
    else if (!strcasecmp(a, "remote")) {
        port = r->useragent_addr->port;
    }
    else if (!strcasecmp(a, "local")) {
        port = r->connection->local_addr->port;
    }
    else {
        /* bogus format */
        return a;
    }
    return apr_itoa(r->pool, (int)port);
}

/* This respects the setting of UseCanonicalName so that
 * the dynamic mass virtual hosting trick works better.
 */
static const char *log_server_name(request_rec *r, char *a)
{
    return ap_escape_logitem(r->pool, ap_get_server_name(r));
}

static const char *log_pid_tid(request_rec *r, char *a)
{
    if (*a == '\0' || !strcasecmp(a, "pid")) {
        return ap_append_pid(r->pool, "", "");
    }
    else if (!strcasecmp(a, "tid") || !strcasecmp(a, "hextid")) {
#if APR_HAS_THREADS
        apr_os_thread_t tid = apr_os_thread_current();
#else
        int tid = 0; /* APR will format "0" anyway but an arg is needed */
#endif
        return apr_psprintf(r->pool,
#if APR_MAJOR_VERSION > 1 || (APR_MAJOR_VERSION == 1 && APR_MINOR_VERSION >= 2)
                            /* APR can format a thread id in hex */
                            *a == 'h' ? "%pt" : "%pT",
#else
                            /* APR is missing the feature, so always use decimal */
                            "%pT",
#endif
                            &tid);
    }
    /* bogus format */
    return a;
}

static const char *log_connection_status(request_rec *r, char *a)
{
    if (r->connection->aborted)
        return "X";

    if (r->connection->keepalive == AP_CONN_KEEPALIVE &&
        (!r->server->keep_alive_max ||
         (r->server->keep_alive_max - r->connection->keepalives) > 0)) {
        return "+";
    }
    return "-";
}

static const char *log_requests_on_connection(request_rec *r, char *a)
{
    int num = r->connection->keepalives ? r->connection->keepalives - 1 : 0;
    return apr_itoa(r->pool, num);
}

/*****************************************************************
 *
 * Parsing the log format string
 */

static char *parse_log_misc_string(apr_pool_t *p, log_format_item *it,
                                   const char **sa)
{
    const char *s;
    char *d;

    it->func = constant_item;
    it->conditions = NULL;

    s = *sa;
    while (*s && *s != '%') {
        s++;
    }
    /*
     * This might allocate a few chars extra if there's a backslash
     * escape in the format string.
     */
    it->arg = apr_palloc(p, s - *sa + 1);

    d = it->arg;
    s = *sa;
    while (*s && *s != '%') {
        if (*s != '\\') {
            *d++ = *s++;
        }
        else {
            s++;
            switch (*s) {
            case '\\':
                *d++ = '\\';
                s++;
                break;
            case 'r':
                *d++ = '\r';
                s++;
                break;
            case 'n':
                *d++ = '\n';
                s++;
                break;
            case 't':
                *d++ = '\t';
                s++;
                break;
            default:
                /* copy verbatim */
                *d++ = '\\';
                /*
                 * Allow the loop to deal with this *s in the normal
                 * fashion so that it handles end of string etc.
                 * properly.
                 */
                break;
            }
        }
    }
    *d = '\0';

    *sa = s;
    return NULL;
}

static char *parse_log_item(apr_pool_t *p, log_format_item *it, const char **sa)
{
    const char *s = *sa;
    ap_log_handler *handler;

    if (*s != '%') {
        return parse_log_misc_string(p, it, sa);
    }

    ++s;
    it->condition_sense = 0;
    it->conditions = NULL;

    if (*s == '%') {
        it->arg = "%";
        it->func = constant_item;
        *sa = ++s;

        return NULL;
    }

    it->want_orig = -1;
    it->arg = "";               /* For safety's sake... */

    while (*s) {
        int i;

        switch (*s) {
        case '!':
            ++s;
            it->condition_sense = !it->condition_sense;
            break;

        case '<':
            ++s;
            it->want_orig = 1;
            break;

        case '>':
            ++s;
            it->want_orig = 0;
            break;

        case ',':
            ++s;
            break;

        case '{':
            ++s;
            it->arg = ap_getword(p, &s, '}');
            break;

        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            i = *s - '0';
            while (apr_isdigit(*++s)) {
                i = i * 10 + (*s) - '0';
            }
            if (!it->conditions) {
                it->conditions = apr_array_make(p, 4, sizeof(int));
            }
            *(int *) apr_array_push(it->conditions) = i;
            break;

        default:
            handler = (ap_log_handler *)apr_hash_get(log_hash, s++, 1);
            if (!handler) {
                char dummy[2];

                dummy[0] = s[-1];
                dummy[1] = '\0';
                return apr_pstrcat(p, "Unrecognized LogFormat directive %",
                               dummy, NULL);
            }
            it->func = handler->func;
            if (it->want_orig == -1) {
                it->want_orig = handler->want_orig_default;
            }
            *sa = s;
            return NULL;
        }
    }

    return "Ran off end of LogFormat parsing args to some directive";
}

static apr_array_header_t *parse_log_string(apr_pool_t *p, const char *s, const char **err)
{
    apr_array_header_t *a = apr_array_make(p, 30, sizeof(log_format_item));
    char *res;

    while (*s) {
        if ((res = parse_log_item(p, (log_format_item *) apr_array_push(a), &s))) {
            *err = res;
            return NULL;
        }
    }

    s = APR_EOL_STR;
    parse_log_item(p, (log_format_item *) apr_array_push(a), &s);
    return a;
}

/*****************************************************************
 *
 * Actually logging.
 */

static const char *process_item(request_rec *r, request_rec *orig,
                          log_format_item *item)
{
    const char *cp;

    /* First, see if we need to process this thing at all... */

    if (item->conditions && item->conditions->nelts != 0) {
        int i;
        int *conds = (int *) item->conditions->elts;
        int in_list = 0;

        for (i = 0; i < item->conditions->nelts; ++i) {
            if (r->status == conds[i]) {
                in_list = 1;
                break;
            }
        }

        if ((item->condition_sense && in_list)
            || (!item->condition_sense && !in_list)) {
            return "-";
        }
    }

    /* We do.  Do it... */

    cp = (*item->func) (item->want_orig ? orig : r, item->arg);
    return cp ? cp : "-";
}

static void flush_log(buffered_log *buf)
{
    if (buf->outcnt && buf->handle != NULL) {
        /* XXX: error handling */
        apr_file_write_full(buf->handle, buf->outbuf, buf->outcnt, NULL);
        buf->outcnt = 0;
    }
}


static int config_log_transaction(request_rec *r, config_log_state *cls,
                                  apr_array_header_t *default_format)
{
    log_format_item *items;
    const char **strs;
    int *strl;
    request_rec *orig;
    int i;
    apr_size_t len = 0;
    apr_array_header_t *format;
    char *envar;
    apr_status_t rv;

    if (cls->fname == NULL) {
        return DECLINED;
    }

    /*
     * See if we've got any conditional envariable-controlled logging decisions
     * to make.
     */
    if (cls->condition_var != NULL) {
        envar = cls->condition_var;
        if (*envar != '!') {
            if (apr_table_get(r->subprocess_env, envar) == NULL) {
                return DECLINED;
            }
        }
        else {
            if (apr_table_get(r->subprocess_env, &envar[1]) != NULL) {
                return DECLINED;
            }
        }
    }
    else if (cls->condition_expr != NULL) {
        const char *err;
        int rc = ap_expr_exec(r, cls->condition_expr, &err);
        if (rc < 0)
            ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(00644)
                           "Error evaluating log condition: %s", err);
        if (rc <= 0)
            return DECLINED;
    }

    format = cls->format ? cls->format : default_format;

    strs = apr_palloc(r->pool, sizeof(char *) * (format->nelts));
    strl = apr_palloc(r->pool, sizeof(int) * (format->nelts));
    items = (log_format_item *) format->elts;

    orig = r;
    while (orig->prev) {
        orig = orig->prev;
    }
    while (r->next) {
        r = r->next;
    }

    for (i = 0; i < format->nelts; ++i) {
        strs[i] = process_item(r, orig, &items[i]);
    }

    for (i = 0; i < format->nelts; ++i) {
        len += strl[i] = strlen(strs[i]);
    }
    if (!log_writer) {
        ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(00645)
                "log writer isn't correctly setup");
         return HTTP_INTERNAL_SERVER_ERROR;
    }
    rv = log_writer(r, cls->log_writer, strs, strl, format->nelts, len);
    if (rv != APR_SUCCESS)
        ap_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, APLOGNO(00646) "Error writing to %s",
                      cls->fname);
    return OK;
}

static int multi_log_transaction(request_rec *r)
{
    multi_log_state *mls = ap_get_module_config(r->server->module_config,
                                                &log_config_module);
    config_log_state *clsarray;
    int i;

    /*
     * Initialize per request state
     */
    log_request_state *state = apr_pcalloc(r->pool, sizeof(log_request_state));
    ap_set_module_config(r->request_config, &log_config_module, state);

    /*
     * Log this transaction..
     */
    if (mls->config_logs->nelts) {
        clsarray = (config_log_state *) mls->config_logs->elts;
        for (i = 0; i < mls->config_logs->nelts; ++i) {
            config_log_state *cls = &clsarray[i];

            config_log_transaction(r, cls, mls->default_format);
        }
    }

    if (mls->server_config_logs) {
        clsarray = (config_log_state *) mls->server_config_logs->elts;
        for (i = 0; i < mls->server_config_logs->nelts; ++i) {
            config_log_state *cls = &clsarray[i];

            if (cls->inherit || !mls->config_logs->nelts) {
                config_log_transaction(r, cls, mls->default_format);
            }
        }
    }

    return OK;
}

/*****************************************************************
 *
 * Module glue...
 */

static void *make_config_log_state(apr_pool_t *p, server_rec *s)
{
    multi_log_state *mls;

    mls = (multi_log_state *) apr_palloc(p, sizeof(multi_log_state));
    mls->config_logs = apr_array_make(p, 1, sizeof(config_log_state));
    mls->default_format_string = NULL;
    mls->default_format = NULL;
    mls->server_config_logs = NULL;
    mls->formats = apr_table_make(p, 4);
    apr_table_setn(mls->formats, "CLF", DEFAULT_LOG_FORMAT);

    return mls;
}

/*
 * Use the merger to simply add a pointer from the vhost log state
 * to the log of logs specified for the non-vhost configuration.  Make sure
 * vhosts inherit any globally-defined format names.
 */

static void *merge_config_log_state(apr_pool_t *p, void *basev, void *addv)
{
    multi_log_state *base = (multi_log_state *) basev;
    multi_log_state *add = (multi_log_state *) addv;

    add->server_config_logs = base->config_logs;
    if (!add->default_format) {
        add->default_format_string = base->default_format_string;
        add->default_format = base->default_format;
    }
    add->formats = apr_table_overlay(p, base->formats, add->formats);

    return add;
}

/*
 * Set the default logfile format, or define a nickname for a format string.
 */
static const char *log_format(cmd_parms *cmd, void *dummy, const char *fmt,
                              const char *name)
{
    const char *err_string = NULL;
    multi_log_state *mls = ap_get_module_config(cmd->server->module_config,
                                                &log_config_module);

    /*
     * If we were given two arguments, the second is a name to be given to the
     * format.  This syntax just defines the nickname - it doesn't actually
     * make the format the default.
     */
    if (name != NULL) {
        parse_log_string(cmd->pool, fmt, &err_string);
        if (err_string == NULL) {
            apr_table_setn(mls->formats, name, fmt);
        }
    }
    else {
        mls->default_format_string = fmt;
        mls->default_format = parse_log_string(cmd->pool, fmt, &err_string);
    }
    return err_string;
}


static const char *add_custom_log(cmd_parms *cmd, void *dummy, const char *fn,
                                  const char *fmt, const char *envclause)
{
    const char *err_string = NULL;
    multi_log_state *mls = ap_get_module_config(cmd->server->module_config,
                                                &log_config_module);
    config_log_state *cls;

    cls = (config_log_state *) apr_array_push(mls->config_logs);
    cls->condition_var = NULL;
    cls->condition_expr = NULL;
    if (envclause != NULL) {
        if (strncasecmp(envclause, "env=", 4) == 0) {
            if ((envclause[4] == '\0')
                || ((envclause[4] == '!') && (envclause[5] == '\0'))) {
                return "missing environment variable name";
            }
            cls->condition_var = apr_pstrdup(cmd->pool, &envclause[4]);
        }
        else if (strncasecmp(envclause, "expr=", 5) == 0) {
            const char *err;
            if ((envclause[5] == '\0'))
                return "missing condition";
            cls->condition_expr = ap_expr_parse_cmd(cmd, &envclause[5],
                                                    AP_EXPR_FLAG_DONT_VARY,
                                                    &err, NULL);
            if (err)
                return err;
        }
        else {
            return "error in condition clause";
        }
    }

    cls->fname = fn;
    cls->format_string = fmt;
    cls->directive = cmd->directive;
    if (fmt == NULL) {
        cls->format = NULL;
    }
    else {
        cls->format = parse_log_string(cmd->pool, fmt, &err_string);
    }
    cls->log_writer = NULL;

    return err_string;
}

static const char *add_global_log(cmd_parms *cmd, void *dummy, const char *fn,
                                  const char *fmt, const char *envclause) {
    multi_log_state *mls = ap_get_module_config(cmd->server->module_config,
                                                &log_config_module);
    config_log_state *clsarray;
    config_log_state *cls;
    const char *ret;

    const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);

    if (err) {
        return err;
    }

    /* Add a custom log through the normal channel */
    ret = add_custom_log(cmd, dummy, fn, fmt, envclause);

    /* Set the inherit flag unless there was some error */
    if (ret == NULL) {
        clsarray = (config_log_state*)mls->config_logs->elts;
        cls = &clsarray[mls->config_logs->nelts-1];
        cls->inherit = 1;
    }

    return ret;
}

static const char *set_transfer_log(cmd_parms *cmd, void *dummy,
                                    const char *fn)
{
    return add_custom_log(cmd, dummy, fn, NULL, NULL);
}

static const char *set_buffered_logs_on(cmd_parms *parms, void *dummy, int flag)
{
    buffered_logs = flag;
    if (buffered_logs) {
        ap_log_set_writer_init(ap_buffered_log_writer_init);
        ap_log_set_writer(ap_buffered_log_writer);
    }
    else {
        ap_log_set_writer_init(ap_default_log_writer_init);
        ap_log_set_writer(ap_default_log_writer);
    }
    return NULL;
}
static const command_rec config_log_cmds[] =
{
AP_INIT_TAKE23("CustomLog", add_custom_log, NULL, RSRC_CONF,
     "a file name, a custom log format string or format name, "
     "and an optional \"env=\" or \"expr=\" clause (see docs)"),
AP_INIT_TAKE23("GlobalLog", add_global_log, NULL, RSRC_CONF,
     "Same as CustomLog, but forces virtualhosts to inherit the log"),
AP_INIT_TAKE1("TransferLog", set_transfer_log, NULL, RSRC_CONF,
     "the filename of the access log"),
AP_INIT_TAKE12("LogFormat", log_format, NULL, RSRC_CONF,
     "a log format string (see docs) and an optional format name"),
AP_INIT_FLAG("BufferedLogs", set_buffered_logs_on, NULL, RSRC_CONF,
                 "Enable Buffered Logging (experimental)"),
    {NULL}
};

static config_log_state *open_config_log(server_rec *s, apr_pool_t *p,
                                         config_log_state *cls,
                                         apr_array_header_t *default_format)
{
    if (cls->log_writer != NULL) {
        return cls;             /* virtual config shared w/main server */
    }

    if (cls->fname == NULL) {
        return cls;             /* Leave it NULL to decline.  */
    }

    cls->log_writer = log_writer_init(p, s, cls->fname);
    if (cls->log_writer == NULL)
        return NULL;

    return cls;
}

static int open_multi_logs(server_rec *s, apr_pool_t *p)
{
    int i;
    multi_log_state *mls = ap_get_module_config(s->module_config,
                                             &log_config_module);
    config_log_state *clsarray;
    const char *dummy;
    const char *format;

    if (mls->default_format_string) {
        format = apr_table_get(mls->formats, mls->default_format_string);
        if (format) {
            mls->default_format = parse_log_string(p, format, &dummy);
        }
    }

    if (!mls->default_format) {
        mls->default_format = parse_log_string(p, DEFAULT_LOG_FORMAT, &dummy);
    }

    if (mls->config_logs->nelts) {
        clsarray = (config_log_state *) mls->config_logs->elts;
        for (i = 0; i < mls->config_logs->nelts; ++i) {
            config_log_state *cls = &clsarray[i];

            if (cls->format_string) {
                format = apr_table_get(mls->formats, cls->format_string);
                if (format) {
                    cls->format = parse_log_string(p, format, &dummy);
                }
            }

            if (!open_config_log(s, p, cls, mls->default_format)) {
                /* Failure already logged by open_config_log */
                return DONE;
            }
        }
    }
    else if (mls->server_config_logs) {
        clsarray = (config_log_state *) mls->server_config_logs->elts;
        for (i = 0; i < mls->server_config_logs->nelts; ++i) {
            config_log_state *cls = &clsarray[i];

            if (cls->format_string) {
                format = apr_table_get(mls->formats, cls->format_string);
                if (format) {
                    cls->format = parse_log_string(p, format, &dummy);
                }
            }

            if (!open_config_log(s, p, cls, mls->default_format)) {
                /* Failure already logged by open_config_log */
                return DONE;
            }
        }
    }

    return OK;
}


static apr_status_t flush_all_logs(void *data)
{
    server_rec *s = data;
    multi_log_state *mls;
    apr_array_header_t *log_list;
    config_log_state *clsarray;
    buffered_log *buf;
    int i;

    if (!buffered_logs)
        return APR_SUCCESS;

    for (; s; s = s->next) {
        mls = ap_get_module_config(s->module_config, &log_config_module);
        log_list = NULL;
        if (mls->config_logs->nelts) {
            log_list = mls->config_logs;
        }
        else if (mls->server_config_logs) {
            log_list = mls->server_config_logs;
        }
        if (log_list) {
            clsarray = (config_log_state *) log_list->elts;
            for (i = 0; i < log_list->nelts; ++i) {
                buf = clsarray[i].log_writer;
                flush_log(buf);
            }
        }
    }
    return APR_SUCCESS;
}


static int init_config_log(apr_pool_t *pc, apr_pool_t *p, apr_pool_t *pt, server_rec *s)
{
    int res;

    /* First init the buffered logs array, which is needed when opening the logs. */
    if (buffered_logs) {
        all_buffered_logs = apr_array_make(p, 5, sizeof(buffered_log *));
    }

    /* Next, do "physical" server, which gets default log fd and format
     * for the virtual servers, if they don't override...
     */
    res = open_multi_logs(s, p);

    /* Then, virtual servers */

    for (s = s->next; (res == OK) && s; s = s->next) {
        res = open_multi_logs(s, p);
    }

    return res;
}

static void init_child(apr_pool_t *p, server_rec *s)
{
    int mpm_threads;

    ap_mpm_query(AP_MPMQ_MAX_THREADS, &mpm_threads);

    /* Now register the last buffer flush with the cleanup engine */
    if (buffered_logs) {
        int i;
        buffered_log **array = (buffered_log **)all_buffered_logs->elts;

        apr_pool_cleanup_register(p, s, flush_all_logs, flush_all_logs);

        for (i = 0; i < all_buffered_logs->nelts; i++) {
            buffered_log *this = array[i];

#if APR_HAS_THREADS
            if (mpm_threads > 1) {
                apr_status_t rv;

                this->mutex.type = apr_anylock_threadmutex;
                rv = apr_thread_mutex_create(&this->mutex.lock.tm,
                                             APR_THREAD_MUTEX_DEFAULT,
                                             p);
                if (rv != APR_SUCCESS) {
                    ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s, APLOGNO(00647)
                                 "could not initialize buffered log mutex, "
                                 "transfer log may become corrupted");
                    this->mutex.type = apr_anylock_none;
                }
            }
            else
#endif
            {
                this->mutex.type = apr_anylock_none;
            }
        }
    }
}

static void ap_register_log_handler(apr_pool_t *p, char *tag,
                                    ap_log_handler_fn_t *handler, int def)
{
    ap_log_handler *log_struct = apr_palloc(p, sizeof(*log_struct));
    log_struct->func = handler;
    log_struct->want_orig_default = def;

    apr_hash_set(log_hash, tag, 1, (const void *)log_struct);
}
static ap_log_writer_init *ap_log_set_writer_init(ap_log_writer_init *handle)
{
    ap_log_writer_init *old = log_writer_init;
    log_writer_init = handle;

    return old;

}
static ap_log_writer *ap_log_set_writer(ap_log_writer *handle)
{
    ap_log_writer *old = log_writer;
    log_writer = handle;

    return old;
}

static apr_status_t ap_default_log_writer( request_rec *r,
                           void *handle,
                           const char **strs,
                           int *strl,
                           int nelts,
                           apr_size_t len)

{
    char *str;
    char *s;
    int i;
    apr_status_t rv;

    /*
     * We do this memcpy dance because write() is atomic for len < PIPE_BUF,
     * while writev() need not be.
     */
    str = apr_palloc(r->pool, len + 1);

    for (i = 0, s = str; i < nelts; ++i) {
        memcpy(s, strs[i], strl[i]);
        s += strl[i];
    }

    rv = apr_file_write_full((apr_file_t*)handle, str, len, NULL);

    return rv;
}
static void *ap_default_log_writer_init(apr_pool_t *p, server_rec *s,
                                        const char* name)
{
    if (*name == '|') {
        piped_log *pl;

        pl = ap_open_piped_log(p, name + 1);
        if (pl == NULL) {
           return NULL;
        }
        return ap_piped_log_write_fd(pl);
    }
    else {
        const char *fname = ap_server_root_relative(p, name);
        apr_file_t *fd;
        apr_status_t rv;

        if (!fname) {
            ap_log_error(APLOG_MARK, APLOG_ERR, APR_EBADPATH, s, APLOGNO(00648)
                            "invalid transfer log path %s.", name);
            return NULL;
        }
        rv = apr_file_open(&fd, fname, xfer_flags, xfer_perms, p);
        if (rv != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00649)
                            "could not open transfer log file %s.", fname);
            return NULL;
        }
        return fd;
    }
}
static void *ap_buffered_log_writer_init(apr_pool_t *p, server_rec *s,
                                        const char* name)
{
    buffered_log *b;
    b = apr_pcalloc(p, sizeof(buffered_log));
    b->handle = ap_default_log_writer_init(p, s, name);

    if (b->handle) {
        *(buffered_log **)apr_array_push(all_buffered_logs) = b;
        return b;
    }
    else
        return NULL;
}
static apr_status_t ap_buffered_log_writer(request_rec *r,
                                           void *handle,
                                           const char **strs,
                                           int *strl,
                                           int nelts,
                                           apr_size_t len)

{
    char *str;
    char *s;
    int i;
    apr_status_t rv;
    buffered_log *buf = (buffered_log*)handle;

    if ((rv = APR_ANYLOCK_LOCK(&buf->mutex)) != APR_SUCCESS) {
        return rv;
    }

    if (len + buf->outcnt > LOG_BUFSIZE) {
        flush_log(buf);
    }
    if (len >= LOG_BUFSIZE) {
        apr_size_t w;

        /*
         * We do this memcpy dance because write() is atomic for
         * len < PIPE_BUF, while writev() need not be.
         */
        str = apr_palloc(r->pool, len + 1);
        for (i = 0, s = str; i < nelts; ++i) {
            memcpy(s, strs[i], strl[i]);
            s += strl[i];
        }
        w = len;
        rv = apr_file_write_full(buf->handle, str, w, NULL);

    }
    else {
        for (i = 0, s = &buf->outbuf[buf->outcnt]; i < nelts; ++i) {
            memcpy(s, strs[i], strl[i]);
            s += strl[i];
        }
        buf->outcnt += len;
        rv = APR_SUCCESS;
    }

    APR_ANYLOCK_UNLOCK(&buf->mutex);
    return rv;
}

static int log_pre_config(apr_pool_t *p, apr_pool_t *plog, apr_pool_t *ptemp)
{
    static APR_OPTIONAL_FN_TYPE(ap_register_log_handler) *log_pfn_register;

    log_pfn_register = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_handler);

    if (log_pfn_register) {
        log_pfn_register(p, "h", log_remote_host, 0);
        log_pfn_register(p, "a", log_remote_address, 0 );
        log_pfn_register(p, "A", log_local_address, 0 );
        log_pfn_register(p, "l", log_remote_logname, 0);
        log_pfn_register(p, "u", log_remote_user, 0);
        log_pfn_register(p, "t", log_request_time, 0);
        log_pfn_register(p, "f", log_request_file, 0);
        log_pfn_register(p, "b", clf_log_bytes_sent, 0);
        log_pfn_register(p, "B", log_bytes_sent, 0);
        log_pfn_register(p, "i", log_header_in, 0);
        log_pfn_register(p, "o", log_header_out, 0);
        log_pfn_register(p, "n", log_note, 0);
        log_pfn_register(p, "L", log_log_id, 1);
        log_pfn_register(p, "e", log_env_var, 0);
        log_pfn_register(p, "V", log_server_name, 0);
        log_pfn_register(p, "v", log_virtual_host, 0);
        log_pfn_register(p, "p", log_server_port, 0);
        log_pfn_register(p, "P", log_pid_tid, 0);
        log_pfn_register(p, "H", log_request_protocol, 0);
        log_pfn_register(p, "m", log_request_method, 0);
        log_pfn_register(p, "q", log_request_query, 0);
        log_pfn_register(p, "X", log_connection_status, 0);
        log_pfn_register(p, "C", log_cookie, 0);
        log_pfn_register(p, "k", log_requests_on_connection, 0);
        log_pfn_register(p, "r", log_request_line, 1);
        log_pfn_register(p, "D", log_request_duration_microseconds, 1);
        log_pfn_register(p, "T", log_request_duration, 1);
        log_pfn_register(p, "U", log_request_uri, 1);
        log_pfn_register(p, "s", log_status, 1);
        log_pfn_register(p, "R", log_handler, 1);
    }

    /* reset to default conditions */
    ap_log_set_writer_init(ap_default_log_writer_init);
    ap_log_set_writer(ap_default_log_writer);
    buffered_logs = 0;

    return OK;
}

static int check_log_dir(apr_pool_t *p, server_rec *s, config_log_state *cls)
{
    if (!cls->fname || cls->fname[0] == '|' || !cls->directive) {
        return OK;
    }
    else {
        char *abs = ap_server_root_relative(p, cls->fname);
        char *dir = ap_make_dirstr_parent(p, abs);
        apr_finfo_t finfo;
        const ap_directive_t *directive = cls->directive;
        apr_status_t rv = apr_stat(&finfo, dir, APR_FINFO_TYPE, p);
        cls->directive = NULL; /* Don't check this config_log_state again */
        if (rv == APR_SUCCESS && finfo.filetype != APR_DIR)
            rv = APR_ENOTDIR;
        if (rv != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_STARTUP|APLOG_EMERG, rv, s,
                         APLOGNO(02297)
                         "Cannot access directory '%s' for log file '%s' "
                         "defined at %s:%d", dir, cls->fname,
                         directive->filename, directive->line_num);
            return !OK;
        }
    }
    return OK;
}

static int log_check_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp, server_rec *s)
{
    int rv = OK;
    while (s) {
        multi_log_state *mls = ap_get_module_config(s->module_config,
                                                    &log_config_module);
        /*
         * We don't need to check mls->server_config_logs because it just
         * points to the parent server's mls->config_logs.
         */
        apr_array_header_t *log_list = mls->config_logs;
        config_log_state *clsarray = (config_log_state *) log_list->elts;
        int i;
        for (i = 0; i < log_list->nelts; ++i) {
            if (check_log_dir(ptemp, s, &clsarray[i]) != OK)
                rv = !OK;
        }

        s = s->next;
    }
    return rv;
}

static void register_hooks(apr_pool_t *p)
{
    ap_hook_pre_config(log_pre_config,NULL,NULL,APR_HOOK_REALLY_FIRST);
    ap_hook_check_config(log_check_config,NULL,NULL,APR_HOOK_MIDDLE);
    ap_hook_child_init(init_child,NULL,NULL,APR_HOOK_MIDDLE);
    ap_hook_open_logs(init_config_log,NULL,NULL,APR_HOOK_MIDDLE);
    ap_hook_log_transaction(multi_log_transaction,NULL,NULL,APR_HOOK_MIDDLE);

    /* Init log_hash before we register the optional function. It is
     * possible for the optional function, ap_register_log_handler,
     * to be called before any other mod_log_config hooks are called.
     * As a policy, we should init everything required by an optional function
     * before calling APR_REGISTER_OPTIONAL_FN.
     */
    log_hash = apr_hash_make(p);
    APR_REGISTER_OPTIONAL_FN(ap_register_log_handler);
    APR_REGISTER_OPTIONAL_FN(ap_log_set_writer_init);
    APR_REGISTER_OPTIONAL_FN(ap_log_set_writer);
}

AP_DECLARE_MODULE(log_config) =
{
    STANDARD20_MODULE_STUFF,
    NULL,                       /* create per-dir config */
    NULL,                       /* merge per-dir config */
    make_config_log_state,      /* server config */
    merge_config_log_state,     /* merge server config */
    config_log_cmds,            /* command apr_table_t */
    register_hooks              /* register hooks */
};