void TraceDumpToFile() { if (TraceFile != nullptr) { TGuard Guard(TracingCriticalSection); DWORD Written; TDateTime N = Now(); #ifdef TRACE_IN_MEMORY_NO_FORMATTING DWORD Ticks = GetTickCount(); #endif const UnicodeString TimestampFormat = L"hh:mm:ss.zzz"; UnicodeString TimeString = FormatDateTime(TimestampFormat, N); UTF8String Buffer = UTF8String( FORMAT("[%s] Dumping in-memory tracing =================================\n", (TimeString))); WriteFile(TraceFile, Buffer.c_str(), Buffer.Length(), &Written, nullptr); TTracesInMemory::const_iterator i = TracesInMemory.begin(); while (i != TracesInMemory.end()) { #ifdef TRACE_IN_MEMORY_NO_FORMATTING const wchar_t * SourceFile = i->SourceFile; const wchar_t * Slash = wcsrchr(SourceFile, L'\\'); if (Slash != nullptr) { SourceFile = Slash + 1; } TimeString = FormatDateTime(TimestampFormat, IncMilliSecond(N, -static_cast<int>(Ticks - i->Ticks))); Buffer = UTF8String(FORMAT(L"[%s] [%.4X] [%s:%d:%s] %s\n", (TimeString, int(i->Thread), SourceFile, i->Line, i->Func, i->Message))); WriteFile(TraceFile, Buffer.c_str(), Buffer.Length(), &Written, nullptr); #else WriteFile(TraceFile, i->Message.c_str(), i->Message.Length(), &Written, nullptr); #endif ++i; } TracesInMemory.clear(); TimeString = FormatDateTime(TimestampFormat, Now()); Buffer = UTF8String( FORMAT("[%s] Done in-memory tracing =================================\n", (TimeString))); WriteFile(TraceFile, Buffer.c_str(), Buffer.Length(), &Written, nullptr); } }
void TSessionLog::DoAddToSelf(TLogLineType Type, UnicodeString ALine) { if (LogToFile()) { try { if (FLogger == nullptr) { OpenLogFile(); } if (FLogger != nullptr) { UnicodeString Timestamp = FormatDateTime(L" yyyy-mm-dd hh:nn:ss.zzz ", Now()); UTF8String UtfLine = UTF8String(UnicodeString(LogLineMarks[Type]) + Timestamp + TrimRight(ALine)) + "\r\n"; #if 0 for (intptr_t Index = 1; Index <= UtfLine.Length(); Index++) { if ((UtfLine[Index] == '\n') && (UtfLine[Index - 1] != '\r')) { UtfLine.Insert(L'\r', Index); } } #endif // #if 0 intptr_t ToWrite = UtfLine.Length(); CheckSize(ToWrite); FCurrentFileSize += FLogger->Write(UtfLine.c_str(), ToWrite); }} catch (...) { // TODO: log error DEBUG_PRINTF("TSessionLog::DoAddToSelf: error"); } } }
//--------------------------------------------------------------------------- void TActionLog::Add(const UnicodeString & Line) { assert(FConfiguration); if (FLogging) { try { TGuard Guard(FCriticalSection); if (FFile == nullptr) { OpenLogFile(); } if (FFile != nullptr) { UTF8String UtfLine = UTF8String(Line); fwrite(UtfLine.c_str(), 1, UtfLine.Length(), (FILE *)FFile); fwrite("\n", 1, 1, (FILE *)FFile); } } catch (Exception &E) { // We failed logging, turn it off and notify user. FConfiguration->SetLogActions(false); try { throw ExtException(&E, LoadStr(LOG_GEN_ERROR)); } catch (Exception &E) { FUI->HandleExtendedException(&E); } } } }
BitmapPtr BitmapLoader::load(const UTF8String& sFName, PixelFormat pf) const { AVG_ASSERT(s_pBitmapLoader != 0); GError* pError = 0; GdkPixbuf* pPixBuf; { ScopeTimer timer(GDKPixbufProfilingZone); pPixBuf = gdk_pixbuf_new_from_file(sFName.c_str(), &pError); } if (!pPixBuf) { string sErr = pError->message; g_error_free(pError); throw Exception(AVG_ERR_FILEIO, sErr); } IntPoint size = IntPoint(gdk_pixbuf_get_width(pPixBuf), gdk_pixbuf_get_height(pPixBuf)); PixelFormat srcPF; if (gdk_pixbuf_get_has_alpha(pPixBuf)) { srcPF = R8G8B8A8; } else { srcPF = R8G8B8; } if (pf == NO_PIXELFORMAT) { if (m_bBlueFirst) { if (srcPF == R8G8B8A8) { pf = B8G8R8A8; } else if (srcPF == R8G8B8) { pf = B8G8R8X8; } } else { if (srcPF == R8G8B8A8) { pf = R8G8B8A8; } else if (srcPF == R8G8B8) { pf = R8G8B8X8; } } } BitmapPtr pBmp(new Bitmap(size, pf, sFName)); { ScopeTimer timer(ConvertProfilingZone); int stride = gdk_pixbuf_get_rowstride(pPixBuf); guchar* pSrc = gdk_pixbuf_get_pixels(pPixBuf); BitmapPtr pSrcBmp(new Bitmap(size, srcPF, pSrc, stride, false)); { ScopeTimer timer(RGBFlipProfilingZone); if (pixelFormatIsBlueFirst(pf) != pixelFormatIsBlueFirst(srcPF)) { FilterFlipRGB().applyInPlace(pSrcBmp); } } pBmp->copyPixels(*pSrcBmp); } g_object_unref(pPixBuf); return pBmp; }
Pixel32 colorStringToColor(const UTF8String& s) { int r, g, b; int numChars; int numItems = sscanf(s.c_str(), "%2x%2x%2x%n", &r, &g, &b, &numChars); if (s.length() != 6 || numChars != 6 || numItems != 3) { throw(Exception (AVG_ERR_INVALID_ARGS, "colorstring cannot be parsed.")); } return Pixel32(r, g, b); }
//--------------------------------------------------------------------------- TKeyType KeyType(UnicodeString FileName) { assert(ktUnopenable == SSH_KEYTYPE_UNOPENABLE); assert(ktSSHCom == SSH_KEYTYPE_SSHCOM); UTF8String UtfFileName = UTF8String(FileName); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); TKeyType Result = (TKeyType)key_type(KeyFile); filename_free(KeyFile); return Result; }
TKeyType KeyType(const UnicodeString & AFileName) { assert(ktUnopenable == SSH_KEYTYPE_UNOPENABLE); assert(ktSSHCom == SSH_KEYTYPE_SSHCOM); UTF8String UtfFileName = UTF8String(AFileName); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); TKeyType Result = static_cast<TKeyType>(key_type(KeyFile)); filename_free(KeyFile); return Result; }
TKeyType GetKeyType(const UnicodeString & AFileName) { DebugAssert(ktUnopenable == SSH_KEYTYPE_UNOPENABLE); #ifndef __linux__ DebugAssert(ktSSH2PublicOpenSSH == SSH_KEYTYPE_SSH2_PUBLIC_OPENSSH); #endif UTF8String UtfFileName = UTF8String(::ExpandEnvironmentVariables(AFileName)); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); TKeyType Result = static_cast<TKeyType>(key_type(KeyFile)); filename_free(KeyFile); return Result; }
TPrivateKey * LoadKey(TKeyType KeyType, const UnicodeString & FileName, const UnicodeString & Passphrase) { UTF8String UtfFileName = UTF8String(::ExpandEnvironmentVariables(FileName)); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); AnsiString AnsiPassphrase = AnsiString(Passphrase); struct ssh2_userkey * Ssh2Key = nullptr; const char * ErrorStr = nullptr; switch (KeyType) { case ktSSH2: Ssh2Key = ssh2_load_userkey(KeyFile, (char *)AnsiPassphrase.c_str(), &ErrorStr); break; case ktOpenSSHPEM: case ktOpenSSHNew: case ktSSHCom: Ssh2Key = import_ssh2(KeyFile, KeyType, (char *)AnsiPassphrase.c_str(), &ErrorStr); break; default: DebugFail(); break; } Shred(AnsiPassphrase); if (Ssh2Key == nullptr) { UnicodeString Error = UnicodeString(ErrorStr); // While theoretically we may get "unable to open key file" and // so we should check system error code, // we actully never get here unless we call KeyType previously // and handle ktUnopenable accordingly. throw Exception(Error); } else if (Ssh2Key == SSH2_WRONG_PASSPHRASE) { throw Exception(LoadStr(AUTH_TRANSL_WRONG_PASSPHRASE)); } return reinterpret_cast<TPrivateKey *>(Ssh2Key); }
void PythonLogSink::logMessage(const tm* pTime, unsigned millis, const string& category, unsigned severity, const UTF8String& sMsg) { string sSeverity = boost::to_lower_copy(string(Logger::severityToString(severity))); PyObject * extra = PyDict_New(); PyObject * pyCat = PyString_FromString(category.c_str()); PyDict_SetItemString(extra, "category", pyCat); PyObject * pyMsg = PyString_FromString(sMsg.c_str()); PyObject * args = PyTuple_New(1); PyObject * kwargs = PyDict_New(); PyDict_SetItemString(kwargs, "extra", extra); PyTuple_SetItem(args, 0, pyMsg); PyObject_Call(PyObject_GetAttrString(m_pyLogger, sSeverity.c_str()), args, kwargs); Py_DECREF(extra); Py_DECREF(pyCat); Py_DECREF(args); Py_DECREF(kwargs); }
void DoTrace(const wchar_t * SourceFile, const wchar_t * Func, uintptr_t Line, const wchar_t * Message) { DebugAssert(IsTracing); UnicodeString TimeString; // DateTimeToString(TimeString, L"hh:mm:ss.zzz", Now()); TODO("use Format"); const wchar_t * Slash = wcsrchr(SourceFile, L'\\'); if (Slash != nullptr) { SourceFile = Slash + 1; } UTF8String Buffer = UTF8String(FORMAT(L"[%s] [%.4X] [%s:%d:%s] %s\n", TimeString.c_str(), int(::GetCurrentThreadId()), SourceFile, Line, Func, Message)); #ifdef TRACE_IN_MEMORY if (TracingCriticalSection != nullptr) { TTraceInMemory TraceInMemory; TraceInMemory.Message = Buffer; TGuard Guard(TracingCriticalSection); if (TracesInMemory.capacity() == 0) { TracesInMemory.reserve(100000); TThreadID ThreadID; StartThread(nullptr, 0, TraceThreadProc, nullptr, 0, ThreadID); } TracesInMemory.push_back(TraceInMemory); } #else DWORD Written; WriteFile(TraceFile, Buffer.c_str(), static_cast<DWORD>(Buffer.Length()), &Written, nullptr); #endif TRACE_IN_MEMORY }
void SaveKey(TKeyType KeyType, const UnicodeString & FileName, const UnicodeString & Passphrase, TPrivateKey * PrivateKey) { UTF8String UtfFileName = UTF8String(::ExpandEnvironmentVariables(FileName)); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); struct ssh2_userkey * Ssh2Key = reinterpret_cast<struct ssh2_userkey *>(PrivateKey); AnsiString AnsiPassphrase = AnsiString(Passphrase); const char * PassphrasePtr = (AnsiPassphrase.IsEmpty() ? nullptr : AnsiPassphrase.c_str()); switch (KeyType) { case ktSSH2: if (!ssh2_save_userkey(KeyFile, Ssh2Key, (char *)PassphrasePtr)) { int Error = errno; throw EOSExtException(FMTLOAD(KEY_SAVE_ERROR, FileName.c_str()), Error); } break; default: DebugFail(); break; } }
//--------------------------------------------------------------------------- void TSessionLog::DoAddToSelf(TLogLineType AType, const UnicodeString & ALine) { if (FTopIndex < 0) { FTopIndex = 0; } TStringList::AddObject(ALine, static_cast<TObject *>(reinterpret_cast<void *>(static_cast<size_t>(AType)))); FLoggedLines++; if (LogToFile()) { if (FFile == nullptr) { OpenLogFile(); } if (FFile != nullptr) { #if defined(__BORLANDC__) UnicodeString Timestamp = FormatDateTime(L" yyyy-mm-dd hh:nn:ss.zzz ", Now()); UTF8String UtfLine = UTF8String(UnicodeString(LogLineMarks[Type]) + Timestamp + Line + "\n"); fwrite(UtfLine.c_str(), UtfLine.Length(), 1, (FILE *)FFile); #else unsigned short Y, M, D, H, N, S, MS; TDateTime DateTime = Now(); DateTime.DecodeDate(Y, M, D); DateTime.DecodeTime(H, N, S, MS); UnicodeString dt = FORMAT(L" %04d-%02d-%02d %02d:%02d:%02d.%03d ", Y, M, D, H, N, S, MS); UnicodeString Timestamp = dt; UTF8String UtfLine = UTF8String(UnicodeString(LogLineMarks[AType]) + Timestamp + ALine + "\n"); fprintf_s(static_cast<FILE *>(FFile), "%s", const_cast<char *>(AnsiString(UtfLine).c_str())); #endif } } }
bool IsKeyEncrypted(TKeyType KeyType, const UnicodeString & FileName, UnicodeString & Comment) { UTF8String UtfFileName = UTF8String(::ExpandEnvironmentVariables(FileName)); Filename * KeyFile = filename_from_str(UtfFileName.c_str()); bool Result; char * CommentStr = nullptr; switch (KeyType) { case ktSSH2: Result = (ssh2_userkey_encrypted(KeyFile, &CommentStr) != 0); break; case ktOpenSSHPEM: case ktOpenSSHNew: case ktSSHCom: Result = (import_encrypted(KeyFile, KeyType, &CommentStr) != 0); break; default: DebugFail(); Result = false; break; } if (CommentStr != nullptr) { Comment = UnicodeString(AnsiString(CommentStr)); // ktOpenSSH has no comment, PuTTY defaults to file path if (Comment == FileName) { Comment = base::ExtractFileName(FileName, false); } sfree(CommentStr); } return Result; }
void VTune_RegisterMethod(AvmCore* core, JITCodeInfo* inf) { // assume no method inlining so start/end of JIT code gen = method start/end uintptr startAt = inf->startAddr; uintptr endAt = inf->endAddr; uint32 methodSize = endAt - startAt; Stringp name = inf->method->format(core); int idx[4]; bool hasClass = locateNames(core, name, idx); // register the method iJIT_Method_Load ML; Stringp mname = name->substring(idx[2],idx[3]); VMPI_memset(&ML, 0, sizeof(iJIT_Method_Load)); ML.method_id = (inf->vtune) ? inf->vtune->method_id : iJIT_GetNewMethodID(); ML.method_name = string2char(core, mname); ML.method_load_address = (void *)startAt; // virtual address of that method - This determines the method range for the iJVM_EVENT_TYPE_ENTER/LEAVE_METHOD_ADDR events ML.method_size = methodSize; // Size in memory - Must be exact // md position / line number table SortedIntMap<LineNumberRecord*>* tbl = &inf->lineNumTable; int size = tbl->size(); LineNumberInfo* lines = 0; if (size) { int bsz = size*sizeof(LineNumberInfo); lines = (LineNumberInfo*) malloc(bsz); VMPI_memset(lines, 0, bsz); } String* fileName = 0; int at = 0; for(int i=0; i<size; i++) { sintptr mdPos = tbl->keyAt(i); LineNumberRecord* entry = tbl->at(i); if (entry->filename && entry->lineno) { if (!fileName) fileName = entry->filename; // @todo file name should be part of the lines[] record, no? lines[at].LineNumber = entry->lineno; lines[at].Offset = mdPos - startAt; at++; } } // @todo hack for vtune since it can't process multiple records with the same method name if (inf->sid>0 && at>0) { mname = core->concatStrings(mname,core->newString("_L")); mname = core->concatStrings(mname,core->intToString(lines[0].LineNumber)); mname = core->concatStrings(mname,core->newString("_")); mname = core->concatStrings(mname,core->intToString(inf->sid)); if (ML.method_name) free(ML.method_name); ML.method_name = string2char(core,mname); } ML.line_number_table = lines; // Pointer to the begining of the line numbers info array ML.line_number_size = at; // Line Table size in number of entries - Zero if none UTF8String* utf = ( fileName ) ? fileName->toUTF8String() : core->kEmptyString->toUTF8String(); ML.class_id = 0; // uniq class ID ML.class_file_name = (hasClass) ? string2char(core,name->substring(idx[0],idx[1])) : 0; // class file name ML.source_file_name = (char *)(malloc((utf->length()+3)*sizeof(char))); // +1 for \0 and +2 for wtoc's () wtoc(ML.source_file_name, utf->c_str(), 0); // source file name ML.user_data = NULL; // bits supplied by the user for saving in the JIT file... ML.user_data_size = 0; // the size of the user data buffer ML.env = iJDE_JittingAPI; // DumpVTuneMethodInfo(core, &ML); // Uncommented to debug VTune iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, &ML); if (inf->vtune && core->VTuneStatus == iJIT_CALLGRAPH_ON) { MMgc::GCHeap* heap = core->GetGC()->GetGCHeap(); heap->SetPageProtection(inf->vtune, sizeof (iJIT_Method_NIDS), false, true); } // free everything we alloc'd ( @todo did vtune really copy all the strings?!? ) if (ML.line_number_table) free(ML.line_number_table); if (ML.class_file_name && hasClass) free(ML.class_file_name); if (ML.method_name) free(ML.method_name); if (ML.source_file_name) free(ML.source_file_name); }
const AnsiString & __fastcall AnsiString::operator +=(const UTF8String & rhs) { Data.append(reinterpret_cast<const char *>(rhs.c_str()), rhs.size()); return *this; }
void TActionLog::Add(UnicodeString Line) { DebugAssert(FConfiguration); if (FLogging) { TGuard Guard(FCriticalSection); if (FLogger == nullptr) { OpenLogFile(); } if (FLogger != nullptr) { try { UTF8String UtfLine = UTF8String(Line); size_t Written = FLogger->Write(UtfLine.c_str(), UtfLine.Length()); if (Written != static_cast<size_t>(UtfLine.Length())) { throw ECRTExtException(L""); } Written = FLogger->Write("\n", 1); if (Written != 1) { throw ECRTExtException(L""); } } catch (Exception &E) { // FCriticalSection.Release(); // avoid endless loop when trying to close tags when closing log, when logging has failed if (!FFailed) { FFailed = true; // We failed logging, turn it off and notify user. FConfiguration->SetLogActions(false); if (FConfiguration->GetLogActionsRequired()) { throw EFatal(&E, LoadStr(LOG_FATAL_ERROR)); } else { try { throw ExtException(&E, LoadStr(LOG_GEN_ERROR)); } catch (Exception &E2) { if (FUI != nullptr) { FUI->HandleExtendedException(&E2); } } } } } } } }