expand GNUNET_OS_ProjectData API to also enable de-duplcation of logic for --help

[oweals/gnunet.git] / src / util / common_logging.c

diff --git a/src/util/common_logging.c b/src/util/common_logging.c
index 23749dd99f6c9ac16e5622a965a71b2310f5d0a3..0cefa194d128bebe8311614e53f0e14f4061f124 100644 (file)
--- a/src/util/common_logging.c
+++ b/src/util/common_logging.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2006, 2008, 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2006-2013 GNUnet e.V.

 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      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
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -14,29 +14,26 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
 
      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
 */
 
 /**
  * @file util/common_logging.c
  * @brief error handling API

- *

  * @author Christian Grothoff
  */
 #include "platform.h"
  * @author Christian Grothoff
  */
 #include "platform.h"

-#include "gnunet_common.h"

 #include "gnunet_crypto_lib.h"
 #include "gnunet_strings_lib.h"
 #include "gnunet_crypto_lib.h"
 #include "gnunet_strings_lib.h"

-#include "gnunet_time_lib.h"
-

 #include <regex.h>
 
 #include <regex.h>
 

+

 /**
  * After how many milliseconds do we always print
  * that "message X was repeated N times"?  Use 12h.
  */
 /**
  * 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
 
 /**
  * After how many repetitions do we always print


@@ -152,7 +149,7 @@ static struct CustomLogger *loggers;
 /**
  * Number of log calls to ignore.
  */
 /**
  * Number of log calls to ignore.
  */

-int skip_log = 0;
+static int skip_log = 0;

 
 /**
  * File descriptor to use for "stderr", or NULL for none.
 
 /**
  * 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
  * Abort the process, generate a core dump if possible.
  */
 void

-GNUNET_abort ()
+GNUNET_abort_ ()

 {
 #if WINDOWS
   DebugBreak ();
 {
 #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
  * Rotate logs, deleting the oldest log.
  *
  * @param new_name new name to add to the rotation

- */ 
+ */

 static void
 log_rotate (const char *new_name)
 {
 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);
     GNUNET_free (discard);
   }
   rotation[rotation_off % ROTATION_KEEP] = GNUNET_strdup (new_name);

-  rotation_off++;  
+  rotation_off++;

 }
 
 
 }
 
 


@@ -325,19 +322,18 @@ log_rotate (const char *new_name)
  * Setup the log file.
  *
  * @param tm timestamp for which we should setup logging
  * 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 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];
   char fn[PATH_MAX + 1];

-  int dirwarn;

   int altlog_fd;
   int dup_return;
   FILE *altlog;
   char *leftsquare;
   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))
   if (NULL == log_file_name)
     return GNUNET_SYSERR;
   if (0 == strftime (fn, sizeof (fn), log_file_name, tm))


@@ -346,17 +342,21 @@ setup_log_file (const struct tm *tm)
   if ( (NULL != leftsquare) && (']' == leftsquare[1]) )
   {
     char *logfile_copy = GNUNET_strdup (fn);
   if ( (NULL != leftsquare) && (']' == leftsquare[1]) )
   {
     char *logfile_copy = GNUNET_strdup (fn);

+

     logfile_copy[leftsquare - fn] = '\0';
     logfile_copy[leftsquare - fn + 1] = '\0';
     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]);
+    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);
     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 |
 #if WINDOWS
   altlog_fd = OPEN (fn, O_APPEND |
                         O_BINARY |


@@ -390,16 +390,13 @@ setup_log_file (const struct tm *tm)
   if (-1 == altlog_fd)
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
   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;
   }
     return GNUNET_SYSERR;
   }

-  GNUNET_stderr = altlog; 
+  GNUNET_stderr = altlog;

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 

+

 /**
  * Utility function - adds a parsed definition to logdefs array.
  *
 /**
  * Utility function - adds a parsed definition to logdefs array.
  *


@@ -413,8 +410,13 @@ setup_log_file (const struct tm *tm)
  * @return 0 on success, regex-specific error otherwise
  */
 static int
  * @return 0 on success, regex-specific error otherwise
  */
 static int

-add_definition (char *component, char *file, char *function, int from_line,
-                int to_line, int level, int force)
+add_definition (const char *component,
+                const char *file,
+                const char *function,
+                int from_line,
+                int to_line,
+                int level,
+                int force)

 {
   struct LogDef n;
   int r;
 {
   struct LogDef n;
   int r;


@@ -469,8 +471,11 @@ add_definition (char *component, char *file, char *function, int from_line,
  * @return 0 to disallow the call, 1 to allow it
  */
 int
  * @return 0 to disallow the call, 1 to allow it
  */
 int

-GNUNET_get_log_call_status (int caller_level, const char *comp,
-                            const char *file, const char *function, int line)
+GNUNET_get_log_call_status (int caller_level,
+                            const char *comp,
+                            const char *file,
+                            const char *function,
+                            int line)

 {
   struct LogDef *ld;
   int i;
 {
   struct LogDef *ld;
   int i;


@@ -665,10 +670,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)
  * @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
  */
 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;
 {
   const char *env_logfile;
   const struct tm *tm;


@@ -702,17 +709,21 @@ GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
 
 
 /**
 
 
 /**

- * Add a custom logger.
+ * Add a custom logger. Note that installing any custom logger
+ * will disable the standard logger.  When multiple custom loggers
+ * are installed, all will be called.  The standard logger will
+ * only be used if no custom loggers are present.

  *
  * @param logger log function
  *
  * @param logger log function

- * @param logger_cls closure for logger
+ * @param logger_cls closure for @a logger

  */
 void
  */
 void

-GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
+GNUNET_logger_add (GNUNET_Logger logger,
+                   void *logger_cls)

 {
   struct CustomLogger *entry;
 
 {
   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;
   entry->logger = logger;
   entry->logger_cls = logger_cls;
   entry->next = loggers;


@@ -724,24 +735,25 @@ GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
  * Remove a custom logger.
  *
  * @param logger log function
  * Remove a custom logger.
  *
  * @param logger log function

- * @param logger_cls closure for logger
+ * @param logger_cls closure for @a logger

  */
 void
  */
 void

-GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
+GNUNET_logger_remove (GNUNET_Logger logger,
+                      void *logger_cls)

 {
   struct CustomLogger *pos;
   struct CustomLogger *prev;
 
   prev = NULL;
   pos = loggers;
 {
   struct CustomLogger *pos;
   struct CustomLogger *prev;
 
   prev = NULL;
   pos = loggers;

-  while ((pos != NULL) &&
+  while ((NULL != pos) &&

          ((pos->logger != logger) || (pos->logger_cls != logger_cls)))
   {
     prev = pos;
     pos = pos->next;
   }
          ((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;
     loggers = pos->next;
   else
     prev->next = pos->next;


@@ -762,17 +774,26 @@ CRITICAL_SECTION output_message_cs;
  * @param msg the actual message
  */
 static void
  * @param msg the actual message
  */
 static void

-output_message (enum GNUNET_ErrorType kind, const char *comp,
-                const char *datestr, const char *msg)
+output_message (enum GNUNET_ErrorType kind,
+                const char *comp,
+                const char *datestr,
+                const char *msg)

 {
   struct CustomLogger *pos;
 {
   struct CustomLogger *pos;

+

 #if WINDOWS
   EnterCriticalSection (&output_message_cs);
 #endif
 #if WINDOWS
   EnterCriticalSection (&output_message_cs);
 #endif

-  if (NULL != GNUNET_stderr)
+  /* only use the standard logger if no custom loggers are present */
+  if ( (NULL != GNUNET_stderr) &&
+       (NULL == loggers) )

   {
   {

-    FPRINTF (GNUNET_stderr, "%s %s %s %s", datestr, comp,
-             GNUNET_error_type_to_string (kind), msg);
+    FPRINTF (GNUNET_stderr,
+             "%s %s %s %s",
+             datestr,
+             comp,
+             GNUNET_error_type_to_string (kind),
+             msg);

     fflush (GNUNET_stderr);
   }
   pos = loggers;
     fflush (GNUNET_stderr);
   }
   pos = loggers;


@@ -800,7 +821,7 @@ flush_bulk (const char *datestr)
   char *last;
   const char *ft;
 
   char *last;
   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);
     return;
   rev = 0;
   last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);


@@ -830,10 +851,11 @@ flush_bulk (const char *datestr)
  * Ignore the next n calls to the log function.
  *
  * @param n number of log calls to ignore (could be negative)
  * Ignore the next n calls to the log function.
  *
  * @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
+ * @param check_reset #GNUNET_YES to assert that the log skip counter is currently zero

  */
 void
  */
 void

-GNUNET_log_skip (int n, int check_reset)
+GNUNET_log_skip (int n,
+                int check_reset)

 {
   int ok;
 
 {
   int ok;
 


@@ -842,7 +864,7 @@ GNUNET_log_skip (int n, int check_reset)
     ok = (0 == skip_log);
     skip_log = 0;
     if (check_reset)
     ok = (0 == skip_log);
     skip_log = 0;
     if (check_reset)

-      GNUNET_assert (ok);
+      GNUNET_break (ok);

   }
   else
   {
   }
   else
   {


@@ -850,6 +872,7 @@ GNUNET_log_skip (int n, int check_reset)
   }
 }
 
   }
 }
 

+

 /**
  * Get the number of log calls that are going to be skipped
  *
 /**
  * Get the number of log calls that are going to be skipped
  *


@@ -861,6 +884,7 @@ GNUNET_get_log_skip ()
   return skip_log;
 }
 
   return skip_log;
 }
 

+

 /**
  * Output a log message using the default mechanism.
  *
 /**
  * Output a log message using the default mechanism.
  *


@@ -870,7 +894,9 @@ GNUNET_get_log_skip ()
  * @param va arguments to the format string "message"
  */
 static void
  * @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];
        va_list va)
 {
   char date[DATE_STR_SIZE];


@@ -886,11 +912,14 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
   memset (date, 0, DATE_STR_SIZE);
   {
     char buf[size];
   memset (date, 0, DATE_STR_SIZE);
   {
     char buf[size];

+    long long offset;

 #ifdef WINDOWS
     LARGE_INTEGER pc;
     time_t timetmp;
 
 #ifdef WINDOWS
     LARGE_INTEGER pc;
     time_t timetmp;
 

+    offset = GNUNET_TIME_get_offset ();

     time (&timetmp);
     time (&timetmp);

+    timetmp += offset / 1000;

     tmptr = localtime (&timetmp);
     pc.QuadPart = 0;
     QueryPerformanceCounter (&pc);
     tmptr = localtime (&timetmp);
     pc.QuadPart = 0;
     QueryPerformanceCounter (&pc);


@@ -909,6 +938,30 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
     struct timeval timeofday;
 
     gettimeofday (&timeofday, NULL);
     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)
     {
     tmptr = localtime (&timeofday.tv_sec);
     if (NULL == tmptr)
     {


@@ -919,17 +972,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);
     }
       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);
     if (NULL != tmptr)
       (void) setup_log_file (tmptr);
     if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
     VSNPRINTF (buf, size, message, va);
     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++;
         (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;
     }
         flush_bulk (date);
       return;
     }


@@ -952,7 +1006,8 @@ mylog (enum GNUNET_ErrorType kind, const char *comp, const char *message,
  * @param ... arguments for format string
  */
 void
  * @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;
 
 {
   va_list va;
 


@@ -1011,43 +1066,6 @@ GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
 }
 
 
 }
 
 

-/**
- * Convert a short hash to a string (for printing debug messages).
- * This is one of the very few calls in the entire API that is
- * NOT reentrant!
- *
- * @param hc the short hash code
- * @return string form; will be overwritten by next call to GNUNET_h2s.
- */
-const char *
-GNUNET_short_h2s (const struct GNUNET_CRYPTO_ShortHashCode * hc)
-{
-  static struct GNUNET_CRYPTO_ShortHashAsciiEncoded ret;
-
-  GNUNET_CRYPTO_short_hash_to_enc (hc, &ret);
-  ret.short_encoding[8] = '\0';
-  return (const char *) ret.short_encoding;
-}
-
-
-/**
- * Convert a short hash to a string (for printing debug messages).
- * This is one of the very few calls in the entire API that is
- * NOT reentrant!
- *
- * @param hc the short hash code
- * @return string form; will be overwritten by next call to GNUNET_h2s_full.
- */
-const char *
-GNUNET_short_h2s_full (const struct GNUNET_CRYPTO_ShortHashCode * hc)
-{
-  static struct GNUNET_CRYPTO_ShortHashAsciiEncoded ret;
-
-  GNUNET_CRYPTO_short_hash_to_enc (hc, &ret);
-  ret.short_encoding[sizeof (ret) - 1] = '\0';
-  return (const char *) ret.short_encoding;
-}
-

 /**
  * Convert a hash to a string (for printing debug messages).
  * This is one of the very few calls in the entire API that is
 /**
  * Convert a hash to a string (for printing debug messages).
  * This is one of the very few calls in the entire API that is


@@ -1093,16 +1111,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
  *
  * @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)
 {
  */
 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;

 }
 
 
 }
 
 


@@ -1113,15 +1134,18 @@ GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
  *
  * @param pid the peer identity
  * @return string form of the pid; will be overwritten by next
  *
  * @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)
 {
  */
 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;

 }
 
 
 }
 
 


@@ -1131,14 +1155,22 @@ GNUNET_i2s_full (const struct GNUNET_PeerIdentity *pid)
  * in the entire API that is NOT reentrant!
  *
  * @param addr the address
  * 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
  * @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 *
  */
 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;
   static char b2[6];
   const struct sockaddr_in *v4;
   const struct sockaddr_un *un;


@@ -1177,11 +1209,15 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
       return "<unbound UNIX client>";
     un = (const struct sockaddr_un *) addr;
     off = 0;
       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++;
       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");
     return buf;
   default:
     return _("invalid address");


@@ -1197,7 +1233,7 @@ GNUNET_a2s (const struct sockaddr *addr, socklen_t addrlen)
  * @param option name of missing option
  */
 void
  * @param option name of missing option
  */
 void

-GNUNET_log_config_missing (enum GNUNET_ErrorType kind, 
+GNUNET_log_config_missing (enum GNUNET_ErrorType kind,

                           const char *section,
                           const char *option)
 {
                           const char *section,
                           const char *option)
 {


@@ -1217,7 +1253,7 @@ GNUNET_log_config_missing (enum GNUNET_ErrorType kind,
  * @param required what is required that is invalid about the option
  */
 void
  * @param required what is required that is invalid about the option
  */
 void

-GNUNET_log_config_invalid (enum GNUNET_ErrorType kind, 
+GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,

                           const char *section,
                           const char *option,
                           const char *required)
                           const char *section,
                           const char *option,
                           const char *required)


@@ -1231,15 +1267,16 @@ GNUNET_log_config_invalid (enum GNUNET_ErrorType kind,
 /**
  * Initializer
  */
 /**
  * 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
 {
   GNUNET_stderr = stderr;
 #ifdef MINGW
   GNInitWinEnv (NULL);
 #endif
 #if WINDOWS

-  if (!InitializeCriticalSectionAndSpinCount (&output_message_cs, 0x00000400))\r
-    GNUNET_abort ();
+  if (!InitializeCriticalSectionAndSpinCount (&output_message_cs, 0x00000400))
+    GNUNET_abort_ ();

 #endif
 }
 
 #endif
 }
 


@@ -1247,7 +1284,8 @@ void __attribute__ ((constructor)) GNUNET_util_cl_init ()
 /**
  * Destructor
  */
 /**
  * Destructor
  */

-void __attribute__ ((destructor)) GNUNET_util_cl_fini ()
+void __attribute__ ((destructor))
+GNUNET_util_cl_fini ()

 {
 #if WINDOWS
   DeleteCriticalSection (&output_message_cs);
 {
 #if WINDOWS
   DeleteCriticalSection (&output_message_cs);