/*
	xfermem: unidirectional fast pipe

	copyright ?-2015 by the mpg123 project - free software under the terms of the LGPL 2.1
	see COPYING and AUTHORS files in distribution or http://mpg123.org
	initially written by Oliver Fromme
	old timestamp: Sun Apr  6 02:26:26 MET DST 1997

	See xfermem.h for documentation/description.
*/

#include "config.h"
#include "compat.h"
#include "xfermem.h"
#include <string.h>
#include <errno.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <fcntl.h>

#ifndef HAVE_MMAP
#include <sys/ipc.h>
#include <sys/shm.h>
#endif

#include "debug.h"

#if defined (HAVE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
#define MAP_ANON MAP_ANONYMOUS
#endif

void xfermem_init (txfermem **xf, size_t bufsize, size_t msize, size_t skipbuf)
{
	size_t regsize = bufsize + msize + skipbuf + sizeof(txfermem);

#ifdef HAVE_MMAP
#  ifdef MAP_ANON
	if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
			MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) {
		perror ("mmap()");
		exit (1);
	}
#  else
	int devzero;
	if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) {
		perror ("open(/dev/zero)");
		exit (1);
	}
	if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
			MAP_SHARED, devzero, 0)) == (txfermem *) -1) {
		perror ("mmap()");
		exit (1);
	}
	close (devzero);
#  endif
#else
	struct shmid_ds shmemds;
	int shmemid;
	if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) {
		perror ("shmget()");
		exit (1);
	}
	if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) {
		perror ("shmat()");
		shmctl (shmemid, IPC_RMID, &shmemds);
		exit (1);
	}
	if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) {
		perror ("shmctl()");
		xfermem_done (*xf);
		exit (1);
	}
#endif
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) {
		perror ("socketpair()");
		xfermem_done (*xf);
		exit (1);
	}
	(*xf)->freeindex = (*xf)->readindex = 0;
	(*xf)->data = ((char *) *xf) + sizeof(txfermem) + msize;
	(*xf)->metadata = ((char *) *xf) + sizeof(txfermem);
	(*xf)->size = bufsize;
	(*xf)->metasize = msize + skipbuf;
}

void xfermem_done (txfermem *xf)
{
	if(!xf)
		return;
#ifdef HAVE_MMAP
	/* Here was a cast to (caddr_t) ... why? Was this needed for SunOS?
	   Casting to (void*) should silence compilers in case of funny
	   prototype for munmap(). */
	munmap ( (void*)xf, xf->size + xf->metasize + sizeof(txfermem));
#else
	if (shmdt((void *) xf) == -1) {
		perror ("shmdt()");
		exit (1);
	}
#endif
}

void xfermem_init_writer (txfermem *xf)
{
	if(xf)
		close (xf->fd[XF_READER]);
	debug1("xfermem writer fd=%i", xf->fd[XF_WRITER]);
}

void xfermem_init_reader (txfermem *xf)
{
	if(xf)
		close (xf->fd[XF_WRITER]);
	debug1("xfermem reader fd=%i", xf->fd[XF_READER]);
}

size_t xfermem_get_freespace (txfermem *xf)
{
	size_t freeindex, readindex;

	if(!xf)
		return 0;

	if ((freeindex = xf->freeindex) < 0
			|| (readindex = xf->readindex) < 0)
		return (0);
	if (readindex > freeindex)
		return ((readindex - freeindex) - 1);
	else
		return ((xf->size - (freeindex - readindex)) - 1);
}

size_t xfermem_get_usedspace (txfermem *xf)
{
	size_t freeindex, readindex;

	if(!xf)
		return 0;

	if ((freeindex = xf->freeindex) < 0
			|| (readindex = xf->readindex) < 0)
		return (0);
	if (freeindex >= readindex)
		return (freeindex - readindex);
	else
		return (xf->size - (readindex - freeindex));
}

static int xfermem_getcmd_raw (int fd, int block, byte *cmds, int count)
{
	fd_set selfds;
	int ret;

	for (;;) {
		struct timeval selto = {0, 0};

		FD_ZERO (&selfds);
		FD_SET (fd, &selfds);
#ifdef HPUX
		switch (select(FD_SETSIZE, (int *) &selfds, NULL, NULL, block ? NULL : &selto))
#else
		switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto))
#endif
		{
			case 0:
				if (!block)
					return (0);
				continue;
			case -1:
				if (errno == EINTR)
					continue;
				return (-2);
			case 1:
				if (FD_ISSET(fd, &selfds))
					switch((ret=read(fd, cmds, count)))
					{
						case 0: /* EOF */
							return (-1);
						case -1:
							if (errno == EINTR)
								continue;
							return (-3);
						default:
							return ret;
					}
				else /* ?!? */
					return (-5);
			default: /* ?!? */
				return (-6);
		}
	}
}

/* Verbose variant for debugging communication. */
int xfermem_getcmd(int fd, int block)
{
	byte cmd;
	int res = xfermem_getcmd_raw(fd, block, &cmd, 1);
	debug3("xfermem_getcmd(%i, %i) = %i", fd, block, res == 1 ? cmd : res);
	return res == 1 ? cmd : res;
}

int xfermem_getcmds(int fd, int block, byte *cmds, int count)
{
	int res = xfermem_getcmd_raw(fd, block, cmds, count);
	debug5("xfermem_getcmds(%i, %i, %p, %i) = %i"
	,	fd, block, (void*)cmds, count
	,	res);
	return res;
}


int xfermem_putcmd (int fd, byte cmd)
{
	for (;;) {
		switch (write(fd, &cmd, 1)) {
			case 1:
				debug2("xfermem_putcmd(%i, %i) = 1", fd, cmd);
				return (1);
			case -1:
				if (errno != EINTR)
				{
					debug3("xfermem_putcmd(%i, %i) = -1 (%s)"
					,	fd, cmd, strerror(errno));
					return (-1);
				}
		}
	}
}

/*
	There is a basic assumetry between reader and writer:
	The reader does work in periodic pieces and can be relied upon to
	eventually answer a call. It is important that it does not block
	for a significant duration unless it has really nothing to do.

	The writer is more undefined in its behaviour, it is controlled by
	external agents. You cannot rely on it answering synchronization
	requests in a timely manner. But on the other hand, it can be left
	hanging for a while. The critical side is that of the reader.

	Because of that, it is only sensible to provide a voluntary
	xfermem_writer_block() here. The reader does not need such a function.
	Only if it has nothing else to do, it will simply block on
	xfermem_getcmd(), and the writer promises to xfermem_putcmd() when
	something happens.

	The writer always sends a wakeup command to the reader since the latter
	could be in the process of putting itself to sleep right now, without
	a flag indicating so being set yet.

	The reader periodically reads from its file descriptor so that it does
	not get clogged up with pending messages. It will only (and always) send
	a wakeup call in response to a received command.
*/

/* Wait a bit to get a sign of life from the reader.
   Returns -1 if even that did not work. */
int xfermem_writer_block(txfermem *xf)
{
	int myfd = xf->fd[XF_WRITER];
	int result;

	xfermem_putcmd(myfd, XF_CMD_PING);
	result = xfermem_getcmd(myfd, TRUE);
	/* Only a pong to my ping is the expected good answer.
	   Everything else is a problem to be communicated. */
	return (result == XF_CMD_PONG) ? 0 : result;
}

/* Return: 0 on success, -1 on communication error, > 0 for
   error on buffer side, some special return code from buffer to be
   evaluated. */
int xfermem_write(txfermem *xf, void *buffer, size_t bytes)
{
	if(buffer == NULL || bytes < 1) return 0;

	/* You weren't so braindead not allocating enough space at all, right? */
	while (xfermem_get_freespace(xf) < bytes)
	{
		int cmd = xfermem_writer_block(xf);
		if(cmd) /* Non-successful wait. */
			return cmd;
	}
	/* Now we have enough space. copy the memory, possibly with the wrap. */
	if(xf->size - xf->freeindex >= bytes)
	{	/* one block of free memory */
		memcpy(xf->data+xf->freeindex, buffer, bytes);
	}
	else
	{ /* two blocks */
		size_t endblock = xf->size - xf->freeindex;
		memcpy(xf->data+xf->freeindex, buffer, endblock);
		memcpy(xf->data, (char*)buffer + endblock, bytes-endblock);
	}
	/* Advance the free space pointer, including the wrap. */
	xf->freeindex = (xf->freeindex + bytes) % xf->size;
	/* Always notify the buffer process. */
	debug("write waking");
	return xfermem_putcmd(xf->fd[XF_WRITER], XF_CMD_DATA) < 0
	?	-1
	:	0;
}