Shared Memory with Fork

/* Shared Memory with Fork
 * by Utroz */

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

#include <sys/shm.h>
#include <sys/ipc.h>

#define BUFFER_SIZE 256

struct shared_use_st {
        pid_t pid;
        char buffer[BUFFER_SIZE];
        struct shared_use_st *next;
};
typedef struct shared_use_st __shared_struct;

void error(const char *);
__shared_struct *insert_on_list(char *, __shared_struct *);
void print_the_data_list(__shared_struct *);

int main(void)
{
        void *shared_memory = (void *)0;
        __shared_struct *shared_stuff, *begin_list;
        pid_t pid;

        /* Shared Memory */
        key_t key; /* key to be passed to shmget() */
        int shmflg; /* shmflg to be passed to shmget() */
        int shmid; /* return value from shmget() */
        size_t size; /* size to be passed to shmget() */

        /*
         * We'll name our shared memory segment
         * and fill data's.
         */
        key = (key_t) getuid();
        size = sizeof(__shared_struct);
        shmflg = IPC_CREAT | 0666;

        /* Creating a shared memory segment */
        shmid = shmget (key, size, shmflg);
        if (shmid == -1)
        error("shmget failed");

        /*
         * Now we attach the segment to our data space.
         */
        shared_memory = shmat(shmid, (void *)0, 0);
        if (shared_memory == (void *) -1)
        error("shmat failed");

        printf("Memory attached at %X PID: %d\n", (int)shared_memory, getpid());
        shared_stuff = (__shared_struct *)shared_memory;
        shared_stuff = NULL;

        shared_stuff = insert_on_list("Message (1) from ", shared_stuff);

        /* Create First fork() */
        pid = fork();
        if (pid < 0)
        error("Error on fork!");
        else if (pid == 0)
            print_the_data_list(shared_stuff);

        shared_stuff = insert_on_list("Message (2) from ", shared_stuff);

        print_the_data_list(shared_stuff);

        while (1)
        sleep(1);

        /* Lastly, the shared memory is detached and then deleted. */
        if (shmdt(shared_memory) == -1)
        error("shmdt failed");

        if (shmctl(shmid, IPC_RMID, 0) == -1)
        error("shmctl(IPC_RMID) failed");

        return (EXIT_SUCCESS);
}

void error(const char *msg)
{
        perror(msg);
        exit(EXIT_FAILURE);
}

__shared_struct *insert_on_list(char *args, __shared_struct *list)
{
        int new_shmid;
        void *shared_memory = (void *)0;
        __shared_struct *new_list;

        new_shmid = shmget ((key_t) getuid(), sizeof(__shared_struct), IPC_CREAT | 0666);
        if (new_shmid == -1)
        error("shmget failed");

        shared_memory = shmat(new_shmid, (void *)0, 0);
        new_list = (__shared_struct *)shared_memory;

        /* Fills data's on the struct memory block */
        memset(new_list->buffer, 0, BUFFER_SIZE);

        new_list->pid = getpid();
        strcpy(new_list->buffer, args);
        new_list->next = list;

        return new_list;
}

void print_the_data_list(__shared_struct *data)
{
        __shared_struct *aux_list;
        aux_list = data;

        while(aux_list != NULL && aux_list->pid != 0) {
        fprintf(stdout, "PID: %d | %s PID %d. | Buf: %s\n", getpid(), aux_list->buffer, aux_list->pid);
        aux_list = aux_list->next;
        sleep(2);
        }

        return print_the_data_list(data);
}