capter le Ctrl-C pour quitter proprement

Bonjour,
voila j'ai un programme qui tourne en boucle (un serveur en fait) et je pour quitter faut faire Ctrl-c je voudrais donc intercepté ce signal pour fermer ce qui doit l'etre (les thread les file de messages etc...) pour quitter le programme qu'une fois tout correctement quitté.

en fait faudrait un truc comme ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 debut: while{ insctructions } capter (Ctrl-C){ instructions pour tout fermer exit(0); } } fin
je sais qu'il faut utiliser les signaux mais je vois pas comment utiliser ça. Faut un thread pour pouvoir faire tourner le programme en boucle tout en étant pret a récupérer le Ctrl-C?

Pourriez vous m'aider?

Merci

Alors moi j'avais fais un jour un serveur (pour un chat) et pour quitter proprement tout j'avais rajouter à select (en plus des socket de chaque clients) stdin, lorsque je tapais quelque chose au clavier select se declenché, et je faisai ce que j'avais à faire.

Peut-etre tu peux faite la meme chose.

Je ne me rappele plus si on peut intercepter Ctrl+C

A priori tu tournes sous linux.

Ce que je vais dire ne fonctionne que sous unix.
Il faut que tu installes un gestionnaire de signal pour le signal envoyé par control^c dans le terminal (SIGINT).

Un petit exemple de code va mieux parler que moi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
 
//Drapeau d'arrêt du programme. Sa valeur d'origine est 0.
unsigned short stop = 0;
 
 
/***********************************
* Fonction de reception des signaux.
* Si le signal reçu est SIGINT Ctl^c, alors on increment le nombre de signaux de ce type reçu.
* Quand ce nombre est egal a 5 on met stop à 1.
************************************/
void signalHandler(int signal){
	if(signal==SIGINT){
		static unsigned short nbSignal = 0;
		nbSignal++;
		printf("Signal Ctrl^c n°%i reçu\n",nbSignal);
		if(nbSignal==5) stop=1;
	}
}
 
 
/**************************
* Fonction principale.
* Exemple de mise en place d'une fonction de traitement de signal.
**************************/
int main(){
 
/**********************************************************
MISE EN PLACE DE LA GESTION DU SIGNAL CONTROL^C (SIGINT)
**********************************************************/
	//Structure pour l'enregistrement d'une action déclenchée lors de la reception d'un signal.
	struct sigaction action, oldAction;
 
	action.sa_handler = signalHandler;	//La fonction qui sera appellé est signalHandler
 
	//On vide la liste des signaux bloqués pendant le traitement
	//C'est à dire que si n'importe quel signal (à part celui qui est traité)
	//est declenché pendant le traitement, ce traitement sera pris en compte.
	sigemptyset(&action.sa_mask);
 
	//Redémarrage automatique Des appels systêmes lents interrompus par l'arrivée du signal.
	action.sa_flags = SA_RESTART;
 
	//Mise en place de l'action pour le signal SIGINT, l'ancienne action est sauvegardé dans oldAction
	sigaction(SIGINT, &action, &oldAction);
/*********************************************************/
 
 
/************************
        TRAITEMENT
************************/
	while(!stop);
 
/************************
        FIN
************************/
	return EXIT_SUCCESS;
}