/*
================================================================================
  RPL/2 (R) version 4.0.18
  Copyright (C) 1989-2010 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"

#ifdef SEMAPHORES_NOMMES

/*
================================================================================
  Fonctions d'émulation de sémaphores anonymes
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

sem_t *
sem_init2(unsigned int valeur, enum t_semaphore semaphore)
{
	snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
			"/RPLSEM-%d-%llu-%d", (int) getpid(),
			(unsigned long long) pthread_self(),
			(int) semaphore);
	return(sem_open(noms_semaphores[semaphore], O_CREAT,
			(S_IRUSR | S_IWUSR), valeur));
}

int
sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore)
{
	sem_close(semaphore_p);
	return(sem_unlink(noms_semaphores[semaphore]));
}

#undef sem_post
#undef sem_wait
#undef sem_trywait

int
sem_getvalue2(sem_t *semaphore, int *valeur)
{
	int						i;

	logical1				drapeau_fin;

	pthread_mutex_lock(&mutex_sem);

	(*valeur) = 0;
	drapeau_fin = d_faux;

	do
	{
		if (sem_trywait(semaphore) == -1)
		{
			if (errno == EAGAIN)
			{
				// Le sémaphore avait une valeur nulle
				drapeau_fin = d_vrai;
			}
			else
			{
				// Autre erreur
				pthread_mutex_unlock(&mutex_sem);
				return(-1);
			}
		}
		else
		{
			(*valeur)++;
		}
	} while(drapeau_fin == d_faux);

	for(i = 0; i < (*valeur); i++)
	{
		if (sem_post(semaphore) != 0)
		{
			pthread_mutex_unlock(&mutex_sem);
			return(-1);
		}
	}

	pthread_mutex_unlock(&mutex_sem);
	return(0);
}

#endif

#ifdef SEMAPHORES_SYSV

/*
================================================================================
  Fonctions d'émulation de sémaphores POSIX en fonction des sémaphores SysV
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

#ifndef OS2
	extern unsigned char *chemin_semaphores_SysV;
#else
	unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
	unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";
#endif

#ifndef UNION_SEMUN
union semun
{
	int					val;
	struct semid_ds		*buf;
	unsigned short		*array;
	struct seminfo		*__buf;
};
#endif

int
sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
{
#	ifndef OS2

	int				ios;

	union semun		argument;

	if (shared != 0)
	{
		errno = ENOSYS;
		return(-1);
	}

	(*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | SEM_R | SEM_A);

	if ((*semaphore) == -1)
	{
		errno = EINVAL;
		return(-1);
	}

	argument.val = valeur;
	ios = semctl((*semaphore), 0, SETVAL, argument);

	return(ios);

#	else

	sem_t			*psem;

	psem = semaphore;

	if (shared != 0)
	{
		errno = ENOSYS;
		return(-1);
	}

	if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
	{
		free(psem);
		errno = ENOMEM;
		return(-1);
	}

	if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
	{
		free((*psem).cnt);
		free(psem);
		errno = ENOMEM;
		return(-1);
	}

	if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
	{
		free((*psem).cnt);
		free((*psem).nopened);
		free(psem);
		return(-1);
	}

	if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)
	{
		DosCloseMutexSem((*psem).hmtx);
		free((*psem).cnt);
		free((*psem).nopened);
		free(psem);
		return(-1);
	}

	(*(*psem).cnt) = valeur;
	(*(*psem).nopened) = 1;
	(*psem).shared = shared;
	(*psem).allocated = 0;

	return(0);

#	endif
}

int
sem_destroy_SysV(sem_t *semaphore)
{
#	ifndef OS2

	if (semctl((*semaphore), IPC_RMID, 0) == -1)
	{
		return(EINVAL);
	}

	return(0);

#	else

	sem_t		*psem;

	psem = semaphore;

	if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
	{
		return(EINVAL);
	}

	if (DosCloseMutexSem((*psem).hmtx) != 0)
	{
		return(EINVAL);
	}

	while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
	{
		DosPostEventSem((*psem).hev);
	}

	(*(*psem).nopened)--;

	if ((*psem).shared == 0)
	{
		free((*psem).cnt);
		free((*psem).nopened);
	}
	else
	{
		if ((*(*psem).nopened) == 0)
		{
			DosFreeMem((*psem).cnt);
		}
	}

	if ((*psem).allocated != 0)
	{	
		free(psem);
	}

	return(0);

#	endif
}

int
sem_wait_SysV(sem_t *semaphore)
{
#	ifndef OS2

	struct sembuf		commande;

	commande.sem_num = 0;
	commande.sem_op = -1;
	commande.sem_flg = 0;

	if (semop((*semaphore), &commande, 1) == -1)
	{
		errno = EINVAL;
		return(-1);
	}

	return(0);

#	else

	sem_t		*psem;

	ULONG		cnt;

	psem = semaphore;

	if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
	{
		errno = EINVAL;
		return(-1);
	}

	if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
	{
		errno = EINVAL;
		return(-1);
	}

	if ((*(*psem).cnt) > 0)
	{
		(*(*psem).cnt)--;
	}

	if ((*(*psem).cnt) == 0)
	{
		DosResetEventSem((*psem).hev, &cnt);
	}

	DosReleaseMutexSem((*psem).hmtx);
	return(0);

#	endif
}

int
sem_trywait_SysV(sem_t *semaphore)
{
#	ifndef OS2

	struct sembuf		commande;

	commande.sem_num = 0;
	commande.sem_op = -1;
	commande.sem_flg = IPC_NOWAIT;

	if (semop((*semaphore), &commande, 1) == -1)
	{
		return(-1);
	}

	return(0);

#	else

	int			ios;

	sem_t		*psem;

	ULONG		cnt;

	psem = semaphore;

	if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
	{
		errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
		return(-1);
	}

	if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
	{
		errno = EINVAL;
		return(-1);
	}

	if ((*(*psem).cnt) > 0)
	{
		(*(*psem).cnt)--;
	}

	if ((*(*psem).cnt) == 0)
	{
		DosResetEventSem((*psem).hev, &cnt);
	}

	DosReleaseMutexSem((*psem).hmtx);
	return(0);

#	endif
}

int
sem_post_SysV(sem_t *semaphore)
{
#	ifndef OS2

	struct sembuf		commande;

	commande.sem_num = 0;
	commande.sem_op = 1;
	commande.sem_flg = 0;

	if (semop((*semaphore), &commande, 1) == -1)
	{
		errno = EINVAL;
		return(-1);
	}

	return(0);

#	else

	sem_t				*psem;

	psem = semaphore;

	if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
	{
		errno = EINVAL;
		return(-1);
	}

	(*(*psem).cnt)++;
	DosPostEventSem((*psem).hev);
	DosReleaseMutexSem((*psem).hmtx);

	return(0);

#	endif
}

int
sem_getvalue_SysV(sem_t *semaphore, int *valeur)
{
#	ifndef OS2

	(*valeur) = semctl((*semaphore), 0, GETVAL);

	if ((*valeur) < 0)
	{
		return(EINVAL);
	}

	return(0);

#	else

	sem_t				*psem;

	psem = semaphore;

	if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
	{
		errno = EINVAL;
		return(-1);
	}

	(*valeur) = (*(*psem).cnt);
	DosReleaseMutexSem((*psem).hmtx);

	return(0);

#	endif
}

sem_t
*sem_open_SysV(const char *nom, int oflag, ...)
//*sem_open(const char *nom, int oflag)
//*sem_open(const char *nom, int oflag, mode_t mode, unsigned int value)
{
	mode_t				mode;

	sem_t				*semaphore;

#	ifndef OS2
	union semun			argument;
#	endif

	unsigned char		*nom_absolu;

	unsigned int		valeur;

	va_list				liste;

#	ifdef OS2
	sem_t				*psem;

	PVOID				base;

	unsigned char		*ptr;
	unsigned char		*nom_segment;
#	endif

#	ifndef OS2

	if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
			+ 1) * sizeof(unsigned char))) == NULL)
	{
		return(SEM_FAILED);
	}

	sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);

	if ((semaphore = malloc(sizeof(sem_t))) == NULL)
	{
		return(SEM_FAILED);
	}

	(*psem).allocated = 1;

#	else

	if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
			* sizeof(unsigned char))) == NULL)
	{
		return(SEM_FAILED);
	}	

	sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
	ptr = nom_segment;

	while((*ptr) != d_code_fin_chaine)
	{
		if ((*ptr) == '/')
		{
			(*ptr) = '\\';
		}

		ptr++;
	}

	if ((nom_absolu = malloc((strlen(racine_semaphores_OS2) + strlen(nom)
			+ 2) * sizeof(unsigned char))) == NULL)
	{
		return(SEM_FAILED);
	}

	sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
	ptr = nom_absolu;

	while((*ptr) != d_code_fin_chaine)
	{
		if ((*ptr) == '/')
		{
			(*ptr) = '\\';
		}

		ptr++;
	}

	(*(ptr + 1)) = d_code_fin_chaine;

	if ((psem = malloc(sizeof(sem_t))) == NULL)
	{
		return(SEM_FAILED);
	}

#	endif

	if ((oflag & O_CREAT) == 0)
	{
		// 2 arguments

#		ifndef OS2

		(*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);

		if ((*semaphore) == -1)
		{	
			free(semaphore);
			free(nom_absolu);

			return(SEM_FAILED);
		}

#		else

		if ((psem = malloc(sizeof(sem_t))) == NULL)
		{
			free(nom_absolu);
			free(nom_segment);
			return(SEM_FAILED);
		}

		(*ptr) = 'M';

		if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
		{
			free(psem);
			free(nom_absolu);
			free(nom_segment);

			return(SEM_FAILED);
		}

		(*ptr) = 'S';

		if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
		{
			DosCloseMutexSem((*psem).hmtx);

			free(psem);
			free(nom_absolu);
			free(nom_segment);

			return(SEM_FAILED);
		}

		if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)
		{
			DosCloseMutexSem((*psem).hmtx);

			free(nom_absolu);
			free(nom_segment);
			free(psem);

			return(SEM_FAILED);
		}

		free(nom_segment);

		(*psem).cnt = (ULONG *) base;
		(*psem).nopened = ((ULONG *) base) + 1;
		(*psem).shared = 1;

		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
		{
			DosCloseMutexSem((*psem).hmtx);

			free(nom_absolu);
			free(nom_segment);
			free(psem);

			return(SEM_FAILED);
		}

		(*((*psem).nopened))++;

		DosReleaseMutexSem((*psem).hmtx);

		semaphore = psem;

#		endif
	}
	else
	{
		// 4 arguments

		// O_CREAT O_EXCL
		// S_IRUSR S_IWUSR

		va_start(liste, oflag);
		mode = va_arg(liste, mode_t);
		valeur = va_arg(liste, unsigned int);
		va_end(liste);

#		ifndef OS2

		(*semaphore) = semget(ftok(nom_absolu, 1), 1,
				((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT |
				((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL |
				((oflag & S_IRUSR) == 0) ? 0 : SEM_R |
				((oflag & S_IWUSR) == 0) ? 0 : SEM_A);

		if ((*semaphore) == -1)
		{	
			free(semaphore);
			free(nom_absolu);

			return(SEM_FAILED);
		}

		argument.val = valeur;
		semctl((*semaphore), 0, SETVAL, argument);

#		else

		if ((psem = malloc(sizeof(sem_t))) == NULL)
		{
			free(nom_absolu);
			free(nom_segment);

			return(SEM_FAILED);
		}

		(*ptr) = 'M';

		if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
		{
			free(psem);
			free(nom_absolu);
			free(nom_segment);

			return(SEM_FAILED);
		}

		(*ptr) = 'S';

		if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
				(valeur != 0) ? 1 : 0) != 0)
		{
			DosCloseMutexSem((*psem).hmtx);

			free(nom_absolu);
			free(nom_segment);
			free(psem);

			return(SEM_FAILED);
		}

		if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
				PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
		{
			DosCloseMutexSem((*psem).hmtx);

			free(nom_absolu);
			free(nom_segment);
			free(psem);

			return(SEM_FAILED);
		}

		free(nom_segment);

		(*psem).cnt = (ULONG *) base;
		(*psem).nopened = ((ULONG *) base) + 1;
		(*(*psem).cnt) = valeur;
		(*(*psem).nopened) = 1;
		(*psem).shared = 1;
		semaphore = psem;

#		endif
	}

	free(nom_absolu);

	return(semaphore);
}

int
sem_close_SysV(sem_t *semaphore)
{
#	ifndef OS2

	free(semaphore);
	return(0);

#	else

	sem_t		*psem;

	psem = semaphore;

	if (DosCloseMutexSem((*psem).hmtx) != 0)
	{
		return(EINVAL);
	}

	while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
	{
		DosPostEventSem((*psem).hev);
	}

	(*(*psem).nopened)--;

	if ((*psem).shared == 0)
	{
		free((*psem).cnt);
		free((*psem).nopened);
	}
	else
	{
		if ((*(*psem).nopened) == 0)
		{
			DosFreeMem((*psem).cnt);
		}
	}

	if ((*psem).allocated != 0)
	{
		free(psem);
	}

	return(0);

#	endif
}

int
sem_unlink_SysV(const char *nom)
{
#	ifndef OS2

	sem_t				semaphore;

	struct sembuf		commande;

	unsigned char		*nom_absolu;

	if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
			+ 1) * sizeof(unsigned char))) == NULL)
	{
		return(ENOMEM);
	}

	sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);

	if ((semaphore = semget(ftok(nom_absolu, 1), 0, 0)) == -1)
	{	
		free(nom_absolu);
		return(EINVAL);
	}

	commande.sem_num = 0;
	commande.sem_op = 0;
	commande.sem_flg = 0;

	if (semop(semaphore, &commande, 1) == -1)
	{
		free(nom_absolu);
		return(EINVAL);
	}

	if (semctl(semaphore, IPC_RMID, 0) == -1)
	{
		free(nom_absolu);
		return(EINVAL);
	}

	if (unlink(nom_absolu) == -1)
	{
		free(nom_absolu);
		return(EACCES);
	}

	free(nom_absolu);

	return(0);

#	else

	return(0);

#	endif
}

#endif

// vim: ts=4