Code Muri

////////////////////////////////////////////////////////////////////////////////////////////////

    struct DbWinBuffer

    {

        DWORD dwProcessId;

        char data[4096 - sizeof(DWORD)];

    };

    DbWinBuffer* dbBuffer;

    HANDLE hAckEvent;

    HANDLE hEvent;

    HANDLE hSharedFile;

    SECURITY_DESCRIPTOR sd;

    SECURITY_ATTRIBUTES sa;

    ////////////////////////////////////////////////////////////////////////////////////////////////

    sa.nLength = sizeof(SECURITY_ATTRIBUTES);

    sa.bInheritHandle = true;

    sa.lpSecurityDescriptor = &sd;

    if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))

    {

        printf("ERROR: InitializeSecurityDescriptor\\n");

        return 1;

    }

    if (!SetSecurityDescriptorDacl(&sd, true, 0, false))

    {

        printf("ERROR: SetSecurityDescriptorDacl\n");

        return 1;

    }

    hAckEvent = CreateEvent(&sa, false, false, L"DBWIN_BUFFER_READY");

    if (!hAckEvent)

    {

        printf("ERROR: CreateEvent(\\"DBWIN_BUFFER_READY\\")\\n");

        return 1;

    }

    hEvent = CreateEvent(&sa, false, false, L"DBWIN_DATA_READY");

    if (!hEvent)

    {

        printf("ERROR: CreateEvent(\\"DBWIN_DATA_READY\\")\\n");

        return 1;

    }

    hSharedFile = CreateFileMapping((HANDLE)-1, &sa, PAGE_READWRITE, 0, 4096, L"DBWIN_BUFFER");

    if(!hSharedFile)

    {

        printf("ERROR: CreateFileMapping(\\"DBWIN_BUFFER\\")\\n");

        return 1;

    }

    dbBuffer = static_cast<DbWinBuffer*>(MapViewOfFile(hSharedFile, FILE_MAP_READ, 0, 0, 4096));

    if(!dbBuffer)

    {

        printf("ERROR: MapViewOfFile\\n");

        return 1;

    }

    SetEvent(hAckEvent);

    DWORD pid = GetCurrentProcessId();

    printf("Tracing PID: %dnn", pid);

    for(;;)

    {            

        DWORD ret = WaitForSingleObject(hEvent, INFINITE);

        if (ret == WAIT_FAILED)

        {

            printf("ERROR: WaitForSingleObject\\n");

            return 1;

        }

        if (dbBuffer->dwProcessId == pid)

        {

            printf("%s", dbBuffer->data);

        }

        SetEvent(hAckEvent);

    }

// Stuff contents of XML resource into the edit box

// FindResource, LoadResource, LockResource, SizeofResource

HRSRC hResource = FindResource(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_CUSTOMXML), _T("XML") );

HGLOBAL hMem = LoadResource(AfxGetResourceHandle(), hResource);

LPCSTR pResource = (LPCSTR) LockResource(hMem);

DWORD dwSize = SizeofResource(AfxGetResourceHandle(), hResource);

LPSTR pXMLBuf = new char[dwSize+1];

CopyMemory (pXMLBuf, pResource, dwSize);

pXMLBuf[dwSize] = '\0';

CString temp(pXMLBuf);

m_editXML.SetWindowText(temp);

// Cleanup

delete[] pXMLBuf;

FreeResource(hMem);

for(long i=0; i<10000; i++)

{

        // do something

        if( GetAsyncKeyState(VK_ESCAPE) & 0x8000)

        {

               MessageBeep(-1);

               break;

        }

}

// Assume that there is a worker thread that processes records and

// posts a WM_NEWRECORD message for each new record.

BOOL WaitForNRecords(HANDLE h, UINT cRecordsExpected)

{

    MSG msg;

    UINT cRecords = 0;

    while (true) {

        switch (MsgWaitForMultipleObjects(1, &h,

            FALSE, INFINITE, QS_ALLINPUT)) {

    case WAIT_OBJECT_0:

        DoSomethingWith(h); // event has been signalled

        break;

    case WAIT_OBJECT_1:

        // we have a message - peek and dispatch it

        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {

            TranslateMessage(&msg);

            DispatchMessage(&msg);

        }

        if (SendMessage(hwndNotify, WM_GETRECORDCOUNT,

            0, 0) >= cRecordsExpected) {

                return TRUE; // we got enough records

        }

        break;

    default:

        return FALSE; // unexpected failure

        }

    }

}

ATLINLINE ATLAPI_(BOOL) AtlWaitWithMessageLoop(HANDLE hEvent)

{

    DWORD dwRet;

    MSG msg;

    while(1)

    {

        dwRet = MsgWaitForMultipleObjects(1, &hEvent, FALSE, INFINITE, QS_ALLINPUT);

        if (dwRet == WAIT_OBJECT_0)

            return TRUE;    // The event was signaled

        if (dwRet != WAIT_OBJECT_0 + 1)

            break;          // Something else happened

        // There is one or more window message available. Dispatch them

        while(PeekMessage(&msg,0,0,0,PM_NOREMOVE))

        {

            // check for unicode window so we call the appropriate functions

            BOOL bUnicode = ::IsWindowUnicode(msg.hwnd);

            BOOL bRet;

            if (bUnicode)

                bRet = ::GetMessageW(&msg, NULL, 0, 0);

            else

                bRet = ::GetMessageA(&msg, NULL, 0, 0);

            if (bRet > 0)

            {

                ::TranslateMessage(&msg);

                if (bUnicode)

                    ::DispatchMessageW(&msg);

                else

                    ::DispatchMessageA(&msg);

            }

            if (WaitForSingleObject(hEvent, 0) == WAIT_OBJECT_0)

                return TRUE; // Event is now signaled.

        }

    }

    return FALSE;

}

class CSimpleLock

{

public:

// Lock

CSimpleLock(HANDLE hMutex)

{

m_hMutext = hMutex;

WaitForSingleObject(hMutext, INFINITE);

}

// Unlock

~CSimpleLock()

{

ReleaseMutex(m_hMutex);

}

private:

HANDLE m_hMutex;

};