규격

실행인자

환경변수

파일

가장 단순

    HANDLE hTempFile_ = INVALID_HANDLE_VALUE;
    HANDLE hTempFile2 = INVALID_HANDLE_VALUE;
    TCHAR sTempFile[MAX_PATH];

    memset(sTempFile, 0, sizeof sTempFile);
    try
    {
        TCHAR lpTempPathBuffer[MAX_PATH];
        DWORD dwRetVal = 0;

        memset(lpTempPathBuffer, 0, sizeof lpTempPathBuffer);
        dwRetVal = GetTempPath(MAX_PATH, lpTempPathBuffer);
        if (dwRetVal > MAX_PATH || (dwRetVal == 0)) { throw 100; }

        if (GetTempFileName(lpTempPathBuffer, _T("mine"), 0, sTempFile) == 0) { throw 200; }

        /* const */SECURITY_ATTRIBUTES StdOutSA = { sizeof (SECURITY_ATTRIBUTES), NULL, TRUE };

        hTempFile_ = CreateFile(sTempFile, GENERIC_WRITE,
                FILE_SHARE_READ | FILE_SHARE_WRITE, &StdOutSA,
                CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hTempFile_ == INVALID_HANDLE_VALUE) { throw 300; }

        STARTUPINFO StartUpSearch;
        PROCESS_INFORMATION ProcessInfo;

        GetStartupInfo(&StartUpSearch);
        StartUpSearch.dwFlags = STARTF_USESTDHANDLES;
        StartUpSearch.hStdOutput = hTempFile_;
        if (!CreateProcess(NULL, "...", NULL, NULL, TRUE, 0, NULL, NULL, &StartUpSearch, &ProcessInfo)) { throw 400; }

        CloseHandle(hTempFile_); hTempFile_ = INVALID_HANDLE_VALUE;
        CloseHandle(ProcessInfo.hThread);
        WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
        CloseHandle(ProcessInfo.hProcess);

        hTempFile2 = CreateFile(sTempFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (hTempFile2 == INVALID_HANDLE_VALUE) { throw 500; }

        DWORD nIn;
        BYTE Buffer[BUF_SIZE];

        while (ReadFile(hTempFile2, Buffer, BUF_SIZE, &nIn, NULL) && (nIn != 0)) {
                ..
        }
    } catch (int errNo) {
        ShowMessage("err %d", errNo);
    }

    if (INVALID_HANDLE_VALUE != hTempFile_) CloseHandle(hTempFile_);
    if (INVALID_HANDLE_VALUE != hTempFile2) CloseHandle(hTempFile2);

//    ShowMessage("Before DeleteFile(%s)", sTempFile);
    if (0 != strcmp(sTempFile, "") && !DeleteFile(sTempFile)) {
        ShowError();
        return;
    }

DDE

Atom

클립보드

잘라내서-붙여넣기

Drag & Drop // 끌어서-놓기

윈도우 메시지 // 사용자 정의 메시지

c.f. WaitForInputIdle()

WM_COPYDATA

정수 하나와 포인터 하나를 보낼 수 있다.
c.f. WaitForInputIdle()

void CIPC4Dlg::OnButtonSend()
{
    // TODO: Add your control notification handler code here
    ...
    CWnd *pWnd = CWnd::FindWindow(NULL, "...");
    if(!pWnd) {
        AfxMessageBox("Program is not found!");
        return;
    }

    COPYDATASTRUCT cds;

    cds.dwData = 1004; // 교환하고자 하는 정수값
    cds.cbData = strData.GetLength()+1;
    cds.lpData = strData.GetBuffer(strData.GetLength());
    pWnd->SendMessage(WM_COPYDATA, (WPARAM)m_hWnd, (LPARAM)&cds);
    strData.ReleaseBuffer();
}


class CIPC5Dlg : public CDialog
{
...
    // Generated message map functions
    //{{AFX_MSG(CIPC5Dlg)
    ...
    afx_msg HCURSOR OnQueryDragIcon();
    afx_msg BOOL OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};


BEGIN_MESSAGE_MAP(CIPC5Dlg, CDialog)
    //{{AFX_MSG_MAP(CIPC5Dlg)
    ...
    ON_WM_QUERYDRAGICON()
    ON_WM_COPYDATA()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()
...
BOOL CIPC5Dlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)
{
    // TODO: Add your message handler code here and/or call default
// {
    switch(pCopyDataStruct->dwData) {
    case 1004 :
        .. pCopyDataStruct->lpData ..
        break;
    }
// }
    return CDialog::OnCopyData(pWnd, pCopyDataStruct);
}

CloseHandle()
SetHandleInformation()
GetHandleInformation()

공유 메모리

익명 파이프

CreatePipe()
CloseHandle()
SetHandleInformation()

HANDLE_FLAG_INHERIT

WriteFile()

HANDLE g_hChildStd_OUT_Rd = NULL;
HANDLE g_hChildStd_OUT_Wr = NULL;
HANDLE g_hChildStd_IN_Rd = NULL;
HANDLE g_hChildStd_IN_Wr = NULL;

// Create a child process that uses the previously created pipes for STDIN and STDOUT.
void CreateChildProcess()
{
   TCHAR szCmdline[] = TEXT("child");
   PROCESS_INFORMATION piProcInfo;
   STARTUPINFO siStartInfo;
   BOOL bSuccess = FALSE;
 
// Set up members of the STARTUPINFO structure.
// This structure specifies the STDIN and STDOUT handles for redirection.
   ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
   siStartInfo.cb = sizeof(STARTUPINFO);
   siStartInfo.hStdError = g_hChildStd_OUT_Wr;
   siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;
   siStartInfo.hStdInput = g_hChildStd_IN_Rd;
   siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
 
   ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); // Set up members of the PROCESS_INFORMATION structure.
 
// Create the child process.
   bSuccess = CreateProcess(NULL,
      szCmdline,     // command line
      NULL,          // process security attributes
      NULL,          // primary thread security attributes
      TRUE,          // handles are inherited
      0,             // creation flags
      NULL,          // use parent's environment
      NULL,          // use parent's current directory
      &siStartInfo,  // STARTUPINFO pointer
      &piProcInfo);  // receives PROCESS_INFORMATION
   if ( ! bSuccess ) ErrorExit(TEXT("CreateProcess")); // If an error occurs, exit the application.

  // Close handles to the child process and its primary thread.
  // Some applications might keep these handles to monitor the status
  // of the child process, for example.
  CloseHandle(piProcInfo.hProcess);
  CloseHandle(piProcInfo.hThread);
}

HANDLE g_hInputFile = NULL;

#define BUFSIZE 4096

// Read from a file and write its contents to the pipe for the child's STDIN.
// Stop when there is no more data.
void WriteToPipe(void)
{
   DWORD dwRead, dwWritten;
   CHAR chBuf[BUFSIZE];
   BOOL bSuccess = FALSE;
 
   for (;;)
   {
      bSuccess = ReadFile(g_hInputFile, chBuf, BUFSIZE, &dwRead, NULL);
      if ( ! bSuccess || dwRead == 0 ) break;
     
      bSuccess = WriteFile(g_hChildStd_IN_Wr, chBuf, dwRead, &dwWritten, NULL);
      if ( ! bSuccess ) break;
   }
 
// Close the pipe handle so the child process stops reading.
   if ( ! CloseHandle(g_hChildStd_IN_Wr) ) ErrorExit(TEXT("StdInWr CloseHandle"));

}

// Read output from the child process's pipe for STDOUT
// and write to the parent process's pipe for STDOUT.
// Stop when there is no more data.
void ReadFromPipe(void)
{
   DWORD dwRead, dwWritten;
   CHAR chBuf[BUFSIZE];
   BOOL bSuccess = FALSE;
   HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

// The pipe is assumed to have enough buffer space to hold the
// data the child process has already written to it.
   for (;;) {
      bSuccess = ReadFile( g_hChildStd_OUT_Rd, chBuf, BUFSIZE, &dwRead, NULL);
      if ( ! bSuccess || dwRead == 0 ) break;

      bSuccess = WriteFile(hParentStdOut, chBuf, dwRead, &dwWritten, NULL);
      if (! bSuccess ) break;

   }

   if ( ! CloseHandle(g_hChildStd_OUT_Rd) ) ErrorExit(TEXT("StdOutRd CloseHandle"));

}

int _tmain(int argc, TCHAR *argv[])
{
// <
   if (argc == 1) ErrorExit(TEXT("Please specify an input file.\n"));


   SECURITY_ATTRIBUTES saAttr;

// Set the bInheritHandle flag so pipe handles are inherited. 
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
   saAttr.bInheritHandle = TRUE;
   saAttr.lpSecurityDescriptor = NULL;

// Create a pipe for the child process's STDIN.
   if (! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)) ErrorExit(TEXT("Stdin CreatePipe"));

// Ensure the write handle to the pipe for STDIN is not inherited.
   if ( ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) ) ErrorExit(TEXT("Stdin SetHandleInformation"));
 

// Create a pipe for the child process's STDOUT.
   if (!CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0) ) ErrorExit(TEXT("StdoutRd CreatePipe"));

// Ensure the read handle to the pipe for STDOUT is not inherited.
   if ( ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) ) ErrorExit(TEXT("Stdout SetHandleInformation"));


   CreateChildProcess(); // Create the child process.

   if (!CloseHandle(g_hChildStd_IN_Rd)) ErrorExit(TEXT("StdInRd CloseHandle"));

   if (!CloseHandle(g_hChildStd_OUT_Wr)) ErrorExit(TEXT("StdOutWr CloseHandle"));

// Get a handle to an input file for the parent.
// This example assumes a plain text file and uses string output to verify data flow.
   g_hInputFile = CreateFile(argv[1], GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
   if ( g_hInputFile == INVALID_HANDLE_VALUE ) ErrorExit(TEXT("CreateFile"));
 
// Write to the pipe that is the standard input for a child process.
// Data is written to the pipe's buffers, so it is not necessary to wait
// until the child process is running before writing data.
   WriteToPipe();

// Read from pipe that is the standard output for child process.
   ReadFromPipe();
// >
    return 0;
}

명명된 파이프

The named pipe instance is a global resource

CreateNamedPipe()

PIPE_ACCESS_DUPLEX

PIPE_TYPE_BYTE

CloseHandle()
ConnectNamedPipe() // blocking, listen? // indicating that there is an available named pipe instance

ERROR_PIPE_CONNECTED

DisconnectNamedPipe() // for connection with another client
ReadFile()
WriteFile()

CreateFile()

ERROR_PIPE_BUSY

OPEN_EXISTING

WaitNamedPipe() // blocking??, connect?

ConnectNamedPipe()

NMPWAIT_WAIT_FOREVER

Nonetheless, the client's CreateFile call could fail if some other client opens the named pipe instance or if the server closes the instance's handle.

CloseHandle()

allowing another client to connect on the same named pipe instance

ReadFile()
WriteFile()
FlushFileBuffers()

IO Completion Ports

Non-Blocking Reads and Writes using Overlapped IO

DWORD WINAPI PipeThread(LPVOID temp);

DWORD WINAPI MainThread(LPVOID temp);

LRESULT CALLBACK WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{   
    switch (iMessage) {
    case WM_CREATE: {
        DWORD ThreadID;

        CloseHandle(CreateThread(NULL, 0, MainThread, NULL, 0, &ThreadID));
                    }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    ..
                   }
        return 0;

    }

    return(DefWindowProc(hWnd,iMessage,wParam,lParam));
}

// 클라이언트 하나당 하나씩의 스레드를 만든다.
static DWORD WINAPI MainThread(LPVOID temp)
{
    for (;;)
    {
        HANDLE hPipe;
        DWORD ThreadID;
        BOOL bCon;

        hPipe=CreateNamedPipe("\\\\.\\pipe\\MultiPipe",PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE, 3,4096,0,1,NULL); // 파이프 생성

        // 차일드 대기. 접속되면 차일드 요청 처리 스레드 생성
        bCon=ConnectNamedPipe(hPipe,NULL);
        if ((bCon==FALSE) && (GetLastError() == ERROR_PIPE_CONNECTED)) bCon=TRUE;

        if (bCon!=TRUE) {
            CloseHandle(hPipe);
            continue;

        }

        CloseHandle(CreateThread(NULL,0,PipeThread,(LPVOID)hPipe,0,&ThreadID));
    }

    return 0;
}

// 차일드의 요청을 처리한다.
static DWORD WINAPI PipeThread(LPVOID temp)
{
    HANDLE hPipe=(HANDLE)temp;

    // 요청을 받고 연산을 한 후 응답을 보낸다.
    for (;;)
    {
        TCHAR szInput[255], szOutput[255];
        DWORD dwRead, dwWritten;
        BOOL bSuc;

        bSuc=ReadFile(hPipe,szInput,255,&dwRead,NULL);
        if ((bSuc==FALSE) || (dwRead==0)) { break; }

        ..
        bSuc=WriteFile(hPipe,szOutput,lstrlen(szOutput)+1,&dwWritten,NULL);
        if ((bSuc==FALSE) || (dwWritten==0)) {
            break;
        }
    }

    // 파이프 해제
    FlushFileBuffers(hPipe);
    DisconnectNamedPipe(hPipe);

    CloseHandle(hPipe);
    return 0;
}

// Try to open a named pipe; wait for it, if necessary.
 
   while (1)
   {
      hPipe = CreateFile(
         lpszPipename,   // pipe name
         GENERIC_READ |  // read and write access
         GENERIC_WRITE,
         0,              // no sharing
         NULL,           // default security attributes
         OPEN_EXISTING,  // opens existing pipe
         0,              // default attributes
         NULL);          // no template file
 
   // Break if the pipe handle is valid.
 
      if (hPipe != INVALID_HANDLE_VALUE)
         break;
 
      // Exit if an error other than ERROR_PIPE_BUSY occurs.
 
      if (GetLastError() != ERROR_PIPE_BUSY)
      {
         _tprintf( TEXT("Could not open pipe. GLE=%d\n"), GetLastError() );
         return -1;
      }
 
      // All pipe instances are busy, so wait for 20 seconds.
 
      if ( ! WaitNamedPipe(lpszPipename, 20000))
      {
         printf("Could not open pipe: 20 second wait timed out.");
         return -1;
      }
   }
..

메일 슬롯 // be like a message queue

CreateMailslot()

MAILSLOT_WAIT_FOREVER

CloseHandle()
GetMailslotInfo() // polling

can retrieve the size (in bytes) of the next record (if any)

ReadFile() // blocking
CreateFile()
CloseHandle()
WriteFile()

소켓

RPC

COM/DCOM


참조 사이트:

http://www.debuglab.com/knowledge/atom.html
http://myfile.hanafos.com/~kukdas/doc/mfc/ipc2.html
http://myfile.hanafos.com/~kukdas/doc/mfc/ipc.html
http://serious-code.net/moin.cgi/IPC
http://msdn.microsoft.com/en-us/library/ms682499%28v=VS.85%29.aspx