src/Logger.cpp

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