Activity 2: Exploring namespace sharing

//POSIX headers
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>

//Standard C++ headers
#include <cstring>
#include <cerrno>
#include <iostream>
#include <string>
#include <stdexcept>

//The name of our shared memory segment
#define SHARED_MEMORY_NAME "/shared-memory"

//The size (in bytes) of our shared memory segment
#define SHARED_MEMORY_SIZE 1024

//The file mode of our shared memory segment
#define SHARED_MEMORY_MODE 0666


//Reports a fatal error
void reportError(const std::string& prefix) {
	throw std::runtime_error(prefix + " (" + std::string(strerror(errno)) + ")");
}

//Reports a non-fatal warning
void reportWarning(const std::string& prefix) {
	std::clog << "Warning: " << prefix << " (" << strerror(errno) << ")" << std::endl;
}


int main(int argc, char* argv[])
{
	try
	{
		//Determine if we are the producer process or the consumer process
		bool isProducer = (argc > 1 && std::string(argv[1]) == std::string("--producer"));
		std::cout << "We are the " << (isProducer == true ? "producer" : "consumer") << " process." << std::endl;
		
		//If we are the producer, create and configure the shared memory segment
		int descriptor = -1;
		if (isProducer == true)
		{
			//Attempt to create and open the shared memory segment
			descriptor = shm_open(SHARED_MEMORY_NAME, O_CREAT | O_RDWR, SHARED_MEMORY_MODE);
			if (descriptor == -1) {
				reportError("error creating shared memory");
			}
			
			//Set the size of the shared memory segment
			if (ftruncate(descriptor, SHARED_MEMORY_SIZE) == -1) {
				reportWarning("error resizing shared memory");
			}
		}
		else
		{
			//Attempt to open the shared memory segment created by the producer
			descriptor = shm_open(SHARED_MEMORY_NAME, O_RDONLY, SHARED_MEMORY_MODE);
			if (descriptor == -1) {
				reportError("error opening shared memory");
			}
		}
		
		//If we reach this stage then we've opened the file descriptor for the shared memory segment successfully
		std::cout << "Shared memory segment opened successfully." << std::endl;
		
		//Map the shared memory segment into our address space
		int flags = (isProducer == true ? PROT_READ | PROT_WRITE : PROT_READ);
		void* memory = mmap(nullptr, SHARED_MEMORY_SIZE, flags, MAP_SHARED, descriptor, 0);
		if (memory == MAP_FAILED) {
			reportWarning("error mapping shared memory");
		}
		
		//Pause for user input
		std::cout << "Enter any character to close the shared memory segment and exit..." << std::endl;
		char input = 0;
		std::cin >> input;
		
		//Unmap the shared memory segment from our address space
		if (memory != nullptr)
		{
			if (munmap(memory, SHARED_MEMORY_SIZE) == -1) {
				reportWarning("error unmapping shared memory");
			}
		}
		
		//Close the file descriptor for the shared memory segment
		close(descriptor);
		
		//If we are the producer, delete the shared memory segment
		if (isProducer == true)
		{
			if (shm_unlink(SHARED_MEMORY_NAME) == -1) {
				reportError("error deleting shared memory");
			}
		}
		
		return 0;
	}
	catch (std::runtime_error& err)
	{
		std::clog << "Error: " << err.what() << std::endl;
		return 1;
	}
}