When you specify IPC_PRIVATE as the key to a get call, the kernel always creates a brand new IPC object with a unique identifier. You don’t need IPC_CREAT or IPC_EXCL — they are implied.

The main use case for IPC_PRIVATE is in parent-child process communication: the parent creates the IPC object before calling fork(), and the child inherits the identifier (since it’s just an integer in the process’s data).

Classic use: parent creates the IPC object before fork(), child inherits the ID.

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <wait.h>

/* Simple message structure */
struct mymsg {
    long mtype;          /* must be > 0 */
    char mtext[100];
};

int main(void) {
    int msqid;
    struct mymsg msg;
    pid_t pid;

    /* IPC_PRIVATE always creates a new unique queue */
    msqid = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    printf("[Parent] Created queue with ID = %d\n", msqid);

    pid = fork();
    if (pid == -1) { perror("fork"); exit(EXIT_FAILURE); }

    if (pid == 0) {
        /* CHILD: sends a message */
        msg.mtype = 1;
        snprintf(msg.mtext, sizeof(msg.mtext), "Hello from child PID=%d", getpid());
        if (msgsnd(msqid, &msg, sizeof(msg.mtext), 0) == -1) {
            perror("msgsnd");
            exit(EXIT_FAILURE);
        }
        printf("[Child]  Sent: %s\n", msg.mtext);
        exit(EXIT_SUCCESS);
    } else {
        /* PARENT: waits for child, then receives message */
        wait(NULL);
        if (msgrcv(msqid, &msg, sizeof(msg.mtext), 0, 0) == -1) {
            perror("msgrcv");
            exit(EXIT_FAILURE);
        }
        printf("[Parent] Received: %s\n", msg.mtext);

        /* Clean up */
        if (msgctl(msqid, IPC_RMID, NULL) == -1) {
            perror("msgctl IPC_RMID");
        }
        printf("[Parent] Queue deleted.\n");
    }

    return 0;
}

ftok() generates a key by combining information from an existing file with a project number you provide. The function signature is:

#include <sys/ipc.h>

key_t ftok(char *pathname, int proj);
/* Returns an integer key on success, or -1 on error */

How does it generate the key? On Linux, ftok() combines three pieces of information:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>

#define KEY_FILE   "/tmp/myapp_ipc_keyfile"   /* agreed-upon file */
#define PROJ_ID    'A'                          /* agreed-upon project char */

int main(void) {
    key_t key;
    int msqid;

    /* Step 1: Generate the key from the file + project ID */
    key = ftok(KEY_FILE, PROJ_ID);
    if (key == -1) {
        perror("ftok");
        fprintf(stderr, "Make sure %s exists!\n", KEY_FILE);
        exit(EXIT_FAILURE);
    }
    printf("Generated key = 0x%x (%d)\n", (unsigned int)key, key);

    /* Step 2: Use the key to create or open the message queue */
    msqid = msgget(key, IPC_CREAT | 0660);
    if (msqid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }
    printf("Message queue ID = %d\n", msqid);

    /* Any other process that calls ftok(KEY_FILE, 'A')
       will get the same key, and thus the same msqid */

    /* Cleanup */
    msgctl(msqid, IPC_RMID, NULL);
    printf("Queue removed.\n");

    return 0;
}

An application might need several IPC objects of the same type (e.g., three semaphore sets). Use different proj values with the same file to generate distinct keys:

#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>

#define KEY_FILE "/tmp/myapp_keyfile"

int main(void) {
    key_t key1, key2, key3;
    int semid1, semid2, semid3;

    /* Three different proj values → three different keys */
    key1 = ftok(KEY_FILE, 'A');
    key2 = ftok(KEY_FILE, 'B');
    key3 = ftok(KEY_FILE, 'C');

    if (key1 == -1 || key2 == -1 || key3 == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    printf("key1 = 0x%x\n", (unsigned int)key1);
    printf("key2 = 0x%x\n", (unsigned int)key2);
    printf("key3 = 0x%x\n", (unsigned int)key3);

    /* Create three separate semaphore sets */
    semid1 = semget(key1, 1, IPC_CREAT | 0600);
    semid2 = semget(key2, 1, IPC_CREAT | 0600);
    semid3 = semget(key3, 1, IPC_CREAT | 0600);

    if (semid1 == -1 || semid2 == -1 || semid3 == -1) {
        perror("semget");
        exit(EXIT_FAILURE);
    }

    printf("Semaphore IDs: %d, %d, %d\n", semid1, semid2, semid3);

    /* Cleanup */
    semctl(semid1, 0, IPC_RMID); 
    semctl(semid2, 0, IPC_RMID); 
    semctl(semid3, 0, IPC_RMID);
    printf("All semaphores removed.\n");

    return 0;
}

ftok() is widely used but has a small limitation: there is a very small chance of key collisions. Two different files on different filesystems could yield the same key if:

• The least significant bits of their i-node numbers happen to match, AND
• The minor device numbers of their respective filesystems happen to match

In practice, this possibility is small enough that ftok() is a viable technique for most applications. The glibc implementation of ftok() has the same limitation as other UNIX implementations.