void logging_log(config_t *cfg, loglevel_e level, const char *fmt, ...)
{
va_list ap;
char date[APR_RFC822_DATE_LEN];
struct iovec vec[4];
apr_size_t blen;
if (cfg->loglevel < level) return;
va_start(ap, fmt);
apr_pool_clear(cfg->errorlog_p);
apr_rfc822_date(date, apr_time_now());
vec[0].iov_base = date;
vec[0].iov_len = APR_RFC822_DATE_LEN-1;
vec[1].iov_base = " ";
vec[1].iov_len = 2;
vec[2].iov_base = apr_pvsprintf(cfg->errorlog_p, fmt, ap);
vec[2].iov_len = strlen(vec[2].iov_base);
vec[3].iov_base = "\n";
vec[3].iov_len = 1;
if (level == LOGLEVEL_NOISE) {
apr_file_writev(cfg->errorlog_fperr,&vec[2],2,&blen);
}
if (cfg->loglevel > LOGLEVEL_NONE && cfg->errorlog_fp) {
apr_file_writev(cfg->errorlog_fp,vec,4,&blen);
}
va_end(ap);
}
/*++
LogFormatV
Adds an entry to the log file.
Arguments:
level - Log severity level.
format - Pointer to a buffer containing a printf-style format string.
argList - Argument list to insert into 'format'.
Return Values:
None.
Remarks:
This function could be called before the logging subsystem is initialized.
--*/
void
LogFormatV(
apr_uint32_t level,
const char *format,
va_list argList
)
{
apr_time_exp_t now;
char *message;
ASSERT(format != NULL);
if (level <= maxLevel && handle != NULL) {
// Write local time
apr_time_exp_lt(&now, apr_time_now());
apr_file_printf(handle, "%04d-%02d-%02d %02d:%02d:%02d - ",
now.tm_year+1900, now.tm_mon, now.tm_mday,
now.tm_hour, now.tm_min, now.tm_sec);
// Format and write log message
message = apr_pvsprintf(msgPool, format, argList);
if (message == NULL) {
message = "Unable to format message." APR_EOL_STR;
}
apr_file_puts(message, handle);
apr_file_flush(handle);
// Clear memory allocated when formatting the message
apr_pool_clear(msgPool);
}
}
void msIO_setHeader (const char *header, const char* value, ...)
{
va_list args;
va_start( args, value );
#ifdef MOD_WMS_ENABLED
msIOContext *ioctx = msIO_getHandler (stdout);
if(ioctx && !strcmp(ioctx->label,"apache")) {
request_rec *r = (request_rec*) (ioctx->cbData);
char *fullvalue = apr_pvsprintf(r->pool, value,args);
if (strcasecmp (header, "Content-Type") == 0) {
r->content_type = fullvalue;
} else if (strcasecmp (header, "Status") == 0) {
r->status = atoi (fullvalue);
} else {
apr_table_setn (r->headers_out,
apr_pstrdup (r->pool, header),
fullvalue
);
}
} else {
#endif // MOD_WMS_ENABLED
msIO_fprintf(stdout,"%s: ",header);
msIO_vfprintf(stdout,value,args);
msIO_fprintf(stdout,"\r\n");
#ifdef MOD_WMS_ENABLED
}
#endif
}
AP_DECLARE(void) ap_log_rerror(const char *file, int line, int level,
apr_status_t status, const request_rec *r,
const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
log_error_core(file, line, level, status, r->server, NULL, r, NULL, fmt,
args);
/*
* IF APLOG_TOCLIENT is set,
* AND the error level is 'warning' or more severe,
* AND there isn't already error text associated with this request,
* THEN make the message text available to ErrorDocument and
* other error processors.
*/
va_end(args);
va_start(args,fmt);
if ((level & APLOG_TOCLIENT)
&& ((level & APLOG_LEVELMASK) <= APLOG_WARNING)
&& (apr_table_get(r->notes, "error-notes") == NULL)) {
apr_table_setn(r->notes, "error-notes",
ap_escape_html(r->pool, apr_pvsprintf(r->pool, fmt,
args)));
}
va_end(args);
}
svn_error_t *
svn_error_wrap_apr(apr_status_t status,
const char *fmt,
...)
{
svn_error_t *err, *utf8_err;
va_list ap;
char errbuf[255];
const char *msg_apr, *msg;
err = make_error_internal(status, NULL);
if (fmt)
{
/* Grab the APR error message. */
apr_strerror(status, errbuf, sizeof(errbuf));
utf8_err = svn_utf_cstring_to_utf8(&msg_apr, errbuf, err->pool);
if (utf8_err)
msg_apr = NULL;
svn_error_clear(utf8_err);
/* Append it to the formatted message. */
va_start(ap, fmt);
msg = apr_pvsprintf(err->pool, fmt, ap);
va_end(ap);
err->message = apr_psprintf(err->pool, "%s%s%s", msg,
(msg_apr) ? ": " : "",
(msg_apr) ? msg_apr : "");
}
return err;
}
void apache_context_request_log(mapcache_context *c, mapcache_log_level level, char *message, ...) {
mapcache_context_apache_request *ctx = (mapcache_context_apache_request*)c;
va_list args;
va_start(args,message);
ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, ctx->request, "%s", apr_pvsprintf(c->pool,message,args));
va_end(args);
}
svn_string_t *
svn_string_createv(apr_pool_t *pool, const char *fmt, va_list ap)
{
char *data = apr_pvsprintf(pool, fmt, ap);
/* wrap an svn_string_t around the new data */
return create_string(data, strlen(data), pool);
}
void apache_context_server_log(mapcache_context *c, mapcache_log_level level, char *message, ...) {
mapcache_context_apache_server *ctx = (mapcache_context_apache_server*)c;
va_list args;
va_start(args,message);
char *msg = apr_pvsprintf(c->pool,message,args);
va_end(args);
ap_log_error(APLOG_MARK, APLOG_INFO, 0, ctx->server,"%s",msg);
}
static void fcgi_context_log(mapcache_context *c, mapcache_log_level level, char *message, ...)
{
va_list args;
if(!c->config || level >= c->config->loglevel) {
va_start(args,message);
fprintf(stderr,"%s\n",apr_pvsprintf(c->pool,message,args));
va_end(args);
}
}
static void server_error(request_rec *r, const char *fmt, ...)
{
va_list argp;
const char *msg;
va_start(argp, fmt);
msg = apr_pvsprintf(r->pool, fmt, argp);
va_end(argp);
ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, 0, r->server, "%s", msg);
}
svn_stringbuf_t *
svn_stringbuf_createv(apr_pool_t *pool, const char *fmt, va_list ap)
{
char *data = apr_pvsprintf(pool, fmt, ap);
apr_size_t size = strlen(data);
/* wrap an svn_stringbuf_t around the new data */
return create_stringbuf(data, size, size + 1, pool);
}
static void ngx_mapcache_context_log(mapcache_context *c, mapcache_log_level level, char *message, ...) {
mapcache_ngx_context *ctx = (mapcache_ngx_context*)c;
va_list args;
if(!c->config || level >= c->config->loglevel) {
va_start(args,message);
ngx_log_error(NGX_LOG_ALERT, ctx->r->connection->log, 0,
apr_pvsprintf(c->pool,message,args));
va_end(args);
}
}
static svn_error_t *writebuf_printf(svn_ra_svn_conn_t *conn, apr_pool_t *pool,
const char *fmt, ...)
{
va_list ap;
char *str;
va_start(ap, fmt);
str = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
return writebuf_write(conn, pool, str, strlen(str));
}
/* A quick way to create error messages. */
static svn_error_t *
fail(apr_pool_t *pool, const char *fmt, ...)
{
va_list ap;
char *msg;
va_start(ap, fmt);
msg = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
return svn_error_create(SVN_ERR_TEST_FAILED, SVN_NO_ERROR, msg);
}
void wodan_trace(request_rec *r, int level, const char *file, int line, const char *func, const char *formatstring, ...)
{
va_list ap, cp;
char *message = NULL;
va_start(ap, formatstring);
va_copy(cp, ap);
message = apr_pvsprintf(r->pool, formatstring, cp);
va_end(cp);
ap_log_error(file, line, level, 0, r->server, LOGFORMAT, func, message);
}
static int JK_METHOD jk2_logger_file_jkVLog(jk_env_t *env, jk_logger_t *l,
const char *file,
int line,
int level,
const char *fmt,
va_list args)
{
int rc = 0;
char *buf;
char *fmt1;
apr_pool_t *aprPool = env->tmpPool->_private;
char rfctime[APR_RFC822_DATE_LEN];
apr_time_t time = apr_time_now();
if (!file || !args)
return -1;
if (l->logger_private == NULL ||
l->level <= level) {
char *f = (char *)(file + strlen(file) - 1);
char *slevel;
switch (level){
case JK_LOG_INFO_LEVEL:
slevel = JK_LOG_INFO_VERB;
break;
case JK_LOG_ERROR_LEVEL:
slevel = JK_LOG_ERROR_VERB;
break;
case JK_LOG_EMERG_LEVEL:
slevel = JK_LOG_EMERG_VERB;
break;
case JK_LOG_DEBUG_LEVEL:
default:
slevel = JK_LOG_DEBUG_VERB;
break;
}
while (f != file && *f != '\\' && *f != '/')
f--;
if (f != file)
++f;
/* XXX rfc822_date or apr_ctime ? */
apr_ctime(rfctime, time);
fmt1 = apr_psprintf(aprPool, "[%s] (%5s ) [%s (%d)] %s", rfctime, slevel, f, line, fmt);
buf = apr_pvsprintf(aprPool, fmt1, args);
l->log(env, l, level, buf);
}
return rc;
}
void ApacheLogger::error(const char *file, int line, server_rec *s,
const char *format, ...)
{
TemporaryPool temp_pool;
const char *message;
va_list args;
va_start(args, format);
message = apr_pvsprintf(temp_pool.get(), format, args);
va_end(args);
AP_LOG_ERROR(file, line, APLOG_ERR, 0, s, "%s", message);
}
void ApacheLogger::warn(const char *file, int line,
ApacheResponse::Handle *r, const char *format, ...)
{
TemporaryPool temp_pool;
const char *message;
va_list args;
va_start(args, format);
message = apr_pvsprintf(temp_pool.get(), format, args);
va_end(args);
AP_LOG_RERROR(file, line, APLOG_WARNING, 0, r, "%s", message);
}
/**
* a quick way to create error messages
*/
static void
fail(apr_pool_t *pool, apr_status_t status, const char *fmt, ...)
{
va_list ap;
char *msg;
svn_error_t * error;
va_start(ap, fmt);
msg = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
error = svn_error_create(status, nullptr, msg);
throw ClientException(error);
}
/**
* Perform a stream printf style write
*/
static char* mod_sslhaf_snprintf(sslhaf_cfg_t *cfg,
char *buf, size_t len, const char *format, ...) {
va_list args;
conn_rec *c = cfg->user_data;
va_start(args, format);
if (buf == NULL) {
buf = apr_pvsprintf(c->pool, format, args);
} else {
vsnprintf(buf, len, format, args);
}
va_end(args);
return buf;
}
svn_stringbuf_t *
svn_stringbuf_createv(apr_pool_t *pool, const char *fmt, va_list ap)
{
char *data = apr_pvsprintf(pool, fmt, ap);
apr_size_t size = strlen(data);
svn_stringbuf_t *new_string;
new_string = apr_palloc(pool, sizeof(*new_string));
new_string->data = data;
new_string->len = size;
new_string->blocksize = size + 1;
new_string->pool = pool;
return new_string;
}
svn_error_t *
svn_stream_printf(svn_stream_t *stream,
apr_pool_t *pool,
const char *fmt,
...)
{
const char *message;
va_list ap;
va_start(ap, fmt);
message = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
return svn_error_trace(svn_stream_puts(stream, message));
}
void range_request_warn(range_request* rr, const char* fmt, ...)
{
va_list ap;
char* p = rr->warnings;
char* warn;
if (!rr->warn_enabled) return;
va_start(ap, fmt);
warn = apr_pvsprintf(rr->pool, fmt, ap);
va_end(ap);
if (p)
rr->warnings = apr_psprintf(rr->pool, "%s|%s", p, warn);
else
rr->warnings = warn;
}
svn_error_t *
svn_stream_printf(svn_stream_t *stream,
apr_pool_t *pool,
const char *fmt,
...)
{
const char *message;
va_list ap;
apr_size_t len;
va_start(ap, fmt);
message = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
len = strlen(message);
return svn_stream_write(stream, message, &len);
}
svn_error_t *
svn_error_createf(apr_status_t apr_err,
svn_error_t *child,
const char *fmt,
...)
{
svn_error_t *err;
va_list ap;
err = make_error_internal(apr_err, child);
va_start(ap, fmt);
err->message = apr_pvsprintf(err->pool, fmt, ap);
va_end(ap);
return err;
}
void px_log(const px_config *conf, apr_pool_t *pool, bool log_debug, int level, const char *func, const char *fmt, ...) {
// do not log debug messages if debugMode is disabled
if (!conf || !pool || (!conf->px_debug && log_debug)) {
return;
}
va_list ap;
char *text;
va_start(ap, fmt);
text = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
ap_log_error(APLOG_MARK,
conf->px_debug ? level : conf->log_level_err,
0, conf->server,
log_debug ? LOGGER_DEBUG_HDR: LOGGER_ERROR_HDR,
conf->app_id, func, text);
}
svn_error_t *
svn_stream_printf_from_utf8(svn_stream_t *stream,
const char *encoding,
apr_pool_t *pool,
const char *fmt,
...)
{
const char *message, *translated;
va_list ap;
va_start(ap, fmt);
message = apr_pvsprintf(pool, fmt, ap);
va_end(ap);
SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated, message, encoding,
pool));
return svn_error_trace(svn_stream_puts(stream, translated));
}
svn_error_t *
svn_fs_bdb__dberrf(bdb_env_baton_t *bdb_baton,
int db_err, const char *fmt, ...)
{
va_list ap;
char *msg;
svn_error_t *err;
svn_error_t *child_errors;
child_errors = bdb_baton->error_info->pending_errors;
bdb_baton->error_info->pending_errors = NULL;
err = svn_error_create(bdb_err_to_apr_err(db_err), child_errors, NULL);
va_start(ap, fmt);
msg = apr_pvsprintf(err->pool, fmt, ap);
va_end(ap);
err->message = apr_psprintf(err->pool, "%s%s", msg, db_strerror(db_err));
return err;
}
/**
* virgule_send_error_page: Render an error page using the default template.
* If buffer allocation problems occur, declare an internal error and abort.
* Error types:
* 0 Error
* 1 Info
* ToDo: We could generate an Apache error log entry before aborting.
*/
int
virgule_send_error_page (VirguleReq *vr, int type, const char *error_short, const char *fmt, ...)
{
va_list ap;
char *emsg[] = { "Error", "Info" };
char *title = apr_psprintf (vr->r->pool, "%s: %s", emsg[type], error_short);
if (vr->r->status == 404)
vr->r->status_line = apr_pstrdup (vr->r->pool, "404 Not Found");
if (virgule_set_temp_buffer (vr) != 0)
return HTTP_INTERNAL_SERVER_ERROR;
va_start (ap, fmt);
virgule_buffer_puts (vr->b, apr_pvsprintf (vr->r->pool, fmt, ap));
va_end (ap);
virgule_set_main_buffer (vr);
return virgule_render_in_template (vr, "/templates/default.xml", "content", title);
}
apr_status_t lfd_cmdio_write(struct lfd_sess * sess, int cmd, const char *msg, ...)
{
va_list ap;
char * buff = NULL;
apr_size_t len;
apr_status_t rc = APR_SUCCESS;
buff = apr_pstrcat(sess->loop_pool, "AAAA", msg, "\r\n", NULL);
cmd_to_str(cmd, buff);
va_start(ap, msg);
buff = apr_pvsprintf(sess->loop_pool, buff, ap);
len = strlen(buff);
rc = apr_socket_send(sess->comm_sock, buff, &len);
va_end(ap);
if (lfd_config_debug)
fprintf(stderr, "-> %s", buff);
return rc;
}
