지나간 삶

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();
    }
}

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

#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);
}

// 특정 메뉴를 OWNERDRAW로 변경하고 ItemData에 색상을 넣어 준다.
void AddMenuColor( HMENU hMenu, UINT id, COLORREF color )
{
    ModifyMenu( hMenu, id, MF_BYCOMMAND | MF_OWNERDRAW, id, "" );
    // ItemData에 색상을 기록해 둔다.
    MENUITEMINFO mi = { 0 };
    mi.cbSize = sizeof(mi);
    mi.dwItemData = (DWORD)color;
    mi.fMask = MIIM_DATA;
    SetMenuItemInfo( hMenu, id, FALSE, &mi );    // FALSE :2번째 인자가 ID라는 의미.TRUE:POSITION
}
LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_CREATE:
        {
            // 그리기 메뉴 1단계 - 메뉴항목의 속성을 OWNERDRAW로 변경한다.
            HMENU h1 = GetMenu( hwnd );
            HMENU h2 = GetSubMenu( h1, 0 );

            AddMenuColor( h2, ID_RED, RGB( 255, 0, 0 ) );
            AddMenuColor( h2, ID_BLUE, RGB( 0, 0, 255 ) );
            AddMenuColor( h2, ID_GREEN, RGB( 0, 255, 0 ) );
           
            // ModifyMenu(
            //    h2,                // 팝업메뉴 핸들
            //    ID_RED,            // ID 또는 Position
            //    MF_BYCOMMAND | MF_OWNERDRAW,
            //    // 2번째 파라미터의 해석 방법 | 속성...
            //    // MF_BYCOMMAND(ID), MF_BYPOSITION(순서)
            //    ID_RED,            // 변경할 ID
            //    "빨간색"            // 변경할 Text
            //    );
        }
        return 0;
    case WM_MEASUREITEM:
        {
            // 그리기 메뉴 2단계
            // OS 가 구조체를 만들어서 포인터를 보내준다. 그 구조체에 크기를 채워준다.
            LPMEASUREITEMSTRUCT p = (LPMEASUREITEMSTRUCT)lParam;

            if( p->itemID == ID_RED || p->itemID == ID_BLUE || p->itemID == ID_GREEN )
            // 메뉴 Item ID 조사
            {
                p->itemWidth = GetSystemMetrics( SM_CYMENU ) * 4;
                p->itemHeight = GetSystemMetrics( SM_CYMENU );
            }
        }
        return 0;
    case WM_DRAWITEM:
        {
            // 그리기 메뉴 3단계 - Item 에 원하는 그림을 그린다.
            LPDRAWITEMSTRUCT p = (LPDRAWITEMSTRUCT)lParam;

            HDC hdc = p->hDC;
            RECT rc = p->rcItem;    // 그려야 하는 Item의 크기
            int state = p->itemState;    // Item의 상태
            int id = p->itemID;

            if( id == ID_RED || p->itemID == ID_BLUE || p->itemID == ID_GREEN )
            {
                RECT rcTemp = rc;

                // 선택여부를 조사한다.
                COLORREF c;
                /////////////////////////////////////////////////////
                if( state & ODS_SELECTED )    // 선택여부를 나타내는 필드
                {
                    c = GetSysColor( COLOR_HIGHLIGHT );
                    InflateRect( &rcTemp, -2, -2 );    // 사각형을 줄인다.
                }
                else
                {
                    c = GetSysColor( COLOR_MENU );
                    InflateRect( &rcTemp, -5, -5 );    // 사각형을 줄인다.
                }
                /////////////////////////////////////////////////////
                HBRUSH hBrush1 = CreateSolidBrush( c );
                FillRect( hdc, &rc, hBrush1 );

                // ItemData에서 색상을 얻는다.
                COLORREF color = (COLORREF)(p->itemData);
                HBRUSH hBrush = CreateSolidBrush( color );
                FillRect( hdc, &rcTemp, hBrush );

                DeleteObject( hBrush1 );
                DeleteObject( hBrush );
            }
        }
        return 0;

    case WM_RBUTTONUP:
        return DefWindowProc( hwnd, msg, wParam, lParam );    // MSDN에서 강조함!!확인!

    // ContextMenu 나타내기 - Tray에서 나타내려면 WM_RBUTTONUP을 사용해라.!
    case WM_CONTEXTMENU:
        {
            // 1. 메뉴 Load
            HMENU hMenu = LoadMenu( GetModuleHandle(0), MAKEINTRESOURCE(IDR_MENU1) );

            // 2. 나타낼 팝업 메뉴 핸들 얻기
            HMENU hSubMenu = GetSubMenu( hMenu, 0 );

            // 3. 현재 커서의 위치에 나타낸다.
            POINT pt;
            GetCursorPos( &pt );

            TrackPopupMenu(
                hSubMenu, TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
                pt.x, pt.y,        // 좌표
                0,                // Reserved(사용안함)
                hwnd,            // 메뉴 메세지를 받을 윈도우
                0 );            // 사용안함.

            // LoadIcon, LoadCursor는 Destroy 할 필요없다.
            // LoadMenu 는 Destroy 해야 한다. --- MSDN 참고.
            DestroyMenu( hMenu );
        }
        return 0;

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

// DialogBoxParam 을 사용하기 위해선 구조체가 필요하다.
// 각 컨트롤에서 값을 꺼내기 위해 사용한다.
typedef struct _DATA
{
    int cx;
    int cy;
}DLGDATA;

// DialogBox를 나타내려면 DialogProc가 있어야 한다.
BOOL CALLBACK DlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
    static DLGDATA* pData;

    switch( msg )
    {
    case WM_INITDIALOG:
        {
            // 부모를 사용가능하게 한다.
            pData = (DLGDATA*)lParam;

            // 구조체 값으로 컨트롤을 초기화 한다.
            SetDlgItemInt( hDlg, IDC_EDIT1, pData->cx, 0 );
            SetDlgItemInt( hDlg, IDC_EDIT2, pData->cy, 0 );

            // 부모를 사용가능하게 한다.
            //EnableWindow( GetParent( hDlg ), TRUE );
        }
        return TRUE;

    case WM_COMMAND:
        switch( LOWORD(wParam) )
        {
        case IDOK:
            {
                // 값을 꺼내서 부모가 전달해 준 구조체에 넣는다.
                BOOL bRet = 0;

                pData->cx = GetDlgItemInt( hDlg, IDC_EDIT1, &bRet, 0 );
                pData->cy = GetDlgItemInt( hDlg, IDC_EDIT2, &bRet, 0 );
                /*
                char buf[256];
                // 결국 각 Control의 ID를 핸들로 변경하면 다양한 윈도우 관련 함수를 사용가능하다.
                //HWND hEdit = GetDlgItem( hDlg, IDC_EDIT1 );
                //GetWindowLong( hEdit, buf, 256 );

                GetDlgItemText( hDlg, IDC_EDIT1, buf, 256 );
                MessageBox( 0, buf, "", MB_OK );
                */
                //////////////////////////////////////////////////////////////////////////
               
                EndDialog( hDlg, IDOK );    // 모달 Dialog를 닫는다.
            }
            break;
        case IDCANCEL:    EndDialog( hDlg, IDCANCEL ); break;
        }
        return TRUE;    // 메세지를 처리한 경우
    }
    return FALSE;    // 메세지를 처리 하지 않은 경우
}

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

    switch( msg )
    {
        RECT aa;

    case WM_LBUTTONDOWN:
        {
            DialogBox( 0, 0, 0, 0 );
            // 값을 꺼내오기 위해서 구조체 생성
            DLGDATA data;
            data.cx = sx;
            data.cy = sy;
            // 모달 Dialog 나타내기
            UINT ret = DialogBoxParam(
                GetModuleHandle( 0 ),            // hInstance
                MAKEINTRESOURCE( IDD_DIALOG1 ),    // 리소스 ID
                hwnd,                            // 부모 윈도우 핸들
                (DLGPROC)DlgProc,                // 메세지 함수
                (LPARAM)&data                    // WM_INITDIALOG의 lParam으로 간다.
                );

            if ( ret == IDOK )                    // EndDialog의 리턴값
            {
                // 구조체에서 값을 꺼내서 static 변수에 넣어 놓고 사용한다.
                sx = data.cx;
                sy = data.cy;

                InvalidateRect( hwnd, 0, TRUE );
            }
        }
        return 0;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );

            TextOut( hdc, sx, sy, "hello", 5 );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

 // 메뉴를 적재하는 3가지 방법중 1번째
 // 1. 윈도우 클래스에 메뉴 리소스 ID를 등록한다.
 wc.lpszMenuName = IDR_MENU1;

 // 메뉴를 붙이는 2번쨰 방법.
 // 2. CreateWindowEx 9번째 인자를 사용한다.
 hMenu = LoadMenu( hInstance, MAKEINTRESOURCE(IDR_MENU1) );
 SetMenu( hwnd, hMenu );

// 3. 핸들을 얻어내서 추가하기
 HMENU h1 = GetMenu( hwnd );    // 메뉴 바의 핸들을 얻는다.
 HMENU h2 = GetSubMenu( h1, 0 );    // h1의 1번째 팝업 메뉴의 핸들을 얻는다.

 MENUINFO mi = { 0 };
 mi.cbSize = sizeof( mi );
 mi.hbrBack = CreateSolidBrush( RGB( 0, 255, 0 ) );
 mi.fMask = MIM_BACKGROUND;
  // 팝업 메뉴를 관리하는 구조체를 변경한다.
 SetMenuInfo( h2, &mi );

 //AppendMenu( h2, MF_STRING, 50001, "추가메뉴" );
 //// 메뉴 바에도 직접 추가 할 수 있다.
 //AppendMenu( h1, MF_STRING, 50002, "AAA" );
 /// 메뉴 바에 추가한 경우 즉시 그리게 한다.
 //DrawMenuBar( hwnd );

           if ( bFull == FALSE )
            {
                bFull = TRUE;

                hMenu = GetMenu( hwnd );    // 메뉴 핸들을 보관하고
                SetMenu( hwnd, 0 ); // 메뉴를 떼어낸다.

                ModifyStyle( hwnd, WS_CAPTION, 0 );
                ShowWindow( hwnd, SW_MAXIMIZE );
            }
            else
            {
                bFull = FALSE;
                SetMenu( hwnd, hMenu );
                hMenu = 0;
                ModifyStyle( hwnd, 0, WS_CAPTION );
                ShowWindow( hwnd, SW_SHOWNORMAL );
            }

    while ( GetMessage( &msg, 0, 0, 0) )
    {   
        // 모달리스는 자체 루프를 가지고 있지 않다.
        // 그래서... IsDialogMessage()를 직접 호출해야 한다.

        if ( !IsWindow( g_hDlg ) || !IsDialogMessage( g_hDlg, &msg ))
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
    }
// DialogBox를 나타내려면 DialogProc가 있어야 한다.
BOOL CALLBACK DlgProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
    static DLGDATA* pData;

    switch( msg )
    {
    case WM_INITDIALOG:
        {
            // 부모를 사용가능하게 한다.
            pData = (DLGDATA*)lParam;

            // 구조체 값으로 컨트롤을 초기화 한다.
            SetDlgItemInt( hDlg, IDC_EDIT1, pData->cx, 0 );
            SetDlgItemInt( hDlg, IDC_EDIT2, pData->cy, 0 );

            // 부모를 사용가능하게 한다.
            //EnableWindow( GetParent( hDlg ), TRUE );
        }
        return TRUE;

    case WM_COMMAND:
        switch( LOWORD(wParam) )
        {
        case IDOK:
            {
                // 값을 꺼내서 부모가 전달해 준 구조체에 넣는다.
                BOOL bRet = 0;

                pData->cx = GetDlgItemInt( hDlg, IDC_EDIT1, &bRet, 0 );
                pData->cy = GetDlgItemInt( hDlg, IDC_EDIT2, &bRet, 0 );

                // Data를 꺼내서 구조체에 넣어두고, 부모에게 메세지를 보내서 즉시 update 한다.
                SendMessage( GetParent(hDlg), WM_USER+100, 0, 0 );

            }
            break;
        case IDCANCEL:
            DestroyWindow( hDlg );
            g_hDlg = 0;    // 그래야 다음번 모달리스 Dialog가 나타난다.

            break;
        }
        return TRUE;    // 메세지를 처리한 경우
    }
    return FALSE;    // 메세지를 처리 하지 않은 경우
}

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

    // 값을 꺼내오기 위해서 구조체 생성
    static DLGDATA data;

    switch( msg )
    {
    case WM_USER+100:
        sx = data.cx;
        sy = data.cy;

        InvalidateRect( hwnd, 0, TRUE );
        return 0;

    case WM_LBUTTONDOWN:
        {
            if ( g_hDlg == 0 )
            {
                data.cx = sx;
                data.cy = sy;
                // 모달리스 Dialog 나타내기
                g_hDlg = CreateDialogParam(
                    GetModuleHandle( 0 ),            // hInstance
                    MAKEINTRESOURCE( IDD_DIALOG1 ),    // 리소스 ID
                    hwnd,                            // 부모 윈도우 핸들
                    (DLGPROC)DlgProc,                // 메세지 함수
                    (LPARAM)&data                    // WM_INITDIALOG의 lParam으로 간다.
                    );
                ShowWindow( g_hDlg, SW_SHOW );
            }
            else
            {
                // Focus를 이동해서 사용자에게 알려준다.
                SetFocus( g_hDlg );
            }
        }
        return 0;
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint( hwnd, &ps );
            TextOut( hdc, sx, sy, "hello", 5 );
            EndPaint( hwnd, &ps );
        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}