libbase/log.cpp

   1 // log.cpp:  Message logging functions, for gnash.
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   4 //   Foundation, Inc
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 //
  20
  21 #include "log.h"
  22
  23 #include <ctime>
  24 #include <cctype>
  25 #include <cstring>
  26 #include <iostream>
  27 #include <map>
  28 #include <sstream>
  29 #include <fstream>
  30 #include <iomanip>
  31 #include <string>
  32 #include <boost/format.hpp>
  33
  34 #include <unistd.h> // for getpid
  35
  36 #include "utility.h"
  37 #include "GnashAlgorithm.h"
  38
  39 using std::cout;
  40 using std::endl;
  41
  42 namespace gnash {
  43
  44 // Convert each byte into its hex representation
  45 std::string
  46 hexify(const unsigned char *p, size_t length, bool ascii)
  47 {
  48
  49     const std::vector<unsigned char> bytes(p, p + length);
  50
  51     std::ostringstream ss;
  52
  53     // For hex output, fill single-digit numbers with a leading 0.
  54     if (!ascii) ss << std::hex << std::setfill('0');
  55
  56     for (std::vector<unsigned char>::const_iterator i = bytes.begin(),
  57             e = bytes.end(); i != e; ++i)
  58         {
  59         if (ascii) {
  60             if (std::isprint(*i) || *i == 0xd) {
  61                 ss << *i;
  62             }
  63             else ss << ".";
  64         }
  65         else  {
  66             // Not ascii
  67             ss << std::setw(2) << static_cast<int>(*i) << " ";
  68         }
  69     }
  70
  71     return ss.str();
  72
  73 }
  74
  75 std::ostream&
  76 timestamp(std::ostream& o)
  77 {
  78
  79     const char fmt[] = "%H:%M:%S";
  80
  81     time_t t;
  82     char buf[sizeof fmt];
  83
  84     std::time(&t);
  85     std::strftime(buf, sizeof buf, fmt, std::localtime(&t));
  86
  87     static std::map<int, int> threadMap;
  88     int tid = get_thread_id();
  89     int& htid = threadMap[tid];
  90     if (!htid) {
  91         htid = threadMap.size();
  92         // TODO: notify actual thread id for index
  93     }
  94
  95     o << getpid() << ":" << htid << "] " << buf;
  96     return o;
  97
  98 }
  99
 100 LogFile&
 101 LogFile::getDefaultInstance()
 102 {
 103     static LogFile o;
 104     return o;
 105 }
 106
 107 namespace {
 108     LogFile& dbglogfile = LogFile::getDefaultInstance();
 109 }
 110
 111 // boost format functions to process the objects
 112 // created by our hundreds of templates
 113
 114 void
 115 processLog_trace(const boost::format& fmt)
 116 {
 117     dbglogfile.log(N_("TRACE"), fmt.str());
 118 }
 119
 120 void
 121 processLog_debug(const boost::format& fmt)
 122 {
 123     if (dbglogfile.getVerbosity() < LogFile::LOG_DEBUG) return;
 124     dbglogfile.log(N_("DEBUG"), fmt.str());
 125 }
 126
 127 void
 128 processLog_abc(const boost::format& fmt)
 129 {
 130     if (dbglogfile.getVerbosity() < LogFile::LOG_EXTRA) return;
 131     dbglogfile.log(N_("ABC"), fmt.str());
 132 }
 133
 134 void
 135 processLog_parse(const boost::format& fmt)
 136 {
 137     dbglogfile.log(fmt.str());
 138 }
 139
 140 void
 141 processLog_network(const boost::format& fmt)
 142 {
 143     dbglogfile.log(N_("NETWORK"), fmt.str());
 144 }
 145
 146 void
 147 processLog_error(const boost::format& fmt)
 148 {
 149     dbglogfile.log(N_("ERROR"), fmt.str());
 150 }
 151
 152 void
 153 processLog_unimpl(const boost::format& fmt)
 154 {
 155     dbglogfile.log(N_("UNIMPLEMENTED"), fmt.str());
 156 }
 157
 158 void
 159 processLog_security(const boost::format& fmt)
 160 {
 161     dbglogfile.log(N_("SECURITY"), fmt.str());
 162 }
 163
 164 void
 165 processLog_swferror(const boost::format& fmt)
 166 {
 167     dbglogfile.log(N_("MALFORMED SWF"), fmt.str());
 168 }
 169
 170 void
 171 processLog_amferror(const boost::format& fmt)
 172 {
 173     dbglogfile.log(N_("MALFORMED AMF"), fmt.str());
 174 }
 175
 176 void
 177 processLog_aserror(const boost::format& fmt)
 178 {
 179     dbglogfile.log(N_("ACTIONSCRIPT ERROR"), fmt.str());
 180 }
 181
 182 void
 183 processLog_action(const boost::format& fmt)
 184 {
 185     bool stamp = dbglogfile.getStamp();
 186     dbglogfile.setStamp(false);
 187     dbglogfile.log(fmt.str());
 188     dbglogfile.setStamp(stamp);
 189 }
 190
 191 void
 192 LogFile::log(const std::string& msg)
 193 {
 194
 195     boost::mutex::scoped_lock lock(_ioMutex);
 196
 197     if ( !_verbose ) return; // nothing to do if not verbose
 198
 199     if (openLogIfNeeded()) {
 200         if (_stamp) {
 201             _outstream << timestamp << ": " << msg << "\n";
 202         } else {
 203             _outstream << msg << "\n";
 204         }
 205     }
 206     else {
 207         // log to stdout
 208         if (_stamp) {
 209             cout << timestamp << " " << msg << endl;
 210         } else {
 211             cout << msg << endl;
 212         }
 213     }
 214
 215     if (_listener) {
 216         (*_listener)(msg);
 217     }
 218 }
 219
 220 inline void
 221 LogFile::log(const std::string& label, const std::string& msg)
 222 {
 223     log(label + ": " + msg);
 224 }
 225
 226 void
 227 LogFile::setLogFilename(const std::string& fname)
 228 {
 229     closeLog();
 230     _logFilename = fname;
 231 }
 232
 233 void
 234 LogFile::setWriteDisk(bool use)
 235 {
 236     if (!use) closeLog();
 237     _write = use;
 238 }
 239
 240 // Default constructor
 241 LogFile::LogFile()
 242     :
 243     _verbose(0),
 244     _actiondump(false),
 245     _parserdump(false),
 246     _state(CLOSED),
 247     _stamp(true),
 248     _write(false),
 249     _listener(NULL)
 250 {
 251 }
 252
 253 LogFile::~LogFile()
 254 {
 255     if (_state == OPEN) closeLog();
 256 }
 257
 258 bool
 259 LogFile::openLogIfNeeded()
 260 {
 261     if (_state != CLOSED) return true;
 262     if (!_write) return false;
 263
 264     if (_logFilename.empty()) _logFilename = DEFAULT_LOGFILE;
 265
 266     // TODO: expand ~ to getenv("HOME") !!
 267
 268     return openLog(_logFilename);
 269 }
 270
 271 bool
 272 LogFile::openLog(const std::string& filespec)
 273 {
 274
 275     // NOTE:
 276     // don't need to lock the mutex here, as this method
 277     // is intended to be called only by openLogIfNeeded,
 278     // which in turn is called by operator<< which is called
 279     // by the public log_xxx functions that log themselves
 280
 281     if (_state != CLOSED) {
 282     cout << "Closing previously opened stream" << endl;
 283         _outstream.close();
 284         _state = CLOSED;
 285     }
 286
 287     // Append, don't truncate, the log file
 288     _outstream.open(filespec.c_str(), std::ios::app|std::ios::out); // ios::out
 289     if( _outstream.fail() ) {
 290     // Can't use log_error here...
 291         cout << "ERROR: can't open debug log file " << filespec <<
 292             " for appending." << endl;
 293         return false;
 294     }
 295
 296     _filespec = filespec;
 297     _state = OPEN;
 298
 299     return true;
 300 }
 301
 302 bool
 303 LogFile::closeLog()
 304 {
 305     boost::mutex::scoped_lock lock(_ioMutex);
 306     if (_state == OPEN) {
 307         _outstream.flush();
 308         _outstream.close();
 309     }
 310     _state = CLOSED;
 311
 312     return true;
 313 }
 314
 315 bool
 316 LogFile::removeLog()
 317 {
 318     if (_state == OPEN) {
 319         _outstream.close();
 320     }
 321
 322     // Ignore the error, we don't care
 323     unlink(_filespec.c_str());
 324     _filespec.clear();
 325
 326     return true;
 327 }
 328
 329 } // end of gnash namespace
 330
 331
 332 // Local Variables:
 333 // mode: C++
 334 // indent-tabs-mode: t
 335 // End:
 336