2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* TelEngine.cpp
|
|
|
|
* This file is part of the YATE Project http://YATE.null.ro
|
2004-11-29 03:56:41 +00:00
|
|
|
*
|
|
|
|
* Yet Another Telephony Engine - a fully featured software PBX and IVR
|
2006-05-27 15:08:43 +00:00
|
|
|
* Copyright (C) 2004-2006 Null Team
|
2004-11-29 03:56:41 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2006-05-27 15:08:43 +00:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
|
2005-04-08 10:55:22 +00:00
|
|
|
#include "yateclass.h"
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
2006-12-22 00:57:35 +00:00
|
|
|
#include <time.h>
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2006-01-13 05:09:50 +00:00
|
|
|
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
extern "C" {
|
|
|
|
|
|
|
|
static u_int32_t s_randSeed = (u_int32_t)(TelEngine::Time::now() & 0xffffffff);
|
|
|
|
|
|
|
|
long int random()
|
|
|
|
{ return (s_randSeed = (s_randSeed + 1) * 0x8088405) % RAND_MAX; }
|
|
|
|
|
|
|
|
void srandom(unsigned int seed)
|
|
|
|
{ s_randSeed = seed % RAND_MAX; }
|
|
|
|
|
|
|
|
}
|
2007-01-02 15:58:37 +00:00
|
|
|
|
|
|
|
#ifndef HAVE_GMTIME_S
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
int _gmtime_s(struct tm* _tm, const time_t* time)
|
|
|
|
{
|
2009-05-05 12:25:31 +00:00
|
|
|
static TelEngine::Mutex m(false,"_gmtime_s");
|
2007-01-02 15:58:37 +00:00
|
|
|
struct tm* tmp;
|
|
|
|
if (!_tm)
|
|
|
|
return EINVAL;
|
|
|
|
_tm->tm_isdst = _tm->tm_yday = _tm->tm_wday = _tm->tm_year = _tm->tm_mon = _tm->tm_mday =
|
|
|
|
_tm->tm_hour = _tm->tm_min = _tm->tm_sec = -1;
|
|
|
|
if (!time)
|
|
|
|
return EINVAL;
|
|
|
|
m.lock();
|
|
|
|
tmp = gmtime(time);
|
|
|
|
if (!tmp) {
|
|
|
|
m.unlock();
|
|
|
|
return EINVAL;
|
|
|
|
}
|
|
|
|
*_tm = *tmp;
|
|
|
|
m.unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2006-05-24 10:04:22 +00:00
|
|
|
#else
|
|
|
|
#include <sys/resource.h>
|
2006-01-13 05:09:50 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
namespace TelEngine {
|
|
|
|
|
2010-10-12 09:27:13 +00:00
|
|
|
#define DebugMin DebugFail
|
|
|
|
#define DebugVis DebugConf
|
2004-05-22 00:05:20 +00:00
|
|
|
#define DebugMax DebugAll
|
|
|
|
|
2006-02-08 16:53:08 +00:00
|
|
|
#define OUT_BUFFER_SIZE 8192
|
2005-01-06 15:33:35 +00:00
|
|
|
|
2010-11-01 14:54:53 +00:00
|
|
|
// RefObject mutex pool array size
|
|
|
|
#ifndef REFOBJECT_MUTEX_COUNT
|
|
|
|
#define REFOBJECT_MUTEX_COUNT 47
|
|
|
|
#endif
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
static int s_debug = DebugWarn;
|
|
|
|
static int s_indent = 0;
|
|
|
|
static bool s_debugging = true;
|
2004-10-14 16:36:24 +00:00
|
|
|
static bool s_abort = false;
|
2006-05-24 10:04:22 +00:00
|
|
|
static u_int64_t s_startTime = 0;
|
2006-12-22 00:57:35 +00:00
|
|
|
static u_int64_t s_timestamp = 0;
|
|
|
|
static Debugger::Formatting s_fmtstamp = Debugger::None;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2006-05-19 15:52:05 +00:00
|
|
|
static const char* const s_colors[11] = {
|
|
|
|
"\033[5;41;1;33m\033[K",// DebugFail - blinking yellow on red
|
|
|
|
"\033[41;1;33m\033[K", // Unnamed - yellow on red
|
|
|
|
"\033[41;1;37m\033[K", // DebugGoOn - white on red
|
2010-09-29 15:28:27 +00:00
|
|
|
"\033[41;37m\033[K", // DebugConf - gray on red
|
2006-05-27 14:53:18 +00:00
|
|
|
"\033[40;31m\033[K", // DebugStub - red on black
|
2006-05-19 15:52:05 +00:00
|
|
|
"\033[40;1;31m\033[K", // DebugWarn - light red on black
|
|
|
|
"\033[40;1;33m\033[K", // DebugMild - yellow on black
|
|
|
|
"\033[40;1;37m\033[K", // DebugCall - white on black
|
|
|
|
"\033[40;1;32m\033[K", // DebugNote - light green on black
|
|
|
|
"\033[40;1;36m\033[K", // DebugInfo - light cyan on black
|
|
|
|
"\033[40;36m\033[K" // DebugAll - cyan on black
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char* const s_levels[11] = {
|
|
|
|
"FAIL",
|
|
|
|
"FAIL",
|
|
|
|
"GOON",
|
2010-09-29 15:28:27 +00:00
|
|
|
"CONF",
|
2006-05-27 14:53:18 +00:00
|
|
|
"STUB",
|
2006-05-19 15:52:05 +00:00
|
|
|
"WARN",
|
|
|
|
"MILD",
|
|
|
|
"CALL",
|
|
|
|
"NOTE",
|
|
|
|
"INFO",
|
|
|
|
"ALL",
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char* dbg_level(int level)
|
|
|
|
{
|
|
|
|
if (level < DebugMin)
|
|
|
|
level = DebugMin;
|
|
|
|
if (level > DebugMax)
|
|
|
|
level = DebugMax;
|
|
|
|
return s_levels[level];
|
|
|
|
}
|
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
static void dbg_stderr_func(const char* buf, int level)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-05-24 15:09:19 +00:00
|
|
|
::write(2,buf,::strlen(buf));
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2006-05-19 15:52:05 +00:00
|
|
|
static void dbg_colorize_func(const char* buf, int level)
|
|
|
|
{
|
|
|
|
const char* col = debugColor(level);
|
|
|
|
::write(2,col,::strlen(col));
|
|
|
|
::write(2,buf,::strlen(buf));
|
|
|
|
col = debugColor(-2);
|
|
|
|
::write(2,col,::strlen(col));
|
|
|
|
}
|
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
static void (*s_output)(const char*,int) = dbg_stderr_func;
|
|
|
|
static void (*s_intout)(const char*,int) = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2009-05-05 12:25:31 +00:00
|
|
|
static Mutex out_mux(false,"DebugOutput");
|
|
|
|
static Mutex ind_mux(false,"DebugIndent");
|
2007-08-23 09:58:46 +00:00
|
|
|
static Thread* s_thr = 0;
|
|
|
|
|
|
|
|
static bool reentered()
|
|
|
|
{
|
|
|
|
if (!s_thr)
|
|
|
|
return false;
|
|
|
|
return (Thread::current() == s_thr);
|
|
|
|
}
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
static void common_output(int level,char* buf)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-06-20 20:51:17 +00:00
|
|
|
if (level < -1)
|
|
|
|
level = -1;
|
|
|
|
if (level > DebugMax)
|
|
|
|
level = DebugMax;
|
2004-05-22 00:05:20 +00:00
|
|
|
int n = ::strlen(buf);
|
|
|
|
if (n && (buf[n-1] == '\n'))
|
|
|
|
n--;
|
|
|
|
buf[n] = '\n';
|
|
|
|
buf[n+1] = '\0';
|
|
|
|
// serialize the output strings
|
|
|
|
out_mux.lock();
|
2007-08-23 09:58:46 +00:00
|
|
|
// TODO: detect reentrant calls from foreign threads and main thread
|
|
|
|
s_thr = Thread::current();
|
2004-05-22 00:05:20 +00:00
|
|
|
if (s_output)
|
2005-06-20 20:51:17 +00:00
|
|
|
s_output(buf,level);
|
2004-05-22 00:05:20 +00:00
|
|
|
if (s_intout)
|
2005-06-20 20:51:17 +00:00
|
|
|
s_intout(buf,level);
|
2007-08-23 09:58:46 +00:00
|
|
|
s_thr = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
out_mux.unlock();
|
|
|
|
}
|
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
static void dbg_output(int level,const char* prefix, const char* format, va_list ap)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
if (!(s_output || s_intout))
|
|
|
|
return;
|
2005-01-06 15:33:35 +00:00
|
|
|
char buf[OUT_BUFFER_SIZE];
|
2005-04-22 20:07:26 +00:00
|
|
|
unsigned int n = 0;
|
2006-12-22 00:57:35 +00:00
|
|
|
if (s_fmtstamp != Debugger::None) {
|
|
|
|
u_int64_t t = Time::now();
|
|
|
|
if (s_fmtstamp == Debugger::Relative)
|
|
|
|
t -= s_timestamp;
|
2005-04-25 10:34:37 +00:00
|
|
|
unsigned int s = (unsigned int)(t / 1000000);
|
|
|
|
unsigned int u = (unsigned int)(t % 1000000);
|
2006-12-22 00:57:35 +00:00
|
|
|
if (s_fmtstamp == Debugger::Textual) {
|
|
|
|
time_t sec = (time_t)s;
|
|
|
|
struct tm tmp;
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
_gmtime_s(&tmp,&sec);
|
|
|
|
#else
|
|
|
|
gmtime_r(&sec,&tmp);
|
|
|
|
#endif
|
|
|
|
::sprintf(buf,"%04d%02d%02d%02d%02d%02d.%06u ",
|
|
|
|
tmp.tm_year+1900,tmp.tm_mon+1,tmp.tm_mday,
|
|
|
|
tmp.tm_hour,tmp.tm_min,tmp.tm_sec,u);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
::sprintf(buf,"%07u.%06u ",s,u);
|
2005-04-22 20:07:26 +00:00
|
|
|
n = ::strlen(buf);
|
|
|
|
}
|
|
|
|
unsigned int l = s_indent*2;
|
|
|
|
if (l >= sizeof(buf)-n)
|
|
|
|
l = sizeof(buf)-n-1;
|
|
|
|
::memset(buf+n,' ',l);
|
|
|
|
n += l;
|
2004-05-22 00:05:20 +00:00
|
|
|
buf[n] = 0;
|
2005-04-22 20:07:26 +00:00
|
|
|
l = sizeof(buf)-n-2;
|
2004-05-22 00:05:20 +00:00
|
|
|
if (prefix)
|
|
|
|
::strncpy(buf+n,prefix,l);
|
|
|
|
n = ::strlen(buf);
|
|
|
|
l = sizeof(buf)-n-2;
|
|
|
|
if (format) {
|
|
|
|
::vsnprintf(buf+n,l,format,ap);
|
2008-09-16 15:25:26 +00:00
|
|
|
buf[OUT_BUFFER_SIZE - 2] = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
2005-06-20 20:51:17 +00:00
|
|
|
common_output(level,buf);
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2005-03-20 03:11:53 +00:00
|
|
|
void Output(const char* format, ...)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-01-06 15:33:35 +00:00
|
|
|
char buf[OUT_BUFFER_SIZE];
|
2004-05-22 00:05:20 +00:00
|
|
|
if (!((s_output || s_intout) && format && *format))
|
|
|
|
return;
|
2007-08-23 09:58:46 +00:00
|
|
|
if (reentered())
|
|
|
|
return;
|
2004-05-22 00:05:20 +00:00
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
|
|
|
::vsnprintf(buf,sizeof(buf)-2,format,va);
|
|
|
|
va_end(va);
|
2005-06-20 20:51:17 +00:00
|
|
|
common_output(-1,buf);
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2005-04-09 22:10:00 +00:00
|
|
|
void Debug(int level, const char* format, ...)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!s_debugging)
|
2005-04-09 22:10:00 +00:00
|
|
|
return;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (level > s_debug)
|
|
|
|
return;
|
2007-08-23 09:58:46 +00:00
|
|
|
if (reentered())
|
|
|
|
return;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!format)
|
|
|
|
format = "";
|
|
|
|
char buf[32];
|
2006-05-19 15:52:05 +00:00
|
|
|
::sprintf(buf,"<%s> ",dbg_level(level));
|
2005-05-06 18:13:33 +00:00
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
|
|
|
ind_mux.lock();
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(level,buf,format,va);
|
2005-05-06 18:13:33 +00:00
|
|
|
ind_mux.unlock();
|
|
|
|
va_end(va);
|
|
|
|
if (s_abort && (level == DebugFail))
|
|
|
|
abort();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2005-04-09 22:10:00 +00:00
|
|
|
void Debug(const char* facility, int level, const char* format, ...)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!s_debugging)
|
2005-04-09 22:10:00 +00:00
|
|
|
return;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (level > s_debug)
|
|
|
|
return;
|
2007-08-23 09:58:46 +00:00
|
|
|
if (reentered())
|
|
|
|
return;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!format)
|
|
|
|
format = "";
|
|
|
|
char buf[64];
|
2006-05-19 15:52:05 +00:00
|
|
|
::snprintf(buf,sizeof(buf),"<%s:%s> ",facility,dbg_level(level));
|
2005-05-06 18:13:33 +00:00
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
|
|
|
ind_mux.lock();
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(level,buf,format,va);
|
2005-05-06 18:13:33 +00:00
|
|
|
ind_mux.unlock();
|
|
|
|
va_end(va);
|
|
|
|
if (s_abort && (level == DebugFail))
|
|
|
|
abort();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2005-04-09 22:10:00 +00:00
|
|
|
void Debug(const DebugEnabler* local, int level, const char* format, ...)
|
2005-03-20 03:11:53 +00:00
|
|
|
{
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!s_debugging)
|
2005-04-09 22:10:00 +00:00
|
|
|
return;
|
2005-06-20 20:51:17 +00:00
|
|
|
const char* facility = 0;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!local) {
|
|
|
|
if (level > s_debug)
|
|
|
|
return;
|
2005-03-20 03:11:53 +00:00
|
|
|
}
|
2005-05-06 18:13:33 +00:00
|
|
|
else {
|
|
|
|
if (!local->debugAt(level))
|
|
|
|
return;
|
2005-06-20 20:51:17 +00:00
|
|
|
facility = local->debugName();
|
2005-05-06 18:13:33 +00:00
|
|
|
}
|
2007-08-23 09:58:46 +00:00
|
|
|
if (reentered())
|
|
|
|
return;
|
2005-05-06 18:13:33 +00:00
|
|
|
if (!format)
|
|
|
|
format = "";
|
2005-06-20 20:51:17 +00:00
|
|
|
char buf[64];
|
|
|
|
if (facility)
|
2006-05-19 15:52:05 +00:00
|
|
|
::snprintf(buf,sizeof(buf),"<%s:%s> ",facility,dbg_level(level));
|
2005-06-20 20:51:17 +00:00
|
|
|
else
|
2006-05-19 15:52:05 +00:00
|
|
|
::sprintf(buf,"<%s> ",dbg_level(level));
|
2005-05-06 18:13:33 +00:00
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
|
|
|
ind_mux.lock();
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(level,buf,format,va);
|
2005-05-06 18:13:33 +00:00
|
|
|
ind_mux.unlock();
|
|
|
|
va_end(va);
|
|
|
|
if (s_abort && (level == DebugFail))
|
|
|
|
abort();
|
2005-03-20 03:11:53 +00:00
|
|
|
}
|
|
|
|
|
2004-10-14 16:36:24 +00:00
|
|
|
void abortOnBug()
|
|
|
|
{
|
|
|
|
if (s_abort)
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool abortOnBug(bool doAbort)
|
|
|
|
{
|
|
|
|
bool tmp = s_abort;
|
|
|
|
s_abort = doAbort;
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
int debugLevel()
|
|
|
|
{
|
|
|
|
return s_debug;
|
|
|
|
}
|
|
|
|
|
|
|
|
int debugLevel(int level)
|
|
|
|
{
|
2010-10-12 09:27:13 +00:00
|
|
|
if (level < DebugVis)
|
|
|
|
level = DebugVis;
|
2004-05-22 00:05:20 +00:00
|
|
|
if (level > DebugMax)
|
|
|
|
level = DebugMax;
|
|
|
|
return (s_debug = level);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool debugAt(int level)
|
|
|
|
{
|
|
|
|
return (s_debugging && (level <= s_debug));
|
|
|
|
}
|
|
|
|
|
2006-05-19 15:52:05 +00:00
|
|
|
const char* debugColor(int level)
|
|
|
|
{
|
|
|
|
if (level == -2)
|
|
|
|
return "\033[0m\033[K"; // reset to defaults
|
|
|
|
if ((level < DebugMin) || (level > DebugMax))
|
|
|
|
return "\033[0;40;37m\033[K"; // light gray on black
|
|
|
|
return s_colors[level];
|
|
|
|
}
|
|
|
|
|
2005-03-20 03:11:53 +00:00
|
|
|
int DebugEnabler::debugLevel(int level)
|
|
|
|
{
|
2010-10-12 09:27:13 +00:00
|
|
|
if (level < DebugVis)
|
|
|
|
level = DebugVis;
|
2005-03-20 03:11:53 +00:00
|
|
|
if (level > DebugMax)
|
|
|
|
level = DebugMax;
|
2005-03-28 22:27:26 +00:00
|
|
|
m_chain = 0;
|
2005-03-20 03:11:53 +00:00
|
|
|
return (m_level = level);
|
|
|
|
}
|
|
|
|
|
2005-03-28 22:27:26 +00:00
|
|
|
bool DebugEnabler::debugAt(int level) const
|
|
|
|
{
|
|
|
|
if (m_chain)
|
|
|
|
return m_chain->debugAt(level);
|
|
|
|
return (m_enabled && (level <= m_level));
|
|
|
|
}
|
|
|
|
|
2005-05-06 18:13:33 +00:00
|
|
|
void DebugEnabler::debugCopy(const DebugEnabler* original)
|
|
|
|
{
|
|
|
|
if (original) {
|
|
|
|
m_level = original->debugLevel();
|
|
|
|
m_enabled = original->debugEnabled();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
m_level = TelEngine::debugLevel();
|
|
|
|
m_enabled = debugEnabled();
|
|
|
|
}
|
|
|
|
m_chain = 0;
|
|
|
|
}
|
|
|
|
|
2005-03-20 03:11:53 +00:00
|
|
|
Debugger::Debugger(const char* name, const char* format, ...)
|
2004-05-22 00:05:20 +00:00
|
|
|
: m_name(name)
|
|
|
|
{
|
2007-08-23 09:58:46 +00:00
|
|
|
if (s_debugging && m_name && (s_debug >= DebugAll) && !reentered()) {
|
2004-05-22 00:05:20 +00:00
|
|
|
char buf[64];
|
|
|
|
::snprintf(buf,sizeof(buf),">>> %s",m_name);
|
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.lock();
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(DebugAll,buf,format,va);
|
2004-05-22 00:05:20 +00:00
|
|
|
va_end(va);
|
|
|
|
s_indent++;
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.unlock();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
m_name = 0;
|
|
|
|
}
|
|
|
|
|
2005-03-20 03:11:53 +00:00
|
|
|
Debugger::Debugger(int level, const char* name, const char* format, ...)
|
2004-05-22 00:05:20 +00:00
|
|
|
: m_name(name)
|
|
|
|
{
|
2007-08-23 09:58:46 +00:00
|
|
|
if (s_debugging && m_name && (s_debug >= level) && !reentered()) {
|
2004-05-22 00:05:20 +00:00
|
|
|
char buf[64];
|
|
|
|
::snprintf(buf,sizeof(buf),">>> %s",m_name);
|
|
|
|
va_list va;
|
|
|
|
va_start(va,format);
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.lock();
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(DebugAll,buf,format,va);
|
2004-05-22 00:05:20 +00:00
|
|
|
va_end(va);
|
|
|
|
s_indent++;
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.unlock();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
m_name = 0;
|
|
|
|
}
|
|
|
|
|
2005-01-16 02:32:40 +00:00
|
|
|
static void dbg_dist_helper(const char* buf, const char* fmt, ...)
|
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
va_start(va,fmt);
|
2005-06-20 20:51:17 +00:00
|
|
|
dbg_output(DebugAll,buf,fmt,va);
|
2005-01-16 02:32:40 +00:00
|
|
|
va_end(va);
|
|
|
|
}
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
Debugger::~Debugger()
|
|
|
|
{
|
|
|
|
if (m_name) {
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.lock();
|
2004-05-22 00:05:20 +00:00
|
|
|
s_indent--;
|
2007-08-23 09:58:46 +00:00
|
|
|
if (s_debugging)
|
|
|
|
dbg_dist_helper("<<< ","%s",m_name);
|
2004-10-24 21:35:54 +00:00
|
|
|
ind_mux.unlock();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
void Debugger::setOutput(void (*outFunc)(const char*,int))
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2004-10-21 23:11:46 +00:00
|
|
|
out_mux.lock();
|
2004-05-22 00:05:20 +00:00
|
|
|
s_output = outFunc ? outFunc : dbg_stderr_func;
|
2004-10-21 23:11:46 +00:00
|
|
|
out_mux.unlock();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2005-06-20 20:51:17 +00:00
|
|
|
void Debugger::setIntOut(void (*outFunc)(const char*,int))
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2004-10-21 23:11:46 +00:00
|
|
|
out_mux.lock();
|
2004-05-22 00:05:20 +00:00
|
|
|
s_intout = outFunc;
|
2004-10-21 23:11:46 +00:00
|
|
|
out_mux.unlock();
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2006-05-19 15:52:05 +00:00
|
|
|
void Debugger::enableOutput(bool enable, bool colorize)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
s_debugging = enable;
|
2006-05-19 15:52:05 +00:00
|
|
|
if (colorize)
|
|
|
|
setOutput(dbg_colorize_func);
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2006-12-22 00:57:35 +00:00
|
|
|
void Debugger::setFormatting(Formatting format)
|
|
|
|
{
|
|
|
|
// start stamp will be rounded to full second
|
|
|
|
s_timestamp = (Time::now() / 1000000) * 1000000;
|
|
|
|
s_fmtstamp = format;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-13 05:09:50 +00:00
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
u_int64_t Time::now()
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-04-02 00:49:38 +00:00
|
|
|
#ifdef _WINDOWS
|
|
|
|
FILETIME ft;
|
|
|
|
GetSystemTimeAsFileTime(&ft);
|
|
|
|
// Convert from FILETIME (100 nsec units since January 1, 1601)
|
|
|
|
// to extended time_t (1 usec units since January 1, 1970)
|
|
|
|
u_int64_t rval = ((ULARGE_INTEGER*)&ft)->QuadPart / 10;
|
|
|
|
rval -= 11644473600000000;
|
|
|
|
return rval;
|
|
|
|
#else
|
2004-05-22 00:05:20 +00:00
|
|
|
struct timeval tv;
|
|
|
|
return ::gettimeofday(&tv,0) ? 0 : fromTimeval(&tv);
|
2005-05-10 14:54:04 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int64_t Time::msecNow()
|
|
|
|
{
|
|
|
|
return (u_int64_t)(now() / 1000);
|
|
|
|
}
|
2005-04-02 00:49:38 +00:00
|
|
|
|
2005-05-10 14:54:04 +00:00
|
|
|
u_int32_t Time::secNow()
|
|
|
|
{
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
return (u_int32_t)(now() / 1000000);
|
|
|
|
#else
|
|
|
|
struct timeval tv;
|
|
|
|
return ::gettimeofday(&tv,0) ? 0 : tv.tv_sec;
|
2005-04-02 00:49:38 +00:00
|
|
|
#endif
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2006-05-24 10:04:22 +00:00
|
|
|
u_int64_t Time::fromTimeval(const struct timeval* tv)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
2005-04-02 00:49:38 +00:00
|
|
|
u_int64_t rval = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
if (tv) {
|
|
|
|
// Please keep it this way or the compiler may b0rk
|
|
|
|
rval = tv->tv_sec;
|
|
|
|
rval *= 1000000;
|
|
|
|
rval += tv->tv_usec;
|
|
|
|
}
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
void Time::toTimeval(struct timeval* tv, u_int64_t usec)
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
if (tv) {
|
2005-04-02 00:49:38 +00:00
|
|
|
tv->tv_usec = (long)(usec % 1000000);
|
|
|
|
tv->tv_sec = (long)(usec / 1000000);
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-09 14:30:05 +00:00
|
|
|
// Build EPOCH time from date/time components
|
|
|
|
unsigned int Time::toEpoch(int year, unsigned int month, unsigned int day,
|
|
|
|
unsigned int hour, unsigned int minute, unsigned int sec, int offset)
|
|
|
|
{
|
|
|
|
Debug(DebugAll,"Time::toEpoch(%d,%u,%u,%u,%u,%u,%d)",
|
|
|
|
year,month,day,hour,minute,sec,offset);
|
|
|
|
if (year < 1970)
|
|
|
|
return (unsigned int)-1;
|
|
|
|
if (month < 1 || month > 12 || !day)
|
|
|
|
return (unsigned int)-1;
|
|
|
|
if (hour == 24 && (minute || sec))
|
|
|
|
return (unsigned int)-1;
|
|
|
|
else if (hour > 23 || minute > 59 || sec > 59)
|
|
|
|
return (unsigned int)-1;
|
|
|
|
// Check if month and day are correct in the given year
|
|
|
|
month--;
|
|
|
|
unsigned int m[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
|
|
|
|
if (isLeap(year))
|
|
|
|
m[1] = 29;
|
|
|
|
if (day > m[month])
|
|
|
|
return (unsigned int)-1;
|
|
|
|
// Count the number of days since EPOCH
|
|
|
|
int64_t days = (year - 1970) * 365;
|
|
|
|
// Add a day for each leap year from 1970 to 'year' (not including)
|
2009-01-12 09:38:53 +00:00
|
|
|
for (int y = 1972; y < year; y += 4) {
|
2009-01-09 14:30:05 +00:00
|
|
|
if (isLeap(y))
|
|
|
|
days++;
|
2009-01-12 09:38:53 +00:00
|
|
|
}
|
2009-01-09 14:30:05 +00:00
|
|
|
// Add days ellapsed in given year
|
|
|
|
for (unsigned int i = 0; i < month; i++)
|
|
|
|
days += m[i];
|
|
|
|
days += day - 1;
|
|
|
|
int64_t ret = (days * 24 + hour) * 3600 + minute * 60 + sec + offset;
|
|
|
|
|
|
|
|
// Check for incorrect time or overflow
|
|
|
|
if (ret < 0 || ret > (unsigned int)-1)
|
|
|
|
return (unsigned int)-1;
|
|
|
|
return (unsigned int)ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Split a given EPOCH time into its date/time components
|
|
|
|
bool Time::toDateTime(unsigned int epochTimeSec, int& year, unsigned int& month,
|
|
|
|
unsigned int& day, unsigned int& hour, unsigned int& minute, unsigned int& sec)
|
|
|
|
{
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
FILETIME ft;
|
|
|
|
SYSTEMTIME st;
|
|
|
|
// 11644473600: the number of seconds from 1601, January 1st (FILETIME)
|
|
|
|
// to EPOCH (1970, January 1st)
|
|
|
|
// Remember: FILETIME keeps the number of 100 nsec units
|
|
|
|
u_int64_t time = (11644473600 + epochTimeSec) * 10000000;
|
|
|
|
ft.dwLowDateTime = (DWORD)time;
|
|
|
|
ft.dwHighDateTime = (DWORD)(time >> 32);
|
|
|
|
if (!FileTimeToSystemTime(&ft,&st))
|
|
|
|
return false;
|
|
|
|
year = st.wYear;
|
|
|
|
month = st.wMonth;
|
|
|
|
day = st.wDay;
|
|
|
|
hour = st.wHour;
|
|
|
|
minute = st.wMinute;
|
|
|
|
sec = st.wSecond;
|
|
|
|
#else
|
|
|
|
struct tm t;
|
|
|
|
time_t time = (time_t)epochTimeSec;
|
|
|
|
if (!gmtime_r(&time,&t))
|
|
|
|
return false;
|
|
|
|
year = 1900 + t.tm_year;
|
|
|
|
month = t.tm_mon + 1;
|
|
|
|
day = t.tm_mday;
|
|
|
|
hour = t.tm_hour;
|
|
|
|
minute = t.tm_min;
|
|
|
|
sec = t.tm_sec;
|
|
|
|
#endif
|
|
|
|
Debug(DebugAll,"Time::toDateTime(%u,%d,%u,%u,%u,%u,%u)",
|
|
|
|
epochTimeSec,year,month,day,hour,minute,sec);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-01-12 05:32:06 +00:00
|
|
|
|
|
|
|
bool GenObject::alive() const
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GenObject::destruct()
|
|
|
|
{
|
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
2010-11-01 14:54:53 +00:00
|
|
|
static MutexPool s_refMutex(REFOBJECT_MUTEX_COUNT,false,"RefObject");
|
2007-05-15 11:16:41 +00:00
|
|
|
|
2010-11-01 14:54:53 +00:00
|
|
|
RefObject::RefObject()
|
|
|
|
: m_refcount(1), m_mutex(s_refMutex.mutex(this))
|
|
|
|
{
|
|
|
|
}
|
2004-12-20 04:11:29 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
RefObject::~RefObject()
|
|
|
|
{
|
2004-12-20 04:11:29 +00:00
|
|
|
if (m_refcount > 0)
|
2005-03-28 22:27:26 +00:00
|
|
|
Debug(DebugFail,"RefObject [%p] destroyed with count=%d",this,m_refcount);
|
2004-05-22 00:05:20 +00:00
|
|
|
}
|
|
|
|
|
2006-01-12 05:32:06 +00:00
|
|
|
bool RefObject::alive() const
|
|
|
|
{
|
|
|
|
return m_refcount > 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RefObject::destruct()
|
|
|
|
{
|
|
|
|
deref();
|
|
|
|
}
|
|
|
|
|
2007-06-07 17:53:01 +00:00
|
|
|
bool RefObject::refInternal()
|
2004-12-20 04:11:29 +00:00
|
|
|
{
|
2007-06-07 17:53:01 +00:00
|
|
|
if (m_refcount > 0) {
|
2006-01-12 05:32:06 +00:00
|
|
|
++m_refcount;
|
2007-06-07 17:53:01 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RefObject::ref()
|
|
|
|
{
|
2010-11-01 14:54:53 +00:00
|
|
|
Lock lock(m_mutex);
|
2007-06-07 17:53:01 +00:00
|
|
|
return refInternal();
|
2004-12-20 04:11:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool RefObject::deref()
|
|
|
|
{
|
2007-06-04 22:18:59 +00:00
|
|
|
bool zeroCall = false;
|
2010-11-01 14:54:53 +00:00
|
|
|
m_mutex->lock();
|
2006-01-12 05:32:06 +00:00
|
|
|
int i = m_refcount;
|
|
|
|
if (i > 0)
|
|
|
|
--m_refcount;
|
|
|
|
if (i == 1)
|
2007-06-04 22:18:59 +00:00
|
|
|
zeroCall = zeroRefsTest();
|
2010-11-01 14:54:53 +00:00
|
|
|
m_mutex->unlock();
|
2007-06-04 22:18:59 +00:00
|
|
|
if (zeroCall)
|
2005-07-18 21:47:18 +00:00
|
|
|
zeroRefs();
|
2006-01-18 16:06:05 +00:00
|
|
|
else if (i <= 0)
|
|
|
|
Debug(DebugFail,"RefObject::deref() called with count=%d [%p]",i,this);
|
2006-01-12 05:32:06 +00:00
|
|
|
return (i <= 1);
|
2004-12-20 04:11:29 +00:00
|
|
|
}
|
|
|
|
|
2005-07-18 21:47:18 +00:00
|
|
|
void RefObject::zeroRefs()
|
2006-01-12 05:32:06 +00:00
|
|
|
{
|
2007-05-15 11:16:41 +00:00
|
|
|
destroyed();
|
2006-01-12 05:32:06 +00:00
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
|
2007-06-04 22:18:59 +00:00
|
|
|
bool RefObject::zeroRefsTest()
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2006-01-12 05:32:06 +00:00
|
|
|
bool RefObject::resurrect()
|
2005-07-18 21:47:18 +00:00
|
|
|
{
|
2010-11-01 14:54:53 +00:00
|
|
|
m_mutex->lock();
|
2006-01-12 05:32:06 +00:00
|
|
|
bool ret = (0 == m_refcount);
|
|
|
|
if (ret)
|
|
|
|
m_refcount = 1;
|
2010-11-01 14:54:53 +00:00
|
|
|
m_mutex->unlock();
|
2006-01-12 05:32:06 +00:00
|
|
|
return ret;
|
2005-07-18 21:47:18 +00:00
|
|
|
}
|
|
|
|
|
2007-05-15 12:51:13 +00:00
|
|
|
void RefObject::destroyed()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-03-28 00:58:26 +00:00
|
|
|
void RefPointerBase::assign(RefObject* oldptr, RefObject* newptr, void* pointer)
|
|
|
|
{
|
|
|
|
if (oldptr == newptr)
|
|
|
|
return;
|
|
|
|
// Always reference the new object before dereferencing the old one
|
2006-01-12 05:32:06 +00:00
|
|
|
// and also don't keep pointers to objects that fail referencing
|
|
|
|
m_pointer = (newptr && newptr->ref()) ? pointer : 0;
|
2005-03-28 00:58:26 +00:00
|
|
|
if (oldptr)
|
|
|
|
oldptr->deref();
|
|
|
|
}
|
|
|
|
|
2006-05-24 10:04:22 +00:00
|
|
|
|
|
|
|
void SysUsage::init()
|
|
|
|
{
|
|
|
|
if (!s_startTime)
|
|
|
|
s_startTime = Time::now();
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int64_t SysUsage::startTime()
|
|
|
|
{
|
|
|
|
init();
|
|
|
|
return s_startTime;
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int64_t SysUsage::usecRunTime(Type type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case WallTime:
|
|
|
|
return Time::now() - startTime();
|
|
|
|
case UserTime:
|
|
|
|
{
|
|
|
|
#ifdef _WINDOWS
|
2006-07-01 00:23:11 +00:00
|
|
|
FILETIME dummy,ft;
|
|
|
|
if (GetProcessTimes(GetCurrentProcess(),&dummy,&dummy,&dummy,&ft)) {
|
2006-05-24 10:04:22 +00:00
|
|
|
u_int64_t t = ft.dwLowDateTime | (((u_int64_t)ft.dwHighDateTime) << 32);
|
|
|
|
return t / 10;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
struct rusage usage;
|
|
|
|
// FIXME: this is broken, may not sum all threads
|
|
|
|
if (!::getrusage(RUSAGE_SELF,&usage))
|
|
|
|
return Time::fromTimeval(usage.ru_utime);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case KernelTime:
|
|
|
|
{
|
|
|
|
#ifdef _WINDOWS
|
2006-07-01 00:23:11 +00:00
|
|
|
FILETIME dummy,ft;
|
|
|
|
if (GetProcessTimes(GetCurrentProcess(),&dummy,&dummy,&ft,&dummy)) {
|
2006-05-24 10:04:22 +00:00
|
|
|
u_int64_t t = ft.dwLowDateTime | (((u_int64_t)ft.dwHighDateTime) << 32);
|
|
|
|
return t / 10;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
struct rusage usage;
|
|
|
|
// FIXME: this is broken, may not sum all threads
|
|
|
|
if (!::getrusage(RUSAGE_SELF,&usage))
|
|
|
|
return Time::fromTimeval(usage.ru_stime);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int64_t SysUsage::msecRunTime(Type type)
|
|
|
|
{
|
|
|
|
return usecRunTime(type) / 1000;
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int32_t SysUsage::secRunTime(Type type)
|
|
|
|
{
|
|
|
|
return (u_int32_t)(usecRunTime(type) / 1000000);
|
|
|
|
}
|
|
|
|
|
|
|
|
double SysUsage::runTime(Type type)
|
|
|
|
{
|
2006-05-26 08:16:45 +00:00
|
|
|
#ifdef _WINDOWS
|
|
|
|
// VC++ 6 does not implement conversion from UINT64 to double!
|
|
|
|
return 0.000001 * (int64_t)usecRunTime(type);
|
|
|
|
#else
|
2006-05-24 10:04:22 +00:00
|
|
|
return 0.000001 * usecRunTime(type);
|
2006-05-26 08:16:45 +00:00
|
|
|
#endif
|
2006-05-24 10:04:22 +00:00
|
|
|
}
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
2005-03-28 00:58:26 +00:00
|
|
|
|
|
|
|
/* vi: set ts=8 sw=4 sts=4 noet: */
|