nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 
+00029 #ifdef NL_OS_WINDOWS
+00030 #       include <io.h>
+00031 #       include <fcntl.h>
+00032 #       include <sys/types.h>
+00033 #       include <sys/stat.h>
+00034 #endif // NL_OS_WINDOWS
+00035 
+00036 #include <stdio.h>
+00037 #include <stdlib.h>
+00038 #include <time.h>
+00039 
+00040 #include <iostream>
+00041 #include <fstream>
+00042 #include <sstream>
+00043 #include <iomanip>
+00044 
+00045 #include "nel/misc/path.h"
+00046 #include "nel/misc/mutex.h"
+00047 #include "nel/misc/report.h"
+00048 
+00049 #include "nel/misc/debug.h"
+00050 
+00051 
+00052 #ifdef NL_OS_WINDOWS
+00053 // these defines is for IsDebuggerPresent(). it'll not compile on windows 95
+00054 // just comment this and the IsDebuggerPresent to compile on windows 95
+00055 #       define _WIN32_WINDOWS   0x0410
+00056 #       define WINVER                   0x0400
+00057 #       include <windows.h>
+00058 #else
+00059 #       define IsDebuggerPresent() false
+00060 #endif
+00061 
+00062 #include "nel/misc/displayer.h"
+00063 
+00064 using namespace std;
+00065 
+00066 namespace NLMISC
+00067 {
+00068 
+00069 static char *LogTypeToString[][8] = {
+00070         { "", "ERR", "WRN", "INF", "DBG", "STT", "AST", "UKN" },
+00071         { "", "Error", "Warning", "Information", "Debug", "Statistic", "Assert", "Unknown" },
+00072         { "", "A fatal error occurs. The program must quit", "", "", "", "", "A failed assertion occurs", "" },
+00073 };
+00074 
+00075 const char *IDisplayer::logTypeToString (CLog::TLogType logType, bool longFormat)
+00076 {
+00077         if (logType < CLog::LOG_NO || logType > CLog::LOG_UNKNOWN)
+00078                 return "<NotDefined>";
+00079 
+00080         return LogTypeToString[longFormat?1:0][logType];
+00081 }
+00082 
+00083 const char *IDisplayer::dateToHumanString ()
+00084 {
+00085         time_t date;
+00086         time (&date);
+00087         return dateToHumanString (date);
+00088 }
+00089 
+00090 const char *IDisplayer::dateToHumanString (time_t date)
+00091 {
+00092         static char cstime[25];
+00093         struct tm *tms = localtime(&date);
+00094         if (tms)
+00095                 strftime (cstime, 25, "%Y/%m/%d %H:%M:%S", tms);
+00096         else
+00097                 sprintf(cstime, "bad date %d", (uint32)date);
+00098         return cstime;
+00099 }
+00100 
+00101 const char *IDisplayer::dateToComputerString (time_t date)
+00102 {
+00103         static char cstime[25];
+00104         smprintf (cstime, 25, "%ld", &date);
+00105         return cstime;
+00106 }
+00107 
+00108 const char *IDisplayer::HeaderString ()
+00109 {
+00110         static char header[1024];
+00111         smprintf(header, 1024, "\nLog Starting [%s]\n", dateToHumanString());
+00112         return header;
+00113 }
+00114 
+00115 
+00116 IDisplayer::IDisplayer(const char *displayerName)
+00117 {
+00118         _Mutex = new CMutex (string(displayerName)+"DISP");
+00119         DisplayerName = displayerName;
+00120 }
+00121 
+00122 IDisplayer::~IDisplayer()
+00123 {
+00124         delete _Mutex;
+00125 }
+00126 
+00127 /*
+00128  * Display the string where it does.
+00129  */
+00130 void IDisplayer::display ( const TDisplayInfo& args, const char *message )
+00131 {
+00132         _Mutex->enter();
+00133         try
+00134         {
+00135                 doDisplay( args, message );
+00136         }
+00137         catch (Exception &)
+00138         {
+00139                 // silence
+00140         }
+00141         _Mutex->leave();
+00142 }
+00143 
+00144 
+00145 // Log format : "<LogType> <ThreadNo> <FileName> <Line> <ProcessName> : <Msg>"
+00146 void CStdDisplayer::doDisplay ( const TDisplayInfo& args, const char *message )
+00147 {
+00148         bool needSpace = false;
+00149         stringstream ss;
+00150 
+00151         if (args.LogType != CLog::LOG_NO)
+00152         {
+00153                 ss << logTypeToString(args.LogType);
+00154                 needSpace = true;
+00155         }
+00156 
+00157         // Write thread identifier
+00158         if ( args.ThreadId != 0 )
+00159         {
+00160                 ss << setw(5) << args.ThreadId;
+00161                 needSpace = true;
+00162         }
+00163 
+00164         if (args.Filename != NULL)
+00165         {
+00166                 if (needSpace) { ss << " "; needSpace = false; }
+00167                 ss << CFile::getFilename(args.Filename);
+00168                 needSpace = true;
+00169         }
+00170 
+00171         if (args.Line != -1)
+00172         {
+00173                 if (needSpace) { ss << " "; needSpace = false; }
+00174                 ss << args.Line;
+00175                 needSpace = true;
+00176         }
+00177         
+00178         if (!args.ProcessName.empty())
+00179         {
+00180                 if (needSpace) { ss << " "; needSpace = false; }
+00181                 ss << args.ProcessName;
+00182                 needSpace = true;
+00183         }
+00184 
+00185         if (needSpace) { ss << " : "; needSpace = false; }
+00186 
+00187         ss << message;
+00188 
+00189         string s = ss.str();
+00190 
+00191         // we don't use cout because sometimes, it crashs because cout isn't already init, printf doesn t crash.
+00192         printf ("%s", s.c_str()); 
+00193         printf (args.CallstackAndLog.c_str());
+00194 
+00195         fflush(stdout);
+00196 
+00197 #ifdef NL_OS_WINDOWS
+00198         // display the string in the debugger is the application is started with the debugger
+00199         if (IsDebuggerPresent ())
+00200         {
+00201                 stringstream ss2;
+00202                 needSpace = false;
+00203 
+00204                 if (args.Filename != NULL) ss2 << args.Filename;
+00205 
+00206                 if (args.Line != -1)
+00207                 {
+00208                         ss2 << '(' << args.Line << ')';
+00209                         needSpace = true;
+00210                 }
+00211 
+00212                 if (needSpace) { ss2 << " : "; needSpace = false; }
+00213 
+00214                 if (args.LogType != CLog::LOG_NO)
+00215                 {
+00216                         ss2 << logTypeToString(args.LogType);
+00217                         needSpace = true;
+00218                 }
+00219 
+00220                 // Write thread identifier
+00221                 if ( args.ThreadId != 0 )
+00222                 {
+00223                         ss2 << setw(5) << args.ThreadId << ": ";
+00224                 }
+00225 
+00226                 ss2 << message;
+00227 
+00228                 const sint maxOutString = 2*1024;
+00229 
+00230                 if(ss2.str().size() < maxOutString)
+00231                 {
+00233                         // WARNING: READ THIS !!!!!!!!!!!!!!!! ///////////////////////////
+00234                         // If at the release time, it freezes here, it's a microsoft bug:
+00235                         // http://support.microsoft.com/support/kb/articles/q173/2/60.asp
+00236                         OutputDebugString(ss2.str().c_str());
+00237                 }
+00238                 else
+00239                 {
+00240                         /*OutputDebugString(ss2.str().c_str());
+00241                         OutputDebugString("\n\t\t\t");
+00242                         OutputDebugString("message end: ");
+00243                         OutputDebugString(&message[strlen(message) - 1024]);
+00244                         OutputDebugString("\n");*/
+00245 
+00246                         sint count = 0; 
+00247                         uint n = strlen(message);
+00248                         std::string s(&ss2.str().c_str()[0], (ss2.str().size() - n));
+00249                         OutputDebugString(s.c_str());
+00250                         
+00251                         while(true)
+00252                         {                                                                                               
+00253                                 
+00254                                 if((n - count) < maxOutString )
+00255                                 {
+00256                                         s = std::string(&message[count], (n - count));
+00257                                         OutputDebugString(s.c_str());
+00258                                         OutputDebugString("\n");
+00259                                         break;
+00260                                 }       
+00261                                 else
+00262                                 {
+00263                                         s = std::string(&message[count] , count + maxOutString);
+00264                                         OutputDebugString(s.c_str());
+00265                                         OutputDebugString("\n\t\t\t");
+00266                                         count += maxOutString;
+00267                                 }
+00268                         }
+00269                 }
+00270 
+00271                 // OutputDebugString is a big shit, we can't display big string in one time, we need to split
+00272                 uint32 pos = 0;
+00273                 string splited;
+00274                 while(true)
+00275                 {
+00276                         if (pos+1000 < args.CallstackAndLog.size ())
+00277                         {
+00278                                 splited = args.CallstackAndLog.substr (pos, 1000);
+00279                                 OutputDebugString(splited.c_str());
+00280                                 pos += 1000;
+00281                         }
+00282                         else
+00283                         {
+00284                                 splited = args.CallstackAndLog.substr (pos);
+00285                                 OutputDebugString(splited.c_str());
+00286                                 break;
+00287                         }
+00288                 }
+00289         }
+00290 #endif
+00291 }
+00292 
+00293 CFileDisplayer::CFileDisplayer (const std::string &filename, bool eraseLastLog, const char *displayerName) : IDisplayer (displayerName), _NeedHeader(true)
+00294 {
+00295         setParam (filename, eraseLastLog);
+00296         _FilePointer = (FILE*)1;
+00297 }
+00298 
+00299 CFileDisplayer::CFileDisplayer () : IDisplayer (""), _NeedHeader(true)
+00300 {
+00301         _FilePointer = (FILE*)1;
+00302 }
+00303 
+00304 void CFileDisplayer::setParam (const std::string &filename, bool eraseLastLog)
+00305 {
+00306         _FileName = filename;
+00307 
+00308         if (filename.empty())
+00309         {
+00310                 nlwarning ("CFileDisplayer::setParam(): Can't create file with empty filename, don't log");
+00311                 return;
+00312         }
+00313 
+00314         if (eraseLastLog)
+00315         {
+00316                 ofstream ofs (filename.c_str(), ios::out | ios::trunc);
+00317                 if (!ofs.is_open())
+00318                 {
+00319                         nlwarning ("CFileDisplayer::setParam(): Can't open and clear the log file '%s', don't log", filename.c_str());
+00320                 }
+00321         }
+00322 }
+00323 
+00324 
+00325 uint32  toto (FILE *fp)
+00326 {
+00327         if (fp == NULL) return 0;
+00328         fseek (fp, 0, SEEK_END);
+00329         return ftell (fp);
+00330 }
+00331 
+00332 // Log format: "2000/01/15 12:05:30 <ProcessName> <LogType> <ThreadId> <Filename> <Line> : <Msg>"
+00333 void CFileDisplayer::doDisplay ( const TDisplayInfo& args, const char *message )
+00334 {
+00335         bool needSpace = false;
+00336         stringstream ss;
+00337 
+00338         // if the filename is not set, don't log
+00339         if (_FileName.empty()) return;
+00340 
+00341         if (args.Date != 0)
+00342         {
+00343                 ss << dateToHumanString(args.Date);
+00344                 needSpace = true;
+00345         }
+00346 
+00347         if (args.LogType != CLog::LOG_NO)
+00348         {
+00349                 if (needSpace) { ss << " "; needSpace = false; }
+00350                 ss << logTypeToString(args.LogType);
+00351                 needSpace = true;
+00352         }
+00353 
+00354         // Write thread identifier
+00355         if ( args.ThreadId != 0 )
+00356         {
+00357                 if (needSpace) { ss << " "; needSpace = false; }
+00358                 ss << args.ThreadId;
+00359                 needSpace = true;
+00360         }
+00361 
+00362         if (!args.ProcessName.empty())
+00363         {
+00364                 if (needSpace) { ss << " "; needSpace = false; }
+00365                 ss << args.ProcessName;
+00366                 needSpace = true;
+00367         }
+00368 
+00369         if (args.Filename != NULL)
+00370         {
+00371                 if (needSpace) { ss << " "; needSpace = false; }
+00372                 ss << CFile::getFilename(args.Filename);
+00373                 needSpace = true;
+00374         }
+00375 
+00376         if (args.Line != -1)
+00377         {
+00378                 if (needSpace) { ss << " "; needSpace = false; }
+00379                 ss << args.Line;
+00380                 needSpace = true;
+00381         }
+00382         
+00383         if (needSpace) { ss << " : "; needSpace = false; }
+00384 
+00385         ss << message;
+00386 
+00387         if (_FilePointer > (FILE*)1)
+00388         {
+00389                 // if the file is too big (>5mb), rename it and create another one
+00390                 if (ftell (_FilePointer) > 5*1024*1024)
+00391                 {
+00392                         fclose (_FilePointer);
+00393                         rename (_FileName.c_str(), CFile::findNewFile (_FileName).c_str());
+00394                         fclose (_FilePointer);
+00395                         _FilePointer = (FILE*) 1;
+00396                 }
+00397         }
+00398 
+00399         if (_FilePointer == (FILE*)1)
+00400         {
+00401                 _FilePointer = fopen (_FileName.c_str(), "at");
+00402                 if (_FilePointer == NULL)
+00403                         perror ("Can't open log file");
+00404         }
+00405         
+00406         if (_FilePointer != 0)
+00407         {
+00408                 if (_NeedHeader)
+00409                 {
+00410                         const char *hs = HeaderString();
+00411                         fwrite (hs, strlen (hs), 1, _FilePointer);
+00412                         _NeedHeader = false;
+00413                 }
+00414                 
+00415                 fwrite (ss.str().c_str(), ss.str().size (), 1, _FilePointer);
+00416                 fwrite (args.CallstackAndLog.c_str(), args.CallstackAndLog.size (), 1, _FilePointer);
+00417                 fflush (_FilePointer);
+00418         }
+00419 }
+00420 
+00421 // Log format in clipboard: "2000/01/15 12:05:30 <LogType> <ProcessName> <FileName> <Line>: <Msg>"
+00422 // Log format on the screen: in debug   "<ProcessName> <FileName> <Line>: <Msg>"
+00423 //                           in release "<Msg>"
+00424 void CMsgBoxDisplayer::doDisplay ( const TDisplayInfo& args, const char *message)
+00425 {
+00426 #ifdef NL_OS_WINDOWS
+00427 
+00428         bool needSpace = false;
+00429         stringstream ss;
+00430 
+00431         // create the string for the clipboard
+00432 
+00433         if (args.Date != 0)
+00434         {
+00435                 ss << dateToHumanString(args.Date);
+00436                 needSpace = true;
+00437         }
+00438 
+00439         if (args.LogType != CLog::LOG_NO)
+00440         {
+00441                 if (needSpace) { ss << " "; needSpace = false; }
+00442                 ss << logTypeToString(args.LogType);
+00443                 needSpace = true;
+00444         }
+00445 
+00446         if (!args.ProcessName.empty())
+00447         {
+00448                 if (needSpace) { ss << " "; needSpace = false; }
+00449                 ss << args.ProcessName;
+00450                 needSpace = true;
+00451         }
+00452         
+00453         if (args.Filename != NULL)
+00454         {
+00455                 if (needSpace) { ss << " "; needSpace = false; }
+00456                 ss << CFile::getFilename(args.Filename);
+00457                 needSpace = true;
+00458         }
+00459 
+00460         if (args.Line != -1)
+00461         {
+00462                 if (needSpace) { ss << " "; needSpace = false; }
+00463                 ss << args.Line;
+00464                 needSpace = true;
+00465         }
+00466 
+00467         if (needSpace) { ss << ": "; needSpace = false; }
+00468 
+00469         ss << message;
+00470 
+00471         if (OpenClipboard (NULL))
+00472         {
+00473                 HGLOBAL mem = GlobalAlloc (GHND|GMEM_DDESHARE, ss.str().size()+1);
+00474                 if (mem)
+00475                 {
+00476                         char *pmem = (char *)GlobalLock (mem);
+00477                         strcpy (pmem, ss.str().c_str());
+00478                         GlobalUnlock (mem);
+00479                         EmptyClipboard ();
+00480                         SetClipboardData (CF_TEXT, mem);
+00481                 }
+00482                 CloseClipboard ();
+00483         }
+00484         
+00485         // create the string on the screen
+00486         needSpace = false;
+00487         stringstream ss2;
+00488 
+00489 #ifdef NL_DEBUG
+00490         if (!args.ProcessName.empty())
+00491         {
+00492                 if (needSpace) { ss2 << " "; needSpace = false; }
+00493                 ss2 << args.ProcessName;
+00494                 needSpace = true;
+00495         }
+00496         
+00497         if (args.Filename != NULL)
+00498         {
+00499                 if (needSpace) { ss2 << " "; needSpace = false; }
+00500                 ss2 << CFile::getFilename(args.Filename);
+00501                 needSpace = true;
+00502         }
+00503 
+00504         if (args.Line != -1)
+00505         {
+00506                 if (needSpace) { ss2 << " "; needSpace = false; }
+00507                 ss2 << args.Line;
+00508                 needSpace = true;
+00509         }
+00510 
+00511         if (needSpace) { ss2 << ": "; needSpace = false; }
+00512 #endif // NL_DEBUG
+00513 
+00514         ss2 << message;
+00515         ss2 << endl << endl << "(this message was copied in the clipboard)";
+00516 
+00517 /*      if (IsDebuggerPresent ())
+00518         {
+00519                 // Must break in assert call
+00520                 DebugNeedAssert = true;
+00521         }
+00522         else
+00523 */      {
+00524 
+00525                 // Display the report
+00526 
+00527                 string body;
+00528 
+00529                 body += toString(LogTypeToString[2][args.LogType]) + "\n";
+00530                 body += "ProcName: " + args.ProcessName + "\n";
+00531                 body += "Date: " + string(dateToHumanString(args.Date)) + "\n";
+00532                 if(args.Filename == NULL)
+00533                         body += "File: <Unknown>\n";
+00534                 else
+00535                         body += "File: " + string(args.Filename) + "\n";
+00536                 body += "Line: " + toString(args.Line) + "\n";
+00537                 body += "Reason: " + toString(message);
+00538 
+00539                 body += args.CallstackAndLog;
+00540 
+00541                 string subject;
+00542 
+00543                 // procname is host/service_name-sid we only want the service_name to avoid redondant mail
+00544                 string procname;
+00545                 sint pos = args.ProcessName.find ("/");
+00546                 if (pos == string::npos)
+00547                 {
+00548                         procname =  args.ProcessName;
+00549                 }
+00550                 else
+00551                 {
+00552                         sint pos2 = args.ProcessName.find ("-", pos+1);
+00553                         if (pos2 == string::npos)
+00554                         {
+00555                                 procname =  args.ProcessName.substr (pos+1);
+00556                         }
+00557                         else
+00558                         {
+00559                                 procname =  args.ProcessName.substr (pos+1, pos2-pos-1);
+00560                         }
+00561                 }
+00562 
+00563                 subject += procname + " NeL " + toString(LogTypeToString[0][args.LogType]) + " " + string(args.Filename) + " " + toString(args.Line);
+00564 
+00565                 // Check the envvar NEL_IGNORE_ASSERT
+00566                 if (getenv ("NEL_IGNORE_ASSERT") == NULL)
+00567                 {
+00568                         if  (ReportDebug == report (args.ProcessName + " NeL " + toString(logTypeToString(args.LogType, true)), "", subject, body, true, 2, true, 1, true, IgnoreNextTime))
+00569                         {
+00570                                 DebugNeedAssert = true;
+00571                         }
+00572                 }
+00573 
+00574 /*              // Check the envvar NEL_IGNORE_ASSERT
+00575                 if (getenv ("NEL_IGNORE_ASSERT") == NULL)
+00576                 {
+00577                         // Ask the user to continue, debug or ignore
+00578                         int result = MessageBox (NULL, ss2.str().c_str (), logTypeToString(args.LogType, true), MB_ABORTRETRYIGNORE | MB_ICONSTOP);
+00579                         if (result == IDABORT)
+00580                         {
+00581                                 // Exit the program now
+00582                                 exit (EXIT_FAILURE);
+00583                         }
+00584                         else if (result == IDRETRY)
+00585                         {
+00586                                 // Give the debugger a try
+00587                                 DebugNeedAssert = true;
+00588                         }
+00589                         else if (result == IDIGNORE)
+00590                         {
+00591                                 // Continue, do nothing
+00592                         }
+00593                 }
+00594 */      }
+00595 
+00596 #endif
+00597 }
+00598 
+00599 
+00600 
+00601 /***************************************************************/
+00602 /******************* THE FOLLOWING CODE IS COMMENTED OUT *******/
+00603 /***************************************************************
+00604 void CStdDisplayer::display (const std::string& str)
+00605 {
+00606 //      printf("%s", str.c_str ());
+00607         cout << str;
+00608 
+00609 #ifdef NL_OS_WINDOWS
+00610         // display the string in the debugger is the application is started with the debugger
+00611         if (IsDebuggerPresent ())
+00612                 OutputDebugString(str.c_str ());
+00613 #endif
+00614 }
+00615 
+00616 
+00617 void CFileDisplayer::display (const std::string& str)
+00618 {
+00619         if (_FileName.size () == 0) return;
+00620 
+00621         ofstream ofs (_FileName.c_str (), ios::out | ios::app);
+00622         if (ofs.is_open ())
+00623         {
+00624                 ofs << str;
+00625                 ofs.close();
+00626         }
+00627 
+00628 
+00629 //      FILE *fp = fopen (_FileName.c_str (), "a");
+00630 //      if (fp == NULL) return;
+00631 
+00632 //      fprintf (fp, "%s", str.c_str ());
+00633         
+00634 //      fclose (fp);
+00635 }
+00636 
+00637 
+00638 
+00639 void CMsgBoxDisplayer::display (const std::string& str)
+00640 {
+00641 #ifdef NL_OS_WINDOWS
+00642 
+00643         if (OpenClipboard (NULL))
+00644         {
+00645                 HGLOBAL mem = GlobalAlloc (GHND|GMEM_DDESHARE, str.size()+1);
+00646                 if (mem)
+00647                 {
+00648                         char *pmem = (char *)GlobalLock (mem);
+00649                         strcpy (pmem, str.c_str());
+00650                         GlobalUnlock (mem);
+00651                         EmptyClipboard ();
+00652                         SetClipboardData (CF_TEXT, mem);
+00653                 }
+00654                 CloseClipboard ();
+00655         }
+00656         
+00657         string strf = str;
+00658         strf += "\n\n(this message was copied in the clipboard)";
+00659         MessageBox (NULL, strf.c_str (), "", MB_OK | MB_ICONEXCLAMATION);
+00660 #endif
+00661 }
+00662 **************************************************************************/
+00663 
+00664 
+00665 } // NLMISC
+
displayer.cpp
