IPC在C中使用共享内存

Question

I am implementing IPC using shared memory in C linux. Here is my receiving process. It's receiving correct length but not the message. However sending process is properly sending it. Please see this and let me know the error.

//header files
#include "/home/user/msgbuf.h"
#define SHMSZ    127
int main()
{
    int shmid;
    key_t key;
    message_buf *rbuf;
    rbuf=malloc(sizeof(*rbuf));
    key = ftok("/home/user/shmem",17);

    if ((shmid = shmget(key, SHMSZ, 0666)) < 0)
    {       perror("shmget");
            exit(1);
    }
    printf("\nShared Memory Id = %d\n",shmid);
    if ((rbuf = shmat(shmid, NULL, 0)) == (message_buf *) -1)
    {       perror("shmat");
            exit(1);
    }
    printf("\nMEMORY SEGMENT ATTACHED TO THE CLIENT'S PROCESS\n");

/* Now read what the server put in the memory */
    printf("\nmsglen = %d",rbuf->msglen);  //this is correct
    rbuf->cp=malloc(rbuf->msglen);
    memcpy(&rbuf->cp,rbuf+sizeof(int),sizeof(*rbuf));
    printf("\nMESSAGE :: %s",rbuf->cp); //MESSAGE :: null
    fflush(stdout);
    shmdt(&shmid);
    printf("\nMEMORY SEGMENT %d DETACHED\n",shmid);
    return 0;
}

msgbuf.h is

typedef struct msgbuf1
{
    int msglen;
    char *cp;
}message_buf;

thanks :)

Answer 1

You read a char* from the shared memory region. However, that points to a buffer allocated with malloc, in the remote process. As such it points to the process heap of local to that other process.

This is simply undefined behaviour.

Instead, make the character buffer part of the shared memory data structure:

//header files
#define MAX_SH_BUFSIZE 1024
//
typedef struct msgbuf1
{
    int msglen;
    char cp[MAX_SH_BUFSIZE];
} message_buf;

Answer 2

The problem is with the malloc. malloc addresses have scope till he process not the shared memory. You should not use malloc in shared memory.

Method 1.

Instead use a fix size character array as below:

typedef struct msgbuf1
{
    int msglen;
    char cp[MESSAGE_SIZE];
}message_buf;

Set MESSAGE_SIZE as the maximum size of data you would require.

Method 2. Create a sufficient size shared memory. Make you own malloc and free function which would provide memory from shared memory as and when require. For this you need to keep track of free list, which store the free memory space in the shared memory.

You can divide your shared memory into chunks of like say 256bytes, 512bytes and 1024bytes. Now whenever you require memory the custom malloc function for shared memory shoud hold the logic to provide memory efficiently.

Custom free function would free the shared memory released by program along with adding that chunk(s) in free list