#include "gnunet_time_lib.h"
/**
- * After how many seconds do we always print
+ * 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)
*/
static FILE *GNUNET_stderr;
+#ifdef WINDOWS
+/**
+ * Contains the number of performance counts per second.
+ */
+LARGE_INTEGER performance_frequency;
+#endif
+
/**
* Convert a textual description of a loglevel
* to the respective GNUNET_GE_KIND.
return GNUNET_ERROR_TYPE_WARNING;
if (0 == strcasecmp (log, _("ERROR")))
return GNUNET_ERROR_TYPE_ERROR;
+ if (0 == strcasecmp (log, _("NONE")))
+ return GNUNET_ERROR_TYPE_NONE;
return GNUNET_ERROR_TYPE_INVALID;
}
FILE *altlog;
int dirwarn;
char *fn;
+ const char *env_loglevel;
+ int env_minlevel = 0;
+ int env_min_force_level = 100000;
+#ifdef WINDOWS
+ QueryPerformanceFrequency (&performance_frequency);
+#endif
GNUNET_free_non_null (component);
GNUNET_asprintf (&component,
"%s-%d",
comp,
getpid());
+ env_loglevel = getenv ("GNUNET_LOGLEVEL");
+ if (env_loglevel != NULL)
+ env_minlevel = get_type (env_loglevel);
+ env_loglevel = getenv ("GNUNET_FORCE_LOGLEVEL");
+ if (env_loglevel != NULL)
+ env_min_force_level = get_type (env_loglevel);
min_level = get_type (loglevel);
+ if (env_minlevel > min_level)
+ min_level = env_minlevel;
+ if (env_min_force_level < min_level)
+ min_level = env_min_force_level;
if (logfile == NULL)
return GNUNET_OK;
fn = GNUNET_STRINGS_filename_expand (logfile);
+ if (NULL == fn)
+ return GNUNET_SYSERR;
dirwarn = (GNUNET_OK != GNUNET_DISK_directory_create_for_file (fn));
altlog = FOPEN (fn, "a");
if (altlog == NULL)
char *last;
char *ft;
- if ((last_bulk_time.value == 0) || (last_bulk_repeat == 0))
+ if ((last_bulk_time.abs_value == 0) || (last_bulk_repeat == 0))
return;
rev = 0;
last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
const char *comp, const char *message, va_list va)
{
char date[DATE_STR_SIZE];
+ char date2[DATE_STR_SIZE];
time_t timetmp;
+ struct timeval timeofday;
struct tm *tmptr;
size_t size;
char *buf;
time (&timetmp);
memset (date, 0, DATE_STR_SIZE);
tmptr = localtime (&timetmp);
- strftime (date, DATE_STR_SIZE, "%b %d %H:%M:%S", tmptr);
+ gettimeofday(&timeofday, NULL);
+ if (NULL != tmptr)
+ {
+#ifdef WINDOWS
+ LARGE_INTEGER pc;
+ pc.QuadPart = 0;
+ QueryPerformanceCounter (&pc);
+ strftime (date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%020llu", tmptr);
+ snprintf (date, sizeof (date), date2, (long long) (pc.QuadPart / (performance_frequency.QuadPart / 1000)));
+#else
+ strftime (date2, DATE_STR_SIZE, "%b %d %H:%M:%S-%%06u", tmptr);
+ snprintf (date, sizeof (date), date2, timeofday.tv_usec);
+#endif
+ }
+ else
+ strcpy (date, "localtime error");
if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
- (last_bulk_time.value != 0) &&
+ (last_bulk_time.abs_value != 0) &&
(0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
{
last_bulk_repeat++;
- if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).value >
+ if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).rel_value >
BULK_DELAY_THRESHOLD)
|| (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
flush_bulk (date);
last_bulk_repeat = 0;
last_bulk_kind = kind;
last_bulk_time = GNUNET_TIME_absolute_get ();
- strncpy (last_bulk_comp, comp, sizeof (last_bulk_comp));
+ strncpy (last_bulk_comp, comp, COMP_TRACK_SIZE);
output_message (kind, comp, date, buf);
free (buf);
}
const char *comp, const char *message, ...)
{
va_list va;
+ char comp_w_pid[128];
+
va_start (va, message);
- mylog (kind, comp, message, va);
+ GNUNET_snprintf (comp_w_pid,
+ sizeof (comp_w_pid),
+ "%s-%d",
+ comp,
+ getpid());
+ mylog (kind, comp_w_pid, message, va);
va_end (va);
}
GNUNET_h2s (const GNUNET_HashCode * hc)
{
static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+
GNUNET_CRYPTO_hash_to_enc (hc, &ret);
ret.encoding[8] = '\0';
return (const char *) ret.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
+ * NOT reentrant!
+ *
+ * @param hc the hash code
+ * @return string form; will be overwritten by next call to GNUNET_h2s_full.
+ */
+const char *
+GNUNET_h2s_full (const GNUNET_HashCode * hc)
+{
+ static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+
+ GNUNET_CRYPTO_hash_to_enc (hc, &ret);
+ ret.encoding[sizeof(ret)-1] = '\0';
+ return (const char *) ret.encoding;
+}
/**
* Convert a peer identity to a string (for printing debug messages).
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;
switch (addr->sa_family)
{
case AF_INET:
+ if (addrlen != sizeof (struct sockaddr_in))
+ return "<invalid v4 address>";
v4 = (const struct sockaddr_in *) addr;
inet_ntop (AF_INET, &v4->sin_addr, buf, INET_ADDRSTRLEN);
if (0 == ntohs (v4->sin_port))
return buf;
strcat (buf, ":");
- sprintf (b2, "%u", ntohs (v4->sin_port));
+ GNUNET_snprintf (b2, sizeof(b2), "%u", ntohs (v4->sin_port));
strcat (buf, b2);
return buf;
case AF_INET6:
+ if (addrlen != sizeof (struct sockaddr_in6))
+ return "<invalid v4 address>";
v6 = (const struct sockaddr_in6 *) addr;
buf[0] = '[';
inet_ntop (AF_INET6, &v6->sin6_addr, &buf[1], INET6_ADDRSTRLEN);
if (0 == ntohs (v6->sin6_port))
return &buf[1];
strcat (buf, "]:");
- sprintf (b2, "%u", ntohs (v6->sin6_port));
+ GNUNET_snprintf (b2, sizeof(b2), "%u", ntohs (v6->sin6_port));
strcat (buf, b2);
return buf;
case AF_UNIX:
+ if (addrlen <= sizeof (sa_family_t))
+ return "<unbound UNIX client>";
un = (const struct sockaddr_un*) addr;
off = 0;
if (un->sun_path[0] == '\0') off++;
void __attribute__ ((constructor)) GNUNET_util_cl_init ()
{
GNUNET_stderr = stderr;
+#ifdef MINGW
+ GNInitWinEnv (NULL);
+#endif
+}
+
+
+/**
+ * Destructor
+ */
+void __attribute__ ((destructor)) GNUNET_util_cl_fini ()
+{
+#ifdef MINGW
+ GNShutdownWinEnv ();
+#endif
}
/* end of common_logging.c */