Merge branch 'mannol-master'

1 files changed, 158 insertions, 81 deletions

diff --git a/toxcore/logger.c b/toxcore/logger.c
index 674d72e9..fa9d1760 100644
--- a/toxcore/logger.c
+++ b/toxcore/logger.c
@@ -1,7 +1,5 @@
 /*  logger.c
  *
- *  Wrapping logger functions in nice macros
- *
  *  Copyright (C) 2013 Tox project All Rights Reserved.
  *
  *  This file is part of Tox.
@@ -26,10 +24,7 @@
 #endif /* HAVE_CONFIG_H */
 
 #include "logger.h"
-
-#ifdef LOGGING
-
-#include "network.h" /* for time */
+#include "crypto_core.h" /* for random_int() */
 
 #include <stdio.h>
 #include <errno.h>
@@ -37,121 +32,203 @@
 #include <stdarg.h>
 #include <inttypes.h>
 #include <time.h>
+#include <pthread.h>
 
 #if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-#define strerror_r(errno,buf,len) strerror_s(buf,len,errno)
+#   define getpid() ((unsigned) GetCurrentProcessId())
+#   define SFILE(FILE__M) (strrchr(FILE__M, '\\') ? strrchr(FILE__M, '\\') + 1 : FILE__M)
+#else
+#   define SFILE(FILE__M) (strrchr(FILE__M, '/') ? strrchr(FILE__M, '/') + 1 : FILE__M)
 #endif
 
-static struct logger_config {
+
+typedef struct logger {
     FILE *log_file;
-    LoggerLevel level;
+    LOG_LEVEL level;
     uint64_t start_time; /* Time when lib loaded */
-}
-logger = {
-    NULL,
-    DEBUG,
-    0
+    char *id;
+
+    /* Allocate these once */
+    char *tstr;
+    char *posstr;
+    char *msg;
+
+    /* For thread synchronisation */
+    pthread_mutex_t mutex[1];
+} logger;
+
+logger *global = NULL;
+
+const char *LOG_LEVEL_STR [] = {
+    [LOG_TRACE]   = "TRACE",
+    [LOG_DEBUG]   = "DEBUG",
+    [LOG_INFO]    = "INFO" ,
+    [LOG_WARNING] = "WARN" ,
+    [LOG_ERROR]   = "ERROR",
 };
 
-void __attribute__((destructor)) terminate_logger()
+char *strtime(char *dest, size_t max_len)
 {
-    if ( !logger.log_file ) return;
-
-    time_t tim = time(NULL);
+    time_t timer;
+    struct tm *tm_info;
 
-    logger_write(ERROR, "\n============== Closing logger [%u] ==============\n"
-                 "Time: %s", logger_get_pid(), asctime(localtime(&tim)));
+    time(&timer);
+    tm_info = localtime(&timer);
 
-    fclose(logger.log_file);
+    strftime(dest, max_len, "%m:%d %H:%M:%S", tm_info);
+    return dest;
 }
 
-unsigned logger_get_pid()
+
+/**
+ * Public Functions
+ */
+logger *logger_new (const char *file_name, LOG_LEVEL level, const char *id)
 {
-    return
-#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32)
-        GetCurrentProcessId();
-#else
-        getpid();
+#ifndef LOGGING /* Disabled */
+    return NULL;
 #endif
-}
 
-const char *logger_stringify_level(LoggerLevel level)
-{
-    static const char *strings [] = {
-        "INFO",
-        "DEBUG",
-        "WARN",
-        "ERROR"
-    };
-
-    return strings[level];
-}
+    logger *retu = calloc(1, sizeof(logger));
 
+    if (!retu)
+        return NULL;
 
-int logger_init(const char *file_name, LoggerLevel level)
-{
-    if (logger.log_file) {
-        fprintf(stderr, "Error opening logger name: %s with level %d: file already opened!\n",
-                file_name, level);
-        return -1;
+    if ( pthread_mutex_init(retu->mutex, NULL) != 0 ) {
+        free(retu);
+        return NULL;
     }
 
-    logger.log_file = fopen(file_name, "ab");
-
-    if (logger.log_file == NULL) {
+    if (!(retu->log_file = fopen(file_name, "ab"))) {
         fprintf(stderr, "Error opening logger file: %s; info: %s\n", file_name, strerror(errno));
-        return -1;
+        free(retu);
+        pthread_mutex_destroy(retu->mutex);
+        return NULL;
     }
 
-    logger.level = level;
-    logger.start_time = current_time_monotonic();
+    if (!(retu->tstr = calloc(16, sizeof (char))) ||
+            !(retu->posstr = calloc(300, sizeof (char))) ||
+            !(retu->msg = calloc(4096, sizeof (char))) )
+        goto ERROR;
 
-    time_t tim = time(NULL);
-    logger_write(ERROR, "\n============== Starting logger [%u] ==============\n"
-                 "Time: %s", logger_get_pid(), asctime(localtime(&tim)));
-    return 0;
-}
+    if (id) {
+        if (!(retu->id = calloc(strlen(id) + 1, 1)))
+            goto ERROR;
 
+        strcpy(retu->id, id);
+    } else {
+        if (!(retu->id = malloc(8)))
+            goto ERROR;
 
-void logger_write (LoggerLevel level, const char *format, ...)
-{
-    if (logger.log_file == NULL) {
-        /*fprintf(stderr, "Logger file is NULL!\n");*/
-        return;
+        snprintf(retu->id, 8, "%u", random_int());
     }
 
-    if (logger.level > level) return; /* Don't print some levels xuh */
+    retu->level = level;
+    retu->start_time = current_time_monotonic();
 
-    va_list _arg;
-    va_start (_arg, format);
-    vfprintf (logger.log_file, format, _arg);
-    va_end (_arg);
+    fprintf(retu->log_file, "Successfully created and running logger id: %s; time: %s\n",
+            retu->id, strtime(retu->tstr, 16));
 
-    fflush(logger.log_file);
+    return retu;
+
+ERROR:
+    fprintf(stderr, "Failed to create logger!\n");
+    pthread_mutex_destroy(retu->mutex);
+    fclose(retu->log_file);
+    free(retu->tstr);
+    free(retu->posstr);
+    free(retu->msg);
+    free(retu->id);
+    free(retu);
+    return NULL;
 }
 
-char *logger_timestr(char *dest, size_t max_size)
+void logger_kill(logger *log)
 {
-    time_t timer;
-    struct tm *tm_info;
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
 
-    time(&timer);
-    tm_info = localtime(&timer);
+    if (!log)
+        return;
 
-    strftime(dest, max_size, "%m:%d %H:%M:%S", tm_info);
+    pthread_mutex_lock(log->mutex);
+    free(log->id);
+    free(log->tstr);
+    free(log->posstr);
+    free(log->msg);
 
-    return dest;
+    if (fclose(log->log_file) != 0 )
+        perror("Could not close log file");
 
-    /*uint64_t diff = (current_time_monotonic() - logger.start_time); /* ms * /
-    snprintf(dest, max_size, "%"PRIu64"", diff);
+    pthread_mutex_unlock(log->mutex);
+    pthread_mutex_destroy(log->mutex);
 
-    return dest; */
+    free(log);
 }
 
-char *logger_posstr (char *dest, size_t max_size, const char *file, int line)
+void logger_kill_global(void)
 {
-    snprintf(dest, max_size, "%s:%d", file, line);
-    return dest;
+    logger_kill(global);
+}
+
+void logger_set_global(logger *log)
+{
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
+
+    global = log;
+}
+
+logger *logger_get_global(void)
+{
+#ifndef LOGGING /* Disabled */
+    return NULL;
+#endif
+
+    return global;
 }
 
-#endif /* LOGGING */
+void logger_write (logger *log, LOG_LEVEL level, const char *file, int line, const char *format, ...)
+{
+#ifndef LOGGING /* Disabled */
+    return;
+#endif
+
+    static const char *logger_format =
+        "%s  "   /* Logger id string */
+        "%-16s"  /* Time string of format: %m:%d %H:%M:%S */
+        "%u  "   /* Thread id */
+        "%-5s  " /* Logger lever string */
+        "%-20s " /* File:line string */
+        "- %s"   /* Output message */
+        "\n";    /* Every new print new line */
+
+
+    logger *this_log = log ? log : global;
+
+    if (!this_log)
+        return;
+
+    /* Don't print levels lesser than set one */
+    if (this_log->level > level)
+        return;
+
+    pthread_mutex_lock(this_log->mutex);
+
+    /* Set position str */
+    snprintf(this_log->posstr, 300, "%s:%d", SFILE(file), line);
+
+    /* Set message */
+    va_list args;
+    va_start (args, format);
+    vsnprintf(this_log->msg, 4096, format, args);
+    va_end (args);
+
+    fprintf(this_log->log_file, logger_format, this_log->id, strtime(this_log->tstr, 16), pthread_self(),
+            LOG_LEVEL_STR[level], this_log->posstr, this_log->msg);
+    fflush(this_log->log_file);
+
+    pthread_mutex_unlock(this_log->mutex);
+}