void Logger::warn(const char *fmt, ...)
{
if (LOG_WARN >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_WARN, fmt, ap);
va_end(ap);
}
}
void Logger::info(const char *fmt, ...)
{
if (LOG_INFO >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_INFO, fmt, ap);
va_end(ap);
}
}
void TemplateBased::setup(const char* cascadeFileName) {
try {
if(!face_cascade.load(cascadeFileName)) {
throw "--(!)Error loading face cascade, please change face_cascade_name in source code.\n";
}
} catch (const char* msg) {
doLog(true, msg);
throw;
}
};
void Logger::error(const char *fmt, ...)
{
if (LOG_ERROR >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_ERROR, fmt, ap);
va_end(ap);
}
}
void run()
{
status_ = "good";
doLog("send thread running");
std::string msg;
do
{
doLog("send thread enqing msg");
msg = q_.deQ();
if(!s_.writeLine(msg))
{
sout << "\n bad status in sending thread";
status_ = "bad";
break;
}
} while(msg != "stop");
s_.disconnect();
};
/* compute a hash for the plugin and pass to database system for insertion */
int
checkAddPlugin (const char* pluginFile, const char* pluginName,
lt_dlhandle pluginHandle)
{
/* First get the file's digest */
char shaCommand[264];
snprintf (shaCommand, 264, "sha1sum %s", pluginFile);
FILE* shaStream = popen (shaCommand, "r");
char digest[42];
if(!fread (digest, 40, 1, shaStream))
return -1;
digest[41] = '\0';
pclose (shaStream);
doLog (NOTICE, LOG_COMP, _("%s digest: %.40s."), pluginName, digest);
/* Now extract the head and load it! */
ghType getHead = lt_dlsym (pluginHandle, "getPluginHead");
if (getHead)
{
if ( lsddb_pluginHeadLoader (getHead, 0, pluginName, digest,
pluginHandle) < 0 )
{
doLog (ERROR, LOG_COMP, _("Unable to validate plugin HEAD of %s."), pluginName);
lt_dlclose (pluginHandle);
return -1;
}
}
else
{
doLog (ERROR, LOG_COMP, _("Error while loading HEAD of %s.\nDetails: %s"),
pluginName, lt_dlerror());
lt_dlclose (pluginHandle);
return -1;
}
return 0;
}
/* Static plugin counterpart of checkAddPlugin
* searches for pluginHead accessor within linked plugin */
int
checkAddPlugin_static (const char* pluginName, void* ghPtr)
{
ghType getHead = (ghType)ghPtr;
if (getHead)
{
if ( lsddb_pluginHeadLoader (getHead, 0, pluginName, "STATIC",
NULL) < 0 )
{
doLog (ERROR, LOG_COMP, _("Unable to validate plugin HEAD of %s statically."), pluginName);
return -1;
}
}
else
{
doLog (ERROR, LOG_COMP, _("Error while loading HEAD of %s statically."),
pluginName);
return -1;
}
}
// Log each element of the string list
void CElement::log_table(bool bIsWarning, const list<string> lstrMessage) const
{
list<string>::const_iterator iterator(lstrMessage.begin());
list<string>::const_iterator end(lstrMessage.end());
while (iterator != end) {
// Log current list element
doLog(bIsWarning, iterator->c_str());
++iterator;
}
}
/* Opens the plugins directory provided and calls
* scrapePlugin for the name */
int
loadPluginsDirectory ()
{
/* Plugin directory is set by autotools using user-defined prefix */
#ifndef PLUGIN_DIR
doLog (ERROR, LOG_COMP, _("PLUGIN_DIR not provided at compile time."));
return -1;
#endif
return lt_dlforeachfile (PLUGIN_PATH, scrapePlugin, NULL);
}
int doError(char *text)
{
char msg[256];
snprintf(msg,sizeof(msg),
"error:%s off=%lld len=%lld errno=%d",
text,(unsigned long long)off,(unsigned long long)len,errno);
if(debug<2)
syslog(LOG_ERR,"%s",msg);
else doLog(msg);
return False;
}
void Logger::fatal(const char *fmt, ...)
{
// 如果设定的日志级别比FATAL低，则记录日志
if (LOG_FATAL >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_FATAL, fmt, ap);
va_end(ap);
}
}
int main(int argc, char *argv[])
{
if (argc != 2)
usage();
snpHash = newHash(16);
uniqHash = newHash(16);
readInput(argv[1]);
doLog();
return 0;
}
void JLogger::logp(JLevel* level, JString sourceClass, JString sourceMethod, JString msg, JObject* param1) {
if (level->intValue() < levelValue || levelValue == JLevel::OFF->intValue()) {
return;
}
JLogRecord* lr = new JLogRecord(level, msg);
lr->setSourceClassName(sourceClass);
lr->setSourceMethodName(sourceMethod);
JPrimitiveArray* a=new JPrimitiveArray(JObject::getClazz(),1);
a->set(0,param1);
lr->setParameters(a);
doLog(lr);
}
void run()
{
std::string msg;
do
{
doLog("receive thread reading line");
msg = s_.readLine();
if(msg == "")
break;
q_.enQ(msg);
} while(msg != "quit");
stopFlag=true;
}
static void sendReply(int sock,uint32_t opt,uint32_t reply_type, size_t datasize, void* data)
{
uint64_t magic = htonll(0x3e889045565a9LL);
reply_type = htonl(reply_type);
uint32_t datsize = htonl(datasize);
doLog("sendReply");
putBytes(sock,&magic,sizeof(magic));
putBytes(sock,&opt,sizeof(opt));
putBytes(sock,&reply_type,sizeof(reply_type));
putBytes(sock,&datsize,sizeof(datsize));
if(datasize) putBytes(sock,data,datasize);
}
void main(int argc,char **argv)
{
int listener;
int c;
int f;
while ((c = getopt (argc, argv, "d")) != -1)
{
switch(c)
{
case 'd':
debug++;
break;
default:
exit(1);
}
}
if(!debug) {
f = fork();
if(f<0) { printf("Fork error [err=%d]\n",errno); exit(1); }
if(f>0) exit(0); // Parent
setsid(); for (f=getdtablesize();f>=0;--f) close(f);
f=open("/dev/null",O_RDWR); dup(f); dup(f); umask(027); chdir("/tmp/");
signal( SIGCHLD, SIG_IGN );
}
openlog ("nbd", LOG_CONS|LOG_PID|LOG_NDELAY , LOG_USER);
doLog("NBD server v0.1 started");
if(doCreatePid()<0) {
doLog("-- ABORT");
exit(1);
}
if((listener=getSocket())>0) {
doAccept(listener);
close(listener);
}
doLog("NBD server stopped");
closelog ();
exit(0);
}
void putBytes(int sock,void *buf, size_t len)
{
char msg[1024];
if(debug>1) {
sprintf(msg,"putBytes=%d",(int)len);
doLog(msg);
}
if(debug>2) {
int i;
char *ptr = (char*)buf;
for(i=0;i<len;i++) {
if(i>200) break;
printf("%02x ",*ptr++ && 255);
}
printf("\n");
}
if( write( sock,buf,len ) < 0) {
doLog("Critical Error in WRITE");
exit(errno);
}
}
void Logger::debug(
const char *file,
int line,
const char *function,
const char *fmt, ...)
{
if (LOG_DEBUG >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_DEBUG, fmt, ap, file, line, function);
va_end(ap);
}
}
void Logger::trace(
const char *file,
int line,
const char *function,
const char *fmt, ...)
{
if (LOG_TRACE >= m_Level) {
va_list ap;
va_start(ap, fmt);
doLog(LOG_TRACE, fmt, ap, file, line, function);
va_end(ap);
}
}
IOReturn EMUUSBInputStream::readFrameList (UInt32 frameListNum) {
debugIOLogR("+ read frameList %d ", frameListNum);
if (shouldStop) {
debugIOLog("*** Read should have stopped. Who is calling this? Canceling call")
return kIOReturnAborted;
}
IOReturn result = kIOReturnError;
if (pipe) {
UInt32 firstFrame = frameListNum * numUSBFramesPerList;
usbCompletion[frameListNum].target = (void*) this;
usbCompletion[frameListNum].action = readCompleted;
usbCompletion[frameListNum].parameter = (void*) (UInt64)frameListNum; // remember the frameListNum
for (int i = 0; i < numUSBFramesPerList; ++i) {
usbIsocFrames[firstFrame+i].frStatus = -1; // used to check if this frame was already received
usbIsocFrames[firstFrame+i].frActCount = 0; // actual #bytes transferred
usbIsocFrames[firstFrame+i].frReqCount = maxFrameSize; // #bytes to read.
*(UInt64 *)(&(usbIsocFrames[firstFrame + i].frTimeStamp)) = 0ul; //time when frame was procesed
}
/* The updatefrequency (last arg of Read) is not so well documented. But in IOUSBInterfaceInterface192:
Specifies how often, in milliseconds, the frame list data should be updated. Valid range is 0 - 8.
If 0, it means that the framelist should be updated at the end of the transfer.
It appears that this number also has impact on the timing details (latency) in the frame list.
If you set this to 0, there happens an additional 8ms for a full framelist once in a
few minutes in the timings.
If you set this to 1, this jump is 8x more often, about once 30 seconds, but is only 1ms.
We must keep these jumps small, to avoid timestamp errors and buffer overruns.
*/
UInt64 frameNr = getNextFrameNr();
result = pipe->Read(bufferDescriptors[frameListNum], frameNr, numUSBFramesPerList,
&usbIsocFrames[firstFrame], &usbCompletion[frameListNum],1);
debugIOLogR("READ framelist %d in framenr %lld at %lld",frameListNum, frameNr,mach_absolute_time());
if (result != kIOReturnSuccess) {
// FIXME #17 if this goes wrong, why continue?
doLog("USB pipe READ error %x",result);
}
}
return result;
}
void BlinkMeasure::processBm(BlinkMeasure bm, double lavg, double ravg, double lSD, double rSD,
double plsdf, double mlsdf, double prsdf, double mrsdf, double lsdt, double rsdt) {
if (BlinkMeasure::isFirst == false) {
BlinkMeasure::isFirst = true;
BlinkMeasure::prevLcor = bm.lcor;
BlinkMeasure::prevRcor = bm.rcor;
} else {
doLog(debug_blinks_d1, "debug_blinks_d1: lastF %d T %.2lf La %lf %lf %.8lf Ra %lf %lf %.8lf lSDft %lf %lf %lf %lf rSDft %lf %lf %lf %lf\n",
bm.frameNum, bm.timestamp,
bm.lcor, lavg, (bm.lcor-BlinkMeasure::prevLcor), bm.rcor, ravg, (bm.rcor-BlinkMeasure::prevRcor),
lSD, plsdf, mlsdf, lsdt, rSD, prsdf, mrsdf, rsdt);
BlinkMeasure::prevLcor = bm.lcor;
BlinkMeasure::prevRcor = bm.rcor;
}
}
void doConnectionMade(int sock)
{
struct {
volatile uint64_t passwd __attribute__((packed));
volatile uint64_t magic __attribute__((packed));
volatile uint16_t flags __attribute__((packed));
} nbd;
memcpy(&nbd,INIT_PASSWD,8);
nbd.magic = htonll(OPTS_MAGIC);
nbd.flags = htons(NBD_FLAG_FIXED_NEWSTYLE);
doLog("Connection Made");
putBytes(sock,&nbd,sizeof(nbd));
}
void LogManager::vlog(LogChannel* channel, const char* act, const char* srcname, uint line, const char* fnname, const char* fmt, va_list args)
{
// prepare message
char msg[MAX_BUF_SIZE];
int msgLen = vsnprintf(msg, sizeof(msg)-1, fmt, args);
// TODO: handle with insufficient buffer (snprintf(NULL, ...) may work?)
if (msgLen < 0)
{
assert(false);
return;
}
// TODO: detect tag here first
doLog(channel, act, srcname, line, fnname, NULL, msg, msgLen, false);
}
void rcContext::log(const rcLogCategory category, const char* format, ...)
{
if (!m_logEnabled)
return;
static const int MSG_SIZE = 512;
char msg[MSG_SIZE];
va_list ap;
va_start(ap, format);
int len = vsnprintf(msg, MSG_SIZE, format, ap);
if (len >= MSG_SIZE)
{
len = MSG_SIZE - 1;
msg[MSG_SIZE - 1] = '\0';
}
va_end(ap);
doLog(category, msg, len);
}
// -----------------------------------------------------------------------------
// CCPixMWTester::TestAddUnloadlistL
// -----------------------------------------------------------------------------
//
TInt CCPixMWTester::TestAddUnloadlistL( CStifItemParser& /*aItem*/)
{
TInt err = KErrNone;
CBlacklistMgr* blacklistmanager = CBlacklistMgr::NewL();
CleanupStack::PushL( blacklistmanager );
//Add an Uid to Blacklist DB
blacklistmanager->AddtoDontloadListL( KTestUid );
//Check if the Uid is added to database or not
TBool found = blacklistmanager->FindInDontloadListL(KTestUid );
if(!found) err = KErrNotFound;
//clear the UID from the database
blacklistmanager->RemoveFromDontloadListL(KTestUid);
CleanupStack::PopAndDestroy( blacklistmanager );
doLog( iLog, err, KNoErrorString );
return err;
}
void CElement::log_warning(const string& strMessage, ...) const
{
char *pacBuffer;
va_list listPointer;
va_start(listPointer, strMessage);
vasprintf(&pacBuffer, strMessage.c_str(), listPointer);
va_end(listPointer);
if (pacBuffer != NULL) {
doLog(true, pacBuffer);
}
free(pacBuffer);
}
bool BlinkMeasure::joinBlinks() {
bool anyAdded = false;
if (BlinkMeasure::lAdding == true || BlinkMeasure::rAdding == true) {
// waiting that blinks from both eyes are finished
return false;
}
std::set<unsigned int> takenRBlinks;
std::list<Blink>::iterator lIter = lBlinkChunks.begin();
while(lIter != lBlinkChunks.end()) {
Blink& lb = *lIter;
std::list<Blink>::iterator rIter = rBlinkChunks.begin();
while(rIter != rBlinkChunks.end()) {
Blink& rb = *rIter;
if (takenRBlinks.find(rb.frameStart) != takenRBlinks.end()) {
rIter++;
continue;
}
if ((lb.frameStart <= rb.frameStart && rb.frameStart <= lb.frameEnd)
|| (lb.frameStart <= rb.frameEnd && rb.frameEnd <= lb.frameEnd)
|| (rb.frameStart <= lb.frameStart && lb.frameStart <= rb.frameEnd)
|| (rb.frameStart <= lb.frameEnd && lb.frameEnd <= rb.frameEnd)) {
// use extended length as a result (joined) blink
unsigned int frameStart = (lb.frameStart < rb.frameStart)?lb.frameStart:rb.frameStart;
unsigned int frameEnd = (lb.frameEnd > rb.frameEnd)?lb.frameEnd:rb.frameEnd;
double timestampStart = (lb.timestampStart < rb.timestampStart)?lb.timestampStart:rb.timestampStart;
double timestampEnd = (lb.timestampEnd > rb.timestampEnd)?lb.timestampEnd:rb.timestampEnd;
Blink joinedBlink(frameStart, frameEnd, timestampStart, timestampEnd, 0);
joinedBlinkChunksN1.push_back(joinedBlink);
anyAdded = true;
takenRBlinks.insert(rb.frameStart);
doLog(debug_blinks_d5, "debug_blinks_d5: adding fs %d fe %d start %.2lf end %lf duration %lf\n",
frameStart, frameEnd, timestampStart, timestampEnd, timestampEnd-timestampStart);
break;
}
rIter++;
}
lIter++;
}
lBlinkChunks.clear();
rBlinkChunks.clear();
return anyAdded;
}
void EventMonitorEntry::logImmediately(bool sendEvent) {
const int arraySize = _indexArray.size();
if (arraySize > 0) {
QString logMessage;
QString rangeString;
bool makeRange = false;
int idx = 0;
int idxOld = 0;
for (int i = 0; i < arraySize; ++i) {
idx = *_indexArray.at(i);
if (i == 0) {
rangeString.setNum(idx);
} else if (!makeRange && idx == idxOld + 1) {
makeRange = true;
} else if (makeRange && idx != idxOld + 1) {
rangeString = i18n("%1-%2,%3").arg(rangeString).arg(idxOld).arg(idx);
makeRange = false;
} else if (idx != idxOld + 1) {
rangeString = i18n("%1,%2").arg(rangeString).arg(idx);
}
idxOld = idx;
}
if (makeRange) {
rangeString = i18n("%1-%2").arg(rangeString).arg(idx);
}
if (_description.isEmpty()) {
logMessage = i18n("Event Monitor: %1: %2").arg(_event).arg(rangeString);
} else {
logMessage = i18n("Event Monitor: %1: %2").arg(_description).arg(rangeString);
}
_indexArray.clear();
if (sendEvent) { // update thread
QApplication::postEvent(this, new EventMonitorEvent(logMessage));
} else { // GUI thread
doLog(logMessage);
}
}
}
// -----------------------------------------------------------------------------
// CCPixMWTester::TestBlacklistPluginL
// -----------------------------------------------------------------------------
//
TInt CCPixMWTester::TestBlacklistPluginL( CStifItemParser& aItem )
{
TInt err = KErrNone;
CBlacklistMgr* blacklistmanager = CBlacklistMgr::NewL();
CleanupStack::PushL( blacklistmanager );
TInt version = 0;
aItem.GetNextInt(version);
//Add an Uid to Blacklist DB
blacklistmanager->AddL( KTestUid , version );
//Check if the Uid is added to database or not
TBool found = blacklistmanager->FindL(KTestUid , version );
if(!found) err = KErrNotFound;
//clear the UID from the database
blacklistmanager->Remove(KTestUid);
CleanupStack::PopAndDestroy( blacklistmanager );
doLog( iLog, err, KNoErrorString );
return err;
}
void Logger::log(Log log)
{
QString msg;
if( _showTime ) {
msg = log.timeStamp.toString(QLatin1String("MM-dd hh:mm:ss:zzz")) + QLatin1Char(' ');
}
if( log.source == Log::CSync ) {
// msg += "csync - ";
} else {
// msg += "ownCloud - ";
}
msg += QString().sprintf("%p ", (void*)QThread::currentThread());
msg += log.message;
// _logs.append(log);
// std::cout << qPrintable(log.message) << std::endl;
doLog(msg);
}
