--- rpl/src/interruptions.c	2010/04/30 15:01:14	1.13
+++ rpl/src/interruptions.c	2010/05/22 21:45:50	1.17
@@ -366,7 +366,6 @@ retrait_thread_surveillance(struct_proce
 		return;
 	}
 
-	// l_element_courant->donnee n'est pas bonne lorsque ça part en vrille.
 	if (l_element_precedent == NULL)
 	{
 		liste_threads_surveillance = (*l_element_courant).suivant;
@@ -1156,6 +1155,12 @@ liberation_threads(struct_processus *s_e
 				element_courant = element_suivant;
 			}
 
+/*
+================================================================================
+  À noter : on ne ferme pas la connexion car la conséquence immédiate est
+  une destruction de l'objet pour le processus père.
+================================================================================
+
 			element_courant = (*s_etat_processus).s_connecteurs_sql;
 			while(element_courant != NULL)
 			{
@@ -1239,6 +1244,9 @@ liberation_threads(struct_processus *s_e
 
 				element_courant = element_suivant;
 			}
+*/
+
+			(*s_etat_processus).s_connecteurs_sql = NULL;
 
 			element_courant = (*s_etat_processus).s_marques;
 			while(element_courant != NULL)
@@ -1432,7 +1440,7 @@ recherche_thread_principal(pid_t pid, pt
 */
 
 // Les routines suivantes sont uniquement appelées depuis les gestionnaires
-// des signaux asynchrones. Elles de doivent pas bloquer dans le cas où
+// des signaux asynchrones. Elles ne doivent pas bloquer dans le cas où
 // les sémaphores sont déjà bloqués par un gestionnaire de signal.
 
 static inline void
@@ -1963,25 +1971,11 @@ interruption5(int signal, siginfo_t *sig
 			return;
 		}
 
-		if (signal == SIGFABORT)
-		{
-			(*s_etat_processus).arret_depuis_abort = -1;
-		}
-
 		if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
 		{
-			if (signal == SIGFSTOP)
-			{
-				printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
-						(unsigned long long) pthread_self());
-				fflush(stdout);
-			}
-			else
-			{
-				printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
-						(unsigned long long) pthread_self());
-				fflush(stdout);
-			}
+			printf("[%d] SIGFSTOP (thread %llu)\n", (int) getpid(),
+					(unsigned long long) pthread_self());
+			fflush(stdout);
 		}
 
 		/*
@@ -2009,11 +2003,6 @@ interruption5(int signal, siginfo_t *sig
 			return;
 		}
 
-		if (signal == SIGFABORT)
-		{
-			(*s_etat_processus).arret_depuis_abort = -1;
-		}
-
 		// Envoi d'un signal au thread maître du groupe.
 
 		if (recherche_thread_principal(getpid(), &thread) == d_vrai)
@@ -2142,8 +2131,8 @@ interruption9(int signal, siginfo_t *sig
 		fflush(stdout);
 	}
 
-	pthread_kill((*s_etat_processus).tid_processus_pere, SIGFABORT);
 	deverrouillage_gestionnaire_signaux();
+	interruption11(signal, siginfo, context);
 	return;
 }
 
@@ -2185,6 +2174,73 @@ interruption10(int signal, siginfo_t *si
 	}
 
 	deverrouillage_gestionnaire_signaux();
+	return;
+}
+
+void
+interruption11(int signal, siginfo_t *siginfo, void *context)
+{
+	pthread_t				thread;
+	struct_processus		*s_etat_processus;
+
+	verrouillage_gestionnaire_signaux();
+
+	if ((*siginfo).si_pid == getpid())
+	{
+		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
+				== NULL)
+		{
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+
+		(*s_etat_processus).arret_depuis_abort = -1;
+
+		if (((*s_etat_processus).type_debug & d_debug_signaux) != 0)
+		{
+			printf("[%d] SIGFABORT (thread %llu)\n", (int) getpid(),
+					(unsigned long long) pthread_self());
+			fflush(stdout);
+		}
+
+		/*
+		 * var_globale_traitement_retarde_stop :
+		 *  0 -> traitement immédiat
+		 *  1 -> traitement retardé (aucun signal reçu)
+		 * -1 -> traitement retardé (un ou plusieurs signaux stop reçus)
+		 */
+
+		if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
+		{
+			(*s_etat_processus).var_volatile_requete_arret = -1;
+		}
+		else
+		{
+			(*s_etat_processus).var_volatile_traitement_retarde_stop = -1;
+		}
+	}
+	else
+	{
+		if ((s_etat_processus = recherche_thread(getpid(), pthread_self()))
+				== NULL)
+		{
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+
+		(*s_etat_processus).arret_depuis_abort = -1;
+
+		// Envoi d'un signal au thread maître du groupe.
+
+		if (recherche_thread_principal(getpid(), &thread) == d_vrai)
+		{
+			pthread_kill(thread, signal);
+			deverrouillage_gestionnaire_signaux();
+			return;
+		}
+	}
+
+	deverrouillage_gestionnaire_signaux();
 	return;
 }