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; }