/* Print a formatted string using format FMT and argument-list AP,
* prefixing each line of output with a debug header. */
static void
debug_vprintf(const char *fmt, va_list ap)
{
FILE *output = debug_output;
char prefix[80], buffer[1000];
char *s = buffer;
int n;
if (output == NULL || quiet_mode())
return;
n = apr_snprintf(prefix, sizeof(prefix), DBG_FLAG "%s:%4ld: ",
debug_file, debug_line);
assert(n < sizeof(prefix) - 1);
n = apr_vsnprintf(buffer, sizeof(buffer), fmt, ap);
assert(n < sizeof(buffer) - 1);
do
{
char *newline = strchr(s, '\n');
if (newline)
*newline = '\0';
fputs(prefix, output);
fputs(s, output);
fputc('\n', output);
if (! newline)
break;
s = newline + 1;
}
while (*s); /* print another line, except after a final newline */
}
static void unknown_arg(void *str, const char *err, ...)
{
va_list va;
va_start(va, err);
apr_vsnprintf(str, 8196, err, va);
va_end(va);
}
SWITCH_DECLARE(int) switch_snprintf(char *buf, switch_size_t len, const char *format, ...)
{
va_list ap;
int ret;
va_start(ap, format);
ret = apr_vsnprintf(buf, len, format, ap);
va_end(ap);
return ret;
}
/* User-defined logger */
int UniSynth_logger(char const* file, int line, char const* id, apt_log_priority_e priority, char const* format, va_list arg_ptr)
{
char buf[MAX_LOG_ENTRY_SIZE];
(void) file;
(void) line;
(void) id;
(void) priority;
buf[0] = 0;
apr_vsnprintf(buf, MAX_LOG_ENTRY_SIZE, format, arg_ptr);
printf(" %s\n", buf);
return TRUE;
}
static void
_aclr_debug(server_rec *s, const char *fmt, ...)
{
char errstr[MAX_STRING_LEN];
va_list args;
va_start(args, fmt);
apr_vsnprintf(errstr, sizeof(errstr), fmt, args);
va_end(args);
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, "[%" APR_PID_T_FMT "] %s",
getpid(), errstr);
return;
}
static int disasm_fprint_default(port_disassembler_t * disassembler, const char * fmt, ...) {
int required_length;
va_list args;
va_start(args, fmt);
required_length = apr_vsnprintf(NULL, 0, fmt, args);
assert(required_length >= 0);
// insure space
if ((unsigned int)required_length >= disassembler->num_bytes_total -
disassembler->num_bytes_used) {
apr_file_write(disassembler->user_file, disassembler->real_stream,
&disassembler->num_bytes_used);
disassembler->num_bytes_used = 0;
}
while ((unsigned int)required_length >= disassembler->num_bytes_total -
disassembler->num_bytes_used) {
disassembler->num_bytes_total *= 2;
}
apr_vsnprintf(disassembler->real_stream + disassembler->num_bytes_used,
required_length + 1, fmt, args);
disassembler->num_bytes_used += required_length;
return 0;
}
static void nx_exception_add_message(nx_exception_t *e,
const char *file,
int line,
const char *func,
const char *fmt,
va_list ap)
{
apr_size_t n, bufsize;
char *buf;
if ( e->num_throw >= NX_EXCEPTION_THROWLIST_SIZE )
{
e->num_throw = NX_EXCEPTION_THROWLIST_SIZE - 1;
if ( e->throwlist[e->num_throw].msgoffs >= 0 )
{
e->msglen = (apr_size_t) e->throwlist[e->num_throw].msgoffs;
}
}
e->throwlist[e->num_throw].file = file;
e->throwlist[e->num_throw].line = line;
e->throwlist[e->num_throw].func = func;
e->throwlist[e->num_throw].msgoffs = -1;
e->num_throw++;
if ( fmt == NULL )
{
return;
}
if ( e->msglen + 1 >= (int32_t) sizeof(e->msgbuf) )
{
return;
}
buf = e->msgbuf + e->msglen;
bufsize = sizeof(e->msgbuf) - e->msglen;
n = (apr_size_t) apr_vsnprintf((char *) buf, bufsize, fmt, ap);
ASSERT(n != 0);
e->throwlist[e->num_throw - 1].msgoffs = (int32_t) e->msglen;
if ( n < bufsize )
{
e->msglen += n + 1;
}
else
{
e->msglen = sizeof(e->msgbuf);
}
}
static int disasm_sprint_default(port_disassembler_t * disassembler, const char * fmt, ...) {
int required_length;
va_list args;
va_start(args, fmt);
required_length = apr_vsnprintf(NULL, 0, fmt, args);
assert(required_length >= 0);
// insure space
while ((unsigned int)required_length >= disassembler->num_bytes_total -
disassembler->num_bytes_used) {
void * buf = malloc(disassembler->num_bytes_used);
memcpy(buf, disassembler->real_stream, disassembler->num_bytes_used);
apr_pool_clear(disassembler->user_pool);
disassembler->num_bytes_total *= 2;
disassembler->real_stream = apr_palloc(disassembler->user_pool,
disassembler->num_bytes_total);
memcpy(disassembler->real_stream, buf, disassembler->num_bytes_used);
free(buf);
}
apr_vsnprintf(disassembler->real_stream + disassembler->num_bytes_used,
required_length + 1, fmt, args);
disassembler->num_bytes_used += required_length;
return required_length;
}
static apt_bool_t apt_do_log(apt_log_priority_e priority, const char *format, va_list arg_ptr)
{
char log_entry[MAX_LOG_ENTRY_SIZE];
apr_size_t offset = 0;
apr_time_exp_t result;
apr_time_t now = apr_time_now();
apr_time_exp_lt(&result,now);
if(apt_logger.header & APT_LOG_HEADER_DATE) {
offset += apr_snprintf(log_entry+offset,MAX_LOG_ENTRY_SIZE-offset,"%4d-%02d-%02d ",
result.tm_year+1900,
result.tm_mon+1,
result.tm_mday);
}
if(apt_logger.header & APT_LOG_HEADER_TIME) {
offset += apr_snprintf(log_entry+offset,MAX_LOG_ENTRY_SIZE-offset,"%02d:%02d:%02d:%06d ",
result.tm_hour,
result.tm_min,
result.tm_sec,
result.tm_usec);
}
if(apt_logger.header & APT_LOG_HEADER_PRIORITY) {
memcpy(log_entry+offset,priority_snames[priority],MAX_PRIORITY_NAME_LENGTH);
offset += MAX_PRIORITY_NAME_LENGTH;
}
offset += apr_vsnprintf(log_entry+offset,MAX_LOG_ENTRY_SIZE-offset,format,arg_ptr);
log_entry[offset++] = '\n';
log_entry[offset] = '\0';
if((apt_logger.mode & APT_LOG_OUTPUT_CONSOLE) == APT_LOG_OUTPUT_CONSOLE) {
printf(log_entry);
}
if((apt_logger.mode & APT_LOG_OUTPUT_FILE) == APT_LOG_OUTPUT_FILE && apt_logger.file) {
apr_thread_mutex_lock(apt_logger.mutex);
apt_logger.cur_size += offset;
if(apt_logger.cur_size > apt_logger.max_size) {
/* roll over */
fseek(apt_logger.file,0,SEEK_SET);
apt_logger.cur_size = offset;
}
/* write to log file */
fwrite(log_entry,1,offset,apt_logger.file);
fflush(apt_logger.file);
apr_thread_mutex_unlock(apt_logger.mutex);
}
return TRUE;
}
apr_status_t at_comment(at_t *t, const char *fmt, va_list vp)
{
apr_status_t s;
char buf[256], *b = buf + 2;
char *end;
int rv;
rv = apr_vsnprintf(b, 250, fmt, vp);
if (rv <= 0)
return APR_EINVAL;
end = b + rv;
buf[0] = '#';
buf[1] = ' ';
if (rv == 250) {
end[-1] = '.';
*end++ = '.';
*end++ = '.';
*end++ = '\n';
*end = 0;
}
else if (end[-1] != '\n') {
*end++ = '\n';
*end = 0;
}
b = buf;
while (1) {
char *eol;
eol = strchr(b + 2, '\n');
*eol = 0;
s = at_report(t, b);
if (s != APR_SUCCESS || eol == end - 1)
break;
b = eol - 1;
b[0] = '#';
b[1] = ' ';
}
return s;
}
static apt_bool_t apt_do_log(const char *file, int line, apt_log_priority_e priority, const char *format, va_list arg_ptr)
{
char log_entry[MAX_LOG_ENTRY_SIZE];
apr_size_t max_size = MAX_LOG_ENTRY_SIZE - 2;
apr_size_t offset = 0;
apr_time_exp_t result;
apr_time_t now = apr_time_now();
apr_time_exp_lt(&result,now);
if(apt_logger->header & APT_LOG_HEADER_DATE) {
offset += apr_snprintf(log_entry+offset,max_size-offset,"%4d-%02d-%02d ",
result.tm_year+1900,
result.tm_mon+1,
result.tm_mday);
}
if(apt_logger->header & APT_LOG_HEADER_TIME) {
offset += apr_snprintf(log_entry+offset,max_size-offset,"%02d:%02d:%02d:%06d ",
result.tm_hour,
result.tm_min,
result.tm_sec,
result.tm_usec);
}
if(apt_logger->header & APT_LOG_HEADER_MARK) {
offset += apr_snprintf(log_entry+offset,max_size-offset,"%s:%03d ",file,line);
}
if(apt_logger->header & APT_LOG_HEADER_THREAD) {
offset += apr_snprintf(log_entry+offset,max_size-offset,"%05lu ",apt_thread_id_get());
}
if(apt_logger->header & APT_LOG_HEADER_PRIORITY) {
memcpy(log_entry+offset,priority_snames[priority],MAX_PRIORITY_NAME_LENGTH);
offset += MAX_PRIORITY_NAME_LENGTH;
}
offset += apr_vsnprintf(log_entry+offset,max_size-offset,format,arg_ptr);
log_entry[offset++] = '\n';
log_entry[offset] = '\0';
if((apt_logger->mode & APT_LOG_OUTPUT_CONSOLE) == APT_LOG_OUTPUT_CONSOLE) {
fwrite(log_entry,offset,1,stdout);
}
if((apt_logger->mode & APT_LOG_OUTPUT_FILE) == APT_LOG_OUTPUT_FILE && apt_logger->file_data) {
apt_log_file_dump(apt_logger->file_data,log_entry,offset);
}
return TRUE;
}
APR_DECLARE_NONSTD(int) apr_file_printf(apr_file_t *fptr,
const char *format, ...)
{
int cc;
va_list ap;
char *buf;
int len;
buf = malloc(HUGE_STRING_LEN);
if (buf == NULL) {
return 0;
}
va_start(ap, format);
len = apr_vsnprintf(buf, HUGE_STRING_LEN, format, ap);
cc = apr_file_puts(buf, fptr);
va_end(ap);
free(buf);
return (cc == APR_SUCCESS) ? len : -1;
}
static void debugLog(const request_rec *r, const asn_dir_conf *cfg,
const char *fmt, ...)
{
if (cfg->debug == 1) {
char buf[512];
va_list ap;
va_start(ap, fmt);
apr_vsnprintf(buf, sizeof (buf), fmt, ap);
va_end(ap);
/* we use warn loglevel to be able to debug without
* setting the entire server into debug logging mode.
* (Apache 2.4 got per-module loglevel configuration; so, in case that
* Apache 2.2 should no longer be supported by us in the future, we
* could remove this function */
ap_log_rerror(APLOG_MARK,
APLOG_WARNING,
APR_SUCCESS,
r, "[mod_asn] %s", buf);
}
}
static void mod_sslhaf_log(sslhaf_cfg_t *cfg, const char *format, ...) {
va_list args;
conn_rec *c = cfg->user_data;
apr_size_t len;
if (c == NULL)
return;
len = apr_snprintf(mod_sslhaf_log_buf, MAX_STRING_LEN,
"mod_sslhaf [%s]: ", SSLHAF_AP_CONN_REMOTE_IP(c));
if (len == 0)
return;
va_start(args, format);
apr_vsnprintf(mod_sslhaf_log_buf + len, MAX_STRING_LEN - len,
format, args);
va_end(args);
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, c->base_server,
mod_sslhaf_log_buf, NULL);
}
/* Connects UniMRCP logging to Asterisk. */
static apt_bool_t unimrcp_log(const char *file, int line, const char *id, apt_log_priority_e priority, const char *format, va_list arg_ptr)
{
/* Same size as MAX_LOG_ENTRY_SIZE in UniMRCP apt_log.c. */
char log_message[4096] = { 0 };
if (strlen(format) == 0)
return TRUE;
/* Assume apr_vsnprintf supports format extensions required by UniMRCP. */
apr_vsnprintf(log_message, sizeof(log_message) - 1, format, arg_ptr);
log_message[sizeof(log_message) - 1] = '\0';
switch(priority) {
case APT_PRIO_EMERGENCY:
case APT_PRIO_ALERT:
case APT_PRIO_CRITICAL:
case APT_PRIO_ERROR:
ast_log(LOG_ERROR, "%s\n", log_message);
break;
case APT_PRIO_WARNING:
ast_log(LOG_WARNING, "%s\n", log_message);
break;
case APT_PRIO_NOTICE:
ast_log(LOG_NOTICE, "%s\n", log_message);
break;
case APT_PRIO_INFO:
case APT_PRIO_DEBUG:
ast_log(LOG_DEBUG, "%s\n", log_message);
break;
default:
ast_log(LOG_DEBUG, "%s\n", log_message);
break;
}
return TRUE;
}
static void log_error_core(const char *file, int line, int level,
apr_status_t status, const server_rec *s,
const conn_rec *c,
const request_rec *r, apr_pool_t *pool,
const char *fmt, va_list args)
{
char errstr[MAX_STRING_LEN];
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
char scratch[MAX_STRING_LEN];
#endif
apr_size_t len, errstrlen;
apr_file_t *logf = NULL;
const char *referer;
int level_and_mask = level & APLOG_LEVELMASK;
if (r && r->connection) {
c = r->connection;
}
if (s == NULL) {
/*
* If we are doing stderr logging (startup), don't log messages that are
* above the default server log level unless it is a startup/shutdown
* notice
*/
if ((level_and_mask != APLOG_NOTICE)
&& (level_and_mask > ap_default_loglevel)) {
return;
}
logf = stderr_log;
}
else if (s->error_log) {
/*
* If we are doing normal logging, don't log messages that are
* above the server log level unless it is a startup/shutdown notice
*/
if ((level_and_mask != APLOG_NOTICE)
&& (level_and_mask > s->loglevel)) {
return;
}
logf = s->error_log;
}
#ifdef TPF
else if (tpf_child) {
/*
* If we are doing normal logging, don't log messages that are
* above the server log level unless it is a startup/shutdown notice
*/
if ((level_and_mask != APLOG_NOTICE)
&& (level_and_mask > s->loglevel)) {
return;
}
logf = stderr;
}
#endif /* TPF */
else {
/*
* If we are doing syslog logging, don't log messages that are
* above the server log level (including a startup/shutdown notice)
*/
if (level_and_mask > s->loglevel) {
return;
}
}
if (logf && ((level & APLOG_STARTUP) != APLOG_STARTUP)) {
errstr[0] = '[';
ap_recent_ctime(errstr + 1, apr_time_now());
errstr[1 + APR_CTIME_LEN - 1] = ']';
errstr[1 + APR_CTIME_LEN ] = ' ';
len = 1 + APR_CTIME_LEN + 1;
} else {
len = 0;
}
if ((level & APLOG_STARTUP) != APLOG_STARTUP) {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"[%s] ", priorities[level_and_mask].t_name);
}
#ifndef TPF
if (file && level_and_mask == APLOG_DEBUG) {
#if defined(_OSD_POSIX) || defined(WIN32) || defined(__MVS__)
char tmp[256];
char *e = strrchr(file, '/');
#ifdef WIN32
if (!e) {
e = strrchr(file, '\\');
}
#endif
/* In OSD/POSIX, the compiler returns for __FILE__
* a string like: __FILE__="*POSIX(/usr/include/stdio.h)"
* (it even returns an absolute path for sources in
* the current directory). Here we try to strip this
* down to the basename.
*/
if (e != NULL && e[1] != '\0') {
apr_snprintf(tmp, sizeof(tmp), "%s", &e[1]);
e = &tmp[strlen(tmp)-1];
if (*e == ')') {
*e = '\0';
}
file = tmp;
}
#else /* _OSD_POSIX || WIN32 */
const char *p;
/* On Unix, __FILE__ may be an absolute path in a
* VPATH build. */
if (file[0] == '/' && (p = ap_strrchr_c(file, '/')) != NULL) {
file = p + 1;
}
#endif /*_OSD_POSIX || WIN32 */
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"%s(%d): ", file, line);
}
#endif /* TPF */
if (c) {
/* XXX: TODO: add a method of selecting whether logged client
* addresses are in dotted quad or resolved form... dotted
* quad is the most secure, which is why I'm implementing it
* first. -djg
*/
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"[client %s] ", c->remote_ip);
}
if (status != 0) {
if (status < APR_OS_START_EAIERR) {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"(%d)", status);
}
else if (status < APR_OS_START_SYSERR) {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"(EAI %d)", status - APR_OS_START_EAIERR);
}
else if (status < 100000 + APR_OS_START_SYSERR) {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"(OS %d)", status - APR_OS_START_SYSERR);
}
else {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
"(os 0x%08x)", status - APR_OS_START_SYSERR);
}
apr_strerror(status, errstr + len, MAX_STRING_LEN - len);
len += strlen(errstr + len);
if (MAX_STRING_LEN - len > 2) {
errstr[len++] = ':';
errstr[len++] = ' ';
errstr[len] = '\0';
}
}
errstrlen = len;
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
if (apr_vsnprintf(scratch, MAX_STRING_LEN - len, fmt, args)) {
len += ap_escape_errorlog_item(errstr + len, scratch,
MAX_STRING_LEN - len);
}
#else
len += apr_vsnprintf(errstr + len, MAX_STRING_LEN - len, fmt, args);
#endif
if ( r && (referer = apr_table_get(r->headers_in, "Referer"))
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
&& ap_escape_errorlog_item(scratch, referer, MAX_STRING_LEN - len)
#endif
) {
len += apr_snprintf(errstr + len, MAX_STRING_LEN - len,
", referer: %s",
#ifndef AP_UNSAFE_ERROR_LOG_UNESCAPED
scratch
#else
referer
#endif
);
}
/* NULL if we are logging to syslog */
if (logf) {
/* Truncate for the terminator (as apr_snprintf does) */
if (len > MAX_STRING_LEN - sizeof(APR_EOL_STR)) {
len = MAX_STRING_LEN - sizeof(APR_EOL_STR);
}
strcpy(errstr + len, APR_EOL_STR);
apr_file_puts(errstr, logf);
apr_file_flush(logf);
}
#ifdef HAVE_SYSLOG
else {
syslog(level_and_mask, "%s", errstr);
}
#endif
ap_run_error_log(file, line, level, status, s, r, pool, errstr + errstrlen);
}
SWITCH_DECLARE(int) switch_vsnprintf(char *buf, switch_size_t len, const char *format, va_list ap)
{
return apr_vsnprintf(buf, len, format, ap);
}
/**
* Extended internal log helper function. Use msr_log instead. If fixup is
* true, the message will be stripped of any trailing newline and any
* required bytes will be escaped.
*/
static void internal_log_ex(request_rec *r, directory_config *dcfg, modsec_rec *msr,
int level, int fixup, const char *text, va_list ap)
{
apr_size_t nbytes, nbytes_written;
apr_file_t *debuglog_fd = NULL;
int filter_debug_level = 0;
char *remote = NULL;
char *parse_remote = NULL;
char *saved = NULL;
char *str = NULL;
char str1[1024] = "";
char str2[1256] = "";
/* Find the logging FD and determine the logging level from configuration. */
if (dcfg != NULL) {
if ((dcfg->debuglog_fd != NULL)&&(dcfg->debuglog_fd != NOT_SET_P)) {
debuglog_fd = dcfg->debuglog_fd;
}
if (dcfg->debuglog_level != NOT_SET) {
filter_debug_level = dcfg->debuglog_level;
}
}
/* Return immediately if we don't have where to write
* or if the log level of the message is higher than
* wanted in the log.
*/
if ((level > 3)&&( (debuglog_fd == NULL) || (level > filter_debug_level) )) return;
/* Construct the message. */
apr_vsnprintf(str1, sizeof(str1), text, ap);
if (fixup) {
int len = strlen(str1);
/* Strip line ending. */
if (len && str1[len - 1] == '\n') {
str1[len - 1] = '\0';
}
if (len > 1 && str1[len - 2] == '\r') {
str1[len - 2] = '\0';
}
}
/* Construct the log entry. */
apr_snprintf(str2, sizeof(str2),
"[%s] [%s/sid#%pp][rid#%pp][%s][%d] %s\n",
current_logtime(msr->mp), ap_get_server_name(r), (r->server),
r, ((r->uri == NULL) ? "" : log_escape_nq(msr->mp, r->uri)),
level, (fixup ? log_escape_nq(msr->mp, str1) : str1));
/* Write to the debug log. */
if ((debuglog_fd != NULL)&&(level <= filter_debug_level)) {
nbytes = strlen(str2);
apr_file_write_full(debuglog_fd, str2, nbytes, &nbytes_written);
}
/* Send message levels 1-3 to the Apache error log and
* add it to the message list in the audit log. */
if (level <= 3) {
char *unique_id = (char *)get_env_var(r, "UNIQUE_ID");
char *hostname = (char *)msr->hostname;
if (unique_id != NULL) {
unique_id = apr_psprintf(msr->mp, " [unique_id \"%s\"]",
log_escape(msr->mp, unique_id));
}
else unique_id = "";
if (hostname != NULL) {
hostname = apr_psprintf(msr->mp, " [hostname \"%s\"]",
log_escape(msr->mp, hostname));
}
else hostname = "";
#if AP_SERVER_MAJORVERSION_NUMBER > 1 && AP_SERVER_MINORVERSION_NUMBER > 2
ap_log_rerror(APLOG_MARK, APLOG_ERR | APLOG_NOERRNO, 0, r,
"[client %s] ModSecurity: %s%s [uri \"%s\"]%s", r->useragent_ip ? r->useragent_ip : r->connection->client_ip, str1,
hostname, log_escape(msr->mp, r->uri), unique_id);
#else
ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_NOERRNO, 0, r->server,
"[client %s] ModSecurity: %s%s [uri \"%s\"]%s", msr->remote_addr ? msr->remote_addr : r->connection->remote_ip, str1,
hostname, log_escape(msr->mp, r->uri), unique_id);
#endif
/* Add this message to the list. */
if (msr != NULL) {
/* Force relevency if this is an alert */
msr->is_relevant++;
*(const char **)apr_array_push(msr->alerts) = apr_pstrdup(msr->mp, str1);
}
}
return;
}
void nx_log_exception(nx_logmodule_t logmodule,
const nx_exception_t *e,
const char *fmt,
...)
{
int i;
char errmsg[1024];
nx_loglevel_t loglevel = NX_LOGLEVEL_ERROR;
nx_ctx_t *ctx;
nx_string_t *tmpstr;
boolean empty = TRUE;
int size;
ASSERT(e != NULL);
ASSERT(e->num_throw > 0);
ctx = nx_ctx_get();
if ( ctx != NULL )
{
loglevel = ctx->loglevel;
}
tmpstr = nx_string_new();
if ( fmt != NULL )
{
va_list ap;
va_start(ap, fmt);
size = apr_vsnprintf(errmsg, sizeof(errmsg), fmt, ap);
va_end(ap);
nx_string_append(tmpstr, errmsg, size);
empty = FALSE;
}
if ( loglevel == NX_LOGLEVEL_DEBUG )
{
if ( (e->caused_by)[0] != '\0' )
{
ASSERT(e->num_throw > 0);
i = (int) (e->num_throw) - 1;
if ( empty != TRUE )
{
nx_string_append(tmpstr, NX_LINEFEED, -1);
}
size = apr_snprintf(errmsg, sizeof(errmsg),
"Exception was caused by \"%s\" at %s:%d/%s()",
e->caused_by, e->throwlist[i].file,
e->throwlist[i].line, e->throwlist[i].func);
nx_string_append(tmpstr, errmsg, size);
empty = FALSE;
}
}
for ( i = ((int) e->num_throw) - 1; i >= 0; i-- )
{
if ( loglevel == NX_LOGLEVEL_DEBUG )
{
if ( e->throwlist[i].msgoffs < 0 )
{
if ( empty != TRUE )
{
nx_string_append(tmpstr, NX_LINEFEED, -1);
}
size = apr_snprintf(errmsg, sizeof(errmsg),
"[%s:%d/%s()] -",
e->throwlist[i].file, e->throwlist[i].line,
e->throwlist[i].func);
nx_string_append(tmpstr, errmsg, size);
empty = FALSE;
}
else
{
if ( empty != TRUE )
{
nx_string_append(tmpstr, NX_LINEFEED, -1);
}
size = apr_snprintf(errmsg, sizeof(errmsg),
"[%s:%d/%s()] %s",
e->throwlist[i].file, e->throwlist[i].line,
e->throwlist[i].func, e->msgbuf + e->throwlist[i].msgoffs);
nx_string_append(tmpstr, errmsg, size);
empty = FALSE;
}
}
else
{
if ( e->throwlist[i].msgoffs < 0 )
{
}
else
{
if ( empty != TRUE )
{
nx_string_append(tmpstr, NX_LINEFEED, -1);
}
nx_string_append(tmpstr, e->msgbuf + e->throwlist[i].msgoffs, -1);
empty = FALSE;
}
}
}
if ( e->code != APR_SUCCESS )
{
apr_strerror(e->code, errmsg, sizeof(errmsg));
if ( empty != TRUE )
{
nx_string_append(tmpstr, NX_LINEFEED, -1);
}
nx_string_append(tmpstr, errmsg, -1);
empty = FALSE;
}
nx_log(e->code, NX_LOGLEVEL_ERROR, logmodule, "%s", tmpstr->buf);
nx_string_free(tmpstr);
}
static void ssl_log_cert_error(const char *file, int line, int level,
apr_status_t rv, const server_rec *s,
const conn_rec *c, const request_rec *r,
apr_pool_t *p, X509 *cert, const char *format,
va_list ap)
{
char buf[HUGE_STRING_LEN];
int msglen, n;
char *name;
apr_vsnprintf(buf, sizeof buf, format, ap);
msglen = strlen(buf);
if (cert) {
BIO *bio = BIO_new(BIO_s_mem());
if (bio) {
/*
* Limit the maximum length of the subject and issuer DN strings
* in the log message. 300 characters should always be sufficient
* for holding both the timestamp, module name, pid etc. stuff
* at the beginning of the line and the trailing information about
* serial, notbefore and notafter.
*/
int maxdnlen = (HUGE_STRING_LEN - msglen - 300) / 2;
BIO_puts(bio, " [subject: ");
name = modssl_X509_NAME_to_string(p, X509_get_subject_name(cert),
maxdnlen);
if (!strIsEmpty(name)) {
BIO_puts(bio, name);
} else {
BIO_puts(bio, "-empty-");
}
BIO_puts(bio, " / issuer: ");
name = modssl_X509_NAME_to_string(p, X509_get_issuer_name(cert),
maxdnlen);
if (!strIsEmpty(name)) {
BIO_puts(bio, name);
} else {
BIO_puts(bio, "-empty-");
}
BIO_puts(bio, " / serial: ");
if (i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert)) == -1)
BIO_puts(bio, "(ERROR)");
BIO_puts(bio, " / notbefore: ");
ASN1_TIME_print(bio, X509_get_notBefore(cert));
BIO_puts(bio, " / notafter: ");
ASN1_TIME_print(bio, X509_get_notAfter(cert));
BIO_puts(bio, "]");
n = BIO_read(bio, buf + msglen, sizeof buf - msglen - 1);
if (n > 0)
buf[msglen + n] = '\0';
BIO_free(bio);
}
}
else {
apr_snprintf(buf + msglen, sizeof buf - msglen,
" [certificate: -not available-]");
}
if (r) {
ap_log_rerror(file, line, APLOG_MODULE_INDEX, level, rv, r, "%s", buf);
}
else if (c) {
ap_log_cerror(file, line, APLOG_MODULE_INDEX, level, rv, c, "%s", buf);
}
else if (s) {
ap_log_error(file, line, APLOG_MODULE_INDEX, level, rv, s, "%s", buf);
}
}
