String string_vprintf(const char* format, va_list ap)
{
char *rtn = str_vprintf(format, ap);
String return_String(rtn);
free(rtn);
return(return_String);
}
void
str_printf_add (str_t d, const char *fmt, ...)
{
va_list ap;
va_start (ap, fmt);
str_vprintf (d, fmt, 1, ap);
va_end (ap);
}
inline std::string str_vprintf(const char* format, va_list args)
{
std::string s;
int n = str_vprintf(s, format, args);
if (n < 0) {
throw std::invalid_argument("str_vprintf incorrect format");
}
return s;
}
char *str_printf(const char *format, ...) {
char *txt;
va_list arglist;
va_start(arglist, format);
txt=str_vprintf(format, arglist);
va_end(arglist);
return txt;
}
int str_printf(struct string *str, const char *fmt, ...)
{
int err;
va_list args;
va_start(args, fmt);
err = str_vprintf(str, 0, fmt, args);
va_end(args);
return err;
}
// formatter that appends formatted output to existing string
void string_append_printf(String& str, const char* format, ...)
{
va_list ap;
va_start(ap, format);
char* rtn;
rtn = str_vprintf(format, ap);
va_end(ap);
str.append(rtn);
//String rtn_string(rtn);
free(rtn);
}
struct str *str_printf(const char *fmt, ...)
{
struct str *ret;
va_list args;
va_start(args, fmt);
ret = str_vprintf(fmt, args);
va_end(args);
return ret;
}
inline std::string str_printf(const char* format, ...)
{
va_list args;
va_start(args, format);
try {
std::string s(str_vprintf(format, args));
va_end(args);
return s;
} catch (...) {
va_end(args);
throw;
}
}
inline int str_printf(StringType& s, const char* format, ...)
{
va_list args;
va_start(args, format);
int n;
try {
n = str_vprintf(s, format, args);
va_end(args);
} catch (...) {
va_end(args);
throw;
}
return n;
}
void fd_printf(CLI *c, int fd, const char *format, ...) {
va_list ap;
char *line;
va_start(ap, format);
line=str_vprintf(format, ap);
va_end(ap);
if(!line) {
s_log(LOG_ERR, "fd_printf: str_vprintf failed");
longjmp(c->err, 1);
}
fd_putline(c, fd, line);
str_free(line);
}
CIMPLE_NAMESPACE_BEGIN
// formatting function that returns a CIMPLE string.
String string_printf(const char* format, ...)
{
va_list ap;
va_start(ap, format);
char* rtn;
rtn = str_vprintf(format, ap);
va_end(ap);
String rtn_string(rtn);
free(rtn);
return(rtn_string);
}
void NotifyBoard::AddLog(std::array<std::string, 4> stLogType, const char *szLogFormat, ...)
{
std::string szLog;
bool bError = false;
{
va_list ap;
va_start(ap, szLogFormat);
try{
szLog = str_vprintf(szLogFormat, ap);
}catch(const std::exception &e){
bError = true;
szLog = str_printf("Exception caught in NotifyBoard::AddLog(\"%s\", ...): %s", szLogFormat, e.what());
}
va_end(ap);
}
int nLogType = bError ? Log::LOGTYPEV_WARNING : std::atoi(stLogType[0].c_str());
switch(nLogType){
case Log::LOGTYPEV_INFO:
{
AddXML(str_printf("<ROOT><OBJECT TYPE=\"PLAINTEXT\" COLOR=\"WHITE\">%s</OBJECT></ROOT>", szLog.c_str()).c_str(), {});
return;
}
case Log::LOGTYPEV_WARNING:
{
AddXML(str_printf("<ROOT><OBJECT TYPE=\"PLAINTEXT\" COLOR=\"BROWN\">%s</OBJECT></ROOT>", szLog.c_str()).c_str(), {});
return;
}
case Log::LOGTYPEV_FATAL:
{
AddXML(str_printf("<ROOT><OBJECT TYPE=\"PLAINTEXT\" COLOR=\"RED\">%s</OBJECT></ROOT>", szLog.c_str()).c_str(), {});
return;
}
case Log::LOGTYPEV_DEBUG:
{
AddXML(str_printf("<ROOT><OBJECT TYPE=\"PLAINTEXT\" COLOR=\"GREEN\">%s</OBJECT></ROOT>", szLog.c_str()).c_str(), {});
return;
}
default:
{
g_Log->AddLog(LOGTYPE_WARNING, "Invalid LogType %d: %s", nLogType, szLog.c_str());
AddXML(str_printf("<ROOT><OBJECT TYPE=\"PLAINTEXT\" COLOR=\"RED\">Invalid LogType %d: %s</OBJECT></ROOT>", nLogType, szLog.c_str()).c_str(), {});
return;
}
}
}
NO_INLINE void G_GNUC_COLD
assertion_warning_log(const assertion_data * const data,
const char * const fmt, ...)
{
static str_t *str;
va_list args;
assertion_message(data, FALSE);
if G_UNLIKELY(NULL == str)
str = str_new_not_leaking(512);
/*
* Log additional message.
*/
va_start(args, fmt);
str_vprintf(str, fmt, args);
va_end(args);
{
char time_buf[18];
char prefix[UINT_DEC_BUFLEN + CONST_STRLEN(" (WARNING-): ")];
unsigned stid = thread_small_id();
DECLARE_STR(4);
crash_time(time_buf, sizeof time_buf);
print_str(time_buf);
if (0 == stid) {
print_str(" (WARNING): ");
} else {
str_bprintf(prefix, sizeof prefix, " (WARNING-%u): ", stid);
print_str(prefix);
}
print_str(str_2c(str));
print_str("\n");
flush_err_str();
if (log_stdout_is_distinct())
flush_str(STDOUT_FILENO);
}
assertion_stacktrace();
}
void str_formalize( std::basic_string< CharType > & formattedString, int maxSize, const CharType * format, va_list vaList )
{
std::vector< CharType > strText( maxSize + 1, 0 );
try
{
if ( format )
{
size_t written = str_vprintf( strText.data(), maxSize + 1, format, vaList );
formattedString.assign( strText.data(), strText.data() + std::min( written, size_t( maxSize ) ) );
}
}
catch ( ... )
{
StringStream message;
message << ERROR_DB_FORMALIZE << formattedString.c_str();
DB_EXCEPT( EDatabaseExceptionCodes_DateTimeError, message.str() );
}
}
void
notify_error_msg (enum err_contest idxc, const char * msg, ...)
{
struct msg_cell *cell = emalloc (sizeof(struct msg_cell));
str_t tail;
va_list ap;
str_init_from_c (cell->msg, contest_id[idxc]);
va_start (ap, msg);
str_init (tail, 64);
str_vprintf (tail, msg, 0, ap);
str_append (cell->msg, tail, ' ');
str_free (tail);
va_end (ap);
cell->line = NULL;
cell->next = top;
top = cell;
}
void
notify_script_err_msg (enum err_contest idxc, int fline, int lline,
const char * msg, ...)
{
struct msg_cell *cell = emalloc (sizeof(struct msg_cell));
str_t tail;
va_list ap;
str_init_from_c (cell->msg, contest_id[idxc]);
va_start (ap, msg);
str_init (tail, 64);
str_vprintf (tail, msg, 0, ap);
str_append (cell->msg, tail, ' ');
str_free (tail);
va_end (ap);
cell->line = emalloc(sizeof(struct line_info));
cell->line->first = fline;
cell->line->last = lline;
cell->next = top;
top = cell;
}
/**
* Log message.
*/
void
gl_logv(const char *domain, GLogLevelFlags flags, const char *fmt, va_list args)
{
static str_t *msg[THREAD_MAX];
static bool logging[THREAD_MAX];
unsigned stid = thread_small_id();
G_IGNORE_PUSH(-Wformat-nonliteral); /* s_minilogv() call below */
if (logging[stid]) {
s_minilogv(flags | G_LOG_FLAG_RECURSION, FALSE, fmt, args);
return;
}
G_IGNORE_POP;
/*
* This call is thread-unsafe by construction, and supposed to be called
* only from the main thread. This is why it's OK to have a global
* ``logging'' variable.
*/
logging[stid] = TRUE;
if G_UNLIKELY(NULL == msg[stid])
msg[stid] = str_new_not_leaking(0);
str_vprintf(msg[stid], fmt, args);
if (handler_cb != NULL)
(*handler_cb)(domain, flags, str_2c(msg[stid]), handler_data);
else
s_minilog(flags, "%s", str_2c(msg[stid]));
logging[stid] = FALSE;
}
int str_vappend(struct string *str, const char *fmt, va_list args)
{
return str_vprintf(str, str->length, fmt, args);
}
void s_log(int level, const char *format, ...) {
va_list ap;
char *text, *stamp, *id;
struct LIST *tmp;
#ifdef USE_WIN32
DWORD libc_error;
#else
int libc_error;
#endif
int socket_error;
time_t gmt;
struct tm *timeptr;
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
struct tm timestruct;
#endif
TLS_DATA *tls_data;
tls_data=tls_get();
if(!tls_data) {
tls_data=tls_alloc(NULL, NULL, "log");
s_log(LOG_ERR, "INTERNAL ERROR: Uninitialized TLS at %s, line %d",
__FILE__, __LINE__);
}
/* performance optimization: skip the trivial case early */
if(log_mode==LOG_MODE_CONFIGURED && level>tls_data->opt->log_level)
return;
libc_error=get_last_error();
socket_error=get_last_socket_error();
/* format the id to be logged */
time(&gmt);
#if defined(HAVE_LOCALTIME_R) && defined(_REENTRANT)
timeptr=localtime_r(&gmt, ×truct);
#else
timeptr=localtime(&gmt);
#endif
stamp=str_printf("%04d.%02d.%02d %02d:%02d:%02d",
timeptr->tm_year+1900, timeptr->tm_mon+1, timeptr->tm_mday,
timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec);
id=str_printf("LOG%d[%s]", level, tls_data->id);
/* format the text to be logged */
va_start(ap, format);
text=str_vprintf(format, ap);
va_end(ap);
safestring(text);
CRYPTO_THREAD_read_lock(stunnel_locks[LOCK_LOG_MODE]);
if(log_mode==LOG_MODE_BUFFER) { /* save the text to log it later */
CRYPTO_THREAD_write_lock(stunnel_locks[LOCK_LOG_BUFFER]);
tmp=str_alloc_detached(sizeof(struct LIST));
tmp->next=NULL;
tmp->opt=tls_data->opt;
tmp->level=level;
tmp->stamp=stamp;
str_detach(tmp->stamp);
tmp->id=id;
str_detach(tmp->id);
tmp->text=text;
str_detach(tmp->text);
if(tail)
tail->next=tmp;
else
head=tmp;
tail=tmp;
CRYPTO_THREAD_write_unlock(stunnel_locks[LOCK_LOG_BUFFER]);
} else { /* ready log the text directly */
log_raw(tls_data->opt, level, stamp, id, text);
str_free(stamp);
str_free(id);
str_free(text);
}
CRYPTO_THREAD_read_unlock(stunnel_locks[LOCK_LOG_MODE]);
set_last_error(libc_error);
set_last_socket_error(socket_error);
}
