Fixed one serious bug, working on another. Still very broken.
[oweals/gnunet.git] / src / util / common_logging.c
index ff11c777733d57046894f35142040ddffd58729d..f5688f42c620495d8d237396139548a8d217c0c3 100644 (file)
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2006-2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.
 */
 
 /**
  * @file util/common_logging.c
  * @brief error handling API
- *
  * @author Christian Grothoff
  */
 #include "platform.h"
-#include "gnunet_common.h"
 #include "gnunet_crypto_lib.h"
 #include "gnunet_strings_lib.h"
-#include "gnunet_time_lib.h"
-
 #include <regex.h>
 
+
 /**
  * After how many milliseconds do we always print
  * that "message X was repeated N times"?  Use 12h.
  */
-#define BULK_DELAY_THRESHOLD (12 * 60 * 60 * 1000)
+#define BULK_DELAY_THRESHOLD (12 * 60 * 60 * 1000LL * 1000LL)
 
 /**
  * After how many repetitions do we always print
@@ -152,7 +149,7 @@ static struct CustomLogger *loggers;
 /**
  * Number of log calls to ignore.
  */
-unsigned int skip_log;
+int skip_log = 0;
 
 /**
  * File descriptor to use for "stderr", or NULL for none.
@@ -285,7 +282,7 @@ resize_logdefs ()
  * Abort the process, generate a core dump if possible.
  */
 void
-GNUNET_abort ()
+GNUNET_abort_ ()
 {
 #if WINDOWS
   DebugBreak ();
@@ -298,7 +295,7 @@ GNUNET_abort ()
  * Rotate logs, deleting the oldest log.
  *
  * @param new_name new name to add to the rotation
- */ 
+ */
 static void
 log_rotate (const char *new_name)
 {
@@ -317,7 +314,7 @@ log_rotate (const char *new_name)
     GNUNET_free (discard);
   }
   rotation[rotation_off % ROTATION_KEEP] = GNUNET_strdup (new_name);
-  rotation_off++;  
+  rotation_off++;
 }
 
 
@@ -325,27 +322,36 @@ log_rotate (const char *new_name)
  * Setup the log file.
  *
  * @param tm timestamp for which we should setup logging
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
 setup_log_file (const struct tm *tm)
 {
-  static char last_fn[PATH_MAX + 1];  
+  static char last_fn[PATH_MAX + 1];
   char fn[PATH_MAX + 1];
-  int dirwarn;
   int altlog_fd;
   int dup_return;
   FILE *altlog;
-  
+  char *leftsquare;
+
   if (NULL == log_file_name)
     return GNUNET_SYSERR;
   if (0 == strftime (fn, sizeof (fn), log_file_name, tm))
     return GNUNET_SYSERR;
+  leftsquare = strrchr (fn, '[');
+  if ( (NULL != leftsquare) && (']' == leftsquare[1]) )
+  {
+    char *logfile_copy = GNUNET_strdup (fn);
+    logfile_copy[leftsquare - fn] = '\0';
+    logfile_copy[leftsquare - fn + 1] = '\0';
+    snprintf (fn, PATH_MAX, "%s%d%s",
+         logfile_copy, getpid (), &logfile_copy[leftsquare - fn + 2]);
+    GNUNET_free (logfile_copy);
+  }
   if (0 == strcmp (fn, last_fn))
     return GNUNET_OK; /* no change */
   log_rotate (last_fn);
   strcpy (last_fn, fn);
-  dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
 #if WINDOWS
   altlog_fd = OPEN (fn, O_APPEND |
                         O_BINARY |
@@ -379,16 +385,13 @@ setup_log_file (const struct tm *tm)
   if (-1 == altlog_fd)
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
-    if (dirwarn)
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to create or access directory for log file `%s'\n"),
-                  fn);
     return GNUNET_SYSERR;
   }
-  GNUNET_stderr = altlog; 
+  GNUNET_stderr = altlog;
   return GNUNET_OK;
 }
 
+
 /**
  * Utility function - adds a parsed definition to logdefs array.
  *
@@ -654,10 +657,12 @@ parse_all_definitions ()
  * @param comp default component to use
  * @param loglevel what types of messages should be logged
  * @param logfile which file to write log messages to (can be NULL)
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
  */
 int
-GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
+GNUNET_log_setup (const char *comp,
+                 const char *loglevel,
+                 const char *logfile)
 {
   const char *env_logfile;
   const struct tm *tm;
@@ -694,14 +699,14 @@ GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
  * Add a custom logger.
  *
  * @param logger log function
- * @param logger_cls closure for logger
+ * @param logger_cls closure for @a logger
  */
 void
 GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
 {
   struct CustomLogger *entry;
 
-  entry = GNUNET_malloc (sizeof (struct CustomLogger));
+  entry = GNUNET_new (struct CustomLogger);
   entry->logger = logger;
   entry->logger_cls = logger_cls;
   entry->next = loggers;
@@ -713,7 +718,7 @@ GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
  * Remove a custom logger.
  *
  * @param logger log function
- * @param logger_cls closure for logger
+ * @param logger_cls closure for @a logger
  */
 void
 GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
@@ -723,20 +728,24 @@ GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
 
   prev = NULL;
   pos = loggers;
-  while ((pos != NULL) &&
+  while ((NULL != pos) &&
          ((pos->logger != logger) || (pos->logger_cls != logger_cls)))
   {
     prev = pos;
     pos = pos->next;
   }
-  GNUNET_assert (pos != NULL);
-  if (prev == NULL)
+  GNUNET_assert (NULL != pos);
+  if (NULL == prev)
     loggers = pos->next;
   else
     prev->next = pos->next;
   GNUNET_free (pos);
 }
 
+#if WINDOWS
+CRITICAL_SECTION output_message_cs;
+#endif
+
 
 /**
  * Actually output the log message.
@@ -751,7 +760,9 @@ output_message (enum GNUNET_ErrorType kind, const char *comp,
                 const char *datestr, const char *msg)
 {
   struct CustomLogger *pos;
-
+#if WINDOWS
+  EnterCriticalSection (&output_message_cs);
+#endif
   if (NULL != GNUNET_stderr)
   {
     FPRINTF (GNUNET_stderr, "%s %s %s %s", datestr, comp,
@@ -764,6 +775,9 @@ output_message (enum GNUNET_ErrorType kind, const char *comp,
     pos->logger (pos->logger_cls, kind, comp, datestr, msg);
     pos = pos->next;
   }
+#if WINDOWS
+  LeaveCriticalSection (&output_message_cs);
+#endif
 }
 
 
@@ -778,9 +792,9 @@ flush_bulk (const char *datestr)
   char msg[DATE_STR_SIZE + BULK_TRACK_SIZE + 256];
   int rev;
   char *last;
-  char *ft;
+  const char *ft;
 
-  if ((last_bulk_time.abs_value == 0) || (last_bulk_repeat == 0))
+  if ((0 == last_bulk_time.abs_value_us) || (0 == last_bulk_repeat))
     return;
   rev = 0;
   last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
@@ -794,11 +808,10 @@ flush_bulk (const char *datestr)
     last[0] = '\0';
   }
   ft = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration
-                                               (last_bulk_time));
+                                               (last_bulk_time), GNUNET_YES);
   snprintf (msg, sizeof (msg),
             _("Message `%.*s' repeated %u times in the last %s\n"),
             BULK_TRACK_SIZE, last_bulk, last_bulk_repeat, ft);
-  GNUNET_free (ft);
   if (rev == 1)
     last[0] = '\n';
   output_message (last_bulk_kind, last_bulk_comp, datestr, msg);
@@ -810,11 +823,12 @@ flush_bulk (const char *datestr)
 /**
  * Ignore the next n calls to the log function.
  *
- * @param n number of log calls to ignore
- * @param check_reset GNUNET_YES to assert that the log skip counter is currently zero
+ * @param n number of log calls to ignore (could be negative)
+ * @param check_reset #GNUNET_YES to assert that the log skip counter is currently zero
  */
 void
-GNUNET_log_skip (unsigned int n, int check_reset)
+GNUNET_log_skip (int n,
+                int check_reset)
 {
   int ok;
 
@@ -823,7 +837,7 @@ GNUNET_log_skip (unsigned int n, int check_reset)
     ok = (0 == skip_log);
     skip_log = 0;
     if (check_reset)
-      GNUNET_assert (ok);
+      GNUNET_break (ok);
   }
   else
   {
@@ -832,6 +846,18 @@ GNUNET_log_skip (unsigned int n, int check_reset)
 }
 
 
+/**
+ * Get the number of log calls that are going to be skipped
+ *
+ * @return number of log calls to be ignored
+ */
+int
+GNUNET_get_log_skip ()
+{
+  return skip_log;
+}
+
+
 /**
  * Output a log message using the default mechanism.
  *
@@ -841,7 +867,9 @@ GNUNET_log_skip (unsigned int n, int check_reset)
  * @param va arguments to the format string "message"
  */
 static void
-mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
+mylog (enum GNUNET_ErrorType kind,
+       const char *comp,
+       const char *message,
        va_list va)
 {
   char date[DATE_STR_SIZE];
@@ -857,11 +885,14 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
   memset (date, 0, DATE_STR_SIZE);
   {
     char buf[size];
+    long long offset;
 #ifdef WINDOWS
     LARGE_INTEGER pc;
     time_t timetmp;
 
+    offset = GNUNET_TIME_get_offset ();
     time (&timetmp);
+    timetmp += offset / 1000;
     tmptr = localtime (&timetmp);
     pc.QuadPart = 0;
     QueryPerformanceCounter (&pc);
@@ -880,6 +911,30 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
     struct timeval timeofday;
 
     gettimeofday (&timeofday, NULL);
+    offset = GNUNET_TIME_get_offset ();
+    if (offset > 0)
+    {
+      timeofday.tv_sec += offset / 1000LL;
+      timeofday.tv_usec += (offset % 1000LL) * 1000LL;
+      if (timeofday.tv_usec > 1000000LL)
+      {
+       timeofday.tv_usec -= 1000000LL;
+       timeofday.tv_sec++;
+      }
+    }
+    else
+    {
+      timeofday.tv_sec += offset / 1000LL;
+      if (timeofday.tv_usec > - (offset % 1000LL) * 1000LL)
+      {
+       timeofday.tv_usec += (offset % 1000LL) * 1000LL;
+      }
+      else
+      {
+       timeofday.tv_usec += 1000000LL + (offset % 1000LL) * 1000LL;
+       timeofday.tv_sec--;
+      }
+    }
     tmptr = localtime (&timeofday.tv_sec);
     if (NULL == tmptr)
     {
@@ -890,16 +945,18 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
       strftime (date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%06u", tmptr);
       snprintf (date, sizeof (date), date2, timeofday.tv_usec);
     }
-#endif  
+#endif
     VSNPRINTF (buf, size, message, va);
-    (void) setup_log_file (tmptr);
+    if (NULL != tmptr)
+      (void) setup_log_file (tmptr);
     if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
-        (last_bulk_time.abs_value != 0) &&
+        (0 != last_bulk_time.abs_value_us) &&
         (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
     {
       last_bulk_repeat++;
-      if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value >
-           BULK_DELAY_THRESHOLD) || (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
+      if ( (GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value_us >
+           BULK_DELAY_THRESHOLD) ||
+          (last_bulk_repeat > BULK_REPEAT_THRESHOLD) )
         flush_bulk (date);
       return;
     }
@@ -922,7 +979,8 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
  * @param ... arguments for format string
  */
 void
-GNUNET_log_nocheck (enum GNUNET_ErrorType kind, const char *message, ...)
+GNUNET_log_nocheck (enum GNUNET_ErrorType kind,
+                   const char *message, ...)
 {
   va_list va;
 
@@ -1026,16 +1084,19 @@ GNUNET_h2s_full (const struct GNUNET_HashCode * hc)
  *
  * @param pid the peer identity
  * @return string form of the pid; will be overwritten by next
- *         call to GNUNET_i2s.
+ *         call to #GNUNET_i2s.
  */
 const char *
 GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
 {
-  static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
-
-  GNUNET_CRYPTO_hash_to_enc (&pid->hashPubKey, &ret);
-  ret.encoding[4] = '\0';
-  return (const char *) ret.encoding;
+  static char buf[256];
+  char *ret;
+
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid->public_key);
+  strcpy (buf, ret);
+  GNUNET_free (ret);
+  buf[4] = '\0';
+  return buf;
 }
 
 
@@ -1046,15 +1107,18 @@ GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
  *
  * @param pid the peer identity
  * @return string form of the pid; will be overwritten by next
- *         call to GNUNET_i2s.
+ *         call to #GNUNET_i2s_full.
  */
 const char *
 GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
 {
-  static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+  static char buf[256];
+  char *ret;
 
-  GNUNET_CRYPTO_hash_to_enc (&pid->hashPubKey, &ret);
-  return (const char *) ret.encoding;
+  ret = GNUNET_CRYPTO_eddsa_public_key_to_string (&pid->public_key);
+  strcpy (buf, ret);
+  GNUNET_free (ret);
+  return buf;
 }
 
 
@@ -1064,14 +1128,22 @@ GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
  * in the entire API that is NOT reentrant!
  *
  * @param addr the address
- * @param addrlen the length of the address
+ * @param addrlen the length of the address in @a addr
  * @return nicely formatted string for the address
- *  will be overwritten by next call to GNUNET_a2s.
+ *  will be overwritten by next call to #GNUNET_a2s.
  */
 const char *
-GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
+GNUNET_a2s (const struct sockaddr *addr,
+            socklen_t addrlen)
 {
-  static char buf[INET6_ADDRSTRLEN + 8];
+#ifndef WINDOWS
+#define LEN GNUNET_MAX ((INET6_ADDRSTRLEN + 8),         \
+                        (1 + sizeof (struct sockaddr_un) - sizeof (sa_family_t)))
+#else
+#define LEN (INET6_ADDRSTRLEN + 8)
+#endif
+  static char buf[LEN];
+#undef LEN
   static char b2[6];
   const struct sockaddr_in *v4;
   const struct sockaddr_un *un;
@@ -1110,11 +1182,15 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
       return "<unbound UNIX client>";
     un = (const struct sockaddr_un *) addr;
     off = 0;
-    if (un->sun_path[0] == '\0')
+    if ('\0' == un->sun_path[0])
       off++;
-    snprintf (buf, sizeof (buf), "%s%.*s", (off == 1) ? "@" : "",
-              (int) (addrlen - sizeof (sa_family_t) - 1 - off),
-              &un->sun_path[off]);
+    memset (buf, 0, sizeof (buf));
+    GNUNET_snprintf (buf,
+                     sizeof (buf),
+                     "%s%.*s",
+                     (1 == off) ? "@" : "",
+                     (int) (addrlen - sizeof (sa_family_t) - off),
+                     &un->sun_path[off]);
     return buf;
   default:
     return _("invalid address");
@@ -1122,23 +1198,71 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
 }
 
 
+/**
+ * Log error message about missing configuration option.
+ *
+ * @param kind log level
+ * @param section section with missing option
+ * @param option name of missing option
+ */
+void
+GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
+                          const char *section,
+                          const char *option)
+{
+  GNUNET_log (kind,
+             _("Configuration fails to specify option `%s' in section `%s'!\n"),
+             option,
+             section);
+}
+
+
+/**
+ * Log error message about invalid configuration option value.
+ *
+ * @param kind log level
+ * @param section section with invalid option
+ * @param option name of invalid option
+ * @param required what is required that is invalid about the option
+ */
+void
+GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
+                          const char *section,
+                          const char *option,
+                          const char *required)
+{
+  GNUNET_log (kind,
+             _("Configuration specifies invalid value for option `%s' in section `%s': %s\n"),
+             option, section, required);
+}
+
+
 /**
  * Initializer
  */
-void __attribute__ ((constructor)) GNUNET_util_cl_init ()
+void __attribute__ ((constructor))
+GNUNET_util_cl_init ()
 {
   GNUNET_stderr = stderr;
 #ifdef MINGW
   GNInitWinEnv (NULL);
 #endif
+#if WINDOWS
+  if (!InitializeCriticalSectionAndSpinCount (&output_message_cs, 0x00000400))
+    GNUNET_abort_ ();
+#endif
 }
 
 
 /**
  * Destructor
  */
-void __attribute__ ((destructor)) GNUNET_util_cl_fini ()
+void __attribute__ ((destructor))
+GNUNET_util_cl_fini ()
 {
+#if WINDOWS
+  DeleteCriticalSection (&output_message_cs);
+#endif
 #ifdef MINGW
   GNShutdownWinEnv ();
 #endif