C / C++ / MFC

TCHAR szMsg[]=TEXT("Message from first process.");
CopyMemory((PVOID)pBuf, szMsg, (_tcslen(szMsg) * sizeof(TCHAR)));  

hMapFile = OpenFileMapping(
                   FILE_MAP_ALL_ACCESS,   // read/write access
                   FALSE,                 // do not inherit the name
                   szName);   

 pBuf = (LPTSTR) MapViewOfFile(hMapFile, // handle to map object
               FILE_MAP_ALL_ACCESS,  // read/write permission
               0,                    
               0,                    
               BUF_SIZE);   

 MessageBox(NULL, pBuf, TEXT("Process2"), MB_OK);

#include <stdio.h>
#include <stdlib.h>

#define buffSize 2048
char buffer[buffSize];

void initBuffer()
{
    memset((PVOID)buffer, 0, sizeof(char) * buffSize);
}

// returns number of messages in buffer
// -1 if failed
int addMsg(char *msg)
{
    long msgCount, curMsgIndex, curMsgLen;
    char *newStrPos;

    memcpy((PVOID)&msgCount, buffer, sizeof(long));

    newStrPos = (char*) (long)&buffer + sizeof(long);

    for (curMsgIndex=0; curMsgIndex<msgCount; curMsgIndex++)
    {
        curMsgLen = strlen(newStrPos);
        newStrPos += curMsgLen + 1;
    }

    // don't forget to check that this message won't overflow the buffer!!!
    // I didn't bother for this simple example
    //if ( ((newStrPos-buffer)+strlen(msg)+1) < buffSize)
    {
        printf("adding message\n");
        strcpy(newStrPos, msg);
        msgCount++;
        memcpy((PVOID)buffer, &msgCount, sizeof(long));
    }
    //else
    //    printf("unable to add message\n");

}

void printMessages()
{
    long msgCount, curMsgNum;
    char *curMsg;

    memcpy(&msgCount, buffer, sizeof(long));
    curMsg = (char*)(long)&buffer + sizeof(long);
    for (curMsgNum=0; curMsgNum<msgCount;curMsgNum++)
    {
            printf("%s\n", curMsg);
            curMsg += strlen(curMsg) + 1;
    }
}

int main()
{
    initBuffer();
    addMsg("This is msg 1");
    addMsg("This is msg 2");
    printMessages();
    return 0;
}

"http://msdn.microsoft.com/en-us/library/aa366551(v=vs.85).aspx"

TCHAR szMsg[]=TEXT("Message from first process.");

"Message from first process." to second process,

// process1.c
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

#define BUF_SIZE 2048

char *szName = "Global\MyFileMappingObject";
char *pSharedBuffer;

int addMsg(char *msg, char *buffer)
{
    long msgCount, curMsgIndex, curMsgLen;
    char *newStrPos;

    // get count of messages stored
    memcpy(&msgCount, buffer, sizeof(long));

    // first message begins after sizeof(long) bytes - since we stored the num of messages as a long
    newStrPos = (char*) (long)buffer + sizeof(long);

    // step through the buffer, until we find the next free space to insert a new message
    for (curMsgIndex=0; curMsgIndex<msgCount; curMsgIndex++)
    {
        curMsgLen = strlen(newStrPos);
        newStrPos += curMsgLen + 1;
    }

    // copy the message
    strcpy(newStrPos, msg);

    // update the message count
    msgCount++;
    memcpy(buffer, &msgCount, sizeof(long));

    return 0;
}

int main()
{
    HANDLE handleMappedFile;
    LPVOID lpMsgBuf;

    handleMappedFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, HIWORD(BUF_SIZE), LOWORD(BUF_SIZE), szName);
    if (handleMappedFile == NULL)
    {
        printf("Could not create file mapping object.\n");
        LocalFree( lpMsgBuf );
        return 1;
    }

    pSharedBuffer = (char*)MapViewOfFile(handleMappedFile, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE);
    if (pSharedBuffer == NULL)
    {
        printf("Could not map view of file.\n");
        CloseHandle(handleMappedFile);
        return 1;
    }

    // initialize the shared mem
    memset((PVOID)pSharedBuffer, 0, sizeof(char) * BUF_SIZE);

    addMsg("This is msg 1", pSharedBuffer);
    addMsg("This is msg 2", pSharedBuffer);
    addMsg("This is msg 3", pSharedBuffer);

//    // code used to write mapped mem to a disk file for debugging purposes.
//    FILE *fp;
//    char *fName = "buffData.dat";
//    fp = fopen(fName, "wb");
//    fwrite(pSharedBuffer, 1, BUF_SIZE, fp);
//    fclose(fp);

    getch();
    UnmapViewOfFile(pSharedBuffer);
    printf("File unmapped\n");

    CloseHandle(handleMappedFile);
    printf("handle closed.\n");

    return 0;
}

// process2.c
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>

#define BUF_SIZE 2048
char *szName1= "Global\MyFileMappingObject";
char *pSharedBuffer;

int main()
{
    HANDLE hMappedFile;

    hMappedFile = OpenFileMapping(ILE_MAP_ALL_ACCESS, FALSE, szName1); // name of mapping object
    if (hMappedFile == NULL)
    {
        printf("Could not open file mapping object (%d).\n",GetLastError());
        return 1;
    }

    pSharedBuffer = MapViewOfFile(hMappedFile, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE);
    if (pSharedBuffer == NULL)
    {
        printf("Could not map view of file (%d).\n", GetLastError());
        CloseHandle(hMappedFile);
        return 1;
    }

    long msgCount, curMsgNum;
    char *curMsg;
    memcpy(&msgCount, pSharedBuffer, sizeof(long));
    printf("---- Messages retrieved: %d ----\n", msgCount);
    curMsg = (char*)pSharedBuffer + sizeof(long);
    for (curMsgNum=0; curMsgNum<msgCount; curMsgNum++)
    {
        printf("msg(%d): %s\n", curMsgNum, curMsg);
        curMsg += strlen(curMsg) + 1;
    }

    UnmapViewOfFile(pSharedBuffer);
    CloseHandle(hMappedFile);
    getch();
    return 0;
}