release/src-rt-6.x.4708/router/transmission/libtransmission/log.c

   1 /*
   2  * This file Copyright (C) 2010-2014 Mnemosyne LLC
   3  *
   4  * It may be used under the GNU GPL versions 2 or 3
   5  * or any future license endorsed by Mnemosyne LLC.
   6  *
   7  * $Id: utils.c 13863 2013-01-24 23:59:52Z jordan $
   8  */
   9
  10 #include <assert.h>
  11 #include <errno.h>
  12 #include <stdio.h>
  13 #include <stdlib.h> /* getenv() */
  14
  15 #include <event2/buffer.h>
  16
  17 #include "transmission.h"
  18 #include "log.h"
  19 #include "platform.h" /* tr_lock */
  20 #include "utils.h"
  21
  22 tr_log_level __tr_message_level  = TR_LOG_ERROR;
  23
  24 static bool           myQueueEnabled = false;
  25 static tr_log_message *  myQueue = NULL;
  26 static tr_log_message ** myQueueTail = &myQueue;
  27 static int            myQueueLength = 0;
  28
  29 #ifndef WIN32
  30   /* make null versions of these win32 functions */
  31   static inline int IsDebuggerPresent (void) { return false; }
  32   static inline void OutputDebugStringA (const void * unused UNUSED) { }
  33 #endif
  34
  35 /***
  36 ****
  37 ***/
  38
  39 tr_log_level
  40 tr_logGetLevel (void)
  41 {
  42   return __tr_message_level;
  43 }
  44
  45 /***
  46 ****
  47 ***/
  48
  49 static tr_lock*
  50 getMessageLock (void)
  51 {
  52   static tr_lock * l = NULL;
  53
  54   if (!l)
  55     l = tr_lockNew ();
  56
  57   return l;
  58 }
  59
  60 void*
  61 tr_logGetFile (void)
  62 {
  63   static bool initialized = false;
  64   static FILE * file = NULL;
  65
  66   if (!initialized)
  67     {
  68       int fd = 0;
  69       const char * str = getenv ("TR_DEBUG_FD");
  70
  71       if (str && *str)
  72         fd = atoi (str);
  73
  74       switch (fd)
  75         {
  76           case 1:
  77             file = stdout;
  78             break;
  79
  80           case 2:
  81             file = stderr;
  82             break;
  83
  84           default:
  85             file = NULL;
  86             break;
  87         }
  88
  89       initialized = true;
  90     }
  91
  92   return file;
  93 }
  94
  95 void
  96 tr_logSetLevel (tr_log_level level)
  97 {
  98     __tr_message_level = level;
  99 }
 100
 101 void
 102 tr_logSetQueueEnabled (bool isEnabled)
 103 {
 104   assert (tr_isBool (isEnabled));
 105
 106   myQueueEnabled = isEnabled;
 107 }
 108
 109 bool
 110 tr_logGetQueueEnabled (void)
 111 {
 112   return myQueueEnabled;
 113 }
 114
 115 tr_log_message *
 116 tr_logGetQueue (void)
 117 {
 118   tr_log_message * ret;
 119   tr_lockLock (getMessageLock ());
 120
 121   ret = myQueue;
 122   myQueue = NULL;
 123   myQueueTail = &myQueue;
 124   myQueueLength = 0;
 125
 126   tr_lockUnlock (getMessageLock ());
 127   return ret;
 128 }
 129
 130 void
 131 tr_logFreeQueue (tr_log_message * list)
 132 {
 133   tr_log_message * next;
 134
 135   while (NULL != list)
 136     {
 137       next = list->next;
 138       free (list->message);
 139       free (list->name);
 140       free (list);
 141       list = next;
 142     }
 143 }
 144
 145 /**
 146 ***
 147 **/
 148
 149 char*
 150 tr_logGetTimeStr (char * buf, int buflen)
 151 {
 152   char tmp[64];
 153   struct tm now_tm;
 154   struct timeval tv;
 155   time_t seconds;
 156   int milliseconds;
 157
 158   tr_gettimeofday (&tv);
 159
 160   seconds = tv.tv_sec;
 161   tr_localtime_r (&seconds, &now_tm);
 162   strftime (tmp, sizeof (tmp), "%Y-%m-%d %H:%M:%S.%%03d %Z", &now_tm);
 163   milliseconds = tv.tv_usec / 1000;
 164   tr_snprintf (buf, buflen, tmp, milliseconds);
 165
 166   return buf;
 167 }
 168
 169 bool
 170 tr_logGetDeepEnabled (void)
 171 {
 172   static int8_t deepLoggingIsActive = -1;
 173
 174   if (deepLoggingIsActive < 0)
 175     deepLoggingIsActive = IsDebuggerPresent () || (tr_logGetFile ()!=NULL);
 176
 177   return deepLoggingIsActive != 0;
 178 }
 179
 180 void
 181 tr_logAddDeep (const char  * file,
 182                int           line,
 183                const char  * name,
 184                const char  * fmt,
 185                ...)
 186 {
 187   FILE * fp = tr_logGetFile ();
 188   if (fp || IsDebuggerPresent ())
 189     {
 190       va_list args;
 191       char timestr[64];
 192       char * message;
 193       struct evbuffer * buf = evbuffer_new ();
 194       char * base = tr_basename (file);
 195
 196       evbuffer_add_printf (buf, "[%s] ",
 197                            tr_logGetTimeStr (timestr, sizeof (timestr)));
 198       if (name)
 199         evbuffer_add_printf (buf, "%s ", name);
 200       va_start (args, fmt);
 201       evbuffer_add_vprintf (buf, fmt, args);
 202       va_end (args);
 203       evbuffer_add_printf (buf, " (%s:%d)\n", base, line);
 204       /* FIXME (libevent2) ifdef this out for nonwindows platforms */
 205       message = evbuffer_free_to_str (buf);
 206       OutputDebugStringA (message);
 207       if (fp)
 208         fputs (message, fp);
 209
 210       tr_free (message);
 211       tr_free (base);
 212     }
 213 }
 214
 215 /***
 216 ****
 217 ***/
 218
 219 void
 220 tr_logAddMessage (const char * file,
 221                   int line,
 222                   tr_log_level level,
 223                   const char * name,
 224                   const char * fmt,
 225                   ...)
 226 {
 227   const int err = errno; /* message logging shouldn't affect errno */
 228   char buf[1024];
 229   va_list ap;
 230   tr_lockLock (getMessageLock ());
 231
 232   /* build the text message */
 233   *buf = '\0';
 234   va_start (ap, fmt);
 235   evutil_vsnprintf (buf, sizeof (buf), fmt, ap);
 236   va_end (ap);
 237
 238   OutputDebugStringA (buf);
 239
 240   if (*buf)
 241     {
 242       if (tr_logGetQueueEnabled ())
 243         {
 244           tr_log_message * newmsg;
 245           newmsg = tr_new0 (tr_log_message, 1);
 246           newmsg->level = level;
 247           newmsg->when = tr_time ();
 248           newmsg->message = tr_strdup (buf);
 249           newmsg->file = file;
 250           newmsg->line = line;
 251           newmsg->name = tr_strdup (name);
 252
 253           *myQueueTail = newmsg;
 254           myQueueTail = &newmsg->next;
 255           ++myQueueLength;
 256
 257           if (myQueueLength > TR_LOG_MAX_QUEUE_LENGTH)
 258             {
 259               tr_log_message * old = myQueue;
 260               myQueue = old->next;
 261               old->next = NULL;
 262               tr_logFreeQueue (old);
 263               --myQueueLength;
 264               assert (myQueueLength == TR_LOG_MAX_QUEUE_LENGTH);
 265             }
 266         }
 267       else
 268         {
 269           FILE * fp;
 270           char timestr[64];
 271
 272           fp = tr_logGetFile ();
 273           if (fp == NULL)
 274             fp = stderr;
 275
 276           tr_logGetTimeStr (timestr, sizeof (timestr));
 277
 278           if (name)
 279             fprintf (fp, "[%s] %s: %s\n", timestr, name, buf);
 280           else
 281             fprintf (fp, "[%s] %s\n", timestr, buf);
 282           fflush (fp);
 283         }
 284     }
 285
 286   tr_lockUnlock (getMessageLock ());
 287   errno = err;
 288 }