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 &file,
 121         int 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, cat.GetName() + wxT(": ") + char2unicode(msg.str().c_str()));
 179         }
 180 }
 181
 182
 183 const CDebugCategory& CLogger::GetDebugCategory( int index )
 184 {
 185         wxASSERT( index >= 0 && index < categoryCount );
 186
 187         return g_debugcats[ index ];
 188 }
 189
 190
 191 unsigned int CLogger::GetDebugCategoryCount()
 192 {
 193         return categoryCount;
 194 }
 195
 196
 197 bool CLogger::OpenLogfile(const wxString & name)
 198 {
 199         applog = new wxFFileOutputStream(name);
 200         bool ret = applog->Ok();
 201         if (ret) {
 202                 FlushApplog();
 203                 m_LogfileName = name;
 204         } else {
 205                 CloseLogfile();
 206         }
 207         return ret;
 208 }
 209
 210
 211 void CLogger::CloseLogfile()
 212 {
 213         delete applog;
 214         applog = NULL;
 215         m_LogfileName = wxT("");
 216 }
 217
 218
 219 void CLogger::OnLoggingEvent(class CLoggingEvent& evt)
 220 {
 221         // Remove newspace at end
 222         wxString bufferline = evt.Message().Strip(wxString::trailing);
 223
 224         // Create the timestamp
 225         wxString stamp = wxDateTime::Now().FormatISODate() + wxT(" ") + wxDateTime::Now().FormatISOTime()
 226 #ifdef CLIENT_GUI
 227                                         + wxT(" (remote-GUI): ");
 228 #else
 229                                         + wxT(": ");
 230 #endif
 231
 232         // critical lines get a ! prepended, ordinary lines a blank
 233         // logfile-only lines get a . to prevent transmission on EC
 234         wxString prefix = !evt.ToGUI() ? wxT(".") : (evt.IsCritical() ? wxT("!") : wxT(" "));
 235
 236         if ( bufferline.IsEmpty() ) {
 237                 // If it's empty we just write a blank line with no timestamp.
 238                 DoLine(wxT(" \n"), evt.ToStdout(), evt.ToGUI());
 239         } else {
 240                 // Split multi-line messages into individual lines
 241                 wxStringTokenizer tokens( bufferline, wxT("\n") );
 242                 while ( tokens.HasMoreTokens() ) {
 243                         wxString fullline = prefix + stamp + tokens.GetNextToken() + wxT("\n");
 244                         DoLine(fullline, evt.ToStdout(), evt.ToGUI());
 245                 }
 246         }
 247 }
 248
 249
 250 void CLogger::DoLine(const wxString & line, bool toStdout, bool GUI_ONLY(toGUI))
 251 {
 252         ++m_count;
 253
 254         // write to logfile
 255         m_ApplogBuf += line;
 256         FlushApplog();
 257
 258         // write to Stdout
 259         if (m_StdoutLog || toStdout) {
 260                 printf("%s", (const char*)unicode2char(line));
 261         }
 262 #ifndef AMULE_DAEMON
 263         // write to Listcontrol
 264         if (toGUI) {
 265                 theApp->AddGuiLogLine(line);
 266         }
 267 #endif
 268 }
 269
 270
 271 void CLogger::FlushApplog()
 272 {
 273         if (applog) { // Wait with output until logfile is actually opened
 274                 wxStringInputStream stream(m_ApplogBuf);
 275                 (*applog) << stream;
 276                 applog->Sync();
 277                 m_ApplogBuf = wxEmptyString;
 278         }
 279 }
 280
 281 CLogger theLogger;
 282
 283 BEGIN_EVENT_TABLE(CLogger, wxEvtHandler)
 284         EVT_MULE_LOGGING(CLogger::OnLoggingEvent)
 285 END_EVENT_TABLE()
 286
 287
 288 CLoggerTarget::CLoggerTarget()
 289 {
 290 }
 291
 292 #if wxCHECK_VERSION(2, 9, 0)
 293 void CLoggerTarget::DoLogText(const wxString &msg)
 294 {
 295         // prevent infinite recursion
 296         static bool recursion = false;
 297         if (recursion) {
 298                 return;
 299         }
 300         recursion = true;
 301
 302         // This is much simpler than manually handling all wx log-types.
 303         bool critical = msg.StartsWith(_("ERROR: ")) || msg.StartsWith(_("WARNING: "));
 304
 305         AddLogLineM(critical, msg);
 306
 307         recursion = false;
 308 }
 309 #else
 310 void CLoggerTarget::DoLogString(const wxChar* msg, time_t)
 311 {
 312         // prevent infinite recursion
 313         static bool recursion = false;
 314         if (recursion) {
 315                 return;
 316         }
 317         recursion = true;
 318
 319         wxCHECK_RET(msg, wxT("Log message is NULL in DoLogString!"));
 320
 321         wxString str(msg);
 322
 323         // This is much simpler than manually handling all wx log-types.
 324         bool critical = str.StartsWith(_("ERROR: ")) || str.StartsWith(_("WARNING: "));
 325
 326         AddLogLineM(critical, str);
 327
 328         recursion = false;
 329 }
 330 #endif
 331
 332 CLoggerAccess::CLoggerAccess()
 333 {
 334         m_bufferlen = 4096;
 335         m_buffer = new wxCharBuffer(m_bufferlen);
 336         m_logfile = new wxFFileInputStream(theLogger.GetLogfileName());
 337         m_pos = 0;
 338         m_ready = false;
 339 }
 340
 341
 342 CLoggerAccess::~CLoggerAccess()
 343 {
 344         delete m_buffer;
 345         delete m_logfile;
 346 }
 347
 348
 349 //
 350 // read a line of text from the logfile if available
 351 // (can't believe there's no library function for this >:( )
 352 //
 353 bool CLoggerAccess::HasString()
 354 {
 355         while (!m_ready) {
 356                 int c = m_logfile->GetC();
 357                 if (c == wxEOF) {
 358                         break;
 359                 }
 360                 // check for buffer overrun
 361                 if (m_pos == m_bufferlen) {
 362                         m_bufferlen += 1024;
 363                         m_buffer->extend(m_bufferlen);
 364                 }
 365                 m_buffer->data()[m_pos++] = c;
 366                 if (c == '\n') {
 367                         if (m_buffer->data()[0] == '.') {
 368                                 // Log-only line, skip
 369                                 m_pos = 0;
 370                         } else {
 371                                 m_ready = true;
 372                         }
 373                 }
 374         }
 375         return m_ready;
 376 }
 377
 378
 379 bool CLoggerAccess::GetString(wxString & s)
 380 {
 381         if (!HasString()) {
 382                 return false;
 383         }
 384         s = wxString(m_buffer->data(), wxConvUTF8, m_pos);
 385         m_pos = 0;
 386         m_ready = false;
 387         return true;
 388 }
 389
 390 // Functions for EC logging
 391 bool ECLogIsEnabled()
 392 {
 393         return theLogger.IsEnabled(logEC);
 394 }
 395
 396 void DoECLogLine(const wxString &line)
 397 {
 398         // without file/line
 399         theLogger.AddLogLine(wxEmptyString, 0, false, logStandard, line, false, false);
 400 }
 401
 402 // File_checked_for_headers