지나간 삶

//////////////////////////////////////////////////////////////////////////////////////
// 이름없는파이프.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();
}