static void WriteEvents(TextWriter &writer, const Result &result) { JSON::ObjectWriter object(writer); WriteEvent(object, "takeoff", result.takeoff_time, result.takeoff_location); WriteEvent(object, "release", result.release_time, result.release_location); WriteEvent(object, "landing", result.landing_time, result.landing_location); }
void GOrgueMidiRecorder::SendEvent(GOrgueMidiEvent& e) { e.SetDevice(m_OutputDevice); if (m_OutputDevice) m_organfile->SendMidiMessage(e); if (IsRecording()) WriteEvent(e); }
// // Write an EBP configuration element to the XML output stream. // void CDCConfig::WriteEBP(QTextStream& xmlStream) { xmlStream << " <ebp" ; WriteStringAttr(xmlStream, "name", m_configName) ; WriteDecimalAttr(xmlStream, "mux_period", m_multiplexPeriod) ; // num_groups is not read. It is written as a debugging aid xmlStream << ">\n" ; PerfEventList::iterator it = m_eventContainer.getPerfEventList()->begin(); PerfEventList::iterator it_end = m_eventContainer.getPerfEventList()->end(); for (; it != it_end; it++) { WriteEvent(xmlStream, &(*it)) ; } WriteTooltip(xmlStream, m_toolTip) ; WriteDescription(xmlStream, m_description) ; xmlStream << " </ebp>\n" ; }
static DWORD WINAPI _xfilter(LPVOID dummy=nullptr) { ProcessException=TRUE; DWORD Result = EXCEPTION_EXECUTE_HANDLER; BOOL Res=FALSE; // if(From == EXCEPT_KERNEL) // CriticalInternalError=TRUE; if (!Is_STACK_OVERFLOW && Opt.ExceptUsed) { if (!Opt.strExceptEventSvc.IsEmpty()) { HMODULE m = LoadLibrary(Opt.strExceptEventSvc); if (m) { typedef BOOL (WINAPI *ExceptionProc_t)(EXCEPTION_POINTERS *xp, const PLUGINRECORD *Module, const PluginStartupInfo *LocalStartupInfo, LPDWORD Result); ExceptionProc_t p = (ExceptionProc_t)GetProcAddress(m,"ExceptionProc"); if (p) { static PluginStartupInfo LocalStartupInfo; ClearStruct(LocalStartupInfo); static FarStandardFunctions LocalStandardFunctions; ClearStruct(LocalStandardFunctions); CreatePluginStartupInfo(nullptr, &LocalStartupInfo, &LocalStandardFunctions); LocalStartupInfo.ModuleName = Opt.strExceptEventSvc; static PLUGINRECORD PlugRec; if (Module) { ClearStruct(PlugRec); PlugRec.TypeRec=RTYPE_PLUGIN; PlugRec.SizeRec=sizeof(PLUGINRECORD); PlugRec.ModuleName=Module->GetModuleName(); PlugRec.WorkFlags=Module->GetWorkFlags(); PlugRec.CallFlags=Module->GetFuncFlags(); PlugRec.FuncFlags=0; PlugRec.FuncFlags|=Module->HasGetGlobalInfo()?PICFF_GETGLOBALINFO:0; PlugRec.FuncFlags|=Module->HasSetStartupInfo()?PICFF_SETSTARTUPINFO:0; PlugRec.FuncFlags|=Module->HasOpenPanel()?PICFF_OPENPANEL:0; PlugRec.FuncFlags|=Module->HasAnalyse()?PICFF_ANALYSE:0; PlugRec.FuncFlags|=Module->HasClosePanel()?PICFF_CLOSEPANEL:0; PlugRec.FuncFlags|=Module->HasGetPluginInfo()?PICFF_GETPLUGININFO:0; PlugRec.FuncFlags|=Module->HasGetOpenPanelInfo()?PICFF_GETOPENPANELINFO:0; PlugRec.FuncFlags|=Module->HasGetFindData()?PICFF_GETFINDDATA:0; PlugRec.FuncFlags|=Module->HasFreeFindData()?PICFF_FREEFINDDATA:0; PlugRec.FuncFlags|=Module->HasGetVirtualFindData()?PICFF_GETVIRTUALFINDDATA:0; PlugRec.FuncFlags|=Module->HasFreeVirtualFindData()?PICFF_FREEVIRTUALFINDDATA:0; PlugRec.FuncFlags|=Module->HasSetDirectory()?PICFF_SETDIRECTORY:0; PlugRec.FuncFlags|=Module->HasGetFiles()?PICFF_GETFILES:0; PlugRec.FuncFlags|=Module->HasPutFiles()?PICFF_PUTFILES:0; PlugRec.FuncFlags|=Module->HasDeleteFiles()?PICFF_DELETEFILES:0; PlugRec.FuncFlags|=Module->HasMakeDirectory()?PICFF_MAKEDIRECTORY:0; PlugRec.FuncFlags|=Module->HasProcessHostFile()?PICFF_PROCESSHOSTFILE:0; PlugRec.FuncFlags|=Module->HasSetFindList()?PICFF_SETFINDLIST:0; PlugRec.FuncFlags|=Module->HasConfigure()?PICFF_CONFIGURE:0; PlugRec.FuncFlags|=Module->HasExitFAR()?PICFF_EXITFAR:0; PlugRec.FuncFlags|=Module->HasProcessPanelInput()?PICFF_PROCESSPANELINPUT:0; PlugRec.FuncFlags|=Module->HasProcessPanelEvent()?PICFF_PROCESSPANELEVENT:0; PlugRec.FuncFlags|=Module->HasProcessEditorEvent()?PICFF_PROCESSEDITOREVENT:0; PlugRec.FuncFlags|=Module->HasCompare()?PICFF_COMPARE:0; PlugRec.FuncFlags|=Module->HasProcessEditorInput()?PICFF_PROCESSEDITORINPUT:0; PlugRec.FuncFlags|=Module->HasMinFarVersion()?PICFF_MINFARVERSION:0; PlugRec.FuncFlags|=Module->HasProcessViewerEvent()?PICFF_PROCESSVIEWEREVENT:0; PlugRec.FuncFlags|=Module->HasProcessDialogEvent()?PICFF_PROCESSDIALOGEVENT:0; PlugRec.FuncFlags|=Module->HasProcessSynchroEvent()?PICFF_PROCESSSYNCHROEVENT:0; #if defined(MANTIS_0000466) PlugRec.FuncFlags|=Module->HasProcessMacro()?PICFF_PROCESSMACRO:0; #endif #if defined(MANTIS_0001687) PlugRec.FuncFlags|=Module->HasProcessConsoleInput()?PICFF_PROCESSCONSOLEINPUT:0; #endif } Res=p(xp,(Module?&PlugRec:nullptr),&LocalStartupInfo,&Result); } FreeLibrary(m); } } } if (Res) { if (From == EXCEPT_KERNEL) { CriticalInternalError=TRUE; } return Result; } struct __ECODE { NTSTATUS Code; // код исключения LNGID IdMsg; // ID сообщения из LNG-файла DWORD RetCode; // Что вернем? } ECode[]= { {EXCEPTION_ACCESS_VIOLATION, MExcRAccess, EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_ARRAY_BOUNDS_EXCEEDED, MExcOutOfBounds, EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_INT_DIVIDE_BY_ZERO,MExcDivideByZero, EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_STACK_OVERFLOW,MExcStackOverflow, EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_BREAKPOINT,MExcBreakPoint, EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_FLT_DIVIDE_BY_ZERO,MExcFloatDivideByZero,EXCEPTION_EXECUTE_HANDLER}, // BUGBUG: Floating-point exceptions (VC) are disabled by default. See http://msdn2.microsoft.com/en-us/library/aa289157(vs.71).aspx#floapoint_topic8 {EXCEPTION_FLT_OVERFLOW,MExcFloatOverflow,EXCEPTION_EXECUTE_HANDLER}, // BUGBUG: ^^^ {EXCEPTION_FLT_STACK_CHECK,MExcFloatStackOverflow,EXCEPTION_EXECUTE_HANDLER}, // BUGBUG: ^^^ {EXCEPTION_FLT_UNDERFLOW,MExcFloatUnderflow,EXCEPTION_EXECUTE_HANDLER}, // BUGBUG: ^^^ {EXCEPTION_ILLEGAL_INSTRUCTION,MExcBadInstruction,EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_PRIV_INSTRUCTION,MExcBadInstruction,EXCEPTION_EXECUTE_HANDLER}, {EXCEPTION_DATATYPE_MISALIGNMENT, MExcDatatypeMisalignment, EXCEPTION_EXECUTE_HANDLER}, // сюды добавляем. }; // EXCEPTION_CONTINUE_EXECUTION ?????? DWORD rc; string strBuf1, strBuf2, strBuf3; LangString strBuf; string strFileName; BOOL ShowMessages=FALSE; // получим запись исключения EXCEPTION_RECORD *xr = xp->ExceptionRecord; // выведим дамп перед выдачей сообщений WriteEvent(FLOG_ALL,xp,Module,nullptr,0); // CONTEXT можно использовать для отображения или записи в лог // содержимого регистров... // CONTEXT *xc = xp->ContextRecord; rc = Result;// EXCEPTION_EXECUTE_HANDLER; /*$ 23.01.2001 skv Неизвестное исключение не стоит игнорировать. */ if (From == EXCEPT_KERNEL || !Module) strFileName=g_strFarModuleName; else strFileName = Module->GetModuleName(); LPCWSTR Exception=nullptr; // просмотрим "знакомые" FAR`у исключения и обработаем... for (size_t I=0; I < ARRAYSIZE(ECode); ++I) { if (ECode[I].Code == static_cast<NTSTATUS>(xr->ExceptionCode)) { Exception=MSG(ECode[I].IdMsg); rc=ECode[I].RetCode; if (xr->ExceptionCode == static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION)) { int Offset = 0; // вот только не надо здесь неочевидных оптимизаций вида // if ( xr->ExceptionInformation[0] == 8 ) Offset = 2 else Offset = xr->ExceptionInformation[0], // а то M$ порадует нас как-нибудь xr->ExceptionInformation[0] == 4 и все будет в полной жопе. switch (xr->ExceptionInformation[0]) { case 0: Offset = 0; break; case 1: Offset = 1; break; case 8: Offset = 2; break; } strBuf2.Format(L"0x%p", xr->ExceptionInformation[1]+10); strBuf = MExcRAccess+Offset; strBuf << strBuf2; Exception=strBuf; } break; } } if (!Exception) { strBuf2.Format(L"%s (0x%X)", MSG(MExcUnknown), xr->ExceptionCode); Exception = strBuf2; } int MsgCode=0; if (FrameManager && !FrameManager->ManagerIsDown()) { MsgCode=ExcDialog(strFileName,Exception,xr->ExceptionAddress); ShowMessages=TRUE; } if (ShowMessages && (Is_STACK_OVERFLOW || From == EXCEPT_KERNEL)) { CriticalInternalError=TRUE; } if(MsgCode==1) { SetErrorMode(ErrorMode&~SEM_NOGPFAULTERRORBOX); rc=EXCEPTION_CONTINUE_SEARCH; UseExternalHandler=true; } else { rc = EXCEPTION_EXECUTE_HANDLER; } //return UnhandledExceptionFilter(xp); return rc; }
int CDb3Mmap::WorkEventChain(DWORD ofsContact, DBContact *dbc, int firstTime) { int isUnread = 0; if (firstTime) { dbePrevEvent = NULL; ofsPrevEvent = 0; ofsDestPrevEvent = 0; ofsThisEvent = dbc->ofsFirstEvent; eventCount = 0; backLookup = 0; lastTimestamp = 0; ofsFirstUnread = tsFirstUnread = 0; if (cb->bEraseHistory) { dbc->eventCount = 0; dbc->ofsFirstEvent = 0; dbc->ofsLastEvent = 0; dbc->ofsFirstUnread = 0; dbc->tsFirstUnread = 0; return ERROR_NO_MORE_ITEMS; } } if (ofsThisEvent == 0) { FinishUp(ofsDestPrevEvent, dbc); return ERROR_NO_MORE_ITEMS; } DBEvent dbeOld; if (!SignatureValid(ofsThisEvent, DBEVENT_SIGNATURE)) { DWORD ofsNew = 0; DWORD ofsTmp = dbc->ofsLastEvent; if (!backLookup && ofsTmp) { backLookup = 1; while (SignatureValid(ofsTmp, DBEVENT_SIGNATURE)) { if (PeekEvent(ofsTmp, dbc->dwContactID, dbeOld) != ERROR_SUCCESS) break; ofsNew = ofsTmp; ofsTmp = dbeOld.ofsPrev; } } if (ofsNew) { cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event chain corrupted, trying to recover...")); ofsThisEvent = ofsNew; } else { cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Event chain corrupted, further entries ignored")); FinishUp(ofsDestPrevEvent, dbc); return ERROR_NO_MORE_ITEMS; } } if (PeekEvent(ofsThisEvent, dbc->dwContactID, dbeOld) != ERROR_SUCCESS) { FinishUp(ofsDestPrevEvent, dbc); return ERROR_NO_MORE_ITEMS; } if (firstTime) { if (dbeOld.ofsPrev != 0) cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First event not marked as such: correcting")); dbeOld.ofsPrev = 0; lastTimestamp = dbeOld.timestamp; } if (dbeOld.flags & 1) dbeOld.flags &= ~1; if (dbeOld.flags & ~DBEF_ALL) { cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Extra flags found in event: removing")); dbeOld.flags &= DBEF_ALL; } if (!(dbeOld.flags & (DBEF_READ | DBEF_SENT))) { if (cb->bMarkRead) dbeOld.flags |= DBEF_READ; else if (ofsFirstUnread == 0) { if (dbc->ofsFirstUnread != ofsThisEvent || dbc->tsFirstUnread != dbeOld.timestamp) cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("First unread event marked wrong: fixing")); isUnread = 1; } } if (dbeOld.cbBlob > 1024 * 1024 || dbeOld.cbBlob == 0) { cb->pfnAddLogMessage(STATUS_ERROR, TranslateT("Infeasibly large event blob: skipping")); ofsThisEvent = dbeOld.ofsNext; return ERROR_SUCCESS; } DBEvent *dbePrev = NULL; if (dbePrevEvent && dbeOld.timestamp == lastTimestamp) { int len = offsetof(DBEvent, blob) + dbePrevEvent->cbBlob; dbePrev = (DBEvent*)malloc(len); memcpy(dbePrev, dbePrevEvent, len); } if (offsetof(DBEvent, blob) + dbeOld.cbBlob > memsize) { memsize = offsetof(DBEvent, blob) + dbeOld.cbBlob; memblock = (DBEvent*)realloc(memblock, memsize); } DBEvent *dbeNew = memblock; DWORD ret; if (m_dbHeader.version < DB_095_1_VERSION) { DBEvent_094 oldEvent; ret = ReadSegment(ofsThisEvent, &oldEvent, offsetof(DBEvent_094, blob)); if (ret == ERROR_SUCCESS) { dbeNew->signature = oldEvent.signature; dbeNew->contactID = dbc->dwContactID; memcpy(&dbeNew->ofsPrev, &oldEvent.ofsPrev, offsetof(DBEvent_094, blob) - sizeof(DWORD)); ret = ReadSegment(ofsThisEvent + offsetof(DBEvent_094, blob), &dbeNew->blob, dbeOld.cbBlob); } } else ret = ReadSegment(ofsThisEvent, dbeNew, offsetof(DBEvent, blob) + dbeOld.cbBlob); if (ret != ERROR_SUCCESS) { FinishUp(ofsDestPrevEvent, dbc); return ERROR_NO_MORE_ITEMS; } if ((dbeNew->ofsModuleName = ConvertModuleNameOfs(dbeOld.ofsModuleName)) == 0) { ofsThisEvent = dbeOld.ofsNext; return ERROR_SUCCESS; } if (!firstTime && dbeOld.ofsPrev != ofsPrevEvent) cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event not backlinked correctly: fixing")); dbeNew->flags = dbeOld.flags; dbeNew->ofsPrev = ofsDestPrevEvent; dbeNew->ofsNext = 0; if (dbeNew->contactID == 0) dbeNew->contactID = dbc->dwContactID; if (dbeOld.wEventType == EVENTTYPE_MESSAGE && cb->bConvertUtf && !(dbeOld.flags & DBEF_ENCRYPTED)) ConvertOldEvent(dbeNew); if (dbePrev) { if (dbePrev->cbBlob == dbeNew->cbBlob && dbePrev->ofsModuleName == dbeNew->ofsModuleName && dbePrev->wEventType == dbeNew->wEventType && (dbePrev->flags & DBEF_SENT) == (dbeNew->flags & DBEF_SENT) && !memcmp(dbePrev->blob, dbeNew->blob, dbeNew->cbBlob)) { cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Duplicate event was found: skipping")); if (dbc->eventCount) dbc->eventCount--; free(dbePrev); // ofsDestPrevEvent is still the same! ofsPrevEvent = ofsThisEvent; ofsThisEvent = dbeOld.ofsNext; return ERROR_SUCCESS; } free(dbePrev); } else if (!firstTime && dbeNew->timestamp < lastTimestamp) { DWORD found = 0; DBEvent dbeTmp = { 0 }; DWORD ofsTmp = 0; if (cb->bCheckOnly) { if (!cb->bAggressive) { ofsTmp = dbeOld.ofsPrev; while (PeekEvent(ofsTmp, dbc->dwContactID, dbeTmp) == ERROR_SUCCESS) { if (dbeTmp.ofsPrev == ofsContact) { found = 1; break; } if (dbeTmp.timestamp < dbeNew->timestamp) { found = 2; break; } ofsTmp = dbeTmp.ofsPrev; } } cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct")); } else { ofsTmp = ofsDestPrevEvent; while (ReadWrittenSegment(ofsTmp, &dbeTmp, sizeof(dbeTmp)) == ERROR_SUCCESS) { if (dbeTmp.ofsPrev == ofsContact) { found = 1; break; } if (dbeTmp.timestamp < dbeNew->timestamp) { found = 2; break; } ofsTmp = dbeTmp.ofsPrev; } if (found) cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: fixing")); else cb->pfnAddLogMessage(STATUS_WARNING, TranslateT("Event position in chain is not correct: unable to fix")); } // insert before FIRST if (found == 1 && !cb->bCheckOnly) { dbeNew->ofsPrev = 0; dbeNew->ofsNext = dbc->ofsFirstEvent; DWORD ofsDestThis = WriteEvent(dbeNew); if (!ofsDestThis) return ERROR_HANDLE_DISK_FULL; if (isUnread && tsFirstUnread >= dbeNew->timestamp) { ofsFirstUnread = ofsDestThis; tsFirstUnread = dbeNew->timestamp; } // fix first event WriteOfsNextToPrevious(0, dbc, ofsDestThis); // fix next event WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD)); } else if (found == 2 && !cb->bCheckOnly) { dbeNew->ofsPrev = ofsTmp; dbeNew->ofsNext = dbeTmp.ofsNext; DWORD ofsDestThis = WriteEvent(dbeNew); if (!ofsDestThis) return ERROR_HANDLE_DISK_FULL; if (isUnread && tsFirstUnread >= dbeNew->timestamp) { ofsFirstUnread = ofsDestThis; tsFirstUnread = dbeNew->timestamp; } // fix previous event WriteOfsNextToPrevious(dbeNew->ofsPrev, dbc, ofsDestThis); // fix next event WriteSegment(dbeNew->ofsNext + offsetof(DBEvent, ofsPrev), &ofsDestThis, sizeof(DWORD)); } if (found) { eventCount++; // ofsDestPrevEvent is still the same! ofsPrevEvent = ofsThisEvent; ofsThisEvent = dbeOld.ofsNext; return ERROR_SUCCESS; } } lastTimestamp = dbeNew->timestamp; dbePrevEvent = dbeNew; DWORD ofsDestThis = WriteEvent(dbeNew); if (!ofsDestThis) return ERROR_HANDLE_DISK_FULL; if (isUnread) { ofsFirstUnread = ofsDestThis; tsFirstUnread = dbeOld.timestamp; } eventCount++; WriteOfsNextToPrevious(ofsDestPrevEvent, dbc, ofsDestThis); ofsDestPrevEvent = ofsDestThis; ofsPrevEvent = ofsThisEvent; ofsThisEvent = dbeOld.ofsNext; return ERROR_SUCCESS; }
// PRIMARY FUNCTION TO WRITE A LINE TO THE LOGFILE bool LogAnalysis::AnalysisLog(const char* p_function,LogType p_type,bool p_doFormat,const char* p_format,...) { // Multi threaded protection AutoCritSec lock(&m_lock); CString logBuffer; bool result = false; // Make sure the system is initialized Initialisation(); // Make sure we ARE logging if(m_logLevel == HLL_NOLOG) { return result; } // Check on the loglevel if(m_logLevel == HLL_ERRORS && (p_type == LogType::LOG_INFO || p_type == LogType::LOG_TRACE)) { return result; } // Timing position in the buffer int position = 0; // Set the type char type = ' '; switch(p_type) { case LogType::LOG_TRACE:type = 'T'; break; case LogType::LOG_INFO: type = '-'; break; case LogType::LOG_ERROR:type = 'E'; break; case LogType::LOG_WARN: type = 'W'; break; } // Get/print the time if(m_doTiming) { __timeb64 now; struct tm today; position = 26; // Prefix string length _ftime64_s(&now); _localtime64_s(&today,&now.time); logBuffer.Format("%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d.%03d %c " ,today.tm_year + 1900 ,today.tm_mon + 1 ,today.tm_mday ,today.tm_hour ,today.tm_min ,today.tm_sec ,now.millitm ,type); } // Print the calling function logBuffer += p_function; if(logBuffer.GetLength() < position + ANALYSIS_FUNCTION_SIZE) { logBuffer.Append(" " ,position + ANALYSIS_FUNCTION_SIZE - logBuffer.GetLength()); } // Print the arguments if(p_doFormat) { va_list varargs; va_start(varargs,p_format); logBuffer.AppendFormatV(p_format,varargs); va_end(varargs); } else { logBuffer += p_format; } // Add end-of line logBuffer += "\r\n"; if(m_file) { // Locked m_list gets a buffer m_list.push_back(logBuffer); result = true; } else if(m_doEvents) { WriteEvent(m_eventLog,p_type,logBuffer); result = true; } // In case of an error, flush immediately! if(m_file && p_type == LogType::LOG_ERROR) { SetEvent(m_event); } return result; }