--- rpl/src/semaphores.c	2011/03/06 16:44:15	1.17
+++ rpl/src/semaphores.c	2011/09/20 16:57:50	1.36
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.21
+  RPL/2 (R) version 4.1.3
   Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -24,6 +24,41 @@
 
 #ifdef SEMAPHORES_NOMMES
 
+// Les fonctions suivantes ne sont utilisées que dans le cas d'un
+// système POSIX qui ne possède pas de sémaphores anonymes. MacOS X
+// est dans ce cas.
+
+static unsigned char *
+nom_segment_semaphore(pid_t pid, int ordre)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-%d-%d", (int) pid, ordre);
+	return(fichier);
+}
+
+
+static unsigned char *
+nom_segment_semaphore_thread(pid_t pid, pthread_t tid, int ordre)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-%d-%llX-%d", (int) pid,
+			(unsigned long long) tid, ordre);
+	return(fichier);
+}
+
+
 /*
 ================================================================================
   Fonctions d'émulation de sémaphores anonymes
@@ -37,23 +72,106 @@
 */
 
 sem_t *
-sem_init2(unsigned int valeur, enum t_semaphore semaphore)
+sem_init2(unsigned int valeur, pid_t pid, int ordre)
+{
+	sem_t						*semaphore;
+
+	unsigned char				*chemin;
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR,
+			valeur);
+	free(chemin);
+
+	return(semaphore);
+}
+
+
+sem_t *
+sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre)
+{
+	sem_t						*semaphore;
+
+	unsigned char				*chemin;
+
+	if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	semaphore = sem_open(chemin, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR,
+			valeur);
+	free(chemin);
+
+	return(semaphore);
+}
+
+
+sem_t *
+sem_open2(pid_t pid, int ordre)
+{
+	unsigned char				*chemin;
+
+	sem_t						*semaphore;
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	semaphore = sem_open(chemin, O_RDWR);
+	free(chemin);
+
+	return(semaphore);
+}
+
+
+int
+sem_destroy2(sem_t *semaphore, pid_t pid, int ordre)
 {
-	snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
-			"/RPL-SEM-%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							erreur;
+
+	unsigned char				*chemin;
+
+	sem_close(semaphore);
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(1);
+	}
+
+	erreur = sem_unlink(chemin);
+	free(chemin);
+
+	return(erreur);
 }
 
+
 int
-sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore)
+sem_destroy3(sem_t *semaphore, pid_t pid, pthread_t tid, int ordre)
 {
-	sem_close(semaphore_p);
-	return(sem_unlink(noms_semaphores[semaphore]));
+	int							erreur;
+
+	unsigned char				*chemin;
+
+	sem_close(semaphore);
+
+	if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
+	{
+		return(1);
+	}
+
+	erreur = sem_unlink(chemin);
+	free(chemin);
+
+	return(erreur);
 }
 
+
 #undef sem_post
 #undef sem_wait
 #undef sem_trywait
@@ -62,46 +180,64 @@ int
 sem_getvalue2(sem_t *semaphore, int *valeur)
 {
 	int						i;
+	int						j;
 
 	logical1				drapeau_fin;
 
-	pthread_mutex_lock(&mutex_sem);
+	struct timespec			attente;
 
-	(*valeur) = 0;
-	drapeau_fin = d_faux;
+	attente.tv_sec = 0;
+	attente.tv_nsec = GRANULARITE_us * 1000;
 
-	do
+	for(j = 0; j < 100; j++)
 	{
-		if (sem_trywait(semaphore) == -1)
+		if (pthread_mutex_trylock(&mutex_sem) == 0)
 		{
-			if (errno == EAGAIN)
+			(*valeur) = 0;
+			drapeau_fin = d_faux;
+
+			do
 			{
-				// Le sémaphore avait une valeur nulle
-				drapeau_fin = d_vrai;
-			}
-			else
+				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++)
 			{
-				// Autre erreur
-				pthread_mutex_unlock(&mutex_sem);
-				return(-1);
+				if (sem_post(semaphore) != 0)
+				{
+					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);
+			return(0);
 		}
+
+		INCR_GRANULARITE(attente.tv_nsec);
 	}
 
-	pthread_mutex_unlock(&mutex_sem);
+	// Le mutex n'a pas pu être verrouillé. On peut raisonnablement penser
+	// que le sémaphore est bloqué dans un sem_wait() protégé par ce mutex.
+
+	(*valeur) = 0;
 	return(0);
 }
 
@@ -121,9 +257,9 @@ sem_getvalue2(sem_t *semaphore, int *val
 ================================================================================
 */
 
-#ifndef OS2
-	extern unsigned char *chemin_semaphores_SysV;
-#else
+#ifndef OS2 // IPCS_SYSV
+	extern unsigned char *racine_segment;
+#else // OS/2
 	unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
 	unsigned char racine_memoire_OS2[] = "\\SHAREMEM\\";
 #endif
@@ -133,35 +269,71 @@ sem_init_SysV(sem_t *semaphore, int shar
 {
 	// Création d'un sémaphore anonyme qui devra être supprimé par
 	// sem_destroy_SysV
-#	ifndef OS2
 
-	int				ios;
+#	ifndef OS2 // IPCS_SYSV
+		int				desc;
+		int				ios;
+
+		key_t			clef;
+
+		union semun		argument;
+
+		if (shared == 0)
+		{
+			// Sémaphore privé
+			(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
+					S_IRUSR | S_IWUSR);
+			(*semaphore).path = NULL;
+			(*semaphore).pid = getpid();
+			(*semaphore).tid = pthread_self();
+			(*semaphore).alloue = 0;
+		}
+		else
+		{
+			// Sémaphore partagé entre plusieurs processus
+			if (((*semaphore).path = malloc((strlen(racine_segment)
+					+ 2 + 256 + 1) * sizeof(unsigned char))) == NULL)
+			{
+				return(-1);
+			}
 
-	union semun		argument;
+			sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%d",
+					racine_segment, (int) getpid(), pthread_self(), shared);
 
-	if (shared != 0)
-	{
-		errno = ENOSYS;
-		return(-1);
-	}
+			if ((desc = open((*semaphore).path, O_RDWR | O_CREAT | O_EXCL,
+					S_IRUSR | S_IWUSR)) == -1)
+			{
+				free((*semaphore).path);
+				return(-1);
+			}
 
-	(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
-			S_IRUSR | S_IWUSR);
-	(*semaphore).path = NULL;
-	(*semaphore).pid = getpid();
+			(*semaphore).pid = getpid();
+			(*semaphore).tid = pthread_slef();
+			clef = ftok((*semaphore).path, 1);
+			close(desc);
 
-	if ((*semaphore).sem == -1)
-	{
-		errno = EINVAL;
-		return(-1);
-	}
+			if (clef == -1)
+			{
+				free((*semaphore).path);
+				return(-1);
+			}
 
-	argument.val = valeur;
-	ios = semctl((*semaphore).sem, 0, SETVAL, argument);
+			(*semaphore).alloue = 0;
+			(*semaphore).sem = semget(clef, 1, IPC_CREAT | IPC_EXCL |
+					S_IRUSR | S_IWUSR);
+		}
 
-	return(ios);
+		if ((*semaphore).sem == -1)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
 
-#	else
+		argument.val = valeur;
+		ios = semctl((*semaphore).sem, 0, SETVAL, argument);
+
+		return(ios);
+#	else // OS/2
 
 	sem_t			*psem;
 
@@ -219,26 +391,25 @@ int
 sem_destroy_SysV(sem_t *semaphore)
 {
 	// Détruit un sémaphore anonmyme
-#	ifndef OS2
 
-	if ((*semaphore).path != NULL)
-	{
-		return(EINVAL);
-	}
-
-	if ((*semaphore).pid != getpid())
-	{
-		return(0);
-	}
+#	ifndef OS2 // IPCS_SYSV
+		if ((*semaphore).path != NULL)
+		{
+			return(EINVAL);
+		}
 
-	if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
-	{
-		return(EINVAL);
-	}
+		if ((*semaphore).pid != getpid())
+		{
+			return(0);
+		}
 
-	return(0);
+		if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
+		{
+			return(EINVAL);
+		}
 
-#	else
+		return(0);
+#	else // OS/2
 
 	sem_t		*psem;
 
@@ -287,26 +458,24 @@ sem_destroy_SysV(sem_t *semaphore)
 int
 sem_wait_SysV(sem_t *semaphore)
 {
-#	ifndef OS2
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
 
-	struct sembuf		commande;
+		commande.sem_num = 0;
+		commande.sem_op = -1;
+		commande.sem_flg = 0;
 
-	commande.sem_num = 0;
-	commande.sem_op = -1;
-	commande.sem_flg = 0;
-
-	while(semop((*semaphore).sem, &commande, 1) == -1)
-	{
-		if (errno != EINTR)
+		while(semop((*semaphore).sem, &commande, 1) == -1)
 		{
-			errno = EINVAL;
-			return(-1);
+			if (errno != EINTR)
+			{
+				errno = EINVAL;
+				return(-1);
+			}
 		}
-	}
-
-	return(0);
 
-#	else
+		return(0);
+#	else // OS/2
 
 	sem_t		*psem;
 
@@ -345,26 +514,24 @@ sem_wait_SysV(sem_t *semaphore)
 int
 sem_trywait_SysV(sem_t *semaphore)
 {
-#	ifndef OS2
-
-	struct sembuf		commande;
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
 
-	commande.sem_num = 0;
-	commande.sem_op = -1;
-	commande.sem_flg = IPC_NOWAIT;
+		commande.sem_num = 0;
+		commande.sem_op = -1;
+		commande.sem_flg = IPC_NOWAIT;
 
-	while(semop((*semaphore).sem, &commande, 1) == -1)
-	{
-		if (errno != EINTR)
+		while(semop((*semaphore).sem, &commande, 1) == -1)
 		{
-			errno = EINVAL;
-			return(-1);
+			if (errno != EINTR)
+			{
+				errno = EINVAL;
+				return(-1);
+			}
 		}
-	}
-
-	return(0);
 
-#	else
+		return(0);
+#	else // OS/2
 
 	int			ios;
 
@@ -405,26 +572,24 @@ sem_trywait_SysV(sem_t *semaphore)
 int
 sem_post_SysV(sem_t *semaphore)
 {
-#	ifndef OS2
-
-	struct sembuf		commande;
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
 
-	commande.sem_num = 0;
-	commande.sem_op = 1;
-	commande.sem_flg = 0;
+		commande.sem_num = 0;
+		commande.sem_op = 1;
+		commande.sem_flg = 0;
 
-	while(semop((*semaphore).sem, &commande, 1) == -1)
-	{
-		if (errno != EINTR)
+		while(semop((*semaphore).sem, &commande, 1) == -1)
 		{
-			errno = EINVAL;
-			return(-1);
+			if (errno != EINTR)
+			{
+				errno = EINVAL;
+				return(-1);
+			}
 		}
-	}
-
-	return(0);
 
-#	else
+		return(0);
+#	else // OS/2
 
 	sem_t				*psem;
 
@@ -448,17 +613,15 @@ sem_post_SysV(sem_t *semaphore)
 int
 sem_getvalue_SysV(sem_t *semaphore, int *valeur)
 {
-#	ifndef OS2
-
-	(*valeur) = semctl((*semaphore).sem, 0, GETVAL);
+#	ifndef OS2 // IPCS_SYSV
+		(*valeur) = semctl((*semaphore).sem, 0, GETVAL);
 
-	if ((*valeur) < 0)
-	{
-		return(EINVAL);
-	}
-
-	return(0);
+		if ((*valeur) < 0)
+		{
+			return(EINVAL);
+		}
 
+		return(0);
 #	else
 
 	sem_t				*psem;
@@ -489,11 +652,11 @@ sem_t
 	sem_t				*semaphore;
 
 #	ifndef OS2
-	file				*desc;
+		int				desc;
 
-	key_t				clef;
+		key_t			clef;
 
-	union semun			argument;
+		union semun		argument;
 #	endif
 
 	unsigned char		*nom_absolu;
@@ -503,29 +666,31 @@ sem_t
 	va_list				liste;
 
 #	ifdef OS2
-	sem_t				*psem;
+		sem_t			*psem;
 
-	PVOID				base;
+		PVOID			base;
 
-	unsigned char		*ptr;
-	unsigned char		*nom_segment;
+		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);
-	}
+#	ifndef OS2 // IPCS_SYSV
+		if ((nom_absolu = malloc((strlen(racine_segment) + strlen(nom)
+				+ 2) * sizeof(unsigned char))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
 
-	sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
+		sprintf(nom_absolu, "%s/%s", racine_segment, nom);
 
-	if ((semaphore = malloc(sizeof(sem_t))) == NULL)
-	{
-		return(SEM_FAILED);
-	}
+		if ((semaphore = malloc(sizeof(sem_t))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
 
+		(*semaphore).alloue = -1;
+		(*semaphore).pid = getpid();
+		(*semaphore).tid = pthread_self();
 #	else
 
 	if ((nom_segment = malloc((strlen(racine_memoire_OS2) + strlen(nom) + 1)
@@ -581,29 +746,26 @@ sem_t
 	{
 		// 2 arguments
 
-#		ifndef OS2
-
-		clef = ftok(nom_absolu, 1);
+#		ifndef OS2 // IPCS_SYSV
+			clef = ftok(nom_absolu, 1);
 
-		if (clef == -1)
-		{
-			return(SEM_FAILED);
-		}
-
-		(*semaphore).sem = semget(clef, 0, 0);
-		(*semaphore).path = nom_absolu;
-		(*semaphore).pid = getpid();
-
-		if ((*semaphore).sem == -1)
-		{	
-			free(semaphore);
-			free(nom_absolu);
-
-			return(SEM_FAILED);
-		}
+			if (clef == -1)
+			{
+				return(SEM_FAILED);
+			}
 
-#		else
+			(*semaphore).sem = semget(clef, 0, 0);
+			(*semaphore).path = nom_absolu;
+			(*semaphore).pid = getpid();
+
+			if ((*semaphore).sem == -1)
+			{	
+				free(semaphore);
+				free(nom_absolu);
 
+				return(SEM_FAILED);
+			}
+#		else // OS/2
 		if ((psem = malloc(sizeof(sem_t))) == NULL)
 		{
 			free(nom_absolu);
@@ -683,45 +845,45 @@ sem_t
 		valeur = va_arg(liste, unsigned int);
 		va_end(liste);
 
-#		ifndef OS2
-
-		if ((desc = fopen(nom_absolu, "w")) == NULL)
-		{
-			free(semaphore);
-			free(nom_absolu);
+#		ifndef OS2 // IPCS_SYSV
+			if ((desc = open(nom_absolu, O_CREAT | O_EXCL | O_RDWR,
+					S_IRUSR | S_IWUSR)) == -1)
+			{
+				free(semaphore);
+				free(nom_absolu);
 
-			return(SEM_FAILED);
-		}
+				return(SEM_FAILED);
+			}
 
-		fclose(desc);
+			if ((clef = ftok(nom_absolu, 1)) == -1)
+			{
+				close(desc);
+				free(semaphore);
+				free(nom_absolu);
 
-		if ((clef = ftok(nom_absolu, 1)) == -1)
-		{
-			free(semaphore);
-			free(nom_absolu);
+				return(SEM_FAILED);
+			}
 
-			return(SEM_FAILED);
-		}
+			close(desc);
 
-		(*semaphore).sem = semget(clef, 1,
-				(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |
-				(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |
-				(int) mode);
-		(*semaphore).path = nom_absolu;
-		(*semaphore).pid = getpid();
+			(*semaphore).sem = semget(clef, 1,
+					(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |
+					(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |
+					(int) mode);
+			(*semaphore).path = nom_absolu;
+			(*semaphore).pid = getpid();
+
+			if ((*semaphore).sem == -1)
+			{	
+				free(semaphore);
+				free(nom_absolu);
 
-		if ((*semaphore).sem == -1)
-		{	
-			free(semaphore);
-			free(nom_absolu);
-
-			return(SEM_FAILED);
-		}
-
-		argument.val = valeur;
-		semctl((*semaphore).sem, 0, SETVAL, argument);
+				return(SEM_FAILED);
+			}
 
-#		else
+			argument.val = valeur;
+			semctl((*semaphore).sem, 0, SETVAL, argument);
+#		else // OS/2
 
 		if ((psem = malloc(sizeof(sem_t))) == NULL)
 		{
@@ -787,16 +949,18 @@ int
 sem_close_SysV(sem_t *semaphore)
 {
 	// Ferme un sémaphore nommé créé par sem_open_SysV()
-#	ifndef OS2
-
-	if ((*semaphore).path != NULL)
-	{
-		free((*semaphore).path);
-	}
+#	ifndef OS2 // IPCS_SYSV
+		if ((*semaphore).path != NULL)
+		{
+			free((*semaphore).path);
+		}
 
-	free(semaphore);
-	return(0);
+		if ((*semaphore).alloue == -1)
+		{
+			free(semaphore);
+		}
 
+		return(0);
 #	else
 
 	sem_t		*psem;
@@ -842,29 +1006,17 @@ int
 sem_unlink_SysV(const char *nom)
 {
 	// Détruit un sémaphore nommé créé par sem_open_SysV()
-#	ifndef OS2
-
-	unsigned char		*nom_absolu;
-
-	if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
-			+ 1) * sizeof(unsigned char))) == NULL)
-	{
-		return(ENOMEM);
-	}
+#	ifndef OS2 // IPCS_SYSV
+		semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID);
 
-	sprintf(nom_absolu, "%s%s", chemin_semaphores_SysV, nom);
-	semctl(semget(ftok(nom_absolu, 1), 0, 0), 0, IPC_RMID);
+		if (unlink(nom_absolu) == -1)
+		{
+			free(nom_absolu);
+			return(EACCES);
+		}
 
-	if (unlink(nom_absolu) == -1)
-	{
 		free(nom_absolu);
-		return(EACCES);
-	}
-
-	free(nom_absolu);
-
-	return(0);
-
+		return(0);
 #	else
 
 	return(0);