lighttpd 1.4.x https://www.lighttpd.net/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1067 lines
34 KiB

#include "first.h"
#include "sys-time.h"
#include "base.h"
#include "fdevent.h"
#include "fdlog.h"
#include "log.h"
#include "buffer.h"
#include "http_header.h"
#include "sock_addr.h"
#include "plugin.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#ifdef HAVE_SYSLOG_H
# include <syslog.h>
#endif
typedef struct {
char key;
enum {
FORMAT_UNSET,
FORMAT_UNSUPPORTED,
FORMAT_PERCENT,
FORMAT_REMOTE_HOST,
FORMAT_REMOTE_IDENT,
FORMAT_REMOTE_USER,
FORMAT_TIMESTAMP,
FORMAT_REQUEST_LINE,
FORMAT_STATUS,
FORMAT_BYTES_OUT_NO_HEADER,
FORMAT_HEADER,
FORMAT_REMOTE_ADDR,
FORMAT_LOCAL_ADDR,
FORMAT_COOKIE,
FORMAT_TIME_USED_US,
FORMAT_ENV,
FORMAT_FILENAME,
FORMAT_REQUEST_PROTOCOL,
FORMAT_REQUEST_METHOD,
FORMAT_SERVER_PORT,
FORMAT_QUERY_STRING,
FORMAT_TIME_USED,
FORMAT_URL,
FORMAT_SERVER_NAME,
FORMAT_HTTP_HOST,
FORMAT_CONNECTION_STATUS,
FORMAT_BYTES_IN,
FORMAT_BYTES_OUT,
FORMAT_KEEPALIVE_COUNT,
FORMAT_RESPONSE_HEADER,
FORMAT_NOTE
} type;
} format_mapping;
/**
*
*
* "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\""
*
*/
static const format_mapping fmap[] =
{
{ '%', FORMAT_PERCENT },
{ 'h', FORMAT_REMOTE_HOST },
{ 'l', FORMAT_REMOTE_IDENT },
{ 'u', FORMAT_REMOTE_USER },
{ 't', FORMAT_TIMESTAMP },
{ 'r', FORMAT_REQUEST_LINE },
{ 's', FORMAT_STATUS },
{ 'b', FORMAT_BYTES_OUT_NO_HEADER },
{ 'i', FORMAT_HEADER },
{ 'a', FORMAT_REMOTE_ADDR },
{ 'A', FORMAT_LOCAL_ADDR },
{ 'B', FORMAT_BYTES_OUT_NO_HEADER },
{ 'C', FORMAT_COOKIE },
{ 'D', FORMAT_TIME_USED_US },
{ 'e', FORMAT_ENV },
{ 'f', FORMAT_FILENAME },
{ 'H', FORMAT_REQUEST_PROTOCOL },
{ 'k', FORMAT_KEEPALIVE_COUNT },
{ 'm', FORMAT_REQUEST_METHOD },
{ 'n', FORMAT_NOTE },
{ 'p', FORMAT_SERVER_PORT },
{ 'P', FORMAT_UNSUPPORTED }, /* we are only one process */
{ 'q', FORMAT_QUERY_STRING },
{ 'T', FORMAT_TIME_USED },
{ 'U', FORMAT_URL }, /* w/o querystring */
{ 'v', FORMAT_SERVER_NAME },
{ 'V', FORMAT_HTTP_HOST },
{ 'X', FORMAT_CONNECTION_STATUS },
{ 'I', FORMAT_BYTES_IN },
{ 'O', FORMAT_BYTES_OUT },
{ 'o', FORMAT_RESPONSE_HEADER },
{ '\0', FORMAT_UNSET }
};
enum e_optflags_time {
/* format string is passed to strftime unless other format optflags set
* (besides FORMAT_FLAG_TIME_BEGIN or FORMAT_FLAG_TIME_END) */
FORMAT_FLAG_TIME_END = 0x00,/* use request end time (default) */
FORMAT_FLAG_TIME_BEGIN = 0x01,/* use request start time */
FORMAT_FLAG_TIME_SEC = 0x02,/* request time as num sec since epoch */
FORMAT_FLAG_TIME_MSEC = 0x04,/* request time as num msec since epoch */
FORMAT_FLAG_TIME_USEC = 0x08,/* request time as num usec since epoch */
FORMAT_FLAG_TIME_NSEC = 0x10,/* request time as num nsec since epoch */
FORMAT_FLAG_TIME_MSEC_FRAC = 0x20,/* request time msec fraction */
FORMAT_FLAG_TIME_USEC_FRAC = 0x40,/* request time usec fraction */
FORMAT_FLAG_TIME_NSEC_FRAC = 0x80 /* request time nsec fraction */
};
enum e_optflags_port {
FORMAT_FLAG_PORT_LOCAL = 0x01,/* (default) */
FORMAT_FLAG_PORT_REMOTE = 0x02
};
typedef struct {
enum { FIELD_UNSET, FIELD_STRING, FIELD_FORMAT } type;
int field;
int opt;
buffer string;
} format_field;
typedef struct {
[multiple] Y2038 32-bit signed time_t mitigations Most OS platforms have already provided solutions to Y2038 32-bit signed time_t 5 - 10 years ago (or more!) Notable exceptions are Linux i686 and FreeBSD i386. Since 32-bit systems tend to be embedded systems, and since many distros take years to pick up new software, this commit aims to provide Y2038 mitigations for lighttpd running on 32-bit systems with Y2038-unsafe 32-bit signed time_t * Y2038: lighttpd 1.4.60 and later report Y2038 safety $ lighttpd -V + Y2038 support # Y2038-SAFE $ lighttpd -V - Y2038 support (unsafe 32-bit signed time_t) # Y2038-UNSAFE * Y2038: general platform info * Y2038-SAFE: lighttpd 64-bit builds on platforms using 64-bit time_t - all major 64-bit platforms (known to this author) use 64-bit time_t * Y2038-SAFE: lighttpd 32-bit builds on platforms using 64-bit time_t - Linux x32 ABI (different from i686) - FreeBSD all 32-bit and 64-bit architectures *except* 32-bit i386 - NetBSD 6.0 (released Oct 2012) all 32-bit and 64-bit architectures - OpenBSD 5.5 (released May 2014) all 32-bit and 64-bit architectures - Microsoft Windows XP and Visual Studio 2005 (? unsure ?) Another reference suggests Visual Studio 2015 defaults to 64-bit time_t - MacOS 10.15 Catalina (released 2019) drops support for 32-bit apps * Y2038-SAFE: lighttpd 32-bit builds on platforms using 32-bit unsigned time_t - e.g. OpenVMS (unknown if lighttpd builds on this platform) * Y2038-UNSAFE: lighttpd 32-bit builds on platforms using 32-bit signed time_t - Linux 32-bit (including i686) - glibc 32-bit library support not yet available for 64-bit time_t - https://sourceware.org/glibc/wiki/Y2038ProofnessDesign - Linux kernel 5.6 on 32-bit platforms does support 64-bit time_t https://itsubuntu.com/linux-kernel-5-6-to-fix-the-year-2038-issue-unix-y2k/ - https://www.gnu.org/software/libc/manual/html_node/64_002dbit-time-symbol-handling.html "Note: at this point, 64-bit time support in dual-time configurations is work-in-progress, so for these configurations, the public API only makes the 32-bit time support available. In a later change, the public API will allow user code to choose the time size for a given compilation unit." - compiling with -D_TIME_BITS=64 currently has no effect - glibc recent (Jul 2021) mailing list discussion - https://public-inbox.org/bug-gnulib/878s2ozq70.fsf@oldenburg.str.redhat.com/T/ - FreeBSD i386 - DragonFlyBSD 32-bit * Y2038 mitigations attempted on Y2038-UNSAFE platforms (32-bit signed time_t) * lighttpd prefers system monotonic clock instead of realtime clock in places where realtime clock is not required * lighttpd treats negative time_t values as after 19 Jan 2038 03:14:07 GMT * (lighttpd presumes that lighttpd will not encounter dates before 1970 during normal operation.) * lighttpd casts struct stat st.st_mtime (and st.st_*time) through uint64_t to convert negative timestamps for comparisions with 64-bit timestamps (treating negative timestamp values as after 19 Jan 2038 03:14:07 GMT) * lighttpd provides unix_time64_t (int64_t) and * lighttpd provides struct unix_timespec64 (unix_timespec64_t) (struct timespec equivalent using unix_time64_t tv_sec member) * lighttpd provides gmtime64_r() and localtime64_r() wrappers for platforms 32-bit platforms using 32-bit time_t and lighttpd temporarily shifts the year in order to use gmtime_r() and localtime_r() (or gmtime() and localtime()) from standard libraries, before readjusting year and passing struct tm to formatting functions such as strftime() * lighttpd provides TIME64_CAST() macro to cast signed 32-bit time_t to unsigned 32-bit and then to unix_time64_t * Note: while lighttpd tries handle times past 19 Jan 2038 03:14:07 GMT on 32-bit platforms using 32-bit signed time_t, underlying libraries and underlying filesystems might not behave properly after 32-bit signed time_t overflows (19 Jan 2038 03:14:08 GMT). If a given 32-bit OS does not work properly using negative time_t values, then lighttpd likely will not work properly on that system. * Other references and blogs - https://en.wikipedia.org/wiki/Year_2038_problem - https://en.wikipedia.org/wiki/Time_formatting_and_storage_bugs - http://www.lieberbiber.de/2017/03/14/a-look-at-the-year-20362038-problems-and-time-proofness-in-various-systems/
5 months ago
unix_time64_t last_generated_accesslog_ts;
buffer ts_accesslog_str;
#if defined(__STDC_VERSION__) && __STDC_VERSION__-0 >= 199901L /* C99 */
format_field ptr[]; /* C99 VLA */
#else
format_field ptr[1];
#endif
} format_fields;
typedef struct {
fdlog_st *fdlog;
char use_syslog; /* syslog has global buffer */
unsigned short syslog_level;
format_fields *parsed_format;
} plugin_config;
typedef struct {
PLUGIN_DATA;
plugin_config defaults;
plugin_config conf;
format_fields *default_format;/* allocated if default format */
} plugin_data;
INIT_FUNC(mod_accesslog_init) {
return calloc(1, sizeof(plugin_data));
}
static void accesslog_append_escaped_str(buffer * const dest, const char * const str, const size_t len) {
const char *ptr, *start, *end;
/* replaces non-printable chars with \xHH where HH is the hex representation of the byte */
/* exceptions: " => \", \ => \\, whitespace chars => \n \t etc. */
if (0 == len) return;
buffer_string_prepare_append(dest, len);
for (ptr = start = str, end = str+len; ptr < end; ++ptr) {
unsigned char const c = *(const unsigned char *)ptr;
if (c >= ' ' && c <= '~' && c != '"' && c != '\\') {
/* nothing to change, add later as one block */
} else {
/* copy previous part */
if (start < ptr) {
buffer_append_string_len(dest, start, ptr - start);
}
start = ptr + 1;
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
const char *h2;
switch (c) {
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
case '"': h2 = "\\\""; break;
case '\\': h2 = "\\\\"; break;
case '\b': h2 = "\\b"; break;
case '\n': h2 = "\\n"; break;
case '\r': h2 = "\\r"; break;
case '\t': h2 = "\\t"; break;
case '\v': h2 = "\\v"; break;
default: {
/* non printable char => \xHH */
char hh[5] = {'\\','x',0,0,0};
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
char h = c >> 4;
hh[2] = (h > 9) ? (h - 10 + 'A') : (h + '0');
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
h = c & 0xFF;
hh[3] = (h > 9) ? (h - 10 + 'A') : (h + '0');
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
buffer_append_string_len(dest, hh, 4);
continue;
}
}
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
buffer_append_string_len(dest, h2, 2);
}
}
if (start < end) {
buffer_append_string_len(dest, start, end - start);
}
}
static void accesslog_append_escaped(buffer *dest, const buffer *str) {
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
accesslog_append_escaped_str(dest, BUF_PTR_LEN(str));
}
__attribute_cold__
static format_fields * accesslog_parse_format_err(log_error_st *errh, const char *file, unsigned int line, format_field *f, const char *msg) {
log_error(errh, file, line, "%s", msg);
for (; f->type != FIELD_UNSET; ++f) free(f->string.ptr);
return NULL;
}
static format_fields * accesslog_parse_format(const char * const format, const size_t flen, log_error_st * const errh) {
/* common log format (the default) results in 18 elements,
* so 127 should be enough except for obscene custom usage */
size_t i, j, k = 0, start = 0;
uint32_t used = 0;
const uint32_t sz = 127;/* (sz+1 must match fptr[] num elts below) */
format_field *f;
format_field fptr[128]; /* (128 elements takes 4k on stack in 64-bit) */
memset(fptr, 0, sizeof(fptr));
if (0 != FIELD_UNSET) return NULL;
if (0 == flen) return NULL;
for (i = 0; i < flen; ++i) {
if (format[i] != '%') continue;
if (i > 0 && start != i) {
/* copy the string before this % */
if (used == sz)
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"too many fields (>= 127) in accesslog.format");
f = fptr+used;
f->type = FIELD_STRING;
memset(&f->string, 0, sizeof(buffer));
buffer_copy_string_len(&f->string, format + start, i - start);
++used;
}
/* we need a new field */
if (used == sz)
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"too many fields (>= 127) in accesslog.format");
/* search for the terminating command */
switch (format[i+1]) {
case '>':
case '<':
/* after the } has to be a character */
if (format[i+2] == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%< and %> have to be followed by a format-specifier");
}
for (j = 0; fmap[j].key != '\0'; j++) {
if (fmap[j].key != format[i+2]) continue;
/* found key */
f = fptr+used;
f->type = FIELD_FORMAT;
f->field = fmap[j].type;
f->opt = 0;
f->string.ptr = NULL;
++used;
break;
}
if (fmap[j].key == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%< and %> have to be followed by a valid format-specifier");
}
start = i + 3;
i = start - 1; /* skip the string */
break;
case '{':
/* go forward to } */
for (k = i+2; k < flen; ++k) {
if (format[k] == '}') break;
}
if (k == flen) {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%{ has to be terminated by a }");
}
/* after the } has to be a character */
if (format[k+1] == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%{...} has to be followed by a format-specifier");
}
if (k == i + 2) {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%{...} has to contain a string");
}
for (j = 0; fmap[j].key != '\0'; j++) {
if (fmap[j].key != format[k+1]) continue;
/* found key */
f = fptr+used;
f->type = FIELD_FORMAT;
f->field = fmap[j].type;
f->opt = 0;
memset(&f->string, 0, sizeof(buffer));
buffer_copy_string_len(&f->string, format + i + 2, k - (i + 2));
++used;
break;
}
if (fmap[j].key == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"%{...} has to be followed by a valid format-specifier");
}
start = k + 2;
i = start - 1; /* skip the string */
break;
default:
/* after the % has to be a character */
if (format[i+1] == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"% has to be followed by a format-specifier");
}
for (j = 0; fmap[j].key != '\0'; j++) {
if (fmap[j].key != format[i+1]) continue;
/* found key */
f = fptr+used;
f->type = FIELD_FORMAT;
f->field = fmap[j].type;
f->string.ptr = NULL;
f->opt = 0;
++used;
break;
}
if (fmap[j].key == '\0') {
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"% has to be followed by a valid format-specifier");
}
start = i + 2;
i = start - 1; /* skip the string */
break;
}
}
if (start < i) {
/* copy the string */
if (used == sz)
return accesslog_parse_format_err(errh, __FILE__, __LINE__, fptr,
"too many fields (>= 127) in accesslog.format");
f = fptr+used;
f->type = FIELD_STRING;
memset(&f->string, 0, sizeof(buffer));
buffer_copy_string_len(&f->string, format + start, i - start);
++used;
}
format_fields * const fields =
malloc(sizeof(format_fields) + ((used+1) * sizeof(format_field)));
force_assert(fields);
memset(fields, 0, sizeof(format_fields));
memcpy(fields->ptr, fptr, (used+1) * sizeof(format_field));
return fields;
}
static void mod_accesslog_free_format_fields(format_fields * const ff) {
for (format_field *f = ff->ptr; f->type != FIELD_UNSET; ++f)
free(f->string.ptr);
free(ff->ts_accesslog_str.ptr);
free(ff);
}
FREE_FUNC(mod_accesslog_free) {
plugin_data * const p = p_d;
if (NULL == p->cvlist) return;
/* (init i to 0 if global context; to 1 to skip empty global context) */
for (int i = !p->cvlist[0].v.u2[1], used = p->nconfig; i < used; ++i) {
config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
for (; -1 != cpv->k_id; ++cpv) {
if (cpv->vtype != T_CONFIG_LOCAL || NULL == cpv->v.v) continue;
switch (cpv->k_id) {
case 0: /* accesslog.filename */
/*(handled by fdlog_closeall())*/
break;
case 1: /* accesslog.format */
mod_accesslog_free_format_fields(cpv->v.v);
break;
default:
break;
}
}
}
if (NULL != p->default_format) {
mod_accesslog_free_format_fields(p->default_format);
}
}
static void mod_accesslog_merge_config_cpv(plugin_config * const pconf, const config_plugin_value_t * const cpv) {
switch (cpv->k_id) { /* index into static config_plugin_keys_t cpk[] */
case 0:{/* accesslog.filename */
if (cpv->vtype != T_CONFIG_LOCAL) break;
pconf->fdlog = cpv->v.v;
break;
}
case 1:{/* accesslog.format */
if (cpv->vtype != T_CONFIG_LOCAL) break;
pconf->parsed_format = cpv->v.v;
break;
}
case 2: /* accesslog.use-syslog */
pconf->use_syslog = (int)cpv->v.u;
break;
case 3: /* accesslog.syslog-level */
pconf->syslog_level = cpv->v.shrt;
break;
default:/* should not happen */
return;
}
}
static void mod_accesslog_merge_config(plugin_config * const pconf, const config_plugin_value_t *cpv) {
do {
mod_accesslog_merge_config_cpv(pconf, cpv);
} while ((++cpv)->k_id != -1);
}
static void mod_accesslog_patch_config(request_st * const r, plugin_data * const p) {
memcpy(&p->conf, &p->defaults, sizeof(plugin_config));
for (int i = 1, used = p->nconfig; i < used; ++i) {
if (config_check_cond(r, (uint32_t)p->cvlist[i].k_id))
mod_accesslog_merge_config(&p->conf, p->cvlist + p->cvlist[i].v.u2[0]);
}
}
static format_fields * mod_accesslog_process_format(const char * const format, const size_t flen, server * const srv);
SETDEFAULTS_FUNC(mod_accesslog_set_defaults) {
static const config_plugin_keys_t cpk[] = {
{ CONST_STR_LEN("accesslog.filename"),
T_CONFIG_STRING,
T_CONFIG_SCOPE_CONNECTION }
,{ CONST_STR_LEN("accesslog.format"),
T_CONFIG_STRING,
T_CONFIG_SCOPE_CONNECTION }
,{ CONST_STR_LEN("accesslog.use-syslog"),
T_CONFIG_BOOL,
T_CONFIG_SCOPE_CONNECTION }
,{ CONST_STR_LEN("accesslog.syslog-level"),
T_CONFIG_SHORT,
T_CONFIG_SCOPE_CONNECTION }
,{ NULL, 0,
T_CONFIG_UNSET,
T_CONFIG_SCOPE_UNSET }
};
plugin_data * const p = p_d;
if (!config_plugin_values_init(srv, p, cpk, "mod_accesslog"))
return HANDLER_ERROR;
/* process and validate config directives
* (init i to 0 if global context; to 1 to skip empty global context) */
for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) {
config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0];
int use_syslog = 0;
config_plugin_value_t *cpvfile = NULL;
for (; -1 != cpv->k_id; ++cpv) {
switch (cpv->k_id) {
case 0: /* accesslog.filename */
if (!buffer_is_blank(cpv->v.b))
cpvfile = cpv;
else {
cpv->v.v = NULL;
cpv->vtype = T_CONFIG_LOCAL;
}
break;
case 1: /* accesslog.format */
if (NULL != strchr(cpv->v.b->ptr, '\\')) {
/* process basic backslash-escapes in format string */
buffer *b;
*(const buffer **)&b = cpv->v.b;
char *t = b->ptr;
for (char *s = t; *s; ++s) {
if (s[0] != '\\') { *t++ = *s; continue; }
if (s[1] == '\0') continue; /*(ignore dangling '\\')*/
switch (*++s) {
case 'a': *t++ = '\a'; break; /* bell */
case 'b': *t++ = '\b'; break; /* backspace */
case 'f': *t++ = '\f'; break; /* form feed */
case 'n': *t++ = '\n'; break; /* newline */
case 'r': *t++ = '\r'; break; /* carriage return */
case 't': *t++ = '\t'; break; /* horizontal tab */
case 'v': *t++ = '\v'; break; /* vertical tab */
/*case '"':*/
/*case '\\':*/
default: *t++ = *s; break; /*(use literal char)*/
}
}
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
buffer_truncate(b, (size_t)(t - b->ptr));
}
cpv->v.v =
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
mod_accesslog_process_format(BUF_PTR_LEN(cpv->v.b), srv);
if (NULL == cpv->v.v) return HANDLER_ERROR;
cpv->vtype = T_CONFIG_LOCAL;
break;
case 2: /* accesslog.use-syslog */
use_syslog = (int)cpv->v.u;
break;
case 3: /* accesslog.syslog-level */
break;
default:/* should not happen */
break;
}
}
if (srv->srvconf.preflight_check) continue;
if (use_syslog) continue; /* ignore the next checks */
cpv = cpvfile; /* accesslog.filename handled after preflight_check */
if (NULL == cpv) continue;
const char * const fn = cpv->v.b->ptr;
cpv->v.v = fdlog_open(fn);
cpv->vtype = T_CONFIG_LOCAL;
if (NULL == cpv->v.v) {
log_perror(srv->errh, __FILE__, __LINE__,
"opening log '%s' failed", fn);
return HANDLER_ERROR;
}
}
p->defaults.syslog_level = LOG_INFO;
/* initialize p->defaults from global config context */
if (p->nconfig > 0 && p->cvlist->v.u2[1]) {
const config_plugin_value_t *cpv = p->cvlist + p->cvlist->v.u2[0];
if (-1 != cpv->k_id)
mod_accesslog_merge_config(&p->defaults, cpv);
}
if (NULL == p->defaults.parsed_format) {
/* (set default format even if p->use_syslog since
* some other condition might enable logfile) */
static const char fmt[] =
"%h %V %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"";
p->defaults.parsed_format = p->default_format =
mod_accesslog_process_format(CONST_STR_LEN(fmt), srv);
if (NULL == p->default_format) return HANDLER_ERROR;
}
return HANDLER_GO_ON;
}
static format_fields * mod_accesslog_process_format(const char * const format, const size_t flen, server * const srv) {
format_fields * const parsed_format =
accesslog_parse_format(format, flen, srv->errh);
if (NULL == parsed_format) {
log_error(srv->errh, __FILE__, __LINE__,
"parsing accesslog-definition failed: %s", format);
return NULL;
}
uint32_t tcount = 0;
for (format_field *f = parsed_format->ptr; f->type != FIELD_UNSET; ++f) {
const buffer * const fstr = &f->string;
if (FIELD_FORMAT != f->type) continue;
if (FORMAT_TIMESTAMP == f->field) {
[multiple] reduce redundant NULL buffer checks This commit is a large set of code changes and results in removal of hundreds, perhaps thousands, of CPU instructions, a portion of which are on hot code paths. Most (buffer *) used by lighttpd are not NULL, especially since buffers were inlined into numerous larger structs such as request_st and chunk. In the small number of instances where that is not the case, a NULL check is often performed earlier in a function where that buffer is later used with a buffer_* func. In the handful of cases that remained, a NULL check was added, e.g. with r->http_host and r->conf.server_tag. - check for empty strings at config time and set value to NULL if blank string will be ignored at runtime; at runtime, simple pointer check for NULL can be used to check for a value that has been set and is not blank ("") - use buffer_is_blank() instead of buffer_string_is_empty(), and use buffer_is_unset() instead of buffer_is_empty(), where buffer is known not to be NULL so that NULL check can be skipped - use buffer_clen() instead of buffer_string_length() when buffer is known not to be NULL (to avoid NULL check at runtime) - use buffer_truncate() instead of buffer_string_set_length() to truncate string, and use buffer_extend() to extend Examples where buffer known not to be NULL: - cpv->v.b from config_plugin_values_init is not NULL if T_CONFIG_BOOL (though we might set it to NULL if buffer_is_blank(cpv->v.b)) - address of buffer is arg (&foo) (compiler optimizer detects this in most, but not all, cases) - buffer is checked for NULL earlier in func - buffer is accessed in same scope without a NULL check (e.g. b->ptr) internal behavior change: callers must not pass a NULL buffer to some funcs. - buffer_init_buffer() requires non-null args - buffer_copy_buffer() requires non-null args - buffer_append_string_buffer() requires non-null args - buffer_string_space() requires non-null arg
6 months ago
if (!buffer_is_blank(fstr)) {
const char *ptr = fstr->ptr;
if (0 == strncmp(ptr, "begin:", sizeof("begin:")-1)) {
f->opt |= FORMAT_FLAG_TIME_BEGIN;
ptr += sizeof("begin:")-1;
} else if (0 == strncmp(ptr, "end:", sizeof("end:")-1)) {
f->opt |= FORMAT_FLAG_TIME_END;
ptr += sizeof("end:")-1;
}
if (0 == strcmp(ptr, "sec")) f->opt |= FORMAT_FLAG_TIME_SEC;
else if (0 == strcmp(ptr, "msec")) f->opt |= FORMAT_FLAG_TIME_MSEC;
else if (0 == strcmp(ptr, "usec")) f->opt |= FORMAT_FLAG_TIME_USEC;
else if (0 == strcmp(ptr, "nsec")) f->opt |= FORMAT_FLAG_TIME_NSEC;
else if (0 == strcmp(ptr, "msec_frac")) f->opt |= FORMAT_FLAG_TIME_MSEC_FRAC;
else if (0 == strcmp(ptr, "usec_frac")) f->opt |= FORMAT_FLAG_TIME_USEC_FRAC;
else if (0 == strcmp(ptr, "nsec_frac")) f->opt |= FORMAT_FLAG_TIME_NSEC_FRAC;
else if (NULL == strchr(ptr, '%')) {
log_error(srv->errh, __FILE__, __LINE__,
"constant string for time format (misspelled token? or missing '%%'): %s", format);
mod_accesslog_free_format_fields(parsed_format);
return NULL;
}
}
/* make sure they didn't try to send the timestamp in twice
* (would invalidate pconf->parsed_format.ts_accesslog_str cache of timestamp str) */
if (!(f->opt & ~(FORMAT_FLAG_TIME_BEGIN|FORMAT_FLAG_TIME_END|FORMAT_FLAG_TIME_SEC)) && ++tcount > 1) {