src/Logger.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2008 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 #include "Logger.h"
  26 #include "amule.h"
  27 #include "Preferences.h"
  28 #include <common/Macros.h>
  29 #include <sstream>
  30 #include <wx/tokenzr.h>
  31 #include <wx/wfstream.h>
  32 #include <wx/sstream.h>
  33 #include <wx/filename.h>
  34
  35
  36 DEFINE_LOCAL_EVENT_TYPE(MULE_EVT_LOGLINE)
  37
  38
  39 CDebugCategory g_debugcats[] = {
  40         CDebugCategory( logGeneral,             wxT("General") ),
  41         CDebugCategory( logHasher,              wxT("Hasher") ),
  42         CDebugCategory( logClient,              wxT("ED2k Client") ),
  43         CDebugCategory( logLocalClient,         wxT("Local Client Protocol") ),
  44         CDebugCategory( logRemoteClient,        wxT("Remote Client Protocol") ),
  45         CDebugCategory( logPacketErrors,        wxT("Packet Parsing Errors") ),
  46         CDebugCategory( logCFile,               wxT("CFile") ),
  47         CDebugCategory( logFileIO,              wxT("FileIO") ),
  48         CDebugCategory( logZLib,                wxT("ZLib") ),
  49         CDebugCategory( logAICHThread,          wxT("AICH-Hasher") ),
  50         CDebugCategory( logAICHTransfer,        wxT("AICH-Transfer") ),
  51         CDebugCategory( logAICHRecovery,        wxT("AICH-Recovery") ),
  52         CDebugCategory( logListenSocket,        wxT("ListenSocket") ),
  53         CDebugCategory( logCredits,             wxT("Credits") ),
  54         CDebugCategory( logClientUDP,           wxT("ClientUDPSocket") ),
  55         CDebugCategory( logDownloadQueue,       wxT("DownloadQueue") ),
  56         CDebugCategory( logIPFilter,            wxT("IPFilter") ),
  57         CDebugCategory( logKnownFiles,          wxT("KnownFileList") ),
  58         CDebugCategory( logPartFile,            wxT("PartFiles") ),
  59         CDebugCategory( logSHAHashSet,          wxT("SHAHashSet") ),
  60         CDebugCategory( logServer,              wxT("Servers") ),
  61         CDebugCategory( logProxy,               wxT("Proxy") ),
  62         CDebugCategory( logSearch,              wxT("Searching") ),
  63         CDebugCategory( logServerUDP,           wxT("ServerUDP") ),
  64         CDebugCategory( logClientKadUDP,        wxT("Client Kademlia UDP") ),
  65         CDebugCategory( logKadSearch,           wxT("Kademlia Search") ),
  66         CDebugCategory( logKadRouting,          wxT("Kademlia Routing") ),
  67         CDebugCategory( logKadIndex,            wxT("Kademlia Indexing") ),
  68         CDebugCategory( logKadMain,             wxT("Kademlia Main Thread") ),
  69         CDebugCategory( logKadPrefs,            wxT("Kademlia Preferences") ),
  70         CDebugCategory( logPfConvert,           wxT("PartFileConvert") ),
  71         CDebugCategory( logMuleUDP,             wxT("MuleUDPSocket" ) ),
  72         CDebugCategory( logThreads,             wxT("ThreadScheduler" ) ),
  73         CDebugCategory( logUPnP,                wxT("Universal Plug and Play" ) ),
  74         CDebugCategory( logKadUdpFwTester,      wxT("Kademlia UDP Firewall Tester") ),
  75         CDebugCategory( logKadPacketTracking,   wxT("Kademlia Packet Tracking") ),
  76         CDebugCategory( logKadEntryTracking,    wxT("Kademlia Entry Tracking") ),
  77         CDebugCategory( logEC,                  wxT("External Connect") ),
  78         CDebugCategory( logHTTP,                wxT("HTTP") )
  79 };
  80
  81
  82 const int categoryCount = sizeof( g_debugcats ) / sizeof( g_debugcats[0] );
  83
  84
  85
  86 #ifdef __DEBUG__
  87 bool CLogger::IsEnabled( DebugType type ) const
  88 {
  89         int index = (int)type;
  90
  91         if ( index >= 0 && index < categoryCount ) {
  92                 const CDebugCategory& cat = g_debugcats[ index ];
  93                 wxASSERT( type == cat.GetType() );
  94
  95                 return ( cat.IsEnabled() && thePrefs::GetVerbose() );
  96         }
  97
  98         wxFAIL;
  99         return false;
 100 }
 101 #endif
 102
 103
 104 void CLogger::SetEnabled( DebugType type, bool enabled )
 105 {
 106         int index = (int)type;
 107
 108         if ( index >= 0 && index < categoryCount ) {
 109                 CDebugCategory& cat = g_debugcats[ index ];
 110                 wxASSERT( type == cat.GetType() );
 111
 112                 cat.SetEnabled( enabled );
 113         } else {
 114                 wxFAIL;
 115         }
 116 }
 117
 118
 119 void CLogger::AddLogLine(
 120         const wxString& DEBUG_ONLY(file),
 121         int DEBUG_ONLY(line),
 122         bool critical,
 123         DebugType type,
 124         const wxString &str,
 125         bool toStdout,
 126         bool toGUI)
 127 {
 128         wxString msg(str);
 129 // handle Debug messages
 130         if (type != logStandard) {
 131                 if (!critical && !IsEnabled(type)) {
 132                         return;
 133                 }
 134                 int index = (int)type;
 135
 136                 if ( index >= 0 && index < categoryCount ) {
 137                         const CDebugCategory& cat = g_debugcats[ index ];
 138                         wxASSERT(type == cat.GetType());
 139
 140                         msg = cat.GetName() + wxT(": ") + msg;
 141                 } else {
 142                         wxFAIL;
 143                 }
 144         }
 145
 146 #ifdef __DEBUG__
 147         if (line) {
 148                 msg = file.AfterLast(wxFileName::GetPathSeparator()).AfterLast(wxT('/')) << wxT("(") << line << wxT("): ") + msg;
 149         }
 150 #endif
 151
 152         CLoggingEvent Event(critical, toStdout, toGUI, msg);
 153
 154         // Try to handle events immediatly when possible (to save to file).
 155         if (wxThread::IsMain()) {
 156                 // main thread and log file available: process directly
 157                 ProcessEvent(Event);
 158         } else {
 159                 // otherwise put to background
 160                 AddPendingEvent(Event);
 161         }
 162 }
 163
 164
 165 void CLogger::AddLogLine(
 166         const wxString &file,
 167         int line,
 168         bool critical,
 169         DebugType type,
 170         const std::ostringstream &msg)
 171 {
 172         int index = (int)type;
 173
 174         if ( index >= 0 && index < categoryCount ) {
 175                 const CDebugCategory& cat = g_debugcats[ index ];
 176                 wxASSERT(type == cat.GetType());
 177
 178                 AddLogLine(file, line, critical, logStandard,
 179                         cat.GetName() + wxT(": ") + char2unicode(msg.str().c_str()));
 180         }
 181 }
 182
 183
 184 const CDebugCategory& CLogger::GetDebugCategory( int index )
 185 {
 186         wxASSERT( index >= 0 && index < categoryCount );
 187
 188         return g_debugcats[ index ];
 189 }
 190
 191
 192 unsigned int CLogger::GetDebugCategoryCount()
 193 {
 194         return categoryCount;
 195 }
 196
 197
 198 bool CLogger::OpenLogfile(const wxString & name)
 199 {
 200         applog = new wxFFileOutputStream(name);
 201         bool ret = applog->Ok();
 202         if (ret) {
 203                 FlushApplog();
 204                 m_LogfileName = name;
 205         } else {
 206                 CloseLogfile();
 207         }
 208         return ret;
 209 }
 210
 211
 212 void CLogger::CloseLogfile()
 213 {
 214         delete applog;
 215         applog = NULL;
 216         m_LogfileName.Clear();
 217 }
 218
 219
 220 void CLogger::OnLoggingEvent(class CLoggingEvent& evt)
 221 {
 222         // Remove newspace at end
 223         wxString bufferline = evt.Message().Strip(wxString::trailing);
 224
 225         // Create the timestamp
 226         wxString stamp = wxDateTime::Now().FormatISODate() + wxT(" ") + wxDateTime::Now().FormatISOTime()
 227 #ifdef CLIENT_GUI
 228                                         + wxT(" (remote-GUI): ");
 229 #else
 230                                         + wxT(": ");
 231 #endif
 232
 233         // critical lines get a ! prepended, ordinary lines a blank
 234         // logfile-only lines get a . to prevent transmission on EC
 235         wxString prefix = !evt.ToGUI() ? wxT(".") : (evt.IsCritical() ? wxT("!") : wxT(" "));
 236
 237         if ( bufferline.IsEmpty() ) {
 238                 // If it's empty we just write a blank line with no timestamp.
 239                 DoLine(wxT(" \n"), evt.ToStdout(), evt.ToGUI());
 240         } else {
 241                 // Split multi-line messages into individual lines
 242                 wxStringTokenizer tokens( bufferline, wxT("\n") );
 243                 while ( tokens.HasMoreTokens() ) {
 244                         wxString fullline = prefix + stamp + tokens.GetNextToken() + wxT("\n");
 245                         DoLine(fullline, evt.ToStdout(), evt.ToGUI());
 246                 }
 247         }
 248 }
 249
 250
 251 void CLogger::DoLine(const wxString & line, bool toStdout, bool GUI_ONLY(toGUI))
 252 {
 253         ++m_count;
 254
 255         // write to logfile
 256         m_ApplogBuf += line;
 257         FlushApplog();
 258
 259         // write to Stdout
 260         if (m_StdoutLog || toStdout) {
 261                 printf("%s", (const char*)unicode2char(line));
 262         }
 263 #ifndef AMULE_DAEMON
 264         // write to Listcontrol
 265         if (toGUI) {
 266                 theApp->AddGuiLogLine(line);
 267         }
 268 #endif
 269 }
 270
 271
 272 void CLogger::FlushApplog()
 273 {
 274         if (applog) { // Wait with output until logfile is actually opened
 275                 wxStringInputStream stream(m_ApplogBuf);
 276                 (*applog) << stream;
 277                 applog->Sync();
 278                 m_ApplogBuf.Clear();
 279         }
 280 }
 281
 282 CLogger theLogger;
 283
 284 BEGIN_EVENT_TABLE(CLogger, wxEvtHandler)
 285         EVT_MULE_LOGGING(CLogger::OnLoggingEvent)
 286 END_EVENT_TABLE()
 287
 288
 289 CLoggerTarget::CLoggerTarget()
 290 {
 291 }
 292
 293 #if wxCHECK_VERSION(2, 9, 0)
 294 void CLoggerTarget::DoLogText(const wxString &msg)
 295 {
 296         // prevent infinite recursion
 297         static bool recursion = false;
 298         if (recursion) {
 299                 return;
 300         }
 301         recursion = true;
 302
 303         // This is much simpler than manually handling all wx log-types.
 304         bool critical = msg.StartsWith(_("ERROR: ")) || msg.StartsWith(_("WARNING: "));
 305
 306         AddLogLineM(critical, msg);
 307
 308         recursion = false;
 309 }
 310 #else
 311 void CLoggerTarget::DoLogString(const wxChar* msg, time_t)
 312 {
 313         // prevent infinite recursion
 314         static bool recursion = false;
 315         if (recursion) {
 316                 return;
 317         }
 318         recursion = true;
 319
 320         wxCHECK_RET(msg, wxT("Log message is NULL in DoLogString!"));
 321
 322         wxString str(msg);
 323
 324         // This is much simpler than manually handling all wx log-types.
 325         bool critical = str.StartsWith(_("ERROR: ")) || str.StartsWith(_("WARNING: "));
 326
 327         AddLogLineM(critical, str);
 328
 329         recursion = false;
 330 }
 331 #endif
 332
 333 CLoggerAccess::CLoggerAccess()
 334 {
 335         m_bufferlen = 4096;
 336         m_buffer = new wxCharBuffer(m_bufferlen);
 337         m_logfile = new wxFFileInputStream(theLogger.GetLogfileName());
 338         m_pos = 0;
 339         m_ready = false;
 340 }
 341
 342
 343 CLoggerAccess::~CLoggerAccess()
 344 {
 345         delete m_buffer;
 346         delete m_logfile;
 347 }
 348
 349
 350 //
 351 // read a line of text from the logfile if available
 352 // (can't believe there's no library function for this >:( )
 353 //
 354 bool CLoggerAccess::HasString()
 355 {
 356         while (!m_ready) {
 357                 int c = m_logfile->GetC();
 358                 if (c == wxEOF) {
 359                         break;
 360                 }
 361                 // check for buffer overrun
 362                 if (m_pos == m_bufferlen) {
 363                         m_bufferlen += 1024;
 364                         m_buffer->extend(m_bufferlen);
 365                 }
 366                 m_buffer->data()[m_pos++] = c;
 367                 if (c == '\n') {
 368                         if (m_buffer->data()[0] == '.') {
 369                                 // Log-only line, skip
 370                                 m_pos = 0;
 371                         } else {
 372                                 m_ready = true;
 373                         }
 374                 }
 375         }
 376         return m_ready;
 377 }
 378
 379
 380 bool CLoggerAccess::GetString(wxString & s)
 381 {
 382         if (!HasString()) {
 383                 return false;
 384         }
 385         s = wxString(m_buffer->data(), wxConvUTF8, m_pos);
 386         m_pos = 0;
 387         m_ready = false;
 388         return true;
 389 }
 390
 391 // Functions for EC logging
 392 bool ECLogIsEnabled()
 393 {
 394         return theLogger.IsEnabled(logEC);
 395 }
 396
 397 void DoECLogLine(const wxString &line)
 398 {
 399         // without file/line
 400         theLogger.AddLogLine(wxEmptyString, 0, false, logStandard, line, false, false);
 401 }
 402
 403 // File_checked_for_headers