int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
WNDCLASS wc = {};
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = wndProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = L"GameOfLifeWindowClass";
if (!RegisterClass(&wc)) {
MessageBox(NULL, L"RegisterClass failed!", NULL, NULL);
return 1;
}
int windowWidth = globalWindowWidth = DEFAULT_WINDOW_WIDTH;
int windowHeight = globalWindowHeight = DEFAULT_WINDOW_HEIGHT;
RECT clientRect = { 0, 0, windowWidth, windowHeight };
DWORD windowStyle = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
AdjustWindowRect(&clientRect, windowStyle, NULL);
HWND hWnd = CreateWindowEx(NULL, wc.lpszClassName, L"Game of Life", windowStyle, 300, 0,
clientRect.right - clientRect.left, clientRect.bottom - clientRect.top, NULL, NULL, hInstance, NULL);
if (!hWnd) {
MessageBox(NULL, L"CreateWindowEx failed!", NULL, NULL);
return 1;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
LARGE_INTEGER perfCounterFrequency = { 0 };
QueryPerformanceFrequency(&perfCounterFrequency);
LARGE_INTEGER perfCounter = { 0 };
QueryPerformanceCounter(&perfCounter);
LARGE_INTEGER prevPerfCounter = { 0 };
float dt = 0.0f;
float realDt = dt;
const float targetFps = 60.0f;
const float targetDt = 1.0f / targetFps;
srand((unsigned int)time(NULL));
GameState *gameState = (GameState *)malloc(sizeof(GameState));
memset(gameState, 0, sizeof(GameState));
initGame(gameState, windowWidth, windowHeight);
bool gameIsRunning = true;
while (gameIsRunning) {
prevPerfCounter = perfCounter;
QueryPerformanceCounter(&perfCounter);
dt = (float)(perfCounter.QuadPart - prevPerfCounter.QuadPart) / (float)perfCounterFrequency.QuadPart;
realDt = dt;
if (dt > targetDt)
dt = targetDt;
MSG msg;
while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
switch (msg.message) {
case WM_QUIT:
gameIsRunning = false;
break;
case WM_KEYDOWN:
case WM_KEYUP:
switch (msg.wParam) {
case VK_ESCAPE:
gameIsRunning = false;
break;
}
break;
default:
TranslateMessage(&msg);
DispatchMessage(&msg);
break;
}
}
//
// UPDATE
//
// When the window is resized, reinitialize the game with the new window size.
if (globalWindowWidth != windowWidth || globalWindowHeight != windowHeight) {
windowWidth = globalWindowWidth;
windowHeight = globalWindowHeight;
initGame(gameState, globalWindowWidth, globalWindowHeight);
}
// Handle the left mouse button: make the clicked cell alive.
if (GetKeyState(VK_LBUTTON) & (1 << 15)) {
POINT mousePos;
GetCursorPos(&mousePos);
ScreenToClient(hWnd, &mousePos);
int row = mousePos.y / CELL_HEIGHT_PX;
int col = mousePos.x / CELL_WIDTH_PX;
if (row < gameState->cellRows && col < gameState->cellCols) {
bool *cell = gameState->cells + row*gameState->cellCols + col;
*cell = true;
}
}
gameState->tickTimer += dt;
if (gameState->tickTimer > TICK_DURATION) {
gameState->tickTimer = 0;
for (int row = 0; row < gameState->cellRows; ++row) {
for (int col = 0; col < gameState->cellCols; ++col) {
bool *cell = gameState->cells + row*gameState->cellCols + col;
bool *newCell = gameState->newCells + row*gameState->cellCols + col;
*newCell = *cell;
int liveNeighbours = getLiveNeighbourCount(gameState, row, col);
if (*cell) {
if (liveNeighbours < 2 || liveNeighbours > 3)
*newCell = false;
}
else {
if (liveNeighbours == 3)
*newCell = true;
}
}
}
bool *tmp = gameState->cells;
gameState->cells = gameState->newCells;
gameState->newCells = tmp;
}
//
// RENDER
//
for (int row = 0; row < gameState->cellRows; ++row) {
for (int col = 0; col < gameState->cellCols; ++col) {
bool *cell = gameState->cells + row*gameState->cellCols + col;
int color = *cell ? CELL_COLOR_ALIVE : CELL_COLOR_DEAD;
for (int r = 0; r < CELL_HEIGHT_PX; ++r) {
for (int c = 0; c < CELL_WIDTH_PX; ++c) {
int *pixel = gameState->bitmapBuffer + (row*CELL_HEIGHT_PX + r)*gameState->cellCols*CELL_WIDTH_PX + col*CELL_WIDTH_PX + c;
*pixel = color;
}
}
}
}
HDC hDC = GetDC(hWnd);
StretchDIBits(hDC, 0, 0, gameState->bitmapWidth, gameState->bitmapHeight,
0, 0, gameState->bitmapWidth, gameState->bitmapHeight,
gameState->bitmapBuffer, gameState->bitmapInfo, DIB_RGB_COLORS, SRCCOPY);
ReleaseDC(hWnd, hDC);
#if 0
char textBuffer[256];
sprintf(textBuffer, "dt: %f, fps: %f\n", realDt, 1.0f/realDt);
OutputDebugStringA(textBuffer);
#endif
}
return 0;
}
static void exiting(void)
{
OutputDebugStringA("winfsp-tests: exiting\n");
RemoveNetShareIfNeeded();
}
inline int OutputDebugStringF(const char* pszFormat, ...)
{
int ret = 0;
if (fPrintToConsole)
{
// print to console
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret = vprintf(pszFormat, arg_ptr);
va_end(arg_ptr);
}
else
{
// print to debug.log
static FILE* fileout = NULL;
if (!fileout)
{
char pszFile[MAX_PATH+100];
GetDataDir(pszFile);
strlcat(pszFile, "/debug.log", sizeof(pszFile));
fileout = fopen(pszFile, "a");
if (fileout) setbuf(fileout, NULL); // unbuffered
}
if (fileout)
{
static bool fStartedNewLine = true;
// Debug print useful for profiling
if (fLogTimestamps && fStartedNewLine)
fprintf(fileout, "%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
if (pszFormat[strlen(pszFormat) - 1] == '\n')
fStartedNewLine = true;
else
fStartedNewLine = false;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
ret = vfprintf(fileout, pszFormat, arg_ptr);
va_end(arg_ptr);
}
}
#ifdef __WXMSW__
if (fPrintToDebugger)
{
static CCriticalSection cs_OutputDebugStringF;
// accumulate a line at a time
CRITICAL_BLOCK(cs_OutputDebugStringF)
{
static char pszBuffer[50000];
static char* pend;
if (pend == NULL)
pend = pszBuffer;
va_list arg_ptr;
va_start(arg_ptr, pszFormat);
int limit = END(pszBuffer) - pend - 2;
int ret = _vsnprintf(pend, limit, pszFormat, arg_ptr);
va_end(arg_ptr);
if (ret < 0 || ret >= limit)
{
pend = END(pszBuffer) - 2;
*pend++ = '\n';
}
else
pend += ret;
*pend = '\0';
char* p1 = pszBuffer;
char* p2;
while (p2 = strchr(p1, '\n'))
{
p2++;
char c = *p2;
*p2 = '\0';
OutputDebugStringA(p1);
*p2 = c;
p1 = p2;
}
if (p1 != pszBuffer)
memmove(pszBuffer, p1, pend - p1 + 1);
pend -= (p1 - pszBuffer);
}
}
#endif
return ret;
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if USE(CF) && !OS(WINDOWS)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
#if COMPILER(CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat-nonliteral"
#endif
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
#if COMPILER(CLANG)
#pragma clang diagnostic pop
#endif
CFIndex length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
#if USE(APPLE_SYSTEM_LOG)
asl_log(0, 0, ASL_LEVEL_NOTICE, "%s", buffer);
#endif
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
return;
}
#if USE(APPLE_SYSTEM_LOG)
va_list copyOfArgs;
va_copy(copyOfArgs, args);
asl_vlog(0, 0, ASL_LEVEL_NOTICE, format, copyOfArgs);
va_end(copyOfArgs);
#endif
// Fall through to write to stderr in the same manner as other platforms.
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (vsnprintf(buffer, size, format, args) != -1) {
OutputDebugStringA(buffer);
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
vfprintf(stderr, format, args);
}
bool EventCallback::OnException( IProcess* process, DWORD threadId, bool firstChance, const EXCEPTION_RECORD* exceptRec )
{
const DWORD DefaultState = EXCEPTION_STOP_SECOND_CHANCE;
OutputDebugStringA( "EventCallback::OnException\n" );
HRESULT hr = S_OK;
RefPtr<ExceptionEvent> event;
RefPtr<Program> prog;
RefPtr<Thread> thread;
if ( !mEngine->FindProgram( process->GetId(), prog ) )
return false;
if ( !prog->FindThread( threadId, thread ) )
return false;
prog->NotifyException( firstChance, exceptRec );
hr = MakeCComObject( event );
if ( FAILED( hr ) )
return false;
event->Init( prog.Get(), firstChance, exceptRec, prog->CanPassExceptionToDebuggee() );
DWORD state = DefaultState;
ExceptionInfo info;
bool found = false;
if ( event->GetSearchKey() == ExceptionEvent::Name )
{
found = mEngine->FindExceptionInfo( event->GetGUID(), event->GetExceptionName(), info );
}
else // search by code
{
found = mEngine->FindExceptionInfo( event->GetGUID(), event->GetCode(), info );
}
// if not found, then check against the catch-all entry
if ( !found )
found = mEngine->FindExceptionInfo( event->GetGUID(), event->GetRootExceptionName(), info );
if ( found )
{
if ( event->GetSearchKey() == ExceptionEvent::Code )
event->SetExceptionName( info.bstrExceptionName );
state = info.dwState;
}
if ( ( firstChance && ( state & EXCEPTION_STOP_FIRST_CHANCE ) ) ||
( !firstChance && ( state & EXCEPTION_STOP_SECOND_CHANCE ) ) )
{
hr = SendEvent( event.Get(), prog.Get(), thread.Get() );
return false;
}
else
{
RefPtr<MessageTextEvent> msgEvent;
CComBSTR desc;
hr = MakeCComObject( msgEvent );
if ( FAILED( hr ) )
return true;
hr = event->GetExceptionDescription( &desc );
if ( FAILED( hr ) )
return true;
desc.Append( L"\n" );
msgEvent->Init( MT_REASON_EXCEPTION, desc );
hr = SendEvent( msgEvent.Get(), prog.Get(), thread.Get() );
return true; // wants to continue
}
}
/*******************************************************************
Dutil_Trace
*******************************************************************/
extern "C" void DAPI Dutil_Trace(
__in_z LPCSTR szFile,
__in int iLine,
__in REPORT_LEVEL rl,
__in_z __format_string LPCSTR szFormat,
...
)
{
AssertSz(REPORT_NONE != rl, "REPORT_NONE is not a valid tracing level");
HRESULT hr = S_OK;
char szOutput[DUTIL_STRING_BUFFER] = { };
char szMsg[DUTIL_STRING_BUFFER] = { };
if (Dutil_rlCurrentTrace < rl)
{
return;
}
va_list args;
va_start(args, szFormat);
hr = ::StringCchVPrintfA(szOutput, countof(szOutput), szFormat, args);
va_end(args);
if (SUCCEEDED(hr))
{
LPCSTR szPrefix = "Trace/u";
switch (rl)
{
case REPORT_STANDARD:
szPrefix = "Trace/s";
break;
case REPORT_VERBOSE:
szPrefix = "Trace/v";
break;
case REPORT_DEBUG:
szPrefix = "Trace/d";
break;
}
if (Dutil_fTraceFilenames)
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "%s [%s,%d]: %s\r\n", szPrefix, szFile, iLine, szOutput);
}
else
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "%s: %s\r\n", szPrefix, szOutput);
}
if (SUCCEEDED(hr))
{
OutputDebugStringA(szMsg);
}
// else fall through to the case below
}
if (FAILED(hr))
{
if (Dutil_fTraceFilenames)
{
::StringCchPrintfA(szMsg, countof(szMsg), "Trace [%s,%d]: message too long, skipping\r\n", szFile, iLine);
}
else
{
::StringCchPrintfA(szMsg, countof(szMsg), "Trace: message too long, skipping\r\n");
}
szMsg[countof(szMsg)-1] = '\0';
OutputDebugStringA(szMsg);
}
}
/*******************************************************************
Dutil_AssertMsg
*******************************************************************/
extern "C" void DAPI Dutil_AssertMsg(
__in_z LPCSTR szMessage
)
{
static BOOL fInAssert = FALSE; // TODO: make this thread safe (this is a cheap hack to prevent re-entrant Asserts)
HRESULT hr = S_OK;
DWORD er = ERROR_SUCCESS;
int id = IDRETRY;
HKEY hkDebug = NULL;
HANDLE hAssertFile = INVALID_HANDLE_VALUE;
char szPath[MAX_PATH] = { };
DWORD cch = 0;
if (fInAssert)
{
return;
}
fInAssert = TRUE;
char szMsg[DUTIL_STRING_BUFFER];
hr = ::StringCchCopyA(szMsg, countof(szMsg), szMessage);
ExitOnFailure(hr, "failed to copy message while building assert message");
if (Dutil_pfnDisplayAssert)
{
// call custom function to display the assert string
if (!Dutil_pfnDisplayAssert(szMsg))
{
ExitFunction();
}
}
else
{
OutputDebugStringA(szMsg);
}
if (!Dutil_fNoAsserts)
{
er = ::RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Delivery\\Debug", 0, KEY_QUERY_VALUE, &hkDebug);
if (ERROR_SUCCESS == er)
{
cch = countof(szPath);
er = ::RegQueryValueExA(hkDebug, "DeliveryAssertsLog", NULL, NULL, reinterpret_cast<BYTE*>(szPath), &cch);
szPath[countof(szPath) - 1] = '\0'; // ensure string is null terminated since registry won't guarantee that.
if (ERROR_SUCCESS == er)
{
hAssertFile = ::CreateFileA(szPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE != hAssertFile)
{
::SetFilePointer(hAssertFile, 0, 0, FILE_END);
::StringCchCatA(szMsg, countof(szMsg), "\r\n");
::WriteFile(hAssertFile, szMsg, lstrlenA(szMsg), &cch, NULL);
}
}
}
// if anything went wrong while fooling around with the registry, just show the usual assert dialog box
if (ERROR_SUCCESS != er)
{
hr = ::StringCchCatA(szMsg, countof(szMsg), "\nAbort=Debug, Retry=Skip, Ignore=Skip all");
ExitOnFailure(hr, "failed to concat string while building assert message");
id = ::MessageBoxA(0, szMsg, "Debug Assert Message",
MB_SERVICE_NOTIFICATION | MB_TOPMOST |
MB_DEFBUTTON2 | MB_ABORTRETRYIGNORE);
}
}
if (id == IDABORT)
{
if (Dutil_hAssertModule)
{
::GetModuleFileNameA(Dutil_hAssertModule, szPath, countof(szPath));
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "Module is running from: %s\nIf you are not using pdb-stamping, place your PDB near the module and attach to process id: %d (0x%x)", szPath, ::GetCurrentProcessId(), ::GetCurrentProcessId());
if (SUCCEEDED(hr))
{
::MessageBoxA(0, szMsg, "Debug Assert Message", MB_SERVICE_NOTIFICATION | MB_TOPMOST | MB_OK);
}
}
::DebugBreak();
}
else if (id == IDIGNORE)
{
Dutil_fNoAsserts = TRUE;
}
LExit:
ReleaseFileHandle(hAssertFile);
ReleaseRegKey(hkDebug);
fInAssert = FALSE;
}
virtual void RunFrame () {
char log[1024];
sprintf(log,"RunFrame() " );
OutputDebugStringA(log);
);
STDMETHODIMP_(BOOL) CDb3Mmap::WriteContactSetting(MCONTACT contactID, DBCONTACTWRITESETTING *dbcws)
{
if (dbcws == NULL || dbcws->szSetting == NULL || dbcws->szModule == NULL || m_bReadOnly)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(dbcws->szSetting);
int moduleNameLen = (int)mir_strlen(dbcws->szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("WriteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
// used for notifications
DBCONTACTWRITESETTING dbcwNotif = *dbcws;
if (dbcwNotif.value.type == DBVT_WCHAR) {
if (dbcwNotif.value.pszVal != NULL) {
char* val = mir_utf8encodeW(dbcwNotif.value.pwszVal);
if (val == NULL)
return 1;
dbcwNotif.value.pszVal = (char*)alloca(mir_strlen(val) + 1);
mir_strcpy(dbcwNotif.value.pszVal, val);
mir_free(val);
dbcwNotif.value.type = DBVT_UTF8;
}
else return 1;
}
if (dbcwNotif.szModule == NULL || dbcwNotif.szSetting == NULL)
return 1;
DBCONTACTWRITESETTING dbcwWork = dbcwNotif;
mir_ptr<BYTE> pEncoded(NULL);
bool bIsEncrypted = false;
switch (dbcwWork.value.type) {
case DBVT_BYTE: case DBVT_WORD: case DBVT_DWORD:
break;
case DBVT_ASCIIZ: case DBVT_UTF8:
bIsEncrypted = m_bEncrypted || IsSettingEncrypted(dbcws->szModule, dbcws->szSetting);
LBL_WriteString:
if (dbcwWork.value.pszVal == NULL)
return 1;
dbcwWork.value.cchVal = (WORD)mir_strlen(dbcwWork.value.pszVal);
if (bIsEncrypted) {
size_t len;
BYTE *pResult = m_crypto->encodeString(dbcwWork.value.pszVal, &len);
if (pResult != NULL) {
pEncoded = dbcwWork.value.pbVal = pResult;
dbcwWork.value.cpbVal = (WORD)len;
dbcwWork.value.type = DBVT_ENCRYPTED;
}
}
break;
case DBVT_UNENCRYPTED:
dbcwNotif.value.type = dbcwWork.value.type = DBVT_UTF8;
goto LBL_WriteString;
case DBVT_BLOB: case DBVT_ENCRYPTED:
if (dbcwWork.value.pbVal == NULL)
return 1;
break;
default:
return 1;
}
mir_cslockfull lck(m_csDbAccess);
DWORD ofsBlobPtr, ofsContact = GetContactOffset(contactID);
if (ofsContact == 0) {
_ASSERT(false); // contact doesn't exist?
return 2;
}
char *szCachedSettingName = m_cache->GetCachedSetting(dbcwWork.szModule, dbcwWork.szSetting, moduleNameLen, settingNameLen);
log3("set [%08p] %s (%p)", hContact, szCachedSettingName, szCachedSettingName);
// we don't cache blobs and passwords
if (dbcwWork.value.type != DBVT_BLOB && dbcwWork.value.type != DBVT_ENCRYPTED && !bIsEncrypted) {
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
bool bIsIdentical = false;
if (pCachedValue->type == dbcwWork.value.type) {
switch (dbcwWork.value.type) {
case DBVT_BYTE: bIsIdentical = pCachedValue->bVal == dbcwWork.value.bVal; break;
case DBVT_WORD: bIsIdentical = pCachedValue->wVal == dbcwWork.value.wVal; break;
case DBVT_DWORD: bIsIdentical = pCachedValue->dVal == dbcwWork.value.dVal; break;
case DBVT_UTF8:
case DBVT_ASCIIZ: bIsIdentical = mir_strcmp(pCachedValue->pszVal, dbcwWork.value.pszVal) == 0; break;
}
if (bIsIdentical)
return 0;
}
m_cache->SetCachedVariant(&dbcwWork.value, pCachedValue);
}
if (szCachedSettingName[-1] != 0) {
lck.unlock();
log2(" set resident as %s (%p)", printVariant(&dbcwWork.value), pCachedValue);
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwWork);
return 0;
}
}
else m_cache->GetCachedValuePtr(contactID, szCachedSettingName, -1);
log1(" write database as %s", printVariant(&dbcwWork.value));
DWORD ofsModuleName = GetModuleNameOfs(dbcwWork.szModule);
DBContact dbc = *(DBContact*)DBRead(ofsContact, NULL);
if (dbc.signature != DBCONTACT_SIGNATURE)
return 1;
// make sure the module group exists
PBYTE pBlob;
int bytesRequired, bytesRemaining;
DBContactSettings dbcs;
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(&dbc, ofsModuleName);
if (ofsSettingsGroup == 0) { //module group didn't exist - make it
switch (dbcwWork.value.type) {
case DBVT_ASCIIZ: case DBVT_UTF8:
bytesRequired = dbcwWork.value.cchVal + 2;
break;
case DBVT_BLOB: case DBVT_ENCRYPTED:
bytesRequired = dbcwWork.value.cpbVal + 2;
break;
default:
bytesRequired = dbcwWork.value.type;
}
bytesRequired += 2 + settingNameLen;
bytesRequired += (DB_SETTINGS_RESIZE_GRANULARITY - (bytesRequired % DB_SETTINGS_RESIZE_GRANULARITY)) % DB_SETTINGS_RESIZE_GRANULARITY;
ofsSettingsGroup = CreateNewSpace(bytesRequired + offsetof(DBContactSettings, blob));
dbcs.signature = DBCONTACTSETTINGS_SIGNATURE;
dbcs.ofsNext = dbc.ofsFirstSettings;
dbcs.ofsModuleName = ofsModuleName;
dbcs.cbBlob = bytesRequired;
dbcs.blob[0] = 0;
dbc.ofsFirstSettings = ofsSettingsGroup;
DBWrite(ofsContact, &dbc, sizeof(DBContact));
DBWrite(ofsSettingsGroup, &dbcs, sizeof(DBContactSettings));
ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
else {
dbcs = *(DBContactSettings*)DBRead(ofsSettingsGroup, &bytesRemaining);
// find if the setting exists
ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(settingNameLen + 1);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, dbcwWork.szSetting, settingNameLen))
break;
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
// setting already existed, and up to end of name is in cache
if (pBlob[0]) {
MoveAlong(1 + settingNameLen);
// if different type or variable length and length is different
NeedBytes(3);
if (pBlob[0] != dbcwWork.value.type ||
((pBlob[0] == DBVT_ASCIIZ || pBlob[0] == DBVT_UTF8) && *(PWORD)(pBlob + 1) != dbcwWork.value.cchVal) ||
((pBlob[0] == DBVT_BLOB || pBlob[0] == DBVT_ENCRYPTED) && *(PWORD)(pBlob + 1) != dbcwWork.value.cpbVal))
{
// bin it
NeedBytes(3);
int nameLen = 1 + settingNameLen;
int valLen = 1 + GetSettingValueLength(pBlob);
DWORD ofsSettingToCut = ofsBlobPtr - nameLen;
MoveAlong(valLen);
NeedBytes(1);
while (pBlob[0]) {
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
DBMoveChunk(ofsSettingToCut, ofsSettingToCut + nameLen + valLen, ofsBlobPtr + 1 - ofsSettingToCut);
ofsBlobPtr -= nameLen + valLen;
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
else {
// replace existing setting at pBlob
MoveAlong(1); // skip data type
switch (dbcwWork.value.type) {
case DBVT_BYTE: DBWrite(ofsBlobPtr, &dbcwWork.value.bVal, 1); break;
case DBVT_WORD: DBWrite(ofsBlobPtr, &dbcwWork.value.wVal, 2); break;
case DBVT_DWORD: DBWrite(ofsBlobPtr, &dbcwWork.value.dVal, 4); break;
case DBVT_BLOB:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
break;
case DBVT_ENCRYPTED:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
break;
}
// quit
DBFlush(1);
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
}
}
// cannot do a simple replace, add setting to end of list
// pBlob already points to end of list
// see if it fits
switch (dbcwWork.value.type) {
case DBVT_ASCIIZ: case DBVT_UTF8:
bytesRequired = dbcwWork.value.cchVal + 2;
break;
case DBVT_BLOB: case DBVT_ENCRYPTED:
bytesRequired = dbcwWork.value.cpbVal + 2;
break;
default:
bytesRequired = dbcwWork.value.type;
}
bytesRequired += 2 + settingNameLen;
bytesRequired += ofsBlobPtr + 1 - (ofsSettingsGroup + offsetof(DBContactSettings, blob));
if ((DWORD)bytesRequired > dbcs.cbBlob) {
// doesn't fit: move entire group
DBContactSettings *dbcsPrev;
DWORD ofsDbcsPrev, ofsNew;
InvalidateSettingsGroupOfsCacheEntry(ofsSettingsGroup);
bytesRequired += (DB_SETTINGS_RESIZE_GRANULARITY - (bytesRequired % DB_SETTINGS_RESIZE_GRANULARITY)) % DB_SETTINGS_RESIZE_GRANULARITY;
// find previous group to change its offset
ofsDbcsPrev = dbc.ofsFirstSettings;
if (ofsDbcsPrev == ofsSettingsGroup) ofsDbcsPrev = 0;
else {
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
while (dbcsPrev->ofsNext != ofsSettingsGroup) {
if (dbcsPrev->ofsNext == 0) DatabaseCorruption(NULL);
ofsDbcsPrev = dbcsPrev->ofsNext;
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
}
}
// create the new one
ofsNew = ReallocSpace(ofsSettingsGroup, dbcs.cbBlob + offsetof(DBContactSettings, blob), bytesRequired + offsetof(DBContactSettings, blob));
dbcs.cbBlob = bytesRequired;
DBWrite(ofsNew, &dbcs, offsetof(DBContactSettings, blob));
if (ofsDbcsPrev == 0) {
dbc.ofsFirstSettings = ofsNew;
DBWrite(ofsContact, &dbc, sizeof(DBContact));
}
else {
dbcsPrev = (DBContactSettings*)DBRead(ofsDbcsPrev, NULL);
dbcsPrev->ofsNext = ofsNew;
DBWrite(ofsDbcsPrev, dbcsPrev, offsetof(DBContactSettings, blob));
}
ofsBlobPtr += ofsNew - ofsSettingsGroup;
ofsSettingsGroup = ofsNew;
pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
}
// we now have a place to put it and enough space: make it
DBWrite(ofsBlobPtr, &settingNameLen, 1);
DBWrite(ofsBlobPtr + 1, (PVOID)dbcwWork.szSetting, settingNameLen);
MoveAlong(1 + settingNameLen);
DBWrite(ofsBlobPtr, &dbcwWork.value.type, 1);
MoveAlong(1);
switch (dbcwWork.value.type) {
case DBVT_BYTE: DBWrite(ofsBlobPtr, &dbcwWork.value.bVal, 1); MoveAlong(1); break;
case DBVT_WORD: DBWrite(ofsBlobPtr, &dbcwWork.value.wVal, 2); MoveAlong(2); break;
case DBVT_DWORD: DBWrite(ofsBlobPtr, &dbcwWork.value.dVal, 4); MoveAlong(4); break;
case DBVT_BLOB:
DBWrite(ofsBlobPtr, &dbcwWork.value.cpbVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
MoveAlong(2 + dbcwWork.value.cpbVal);
break;
case DBVT_ENCRYPTED:
DBWrite(ofsBlobPtr, &dbcwWork.value.cpbVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pbVal, dbcwWork.value.cpbVal);
MoveAlong(2 + dbcwWork.value.cpbVal);
break;
case DBVT_UTF8: case DBVT_ASCIIZ:
DBWrite(ofsBlobPtr, &dbcwWork.value.cchVal, 2);
DBWrite(ofsBlobPtr + 2, dbcwWork.value.pszVal, dbcwWork.value.cchVal);
MoveAlong(2 + dbcwWork.value.cchVal);
break;
}
BYTE zero = 0;
DBWrite(ofsBlobPtr, &zero, 1);
// quit
DBFlush(1);
lck.unlock();
// notify
NotifyEventHooks(hSettingChangeEvent, contactID, (LPARAM)&dbcwNotif);
return 0;
}
BOOL CreateOpenGLRenderContext(HWND hWnd)
{
BOOL bResult;
char buffer[128];
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd
1, // version number
PFD_DRAW_TO_WINDOW | // support window
PFD_SUPPORT_OPENGL | // support OpenGL
PFD_DOUBLEBUFFER, // double buffered
PFD_TYPE_RGBA, // RGBA type
32, // 24-bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored
0, // no alpha buffer
0, // shift bit ignored
0, // no accumulation buffer
0, 0, 0, 0, // accum bits ignored
24, // 32-bit z-buffer
8, // no stencil buffer
0, // no auxiliary buffer
PFD_MAIN_PLANE, // main layer
0, // reserved
0, 0, 0 // layer masks ignored
};
hDC = GetDC(hWnd);
if (hDC == NULL)
{
OutputDebugStringA("Error: GetDC Failed!\n");
return FALSE;
}
int pixelFormatIndex;
pixelFormatIndex = ChoosePixelFormat(hDC, &pfd);
if (pixelFormatIndex == 0)
{
sprintf(buffer, "Error %d: ChoosePixelFormat Failed!\n", GetLastError());
OutputDebugStringA(buffer);
return FALSE;
}
bResult = SetPixelFormat(hDC, pixelFormatIndex, &pfd);
if (pixelFormatIndex == FALSE)
{
OutputDebugStringA("SetPixelFormat Failed!\n");
return FALSE;
}
openGLRC = wglCreateContext(hDC);
if (openGLRC == NULL)
{
sprintf(buffer, "Error %d: wglCreateContext Failed!\n", GetLastError());
OutputDebugStringA(buffer);
return FALSE;
}
bResult = wglMakeCurrent(hDC, openGLRC);
if (bResult == FALSE)
{
sprintf(buffer, "Error %d: wglMakeCurrent Failed!\n", GetLastError());
OutputDebugStringA(buffer);
return FALSE;
}
sprintf(buffer, "OpenGL version info: %s\n", (char*)glGetString(GL_VERSION));
OutputDebugStringA(buffer);
return TRUE;
}
void ReserveBottomMemory()
{
#ifdef _WIN64
static bool s_initialized = false;
if ( s_initialized )
return;
s_initialized = true;
// Start by reserving large blocks of address space, and then
// gradually reduce the size in order to capture all of the
// fragments. Technically we should continue down to 64 KB but
// stopping at 1 MB is sufficient to keep most allocators out.
const size_t LOW_MEM_LINE = 0x100000000LL;
size_t totalReservation = 0;
size_t numVAllocs = 0;
size_t numHeapAllocs = 0;
size_t oneMB = 1024 * 1024;
for (size_t size = 256 * oneMB; size >= oneMB; size /= 2)
{
for (;;)
{
void* p = VirtualAlloc(0, size, MEM_RESERVE, PAGE_NOACCESS);
if (!p)
break;
if ((size_t)p >= LOW_MEM_LINE)
{
// We don't need this memory, so release it completely.
VirtualFree(p, 0, MEM_RELEASE);
break;
}
totalReservation += size;
++numVAllocs;
}
}
// Now repeat the same process but making heap allocations, to use up
// the already reserved heap blocks that are below the 4 GB line.
HANDLE heap = GetProcessHeap();
for (size_t blockSize = 64 * 1024; blockSize >= 16; blockSize /= 2)
{
for (;;)
{
void* p = HeapAlloc(heap, 0, blockSize);
if (!p)
break;
if ((size_t)p >= LOW_MEM_LINE)
{
// We don't need this memory, so release it completely.
HeapFree(heap, 0, p);
break;
}
totalReservation += blockSize;
++numHeapAllocs;
}
}
// Perversely enough the CRT doesn't use the process heap. Suck up
// the memory the CRT heap has already reserved.
for (size_t blockSize = 64 * 1024; blockSize >= 16; blockSize /= 2)
{
for (;;)
{
void* p = malloc(blockSize);
if (!p)
break;
if ((size_t)p >= LOW_MEM_LINE)
{
// We don't need this memory, so release it completely.
free(p);
break;
}
totalReservation += blockSize;
++numHeapAllocs;
}
}
// Print diagnostics showing how many allocations we had to make in
// order to reserve all of low memory, typically less than 200.
char buffer[1000];
sprintf_s(buffer, "Reserved %1.3f MB (%d vallocs,"
"%d heap allocs) of low-memory.\n",
totalReservation / (1024 * 1024.0),
(int)numVAllocs, (int)numHeapAllocs);
OutputDebugStringA(buffer);
#endif
}
void DbgMsgTest()
{
OutputDebugStringA("Message 1 without newline");
OutputDebugStringA("Message 2 without newline");
OutputDebugStringA("Message 3 with newline\n");
OutputDebugStringA("Message with\nembedded newline\n");
OutputDebugStringA("This should look like a table in a non-proportionally spaced font like 'Courier'");
OutputDebugStringA("Colomn1\tColomn2\tColomn3\tColomn4\tColomn5");
OutputDebugStringA("1\t\t2\t\t3\t\t4\t\t5");
OutputDebugStringA("A\t\tB\t\tC\t\tD\t\tE");
OutputDebugStringA("11\t\t12\t\t13\t\t14\t\t15");
OutputDebugStringA("\t\t22\t\t23A\t\t24\t\t25");
OutputDebugStringA("\t\t\t\t33\t\t34\t\t35");
OutputDebugStringA("2LongLine: Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Very Long Message that ends in a single newline. Message ends HERE.\n");
}
int main(int argc, char* argv[])
{
std::cout << "DbgMsgSrc, pid: " << GetCurrentProcessId() << std::endl;
//OutputDebugStringA("ping");
//return 0;
// get un-spoofable executable file name
//char buf[260];
//GetMappedFileName(GetCurrentProcess(), _tmain, buf, sizeof(buf));
//printf("%S\n", buf);
//HANDLE handle1 = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
//HANDLE handle2 = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
//HANDLE handle3 = ::OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
//printf(" %p, %p, %p\n", handle1, handle2, handle3);
int lastArgc = argc - 1;
for (int i = 1; i < argc; ++i)
{
std::string arg(argv[i]);
if (arg == "-1")
{
Output("titan_crash_debugview_43mb.log");
return 0;
}
else if (arg == "-2")
{
if (i == lastArgc)
{
PrintUsage();
return -1;
}
Output(argv[i + 1]);
return 0;
}
else if (arg == "-3")
{
EndlessTest();
return 0;
}
else if (arg == "-s") // run separate process test
{
SeparateProcessTest();
return 0;
}
else if (arg == "-w")
{
std::cout << "Send OutputDebugStringA 'WithoutNewLine ' (15 bytes)\n";
OutputDebugStringA("WithoutNewLine ");
return 0;
}
else if (arg == "-n")
{
std::cout << "Send OutputDebugStringA 'WithNewLine\\n' (12 bytes)\n";
OutputDebugStringA("WithNewLine\n");
return 0;
}
else if (arg == "-e")
{
std::cout << "Send empty OutputDebugStringA message (0 bytes)\n";
OutputDebugStringA(""); //empty message
return 0;
}
else if (arg == "-4")
{
std::cout << "Send 2x OutputDebugStringA 'WithNewLine\\n (24 bytes)'\n";
OutputDebugStringA("WithNewLine\n");
OutputDebugStringA("WithNewLine\n");
return 0;
}
else if (arg == "-5")
{
std::cout << "Send OutputDebugStringA '1\\n2\\n3\\n' (6 bytes)\n";
OutputDebugStringA("1\n2\n3\n");
return 0;
}
else if (arg == "-6")
{
std::cout << "Send OutputDebugStringA '1 ' '2 ' '3\\n' in separate messages (6 bytes)\n";
OutputDebugStringA("1 ");
OutputDebugStringA("2 ");
OutputDebugStringA("3\n");
return 0;
}
else if (arg == "-7")
{
DbgMsgTest();
return 0;
}
else if (arg == "-8")
{
if (i == lastArgc)
{
PrintUsage();
return -1;
}
int n = atoi(argv[i + 1]);
DbgMsgSrc(n);
return 0;
}
else if (arg == "-9")
{
DbgMsgClearTest();
return 0;
}
else if (arg == "-A")
{
CoutCerrTest();
return 0;
}
else if (arg == "-B")
{
CoutCerrTest2();
return 0;
}
else if (arg == "-C")
{
SocketTest();
return 0;
}
else
{
Output(arg);
return 0;
}
}
PrintUsage();
return 0;
}
void Log::output(const char* str)
{
OutputDebugStringA(str);
}
BOOL InjectDll(DWORD dwPID, char *szDllName)
{
HANDLE hProcess2 = NULL;
LPVOID pRemoteBuf = NULL;
FARPROC pThreadProc = NULL;
PROCESS_INFORMATION pi;
STARTUPINFO si;
BOOL bResult = FALSE;
DWORD dwSessionId = -1;
DWORD winlogonPid = -1;
HANDLE hUserToken,hUserTokenDup,hPToken,hProcess;
DWORD dwCreationFlags;
TCHAR wcQMountPath[256];
TCHAR wcQMountArgs[256];
memset(wcQMountPath,0,sizeof(wcQMountPath));
memset(wcQMountArgs,0,sizeof(wcQMountArgs));
//dwSessionId = WTSGetActiveConsoleSessionId();
HMODULE hModuleKern = LoadLibrary( TEXT("KERNEL32.dll") );
if( hModuleKern != NULL )
{
DWORD (__stdcall *funcWTSGetActiveConsoleSessionId) (void);
funcWTSGetActiveConsoleSessionId = (DWORD (__stdcall *)(void))GetProcAddress( hModuleKern, "WTSGetActiveConsoleSessionId" );
if( funcWTSGetActiveConsoleSessionId != NULL )
{
dwSessionId = funcWTSGetActiveConsoleSessionId();
}
}
if( hModuleKern != NULL )
{
// ¥í©`¥É¤·¤¿DLL¤ò½â·Å
FreeLibrary( hModuleKern );
}
OutputDebugStringA("LaunchAppIntoDifferentSession is called.\n");
//
// Find the winlogon process
//
PROCESSENTRY32 procEntry;
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnap == INVALID_HANDLE_VALUE){
return FALSE;
}
procEntry.dwSize = sizeof(PROCESSENTRY32);
if (!Process32First(hSnap, &procEntry)){
return FALSE;
}
do
{
if (stricmp(procEntry.szExeFile, "winlogon.exe") == 0)
{
//
// We found a winlogon process...make sure it's running in the console session
//
DWORD winlogonSessId = 0;
if (ProcessIdToSessionId(procEntry.th32ProcessID, &winlogonSessId) && winlogonSessId == dwSessionId){
winlogonPid = procEntry.th32ProcessID;
break;
}
}
} while (Process32Next(hSnap, &procEntry));
if (-1 == winlogonPid) {
}
//WTSQueryUserToken(dwSessionId,&hUserToken);
BOOL (__stdcall *funcWTSQueryUserToken) (ULONG, PHANDLE);
HMODULE hModuleWTS = LoadLibrary( TEXT("Wtsapi32.dll") );
if( hModuleWTS != NULL )
{
BOOL (__stdcall *funcWTSQueryUserToken) (ULONG, PHANDLE);
funcWTSQueryUserToken = (BOOL (__stdcall *)(ULONG, PHANDLE))GetProcAddress( hModuleWTS, "WTSQueryUserToken" );
if( funcWTSQueryUserToken != NULL )
{
funcWTSQueryUserToken(dwSessionId,&hUserToken);
}
}
if( hModuleWTS != NULL )
{
// ¥í©`¥É¤·¤¿DLL¤ò½â·Å
FreeLibrary( hModuleKern );
}
dwCreationFlags = NORMAL_PRIORITY_CLASS|CREATE_NEW_CONSOLE;
ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb= sizeof(STARTUPINFO);
si.lpDesktop = "winsta0\\default";
ZeroMemory(&pi, sizeof(pi));
TOKEN_PRIVILEGES tp;
LUID luid;
hProcess = OpenProcess(MAXIMUM_ALLOWED,FALSE,winlogonPid);
if( !::OpenProcessToken(hProcess,
TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY|TOKEN_DUPLICATE|
TOKEN_ASSIGN_PRIMARY|TOKEN_ADJUST_SESSIONID|TOKEN_READ|TOKEN_WRITE,
&hPToken))
{
//OutputDebugPrintf("Failed[LaunchAppIntoDifferentSession]: OpenProcessToken(Error=%d)\n",GetLastError());
}
if (!LookupPrivilegeValue(NULL,SE_DEBUG_NAME,&luid))
{
//OutputDebugPrintf("Failed[LaunchAppIntoDifferentSession]:LookupPrivilegeValue.(Error=%d)\n",GetLastError());
}
tp.PrivilegeCount =1;
tp.Privileges[0].Luid =luid;
tp.Privileges[0].Attributes =SE_PRIVILEGE_ENABLED;
DuplicateTokenEx(hPToken,MAXIMUM_ALLOWED,NULL,SecurityIdentification,TokenPrimary,&hUserTokenDup);
int dup = GetLastError();
//
//Adjust Token privilege
//
SetTokenInformation(hUserTokenDup,TokenSessionId,(void*)dwSessionId,sizeof(DWORD));
if (!AdjustTokenPrivileges(hUserTokenDup,FALSE,&tp,sizeof(TOKEN_PRIVILEGES),(PTOKEN_PRIVILEGES)NULL,NULL))
{
//OutputDebugPrintf("Failed[LaunchAppIntoDifferentSession]: AdjustTokenPrivileges.(Error=%d)\n",GetLastError());
}
if (GetLastError()== ERROR_NOT_ALL_ASSIGNED)
{
//OutputDebugPrintf("Failed[LaunchAppIntoDifferentSession]: Token does not have the provilege\n");
}
LPVOID pEnv =NULL;
if(CreateEnvironmentBlock(&pEnv,hUserTokenDup,TRUE)){
dwCreationFlags |= CREATE_UNICODE_ENVIRONMENT;
}
else
{
pEnv=NULL;
}
DWORD dwBufSize = strlen(szDllName)+1;
if ( !(hProcess2 = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID)) )
{
printf("[´íÎó] OpenProcess(%d) µ÷ÓÃʧ°Ü£¡´íÎó´úÂë: [%d]/n",
dwPID, GetLastError());
return FALSE;
}
pRemoteBuf = VirtualAllocEx(hProcess, NULL, dwBufSize,
MEM_COMMIT, PAGE_READWRITE);
WriteProcessMemory(hProcess, pRemoteBuf, (LPVOID)szDllName,
dwBufSize, NULL);
pThreadProc = GetProcAddress(GetModuleHandle("kernel32.dl"),
"LoadLibraryA");
if( !MyCreateRemoteThread(hProcess, (LPTHREAD_START_ROUTINE)pThreadProc, pRemoteBuf) )
{
printf("[´íÎó] CreateRemoteThread() µ÷ÓÃʧ°Ü£¡´íÎó´úÂë: [%d]/n", GetLastError());
return FALSE;
}
VirtualFreeEx(hProcess2, pRemoteBuf, 0, MEM_RELEASE);
CloseHandle(hProcess2);
CloseHandle(hProcess);
CloseHandle(hUserToken);
CloseHandle(hUserTokenDup);
CloseHandle(hPToken);
return TRUE;
}
int CDb3Mmap::GetContactSettingWorker(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting, DBVARIANT *dbv, int isStatic)
{
if (szSetting == NULL || szModule == NULL)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(szSetting);
int moduleNameLen = (int)mir_strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("GetContactSettingWorker() got a > 255 module name length. \n");
#endif
return 1;
}
mir_cslock lck(m_csDbAccess);
LBL_Seek:
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
log3("get [%08p] %s (%p)", hContact, szCachedSettingName, szCachedSettingName);
DBVARIANT *pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 0);
if (pCachedValue != NULL) {
if (pCachedValue->type == DBVT_ASCIIZ || pCachedValue->type == DBVT_UTF8) {
int cbOrigLen = dbv->cchVal;
char *cbOrigPtr = dbv->pszVal;
memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
if (isStatic) {
int cbLen = 0;
if (pCachedValue->pszVal != NULL)
cbLen = (int)mir_strlen(pCachedValue->pszVal);
cbOrigLen--;
dbv->pszVal = cbOrigPtr;
if (cbLen < cbOrigLen)
cbOrigLen = cbLen;
memcpy(dbv->pszVal, pCachedValue->pszVal, cbOrigLen);
dbv->pszVal[cbOrigLen] = 0;
dbv->cchVal = cbLen;
}
else {
dbv->pszVal = (char*)mir_alloc(mir_strlen(pCachedValue->pszVal) + 1);
mir_strcpy(dbv->pszVal, pCachedValue->pszVal);
}
}
else memcpy(dbv, pCachedValue, sizeof(DBVARIANT));
log2("get cached %s (%p)", printVariant(dbv), pCachedValue);
return (pCachedValue->type == DBVT_DELETED) ? 1 : 0;
}
// never look db for the resident variable
if (szCachedSettingName[-1] != 0)
return 1;
DBCachedContact *cc;
DWORD ofsContact = GetContactOffset(contactID, &cc);
DWORD ofsModuleName = GetModuleNameOfs(szModule);
DBContact dbc = *(DBContact*)DBRead(ofsContact, NULL);
if (dbc.signature != DBCONTACT_SIGNATURE)
return 1;
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(&dbc, ofsModuleName);
if (ofsSettingsGroup) {
int bytesRemaining;
unsigned varLen;
DWORD ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
PBYTE pBlob = DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(1 + settingNameLen);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, szSetting, settingNameLen)) {
MoveAlong(1 + settingNameLen);
NeedBytes(5);
if (isStatic && (pBlob[0] & DBVTF_VARIABLELENGTH) && VLT(dbv->type) != VLT(pBlob[0]))
return 1;
BYTE iType = dbv->type = pBlob[0];
switch (iType) {
case DBVT_DELETED: /* this setting is deleted */
dbv->type = DBVT_DELETED;
return 2;
case DBVT_BYTE: dbv->bVal = pBlob[1]; break;
case DBVT_WORD: memmove(&(dbv->wVal), (PWORD)(pBlob + 1), 2); break;
case DBVT_DWORD: memmove(&(dbv->dVal), (PDWORD)(pBlob + 1), 4); break;
case DBVT_UTF8:
case DBVT_ASCIIZ:
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, pBlob + 3, dbv->cchVal); // decode
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, pBlob + 3, varLen);
dbv->pszVal[varLen] = 0;
}
break;
case DBVT_BLOB:
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
if (isStatic) {
if (varLen < dbv->cpbVal)
dbv->cpbVal = varLen;
memmove(dbv->pbVal, pBlob + 3, dbv->cpbVal);
}
else {
dbv->pbVal = (BYTE *)mir_alloc(varLen);
memmove(dbv->pbVal, pBlob + 3, varLen);
}
dbv->cpbVal = varLen;
break;
case DBVT_ENCRYPTED:
if (m_crypto == NULL)
return 1;
else {
varLen = *(PWORD)(pBlob + 1);
NeedBytes(int(3 + varLen));
size_t realLen;
ptrA decoded(m_crypto->decodeString(pBlob + 3, varLen, &realLen));
if (decoded == NULL)
return 1;
varLen = (WORD)realLen;
dbv->type = DBVT_UTF8;
if (isStatic) {
dbv->cchVal--;
if (varLen < dbv->cchVal)
dbv->cchVal = varLen;
memmove(dbv->pszVal, decoded, dbv->cchVal);
dbv->pszVal[dbv->cchVal] = 0;
dbv->cchVal = varLen;
}
else {
dbv->pszVal = (char*)mir_alloc(1 + varLen);
memmove(dbv->pszVal, decoded, varLen);
dbv->pszVal[varLen] = 0;
}
}
break;
}
/**** add to cache **********************/
if (iType != DBVT_BLOB && iType != DBVT_ENCRYPTED) {
pCachedValue = m_cache->GetCachedValuePtr(contactID, szCachedSettingName, 1);
if (pCachedValue != NULL) {
m_cache->SetCachedVariant(dbv, pCachedValue);
log3("set cached [%08p] %s (%p)", hContact, szCachedSettingName, pCachedValue);
}
}
return 0;
}
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
}
// try to get the missing mc setting from the active sub
if (cc && cc->IsMeta() && ValidLookupName(szModule, szSetting)) {
if (contactID = db_mc_getDefault(contactID)) {
if (szModule = GetContactProto(contactID)) {
moduleNameLen = (int)mir_strlen(szModule);
goto LBL_Seek;
}
}
}
logg();
return 1;
}
void FBOutputDebugString(const char* msg){
#if defined(_PLATFORM_WINDOWS_)
OutputDebugStringA(msg);
#else
#endif
}
STDMETHODIMP_(BOOL) CDb3Mmap::DeleteContactSetting(MCONTACT contactID, LPCSTR szModule, LPCSTR szSetting)
{
if (!szModule || !szSetting)
return 1;
// the db format can't tolerate more than 255 bytes of space (incl. null) for settings+module name
int settingNameLen = (int)mir_strlen(szSetting);
int moduleNameLen = (int)mir_strlen(szModule);
if (settingNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 setting name length. \n");
#endif
return 1;
}
if (moduleNameLen > 0xFE) {
#ifdef _DEBUG
OutputDebugStringA("DeleteContactSetting() got a > 255 module name length. \n");
#endif
return 1;
}
MCONTACT saveContact = contactID;
{
mir_cslock lck(m_csDbAccess);
char *szCachedSettingName = m_cache->GetCachedSetting(szModule, szSetting, moduleNameLen, settingNameLen);
if (szCachedSettingName[-1] == 0) { // it's not a resident variable
DWORD ofsModuleName = GetModuleNameOfs(szModule);
DWORD ofsContact = GetContactOffset(contactID);
DBContact *dbc = (DBContact*)DBRead(ofsContact, NULL);
if (dbc->signature != DBCONTACT_SIGNATURE)
return 1;
// make sure the module group exists
DWORD ofsSettingsGroup = GetSettingsGroupOfsByModuleNameOfs(dbc, ofsModuleName);
if (ofsSettingsGroup == 0)
return 1;
// find if the setting exists
DWORD ofsBlobPtr = ofsSettingsGroup + offsetof(DBContactSettings, blob);
int bytesRemaining;
PBYTE pBlob = (PBYTE)DBRead(ofsBlobPtr, &bytesRemaining);
while (pBlob[0]) {
NeedBytes(settingNameLen + 1);
if (pBlob[0] == settingNameLen && !memcmp(pBlob + 1, szSetting, settingNameLen))
break;
NeedBytes(1);
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
if (!pBlob[0]) //setting didn't exist
return 1;
// bin it
MoveAlong(1 + settingNameLen);
NeedBytes(3);
int nameLen = 1 + settingNameLen;
int valLen = 1 + GetSettingValueLength(pBlob);
DWORD ofsSettingToCut = ofsBlobPtr - nameLen;
MoveAlong(valLen);
NeedBytes(1);
while (pBlob[0]) {
MoveAlong(pBlob[0] + 1);
NeedBytes(3);
MoveAlong(1 + GetSettingValueLength(pBlob));
NeedBytes(1);
}
DBMoveChunk(ofsSettingToCut, ofsSettingToCut + nameLen + valLen, ofsBlobPtr + 1 - ofsSettingToCut);
DBFlush(1);
// remove a value from cache anyway
m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1);
}
else { // resident variable
// if a value doesn't exist, simply return error
if (m_cache->GetCachedValuePtr(saveContact, szCachedSettingName, -1) == NULL)
return 1;
}
}
// notify
DBCONTACTWRITESETTING dbcws = { 0 };
dbcws.szModule = szModule;
dbcws.szSetting = szSetting;
dbcws.value.type = DBVT_DELETED;
NotifyEventHooks(hSettingChangeEvent, saveContact, (LPARAM)&dbcws);
return 0;
}
/*******************************************************************
Dutil_TraceError
*******************************************************************/
extern "C" void DAPI Dutil_TraceError(
__in_z LPCSTR szFile,
__in int iLine,
__in REPORT_LEVEL rl,
__in HRESULT hrError,
__in_z __format_string LPCSTR szFormat,
...
)
{
HRESULT hr = S_OK;
char szOutput[DUTIL_STRING_BUFFER] = { };
char szMsg[DUTIL_STRING_BUFFER] = { };
// if this is NOT an error report and we're not logging at this level, bail
if (REPORT_ERROR != rl && Dutil_rlCurrentTrace < rl)
{
return;
}
va_list args;
va_start(args, szFormat);
hr = ::StringCchVPrintfA(szOutput, countof(szOutput), szFormat, args);
va_end(args);
if (SUCCEEDED(hr))
{
if (Dutil_fTraceFilenames)
{
if (FAILED(hrError))
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "TraceError 0x%x [%s,%d]: %s\r\n", hrError, szFile, iLine, szOutput);
}
else
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "TraceError [%s,%d]: %s\r\n", szFile, iLine, szOutput);
}
}
else
{
if (FAILED(hrError))
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "TraceError 0x%x: %s\r\n", hrError, szOutput);
}
else
{
hr = ::StringCchPrintfA(szMsg, countof(szMsg), "TraceError: %s\r\n", szOutput);
}
}
if (SUCCEEDED(hr))
{
OutputDebugStringA(szMsg);
}
// else fall through to the failure case below
}
if (FAILED(hr))
{
if (Dutil_fTraceFilenames)
{
if (FAILED(hrError))
{
::StringCchPrintfA(szMsg, countof(szMsg), "TraceError 0x%x [%s,%d]: message too long, skipping\r\n", hrError, szFile, iLine);
}
else
{
::StringCchPrintfA(szMsg, countof(szMsg), "TraceError [%s,%d]: message too long, skipping\r\n", szFile, iLine);
}
}
else
{
if (FAILED(hrError))
{
::StringCchPrintfA(szMsg, countof(szMsg), "TraceError 0x%x: message too long, skipping\r\n", hrError);
}
else
{
::StringCchPrintfA(szMsg, countof(szMsg), "TraceError: message too long, skipping\r\n");
}
}
szMsg[countof(szMsg)-1] = '\0';
OutputDebugStringA(szMsg);
}
}
void Log(enum LogType type, const char* fmt, ...)
{
#ifdef DISABLE_LOG
SP_UNREFERENCED_PARAMETER(type);
SP_UNREFERENCED_PARAMETER(fmt);
return;
#else
AMDTScopeLock s(&sMutex);
bool s_LogConsole = false;
const char* s_LogFunction = __FUNCTION__;
va_list arg_ptr;
va_start(arg_ptr, fmt);
// check to see if logging of the level is enabled, or if s_LogConsole is specified
// if not, don't process it.
if (type > OptionLogLevel)
{
va_end(arg_ptr);
return;
}
// Define buffer to store maximum current log message.
// Different destinations will receive a subset of this string.
// On Win32 the entire string is passed to OutputDebugString()
char fullString[SP_LOG_MAX_LENGTH] = "\0";
int nLen = 0;
int nSize;
bool truncated = false;
char* pLogString; // String to print to logfile
char* pConsole; // String to print to console doesn't include debug information
char* pRaw; // Raw string passed in without any additional decoration
switch (type)
{
case traceENTER:
if (truncated == false)
{
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Enter: %s() ", s_LogFunction);
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
break;
case traceEXIT:
logIndent -= SP_LOG_INDENT_SIZE;
if (logIndent < 0)
{
logIndent = 0;
}
truncated = (nLen == SP_LOG_MAX_LENGTH);
if (truncated == false)
{
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Exit : %s() ", s_LogFunction);
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
break;
default:
break;
}
#ifdef WIN32
if (truncated == false)
{
// Prepend "CodeXL GPU Profiler: " for windows OutputDebugString() messages
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "CodeXL GPU Profiler: ");
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
#endif
pLogString = &fullString[nLen]; // logfile message doesn't include above WIN32 section
#if (defined SP_LOG_DEBUG) && (defined _DEBUG)
char* s_LogFile = __FILE__;
int s_LogLine = __LINE__;
if (truncated == false)
{
// In debug builds, include the __FILE__, __LINE__ and __FUNCTION__ information
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "%s(%d) : %s(): ", s_LogFile, s_LogLine, s_LogFunction);
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
#endif
//// Prepend accurate timestamp
//if ( truncated == false )
//{
// std::string time = StringUtils::GetTimeString();
// nSize = _snprintf_s( &fullString[nLen], SP_LOG_MAX_LENGTH - nLen, _TRUNCATE, "%-14s: ", time.c_str() );
// if ( ( truncated = ( nSize == -1 ) ) == false )
// {
// nLen += nSize;
// }
//}
pConsole = &fullString[nLen]; // String to print to console starts here
if (truncated == false)
{
// Add the message type string
switch (type)
{
case logERROR:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Error: ");
break;
case logWARNING:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Warning: ");
break;
case logMESSAGE:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Message: ");
break;
case logTRACE:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Trace: ");
break;
case logASSERT:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Assert: ");
break;
case logRAW:
// Skip
nSize = 0;
break;
case traceENTER:
case traceEXIT:
case traceMESSAGE:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Trace: ");
break;
default:
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "Unknown: ");
break;
}
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
// Add the module identifier
if (s_LogModule && (truncated == false))
{
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "%-14s: ", s_LogModule);
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
if (truncated == false)
{
if (OptionLogLevel >= logTRACE - logERROR)
{
// Add the indent
for (int i = 0; (i < logIndent) && (nLen < SP_LOG_MAX_LENGTH); i++, nLen++)
{
fullString[nLen] = ' ';
}
truncated = (nLen == SP_LOG_MAX_LENGTH);
}
}
pRaw = &fullString[nLen]; // Raw undecorated string starts here
// Add the actual Log Message
if (truncated == false)
{
nSize = SP_vsnprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, fmt, arg_ptr);
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
// Check if message has been truncated and clean up accordingly
if (truncated == true)
{
// Truncation occurred - change end of line to reflect this
char truncationString[] = " ... \n";
SP_sprintf(&fullString[SP_LOG_MAX_LENGTH - sizeof(truncationString)], sizeof(truncationString), "%s", truncationString);
}
if (type > logTRACE)
{
// For trace messages - force a "\n" at the end
if (truncated == false)
{
nSize = SP_snprintf(&fullString[nLen], SP_LOG_MAX_LENGTH - nLen, "\n");
if ((truncated = (nSize == -1)) == false)
{
nLen += nSize;
}
}
}
// Message Constructed. Print to Log, Console, and OutputDebugString as necessary
//
if (type == logRAW)
{
if (s_LogConsole)
{
// Send string to console
printf("%s", pRaw);
}
_logWrite(pRaw);
}
else
{
if (s_LogConsole)
{
// Console messages are always printed in console and in log file
// regardless of logLEVEL
printf("%s", pConsole);
_logWrite(pLogString);
#ifdef WIN32
SP_TODO("revisit use of OutputDebugStringA for Unicode support")
OutputDebugStringA(fullString);
#endif
}
else
{
// not a console message - filter based on log level
if ((type - logERROR) <= OptionLogLevel)
{
if (type == logTRACE)
{
// Trace messages also go to the console
printf("%s", pConsole);
}
_logWrite(pLogString);
#ifdef WIN32
SP_TODO("revisit use of OutputDebugStringA for Unicode support")
OutputDebugStringA(fullString);
#endif
}
}
}
va_end(arg_ptr);
#endif
}
void
Messenger::onDataReceived(
::net::IStream::TId streamId,
const unsigned char* buf,
size_t bufSize)
{
util::ScopedLock lock(&s_sync);
try
{
// Append data to corresponding data buffer
TStreamData::iterator dd = m_streamData.find(streamId);
if (dd == m_streamData.end())
{
dd = m_streamData.insert(std::make_pair(streamId, TData(0))).first;
}
TData& data = dd->second;
// Required data length
size_t dataSize = data.size();
size_t requiredLen = dataSize + bufSize;
size_t availableLen = data.capacity();
#ifndef NDEBUG
{
char buf2[128];
memset(buf2, 0, sizeof(buf2));
sprintf(buf2, "%p data before: ", reinterpret_cast<void*>(streamId));
OutputDebugStringA(buf2);
if (0 < data.size())
dumpBinBuffer(&data[0], data.size());
else
OutputDebugStringA("<empty>\n");
}
#endif // !NDEBUG
// Resize data buffer if it is not large enough
if (availableLen < requiredLen)
{
// Reserve 20% more
size_t reserve = static_cast<size_t>(requiredLen * 1.2);
if (reserve < KMSG_INITIAL_DATA_BUF_SIZE)
reserve = KMSG_INITIAL_DATA_BUF_SIZE;
data.reserve(reserve);
}
data.resize(requiredLen);
// Copy data to buffer
memcpy(&data[dataSize], buf, bufSize);
// Try to extract message from data
while (sizeof(MessageHeader) <= (dataSize = data.size()))
{
MessageHeader header;
memset(&header, 0, sizeof(header));
assert(data.size() == dataSize);
unsigned char* pData = &data[0];
memcpy(&header, pData, sizeof(header));
util::T_UI4 messageSize = header.payloadSize + sizeof(MessageHeader); // two bytes at the beginning are message type and payload length
if (messageSize <= dataSize)
{
TMessagePtr message;
try
{
if (!m_messageFactory)
{
assert(!"Message factory must be set before receiving messages");
throw std::logic_error("Internal error");
}
chkptr(m_messageFactory);
message = m_messageFactory->createMessage(header.messageType);
{
util::ScopedLock lock(&m_memStreamSync);
util::MemoryStream memstream(pData + sizeof(MessageHeader), pData + messageSize);
message->load(memstream);
}
// Remove message bytes from data
{
TData::iterator bb = data.begin();
std::advance(bb, messageSize);
#ifndef NDEBUG
size_t dataSizeBefore = data.size();
assert(dataSizeBefore >= messageSize);
#endif // !NDEBUG
data.erase(data.begin(), bb);
#ifndef NDEBUG
size_t dataSizeAfter = data.size();
assert(dataSizeAfter + messageSize == dataSizeBefore);
assert(dd->second.size() == dataSizeAfter);
{
char buf2[128];
memset(buf2, 0, sizeof(buf2));
sprintf(buf2, "%p data after: ", reinterpret_cast<void*>(streamId));
OutputDebugStringA(buf2);
if (0 < data.size())
dumpBinBuffer(&data[0], data.size());
else
OutputDebugStringA("<empty>\n");
}
#endif // !NDEBUG
}
TMessengerDelegates::iterator ii = m_messengerDelegates.find(streamId);
if (ii == m_messengerDelegates.end())
{
assert(0);
throw util::Error("Stream not found");
}
IMessengerDelegate* delegate_ = ii->second;
chkptr(delegate_);
delegate_->onMessageReceived(streamId, message);
}
catch (const std::exception& x)
{
#ifndef NDEBUG
const char* szMsg = x.what();
#endif
// Unknown messages and message handling errors are simple discarded
ignore_unused(x);
assert(!"Unknown message type or message handling error");
}
catch (...)
{
// Unknown messages and message handling errors are simple discarded
assert(!"Unknown message type or message handling error");
}
}
else
{
// Not enough data
break;
}
}
}
catch (const std::exception& x)
{
// Some error (probably bad_alloc) occured while processing stream data.
// In this case stream is assumed to be in incosistent state and thus is not used any more.
net::StreamListener::instance().closeStream(streamId, x.what());
}
catch (...)
{
// Some unknown error occured while processing stream data.
// In this case stream is assumed to be in incosistent state and thus is not used any more.
net::StreamListener::instance().closeStream(streamId, "Unknown error");
}
}
bool read_data(char* data, size_type offset, size_type size, size_type& read_size)
{
boost::mutex::scoped_lock lock(m_notify_mutex);
const torrent_info& info = m_handle.get_torrent_info();
bool ret = false;
read_size = 0;
#if defined(_DEBUG) && defined(WIN32)
unsigned int time = GetTickCount();
#endif
// 计算偏移所在的片.
int index = offset / info.piece_length();
BOOST_ASSERT(index >= 0 && index < info.num_pieces());
if (index >= info.num_pieces() || index < 0)
return ret;
torrent_status status = m_handle.status();
if (!status.pieces.empty())
{
if (status.state != torrent_status::downloading &&
status.state != torrent_status::finished &&
status.state != torrent_status::seeding)
return ret;
// 设置下载位置.
std::vector<int> pieces;
pieces = m_handle.piece_priorities();
std::for_each(pieces.begin(), pieces.end(), boost::lambda::_1 = 1);
pieces[index] = 7;
m_handle.prioritize_pieces(pieces);
if (status.pieces.get_bit(index))
{
// 保存参数信息.
m_current_buffer = data;
m_read_offset = offset;
m_read_size = &read_size;
m_request_size = size;
// 提交请求.
m_handle.read_piece(index, boost::bind(&extern_read_op::on_read, this, _1, _2, _3));
// 等待请求返回.
m_notify.wait(lock);
// 读取字节数.
if (read_size != 0)
ret = true;
}
}
else
{
// 直接读取文件.
if (m_file_path.string() == "" || !m_file.is_open())
{
boost::filesystem::path path = m_handle.save_path();
const file_storage& stor = info.files();
std::string name = stor.name();
m_file_path = path / name;
name = convert_to_native(m_file_path.string());
// 打开文件, 直接从文件读取数据.
if (!m_file.is_open())
{
m_file.open(name.c_str(), std::ios::in | std::ios::binary);
if (!m_file.is_open())
return ret;
}
}
if (!m_file.is_open())
return ret;
m_file.clear();
m_file.seekg(offset, std::ios::beg);
m_file.read(data, size);
read_size = m_file.gcount();
if (read_size != -1)
ret = true;
}
#if defined(_DEBUG) && defined(WIN32)
static unsigned int cur_time = GetTickCount();
char str_info[8192] = { 0 };
char *ptr = (char*)str_info;
if (GetTickCount() - cur_time >= 5000)
{
cur_time = GetTickCount();
sprintf(str_info, "request: %d, size: %d, request time: %d, peers: %d\n",
index, (int)size, cur_time - time, status.num_peers);
ptr = ptr + strlen(str_info);
for (int i = 0; i < status.pieces.size() / 8; i++)
{
if (i % 32 == 0)
{
sprintf(ptr, "\n");
ptr += 1;
}
sprintf(ptr, "%02X", (unsigned char)status.pieces.bytes()[i]);
ptr += 2;
}
if (status.pieces.size() % 8 != 0)
{
sprintf(ptr, "%02X", (unsigned char)status.pieces.bytes()[status.pieces.size() / 8]);
ptr += 2;
}
sprintf(ptr, "\n\n");
// 显示当前正在下载的分片信息.
std::string out;
char str[500];
std::vector<cached_piece_info> pieces;
torrent_handle &h = m_handle;
std::vector<partial_piece_info> queue;
std::vector<peer_info> peers;
m_ses.get_cache_info(h.info_hash(), pieces);
h.get_download_queue(queue);
h.get_peer_info(peers);
std::sort(queue.begin(), queue.end(), boost::bind(&partial_piece_info::piece_index, _1)
< boost::bind(&partial_piece_info::piece_index, _2));
std::sort(pieces.begin(), pieces.end(), boost::bind(&cached_piece_info::last_use, _1)
> boost::bind(&cached_piece_info::last_use, _2));
for (std::vector<cached_piece_info>::iterator i = pieces.begin();
i != pieces.end(); ++i)
{
partial_piece_info* pp = 0;
partial_piece_info tmp;
tmp.piece_index = i->piece;
std::vector<partial_piece_info>::iterator ppi
= std::lower_bound(queue.begin(), queue.end(), tmp
, boost::bind(&partial_piece_info::piece_index, _1)
< boost::bind(&partial_piece_info::piece_index, _2));
if (ppi != queue.end() && ppi->piece_index == i->piece) pp = &*ppi;
print_piece(pp, &*i, peers, out);
if (pp) queue.erase(ppi);
}
for (std::vector<partial_piece_info>::iterator i = queue.begin()
, end(queue.end()); i != end; ++i)
{
print_piece(&*i, 0, peers, out);
}
snprintf(str, sizeof(str), "%s %s: read cache %s %s: downloading %s %s: cached %s %s: flushed\n"
, esc("34;7"), esc("0") // read cache
, esc("33;7"), esc("0") // downloading
, esc("36;7"), esc("0") // cached
, esc("32;7"), esc("0")); // flushed
out += str;
out += "___________________________________\n";
strcat(str_info, out.c_str());
OutputDebugStringA(str_info);
printf(str_info);
}
#endif
return ret;
}
void EventCallback::OnModuleLoad( IProcess* process, IModule* coreModule )
{
OutputDebugStringA( "EventCallback::OnModuleLoad\n" );
HRESULT hr = S_OK;
RefPtr<ModuleLoadEvent> event;
RefPtr<Program> prog;
RefPtr<Module> mod;
CComPtr<IDebugModule2> mod2;
if ( !mEngine->FindProgram( process->GetId(), prog ) )
return;
hr = prog->CreateModule( coreModule, mod );
if ( FAILED( hr ) )
return;
hr = prog->AddModule( mod.Get() );
if ( FAILED( hr ) )
return;
hr = mod->LoadSymbols( false );
// later we'll check if symbols were loaded
hr = mEngine->BindPendingBPsToModule( mod.Get(), prog.Get() );
hr = MakeCComObject( event );
if ( FAILED( hr ) )
return;
hr = mod->QueryInterface( __uuidof( IDebugModule2 ), (void**) &mod2 );
if ( FAILED( hr ) )
return;
// TODO: message
event->Init( mod2, NULL, true );
SendEvent( event.Get(), prog.Get(), NULL );
//-------------------------
RefPtr<SymbolSearchEvent> symEvent;
CComPtr<IDebugModule3> mod3;
MODULE_INFO_FLAGS flags = 0;
RefPtr<MagoST::ISession> session;
CComBSTR name;
mod->GetName( name );
hr = mod->QueryInterface( __uuidof( IDebugModule3 ), (void**) &mod3 );
if ( FAILED( hr ) )
return;
hr = MakeCComObject( symEvent );
if ( FAILED( hr ) )
return;
if ( mod->GetSymbolSession( session ) )
flags |= MIF_SYMBOLS_LOADED;
symEvent->Init( mod3, name.m_str, flags );
hr = SendEvent( symEvent.Get(), prog.Get(), NULL );
}
void AsyncGetValue( HWND hWnd )
{
OutputDebugStringA("AsyncGetValue\n");
PostThreadMessage(thread_id_accget_, WM_USER, 0, (LPARAM)hWnd);
}
void EventCallback::OnProcessStart( IProcess* process )
{
OutputDebugStringA( "EventCallback::OnProcessStart\n" );
}
static void vprintf_stderr_common(const char* format, va_list args)
{
#if PLATFORM(MAC)
if (strstr(format, "%@")) {
CFStringRef cfFormat = CFStringCreateWithCString(NULL, format, kCFStringEncodingUTF8);
CFStringRef str = CFStringCreateWithFormatAndArguments(NULL, NULL, cfFormat, args);
int length = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char* buffer = (char*)malloc(length + 1);
CFStringGetCString(str, buffer, length, kCFStringEncodingUTF8);
fputs(buffer, stderr);
free(buffer);
CFRelease(str);
CFRelease(cfFormat);
} else
#elif PLATFORM(BREWMP)
// When str is 0, the return value is the number of bytes needed
// to accept the result including null termination.
int size = vsnprintf(0, 0, format, args);
if (size > 0) {
Vector<char> buffer(size);
vsnprintf(buffer.data(), size, format, args);
printLog(buffer);
}
#elif HAVE(ISDEBUGGERPRESENT)
if (IsDebuggerPresent()) {
size_t size = 1024;
do {
char* buffer = (char*)malloc(size);
if (buffer == NULL)
break;
if (_vsnprintf(buffer, size, format, args) != -1) {
#if OS(WINCE)
// WinCE only supports wide chars
wchar_t* wideBuffer = (wchar_t*)malloc(size * sizeof(wchar_t));
if (wideBuffer == NULL)
break;
for (unsigned int i = 0; i < size; ++i) {
if (!(wideBuffer[i] = buffer[i]))
break;
}
OutputDebugStringW(wideBuffer);
free(wideBuffer);
#else
OutputDebugStringA(buffer);
#endif
free(buffer);
break;
}
free(buffer);
size *= 2;
} while (size > 1024);
}
#endif
#if OS(SYMBIAN)
vfprintf(stdout, format, args);
#else
vfprintf(stderr, format, args);
#endif
}
void DbgMsg(char *lpszFile, int Line, char *lpszMsg, ...)
{
va_list mylist;
va_start(mylist, lpszMsg);
func_sprintf f_sprintf = (func_sprintf)GetProcAddress(
LoadLibraryA("msvcrt.dll"),
"sprintf"
);
if (f_sprintf == NULL)
{
return;
}
func_vsprintf f_vsprintf = (func_vsprintf)GetProcAddress(
LoadLibraryA("msvcrt.dll"),
"vsprintf"
);
if (f_vsprintf == NULL)
{
return;
}
func__vscprintf f__vscprintf = (func__vscprintf)GetProcAddress(
LoadLibraryA("msvcrt.dll"),
"_vscprintf"
);
if (f__vscprintf == NULL)
{
return;
}
size_t len = f__vscprintf(lpszMsg, mylist) + 0x100;
char *lpszBuff = (char *)LocalAlloc(LMEM_FIXED, len);
if (lpszBuff == NULL)
{
va_end(mylist);
return;
}
char *lpszOutBuff = (char *)LocalAlloc(LMEM_FIXED, len);
if (lpszOutBuff == NULL)
{
LocalFree(lpszBuff);
va_end(mylist);
return;
}
f_vsprintf(lpszBuff, lpszMsg, mylist);
va_end(mylist);
f_sprintf(
lpszOutBuff, "[%.5d] .\\%s(%d) : %s",
GetCurrentProcessId(), GetNameFromFullPath(lpszFile), Line, lpszBuff
);
OutputDebugStringA(lpszOutBuff);
HANDLE hStd = GetStdHandle(STD_OUTPUT_HANDLE);
if (hStd != INVALID_HANDLE_VALUE)
{
DWORD dwWritten = 0;
WriteFile(hStd, lpszBuff, lstrlenA(lpszBuff), &dwWritten, NULL);
}
LocalFree(lpszOutBuff);
LocalFree(lpszBuff);
}
void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap)
{
#if TARGET_OS_IPHONE
#if TARGET_IPHONE_SIMULATOR
vprintf(fmt, ap);
#else
static aslclient asl_client;
static int asl_initialized = 0;
if (!asl_initialized)
{
asl_client = asl_open(
file_path_str(FILE_PATH_PROGRAM_NAME),
"com.apple.console",
ASL_OPT_STDERR | ASL_OPT_NO_DELAY);
asl_initialized = 1;
}
aslmsg msg = asl_new(ASL_TYPE_MSG);
asl_set(msg, ASL_KEY_READ_UID, "-1");
if (tag)
asl_log(asl_client, msg, ASL_LEVEL_NOTICE, "%s", tag);
asl_vlog(asl_client, msg, ASL_LEVEL_NOTICE, fmt, ap);
asl_free(msg);
#endif
#elif defined(_XBOX1)
{
/* FIXME: Using arbitrary string as fmt argument is unsafe. */
char msg_new[1024];
char buffer[1024];
msg_new[0] = buffer[0] = '\0';
snprintf(msg_new, sizeof(msg_new), "%s: %s %s",
file_path_str(FILE_PATH_PROGRAM_NAME),
tag ? tag : "",
fmt);
wvsprintf(buffer, msg_new, ap);
OutputDebugStringA(buffer);
}
#elif defined(ANDROID)
{
int prio = ANDROID_LOG_INFO;
if (tag)
{
if (string_is_equal(file_path_str(FILE_PATH_LOG_WARN), tag))
prio = ANDROID_LOG_WARN;
else if (string_is_equal(file_path_str(FILE_PATH_LOG_ERROR), tag))
prio = ANDROID_LOG_ERROR;
}
if (log_file_initialized)
{
vfprintf(log_file_fp, fmt, ap);
fflush(log_file_fp);
}
else
__android_log_vprint(prio,
file_path_str(FILE_PATH_PROGRAM_NAME),
fmt,
ap);
}
#else
{
#if defined(HAVE_QT) || defined(__WINRT__)
char buffer[1024];
#endif
FILE *fp = (FILE*)retro_main_log_file();
#if defined(HAVE_QT) || defined(__WINRT__)
buffer[0] = '\0';
vsnprintf(buffer, sizeof(buffer), fmt, ap);
if (fp)
{
fprintf(fp, "%s %s", tag ? tag : file_path_str(FILE_PATH_LOG_INFO), buffer);
fflush(fp);
}
#if defined(HAVE_QT)
ui_companion_driver_log_msg(buffer);
#endif
#if defined(__WINRT__)
OutputDebugStringA(buffer);
#endif
#else
#if defined(NXLINK) && !defined(HAVE_FILE_LOGGER)
if (nxlink_connected)
mutexLock(&nxlink_mtx);
#endif
if (fp)
{
fprintf(fp, "%s ",
tag ? tag : file_path_str(FILE_PATH_LOG_INFO));
vfprintf(fp, fmt, ap);
fflush(fp);
}
#if defined(NXLINK) && !defined(HAVE_FILE_LOGGER)
if (nxlink_connected)
mutexUnlock(&nxlink_mtx);
#endif
#endif
}
#endif
}
void _PR_InitLog(void)
{
char *ev;
_pr_logLock = PR_NewLock();
ev = PR_GetEnv("NSPR_LOG_MODULES");
if (ev && ev[0]) {
char module[64]; /* Security-Critical: If you change this
* size, you must also change the sscanf
* format string to be size-1.
*/
PRBool isSync = PR_FALSE;
PRIntn evlen = strlen(ev), pos = 0;
PRInt32 bufSize = DEFAULT_BUF_SIZE;
while (pos < evlen) {
PRIntn level = 1, count = 0, delta = 0;
count = sscanf(&ev[pos], "%63[ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-]%n:%d%n",
module, &delta, &level, &delta);
pos += delta;
if (count == 0) break;
/*
** If count == 2, then we got module and level. If count
** == 1, then level defaults to 1 (module enabled).
*/
if (strcasecmp(module, "sync") == 0) {
isSync = PR_TRUE;
} else if (strcasecmp(module, "bufsize") == 0) {
if (level >= LINE_BUF_SIZE) {
bufSize = level;
}
} else if (strcasecmp(module, "timestamp") == 0) {
outputTimeStamp = PR_TRUE;
} else {
PRLogModuleInfo *lm = logModules;
PRBool skip_modcheck =
(0 == strcasecmp (module, "all")) ? PR_TRUE : PR_FALSE;
while (lm != NULL) {
if (skip_modcheck) lm -> level = (PRLogModuleLevel)level;
else if (strcasecmp(module, lm->name) == 0) {
lm->level = (PRLogModuleLevel)level;
break;
}
lm = lm->next;
}
}
/*found:*/
count = sscanf(&ev[pos], " , %n", &delta);
pos += delta;
if (count == EOF) break;
}
PR_SetLogBuffering(isSync ? 0 : bufSize);
#ifdef XP_UNIX
if ((getuid() != geteuid()) || (getgid() != getegid())) {
return;
}
#endif /* XP_UNIX */
ev = PR_GetEnv("NSPR_LOG_FILE");
if (ev && ev[0]) {
if (!PR_SetLogFile(ev)) {
#ifdef XP_PC
char* str = PR_smprintf("Unable to create nspr log file '%s'\n", ev);
if (str) {
OutputDebugStringA(str);
PR_smprintf_free(str);
}
#else
fprintf(stderr, "Unable to create nspr log file '%s'\n", ev);
#endif
}
} else {
#ifdef _PR_USE_STDIO_FOR_LOGGING
logFile = stderr;
#else
logFile = _pr_stderr;
#endif
}
}
}
int32_t CWelsTraceWinDgb::WriteString (int32_t iLevel, const char* pStr) {
OutputDebugStringA (pStr);
return strlen (pStr);
}