지나간 삶

//////////////////////////////////////////////////////////////////////////////////////
// 이름없는파이프.cpp - HelloExe 에 파이프를 통해서 인자로  문자열을 보낸다.
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    // 이름 없는 파이프 만들기
    HANDLE hRead, hWrite;
    // 파이프가 내부적으로 사용할 버퍼크기..
    CreatePipe( &hRead, &hWrite, 0, 1024 );

    // 파이프를 다른 프로세스에 전달한다.
    // 1. 상대가 이미 실해중이라면 DuplicateHandle()로 복사후 메시지를 사용해서 핸들전달.
    // 2. 상속을 사용해서 자식프로세스에 전달..

    SetHandleInformation( hRead, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );

    PROCESS_INFORMATION pi;
    STARTUPINFO si = { sizeof( si ) };

    // 명령형 전달인자를 사용해서 pipe 핸들을 전달해 준다.
    char cmd[256] = "";
    wsprintf( cmd, "HelloExe.exe %d" , hRead );

    BOOL b = CreateProcess( 0, cmd, 0, 0, TRUE, // 상속
                            CREATE_NEW_CONSOLE, 0, 0, &si, &pi );

    if ( b )
    {
        CloseHandle( pi.hProcess );
        CloseHandle( pi.hThread );
        CloseHandle( hRead );
    }

    while( 1 )
    {
        char data[256] = { 0 };
        printf( "전달할 data >> " );
        gets( data );

        // 파이프에 적는다. - 파이프도 결국 파일 이다.
        DWORD len;
        WriteFile( hWrite, data, 256, &len, 0 );
    }
}

//////////////////////////////////////////////////////////////////////////////////////
// HelloExe.cpp - 인자로 문자열을 읽어온다.
//////////////////////////////////////////////////////////////////////////////////////
int main( int argc, char* argv[] )
{
    HANDLE hRead = (HANDLE)(atoi(argv[1]));

    while( 1 )
    {
        char buf[256] = { 0 };
        DWORD len;

        ReadFile( hRead, buf, 256, &len, 0 );

        printf( "읽어온 Data : %s\n", buf );
    }
}

//////////////////////////////////////////////////////////////////////////////////////
// TimeServer.cpp - 클라이언트에 현재시간을 보내줄 서버..
//////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI TimeServer( void* p )
{
    // 최대 생성가능한 스레드는 운영체제마다 다르당~.
    HANDLE hPipe = CreateNamedPipe(
        "\\\\.\\pipe\\TimeServer",  // 이름
        PIPE_ACCESS_OUTBOUND,          // 출력 전용
        PIPE_TYPE_MESSAGE,                // 메시지 방식( UDP 방식 )
        PIPE_UNLIMITED_INSTANCES,      // 최대생성 가능한 Instance - 멀티스레드 관련
        1024, 1024,                                  // 입출력 버퍼( 권장 사항~ )
        1000,                                          // WaitNamedPipe() 로 대기 가능한 시간
        0 );                                            // 보안

    if( hPipe == INVALID_HANDLE_VALUE ) // -1
    {
        printf( "Fail To CreateNamedPipe\n" );
        return 0;
    }
    /////////////////////////////////////////////////////////////////
    while( 1 )
    {
        // 클라이언트가 접속할 때까지 대기 한다.
        BOOL b = ConnectNamedPipe( hPipe, 0 );  // 접속 대기

        // 이미 접속된 경우는 성공으로 처리 해준다.
        if ( b == FALSE && GetLastError() == ERROR_PIPE_CONNECTED )
            b = TRUE;

        if( b )
        {
            SYSTEMTIME st;
            GetSystemTime( &st );   // UTC

            // pipe는 결국 파일 처럼 취급된다.
            DWORD len;
            WriteFile( hPipe, &st, sizeof(st), &len, 0 );

            FlushFileBuffers( hPipe );  // 버퍼를 비운다.( C의 fflush )
            DisconnectNamedPipe( hPipe );
        }
    }
}

int main()
{
    // 멀티 스레드를 지원 할 수 있다.
    HANDLE hThread1 = CreateThread( 0, 0, TimeServer, 0, 0, 0 );
    HANDLE hThread2 = CreateThread( 0, 0, TimeServer, 0, 0, 0 );
    HANDLE hThread3 = CreateThread( 0, 0, TimeServer, 0, 0, 0 );
   
    getch();
}

///////////////////////////////////////////////////////////////////////////////////////
// TimeClient.cpp - 서버에 접속하여 시간을 얻어온다.
///////////////////////////////////////////////////////////////////////////////////////
int main()
{
    HANDLE hPipe = CreateFile(
        "\\\\.\\pipe\\TimeServer",
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        0 );

    if( hPipe == INVALID_HANDLE_VALUE )
    {
        printf( "파이프에 접속할 수 없습니다.\n" );
        return 0;
    }

    /////////////////////
    SYSTEMTIME st;
    DWORD len;
    ReadFile( hPipe, &st, sizeof(st), &len, 0 );

    // UTC -> 지역시간으로
    ::SystemTimeToTzSpecificLocalTime( 0, &st, &st );

    // 화면에 출력
    char s1[256];
    char s2[256];

    GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, 0, s1, 256 );
    GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, 0, s2, 256 );

    printf( "%s - %s\n", s1, s2 );

    getch();

    CloseHandle( hPipe );
}

////////////////////////////////////////////////////////////////////////////////////////
// 클리보드 내용 읽어오기.cpp
////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    char data[4096] = {0};

    if ( OpenClipboard(0))
    {
        if ( IsClipboardFormatAvailable( CF_TEXT ) )
        {
            HANDLE hData = GetClipboardData( CF_TEXT );
           
            char* pData = (char*)GlobalLock( hData );
            strcpy( data, pData);
            GlobalUnlock( hData );
        }
        CloseClipboard();
    }
    printf("읽어온 Data : %s\n", data);
}
////////////////////////////////////////////////////////////////////////////////////////
// 클리보드 내용 쓰기.cpp
////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    // 클립보드에 data전달하는 방법.
    char data[256];
    gets( data );
    // 클립 보드에 보내기 위한 메모리 할당 - 이동 가능한 Global 메모리
    HANDLE hData = GlobalAlloc( GMEM_MOVEABLE, 256);

    // Global힙은 동기화를 위해 Lock을 걸어야 한다.
    char* pData = (char*)GlobalLock( hData );
    strcpy( pData, data );
    GlobalUnlock(hData );

    if ( OpenClipboard( 0 ) )
    {
        EmptyClipboard();
        SetClipboardData( CF_TEXT, hData );
        CloseClipboard();
    }
    else
    {
        printf("클립 보드를 열수 없습니다.\n");
    }
}

////////////////////////////////////////////////////////////////////////////////////////
// Send.cpp - WM_COPYDATA , COPYDATASTRUCT 구조체를 LPARAM에 담아서 보낸다.
////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    HWND hwnd = FindWindow( 0, "B" );

    if ( hwnd == 0 )
    {
        printf("B를 먼저 실행해 주세요.\n");
        return 0;
    }
    while( 1 )
    {
        char data[256];
        printf( "전송할 메시지 >> " );
        gets( data );

        // 다른 프로세스로 전송한다.
        COPYDATASTRUCT cds;
        cds.cbData = sizeof( data );    // 전송할 메모리 크기
        cds.dwData = 1;                 // 식별자 32비트.. 원하는 용도로 사용
        cds.lpData = data;              // 전송할 메모리 주소

        // WM_COPYDATA는 포인터 전달이 가능하다.
        SendMessage( hwnd, WM_COPYDATA, 0, (LPARAM)&cds );;
    }
}

////////////////////////////////////////////////////////////////////////////////////////
// B.cpp - WM_COPYDATA 메시지를 처리한다.
////////////////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static char* pData;
    static char buf[256]; switch( msg )
    {   
    case WM_COPYDATA:
        {
            COPYDATASTRUCT* p = (COPYDATASTRUCT*) lParam;

            if( p->dwData == 1 )    // 식별자 조사
            {
                // static 변수에 주소 보관 했다면??
                // 다시 쓰고자 할때잘못된 값을 읽는다.
                pData = (char*)(p->lpData);

                // 참조 했던값을 복사해서 보관 해 둔다.
                strcpy( buf, (char*)(p->lpData) );

                MessageBox( 0, pData, "", MB_OK );
            }
        }
        return 0;
    case WM_LBUTTONDOWN:
        MessageBox( 0, pData, "", MB_OK );
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

#define _WIN32_WINNT 0x0501
#define WINVER       0x0501

#include <conio.h>
#include <stdio.h>
#include <windows.h>
#include <process.h>

unsigned __stdcall Thread( void* p )
{
    for( int i = 0; i < 5; ++i )
    {
        printf( "busy...\n" );
        Sleep(1000);
    }
    while( 1 )
    {
        //APC Q의 함수를 실행한다.
        SleepEx( INFINITE, TRUE );  // TRUE : APCQ에 작업이 들어오면 실행하라.
    }
    return 0;
}

// APC Q에 넣기 위한 함수
void CALLBACK foo( ULONG_PTR param )
{
    while( 1 )
    {
        printf( "foo...\n");
        Sleep(1000);
    }
}

int main()
{
    HANDLE hThread = (HANDLE)_beginthreadex( 0, 0, Thread, 0, 0, 0 );
    Sleep(1000); // APCQ를 확인할 시간을 벌어준다. 비어있는가를 확인한다.
    QueueUserAPC( foo, hThread, 0 );    // 함수, 실행할 스레드, 파라미터

    printf( "main...\n" );
    getch();

    CloseHandle( hThread );
}

int main()
{
    HANDLE hFile = CreateFile(
        "COM1", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0 );  // 비동기 옵션OVERLAP

    if ( hFile == INVALID_HANDLE_VALUE )
    {
        printf( "Com1을 Open 할 수 없습니다.\n" );
        return 0;
    }
    const int sz = 1024;
    char data[sz];
    DWORD len;
   
    printf( "출력 시작\n" );

    // 비동기 작업시 반드시 OVERLAPPED 구조체를 제공해야 한다.
    OVERLAPPED ov = { 0 };
    ov.Internal = 0;
    ov.InternalHigh = 0;    // OS가 내부적으로 사용. 항상 0으로
    ov.Offset = 0;
    ov.OffsetHigh = 0;      // Fie Offset
    ov.hEvent = CreateEvent( 0, 0, 0, "e1" );

    BOOL b = WriteFile( hFile, data, sz, &len, &ov );   // 비동기 구조체를 넘김

    if ( b == TRUE )
        printf( "동기적으로 쓰기 완료\n" );
    else if ( b == FALSE && GetLastError() == ERROR_IO_PENDING )
    {
        printf( "비동기 작업중\n" );

        // 화일은 쓰기를 마치면 Signal이 된다.
        // 파일에 여러개의 비동기가 걸리면 문제가 된다.이벤트를 사용 못함...ㅠ_ㅠ
        WaitForSingleObject( hFile, INFINITE ); // 장치의 KO가 signal 이 되기를 기다림

        printf( "비동기 작업 완료\n" );
    }
    else
        printf( "실패\n" );

    CloseHandle( hFile );
    getch();

}

int main()
{
    HANDLE hFile = CreateFile(
        "COM1", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0 );  // 비동기 옵션OVERLAP

    if ( hFile == INVALID_HANDLE_VALUE )
    {
        printf( "Com1을 Open 할 수 없습니다.\n" );
        return 0;
    }
    const int sz = 1024;
    char data[sz];
    DWORD len;
   
    printf( "출력 시작\n" );

    // 비동기 작업시 반드시 OVERLAPPED 구조체를 제공해야 한다.
    OVERLAPPED ov = { 0 };
    ov.Internal = 0;
    ov.InternalHigh = 0;    // OS가 내부적으로 사용. 항상 0으로
    ov.Offset = 0;
    ov.OffsetHigh = 0;      // Fie Offset
    ov.hEvent = CreateEvent( 0, 0, 0, "e1" );

    BOOL b = WriteFile( hFile, data, sz, &len, &ov );   // 비동기 구조체를 넘김

    if ( b == TRUE )
        printf( "동기적으로 쓰기 완료\n" );
    else if ( b == FALSE && GetLastError() == ERROR_IO_PENDING )
    {
        printf( "비동기 작업중\n" );

        // 작업당 1개씩 전달된 Event 객체를 대기한다.
        HANDLE h[2] = { ov.hEvent, CreateEvent( 0, 0, 0, "CancelEvent") };
        DWORD ret = WaitForMultipleObjects( 2, h, FALSE, INFINITE );

        if ( ret == WAIT_OBJECT_0+1 )
        {
            // 비동기를 취소하면 된다.
            CancelIo( hFile );
        }
        printf( "비동기 작업 완료\n" );
    }
    else
        printf( "실패\n" );

    CloseHandle( hFile );
    getch();

}

// Callback 함수 사용 APCQ에 넣는다.
// 비동기를 요청한 스레드와 대기하는 스레드를 분리 시켜줘야 한다.
VOID CALLBACK foo( DWORD e, DWORD bytes, OVERLAPPED* p )
{
    printf( "작업완료 : %d\n", bytes );
}

int main()
{
    HANDLE hFile = CreateFile(
        "COM1", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0 );  // 비동기 옵션OVERLAP

    if ( hFile == INVALID_HANDLE_VALUE )
    {
        printf( "Com1을 Open 할 수 없습니다.\n" );
        return 0;
    }
    const int sz = 1024;
    char data[sz];
    DWORD len;

    printf( "출력 시작\n" );

    // 비동기 작업시 반드시 OVERLAPPED 구조체를 제공해야 한다.
    OVERLAPPED ov = { 0 };
    ov.Internal = 0;
    ov.InternalHigh = 0;    // OS가 내부적으로 사용. 항상 0으로
    ov.Offset = 0;
    ov.OffsetHigh = 0;      // Fie Offset
    ov.hEvent = CreateEvent( 0, 0, 0, "e1" );

    // 비동기 전용함수 - 비동기 작업이 종료되면 현재스레드의 APCQ에 foo가 놓인다.
    BOOL b = WriteFileEx( hFile, data, sz, &ov, foo );  // len은 끝나야 알수 있다.

    // 얼러터블 상태로 들어가야 APCQ가 실행된다.
    SleepEx( INFINITE, TRUE );
 
    CloseHandle( hFile );
    getch();
}

// 비동기를 요청한 스레드와 대기하는 스레드를 분리 시켜줘야 한다.
VOID CALLBACK foo( DWORD e, DWORD bytes, OVERLAPPED* p )
{
    printf( "작업완료 : %d\n", bytes );
}

DWORD WINAPI IOCPWait( void* p )
{
    HANDLE hPort = (HANDLE)p;

    DWORD id;
    DWORD byte;
    OVERLAPPED* pov;

    while( GetQueuedCompletionStatus( hPort, &byte, &id, &pov, INFINITE ) )
    {
        OVERLAPPED_PLUS* p = (OVERLAPPED_PLUS*)pov;
        // 화일 ID, 실제 작업한 크기
        printf( "작업 완료 : %d %d %d\n", id, byte, p->workID );
    }
    return 0;
}

int main()
{
    HANDLE hFile = CreateFile(
        "COM1", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0 );  // 비동기 옵션OVERLAP

    if ( hFile == INVALID_HANDLE_VALUE )
    {
        printf( "Com1을 Open 할 수 없습니다.\n" );
        return 0;
    }
    // 입출력 완료 포트(IOCP)를 생성한다.
    HANDLE hPort = CreateIoCompletionPort(
        INVALID_HANDLE_VALUE,   // IOCP에 연결할 파일
        0,                      // 이미 존재하는 IOCP 핸들
        0,                      // 완료 키
        2 );                    // IOCP에서 대기할 수 있는 스레드 갯수

    //IOCP 와 비동기 파일을 연결한다.
    CreateIoCompletionPort( hFile, hPort, 1, 2 );

    // 스레드를 생성해서 IOCP를 대기 하게 한다.
    HANDLE hThread = CreateThread( 0, 0, IOCPWait, (void*)hPort, 0, 0 );
    ////////////////////////////////////////////////////////////////////////
    const int sz = 1024;
    char data[sz];
    DWORD len;

    printf( "출력 시작\n" );

    // 비동기 작업시 반드시 OVERLAPPED 구조체를 제공해야 한다.
    OVERLAPPED ov;
    memset( &ov, 0, sizeof(ov) );
    ov.Internal = 0;
    ov.InternalHigh = 0;    // OS가 내부적으로 사용. 항상 0으로
    ov.Offset = 0;
    ov.OffsetHigh = 0;      // Fie Offset
    ov.hEvent = CreateEvent( 0, 0, 0, "e1" );

    // 새로운 스레드를 만들어서 비동기 작업을 대기하게 한다.
    HANDLE hThread = CreateThread( 0, 0, Wait, (void*)&ov, 0, 0 );

    BOOL b = WriteFile( hFile, data, sz, &len, &ov );  // len은 끝나야 알수 있다.
 
    // 주스레드는 그냥..다른 작업을 계속한다.
    printf( "비동기 작업 요청완료\n");
    getch();

    // 주스레드는 그냥 다른 작업을 계속한다.( 대기는 다른스레드가 하게 한다. )
    CloseHandle( hFile );
    getch();
}

// IOCP 에서 완료된 작업을 처리할 스레드
// 작업 ID를 관리하기 위해 OVERLAPPED를 확장한다. 상속 또는 포함
struct OVERLAPPED_PLUS : public OVERLAPPED
{
    DWORD workID;
};

DWORD WINAPI IOCPWait( void* p )
{
    HANDLE hPort = (HANDLE)p;

    DWORD id;
    DWORD byte;
    OVERLAPPED* pov;

    while( GetQueuedCompletionStatus( hPort, &byte, &id, &pov, INFINITE ) )
    {
        OVERLAPPED_PLUS* p = (OVERLAPPED_PLUS*)pov;
        // 화일 ID, 실제 작업한 크기
        printf( "작업 완료 : %d %d %d\n", id, byte, p->workID );
    }
    return 0;
}

int main()
{
    HANDLE hFile = CreateFile(
        "COM1", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0, OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0 );  // 비동기 옵션OVERLAP

    if ( hFile == INVALID_HANDLE_VALUE )
    {
        printf( "Com1을 Open 할 수 없습니다.\n" );
        return 0;
    }
    // 입출력 완료 포트(IOCP)를 생성한다.
    HANDLE hPort = CreateIoCompletionPort(
        INVALID_HANDLE_VALUE,   // IOCP에 연결할 파일
        0,                      // 이미 존재하는 IOCP 핸들
        0,                      // 완료 키
        2 );                    // IOCP에서 대기할 수 있는 스레드 갯수

    //IOCP 와 비동기 파일을 연결한다.
    CreateIoCompletionPort( hFile, hPort, 1, 2 );

    // 스레드를 생성해서 IOCP를 대기 하게 한다.
    HANDLE hThread = CreateThread( 0, 0, IOCPWait, (void*)hPort, 0, 0 );
    ////////////////////////////////////////////////////////////////////////
    const int sz = 1024;
    char data[sz];
    DWORD len;

    printf( "출력 시작\n" );

    // 비동기 작업시 반드시 OVERLAPPED 구조체를 제공해야 한다.
    OVERLAPPED_PLUS ov;
    memset( &ov, 0, sizeof(ov) );
    ov.Internal = 0;
    ov.InternalHigh = 0;    // OS가 내부적으로 사용. 항상 0으로
    ov.Offset = 0;
    ov.OffsetHigh = 0;      // Fie Offset
    ov.hEvent = CreateEvent( 0, 0, 0, "e1" );
    ov.workID = 1;

    BOOL b = WriteFile( hFile, data, sz, &len, &ov );  // len은 끝나야 알수 있다.

    OVERLAPPED_PLUS ov2;
    memset( &ov2, 0, sizeof(ov2) );
    ov2.workID = 2;
    BOOL b2 = WriteFile( hFile, data, sz, &len, &ov2 );

    // 주스레드는 그냥..다른 작업을 계속한다.
    printf( "비동기 작업 요청완료\n");
    getch();

    // 주스레드는 그냥 다른 작업을 계속한다.( 대기는 다른스레드가 하게 한다. )
    CloseHandle( hFile );
    getch();
}

// API Hooking 의 개념 - DLL 함수 호출의 원리
typedef UINT ( WINAPI* F )( HWND, PCSTR, PCSTR, UINT );

UINT WINAPI foo( HWND hwnd, PCSTR msg, PCSTR caption, UINT btn )
{
    printf( "foo : %x, %s, %s \n", hwnd, msg, caption );

    // 원래 함수로 다시 보낸다.
    // MessageBoxA();  // 재귀호출을 한다..

    HMODULE hDll = GetModuleHandle("User32.dll");
    F f = (F)GetProcAddress( hDll, "MessageBoxA" );

    return f( hwnd, msg, caption, btn );
}

int main()
{
    printf( "%p\n", GetModuleHandle("User32.dll") );
    printf( "%p\n", MessageBoxA );

    // .idata section 에서 MessageBoxA의 주소를 담은 곳을 foo의 주소로 변경한다.
    // 주소에 타입없이 대입시킨다면 호출시 읽어 올수가 없다.
    // 그러므로 int 로 강제 형변환 해준다.
    *((int*)(0x00418338)) = (int)foo;

    MessageBoxA( 0, "Hello", "", MB_OK);    // User32.dll 에 있다.
}

#include "Dbghelp.h"

#pragma comment( lib, "Dbghelp.lib" )

// 제프리책 853p 에 있는 코드들~

void Replace( HMODULE hDll,     // exe의 주소
              char*   name,     // 후킹할 함수를 가진 dll의 이름
              PROC    oldfunc,  // 원래 API함수의 주소
              PROC    newfunc ) // 후킹할 함수
{
    // .exe에서 .idata section의 주소를 얻는다.
    ULONG sz;
    IMAGE_IMPORT_DESCRIPTOR* pImage = (IMAGE_IMPORT_DESCRIPTOR*)
        ImageDirectoryEntryToData( hDll,    // 모듈 주소
                                   TRUE,    // Mapping?
                                   IMAGE_DIRECTORY_ENTRY_IMPORT,
                                   &sz );

    printf( ".idata의 주소 : %p\n", pImage );

    // 2. User32.dll 의 항목을 구한다.
    for( ; pImage->Name; ++pImage )
    {
        char* p = (char*)hDll + pImage->Name;
        if( strcmpi( p, name ) == 0 ) break;        //찾은경우
    }
    if ( pImage->Name == 0 )
    {
        printf( "User32.dll을 import 하지 않습니다.\n" );
        return;
    }
    printf( "User32.dll를 관리하는 구조체 주소 : %p\n", pImage );

    // 3. Thunk Table에서 원하는 함수를 찾는다.
    IMAGE_THUNK_DATA* pThunk = (IMAGE_THUNK_DATA*)
        ( (char*)hDll + pImage->FirstThunk );

    // 4. 이제 함수를 찾아서 새로운 함수 주소를 덮어 쓴다.
    for ( ; pThunk->u1.Function; ++pThunk )
    {
        if( (PROC)(pThunk->u1.Function) == oldfunc )
        {
            PROC* p = (PROC*)&(pThunk->u1.Function);

            // Release 모드에서는 가상주소를 보호해준다.
            // 그러므로 보호속성을 R/W로 변경해야 한다.
            DWORD old;
            VirtualProtect( p, sizeof(PROC), PAGE_READWRITE, &old );
            // 쓰기를 할때는 WriteProcessMemory() 함수를 사용핮.
            WriteProcessMemory( GetCurrentProcess(), p, &newfunc, sizeof(PROC), 0 );                                
        }
    }
}

typedef UINT ( WINAPI* F )( HWND, PCSTR, PCSTR, UINT );

UINT WINAPI foo( HWND hwnd, PCSTR msg, PCSTR caption, UINT btn )
{
    printf( "foo : %x, %s, %s \n", hwnd, msg, caption );

    // 원래 함수로 다시 보낸다.
    // MessageBoxA();  // 재귀호출을 한다..

    HMODULE hDll = GetModuleHandle("User32.dll");
    F f = (F)GetProcAddress( hDll, "MessageBoxA" );

    return f( hwnd, msg, caption, btn );
}

void Setup()
{
    Replace( GetModuleHandle(0), "User32.dll", (PROC)MessageBoxA, (PROC)foo );
}

int main()
{
    Setup();

    printf( "%p\n", GetModuleHandle("User32.dll") );
    printf( "%p\n", MessageBoxA );  // Release 모드에서는 이 순간 MessageBoxA의 주소를
                                    // ECX 레지스터에 보관해둔다.
    // Replace( GetModuleHandle(0), "User32.dll", (PROC)MessageBoxA, (PROC)foo );

    MessageBoxA( 0, "Hello", "", MB_OK);    // User32.dll 에 있다.
}

// SEH : structual Exception Handling
int n = 0;

DWORD Filter( DWORD code )
{
    if ( code == EXCEPTION_INT_DIVIDE_BY_ZERO ) // 0xc0000094
    {
        printf( "0으로 나누는 예외 발생. 다른값을 입력 : " );
        scanf("%d", &n);

        return -1;  // 예외의 원인을 수정했으므로 다시 실행해 본다.
    }
    return 1;
}

int main()
{
    int s = 0;

    __try
    {
        s = 10 / n ; // Code : 0xc0000094

        char* p = 0;
        *p = 'A';   // access - violation Code : 0xc0000005
       
        printf( "%d\n", s );
    }
    // 1: 핸들러 수행, -1: 예외난곳을 다시 실행 0: 외부의 __try블록으로 전달.
    __except( Filter( GetExceptionCode() ) )
    {
        printf( "예외발생: %x\n", GetExceptionCode() );
    }
    printf("프로그램은 계속 실행\n");
}

// C++예외 e06d7363 를 발생시키기!!!!!!!!
int main()
{
    __try
    {
        throw 1;    // C++ 예외...
    }
    __except( 1 )
    {
        printf("예외 번호 : %x\n", GetExceptionCode() );
    }
}

DWORD foo()
{
    DWORD ret = 0;

    __try
    {
        // 성능이 떨어질 수 있으므로 return은 자제하자.!!!
        return ret; // 이순간 리턴값을 잠시 스택에 보관하고
                    // finally 를 실행한 후에 .. 리턴값을 다시 꺼내서 리턴.
    }
    __finally
    {
        BOOL b = AbnormalTermination();

        if ( b == TRUE )
        {
            printf("__try를 탈출하는 코드(리턴,예외) 발생..\n");
        }
        else
        {
            printf("....\n");
        }
        printf( "이 부분은 try를 벗어나려고 하면 항상 호출됩니다.\n" );
    }
    return 0;
}

int main()
{
    int s = foo();

    printf( "%d\n", s );
}

// STH를 사용하는 의사코드..
// One Entry Multiple Exit
BOOL foo()
{
    HANDLE hFile = INVALID_HANDLE_VALUE;    // -1
    BOOL   ret = FALSE;
    char*  buf = 0;

    hFile = CreateFile(...);
    if ( hFile == -1 ) return FALSE;

    buf = new char[1000];
    if ( buf == 0 ) return FALSE;

    ret = ReadFile(...);
    if ( ret == FALSE ) { CloseHandle( hFile ); delete[] buf;
        return FALSE;
    }

    // 성공...
    CloseHandle( hFile );
    delete[] buf;

    return TRUE;
}
///////////////////////////////////////////////////////////
BOOL foo()
{
    HANDLE hFile = INVALID_HANDLE_VALUE;    // -1
    BOOL   ret = FALSE;
    char*  buf = 0;

    hFile = CreateFile(...);
    if ( hFile != -1 )
    {
        buf = new char[1000];
        if ( buf != 0 )
        {
            ret = ReadFile(...);
            if ( ret != FALSE )
            {
                // 성공.....
            }
            delete[] buf;
        }
        CloseHandle( hFile );
    }

    return ret;
}
///////////////////////////////////////////////////////////
// 모든 자원관리를 한군데로 몰아서 한다.
// return 은 성능에 문제를 주므로 __leave 를 써서 finally로 간다.
// STH를 사용한 자원 관리 기법 - 23장(제프리)
////////////////////////////////////////////////////////
BOOL foo()
{
    // 필요한 변수를 실패값으로 초기화 해서 만들어라.
    HANDLE hFile = INVALID_HANDLE_VALUE;    // -1
    BOOL   ret = FALSE;
    char*  buf = 0;

    // __try 안에서 자원 할당과 사용을 한다.
    __try
    {
        hFile = CreateFile(...);
        if ( hFile == -1 )  __leave; // goto __finally

        buf = new char[1000];
        if ( buf == 0 )     __leave;

        ret = ReadFile(...);
        if ( ret == FALSE ) __leave;
    }
    __finally
    {
        // 이부분은 반드시 실행됨이 보장된다. 자원해지.
        if ( buf != 0 ) delete[] buf;
        if ( hFile != INVALID_HANDLE_VALUE ) CloseHandle( hFile );
    }

    return ret;
}

struct CELL
{
    char data[4096-5];   // 1Page- 5byte..
};

int main()
{
    // 필요한 CELL 만큼 가상주소를 예약한다.
    CELL* pTable = (CELL*)VirtualAlloc( 0, sizeof(CELL)*1000,
                                        MEM_RESERVE, PAGE_NOACCESS );

    printf( "예약된 주소 : %p\n", pTable );

    while( 1 )
    {
        int no = 0;
        char data[4096] = { 0 };

        printf( "CELL 번호 >> " );
        scanf( "%d", &no );

        printf( "DATA >> " );
        scanf( "%s", data );
        /////////////////////////////////
        __try
        {
            // 확정된 데이타에 더 작은 데이터를 넣는다면 에러가 나오지 않는다.!!
            strcpy( pTable[no].data, data );
        }
        __except( 1 )
        {
            printf( "%d CELL을 확정 합니다.\n", no );

            VirtualAlloc( &pTable[no], sizeof(CELL), MEM_COMMIT, PAGE_READWRITE );

            // 이제 다시 복사한다.
            strcpy( pTable[no].data, data );
        }       
    }
}

////////////////////////////////////////////////////////////////////////////////
// SpeedHook.dll 만들기
////////////////////////////////////////////////////////////////////////////////
#include <dbghelp.h>

#pragma comment( lib, "dbghelp.lib" )

typedef UINT_PTR (WINAPI* F)( HWND, UINT_PTR, UINT, TIMERPROC ); void Replace( HMODULE hDll,     // exe의 주소
              char*   name,     // 후킹할 함수를 가진 dll의 이름
              PROC    oldfunc,  // 원래 API함수의 주소
              PROC    newfunc ) // 후킹할 함수
{
    // .exe에서 .idata section의 주소를 얻는다.
    ULONG sz;
    IMAGE_IMPORT_DESCRIPTOR* pImage = (IMAGE_IMPORT_DESCRIPTOR*)
        ImageDirectoryEntryToData( hDll,    // 모듈 주소
                                   TRUE,    // Mapping?
                                   IMAGE_DIRECTORY_ENTRY_IMPORT,
                                   &sz );

    // 2. User32.dll 의 항목을 구한다.
    for( ; pImage->Name; ++pImage )
    {
        char* p = (char*)hDll + pImage->Name;
        if( strcmpi( p, name ) == 0 ) break;        //찾은경우
    }
    if ( pImage->Name == 0 )
    {
        return;
    }

    // 3. Thunk Table에서 원하는 함수를 찾는다.
    IMAGE_THUNK_DATA* pThunk = (IMAGE_THUNK_DATA*)
        ( (char*)hDll + pImage->FirstThunk );

    // 4. 이제 함수를 찾아서 새로운 함수 주소를 덮어 쓴다.
    for ( ; pThunk->u1.Function; ++pThunk )
    {
        if( (PROC)(pThunk->u1.Function) == oldfunc )
        {
            PROC* p = (PROC*)&(pThunk->u1.Function);

            DWORD old;
            VirtualProtect( p, sizeof(PROC), PAGE_READWRITE, &old );

            WriteProcessMemory( GetCurrentProcess(), p, &newfunc, sizeof(PROC), 0 );
        }
    }
}

UINT_PTR MyTimer( HWND hwnd, UINT_PTR id, UINT ms, TIMERPROC f )
{
    HMODULE h = GetModuleHandle( "user32.dll" );
    F func = (F)GetProcAddress( h, "SetTimer" );

    // 원래 함수를 호출한다.
    return func( hwnd, id, ms/10, f );
}

void Setup()
{
    Replace( GetModuleHandle(0), "user32.dll", (PROC)SetTimer, (PROC)MyTimer );
}

BOOL WINAPI DllMain( HANDLE h, DWORD r, LPVOID how )
{
    if ( r == DLL_PROCESS_ATTACH )
    {
       Setup();
    }
    return TRUE;
}

void DLLInject( DWORD pid, const char* path )
{
    HANDLE hProcess = OpenProcess(
        PROCESS_QUERY_INFORMATION | // 프로세스의 정보 요청
        PROCESS_CREATE_THREAD | // CreateRemoteThread를 사용하기 위해
        PROCESS_VM_OPERATION | // VirtualAllocEx/VirtualFreeEx를 사용하기 위해
        PROCESS_VM_WRITE,
        0, pid );
    //---------------------------------------------------------
    // LoadLibrary 의 주소를 찾는다.
    HMODULE hDll = GetModuleHandle( "Kernel32.dll");

    PTHREAD_START_ROUTINE f = (PTHREAD_START_ROUTINE)
                              GetProcAddress( hDll, "LoadLibraryA");
   
    // PTHREAD_START_ROUTINE 은 미리 정의된 스레드함수포인터 type이다.!!!

    // 계산기의 가상주소 공간에 메모리를 할당한다.
    void* p = VirtualAllocEx( hProcess, 0, strlen(path)+1,
                            MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);

    // Inject 할 DLL의 경로를 계산기 메모리에 복사해 놓는다.

    DWORD len;
    WriteProcessMemory( hProcess, p, path, strlen(path)+1, &len);


    //---------------------------------------------------------
    // 다른 프로세스에 스레드를 생성한다.
    HANDLE hThread = CreateRemoteThread( hProcess, 0, 0,
                                        f, (void*)p, // 함수, 파라미터.
                                        0, 0);

    WaitForSingleObject( hThread, INFINITE );

    CloseHandle( hThread );
    VirtualFreeEx( hProcess, p, sizeof(path), MEM_RELEASE );


    // 대상 프로세스에서 ".dll"을 unload 한다
    // (CreateRemoteThread와 FreeLibrary를 이용하여)
    hThread = CreateRemoteThread( hProcess, NULL, 0,
        (LPTHREAD_START_ROUTINE)GetProcAddress( hDll,
        "FreeLibrary" ),
        (void*)p, 0, NULL );
    WaitForSingleObject( hThread, INFINITE );

    // Clean up
    CloseHandle( hThread );

}
int main()
{
    HWND hwnd = FindWindow( 0, "지뢰 찾기");

    if ( hwnd == 0 )
    {
        printf("계산기 부터 실행하세요..\n");
        return 0;
    }
    // 계산기 프로세스에 DLL을 강제로 넣는다.
    DWORD pid;
    DWORD tid = GetWindowThreadProcessId( hwnd, &pid );

    DLLInject( pid, "C:\\SpeedHook.dll");
    getch();
}

void print( MEMORY_BASIC_INFORMATION* p );

int main()
{
    char* addr = (char*)0x0;

    MEMORY_BASIC_INFORMATION mbi;

    while( addr < (char*)0x80000000 )
    {
        // 가상 주소 공간의 상태를 조사한다.
        VirtualQuery( addr, &mbi, sizeof(mbi) );

        print( &mbi );

        addr += mbi.RegionSize;
    }
}

void print( MEMORY_BASIC_INFORMATION* p )
{
    char* s = (char*)p->BaseAddress;
    char* e = s + p->RegionSize - 1;

    printf( "%08x ~ %08x : ", s, e );

    char* state = "unknown";
    switch ( p->State )
    {
    case MEM_FREE:        state = "Free    "; break;
    case MEM_RESERVE:    state = "Reserve";    break;
    case MEM_COMMIT:    state = "Commit";    break;
    }
    printf("%s\n", state );
}

int main()
{
    // 프로세스의 기본힙을 구한다.
    HANDLE h1 = GetProcessHeap();
    // 새로운 힙을 만든다.. 동기화 되지 않게 하고..
    // 메모리 할당 실패시 예외가 나오게 한다.
    HANDLE h2 = HeapCreate( HEAP_NO_SERIALIZE | HEAP_GENERATE_EXCEPTIONS,
                            1024*1024, // 초기크기
                            0 );       // 최대 크기( 0은 자동증가(Commit) )
    // 이제 힙에서 메모리를 할당한다.
    void* p1 = HeapAlloc( h1, HEAP_ZERO_MEMORY, 10 );
    void* p2 = HeapAlloc( h2, HEAP_ZERO_MEMORY, 10 );

    printf( "%p\n", p1 );
    printf( "%p\n", p2 );

    HeapFree( h1, 0, p1 );
    HeapFree( h2, 0, p2 );

    // 힙 파괴
    HeapDestroy( h2 );
}

// 자신 전용의 힙을 사용하는 Node
class Node
{
    static HANDLE my_heap;
    static int count;
public:
    void* operator new( size_t sz )
    {
        if( my_heap == 0 )
        {
            my_heap = HeapCreate( 0, 1024*1024, 0 );
        }
        void* p = HeapAlloc( my_heap, HEAP_ZERO_MEMORY, sz );
        ++count;
        return p;
    }
    void operator delete( void* p )
    {
        HeapFree( my_heap, 0, p );
        --count;
        if( count == 0 )    HeapDestroy( my_heap );
    }
};

HANDLE Node::my_heap = 0;
int Node::count = 0;

int main()
{
    Node* p1 = new Node;
    int*  p2 = new int;
}

// 정적 TLS : LoadLibrary를 사용하게 되면 문제가 된다.
// __declspec(thread) char* buf = 0;

DWORD index = 0; // 동적 TLS index로 사용.

extern "C" _declspec(dllexport) void SetData( char* s )
{
    char* buf = (char*) TlsGetValue( index );
    strcpy( buf, s );
}
extern "C" _declspec(dllexport) void GetData( char* s )
{
    char* buf = (char*) TlsGetValue( index );
    strcpy( s, buf );
}

BOOL WINAPI DllMain( HANDLE hDll,    // DLL 핸들, 결국 주소
                     DWORD  r,                    // DllMain 이 호출된 이유
                     LPVOID how                 // DLL이 Load된 방식( 0이면 LoadLibrary 사용 )
                    )
{
    char* buf = 0;

    switch( r )
    {
    case DLL_PROCESS_ATTACH:
///////////////////////////////////////////////////////////////////////////////////
        {
            // 특정기능을 수행
            foo();

            // DLL을 자동으로 내린다.
            // FreeLibrary( hDll ); // Dll이 내려가면 메모리에서 사라지므로 안됨.

            // 강제로 dll를 내리고 스레드를 종료한다.
            // 아래 함수를 만든이가 DLL안에서 스스로를 Free하는 기회를 주기 위해서.
            FreeLibraryAndExitThread( hDll, 0 );

            // DLL이 Load되면 동시에 스레드를 만든다.
            // HANDLE h = CreateThread( 0, 0, foo, 0, 0, 0 );    // 바이러스 검사
            // 새로운 스레드가 Wait에 막혀서 절대 실행될 수 없다.
            // 주스레드가 아직 DllMain을 나가지 못했으므로 foo를 실행하는
            // 새로운 스레드는 DllMain을 실행하기 위해 Block된 상태..
            // WaitForSingleObject( h, INFINITE );
        }
///////////////////////////////////////////////////////////////////////////////////
        //buf = (char*)HeapAlloc( GetProcessHeap(), 0, 1000 );    // 기본힙으로부터 1000byte를 할당..

        index = TlsAlloc();    // 동적 TLS에 빈슬롯 할당
        // 주스레드를 위해서 메모리 할당.
        buf = (char*)HeapAlloc( GetProcessHeap(), 0, 1000 );
        // 주소를 TLS에 보관
        TlsSetValue( index, (void*)buf );

        printf( "DLL이 Load되었습니다. 주소 : %p\n", hDll );
        printf( "%s\n", how ? "implicit linking" : "explicit linking");    // 명시적, 암시적 로드를 판단.!!
        break;
       
    case DLL_PROCESS_DETACH:
        //HeapFree( GetProcessHeap(), 0, buf );

        TlsFree( index );
        printf( "DLL이 프로세스에서 해지 됩니다.\n" );
        break;

    case DLL_THREAD_ATTACH:
        // 새로운 스레드가 생성 될 때마다 메모리를 할당해서 Thread-Safe를 보장!!
        buf = (char*)HeapAlloc( GetProcessHeap(), 0, 1000 );
        TlsSetValue( index, (void*)buf );

        printf( "스레드가 생성됩니다.\n" );
        break;

    case DLL_THREAD_DETACH:
        buf = (char*) TlsGetValue( index );
        HeapFree( GetProcessHeap(), 0, buf );

        printf( "스레드가 파괴됩니다.\n" );
        break;
    }
    return TRUE;
}

DWORD WINAPI foo( void* p )
{
    Sleep(5000);
    return 0;
}

int main()
{
    getch();
    HMODULE hDll = LoadLibrary( "DllMain.dll" );

    CloseHandle( CreateThread( 0, 0, foo, 0, 0, 0 ) );    // 스레드 생성

    getch();
    FreeLibrary( hDll );

    getch();
}

HMODULE g_hDll;        // 훅 함수를 가진 DLL의 핸들

#pragma data_seg( "AAA" )
HHOOK    g_hHook = 0;    // 훅 핸들
#pragma data_seg()

#pragma comment(linker, "/section:AAA,RWS")


BOOL WINAPI DllMain( HANDLE h, DWORD r, LPVOID how )
{
    if ( r == DLL_PROCESS_ATTACH )
    {
        g_hDll = (HMODULE)h;
    }
    return TRUE;
}
// 훅필터 함수
LRESULT CALLBACK GetMsgProc( int nCode, WPARAM wParam, LPARAM lParam )
{
    if ( nCode == HC_ACTION )        // 메시지를 꺼내 가는중..
    {
        MSG* pMsg = (MSG*)lParam;    // 꺼내가고 있는 메시지.

        if ( pMsg->message == WM_CHAR )
        {
            // 다른 곳으로 보낸다.( N/W또는 IPC사용, 또는 파일로 저장 )
            HWND hwnd = FindWindow( 0, "Friend" );
            PostMessage( hwnd, WM_USER+100, pMsg->wParam, pMsg->lParam );
        }
    }
    // 다음 번 훅필터 함수에게 전달한다.( Hook Chain )
    return CallNextHookEx( g_hHook, nCode, wParam, lParam );
}

// 훅을 설치하는 함수
extern "C" __declspec(dllexport) void Install( DWORD tid )
{
    g_hHook = SetWindowsHookEx( WH_GETMESSAGE,    // 훅의 종료(15가지)
                                GetMsgProc,        // 훅함수
                                g_hDll,            // 훅함수를 가진 DLL핸들(주소)
                                tid );            // 훅을 설치할 스레드( 0:Global hook )
}
extern "C" __declspec(dllexport) void Uninstall()
{
    UnhookWindowsHookEx( g_hHook );
}

typedef void(*INSTALL)(DWORD);
typedef void(*UNINSTALL)();

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HMODULE hDll;
    static INSTALL Install;
    static UNINSTALL Uninstall;
    static HWND hEdit;

    switch( msg )
    {   
    case WM_CREATE:

        hEdit = CreateWindow( "edit", "", WS_CHILD | WS_VISIBLE | WS_BORDER | ES_MULTILINE,
                              10, 10, 500, 500, hwnd, (HMENU)1, 0, 0 );
        hDll = LoadLibrary( "HookDll.dll" );
        Install   = (INSTALL)GetProcAddress( hDll, "Install" );
        Uninstall = (UNINSTALL)GetProcAddress( hDll, "Uninstall" );

        Install(0); // global hook 설치
        return 0;

    case WM_USER+100:
        // Edit에 WM_CHAR를 보내면 알아서 출력해 줄것이다.
        SendMessage( hEdit, WM_CHAR, wParam, lParam );
        return 0;

    case WM_DESTROY:
        Uninstall();
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

int main()
{
    const int size = 1024 * 1024 * 100;    // 100M

    char* p1 = (char*)VirtualAlloc( (void*)0, // 원하는 주소(64k배수), 자동으로 할당 0
                             size*15,            // 원하는 크기(4k 단위)
                             MEM_RESERVE,        // 예약만
                             PAGE_NOACCESS );    // 보호 속성(어짜피 접근못하므로 NOACCESS)

    printf( "예약된 주소 : %p\n", p1 );
    //*p1 = 'a';    // 예약만 된 주소를 사용하는 경우. - RunTime Error 발생..

    char* p2 = p1;
    for( int i = 0; i < 15; ++i )
    {
        getch();

        void* p3 = VirtualAlloc( p2, size, MEM_COMMIT, PAGE_READWRITE );

        printf( "확정된 메모리 : %d\n", p3 );
        p2 = p2 + size;    // 다음 확정할 주소
    }

    VirtualFree( p1, size*15, MEM_DECOMMIT );    // 다시 예약 상태로
    VirtualFree( p1, 0, MEM_RELEASE );        // 다시 Free상태로
                                                                // MEM_RELEASE 지정시 반드시 두번째인자는 0!!
}

/////////////////////////////////////////////////////////////////////////////////////
// exe 로드해서 IMAGE_DOS_HEADER 읽기
int main()
{
    // MMF 1단계 - 화일 Create 또는 Open
    HANDLE hFile = CreateFile(
                               "c:\\windows\\system32\\calc.exe",
                               GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ,
                               0,
                               OPEN_EXISTING,
                               FILE_ATTRIBUTE_NORMAL, 0 );
    // MMF 2단계 - 화일 매핑 KO 생성
    HANDLE hMap = CreateFileMapping( hFile,        // 연결할 파일
                                     0,                                 // 매핑KO( 섹션 Object ) 보안 속성
                                     PAGE_READONLY,         //
                                     0, sizeof(IMAGE_DOS_HEADER),    // 매핑할 크기
                                     "map" );                        // 매핑 객체 이름

    // MMF 3단계 - 매핑 객체를 사용해서 화일을 가상주소와 연결한다.
    IMAGE_DOS_HEADER* p = (IMAGE_DOS_HEADER*) MapViewOfFileEx( hMap, FILE_MAP_READ,
           0, 0,        // Offset( 파일 생성시는 무조건 0 기존파일 Open시에만 적용 )
           0,           // 크기( 0 매핑 객체에 지정된 크기를 사용 )
           (void*)0x00600000 ); // 원하는 주소

    if ( p == 0 ) printf( "error\n" );
    else
    {
        printf( "매핑된 주소 : %p\n", p );
        printf( "%x\n", p->e_magic );    // 모든 실행 파일은 "MZ" 로 시작한다.
    }
    UnmapViewOfFile( p );
    CloseHandle( hMap );
    CloseHandle( hFile );
}

/////////////////////////////////////////////////////////////////////////////////////
// FILE 로드해서 버퍼처럼 쓰기~
int main()
{
    // MMF 1단계 - 화일 Create 또는 Open
    HANDLE hFile = CreateFile( "a.txt", GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ,
                               0,
                               CREATE_ALWAYS,
                               FILE_ATTRIBUTE_NORMAL, 0 );
    // MMF 2단계 - 화일 매핑 KO 생성
    HANDLE hMap = CreateFileMapping( hFile,        // 연결할 파일
                                     0,            // 매핑KO( 섹션 Object ) 보안 속성
                                     PAGE_READWRITE,    //
                                     0, sizeof(IMAGE_DOS_HEADER),    // 매핑할 크기
                                     "map" );    // 매핑 객체 이름

    // MMF 3단계 - 매핑 객체를 사용해서 화일을 가상주소와 연결한다.
    char* p = (char*) MapViewOfFileEx( hMap, FILE_MAP_WRITE,
           0, 0,        // Offset( 파일 생성시는 무조건 0 기존파일 Open시에만 적용 )
           0,           // 크기( 0 매핑 객체에 지정된 크기를 사용 )
           (void*)0x00600000 ); // 원하는 주소

    if ( p == 0 ) printf( "error\n" );
    else
    {
        printf( "매핑된 주소 : %p\n", p );

        strcpy( p, "Hello" );    // 파일에 출력
        p[40] = 'C';
    }
    UnmapViewOfFile( p );
    CloseHandle( hMap );
    CloseHandle( hFile );
}

//-------------------------------------------------------------------------------
// A.cpp - 좌표를 pagefile에 써준다.
struct LINE
{
    POINTS ptFrom;
    POINTS ptTo;
};

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HANDLE hEvent, hMap, hEvent2;
    static POINTS ptFrom, ptTo;
    static LINE* pLine;

    switch( msg )
    {   
    case WM_CREATE:
        {
            hEvent = CreateEvent( 0, 0, 0, "e1" );
            hEvent2 = CreateEvent( 0, 0, TRUE, "e2" );

            // 매핑 객체 생성
            hMap = CreateFileMapping( (HANDLE)-1, // Page 화일을 사용하라.
                                      0, PAGE_READWRITE,
                                      0, sizeof(LINE), "map" );
            pLine = (LINE*) MapViewOfFile( hMap, FILE_MAP_WRITE, 0, 0, 0 );
        }
        return 0;

    case WM_LBUTTONDOWN:
        ptFrom = ptTo = MAKEPOINTS( lParam );
        return 0;
    case WM_MOUSEMOVE:
        if( wParam & MK_LBUTTON )
        {
            POINTS pt = MAKEPOINTS( lParam );
            HDC hdc = GetDC( hwnd );

            MoveToEx( hdc, ptFrom.x, ptFrom.y, 0 );
            LineTo  ( hdc, pt.x, pt.y );

            ReleaseDC( hwnd, hdc );

            // MMF에 넣는다.
            WaitForSingleObject( hEvent2, INFINITE ); // 꺼내 갔는가를 확인..

            pLine->ptFrom = ptFrom;
            pLine->ptTo = pt;

            // Event Signal
            SetEvent( hEvent );

            ptFrom = pt;
        }
        return 0;

    case WM_DESTROY:
        UnmapViewOfFile( pLine );
        CloseHandle( hEvent );
        CloseHandle( hMap );

        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}
//-------------------------------------------------------------------------------
// B.cpp - A.cpp 에서 입력한 pagefile을 읽는다.
struct LINE
{
    POINTS ptFrom;
    POINTS ptTo;
};

DWORD WINAPI Work( void* p )
{
    HWND hwnd = (HWND)p;
    HANDLE hEvent = OpenEvent( EVENT_ALL_ACCESS, 0, "e1" );
    HANDLE hEvent2 = OpenEvent( EVENT_ALL_ACCESS, 0, "e2" );

    HANDLE hMap   = OpenFileMapping( FILE_MAP_ALL_ACCESS, 0, "map" );

    LINE* pLine = (LINE*) MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 );

    while( 1 )
    {
        WaitForSingleObject( hEvent, INFINITE );
       
        // 약간의 지연이 발생..
        Sleep(10);

        // 이제 MMF에서 꺼내서 그린다.
        HDC hdc = GetDC( hwnd );

        MoveToEx( hdc, pLine->ptFrom.x, pLine->ptFrom.y, 0 );
        LineTo( hdc,   pLine->ptTo.x,   pLine->ptTo.y );

        // 꺼내 갔음을 알려준다.
        SetEvent( hEvent2 );

        ReleaseDC( hwnd, hdc );
    }
    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_CREATE:
        CloseHandle( CreateThread( 0, 0, Work, (void*)hwnd, 0, 0 ) );
        return 0;

    case WM_LBUTTONDOWN:
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// spy.dll 만들기~
WNDPROC old;
// 계산기의 메세지 처리함수를 가로챌 함수

LRESULT CALLBACK foo( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
    case WM_COMMAND:    // 메뉴 선택
        switch( LOWORD(wParam) )
        {
        case 304:    //    "공학용" 메뉴
            MessageBox( 0, "^^", "", MB_OK );
            return 0;
        }
        break;
    }
    // 나머지 메세지는 모두 원래의 함수로 보낸다.
    return CallWindowProc( old, hwnd, msg, wParam, lParam );
}

// DLL이 프로세스에 매핑될때 자동으로 호출되는 함수
BOOL WINAPI DllMain( HANDLE h, DWORD r, LPVOID how )
{
    if ( r == DLL_PROCESS_ATTACH )
    {
        HWND hwnd = FindWindow( 0, "계산기" );

        old = (WNDPROC)SetWindowLong( hwnd, GWL_WNDPROC, (LONG)foo );
    }
    return TRUE;    // 반드시 TRUE를 리턴.
}

////////////////////////////////////////////////////////////////////////////////
// DLLInject.cpp
void DLLInject( DWORD pid, const char* path )
{
    HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );

    ///////////////////////////////////////////////////////////
    // LoadLibrary 의 주소를 찾는다.
    HMODULE hDll = GetModuleHandle( "Kernel32.dll" );

    PTHREAD_START_ROUTINE f = (PTHREAD_START_ROUTINE)
                                GetProcAddress( hDll, "LoadLibraryA" );

    // PTHREAD_START_ROUTINE 은 미리 정의된 스레드 함수 포인터 type이다.
    void* p = VirtualAllocEx( hProcess, 0, strlen(path)+1, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );

    // Inject 할 DLL의 경로를 계산기 메모리에 복사해 놓는다.
    DWORD len;
    WriteProcessMemory( hProcess, p, path, strlen(path)+1, &len );

    ///////////////////////////////////////////////////////////
    // 다른 프로세스에 스레드를 생성한다.
    HANDLE hThread = CreateRemoteThread( hProcess, 0, 0,
                                         f, (void*)p,        // 함수, 파라미터
                                         0, 0 );
}

int main()
{
    HWND hwnd = FindWindow( 0, "계산기" );

    if ( hwnd == 0 )
    {
        printf( "계산기 부터 실행하세요..\n" );
        return 0;
    }
    // 계산기 프로세스에 DLL을 강제로 넣는다.
    DWORD pid;
    DWORD tid = GetWindowThreadProcessId( hwnd, &pid );

    DLLInject( pid, "C:\\spy.dll" );
}

// 정적 TLS의 문제점 : DLL에 만들고.. 해당 DLL을 LoadLibrary로 사용하면 TLS에 있는 변수가
//                   제대로 동작하지 않는다. => 동적 TLS를 사용하자.                   

// 3의 배수를 차례대로 리턴하는 함수
// single Thread에서는 문제없다.
int Next3Times()
{
    // 정적 TLS : static 지역 변수 혹은 전역 변수에만 사용가능..
    __declspec(thread) static int n = 0;
    n = n + 3;
    return n;
}

DWORD WINAPI foo( void* p )
{
    char* n = (char*)p;

    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );

    return 0;
}

int main()
{
    HANDLE h[2];
    h[0] = CreateThread( 0, 0, foo, "A", 0, 0 );
    h[1] = CreateThread( 0, 0, foo, "\tB", 0, 0 );

    getch();
}

// 전역변수( 모든 스레드 공유 )로 TLS Index를 보관한다.
DWORD index = 0;

int Next3Times()
{
    DWORD n = (DWORD)TlsGetValue( index ); // TLS에서 값을 꺼내서
    n = n + 3;  // 증가하고
    TlsSetValue( index, (LPVOID) n );    // 다시 보관한다.

    return n;
}

DWORD WINAPI foo( void* p )
{
    // TLS 초기값을 설정한다.
    TlsSetValue( index, 0 );

    char* n = (char*)p;

    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );

    return 0;
}

int main()
{
    // 스레드를 생성하기 전에 동적으로 TLS의 빈 슬롯(4byte)을 할당한다.
    index = TlsAlloc();

    HANDLE h[2];
    h[0] = CreateThread( 0, 0, foo, "A", 0, 0 );
    h[1] = CreateThread( 0, 0, foo, "\tB", 0, 0 );

    WaitForMultipleObjects( 2, h, TRUE, INFINITE );

    TlsFree( index );  // TLS를 해지한다.
}

void get_thread_time( HANDLE hThread, __int64* usertime, __int64* kerneltime )
{
    // 스레드의 생성시간, 종료시간, 커널시간, user시간을 구한다.
    __int64 t1, t2;

    GetThreadTimes( hThread, (FILETIME*)&t1,    // 생성시간
                             (FILETIME*)&t2,    // 종료시간
                             (FILETIME*)kerneltime,    // 커널에서 실행한 시간
                             (FILETIME*)usertime );     // 유저모드에서 실행한 시간

}
int factorial( int a )
{
    if( a == 1 ) return 1;

    return a * factorial( a-1 );
}

int main()
{
    __int64 k1 = 0, k2 = 0, u1 = 0, u2 = 0;

    get_thread_time( GetCurrentThread(), &u1, &k1 );

    // 시간을 측정하고 싶은 알고리즘
    for ( int i = 0; i < 1000; ++i )
        printf( "%d\n", factorial(10) );

    get_thread_time( GetCurrentThread(), &u2, &k2 );

    printf( "걸린시간 : %d ms\n", ( (u2-u1) + (k2-k1))/10);
}

#include <commctrl.h> // 공용 컨트롤 헤더
// 스레드간 메세지 통신...
DWORD WINAPI foo( void* p )
{
    TCHAR szApp[] = _T("BBB");

    ATOM atom;
    WNDCLASS wc;
    HWND hwnd;
    MSG msg;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hbrBackground= (HBRUSH)GetStockObject( WHITE_BRUSH );
    wc.hCursor        = LoadCursor( 0, IDC_ARROW );
    wc.hIcon        = LoadIcon( 0, IDI_APPLICATION);
    wc.hInstance    = GetModuleHandle(0);
    wc.lpfnWndProc  = WndProc;
    wc.lpszClassName= szApp;
    wc.lpszMenuName = 0;
    wc.style        = 0;
    atom = RegisterClass( &wc);
   
    if ( atom == 0 )
    {
        MessageBox( 0, _T("Fail To RegisterClass"), _T("Error"), MB_OK);
        return 0;
    }
    hwnd = CreateWindowEx( 0, szApp, szApp, WS_OVERLAPPEDWINDOW,
                                CW_USEDEFAULT, 0, CW_USEDEFAULT,0, 0, 0,
                                0, 0);
    ShowWindow( hwnd, SW_SHOW);
    UpdateWindow( hwnd );

    while ( GetMessage( &msg, 0, 0, 0) )
    {                           
        TranslateMessage(&msg);
        DispatchMessage( &msg);
    }

    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hPrg;

    switch( msg )
    {   
    case WM_CREATE:
       
        hPrg = CreateWindow( PROGRESS_CLASS, "", WS_CHILD | WS_VISIBLE | WS_BORDER,
                                10,10,500,30, hwnd, (HMENU)1, 0,0);
        SendMessage( hPrg, PBM_SETRANGE32,0,1000);
        return 0;
    case WM_LBUTTONDOWN:
        {
            HANDLE h = CreateThread( 0, 0, foo, (void*)hwnd, 0, 0);

        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// 스레드간 메세지 통신...
DWORD WINAPI foo( void* p )
{
    HWND hwnd = (HWND)p;

    for ( int i=0; i< 1000; ++i )
    {
       // 생성된 프로그레스바에 메시지를 보낸다.
       SendMessage( hPrg, PBM_SETPOS, i, 0);
       Sleep(10);

        // 주스레드에 직접 메세지를 보내서 자신을 스스로 Update가 되게 하다.
        BOOL b = PostMessage( hwnd, WM_USER+100, i, 0);
        if ( b == FALSE ) break;
        Sleep( 10 );
    }
    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hPrg;

    switch( msg )
    {   
    case WM_CREATE:
       
        hPrg = CreateWindow( PROGRESS_CLASS, "", WS_CHILD | WS_VISIBLE | WS_BORDER,
                                10,10,500,30, hwnd, (HMENU)1, 0,0);
        SendMessage( hPrg, PBM_SETRANGE32,0,1000);
        return 0;

        case WM_RBUTTONDOWN:
            {
                while(1);
            }
            return 0;

    case WM_LBUTTONDOWN:
        {
            HANDLE h = CreateThread( 0, 0, foo, (void*)hwnd, 0, 0);

        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// 일반 전역 변수..  .data section에 놓인다. 기본적으로 COW하는 속성을 가지고 있다.
int x = 0;

// exe에 새로운 data 섹션을 만든다.
#pragma data_seg("AAA")
int y = 0;      // 공유 섹션으로 만드려면 반드시 초기값이 필요하다.
#pragma data_seg()

// 특정 섹션의 속성을 지정한다. - Read, Write, Share( COW 속성이 제거된다. )
#pragma comment( linker, "/section:AAA,RWS")    // Copy On Write

int main()
{
    ++x;    ++y;

    if( y >= 3 )
    {
        printf( "3번 이상은 실행하지 마세요\n" );
        --y;
        return 0;
    }

    printf( "x = %d, y = %d\n", x, y );

    _getch(); 
}

// SHARED.dll만들기
// 공유 메모리는 반드시 초기화 해야 한다.,!!!!!!!!!!!!!!
#pragma data_seg("SHARED")
char buf[1024] = { 0 };
#pragma data_seg()

#pragma comment( linker, "/section:SHARED,RWS" )
/////////////////////////////////////////////////////

extern "C" __declspec(dllexport) void SetData(char* s)
{
    strcpy( buf, s );
}
extern "C" __declspec(dllexport) void GetData(char* s)
{
    strcpy( s, buf );
}
/////////////////////////////////////////////////////////////////////////////
// A.cpp
typedef void(*F)(char*);
int main()
{
    HMODULE hDll = LoadLibrary( "SHARED.dll" );
    F SetData = (F)GetProcAddress( hDll, "SetData" );
    F GetData = (F)GetProcAddress( hDll, "GetData" );

    HANDLE hEvent = CreateEvent( 0, 0, 0, "e" );
    HANDLE hEvent2 = CreateEvent( 0, 0, TRUE, "e2" ); // 최초의 signal은 통과해라.

    while( 1 )
    {
        char buf[256] = { 0 };

        WaitForSingleObject( hEvent, INFINITE );

        // DLL의 공유 버퍼에서 Data를 꺼낸다.
        GetData( buf );

        SetEvent( hEvent2 );

        printf( "읽어온 data : %s\n", buf );
    }
}
///////////////////////////////////////////////////////////////////////////
// B.cpp
typedef void(*F)(char*);

int main()
{
    HMODULE hDll = LoadLibrary( "SHARED.dll" );
    F SetData = (F)GetProcAddress( hDll, "SetData" );
    F GetData = (F)GetProcAddress( hDll, "GetData" );

    HANDLE hEvent = CreateEvent( 0, 0, 0, "e" );
    HANDLE hEvent2 = CreateEvent( 0, 0, TRUE, "e2" ); // 최초의 signal은 통과해라.
   
    while( 1 )
    {
        char buf[256] = { 0 };
        gets( buf );    // 1줄입력

        // 정말 가져 갔는지 확인한다.
        WaitForSingleObject( hEvent2, INFINITE );

        SetData( buf );

        // 대기중인 스레드를 깨운다.
        SetEvent( hEvent );
    }
}

// 뮤텍스 : 자원의 독점.. 다중 프로세스의 다중 스레드 동기화
int main()
{
    HANDLE h = CreateMutex(
        0,          // 보안속성
        FALSE,      // 소유권 여부
        "m"         // 이름 - 생략가능
        );

    if( h == 0 )
        printf( "뮤텍스를 만들수 없다.\n");
    else
    {
        // Createxxx() 함수로 KO를 생성했을 떄 Create or Open 인지 알고 싶다면.
        // LastErrorCode를 확인한다.
        if( GetLastError() == ERROR_ALREADY_EXISTS )
            printf( " 뮤텍스를 open 했습니다.\n" );
        else
            printf( "뮤텍스를 create 했습니다.\n" );
    }
    printf("뮤텍스 대기\n");

    // 재귀 횟수를++; 소유권을 획득 한다. --Mutex.signalState
    DWORD ret = WaitForSingleObject( h, INFINITE );
    if( ret == WAIT_OBJECT_0 )  // 정상적으로 signal이 된 경우
        printf("뮤텍스 획득\n");
    else if( ret == WAIT_ABANDONED )
        printf("포기된 뮤텍스\n");
    else if( ret == WAIT_TIMEOUT )
        printf("대기 시간 종료\n");
    else if( ret == WAIT_FAILED )
        printf("Wait에 전달된 핸들이 잘못됨\n");

    getch();

    // 뮤텍스의 소유자는 뮤텍스의 signal 상태와 상관없이 wait를 통과할 수 있다.
    // 자신의 주머니에 열쇠가 있는데 다시 열쇠를 찾는 상황( DeadLock의 위험.. )
    //WaitForSingleObject( h, INFINITE );
    //printf("뮤텍스 획득\n");
    //getch();

  // ReleaseMutex를 하지 않는다면 포기된 뮤텍스가 발생한다.
   // ReleaseMutex( h );      // 재귀횟수--; 소유권을 반납.. ++Mutex.signalState
    CloseHandle( h );
}

  // Limit가 1인 세마포어는 뮤텍스와 비슷하다. 하지만 차이가 있다.
    // 뮤텍스 : 소유권 개념을 가진다. 자원을 획득한 스레드만 자원 반납이 가능하다.
    // 세마포어 : 소유의 개념이 없다. - count의 감소와 증가를 서로 다른 스레드가 해도 된다
int main()
{
    HANDLE h = CreateSemaphore(
        0,      // 보안
        3,      // 카운트의 현재값 ( signalstate = 3 )
        3,      // 카운트 최대값   ( limit = 3 )
        "s" );  // 이름

    printf( "세마포어를 대기합니다.\n" );

    WaitForSingleObject( h, INFINITE ); // --signalstate

    printf( "세마포어 획득\n" );

    getch();

    LONG old;
    // 대부분 1을 증가한다. limit이상의 값은 의미가 없다.
    ReleaseSemaphore( h, 1, &old );     // signalstate += 2번째 인자만큼..

    CloseHandle( h );.
}

// SetEvent.cpp
int main()
{
    HANDLE h = CreateEvent(
        0,      //보안
        FALSE,  // Reset의 종류( T:manual, F:auto )
        FALSE,  // 초기 signal 상태
        "e" );  // 이름

    while( 1 )
    {
        getch();

        SetEvent( h );  // Event를 Signal 상태로 한다.
                        // 결국 커널 함수인 KeSetEvent()를 호출하게 된다.
    }
    CloseHandle( h );
}

////////////////////////////////////////////////////////////////////////////////
// Event.cpp  이벤트 signal이 오기를 기달린다.
int main()
{
    HANDLE h = CreateEvent(
        0,      //보안
        FALSE,  // Reset의 종류( T:manual, F:auto )
        FALSE,  // 초기 signal 상태
        "e" );  // 이름

    printf("Event를 대기 합니다.\n");

    WaitForSingleObject( h, INFINITE );
    printf("Event 획득\n");

    CloseHandle( h );
}

queue<int> Q;   // 생산자와 소비자가 공유할 Q( 전역변수, 모든 data멤버를 스레드가 공유)
HANDLE hMutex;  // 접근을 동기화 하기 위해 사용한다.
HANDLE hSemaphore;  // Q에 이쓴ㄴ 자원의 갯수를 파악한다.(Empty일 경우를 대비)

// 생산자
DWORD WINAPI Produce(void* p)
{
    static int n = 0;

    while( 1 )
    {
        ++n;

        // Q에 대한 독점권을 획득한다.
        WaitForSingleObject( hMutex, INFINITE );
        ///////////////////////////////////////////////
        Q.push( n );  //생산
        printf("생산자 : %d\n", n );

        // 세마포어의 카운트를 올려준다.
        LONG old;
        ReleaseSemaphore( hSemaphore, 1, &old );
        //////////////////////////////////////////////
        // Q에 대한 독점권을 반납한다.
        ReleaseMutex( hMutex );

        Sleep( (rand() % 100) * 30 );    // 0~3초간 대기
    }
    return 0;
}

// 소비자
DWORD WINAPI Consume( void* p )
{
    while( 1 )
    {       
        // Q에 자원이 있는지를 파악한다. - 세마포어
        WaitForSingleObject( hSemaphore, INFINITE );
        // Q에 대한 독점권을 획득한다.
        WaitForSingleObject( hMutex, INFINITE );

        ///////////////////////////////////////////////
        int n = Q.front();
        Q.pop();
        printf("               소비자 : %d\n", n );
        //////////////////////////////////////////////
        // Q에 대한 독점권을 반납한다.
        ReleaseMutex( hMutex );

        Sleep( ( rand() % 100 ) * 30 );
    }
    return 0;
}

int main()
{
    // 생산자 소비자가의 Q의 동기화를 위해서 뮤텍스(크리티컬섹션)사용
    hMutex = CreateMutex( 0, 0, 0 );    // 이름이 필요없으면 0.

    // 초기 카운트 0, 최대 카운트 1000(Q의 크기)의 세마포어..
    hSemaphore = CreateSemaphore( 0, 0, 1000, 0 );

    srand( time(0) );
    HANDLE h[2];

    h[0] = CreateThread( 0, 0, Produce, 0, 0, 0 );
    h[1] = CreateThread( 0, 0, Consume, 0, 0, 0 );

    WaitForMultipleObjects( 2, h, TRUE, INFINITE );
}

// thread-safe class 만들기
// slist는 내부적으로 동기화를 해주게 된다.
// 이는 VC2005 내부적으로 구현이 되어 있다.

template<typename T> class slist
{
    CRITICAL_SECTION cs;

public:
    virtual void Lock() { EnterCriticalSection( &cs ); }
    virtual void Unlock() {  LeaveCriticalSection( &cs ); }
    void push_front( const T& n )
    {
        Lock();
        //....
        Unlock()
    }

    void pop_front()
    {
        Lock();
        //...
        Unlock();
    }
};

// 동기화가 싫다면 상속을 받아서 virtual 의 작업을 아무것도 하지 못하게 한다.
template<typename T> class slist_nosync : public slist<T>
{
    virtual void Lock() {}
    virtual void Unlock() {}
};

class UseCriticalSection
{
public:
    UseCriticalSection() { InitializeCriticalSection( &cs ); }
    ~UseCriticalSection() { DeleteCriticalSection( &cs ); }

    virtual void Lock() {  EnterCriticalSection( &cs ); }
    virtual void Unlock() { LeaveCriticalSection( &cs );  }
};
class NoThread
{
public:
    virtual void Lock() {}
    virtual void Unlock() {}
};
// 단위 전략 기반의 설계 기술.
template<typename T, typename ThreadModel = NoThread> class slist
{
    ThreadModel Sync;

public:
    virtual void Lock() { Sync.Lock(); }
    virtual void Unlock() {  Sync.Unlock(); }
    void push_front( const T& n )
    {
        Lock()
        //....
        Unlock()
    }

    void pop_front()
    {
        Lock();
        //...
        Unlock();
    }
};

slist< int, UseCriticalSection > s;

typedef void(*WORK)();  // 작업의 모양 - 결국 함수 포인터

queue<WORK> Q;  // 작업 Q ( VC2005의 STL은 스레드 안전하므로 동시접근해도 된다. )

BOOL bContinue = TRUE;

HANDLE hSemaphore;

// Thread Pool 에 놓인 모든 스레드가 실행하는 함수
DWORD WINAPI ThreadFunc( void* p )
{
    while( bContinue )
    {
        // 작업 Q에 작업이 들어 올때 까지 대기한다.
        WaitForSingleObject( hSemaphore, INFINITE );

        // Q에서 작업을 꺼낸다.
        //-------------------------------
        // 동기화가 필요하다!!!!!!!!!!
        WORK w = Q.front();
        Q.pop();
        //-------------------------------

        w(); // 작업을 수행한다.
    }
    return 0;
}
// 작업 Q에 작업을 넣는 함수.
void AddWork( WORK f )
{
    Q.push( f );

    LONG old;
    ReleaseSemaphore( hSemaphore, 1, &old );
}
// Pool을 초기화 한다.
void InitPool( int n )
{
    hSemaphore = CreateSemaphore( 0, 0, 1000, 0 );

    for( int i = 0; i < n; ++i )
        CloseHandle( CreateThread( 0, 0, ThreadFunc, 0, 0, 0 ) );
}
//--------------------------------------------------
// Pool에서 작업할 함수
void foo()
{
    for( int i = 0; i < 20; ++i )
    {
        printf( "%d : %d\n", GetCurrentThreadId(), i );
        Sleep(1000);
    }
}

int main()
{
    InitPool( 3 );

    // Pool에 작업을 넣는다.
    AddWork( foo ); AddWork( foo ); AddWork( foo );
    AddWork( foo ); AddWork( foo ); AddWork( foo );

    printf( "main...\n" );

    getch();
}

DWORD WINAPI Monitor( void* p )
{
    DWORD pid = (DWORD)p;

    HANDLE hProcess = OpenProcess( SYNCHRONIZE, 0, pid );
    HANDLE hEvent = OpenEvent( EVENT_ALL_ACCESS, 0, // 상속가능여부
                                   "EXIT_EVENT" );  // 이름

    HANDLE h[2] = { hEvent, hProcess };
    DWORD ret = WaitForMultipleObjects( 2, h, FALSE, INFINITE );

    if( ret == WAIT_OBJECT_0 )  // h[0] 즉 event signal
        printf("Event가 signal이 되어서 종료합니다.");
    else if( ret == WAIT_OBJECT_0+1 ) // h[1] .. +63까지 가능..
        printf("\n %d 프로세스가 종료되었습니다. \n", pid );

    CloseHandle( hEvent );
    CloseHandle( hProcess );

    return 0;
}

int main()
{
    // 새롭게 생성되는 스레드와 통신하기 위한 manual Event
    HANDLE hEvent = CreateEvent( 0, TRUE, 0, "EXIT_EVENT" );
    int count = 0;
    HANDLE hThread[100];

    while( 1 )
    {
        int n;
        printf("대기할 프로세스 ID >> " );
        scanf("%d", &n);

        if ( n == -1 ) break;   // 루프 탈출

        // 새로운 스레드를 생성해서 감시를 하게 한다.
        hThread[count++] = CreateThread( 0, 0, Monitor, (void*)n, 0, 0 );
    }

    // 모든 작업중인 스레드를 깨워서 종료되게 한다.
    SetEvent( hEvent );

    // 모든 스레드가 죽을때까지 대기!!
    WaitForMultipleObjects( count, hThread, TRUE, INFINITE );
    for( int i = 0; i < count; ++i )    CloseHandle( hThread[i] );

    return 0;
}

void Delay() { for( int i = 0; i < 10000000; ++i); }

BOOL bWait = TRUE;

// win32 스레드 함수의 모양
DWORD CALLBACK foo( void* p )
{
    char* n = (char*)p;
    int x = 0;

    for ( int i = 0; i < 1000; ++i )
    {
        x = 100;    Delay();
        x = x + 1;    Delay();

        printf( "%s : %d\n", n, x );
    }

    printf( "%s Finish\n", n );
    bWait = FALSE;
    return 0;
}

int main()
{
    //    foo( "A" );    // 호출

    DWORD tid;

    HANDLE h1 = CreateThread(
        0,        // 보안속성
        0,        // stack 크기
        foo,    // 스레드로 실행할 함수
        "A",    // 인자
        0,        // 우선순위 | 플래그
        &tid    // 생성된 스레드 ID를 담아올 변수(win2000 에서는 0 가능)
        );

    WaitForSingleObject( h1, INFINITE );

//    while( bWait );    // 최악의 코드.. 할일이 없는데 CPU를 사용한다.

//    printf("main....\n");
//    ExitThread(0);    // 현재 스레드(주스레드)만 종료한다. - 프로세스 종료가 아니다.
}

void Delay() { for( int i = 0; i < 10000000; ++i); }

DWORD CALLBACK foo( void* p )
{
    char* n = (char*)p;
    static int x = 0;

    for ( int i = 0; i < 20; ++i )
    {
        //EnterCriticalSection( &cs );    // cs영역에 들어가는 것. cs는 1개의 스레드만 들어간다.
        if( TryEnterCriticalSection( &cs ) )    // win2000 전용함수
        {
        //////////////////////////////////////
        x = 100;    Delay();
        x = x + 1;    Delay();
        printf( "%s : %d\n", n, x );
        //////////////////////////////////////
        LeaveCriticalSection( &cs );    // cs영역에서 나온다.

        }
        else
        {
            // Critical Section에 들어가지 못할 경우에 할일..
            printf("%s : CriticalSection에 들어 갈수 없습니다.\n", n );
            --i;
        }
    }

    printf( "%s Finish\n", n );
    return 0;
}

int main()
{
    InitializeCriticalSection( &cs );

    HANDLE h1 = CreateThread( 0, 0,    foo, "A", 0, 0 );
    HANDLE h2 = CreateThread( 0, 0,    foo, "\tB", 0, 0 );
    // 64개 까지 대기 가능한 함수.!! - MFC에서 CMultiLock 클래스가 아래 함수의 기능을 클래스화 한다.
    HANDLE h[2] = { h1, h2 };
    WaitForMultipleObjects( 2, h, TRUE, INFINITE );
   
    CloseHandle( h1 );
    CloseHandle( h2 );

    DeleteCriticalSection( &cs );
}

// 예외를 대비하는 새로운 클래스 : MFC 배울때. CSingleLock과 CMultiLock 헷갈리지 마세요.
class CsyncObject
{
public:
    virtual void Lock() {}
    virtual void UnLock() {}
};
class CCriticalSection : public CsyncObject
{
    CRITICAL_SECTION m_cs;
public:
    CCriticalSection()  { InitializeCriticalSection(&m_cs); }
    ~CCriticalSection() { DeleteCriticalSection(&m_cs); }

    void Lock() { EnterCriticalSection(&m_cs); }
    void UnLock() { LeaveCriticalSection(&m_cs); }
};
class CSingleLock
{
    CsyncObject* p;
public:
    CSingleLock( CsyncObject* _p ) : p(_p) {}

    void Lock() { p->Lock(); }
    void UnLock() { p->UnLock(); }
};
CCriticalSection cs;
UINT CALLBACK goo( void* p )
{
    CSingleLock slock(&cs);

    slock.Lock();

    // 그런데.. 여기서 C++ 예외가 발생.
    // 어떻게 될까??
    throw 1;

    slock.UnLock();
}

LONG x = 0;

DWORD CALLBACK foo( void* p )
{
    for ( int i = 0; i < 1000000; ++i )
    {
        // COM 기반 기술에서 자주 사용한다.!!!!!!!
        InterlockedExchange( &x, 0 ); // x = 0
        InterlockedExchangeAdd( &x, 5 );    // x = x+5;
        InterlockedDecrement( &x ); // x -= 1;
        InterlockedIncrement( &x );    // lock inc x 로 구현된 함수. x += 1
        //x = x+1;    // 보장받지 못한다.

        __asm
        {
            //lock inc x // inc 는 원자 연산이다. 즉, inc 실행중 절대 Context Switch가 발생안함.
//            mov eax,    x
//            add eax,    1
//            mov x,        eax
        }
    }
    return 0;
}

int main()
{
    HMODULE hDll = GetModuleHandle( "Kernel32.dll" );
    void* p = (void*)GetProcAddress( hDll, "GetLastError" );
    printf("%p\n", p);
    GetLastError();

    HANDLE h[3];

    h[0] = CreateThread( 0, 0, foo, 0, 0, 0 );
    h[1] = CreateThread( 0, 0, foo, 0, 0, 0 );
    h[2] = CreateThread( 0, 0, foo, 0, 0, 0 );

    WaitForMultipleObjects( 3, h, TRUE, INFINITE );

    CloseHandle( h[0] );
    CloseHandle( h[1] );
    CloseHandle( h[2] );

    printf( "결과 : %d\n", x );
}

// A.cpp 메모리에 변수하나를 올린다.
int main()
{
    char passwd[256] = { 0 };

    printf( "PID : %d\n", GetCurrentProcessId() );
    printf( "passwd 주소 : %p\n", passwd );

    while ( 1 )
    {
        printf( "암호를 입력하세요. >>" );
        scanf( "%s", passwd );
    }
}

// B.cpp  A.exe의 메모리 읽어오기..
int main()
{
    DWORD pid = xxxx;    // A의 PID를 넣으세요.
    char* addr = (char*)0x0012FE60; // passwd의 주소를 넣으세요.

    HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );

    while ( 1 )
    {
        char buf[256] = { 0 };
        DWORD len;
        ReadProcessMemory( hProcess, addr, buf, 256, &len );    // 핵심!!

        printf( "읽어온 data : %s\n", buf );
        getch();
    }
}

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include "nativeAPI.h"

#pragma comment( lib, "ntdll.lib" )

// 쓰레드의 처음 시작하는 프로세스의 시작주소를 알려준다!!!

void main()
{
    ULONG                dwAllocedSize, dwNeeded;
    PSYSTEM_PROCESSES    pProcesses;
    NTSTATUS            Status;
    int                    nThreadCount = 0;
   
    //1. Get Buffer of information data
    dwAllocedSize = 0x1000;
    while(TRUE)
    {
        pProcesses = (PSYSTEM_PROCESSES)VirtualAlloc(NULL, dwAllocedSize, MEM_COMMIT, PAGE_READWRITE);
       
        Status = ZwQuerySystemInformation(
            SystemProcessesAndThreadsInformation,
            pProcesses,        // 버퍼
            dwAllocedSize,    // 버퍼크기
            &dwNeeded);        // 버퍼가 작으면 크기를 알려준다.
       
        if(Status == STATUS_INFO_LENGTH_MISMATCH )
        {
            VirtualFree(pProcesses, dwAllocedSize, MEM_RELEASE);

            if(dwNeeded > dwAllocedSize)
                dwAllocedSize = dwNeeded;
            else
                dwAllocedSize += 0x500;
        }
        else if (NT_SUCCESS(Status))
        {
            break;
        }
        else
        {
            break;
        }
    }

    while(pProcesses->NextEntryDelta != 0)
    {
        pProcesses = (PSYSTEM_PROCESSES)((char *)pProcesses +
                                        pProcesses->NextEntryDelta);
        //Print Process Information
        printf("PID:%d - %.*ws- %d\n",
            pProcesses->ProcessId,
            pProcesses->ProcessName.Length / 2,
            pProcesses->ProcessName.Buffer,
            pProcesses->HandleCount );
   
        //Print Thread
        for(ULONG nIndex = 0 ; nIndex < pProcesses->ThreadCount ; nIndex ++)
        {
            printf("    [%d], StartAddress : 0x%08x\n",
                    pProcesses->Threads[nIndex].ClientId.UniqueThread,
                    pProcesses->Threads[nIndex].StartAddress);

        }
        getch();
    }
}

// GetLastError() 함수의 원리 - 스레드당 1개의 에러코드를 얻는 함수.(TEB에 있다.)
int get_last_error()
{
    int err = 0;

    __asm
    {
        // TEB의 0x34번째 값을 얻는다.
        mov        eax,    FS:[0x34]

        mov        err,    eax
    }
    return err;
}
// 현재 프로세스가 디버깅 중인지 알아낸다. - Anti hack 프로그램의 원리
int AntiHack()
{
    char bRet = 0;
   
    __asm
    {
        // PEB의 주소를 알아낸다.
        mov        eax,    FS:[0x30]
        // PEB에서 2byte 이동한다.
        add        eax,    2

        // 디버깅 중인지를 알아낸다.
        mov        bl,        byte ptr[eax]
        mov        bRet,    bl
    }
    return bRet;
}
// 현재 쓰레드의 Id를 알아낸다.
int MyGetCurrentThreadId()
{
    int tid = 0;
        __asm
        {
            mov eax, FS:[0x24]
            mov tid, eax
        }
    return tid;
}
// 현재 스택의 시작주소를 알아낸다.
PVOID MyGetStackBase()
{
    PVOID tid = 0;
    __asm
    {
        mov eax, FS:[0x04]

        mov tid, eax
    }
    return tid;
}
// TLS의 주소를 알아온다.
PVOID MyGetThreadLocalStorage()
{
    PVOID tid = 0;
    __asm
    {
        mov eax, FS:[0x2c]

        mov tid, eax
    }
    return tid;
}

//-------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hEdit;
    switch( msg )
    {   
    case WM_CREATE:
        {
            hEdit = CreateWindow( "edit", "",
                WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE,
                10, 10, 500, 500, hwnd, (HMENU)1, 0, 0 );
        }
        return 0;
    case WM_LBUTTONDOWN:
        {
            PROCESS_INFORMATION pi;
            STARTUPINFO si = { sizeof(si) };

            // 화일을 생성해서 ping의 표준 출력을 redirect 한다.
            HANDLE hFile = CreateFile(
                "a.txt", GENERIC_READ | GENERIC_WRITE,
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                0,
                CREATE_ALWAYS,
                FILE_ATTRIBUTE_NORMAL,
                0 );

            // 모든 KO는 기본적으로 상속 불가능
            // 특정 KO를 상속 가능하게 변경한다.
            SetHandleInformation( hFile, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );

            si.hStdOutput = hFile;    // 표준 출력과 연결할 파일 핸들을 지정한다.
            si.dwXSize = 100;
            si.dwYSize = 100;        // 자식이 만드는 윈도우의 크기를 지정한다.
            si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESIZE;
            //----------------------------------------------------------------           

            char cmd[256] = "ping www.dblab.co.kr";
            BOOL b = CreateProcess(
                0, cmd, 0, 0, TRUE,
                CREATE_NO_WINDOW, // 콘솔에서 만들지 말라.//우선순위 | 플래그
                0, 0, &si, &pi );

            if( b )
            {
                // ping이 종료될 때까지 대기한다.
                WaitForSingleObject( pi.hProcess, INFINITE );

                // 이제 파일에서 읽어 온다.
                char buf[8096] = { 0 };    // 8k 버퍼   
       
                // 파일 포인터를 처음으로 옮기고. 4G가 보다 클수 있으므로 크기를 알려준다.
                SetFilePointer( hFile, 0, 0, FILE_BEGIN );

                DWORD len;
                ReadFile( hFile, buf, 8096, &len, 0 );

                // EditBox에 출력해준다.
                SetWindowText( hEdit, buf );
               
                CloseHandle( pi.hProcess );
                CloseHandle( pi.hThread );
            }
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hEdit;
    switch( msg )
    {   
    case WM_CREATE:
        {
            hEdit = CreateWindow( "edit", "",
                WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE,
                10, 10, 500, 500, hwnd, (HMENU)1, 0, 0 );
        }
        return 0;

    case WM_LBUTTONDOWN:
        {
            PROCESS_INFORMATION pi;
            STARTUPINFO si = { sizeof(si) };

            HANDLE hRead, hWrite;
            CreatePipe( &hRead, &hWrite, 0, 1024 );

            SetHandleInformation( hWrite, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT );

            si.hStdOutput = hWrite;    // 쓰기 위한 Pipe 핸들을 전달한다.
            si.dwFlags = STARTF_USESTDHANDLES;

            char cmd[256] = "ping www.dblab.co.kr";

            BOOL b = CreateProcess( 0, cmd, 0, 0, TRUE, CREATE_NO_WINDOW, 0, 0, &si, &pi );

            if( b )
            {
                CloseHandle( hWrite );    // 이제 쓰기 위한 핸들은 필요없다.
               
                while( 1 )
                {
                    char buf[2048] = { 0 }; // 2k 버퍼
                   
                    DWORD len;
                    BOOL b = ReadFile( hRead, buf, 2048, &len, 0 );    // 파이프로 결국 파일

                    if( len <= 0 )    // 에러 발생이거나 파이프가 닫힌 경우
                        break;

                    // 에디트에 한줄 씩 추가한다.
                    SendMessage( hEdit, EM_REPLACESEL, 0, (LPARAM)buf );
                }
                CloseHandle( hRead );
                CloseHandle( pi.hProcess );
                CloseHandle( pi.hThread );
            }
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

#include <tlhelp32.h>
// TOOL Help API : process, thread, module, heap 등을 열거 할때 사용하는 API의 모음
//                kernel32.dll 에 있다.

BOOL EnablePrimary( HANDLE    hProcess, // 권한을 부여할 프로세스
                    char*    pri,      // 권한을 나타내는 문자열
                    BOOL    bEnable   // 가능/불가능 여부
                    )
{

    HANDLE hToken;
    OpenProcessToken( hProcess, TOKEN_ADJUST_PRIVILEGES, &hToken );

    // 문자열로 되어 있는 권한ID( LUID, 64비트 정수 )로 변경한다.
    LUID luid;
    LookupPrivilegeValue(
        ".", // PC이름
        pri, // 권한이름
        &luid ); // luid를 담을 변수

    TOKEN_PRIVILEGES tp;
    tp.PrivilegeCount = 1;    // 갯수
    tp.Privileges[0].Luid = luid;    // 권한 ID
    tp.Privileges[0].Attributes= bEnable ? SE_PRIVILEGE_ENABLED : 0;

    return AdjustTokenPrivileges( hToken, 0, &tp, sizeof(tp), 0, 0 );
}

int main()
{
    if ( EnablePrimary(
        GetCurrentProcess(),    // 현재 프로세스의 핸들(-1이 나온다. -1은 자신을의미)
        SE_SHUTDOWN_NAME, TRUE )        // PC를 종료할수 있는 특권.
        == FALSE )
    {
        printf("can't Get Privieges\n");
        return 0;
    }

    // 프로세스의 목록을 메모리 어딘가에 보관(snapshot)해 둔다.
    HANDLE hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

    PROCESSENTRY32 pe32 = { 0 };
    pe32.dwSize = sizeof( pe32 );

    BOOL b = Process32First( hSnap, &pe32 );

    while( b )
    {
        printf( "%04d %04d %s\n",
            pe32.th32ProcessID,
            pe32.th32ParentProcessID,
            pe32.szExeFile );

        b = Process32Next( hSnap, &pe32 );
    }
    CloseHandle( hSnap );
}

#include <tlhelp32.h>

int main( int argc, char** argv ) { if ( argc != 2 )
    {
        printf( "usage : %s <pid> \n", argv[0] );
        return 0;
    }
    DWORD pid = atoi( argv[1] );

    HANDLE hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, pid );

    MODULEENTRY32 me32 = { sizeof(me32) };

    BOOL b = Module32First( hSnap, &me32 );

    while( b )
    {
        printf( "%08x : %s\n", me32.modBaseAddr, me32.szModule );

        b = Module32Next( hSnap, &me32 );
    }
    CloseHandle( hSnap );
}

// 특정 프로세스에 특정 권한을 부여한다. - 이 함수 역시 관리자 모드이어야만 실행이 성공.
BOOL EnablePrimary( HANDLE    hProcess, // 권한을 부여할 프로세스
                    char*    pri,      // 권한을 나타내는 문자열
                    BOOL    bEnable   // 가능/불가능 여부
                    )
{
    HANDLE hToken;
    OpenProcessToken( hProcess, TOKEN_ADJUST_PRIVILEGES, &hToken );

    // 문자열로 되어 있는 권한ID( LUID, 64비트 정수 )로 변경한다.
    LUID luid;
    LookupPrivilegeValue(
        ".", // PC이름
        pri, // 권한이름
        &luid ); // luid를 담을 변수

    TOKEN_PRIVILEGES tp;
    tp.PrivilegeCount = 1;    // 갯수
    tp.Privileges[0].Luid = luid;    // 권한 ID
    tp.Privileges[0].Attributes= bEnable ? SE_PRIVILEGE_ENABLED : 0;

    return AdjustTokenPrivileges( hToken, 0, &tp, sizeof(tp), 0, 0 );
}
                     
int main()
{
    // PC를 끌수 있는 권한을 부여한다.
    if ( EnablePrimary(
        GetCurrentProcess(),    // 현재 프로세스의 핸들(-1이 나온다. -1은 자신을의미)
        SE_SHUTDOWN_NAME, TRUE )        // PC를 종료할수 있는 특권.
        == FALSE )
    {
        printf("can't Get Privieges\n");
        return 0;
    }


    // 컴퓨터를 종료 하는 함수
    BOOL b = ExitWindowsEx( EWX_POWEROFF, 0 );

    if( b == FALSE )
    {
        printf( "실패 : %d\n", GetLastError() );
    }
}

// 프로세스를 생성하는 간단한 방법들
int main()
{
    //system( "calc.exe" );   // 자식 프로세스가 종료 될때 까지 Blocking 된다.

    WinExec( "calc.exe", SW_SHOW ); // non - Blocking

    cout << "프로그램 계속 실행" << endl;
}

int main()
{
    PROCESS_INFORMATION pi;

    STARTUPINFO si = { 0 };
    si.cb = sizeof(si);

    // 버퍼가 아니라 "calc.exe"(문자열은 const) 로 넘기면
    // 유니코드 환경(내부적으로변경)에서 상수변경 에러 뜬다.
    char name[256] = _T("C:\\windows\\system32\\calc.exe");    // 실행할 프로세스

    BOOL b = CreateProcess(
        0,      // App Name - 절대경로
        name,   // Command Line Arg..
        0,0,    // PKO, TKO 보안
        FALSE,  // Object Table 상속여부
        NORMAL_PRIORITY_CLASS,  // 우선순위 | Flag
        0, 0,   // 환경변수, 현재 디렉토리
        &si,    // 시작정보구조체
        &pi     // 자식 프로세스의 ID와 핸들을 담을 변수
        );

    // 이때 자식프로세스의 참조계수는 2이다.
    cout << "자식프로세스에 접근하기 위한 핸들" << (void*)pi.hProcess << endl;
    cout << "자식프로세스의 스레드에 접근하기 위한 핸들" << (void*)pi.hThread << endl;
   
    // 자식의 핸들을 닫는 것이 중요한다.
    // 닫지 않으면 자식이 종료된 후에도 계속 메모리에 PKO, TKO가 남아 있다.
    // 핸들이 필요 없다면 즉시 닫아라.
    //if ( b )
    //{
    //    // 자식의 핸들을 닫는것이 중요한다.
    //    CloseHandle( pi.hProcess );
          CloseHandle( pi.hThread );
    //}
    // 이때 자식프로세스의 참조계수는 1이다.

    //////////////////////////////////////////////////////////////////////////
    int cmd;
    while( 1 )
    {
        cin >> cmd;

        if ( cmd == 2 )
        {
            // 자식 프로세스를 강제로 종료되게 한다. - 그리고 종료 코드를 채운다.
            TerminateProcess( pi.hProcess, 100 );

            // TermainateProcee는 비동기 함수 이다. 아직 자식이 죽었다고 장담못한다.
            // 모든 프로세스는 죽을때 KO가 signal 된다.
            // 특정 KO가 signal 될 때 까지 대기한다.
            WaitForSingleObject( pi.hProcess, INFINITE );
            // 이제 자식은 정말 죽었다.

            cmd = 1; // 자식이 정말 죽었는지 확인한다.!!!
        }

        if ( cmd == 1 )
        {
            // 자식 프로세스의 종료 코드를 구한다.
            DWORD code;
            GetExitCodeProcess( pi.hProcess, &code );

            if( code == STILL_ACTIVE ) // 0x103
                cout << "아직 자식이 살아 있습니다." << endl;
            else
            {
                cout << "자식 종료 : " << code << endl;
                CloseHandle( pi.hProcess ); // 더이상 핸들이 필요 없으면..
            }
        }
    }

    return 0;
}

int main()
{
    HANDLE hFile = CreateFile(
        "a.txt", GENERIC_READ | GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        0,  // 보안속성
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        0
        );

    cout << "생성된 파일의 핸들 : " << (void*)hFile << endl;

    // 다른 프로세스에 전달한다.
    HWND hwnd = FindWindow( 0, "B" );

    // 윈도우 핸들로 프로세스 ID를 구한다.
    DWORD pid;
    DWORD tid = GetWindowThreadProcessId( hwnd, &pid );

    // 프로세스 ID를 가지고 프로세스 핸들을 얻는다.
    HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );

    // Object Table의 항목을 복사 해준다.
    HANDLE hDest;
    DuplicateHandle(
        GetCurrentProcess(), hFile,  // source
        hProcess,            &hDest, // Target
        0, 0, DUPLICATE_SAME_ACCESS // option
        ); 

    cout << "복사된 항목의 핸들 : " << (void*)hDest << endl;

    /////////////////////////////////////////////////////////
    SendMessage( hwnd, WM_USER+100, 0, (LPARAM)hDest );

    CloseHandle( hFile );   // 1. if (--(fFile.참조개수) == 0 ) Delete KO
                            // 2. Object Table에서 항목을 제거한다.
}

// 윈도우 캡션이 "B"인 윈도우App 하나 만들기
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {
    case WM_USER+100:
        {
            char s1[256] = "hello";
            char s2[256];
            HANDLE hFile = (HANDLE)lParam;
            DWORD len;
            BOOL b = WriteFile( hFile, s1, 256, &len, 0 );

            if( b )
                MessageBox( 0, "성공", "", MB_OK );
            else
            {
                // 에러의 원인을 알아낸다.
                wsprintf( s2, "실패 : %d", GetLastError() );
                MessageBox( 0, s2, "", MB_OK );
            }
        }
        return 0;
        // B을 먼저 실행하세요. 그리고 A을 실행 하세요.
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {
    case WM_LBUTTONDOWN:
        SetCapture( hwnd );
        return 0;

    case WM_LBUTTONUP:
        if( GetCapture() == hwnd )
        {
            ReleaseCapture();

            POINT pt;
            GetCursorPos( &pt ); // 커서의 좌표를 스크린 좌표로 구한다.

            HWND h = WindowFromPoint( pt );

            // 해당 윈도우를 만든 프로세스ID, 스레드 ID를 구한다.
            DWORD pid;
            DWORD tid = GetWindowThreadProcessId( h, &pid );

            // 프로세스 ID를 가지고 해당 프로세스에 접근하기 위한 핸들을 얻는다.
            // (Table에 항목을 만드는 것이다. ************)

            // HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );
            // ALL은 너무 많은 권한
            // 최소 요구의 원칙 - 필요한 권한만 요구하자.****꼭 필요한것만 요구하자.
            HANDLE hProcess = OpenProcess(
                PROCESS_TERMINATE | SYNCHRONIZE,    // 죽이고 | wait 할수 있는 권한
                0,
                pid
                );

            // 이제 핸들을 사용한다.
            TerminateProcess( hProcess, INFINITE );
            DWORD ret = WaitForSingleObject( hProcess, 5000 );

            if( ret == WAIT_OBJECT_0 )  // 숫자 0
            {
                // 강제종료 성공 - KO가 signal 되었다.
            }
            else if( ret == WAIT_TIMEOUT )
            {
                MessageBox( 0, "프로세스를 죽일 수 없습니다.", "", MB_OK );
            }
            else if( ret == WAIT_FAILED )
            {
                // 핸들이 잘못된 경우
            }
            CloseHandle( hProcess );
        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}