src/Logger.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25 #ifndef LOGGER_H
  26 #define LOGGER_H
  27
  28 #include <wx/log.h>
  29 #include <wx/event.h>
  30 #include <iosfwd>
  31
  32
  33 enum DebugType
  34 {
  35         //! Standard warning, not debug
  36         logStandard = -1,
  37         //! General warnings/errors.
  38         logGeneral = 0,
  39         //! Warnings/Errors for the main hashing thread.
  40         logHasher,
  41         //! Warnings/Errors for client-objects.
  42         logClient,
  43         //! Warnings/Errors for the local client protocol.
  44         logLocalClient,
  45         //! Warnings/Errors for the remote client protocol.
  46         logRemoteClient,
  47         //! Warnings/Errors when parsing packets.
  48         logPacketErrors,
  49         //! Warnings/Errors for the CFile class.
  50         logCFile,
  51         //! Warnings/Errors related to reading/writing files.
  52         logFileIO,
  53         //! Warnings/Errors when using the zLib library.
  54         logZLib,
  55         //! Warnings/Errors for the AICH-syncronization thread.
  56         logAICHThread,
  57         //! Warnings/Errors for transfering AICH hash-sets.
  58         logAICHTransfer,
  59         //! Warnings/Errors when recovering with AICH.
  60         logAICHRecovery,
  61         //! Warnings/Errors for the CListenSocket class.
  62         logListenSocket,
  63         //! Warnings/Errors for Client-Credits.
  64         logCredits,
  65         //! Warnings/Errors for the client UDP socket.
  66         logClientUDP,
  67         //! Warnings/Errors for the download-queue.
  68         logDownloadQueue,
  69         //! Warnings/Errors for the IP-Filter.
  70         logIPFilter,
  71         //! Warnings/Errors for known-files.
  72         logKnownFiles,
  73         //! Warnings/Errors for part-files.
  74         logPartFile,
  75         //! Warnings/Errors for SHA-hashset creation.
  76         logSHAHashSet,
  77         //! Warnings/Errors for servers, server connections.
  78         logServer,
  79         //! Warnings/Errors for proxy.
  80         logProxy,
  81         //! Warnings/Errors related to searching.
  82         logSearch,
  83         //! Warnings/Errors related to the server UDP socket.
  84         logServerUDP,
  85         //! Warning/Errors related to Kademlia UDP comunication on client
  86         logClientKadUDP,
  87         //! Warning/Errors related to Kademlia Search
  88         logKadSearch,
  89         //! Warning/Errors related to Kademlia Routing
  90         logKadRouting,
  91         //! Warning/Errors related to Kademlia Indexing
  92         logKadIndex,
  93         //! Warning/Errors related to Kademlia Main Thread
  94         logKadMain,
  95         //! Warning/Errors related to Kademlia Preferences
  96         logKadPrefs,
  97         //! Warnings/Errors related to partfile importer
  98         logPfConvert,
  99         //! Warnings/Errors related to the basic UDP socket-class.
 100         logMuleUDP,
 101         //! Warnings/Errors related to the thread-scheduler.
 102         logThreads,
 103         //! Warnings/Errors related to the Universal Plug and Play subsystem.
 104         logUPnP,
 105         //! Warnings/Errors related to the UDP Firewall Tester
 106         logKadUdpFwTester,
 107         //! Warnings/Errors related to Kad packet tracking.
 108         logKadPacketTracking,
 109         //! Warnings/Errors related to Kad entry tracking.
 110         logKadEntryTracking,
 111         //! Full log of external connection packets
 112         logEC,
 113         //! Warnings/Errors related to HTTP traffic
 114         logHTTP
 115         // IMPORTANT NOTE: when you add values to this enum, update the g_debugcats
 116         // array in Logger.cpp!
 117 };
 118
 119
 120
 121 /**
 122  * Container-class for the debugging categories.
 123  */
 124 class CDebugCategory
 125 {
 126 public:
 127         /**
 128          * Constructor.
 129          *
 130          * @param type The actual debug-category type.
 131          * @param name The user-readable name.
 132          */
 133         CDebugCategory( DebugType type, const wxString& name )
 134                 : m_name(name), m_type(type), m_enabled(false)
 135         {}
 136
 137
 138         /**
 139          * Returns true if the category is enabled.
 140          */
 141         bool IsEnabled() const          { return m_enabled; }
 142
 143         /**
 144          * Enables/Disables the category.
 145          */
 146         void SetEnabled( bool enabled ) { m_enabled = enabled; }
 147
 148
 149         /**
 150          * Returns the user-readable name.
 151          */
 152         const wxString& GetName() const { return m_name; }
 153
 154         /**
 155          * Returns the actual type.
 156          */
 157         DebugType GetType() const       { return m_type; }
 158
 159 private:
 160         //! The user-readable name.
 161         wxString        m_name;
 162         //! The actual type.
 163         DebugType       m_type;
 164         //! Whenever or not the category is enabled.
 165         bool            m_enabled;
 166 };
 167
 168
 169 /**
 170  * Functions for logging operations.
 171  */
 172 class CLogger: public wxEvtHandler
 173 {
 174 public:
 175         /**
 176          * Returns true if debug-messages should be generated for a specific category.
 177          */
 178 #ifdef __DEBUG__
 179         bool IsEnabled( DebugType ) const;
 180 #else
 181         bool IsEnabled( DebugType ) const       { return false; }
 182 #endif
 183
 184         /**
 185          * Enables or disables debug-messages for a specific category.
 186          */
 187         void SetEnabled( DebugType type, bool enabled );
 188
 189         /**
 190          * Returns true if logging to stdout is enabled
 191          */
 192         bool IsEnabledStdoutLog() const         { return m_StdoutLog; }
 193
 194         /**
 195          * Enables or disables logging to stdout.
 196          */
 197         void SetEnabledStdoutLog(bool enabled)  { m_StdoutLog = enabled; }
 198
 199
 200         /**
 201          * Logs the specified line of text, prefixed with the name of the DebugType.
 202          * (except for logStandard)
 203          *
 204          * @param file
 205          * @param line
 206          * @param critical If true, then the message will be made visible directly to the user.
 207          * @param type The debug-category, the name of which will be prepended to the line.
 208          * @param str The actual line of text.
 209          *
 210          * This function is thread-safe. If it is called by the main thread, the
 211          * event will be sent directly to the application, otherwise it will be
 212          * queued in the event-loop.
 213          */
 214         void AddLogLine(
 215                 const wxString &file,
 216                 int line,
 217                 bool critical,
 218                 DebugType type,
 219                 const wxString &str,
 220                 bool toStdout = false,
 221                 bool toGUI = true);
 222
 223         // for UPnP
 224         void AddLogLine(
 225                 const wxString &file,
 226                 int line,
 227                 bool critical,
 228                 DebugType type,
 229                 const std::ostringstream &msg);
 230
 231         void AddLogLine(
 232                 const wxString &file,
 233                 int line,
 234                 bool critical,
 235                 const std::ostringstream &msg);
 236
 237
 238         /**
 239          * Emergency log for crashes.
 240          */
 241         void EmergencyLog(const wxString &message, bool closeLog = true);
 242
 243         /**
 244          * Returns a category specified by index.
 245          */
 246         const CDebugCategory&   GetDebugCategory( int index );
 247
 248         /**
 249          * Returns the number of debug-categories.
 250          */
 251         unsigned int GetDebugCategoryCount();
 252
 253         /**
 254          * Open Logfile, true on success
 255          */
 256         bool OpenLogfile(const wxString & name);
 257
 258         /**
 259          * Close Logfile
 260          */
 261         void CloseLogfile();
 262
 263         /**
 264          * Get name of Logfile
 265          */
 266         const wxString & GetLogfileName() const {
 267                 return m_LogfileName;
 268         }
 269
 270         /**
 271          * Event handler
 272          */
 273         void OnLoggingEvent(class CLoggingEvent& evt);
 274
 275         /**
 276          * Construct
 277          */
 278         CLogger() {
 279                 applog = NULL;
 280                 m_StdoutLog = false;
 281                 m_count = 0;
 282         }
 283
 284 private:
 285         class wxFFileOutputStream* applog;      // the logfile
 286         wxString m_LogfileName;
 287         wxString m_ApplogBuf;
 288         bool m_StdoutLog;
 289         int  m_count;                   // output line counter
 290
 291         /**
 292          * Write all waiting log info to the logfile
 293          */
 294         void FlushApplog();
 295
 296         /**
 297          * Really output a single line
 298          */
 299         void DoLine(const wxString & line, bool toStdout, bool toGUI);
 300
 301         DECLARE_EVENT_TABLE()
 302 };
 303
 304 extern CLogger theLogger;
 305
 306 /**
 307  * This class forwards log-lines from wxWidgets to CLogger.
 308  */
 309 class CLoggerTarget : public wxLog
 310 {
 311 public:
 312         CLoggerTarget();
 313
 314         /**
 315          * @see wxLog::DoLogString
 316          */
 317 #if wxCHECK_VERSION(2, 9, 0)
 318         void DoLogText(const wxString &msg);
 319 #else
 320         void DoLogString(const wxChar *msg, time_t);
 321 #endif
 322 };
 323
 324
 325 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_LOGLINE, -1)
 326
 327
 328 /** This event is sent when a log-line is queued. */
 329 class CLoggingEvent : public wxEvent
 330 {
 331 public:
 332         CLoggingEvent(bool critical, bool toStdout, bool toGUI, const wxString& msg)
 333                 : wxEvent(-1, MULE_EVT_LOGLINE)
 334                 , m_critical(critical)
 335                 , m_stdout(toStdout)
 336                 , m_GUI(toGUI)
 337                 // Deep copy, to avoid thread-unsafe reference counting. */
 338                 , m_msg(msg.c_str(), msg.Length())
 339         {
 340         }
 341
 342         const wxString& Message() const {
 343                 return m_msg;
 344         }
 345
 346         bool IsCritical() const {
 347                 return m_critical;
 348         }
 349
 350         bool ToStdout() const {
 351                 return m_stdout;
 352         }
 353
 354         bool ToGUI() const {
 355                 return m_GUI;
 356         }
 357
 358         wxEvent* Clone() const {
 359                 return new CLoggingEvent(m_critical, m_stdout, m_GUI, m_msg);
 360         }
 361
 362 private:
 363         bool            m_critical;
 364         bool            m_stdout;
 365         bool            m_GUI;
 366         wxString        m_msg;
 367 };
 368
 369
 370 typedef void (wxEvtHandler::*MuleLogEventFunction)(CLoggingEvent&);
 371
 372 //! Event-handler for completed hashings of new shared files and partfiles.
 373 #define EVT_MULE_LOGGING(func) \
 374         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_LOGLINE, -1, -1, \
 375         (wxObjectEventFunction) (wxEventFunction) \
 376         wxStaticCastEvent(MuleLogEventFunction, &func), (wxObject*) NULL),
 377
 378
 379 // access the logfile for EC
 380 class CLoggerAccess
 381 {
 382 private:
 383         class wxFFileInputStream * m_logfile;
 384         class wxCharBuffer * m_buffer;
 385         size_t m_bufferlen;
 386         size_t m_pos;
 387
 388         bool m_ready;
 389 public:
 390         //
 391         // construct/destruct
 392         //
 393         CLoggerAccess();
 394         ~CLoggerAccess();
 395         //
 396         // Reset (used when logfile is cleared)
 397         //
 398         void Reset();
 399         //
 400         // get a String (if there is one)
 401         //
 402         bool GetString(wxString & s);
 403         //
 404         // is a String available ?
 405         //
 406         bool HasString();
 407 };
 408
 409
 410 /**
 411  * These macros should be used when logging. The
 412  * AddLogLineM macro will simply call one of the
 413  * two CLogger::AddLogLine functions depending on
 414  * parameters, but AddDebugLogLine* will only log
 415  * a message if the message is either critical or
 416  * the specified debug-type is enabled in the
 417  * preferences.
 418  * AddLogLineMS will also always print to stdout.
 419  */
 420 #ifdef MULEUNIT
 421         #define AddDebugLogLineN(...) do {} while (false)
 422         #define AddLogLineN(...) do {} while (false)
 423         #define AddLogLineNS(...) do {} while (false)
 424         #define AddDebugLogLineC(...) do {} while (false)
 425         #define AddLogLineC(...) do {} while (false)
 426         #define AddLogLineCS(...) do {} while (false)
 427 #else
 428 // Macro for UPnP. This is not a debug macro, but wants its category printed nevertheless (sigh).
 429         #define AddLogLineU(critical, type, string) theLogger.AddLogLine(__TFILE__, __LINE__, critical, type, string)
 430 // Macros for 'N'on critical logging
 431         #ifdef __DEBUG__
 432                 #define AddDebugLogLineN(type, string) theLogger.AddLogLine(__TFILE__, __LINE__, false, type, string)
 433         #else
 434                 #define AddDebugLogLineN(type, string)  do {} while (false)
 435         #endif
 436         #define AddLogLineN(string) theLogger.AddLogLine(__TFILE__, __LINE__, false, logStandard, string)
 437         #define AddLogLineNS(string) theLogger.AddLogLine(__TFILE__, __LINE__, false, logStandard, string, true)
 438 // Macros for 'C'ritical logging
 439         #define AddDebugLogLineC(type, string) theLogger.AddLogLine(__TFILE__, __LINE__, true, type, string)
 440         #define AddLogLineC(string) theLogger.AddLogLine(__TFILE__, __LINE__, true, logStandard, string)
 441         #define AddLogLineCS(string) theLogger.AddLogLine(__TFILE__, __LINE__, true, logStandard, string, true)
 442 // Macros for logging to logfile only
 443         #define AddDebugLogLineF(type, string) theLogger.AddLogLine(__TFILE__, __LINE__, false, type, string, false, false)
 444         #define AddLogLineF(string) theLogger.AddLogLine(__TFILE__, __LINE__, false, logStandard, string, false, false)
 445 #endif
 446
 447 #endif
 448 // File_checked_for_headers