int tr_snprintf(char *buf, size_t buflen, const char *fmt, ...)
{
int len;
va_list args;
va_start(args, fmt);
len = evutil_vsnprintf(buf, buflen, fmt, args);
va_end(args);
return len;
}
int
evutil_snprintf(char *buf, size_t buflen, const char *format, ...)
{
int r;
va_list ap;
va_start(ap, format);
r = evutil_vsnprintf(buf, buflen, format, ap);
va_end(ap);
return r;
}
static void
_warn_helper(int severity, const char *errstr, const char *fmt, va_list ap)
{
char buf[1024];
size_t len;
if (fmt != NULL)
evutil_vsnprintf(buf, sizeof(buf), fmt, ap);
else
buf[0] = '\0';
if (errstr) {
len = strlen(buf);
if (len < sizeof(buf) - 3) {
evutil_snprintf(buf + len, sizeof(buf) - len, ": %s", errstr);
}
}
event_log(severity, buf);
}
int
evbuffer_add_vprintf(struct evbuffer *buf, const char *fmt, va_list ap)
{
char *buffer;
size_t space;
size_t oldoff = buf->off;
int sz;
va_list aq;
/* make sure that at least some space is available */
evbuffer_expand(buf, 64);
for (;;) {
size_t used = buf->misalign + buf->off;
buffer = (char *)buf->buffer + buf->off;
assert(buf->totallen >= used);
space = buf->totallen - used;
#ifndef va_copy
#define va_copy(dst, src) memcpy(&(dst), &(src), sizeof(va_list))
#endif
va_copy(aq, ap);
sz = evutil_vsnprintf(buffer, space, fmt, aq);
va_end(aq);
if (sz < 0)
return (-1);
if ((size_t)sz < space) {
buf->off += sz;
if (buf->cb != NULL)
(*buf->cb)(buf, oldoff, buf->off, buf->cbarg);
return (sz);
}
if (evbuffer_expand(buf, sz + 1) == -1)
return (-1);
}
/* NOTREACHED */
}
void
event_logv_(int severity, const char *errstr, const char *fmt, va_list ap)
{
char buf[1024];
size_t len;
if (severity == EVENT_LOG_DEBUG && !event_debug_get_logging_mask_())
return;
if (fmt != NULL)
evutil_vsnprintf(buf, sizeof(buf), fmt, ap);
else
buf[0] = '\0';
if (errstr) {
len = strlen(buf);
if (len < sizeof(buf) - 3) {
evutil_snprintf(buf + len, sizeof(buf) - len, ": %s", errstr);
}
}
event_log(severity, buf);
}
void
tr_msg( const char * file, int line,
tr_msg_level level,
const char * name,
const char * fmt, ... )
{
const int err = errno; /* message logging shouldn't affect errno */
char buf[1024];
va_list ap;
tr_lockLock( getMessageLock( ) );
/* build the text message */
*buf = '\0';
va_start( ap, fmt );
evutil_vsnprintf( buf, sizeof( buf ), fmt, ap );
va_end( ap );
OutputDebugString( buf );
if( *buf )
{
if( messageQueuing )
{
tr_msg_list * newmsg;
newmsg = tr_new0( tr_msg_list, 1 );
newmsg->level = level;
newmsg->when = tr_time( );
newmsg->message = tr_strdup( buf );
newmsg->file = file;
newmsg->line = line;
newmsg->name = tr_strdup( name );
*messageQueueTail = newmsg;
messageQueueTail = &newmsg->next;
++messageQueueCount;
if( messageQueueCount > TR_MAX_MSG_LOG )
{
tr_msg_list * old = messageQueue;
messageQueue = old->next;
old->next = NULL;
tr_freeMessageList(old);
--messageQueueCount;
assert( messageQueueCount == TR_MAX_MSG_LOG );
}
}
else
{
char timestr[64];
FILE * fp;
fp = tr_getLog( );
if( fp == NULL )
fp = stderr;
tr_getLogTimeStr( timestr, sizeof( timestr ) );
if( name )
fprintf( fp, "[%s] %s: %s\n", timestr, name, buf );
else
fprintf( fp, "[%s] %s\n", timestr, buf );
fflush( fp );
}
}
tr_lockUnlock( getMessageLock( ) );
errno = err;
}
void
tr_logAddMessage (const char * file,
int line,
tr_log_level level,
const char * name,
const char * fmt,
...)
{
const int err = errno; /* message logging shouldn't affect errno */
char buf[1024];
int buf_len;
va_list ap;
tr_lockLock (getMessageLock ());
/* build the text message */
*buf = '\0';
va_start (ap, fmt);
buf_len = evutil_vsnprintf (buf, sizeof (buf), fmt, ap);
va_end (ap);
if (buf_len < 0)
return;
#ifdef _WIN32
if ((size_t) buf_len < sizeof (buf) - 3)
{
buf[buf_len + 0] = '\r';
buf[buf_len + 1] = '\n';
buf[buf_len + 2] = '\0';
OutputDebugStringA (buf);
buf[buf_len + 0] = '\0';
}
else
{
OutputDebugStringA (buf);
}
#endif
if (*buf)
{
if (tr_logGetQueueEnabled ())
{
tr_log_message * newmsg;
newmsg = tr_new0 (tr_log_message, 1);
newmsg->level = level;
newmsg->when = tr_time ();
newmsg->message = tr_strdup (buf);
newmsg->file = file;
newmsg->line = line;
newmsg->name = tr_strdup (name);
*myQueueTail = newmsg;
myQueueTail = &newmsg->next;
++myQueueLength;
if (myQueueLength > TR_LOG_MAX_QUEUE_LENGTH)
{
tr_log_message * old = myQueue;
myQueue = old->next;
old->next = NULL;
tr_logFreeQueue (old);
--myQueueLength;
assert (myQueueLength == TR_LOG_MAX_QUEUE_LENGTH);
}
}
else
{
tr_sys_file_t fp;
char timestr[64];
fp = tr_logGetFile ();
if (fp == TR_BAD_SYS_FILE)
fp = tr_sys_file_get_std (TR_STD_SYS_FILE_ERR, NULL);
tr_logGetTimeStr (timestr, sizeof (timestr));
if (name)
tr_sys_file_write_fmt (fp, "[%s] %s: %s" TR_NATIVE_EOL_STR, NULL, timestr, name, buf);
else
tr_sys_file_write_fmt (fp, "[%s] %s" TR_NATIVE_EOL_STR, NULL, timestr, buf);
tr_sys_file_flush (fp, NULL);
}
}
tr_lockUnlock (getMessageLock ());
errno = err;
}
int
logger(struct ProxyContext_ * const context,
const int crit, const char * const format, ...)
{
static char previous_line[MAX_LOG_LINE];
static time_t last_log_ts = (time_t) 0;
static unsigned int burst_counter = 0U;
char line[MAX_LOG_LINE];
va_list va;
const char *urgency;
time_t now = time(NULL);
size_t len;
int log_fd;
#ifndef DEBUG
if (crit == LOG_DEBUG) {
return 0;
}
#endif
switch (crit) {
case LOG_INFO:
urgency = "[INFO] ";
break;
case LOG_WARNING:
urgency = "[WARNING] ";
break;
case LOG_ERR:
urgency = "[ERROR] ";
break;
case LOG_NOTICE:
urgency = "[NOTICE] ";
break;
case LOG_DEBUG:
urgency = "[DEBUG] ";
break;
default:
urgency = "";
}
va_start(va, format);
len = (size_t) evutil_vsnprintf(line, sizeof line, format, va);
va_end(va);
if (len >= sizeof line) {
assert(sizeof line > (size_t) 0U);
len = sizeof line - (size_t) 1U;
}
line[len++] = 0;
#ifndef _WIN32
if (context != NULL && context->log_fd == -1 && context->daemonize) {
syslog(crit, "%s", line);
return 0;
}
#endif
if (memcmp(previous_line, line, len) == 0) {
burst_counter++;
if (burst_counter > LOGGER_ALLOWED_BURST_FOR_IDENTICAL_LOG_ENTRIES &&
now - last_log_ts < LOGGER_DELAY_BETWEEN_IDENTICAL_LOG_ENTRIES) {
return 1;
}
} else {
burst_counter = 0U;
}
last_log_ts = now;
assert(sizeof previous_line >= sizeof line);
memcpy(previous_line, line, len);
if (context == NULL || context->log_fd == -1) {
log_fd = STDERR_FILENO;
} else {
log_fd = context->log_fd;
}
#ifndef _WIN32
safe_write(log_fd, urgency, strlen(urgency), LOG_WRITE_TIMEOUT);
safe_write(log_fd, line, strlen(line), LOG_WRITE_TIMEOUT);
safe_write(log_fd, "\n", (size_t) 1U, LOG_WRITE_TIMEOUT);
#else
(void) log_fd;
printf("%s%s\n", urgency, line);
fflush(stdout);
#endif
return 0;
}
void
tr_logAddMessage (const char * file,
int line,
tr_log_level level,
const char * name,
const char * fmt,
...)
{
const int err = errno; /* message logging shouldn't affect errno */
char buf[1024];
va_list ap;
tr_lockLock (getMessageLock ());
/* build the text message */
*buf = '\0';
va_start (ap, fmt);
evutil_vsnprintf (buf, sizeof (buf), fmt, ap);
va_end (ap);
OutputDebugStringA (buf);
if (*buf)
{
if (tr_logGetQueueEnabled ())
{
tr_log_message * newmsg;
newmsg = tr_new0 (tr_log_message, 1);
newmsg->level = level;
newmsg->when = tr_time ();
newmsg->message = tr_strdup (buf);
newmsg->file = file;
newmsg->line = line;
newmsg->name = tr_strdup (name);
*myQueueTail = newmsg;
myQueueTail = &newmsg->next;
++myQueueLength;
if (myQueueLength > TR_LOG_MAX_QUEUE_LENGTH)
{
tr_log_message * old = myQueue;
myQueue = old->next;
old->next = NULL;
tr_logFreeQueue (old);
--myQueueLength;
assert (myQueueLength == TR_LOG_MAX_QUEUE_LENGTH);
}
}
else
{
FILE * fp;
char timestr[64];
fp = tr_logGetFile ();
if (fp == NULL)
fp = stderr;
tr_logGetTimeStr (timestr, sizeof (timestr));
if (name)
fprintf (fp, "[%s] %s: %s\n", timestr, name, buf);
else
fprintf (fp, "[%s] %s\n", timestr, buf);
fflush (fp);
}
}
tr_lockUnlock (getMessageLock ());
errno = err;
}
