/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2000-2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* .
*
* Portions of this software are based upon public domain software
* originally written at the National Center for Supercomputing Applications,
* University of Illinois, Urbana-Champaign.
*/
/*
* Modified by djm@va.pubnix.com:
* If no TransferLog is given explicitly, decline to log.
*
* Modified by st:
* Added logic to give other log writers a more detailed view of the
* data to be logged.
* Added item %R, which returns the unmodified URL (this is not %U).
*
* This module implements the TransferLog directive (same as the
* common log module), and additional directives, LogFormat and CustomLog.
*
*
* Syntax:
*
* TransferLog fn Logs transfers to fn in standard log format, unless
* a custom format is set with LogFormat
* LogFormat format Set a log format from TransferLog files
* CustomLog fn format
* Log to fn with format given by the format
* argument
*
* CookieLog fn For backwards compatability with old Cookie
* logging module - now deprecated.
*
* fn is a URL-like descriptor of the form "writer:path". The exact format
* of "path" depends on the log writer to use.
* This module implements two default log writers, "file" and "pipe".
*
* For backwards compatibility: fn may also be a simple filesystem path
* without the "writer:"-part, and possibly prepended by a | to indicate
* logging into a pipe. These fn will be handled by the build-in file or
* pipe log writer.
* Furthermore, if a "writer:"-part exists in fn but no matching log writer
* was found, this module will fall back to log into a file named [fn]. In
* other words: No error will be posted upon missing log writer, the default
* file log writer will be used.
*
* There can be any number of TransferLog and CustomLog
* commands. Each request will be logged to _ALL_ the
* named files, in the appropriate format.
*
* If no TransferLog or CustomLog directive appears in a VirtualHost,
* the request will be logged to the log file(s) defined outside
* the virtual host section. If a TransferLog or CustomLog directive
* appears in the VirtualHost section, the log files defined outside
* the VirtualHost will _not_ be used. This makes this module compatable
* with the CLF and config log modules, where the use of TransferLog
* inside the VirtualHost section overrides its use outside.
*
* Examples:
*
* TransferLog file:logs/access_log
*
* LogFormat "... custom format ..."
* TransferLog file:log/virtual_only
* CustomLog file:log/virtual_useragents "%t %{user-agent}i"
*
*
* This will log using CLF to access_log any requests handled by the
* main server, while any requests to the virtual host will be logged
* with the "... custom format..." to virtual_only _AND_ using
* the custom user-agent log to virtual_useragents.
*
* Note that the NCSA referer and user-agent logs are easily added with
* CustomLog:
* CustomLog file:logs/referer "%{referer}i -> %U"
* CustomLog file:logs/agent "%{user-agent}i"
*
* RefererIgnore functionality can be obtained with conditional
* logging (SetEnvIf and CustomLog ... env=!VAR).
*
* But using this method allows much easier modification of the
* log format, e.g. to log hosts along with UA:
* CustomLog file:logs/referer "%{referer}i %U %h"
*
* The argument to LogFormat and CustomLog is a string, which can include
* literal characters copied into the log files, and '%' directives as
* follows:
*
* %...B: bytes sent, excluding HTTP headers.
* %...b: bytes sent, excluding HTTP headers in CLF format, i.e. a '-'
* when no bytes where sent (rather than a '0'.
* %...{FOOBAR}C: The contents of the HTTP cookie FOOBAR
* %...{FOOBAR}e: The contents of the environment variable FOOBAR
* %...f: filename
* %...h: remote host
* %...a: remote IP-address
* %...A: local IP-address
* %...{Foobar}i: The contents of Foobar: header line(s) in the request
* sent to the client.
* %...l: remote logname (from identd, if supplied)
* %...{Foobar}n: The contents of note "Foobar" from another module.
* %...{Foobar}o: The contents of Foobar: header line(s) in the reply.
* %...p: the port the request was served to
* %...P: the process ID of the child that serviced the request.
* %...{format}P: the process ID (pid) or thread ID (tid) of the
* child/thread that serviced the request
* %...r: first line of request
* %...s: status. For requests that got internally redirected, this
* is status of the *original* request --- %...>s for the last.
* %...t: time, in common log format time format
* %...{format}t: The time, in the form given by format, which should
* be in strftime(3) format.
* %...T: the time taken to serve the request, in seconds.
* %...D: the time taken to serve the request, in micro seconds.
* %...u: remote user (from auth; may be bogus if return status (%s) is 401)
* %...U: the URL path requested.
* %...R: the URL requested, unmodified
* %...v: the configured name of the server (i.e. which virtual host?)
* %...V: the server name according to the UseCanonicalName setting
* %...m: the request method
* %...H: the request protocol
* %...q: the query string prepended by "?", or empty if no query string
* %...X: Status of the connection.
* 'X' = connection aborted before the response completed.
* '+' = connection may be kept alive after the response is sent.
* '-' = connection will be closed after the response is sent.
* (This directive was %...c in late versions of Apache 1.3, but
* this conflicted with the historical ssl %...{var}c syntax.)
*
* The '...' can be nothing at all (e.g. "%h %u %r %s %b"), or it can
* indicate conditions for inclusion of the item (which will cause it
* to be replaced with '-' if the condition is not met). Note that
* there is no escaping performed on the strings from %r, %...i and
* %...o; some with long memories may remember that I thought this was
* a bad idea, once upon a time, and I'm still not comfortable with
* it, but it is difficult to see how to "do the right thing" with all
* of '%..i', unless we URL-escape everything and break with CLF.
*
* The forms of condition are a list of HTTP status codes, which may
* or may not be preceded by '!'. Thus, '%400,501{User-agent}i' logs
* User-agent: on 400 errors and 501 errors (Bad Request, Not
* Implemented) only; '%!200,304,302{Referer}i' logs Referer: on all
* requests which did *not* return some sort of normal status.
*
* The default LogFormat reproduces CLF; see below.
*
* The way this is supposed to work with virtual hosts is as follows:
* a virtual host can have its own LogFormat, or its own TransferLog.
* If it doesn't have its own LogFormat, it inherits from the main
* server. If it doesn't have its own TransferLog, it writes to the
* same descriptor (meaning the same process for "| ...").
*
* --- rst */
#include "apr_strings.h"
#include "apr_lib.h"
#include "apr_hash.h"
#include "apr_optional.h"
#define APR_WANT_STRFUNC
#include "apr_want.h"
#include "ap_config.h"
#include "mod_log_config.h"
#include "httpd.h"
#include "http_config.h"
#include "http_core.h" /* For REMOTE_NAME */
#include "http_log.h"
#include "http_protocol.h"
#include "util_time.h"
#if APR_HAVE_UNISTD_H
#include
#endif
#ifdef HAVE_LIMITS_H
#include
#endif
#define DEFAULT_LOG_FORMAT "%h %l %u %t \"%r\" %>s %b"
module AP_MODULE_DECLARE_DATA log_config_module;
static int xfer_flags = (APR_WRITE | APR_APPEND | APR_CREATE);
static apr_fileperms_t xfer_perms = APR_OS_DEFAULT;
typedef struct {
union {
ap_log_handler_fn_t *func;
ap_log_ehandler_fn_t *efunc;
} handler;
int oldstyle;
int want_orig_default;
} log_handler;
static apr_hash_t *log_hash;
typedef struct {
ap_log_ewriter_setup *setup;
ap_log_ewriter *write;
ap_log_ewriter_init *init;
ap_log_ewriter_exit *exit;
} log_ewriter;
static apr_hash_t *writer_hash;
static void *ap_old_log_writer_init(apr_pool_t *p, server_rec *s,
const char* name);
static apr_status_t ap_filepipe_log_ewriter(request_rec *r,
void *handle,
apr_array_header_t *data);
static ap_log_writer *log_writer = NULL;
static ap_log_writer_init *log_writer_init = NULL;
static int buffered_logs = 0; /* default unbuffered */
/* POSIX.1 defines PIPE_BUF as the maximum number of bytes that is
* guaranteed to be atomic when writing a pipe. And PIPE_BUF >= 512
* is guaranteed. So we'll just guess 512 in the event the system
* 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.
* writer_data is NULL before the log file is opened and is
* set to an opaque structure (usually a fd) after it is opened.
*/
typedef struct {
apr_file_t *handle;
apr_size_t outcnt;
char outbuf[LOG_BUFSIZE];
} buffered_log;
typedef struct {
const char *fname;
const char *format_string;
apr_array_header_t *format;
log_ewriter *writer;
void *writer_data;
int condition_sense;
char *condition_var;
apr_array_header_t *conditions;
} config_log_state;
/*
* Format items...
* Note that many of these could have ap_sprintfs replaced with static buffers.
*/
typedef struct {
log_handler *handler;
char *arg;
int condition_sense;
int want_orig;
apr_array_header_t *conditions;
} log_format_item;
static void *constant_item(request_rec *r, char *stuff, ap_log_ehandler_data *d)
{
d->data=stuff;
d->arg=NULL;
d->type=AP_LOG_EHANDLER_RETURN_CONST;
}
static void *log_remote_host(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=(void *) ap_get_remote_host(r->connection,
r->per_dir_config,
REMOTE_NAME, NULL);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_remote_address(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=r->connection->remote_ip;
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_local_address(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=r->connection->local_ip;
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_remote_logname(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=(void *) ap_get_remote_logname(r);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_remote_user(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->user;
d->type=AP_LOG_EHANDLER_RETURN_STRING;
/*
if (d->data == NULL) {
rvalue = "-";
}
else if (strlen(d->data) == 0) {
rvalue = "\"\"";
}
else {
rvalue = ap_escape_logitem(r->pool, rvalue);
}
*/
}
static void *log_request_line(request_rec *r, char *a, ap_log_ehandler_data *d)
{
/* 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)
*/
d->data = (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;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_request_file(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->filename;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_request_uri(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->uri;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_unparsed_request_uri(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->unparsed_uri;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_request_method(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = (void *)r->method;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_request_protocol(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->protocol;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_request_query(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (r->args)
d->data=apr_pstrcat(r->pool, "?", r->args, NULL);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_status(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (r->status > 0) {
d->data=apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data)=r->status;
}
d->type=AP_LOG_EHANDLER_RETURN_UNUMBER;
}
static void *clf_log_bytes_sent(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (!r->sent_bodyct || !r->bytes_sent) {
d->data="-";
}
else {
d->data=apr_off_t_toa(r->pool, r->bytes_sent);
}
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_bytes_sent(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (r->header_only == 0) {
d->data=apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data)=r->bytes_sent;
}
d->type=AP_LOG_EHANDLER_RETURN_UNUMBER;
}
static void *log_header_in(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=(void *) apr_table_get(r->headers_in, a);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_header_out(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (!strcasecmp(a, "Content-type") && r->content_type)
d->data = ap_field_noparam(r->pool, r->content_type);
else
d->data = (void *) apr_table_get(r->headers_out, a);
if (! d->data)
d->data = (void *) apr_table_get(r->err_headers_out, a);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_note(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = (void *) apr_table_get(r->notes, a);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_env_var(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = (void *) apr_table_get(r->subprocess_env, a);
d->type=AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_cookie(request_rec *r, char *a, ap_log_ehandler_data *d)
{
const char *cookies;
const char *start_cookie;
d->type=AP_LOG_EHANDLER_RETURN_STRING;
if ((cookies = apr_table_get(r->headers_in, "Cookie"))) {
if ((start_cookie = ap_strstr_c(cookies,a))) {
char *cookie, *end_cookie;
start_cookie += strlen(a) + 1; /* cookie_name + '=' */
cookie = apr_pstrdup(r->pool, start_cookie);
/* kill everything in cookie after ';' */
end_cookie = strchr(cookie, ';');
if (end_cookie) {
*end_cookie = '\0';
}
d->data=cookie;
}
}
}
static void *log_request_time(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->type=AP_LOG_EHANDLER_RETURN_DATETIME;
d->data=apr_palloc(r->pool,sizeof(apr_time_t));
#ifdef I_INSIST_ON_EXTRA_CYCLES_FOR_CLF_COMPLIANCE
*((apr_time_t *) d->data) = apr_time_now();
#else
*((apr_time_t *) d->data) = r->request_time;
#endif
}
static void *log_request_duration(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data) = apr_time_sec(apr_time_now() - r->request_time);
d->arg=a;
d->type=AP_LOG_EHANDLER_RETURN_UNUMBER;
}
static void *log_request_duration_microseconds(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data) = apr_time_now() - r->request_time;
d->arg=a;
d->type=AP_LOG_EHANDLER_RETURN_UNUMBER;
}
/* These next two routines use the canonical name:port so that log
* parsers don't need to duplicate all the vhost parsing crud.
*/
static void *log_virtual_host(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = r->server->server_hostname;
d->arg=a;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_server_port(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data=apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data) = r->server->port ? r->server->port : ap_default_port(r);
d->arg=a;
d->type=AP_LOG_EHANDLER_RETURN_UNUMBER;
}
/* This respects the setting of UseCanonicalName so that
* the dynamic mass virtual hosting trick works better.
*/
static void *log_server_name(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->data = (void *) ap_get_server_name(r);
d->arg=a;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
static void *log_pid_tid(request_rec *r, char *a, ap_log_ehandler_data *d)
{
d->arg=a;
if (!a || *a == '\0' || !strcmp(a, "pid")) {
d->data = apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data) = getpid();
}
#if APR_HAS_THREADS
else if (!strcmp(a, "tid")) {
d->data = apr_palloc(r->pool,sizeof(ap_log_unumber_t));
*((ap_log_unumber_t *) d->data) = apr_os_thread_current();
}
#endif
d->type = AP_LOG_EHANDLER_RETURN_UNUMBER;
}
static void *log_connection_status(request_rec *r, char *a, ap_log_ehandler_data *d)
{
if (r->connection->aborted)
d->data = "X";
else if (r->connection->keepalive == AP_CONN_KEEPALIVE &&
(!r->server->keep_alive_max ||
(r->server->keep_alive_max - r->connection->keepalives) > 0))
d->data = "+";
else
d->data = "-";
d->arg=a;
d->type = AP_LOG_EHANDLER_RETURN_STRING;
}
/*****************************************************************
*
* 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->handler = (log_handler *)apr_hash_get(log_hash, "%", 1);
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;
if (*s != '%') {
return parse_log_misc_string(p, it, sa);
}
++s;
it->condition_sense = 0;
it->conditions = NULL;
if (*s == '%') {
it->arg = "%";
it->handler = (log_handler *)apr_hash_get(log_hash, "%", 1);
*sa = ++s;
return NULL;
}
it->want_orig = -1;
it->arg = NULL; /* 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:
it->handler = (log_handler *)apr_hash_get(log_hash, s++, 1);
if (!it->handler) {
char dummy[2];
dummy[0] = s[-1];
dummy[1] = '\0';
return apr_pstrcat(p, "Unrecognized LogFormat directive %",
dummy, NULL);
}
if (it->want_orig == -1) {
it->want_orig = it->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;
}
}
return a;
}
/*****************************************************************
*
* Actually logging.
*/
static const char *format_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_CACHE_SIZE 4
#define TIME_CACHE_MASK 3
static cached_request_time request_time_cache[TIME_CACHE_SIZE];
static const char *format_request_time(request_rec *r, char *a, apr_time_t *t, cached_request_time *cache)
{
apr_time_exp_t xt;
/* ### I think getting the time again at the end of the request
* just for logging is dumb. i know it's "required" for CLF.
* folks writing log parsing tools don't realise that out of order
* times have always been possible (consider what happens if one
* process calculates the time to log, but then there's a context
* switch before it writes and before that process is run again the
* log rotation occurs) and they should just fix their tools rather
* than force the server to pay extra cpu cycles. if you've got
* a problem with this, you can set the define. -djg
*/
if (a && *a) { /* 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.)
*/
#ifdef I_INSIST_ON_EXTRA_CYCLES_FOR_CLF_COMPLIANCE
ap_explode_recent_localtime(&xt, apr_time_now());
#else
ap_explode_recent_localtime(&xt, *t);
#endif
return format_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));
#ifdef I_INSIST_ON_EXTRA_CYCLES_FOR_CLF_COMPLIANCE
apr_time_t request_time = apr_time_now();
#else
apr_time_t request_time = *t;
#endif
unsigned t_seconds = (unsigned)apr_time_sec(request_time);
unsigned i = t_seconds & TIME_CACHE_MASK;
memcpy(cached_time, &(request_time_cache[i]), sizeof(*cached_time));
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, *t);
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));
cached_time->t_validate = t_seconds;
memcpy(&(request_time_cache[i]), cached_time,
sizeof(*cached_time));
}
return cached_time->timestr;
}
}
static void process_item(request_rec *r, request_rec *orig,
log_format_item *item,
ap_log_ehandler_data *d)
{
/* 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)) {
d->type=AP_LOG_EHANDLER_RETURN_STRING;
return;
}
}
/* We do. Do it... */
if (item->handler->oldstyle) {
if (! (d->data = (void *)(*item->handler->handler.func) (item->want_orig ? orig : r, item->arg)))
d->data = "-";
d->type = AP_LOG_EHANDLER_RETURN_OLDSTYLE;
}
else {
(*item->handler->handler.efunc) (item->want_orig ? orig : r, item->arg, d);
}
}
static void flush_log(buffered_log *buf)
{
if (buf->outcnt && buf->handle != NULL) {
apr_file_write(buf->handle, buf->outbuf, &buf->outcnt);
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;
apr_status_t rv;
apr_array_header_t *data;
ap_log_ehandler_data *d;
if (cls->fname == NULL) {
return DECLINED;
}
/*
* See if we've got any conditional envariable-controlled logging decisions
* to make.
*/
if (cls->condition_var != NULL) {
if ((cls->condition_sense && apr_table_get(r->subprocess_env, cls->condition_var) != NULL)
||
(!cls->condition_sense && apr_table_get(r->subprocess_env, cls->condition_var) == NULL))
{
return DECLINED;
}
}
orig = r;
while (orig->prev) {
orig = orig->prev;
}
while (r->next) {
r = r->next;
}
if (cls->conditions && cls->conditions->nelts != 0) {
int *conds = (int *) cls->conditions->elts;
int in_list = 0;
for (i = 0; i < cls->conditions->nelts; ++i) {
if (r->status == conds[i]) {
in_list = 1;
break;
}
}
if ((cls->condition_sense && in_list)
|| (!cls->condition_sense && !in_list)) {
return DECLINED;
}
}
format = cls->format ? cls->format : default_format;
data = apr_array_make(r->pool, format->nelts, sizeof(ap_log_ehandler_data));
items = (log_format_item *) format->elts;
for (i = 0; i < format->nelts; ++i) {
d = (ap_log_ehandler_data *) apr_array_push(data);
d->data = NULL;
d->arg = items[i].arg;
process_item(r, orig, &items[i], d);
}
if (cls->writer) { /* this is a new style writer */
rv = cls->writer->write(r, cls->writer_data, data);
}
else if (log_writer) { /* this is an old style writer */
strs = apr_palloc(r->pool, sizeof(char *) * (format->nelts));
strl = apr_palloc(r->pool, sizeof(int) * (format->nelts));
for (i = 0; i < data->nelts; ++i) {
d=&(((ap_log_ehandler_data*)(data->elts))[i]);
if ((d) && (d->data)) {
switch (d->type) {
case AP_LOG_EHANDLER_RETURN_OLDSTYLE:
strs[i] = d->data;
break;
case AP_LOG_EHANDLER_RETURN_CONST:
strs[i] = d->data;
break;
case AP_LOG_EHANDLER_RETURN_STRING:
if (strlen(d->data)==0)
strs[i] = "\"\"";
else
strs[i] = ap_escape_logitem(r->pool, d->data);
break;
case AP_LOG_EHANDLER_RETURN_NUMBER:
strs[i] = apr_psprintf(r->pool,"%" AP_LOG_NUMBER_T_FMT,*((ap_log_number_t *) d->data));
break;
case AP_LOG_EHANDLER_RETURN_UNUMBER:
strs[i] = apr_psprintf(r->pool,"%" AP_LOG_UNUMBER_T_FMT,*((ap_log_unumber_t *) d->data));
break;
case AP_LOG_EHANDLER_RETURN_DATETIME:
strs[i] = format_request_time(r,d->arg,d->data,NULL);
break;
}
}
else {
strs[i]="-";
}
}
for (i = 0; i < format->nelts; ++i) {
len += strl[i] = strlen(strs[i]);
}
rv = log_writer(r, cls->writer_data, strs, strl, format->nelts, len);
/* xxx: do we return an error on log_writer? */
}
else { /* no writer at all, use our file writer as default */
rv = ap_filepipe_log_ewriter(r, cls->writer_data, data);
}
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;
/*
* 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);
}
}
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];
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;
char *pos;
log_ewriter *writer;
int i;
cls = (config_log_state *) apr_array_push(mls->config_logs);
cls->condition_var = NULL;
cls->conditions = NULL;
if (envclause != NULL) {
if (strncasecmp(envclause, "env=", 4) == 0) {
i = 4;
if (cls->condition_sense = (envclause[i] == '!')) {
i++;
}
if (envclause[i] == '\0') {
return "missing environment variable name";
}
else {
cls->condition_var = apr_pstrdup(cmd->pool, &envclause[i]);
}
}
else if (strncasecmp(envclause, "status=", 7) == 0) {
i = 7;
if (cls->condition_sense = (envclause[i] == '!')) {
i++;
}
if (envclause[i] == '\0') {
return "missing status code(s)";
}
else {
pos = (char*)&envclause[i];
while (*pos) {
switch (*pos) {
case ',':
++pos;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
i = *pos - '0';
while (apr_isdigit(*++pos)) {
i = i * 10 + (*pos) - '0';
}
if (!cls->conditions) {
cls->conditions = apr_array_make(cmd->pool, 4, sizeof(int));
}
*(int *) apr_array_push(cls->conditions) = i;
break;
default:
return "illegal character within status code(s)";
}
}
}
}
else {
return "error in condition clause";
}
}
cls->fname = fn;
if ((pos = strchr(fn,':')) && (cls->writer = apr_hash_get(writer_hash, fn, pos-fn)) ) {
cls->fname=pos+1;
}
else {
cls->writer=NULL;
}
/* xxx Doesn't return an error if a key ("bla:/file") is given but no
* corresponding writer exists. The reason is backwards compatibility,
* to be able to fall back to the old file write mechanism -- but is
* this really necessary? Is there anybody (except fellow Amigans)
* who uses : in file system paths?
*/
cls->format_string = fmt;
if (fmt == NULL) {
cls->format = NULL;
}
else {
cls->format = parse_log_string(cmd->pool, fmt, &err_string);
}
cls->writer_data = NULL;
return err_string;
}
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_cookie_log(cmd_parms *cmd, void *dummy, const char *fn)
{
return add_custom_log(cmd, dummy, fn, "%{Cookie}n \"%r\" %t", NULL);
}
static const char *set_buffered_logs_on(cmd_parms *parms, void *dummy, int flag)
{
buffered_logs = flag;
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=\" clause (see docs)"),
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_TAKE1("CookieLog", set_cookie_log, NULL, RSRC_CONF,
"the filename of the cookie log"),
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->writer_data != NULL) {
return cls; /* virtual config shared w/main server */
}
if (cls->fname == NULL) {
return cls; /* Leave it NULL to decline. */
}
if (cls->writer) { /* new style style writer */
cls->writer_data = cls->writer->setup(p, s, cls->fname);
}
else if (log_writer_init) { /* old style writer */
cls->writer_data = log_writer_init(p, s, cls->fname);
}
else { /* default, takes care of old "|pipe" as well as simple "file" syntax */
cls->writer_data = ap_old_log_writer_init(p, s, cls->fname);
}
if (cls->writer_data == 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;
for (; s; s = s->next) {
mls = ap_get_module_config(s->module_config, &log_config_module);
if (mls->config_logs->nelts) {
log_list = mls->config_logs;
}
else if (mls->server_config_logs) {
log_list = mls->server_config_logs;
}
else {
log_list = NULL;
}
if (log_list) {
clsarray = (config_log_state *) log_list->elts;
for (i = 0; i < log_list->nelts; ++i) {
if ((clsarray[i].writer) && (clsarray[i].writer->exit))
clsarray[i].writer->exit(s, clsarray[i].writer_data);
}
}
}
return APR_SUCCESS;
}
static int init_config_log(apr_pool_t *pc, apr_pool_t *p, apr_pool_t *pt, server_rec *s)
{
/* First, do "physical" server, which gets default log fd and format
* for the virtual servers, if they don't override...
*/
int 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)
{
multi_log_state *mls;
apr_array_header_t *log_list;
config_log_state *clsarray;
buffered_log *buf;
int i;
apr_pool_cleanup_register(p, s, flush_all_logs, flush_all_logs);
for (; s; s = s->next) {
mls = ap_get_module_config(s->module_config, &log_config_module);
if (mls->config_logs->nelts) {
log_list = mls->config_logs;
}
else if (mls->server_config_logs) {
log_list = mls->server_config_logs;
}
else {
log_list = NULL;
}
if (log_list) {
clsarray = (config_log_state *) log_list->elts;
for (i = 0; i < log_list->nelts; ++i) {
if ((clsarray[i].writer) && (clsarray[i].writer->init))
clsarray[i].writer->init(p, s, clsarray[i].writer_data);
}
}
}
}
static void ap_register_log_handler(apr_pool_t *p, char *tag,
ap_log_handler_fn_t *handler, int def)
{
log_handler *log_struct = apr_palloc(p, sizeof(*log_struct));
log_struct->handler.func = handler;
log_struct->want_orig_default = def;
log_struct->oldstyle = -1;
apr_hash_set(log_hash, tag, 1, (const void *)log_struct);
}
static void ap_register_log_ehandler(apr_pool_t *p, char *tag,
ap_log_ehandler_fn_t *handler, int def)
{
log_handler *log_struct = apr_palloc(p, sizeof(*log_struct));
log_struct->handler.efunc = handler;
log_struct->want_orig_default = def;
log_struct->oldstyle = 0;
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 void ap_register_log_ewriter(apr_pool_t *p, char *key,
ap_log_ewriter_setup *setup,
ap_log_ewriter *write,
ap_log_ewriter_init *init,
ap_log_ewriter_exit *exit)
{
log_ewriter *writer_struct = apr_palloc(p, sizeof(*writer_struct));
writer_struct->setup = setup;
writer_struct->write = write;
writer_struct->init = init;
writer_struct->exit = exit;
apr_hash_set(writer_hash, key, APR_HASH_KEY_STRING, (const void *)writer_struct);
}
static apr_status_t ap_filepipe_log_ewriter(request_rec *r,
void *handle,
apr_array_header_t *data)
{
char *str;
char *s;
const char **strs;
int *strl;
int i;
int len = 0;
apr_status_t rv;
buffered_log *buf = (buffered_log*)handle;
ap_log_ehandler_data *d;
strs = apr_palloc(r->pool, sizeof(char *) * (data->nelts));
strl = apr_palloc(r->pool, sizeof(int) * (data->nelts));
for (i = 0; i < data->nelts; ++i) {
d=&(((ap_log_ehandler_data*)(data->elts))[i]);
if ((d) && (d->data)) {
switch (d->type)
{
case AP_LOG_EHANDLER_RETURN_OLDSTYLE:
strs[i] = d->data;
break;
case AP_LOG_EHANDLER_RETURN_CONST:
strs[i] = d->data;
break;
case AP_LOG_EHANDLER_RETURN_STRING:
if (strlen(d->data)==0)
strs[i] = "\"\"";
else
strs[i] = ap_escape_logitem(r->pool, d->data);
break;
case AP_LOG_EHANDLER_RETURN_NUMBER:
strs[i] = apr_psprintf(r->pool,"%" AP_LOG_NUMBER_T_FMT,*((ap_log_number_t *) d->data));
break;
case AP_LOG_EHANDLER_RETURN_UNUMBER:
strs[i] = apr_psprintf(r->pool,"%" AP_LOG_UNUMBER_T_FMT,*((ap_log_unumber_t *) d->data));
break;
case AP_LOG_EHANDLER_RETURN_DATETIME:
strs[i] = format_request_time(r,d->arg,d->data,NULL);
break;
}
}
else {
strs[i]="-";
}
len += strl[i] = strlen(strs[i]);
}
len += strlen(APR_EOL_STR);
if (!buffered_logs) {
str = apr_palloc(r->pool, len + 1);
for (i = 0, s = str; i < data->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
memcpy(s, APR_EOL_STR, strlen(APR_EOL_STR));
rv = apr_file_write((apr_file_t*)handle, str, &len);
}
else {
buffered_log *buf = (buffered_log*)handle;
if (len + buf->outcnt > LOG_BUFSIZE) {
flush_log(buf);
}
if (len >= LOG_BUFSIZE) {
apr_size_t w;
str = apr_palloc(r->pool, len + 1 );
for (i = 0, s = str; i < data->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
memcpy(s, APR_EOL_STR, strlen(APR_EOL_STR));
w = len;
rv = apr_file_write(buf->handle, str, &w);
}
else {
for (i = 0, s = &buf->outbuf[buf->outcnt]; i < data->nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
memcpy(s, APR_EOL_STR, strlen(APR_EOL_STR));
buf->outcnt += len;
rv = APR_SUCCESS;
}
}
return rv;
}
static void *init_buffered_logs(apr_pool_t *p, void *handle)
{
buffered_log *b;
b = apr_palloc(p, sizeof(buffered_log));
b->handle = handle;
b->outcnt = 0;
if (b->handle)
return b;
else
return NULL;
}
static void *ap_file_log_writer_setup(apr_pool_t *p, server_rec *s,
const char* name)
{
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,
"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,
"could not open transfer log file %s.", fname);
return NULL;
}
if (buffered_logs)
return init_buffered_logs(p, fd);
else
return fd;
}
static void *ap_pipe_log_writer_setup(apr_pool_t *p, server_rec *s,
const char* name)
{
piped_log *pl;
pl = ap_open_piped_log(p, name);
if (pl == NULL) {
return NULL;;
}
if (buffered_logs)
return init_buffered_logs(p, ap_piped_log_write_fd(pl));
else
return ap_piped_log_write_fd(pl);
}
static void *ap_old_log_writer_init(apr_pool_t *p, server_rec *s,
const char* name)
{
if (*name == '|')
return ap_pipe_log_writer_setup(p, s, name + 1);
else
return ap_file_log_writer_setup(p, s, name);
}
static void ap_filepipe_log_ewriter_exit(server_rec *s, void *data)
{
if (buffered_logs)
flush_log((buffered_log*)data);
}
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_ehandler) *log_pfn_eregister;
ap_register_log_ewriter(p,"file",ap_file_log_writer_setup,ap_filepipe_log_ewriter,NULL,ap_filepipe_log_ewriter_exit);
ap_register_log_ewriter(p,"pipe",ap_pipe_log_writer_setup,ap_filepipe_log_ewriter,NULL,ap_filepipe_log_ewriter_exit);
log_pfn_eregister = APR_RETRIEVE_OPTIONAL_FN(ap_register_log_ehandler);
if (log_pfn_eregister) {
log_pfn_eregister(p, "%", constant_item, 0);
log_pfn_eregister(p, "h", log_remote_host, 0);
log_pfn_eregister(p, "a", log_remote_address, 0 );
log_pfn_eregister(p, "A", log_local_address, 0 );
log_pfn_eregister(p, "l", log_remote_logname, 0);
log_pfn_eregister(p, "r", log_request_line, 1);
log_pfn_eregister(p, "u", log_remote_user, 0);
log_pfn_eregister(p, "s", log_status, 1);
log_pfn_eregister(p, "f", log_request_file, 0);
log_pfn_eregister(p, "U", log_request_uri, 1);
log_pfn_eregister(p, "m", log_request_method, 0);
log_pfn_eregister(p, "H", log_request_protocol, 0);
log_pfn_eregister(p, "q", log_request_query, 0);
log_pfn_eregister(p, "b", clf_log_bytes_sent, 0);
log_pfn_eregister(p, "B", log_bytes_sent, 0);
log_pfn_eregister(p, "i", log_header_in, 0);
log_pfn_eregister(p, "o", log_header_out, 0);
log_pfn_eregister(p, "n", log_note, 0);
log_pfn_eregister(p, "e", log_env_var, 0);
log_pfn_eregister(p, "C", log_cookie, 0);
log_pfn_eregister(p, "V", log_server_name, 0);
log_pfn_eregister(p, "v", log_virtual_host, 0);
log_pfn_eregister(p, "p", log_server_port, 0);
log_pfn_eregister(p, "D", log_request_duration_microseconds, 1);
log_pfn_eregister(p, "P", log_pid_tid, 0);
log_pfn_eregister(p, "R", log_unparsed_request_uri, 1);
log_pfn_eregister(p, "t", log_request_time, 0);
log_pfn_eregister(p, "T", log_request_duration, 1);
log_pfn_eregister(p, "X", log_connection_status, 0);
}
return OK;
}
static void register_hooks(apr_pool_t *p)
{
ap_hook_pre_config(log_pre_config,NULL,NULL,APR_HOOK_REALLY_FIRST);
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);
APR_REGISTER_OPTIONAL_FN(ap_register_log_ehandler);
writer_hash = apr_hash_make(p);
APR_REGISTER_OPTIONAL_FN(ap_register_log_ewriter);
}
module AP_MODULE_DECLARE_DATA log_config_module =
{
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 */
};