IPCWorkshop

• Download demo project - 40 Kb
• Download source - 10 Kb

Introduction

The main objective of this application was to learn about the various Inter Process Communication methods and how it can be used for data transfer. This application also helps us to decide which of the available IPC methods is best to use. For a description of these IPC mechanisms I have taken a structure pointer named EmployeeData whose pointer is passed from the client to the server. For simplicity this demo application describes one way inter-process communication (ie) from the client to the server. The server will just listen to its clients. Here I have described 5 types of IPCs.

For detailed Information about the Inter Process Communication, you should read MSDN Library\Platform SDK Documentation\Base Services\InterProcess Communications

Clipboard

The clipboard is a set of functions and messages that enable applications to transfer data. Because all applications have access to the clipboard, data can be easily transferred between applications or within an application.

To Write in the Clipboard

1. OpenClipboard
2. Register Clipboard Format (Optional)
3. Use global allocation for the data
4. SetClipboardData
5. CloseClipboard.

To Read from the Clipbaord

1. OpenClipboard
2. Register Clipboard Format (Optional)
3. Check the clipboard format is available
4. Get the clipboard data
5. Unlock the handle

SDK functions are available for the above operations. CClipboard is a class that provides developers with a simple way to implement the clipboard functions. Write the data in the clipboard as easy as shown below.

CClipboard m_objClipboard;
m_objClipboard.Open();
m_objClipboard.Write( (char*)data, size );

CClipboard m_objClipboard;
m_objClipboard.Open();
m_objClipboard.Read( data, size);

Many standard clipboard formats are available. If you want to support more applications to work on the clipboard at the same time, then register a new clipboard format. (Optional)

m_objClipboard.Register("New format") // any name

File Mapping

File mapping is an efficient way for two or more processes on the same computer to share data. Here i have not described about the synchronization of the process. In order to access the file's contents, the processes uses virtual address space called file view. Processes read from and write to the file view using pointers, just as they would with dynamically allocated memory.

To write in the file

1. Create File Mapping
2. map the handle to the process virtual address space (MapViewOfFile)
3. copy the data in the file

To Read from the File

1. Create File Mapping
2. maps the handle to the process virtual address space (MapViewOfFile)
3. copy the data from the file.

CFileMapping m_objFilemapping;
m_objFilemapping.Initialize( "ANY FILE NAME", size/* size of the filemap*/);
m_objFilemapping.Write( (char*) data);

If the name of the filemap is known then we can read the data from any other process as shown below.

CFileMapping m_objFilemapping;
m_objFilemapping.Initialize( "ANY FILE NAME", size);
m_objFilemapping.Read( data );

Notify the server using HWND_BROADCAST handle. we have successfully transferred the pointer between two processes on the same local machine. we get curious of how to pass this pointer in the Intranet if this two processes resides on different computers. Next section is Named Pipes and Mailslots.

Mailslots

To write in the Mailslot

1. Create a Mailslot (CreateMailslot)
2. Write data in the mailslot (WriteFile)

To Read from the Mailslot

1. Open the mailslot (CreateFile)
2. check for the messages in the mail slot (GetMailslotInfo)
3. Read data from the Mailslot (ReadFile)

m_objMailslot.Initialize( <br>
          true /*IsServer*/,<br> 
          "Any Mailslot Name");

m_objMailslot.Initialize(<br>
         false /*IsServer*/,<br>      "Any Mailslot Name");

Internal Details :- A mailslot server is a process that creates and owns a mailslot. When the server creates a mailslot it receives a mailslot handle.

m_strMailslot.Format("\\\\.\\mailslot\\%s", pMailslotName);
m_hInputslot = CreateMailslot(  m_strMailslot,    // mailslot name
                                0,                // message can be of any size
                                MAILSLOT_WAIT_FOREVER, // waits forever for a message
                                NULL             // It cannot be inherited
                             );

The mailslot server can read messages in the mailslot at any time. For the automatic response of the server you can use Listen(messageId, lparam). Here the messageId is the RegisterWindowMessage identity. In the listen function, a worker thread is created to continuously check for messages in the mailslot. If any messages found, it fires to the messageId for the read operation. The total messages will be reduced only at the end of read operation. Hence in this function SendMessageTimeOut is used in order to decrement the message count. Let us check the total messages in the mailslot.

while(1) {
         GetMailslotInfo( This->GetInputslot(), NULL, &message, 
                          &noofMessages, NULL ); 
         if( noofMessages > 0) {
           // The total messages will be reduced only at the end of read operation
           // Hence don't use post message operation.
           LRESULT returnVal = ::SendMessageTimeout(HWND_BROADCAST, 
                                       This->GetTransferMessage(),
                                       NULL, This->GetLparam(), SMTO_BLOCK,
                                       MESSAGETIMEOUT, NULL);
           if( returnVal == 0)
                TRACE("Unable to send message. Error is %d", 
                             GetLastError());
         }
}

Read the mailslot message using the created mailslot handle.

while( noofMessages != 0) {
       ReadFile( m_hInputslot, buffer, size, &dataRead, NULL);
       GetMailslotInfo(  m_hInputslot,           // mailslot handle
                         0,                      // message can be of any size
                         &message,           // size of next message
                         &noofMessages,      // number of messages
                         NULL                    // read time-out interval
                      );
}

A mailslot client is a process that writes a message to a mailslot. Any process that has the name of a mailslot can put a message there. New messages follow any existing messages in the mailslot. The client opens the mailslot using CreateFile.

m_strMailslot.Format("\\\\*\\mailslot\\%s", pMailslotName);
m_hOutputslot = CreateFile(  m_strMailslot,          // file name
                             GENERIC_WRITE,          // Only Write Permission
                             0,                      // cannot be shared
                             NULL,                   // SD
                             OPEN_EXISTING,          // Opens the file. fails if 
                                                     // file doesn't exist
                             FILE_ATTRIBUTE_NORMAL,  // file attributes
                             NULL                    // handle to template file
                          );

Write the data in the mailslot is as simple as shown below.

DWORD sizeWritten;
WriteFile( m_hOutputslot, pData, m_nSize, &sizeWritten, NULL);
if( sizeWritten == 0 )
    TRACE(" Unable to write to the Mail slot. Error is %d", 
          GetLastError() );

NAMEDPIPES

A named pipe is a named, one-way or duplex pipe for communication between the pipe server and one or more pipe clients. Named pipes are like telephone calls: you talk only to one party, but you know that the message is being received.

To Write in the pipe.

1. Create a named pipe. (with or without security attributes)
2. Write the data in the file. (at the time of writing the server should listen)

To read from the pipe

1. Open the named pipe.
2. Continuously read from the pipe
3. Notify that the message has been received.

m_objNamedPipe.Initialize( <br>
          true /*IsServer*/,<br>      
    "." /*Server name*/, <br>      "Any NamedPipe Name");

m_objNamedPipe.Initialize( <br>
       false /*IsServer*/,<br>      "server" /*Server name*/,<br>     
  "Any NamedPipe Name");

Call the Initialize function of the CNamedPipe to create named pipe server and named pipe client. A named pipe server, refers to a process that creates a named pipe.

m_strPipeName.Format("\\\\.\\pipe\\%s", pPipeName);
m_hInputPipeHandle = CreateNamedPipe(
                       m_strPipeName,          // pipe name
                       PIPE_ACCESS_INBOUND,    // client to the server
                       PIPE_WAIT,              // Blocking mode is enabled
                       1,                      // support given to only one client
                       0,                      // output buffer size
                       0,                      // input buffer size
                       PIPE_TIMEOUT,           // time-out interval
                       NULL                    // Security Attributes
                                    );

If the security attribute is NULL, then the transfer of data will be available to only Local machine. Inorder to support across the network, set the security attribute.

SECURITY_ATTRIBUTES saPipe;
saPipe.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR) malloc
                                              (SECURITY_DESCRIPTOR_MIN_LENGTH);
InitializeSecurityDescriptor(saPipe.lpSecurityDescriptor,
                             SECURITY_DESCRIPTOR_REVISION);
// Access Control list is asiigned as NULL inorder to allow all access to 
// the object.
SetSecurityDescriptorDacl(saPipe.lpSecurityDescriptor, TRUE, (PACL) NULL,FALSE);
saPipe.nLength = sizeof(saPipe);
saPipe.bInheritHandle = TRUE; 

This created pipe will listen continuously for the client to write data. Inorder to satisfy this condition a worker thread is created. In the mailslot the infinite thread is an optional, we can give an external control to read from the mailslot. Since the pipe is created in the blocking mode, this infinite thread is necessary. Otherwise the client will get hanged while writing data. This thread named as Listenerproc will continuously read the file. If the data is read then it will notify to the messageId.

UINT ListenerProc( LPVOID pNamedPipe )
{
    CNamedPipe* This = (CNamedPipe*)pNamedPipe;
    if( This == NULL )
        return 0;
    int size = This->GetSize();

    // assign the size of the data to be read.
    ASSERT( size != 0 );
    ASSERT( This->GetTransferMessage() != NULL);
    char* buff = new char[size];
    DWORD dataRead;
    while(1) {
        BOOL isRead = ReadFile( This->GetInputPipeHandle(), 
                                          buff, size, &dataRead, NULL);
        if( dataRead > 0) {
            // acts as a post thread message
            // since this is internal to the process, it can also 
            // work on the network satisfying the named pipe advantage.
            ::PostMessage( HWND_BROADCAST, 
                This->GetTransferMessage(), (WPARAM)buff, This->GetLparam());
        }        
    }
    return 1;
}

A named pipe client, opens the named pipe handle using CreateFile. With the help of the handle the client writes the data to the server. This procedure is same as in the mailslot. please refer above.

Sockets

CDerivedSocket is a class derived from the MFC class CSocket. This class only describes the data transfer from the client to the server.

History

Version 1.0