void log_printf(FILE * io, const char *format, ...)
{
const char * prefix = "INFO";
const int mask = LOG_CPINFO;
/* write to the logfile, always */
if (logfile && (log_flags & mask)) {
int codepage = (logfile==stderr || logfile==stdout) ? stdio_codepage : 0;
va_list args;
va_start(args, format);
_log_write(logfile, codepage, prefix, format, args);
va_end(args);
}
/* write to io, if that's not the logfile already */
if (logfile!=io && (log_stderr & mask)) {
int dupe = check_dupe(format, prefix);
if (!dupe) {
va_list args;
va_start(args, format);
_log_write(io, stdio_codepage, prefix, format, args);
va_end(args);
}
}
if (log_flags & LOG_FLUSH) {
log_flush();
}
}
void log_info(const char *format, ...)
{
const char * prefix = "INFO";
const int mask = LOG_CPINFO;
/* write to the logfile, always */
if (logfile && (log_flags & mask)) {
va_list args;
va_start(args, format);
_log_write(logfile, 0, prefix, format, args);
va_end(args);
}
/* write to stderr, if that's not the logfile already */
if (logfile!=stderr && (log_stderr & mask)) {
int dupe = check_dupe(format, prefix);
if (!dupe) {
va_list args;
va_start(args, format);
_log_write(stderr, stdio_codepage, prefix, format, args);
va_end(args);
}
}
if (log_flags & LOG_FLUSH) {
log_flush();
}
}
static inline
void _log_pto_fetch_msg(thread_data_t* th_data)
{
fmbuf* pbuf = th_data->plog_buf;
char tmp_buf[LOG_MAX_LEN_PER_MSG];
char* tmsg = NULL;
log_msg_head_t header;
if ( fmbuf_pop(pbuf, &header, LOG_MSG_HEAD_SIZE) ) {
_log_event_notice(FLOG_EVENT_ERROR_ASYNC_POP);
return;
}
tmsg = fmbuf_rawget(pbuf, tmp_buf, (size_t)header.len);
if ( !tmsg ) {
_log_event_notice(FLOG_EVENT_ERROR_ASYNC_POP);
return;
}
size_t writen_len = _log_write(header.f, tmsg, (size_t)header.len);
if ( writen_len < (size_t)header.len) {
_log_event_notice(FLOG_EVENT_ERROR_WRITE);
}
fmbuf_pop(pbuf, NULL, (size_t)header.len);
}
void slog_level(const char *pfx, const PgSocket *sock, const char *fmt, ...)
{
char buf1[1024];
char buf2[1024];
char *user, *db, *host;
int port;
va_list ap;
db = sock->pool ? sock->pool->db->name : "(nodb)";
user = sock->auth_user ? sock->auth_user->name : "(nouser)";
if (sock->remote_addr.is_unix) {
host = "unix";
} else {
host = inet_ntoa(sock->remote_addr.ip_addr);
}
port = sock->remote_addr.port;
va_start(ap, fmt);
vsnprintf(buf1, sizeof(buf1), fmt, ap);
va_end(ap);
snprintf(buf2, sizeof(buf2), "%c-%p: %s/%s@%s:%d %s",
is_server_socket(sock) ? 'S' : 'C',
sock, db, user, host, port, buf1);
_log_write(pfx, buf2);
}
/*
* Log messages using the logconfig configuration.
*/
ATTR_HIDDEN
void log_print(const char *fmt, ...)
{
int ret;
size_t written = 0;
va_list ap;
/* This is a hard limit for the size of the line. */
char buf[4096];
assert(fmt);
if (!logconfig.fp) {
goto end;
}
memset(buf, 0, sizeof(buf));
va_start(ap, fmt);
if (logconfig.time_status == LOG_TIME_ADD) {
written = add_time_to_log(buf, sizeof(buf));
}
ret = vsnprintf(buf + written, sizeof(buf) - written, fmt, ap);
if (ret < 0) {
perror("[tsocks] vsnprintf log");
goto error;
}
_log_write(buf, sizeof(buf));
error:
va_end(ap);
end:
return;
}
static void _log_writeln(FILE * stream, int codepage, const char * prefix, const char *format, va_list args)
{
size_t len = strlen(format);
_log_write(stream, codepage, prefix, format, args);
if (format[len - 1] != '\n') {
fputc('\n', stream);
}
}
static
size_t _log_sync_write_to_kernel(flog_file_t* f,
const char* header, size_t header_len,
const char* log, size_t len)
{
size_t writen_len = 0;
pthread_mutex_lock(&g_log->lock);
{
writen_len += _log_write(f, header, header_len);
writen_len += _log_write(f, log, len);
writen_len += _log_write(f, "\n", 1);
}
pthread_mutex_unlock(&g_log->lock);
if ( writen_len < len + header_len ) {
_log_event_notice(FLOG_EVENT_ERROR_WRITE);
}
return writen_len;
}
void main_task
(
uint_32 initial_data
)
{
ENTRY_STRUCT entry;
_mqx_uint result;
_mqx_uint i;
uchar c;
/* Create the log component */
result = _log_create_component();
if (result != MQX_OK) {
printf("Main task: _log_create_component failed");
_task_block();
}
/* Create a log */
result = _log_create(MY_LOG,
10 * (sizeof(ENTRY_STRUCT)/sizeof(_mqx_uint)), 0);
if (result != MQX_OK) {
printf("Main task: _log_create failed");
_task_block();
}
/* Write the data to the log */
printf("Please type in 10 characters:\n");
for (i = 0; i < 10; i++) {
c = getchar();
result = _log_write(MY_LOG, 2, (_mqx_uint)c, i);
if (result != MQX_OK) {
printf("Main task: _log_write failed");
}
}
/* Read data from the log */
printf("\nLog contains:\n");
while (_log_read(MY_LOG, LOG_READ_OLDEST_AND_DELETE, 2,
(LOG_ENTRY_STRUCT_PTR)&entry) == MQX_OK)
{
printf("Time: %lu.%03u%03u, c=%c, i=%u\n",
entry.HEADER.SECONDS,
(_mqx_uint)entry.HEADER.MILLISECONDS,
(_mqx_uint)entry.HEADER.MICROSECONDS,
(uchar)entry.C & 0xff,
entry.I);
}
/* Destroy the log */
_log_destroy(MY_LOG);
_task_block();
}
static void log_stdio(void *data, int level, const char *module, const char *format, va_list args) {
FILE *out = (FILE *)data;
int codepage = (out == stderr || out == stdout) ? stdio_codepage : 0;
const char *prefix = log_prefix(level);
size_t len = strlen(format);
fprintf(out, "%s: ", prefix);
_log_write(out, codepage, format, args);
if (format[len - 1] != '\n') {
fputc('\n', out);
}
fflush(out);
}
static void _log(const char *pfx, const char *fmt, va_list ap)
{
char buf[1024];
vsnprintf(buf, sizeof(buf), fmt, ap);
_log_write(pfx, buf);
}
