/* svsem - POSIX-like semaphores implemented using SysV semaphores
 * Copyright (c) 2003 Michael B. Allen <mba2000 ioplex.com>
 *
 * The MIT License
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>

#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/mman.h>
#include <sys/wait.h>

#include "mba/svsem.h"
#include "mba/pool.h"
#include "mba/varray.h"
#include "mba/misc.h"
#include "mba/msgno.h"

#if defined(_SEM_SEMUN_UNDEFINED) || \
		(defined(__digital__) && defined(__unix__)) || \
		defined(_HPUX_SOURCE)
union semun {
	int val;                  /* value for SETVAL */
	struct semid_ds *buf;     /* buffer for IPC_STAT, IPC_SET */
	unsigned short *array;    /* array for GETALL, SETALL */
	/* Linux specific part: */
	struct seminfo *__buf;    /* buffer for IPC_INFO */
};
#endif

#define MAGIC 0xAD800000
#define MAX_TRIES 10
#define MAX_SEMNUM 255
#define SEM_ISVALID(s) ((s) && ((s)->flags & 0xFFF00000) == MAGIC)
#define IS_UNDO(s)     ((s) && ((s)->flags & 0x00080000) != 0)

/* Open or create a semaphore initializing it as necessary.
 */
static int
semid_get(const char *name, int nsems, int oflags, mode_t mode, int value)
{
	key_t key;
	int max;

	if (nsems > MAX_SEMNUM) {
		PMNO(errno = ERANGE);
		return -1;
	}
	if ((key = ftok((char *)name, 1)) == (key_t)-1) {
		PMNO(errno);
		return -1;
	}

	/* This following loop ensures that we know if the semaphore was created
	 * as opposed to just opened so that it can be initialized properly. We
	 * do this by alternating between oflags 0 and IPC_CREATE|IPC_EXCL until
	 * one succeeds.
	 */ 
	for (max = MAX_TRIES; max; max--) {
		int semid;
		union semun arg;

		if ((oflags & O_EXCL) == 0) {
			if ((semid = semget(key, nsems, 0)) != -1) {
				struct semid_ds buf;

				/* This inner try-loop ensures that the semaphore is initialized before
				 * we return even if the semaphore has been created with semget but not
				 * yet initialized with semctl. See Stevens' UNPv2 p274.
				 */
				arg.buf = &buf;
				for (max = MAX_TRIES; max; max--) {
					if (semctl(semid, 0, IPC_STAT, arg) == -1) {
						PMNO(errno);
						return -1;
					}
					if (buf.sem_otime != 0) {
						return semid;
					}
					sleep(1);
				}

				PMNO(errno = ETIMEDOUT);
				return -1;
			} else if (errno != ENOENT) {
				PMNO(errno);
				return -1;
			}
		}
		if ((semid = semget(key, nsems, IPC_CREAT | IPC_EXCL | (mode & 0777))) != -1) {
			struct sembuf initop;

			if (nsems > 1) {
				unsigned short array[MAX_SEMNUM * sizeof(unsigned short)];
				int i;

				arg.array = array;
				arg.array[0] = 0; /* leave the first one 0 to be set with semop */
				for (i = 1; i < nsems; i++) {
					arg.array[i] = value;
				}
				if (semctl(semid, 0, SETALL, arg) == -1) {
					PMNO(errno);
					semctl(semid, 0, IPC_RMID);
					return -1;
				}
			} else {
				arg.val = 0;
				if (semctl(semid, 0, SETVAL, arg) == -1) {
					PMNO(errno);
					semctl(semid, 0, IPC_RMID);
					return -1;
				}
			}
                                 /* increment by value to set sem_otime nonzero */
			initop.sem_num = 0;
			initop.sem_op = value;
			initop.sem_flg = 0;
			if (semop(semid, &initop, 1) == -1) {
				PMNO(errno);
				semctl(semid, 0, IPC_RMID);
				return -1;
			}

			return semid;
		} else if ((oflags & O_EXCL) || errno != EEXIST) {
			PMNO(errno);
			return -1;
		}
	}

	PMNO(errno = ETIMEDOUT);
	return -1;
}
static void *
_svs_new(void *context, size_t size, int flags)
{
	struct _svs_data *sd = context;
	svsem_t *sem;

				/* size is really semaphore number */
	if ((sem = varray_get(&sd->sems, size)) == NULL) {
		AMSG("");
		return NULL;
	}
	sem->id = sd->id;
	sem->num = size;
	sem->flags = MAGIC | (flags & 0x000FFFFFF);

                             /* is this necessary? */
	if (svsem_setvalue(sem, sd->val) == -1) {
		AMSG("");
		sem->flags = 0;
		return NULL;
	}

	return sem;
}
static int
_svs_del(void *context, void *object)
{
	svsem_t *sem = object;

	sem->id = 0;
	sem->flags = 0;

	(void)context;
	return 0;
}
static int
_svs_rst(void *context, void *object)
{
	struct _svs_data *sd = context;
	svsem_t *sem = object;

	if (svsem_setvalue(sem, sd->val) == -1) {
		AMSG("");
		return -1;
	}

	return 0;
}
int
svsem_pool_destroy(struct pool *p)
{
	int ret = 0;

	if (p) {
		struct _svs_data *sd = p->context;
		ret += pool_destroy(p);
		ret += varray_deinit(&sd->sems);
		ret += semctl(sd->id, 0, IPC_RMID);
		unlink(sd->name);
		ret += allocator_free(p->al, sd);
	}

	return ret;
}
int
svsem_pool_create(struct pool *p,
		unsigned int max_size,
		unsigned int value,
		int undo,
		struct allocator *al)
{
	struct _svs_data *sd;
	int fd = 0, nsems = max_size;

	memset(p, 0, sizeof *p);

	if ((sd = allocator_alloc(al, sizeof *sd, 0)) == NULL) {
		AMSG("");
		return -1;
	}

	strcpy(sd->name, "/tmp/svsemXXXXXX");
	if ((fd = mkstemp(sd->name)) == -1) {
		PMNO(errno);
		allocator_free(al, sd);
		return -1;
	}

	if ((sd->id = semid_get(sd->name, nsems, O_CREAT, 0666, value)) == -1) {
		AMSG("");
		allocator_free(al, sd);
		unlink(sd->name);
		return -1;
	}
	unlink(sd->name);
	if (fd) close(fd);

	sd->val = value;
	if (varray_init(&sd->sems, offsetof(svsem_t, name), al) == -1) {
		AMSG("");
		return -1;
	}
	if (pool_create(p, max_size, _svs_new, _svs_del, _svs_rst, sd, (size_t)-1, undo ? O_UNDO : 0, al) == -1) {
		AMSG("");
		semctl(sd->id, 0, IPC_RMID);
		allocator_free(al, sd);
		return -1;
	}

	return 0;
}
int
svsem_open(svsem_t *sem, const char *path, int oflag, ...)
{
	mode_t mode = 0;
	int val = 0, fd = 0;

	if ((oflag & O_CREAT)) {
		va_list ap;

		va_start(ap, oflag);
		mode = va_arg(ap, int);
		val = va_arg(ap, unsigned int);
		va_end(ap);

		if ((fd = open(path, O_CREAT, mode)) == -1) {
			PMNF(errno, ": %s", path);
			return -1;
		}
	}

	if ((sem->id = semid_get(path, 1, oflag, mode, val)) == -1) {
		AMSG("");
		return -1;
	}
	sem->num = 0;
	sem->flags = MAGIC | (oflag & 0x000FFFFFF);
                         /* how do I know this mask is ok? */
	if (fd) close(fd);

	return 0;
}
int
svsem_close(svsem_t *sem)
{
	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	sem->id = sem->flags = 0;

	return 0;
}
int
svsem_remove(svsem_t *sem)
{
	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	if (semctl(sem->id, 0, IPC_RMID) == -1) {
		PMNO(errno);
		return -1;
	}
	sem->id = sem->flags = 0;

	return 0;
}
int
svsem_create(svsem_t *sem, int value, int undo)
{
	int fd = 0;
			/* do not change this path without also adjusting
			 * the size if svsem_t's name member */
	strcpy(sem->name, "/tmp/svsemXXXXXX");
	if ((fd = mkstemp(sem->name)) == -1) {
		PMNO(errno);
		return -1;
	}

	if ((sem->id = semid_get(sem->name, 1, O_CREAT | O_EXCL, 0600, value)) == -1) {
		AMSG("");
		return -1;
	}
	sem->num = 0;
	sem->flags = MAGIC | (undo ? O_UNDO : 0);
	if (fd) close(fd);

	return 0;
}
int
svsem_destroy(svsem_t *sem)
{
	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	if (semctl(sem->id, 0, IPC_RMID) == -1 && errno != EINVAL) {
		PMNO(errno);
		return -1;
	}
	sem->id = sem->flags = 0;
	unlink(sem->name);

	return 0;
}
int
svsem_wait(svsem_t *sem)
{
	struct sembuf wait;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	wait.sem_num = sem->num;
	wait.sem_op = -1;
	wait.sem_flg = IS_UNDO(sem) ? SEM_UNDO : 0;

	if (semop(sem->id, &wait, 1) == -1) {
		PMNF(errno, ": %d:%d", sem->id, sem->num);
		return -1;
	}

	return 0;
}
int
svsem_trywait(svsem_t *sem)
{
	struct sembuf wait;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	wait.sem_num = sem->num;
	wait.sem_op = -1;
	wait.sem_flg = IPC_NOWAIT | (IS_UNDO(sem) ? SEM_UNDO : 0);

	if (semop(sem->id, &wait, 1) == -1) {
		PMNF(errno, ": %d:%d", sem->id, sem->num);
		return -1;
	}

	return 0;
}
int
svsem_post(svsem_t *sem)
{
	struct sembuf post;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	post.sem_num = sem->num;
	post.sem_op = 1;
	post.sem_flg = IS_UNDO(sem) ? SEM_UNDO : 0;

	if (semop(sem->id, &post, 1) == -1) {
		PMNF(errno, ": %d:%d", sem->id, sem->num);
		return -1;
	}

	return 0;
}
int
svsem_post_multiple(svsem_t *sem, int count)
{
	int ret = 0;
	struct sembuf post;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	post.sem_num = sem->num;
	post.sem_op = 1;
	post.sem_flg = IS_UNDO(sem) ? SEM_UNDO : 0;

	while (count--) {
		ret += semop(sem->id, &post, 1);
	}

	if (ret) {
		PMNF(errno, ": %d:%d", sem->id, sem->num);
		return -1;
	}

	return 0;
}
int
svsem_getvalue(svsem_t *sem, int *value)
{
	int v;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	if ((v = semctl(sem->id, sem->num, GETVAL, 0)) == -1) {
		PMNO(errno);
		return -1;
	}
	*value = v;

	return 0;
}
int
svsem_setvalue(svsem_t *sem, int value)
{
	union semun arg;

	if (!SEM_ISVALID(sem)) {
		PMNO(errno = EINVAL);
		return -1;
	}

	arg.val = value;
	if (semctl(sem->id, sem->num, SETVAL, arg) == -1) {
		PMNO(errno);
		return -1;
	}

	return 0;
}