#include <sys/mman.h>
#include <fcntl.h>
#include <semaphore.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                        } while (0)

#define BUF_SIZE 1024   /* Maximum size for exchanged string */

/* Define a structure that will be imposed on the shared
   memory object */

struct shmbuf {
    sem_t  sem1;            /* POSIX unnamed semaphore */
    sem_t  sem2;            /* POSIX unnamed semaphore */
    size_t cnt;             /* Number of bytes used in 'buf' */
    char   buf[BUF_SIZE];   /* Data being transferred */
};

/* pshm_ucase_bounce.c

   Licensed under GNU General Public License v2 or later.
*/
#include <ctype.h>
#include "pshm_ucase.h"

int
main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s /shm−path\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *shmpath = argv[1];

    /* Create shared memory object and set its size to the size
       of our structure. */

    int fd = shm_open(shmpath, O_CREAT | O_EXCL | O_RDWR,
                      S_IRUSR | S_IWUSR);
    if (fd == −1)
        errExit("shm_open");

    if (ftruncate(fd, sizeof(struct shmbuf)) == −1)
        errExit("ftruncate");

    /* Map the object into the caller's address space. */

    struct shmbuf *shmp = mmap(NULL, sizeof(*shmp),
                               PROT_READ | PROT_WRITE,
                               MAP_SHARED, fd, 0);
    if (shmp == MAP_FAILED)
        errExit("mmap");

    /* Initialize semaphores as process−shared, with value 0. */

    if (sem_init(&shmp−>sem1, 1, 0) == −1)
        errExit("sem_init−sem1");
    if (sem_init(&shmp−>sem2, 1, 0) == −1)
        errExit("sem_init−sem2");

    /* Wait for 'sem1' to be posted by peer before touching
       shared memory. */

    if (sem_wait(&shmp−>sem1) == −1)
        errExit("sem_wait");

    /* Convert data in shared memory into upper case. */

    for (int j = 0; j < shmp−>cnt; j++)
        shmp−>buf[j] = toupper((unsigned char) shmp−>buf[j]);

    /* Post 'sem2' to tell the to tell peer that it can now
       access the modified data in shared memory. */

    if (sem_post(&shmp−>sem2) == −1)
        errExit("sem_post");

    /* Unlink the shared memory object. Even if the peer process
       is still using the object, this is okay. The object will
       be removed only after all open references are closed. */

    shm_unlink(shmpath);

    exit(EXIT_SUCCESS);
}

/* pshm_ucase_send.c

   Licensed under GNU General Public License v2 or later.
*/
#include <string.h>
#include "pshm_ucase.h"

int
main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "Usage: %s /shm−path string\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *shmpath = argv[1];
    char *string = argv[2];
    size_t len = strlen(string);

    if (len > BUF_SIZE) {
        fprintf(stderr, "String is too long\n");
        exit(EXIT_FAILURE);
    }

    /* Open the existing shared memory object and map it
       into the caller's address space. */

    int fd = shm_open(shmpath, O_RDWR, 0);
    if (fd == −1)
        errExit("shm_open");

    struct shmbuf *shmp = mmap(NULL, sizeof(*shmp),
                               PROT_READ | PROT_WRITE,
                               MAP_SHARED, fd, 0);
    if (shmp == MAP_FAILED)
        errExit("mmap");

    /* Copy data into the shared memory object. */

    shmp−>cnt = len;
    memcpy(&shmp−>buf, string, len);

    /* Tell peer that it can now access shared memory. */

    if (sem_post(&shmp−>sem1) == −1)
        errExit("sem_post");

    /* Wait until peer says that it has finished accessing
       the shared memory. */

    if (sem_wait(&shmp−>sem2) == −1)
        errExit("sem_wait");

    /* Write modified data in shared memory to standard output. */

    write(STDOUT_FILENO, &shmp−>buf, len);
    write(STDOUT_FILENO, "\n", 1);

    exit(EXIT_SUCCESS);
}