/*

	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;

}