Client serveur pour un palindrome

Bonsoir,

J'ai voulu le testé juste comme ça;car j'aime bien testé des codes.
Mais le problème c'est qu' il y a une erreur;j'ai fait part de ceci à celui qui a posté ce code mais il n'a toujours pas répondu;donc je me tourne vers vous.
Erreur lors de l'exécution: segmentation fault
Débogue: erreur au niveau de la variable mot.
L'erreur survint au niveau du code du client :ligne 16 sinon la ligne 19 quand la ligne 16 est en en commentaire et 22 quand la ligne 16 et 19 sont en commentaires.

Voici le code
serveur.c

/*** Fichier Serveur ***/
/* Il créée une fifo tube_serveur dans laquelle il recevra les messages des clients*/
/* Chaque message est composé du nom de la fifo client et du mot qu'envoit le client : "fifo;mot"*/
/* Le serveur détruit le tube serveur, crée le tube du client, analyse le mot puis renvoit sa réponse au client via son tube */

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
61
62
63
64
65
66
67
#include "librairie.h"
#include "./palindrome.c"
 
int main()
{   char tube_serveur[TAILLE_CHAINE]="tube_serveur.fifo";
    int sortieTube; /* pointera sur la sortie du tube serveur */
    int entree_tube;/* pointera sur le tube client */
    char chaineALire[TAILLE_CHAINE];/*chaine à lire dans le tube serveur*/
    char chaineAEcrire[TAILLE_CHAINE]; /*chaine à écrire dans le tube du client*/
    char *tube_client;/*un pointeur pour la fonction strtok (chaineALire, ";") qui permet de segmenter chaineALire */
    char *mot;/* mot que le client veut tester si c'est un palindrome ou non */
 
    do /* while((strcmp(mot,"FIN") != 0) ); => tant que le client n'a pas dit FIN */
    {   /***************** création tube serveur **********************/
        if(mkfifo(tube_serveur, 0644) != 0)
        {   fprintf(stderr, "Impossible de créer le tube nommé.\n");
            exit(EXIT_FAILURE);
        }
        /**************** Attente d'un appel client ******************/
        if((sortieTube = open (tube_serveur, O_RDONLY)) == -1)
        {
            fprintf(stderr, "Impossible d'ouvrir la sortie du tube nommé.\n");
            exit(EXIT_FAILURE);
        }
        read(sortieTube, chaineALire, TAILLE_CHAINE);
        unlink(tube_serveur);
        printf("%s\n", chaineALire);
        tube_client = strtok (chaineALire, ";");/* segmente la chaine par le séparateur ; donc tube_client vaut le nom du tube du client (1ère partie de la chaine)*/
        mot = strtok (NULL, ";");
        printf ("client : %s\n", tube_client);
        printf ("message : %s\n", mot);
        /************* Ecriture dans le tube client ********/
        unlink(tube_client);/*on détruit le dernier tube client*/
        if(mkfifo(tube_client, 0644) != 0)
        {   fprintf(stderr, "Impossible de créer le tube nommé.\n");
            exit(EXIT_FAILURE);
        }
        if((entree_tube = open(tube_client, O_WRONLY)) == -1)
        {   fprintf(stderr, "Impossible d'ouvrir l'entrée du tube nommé.\n");
            exit(EXIT_FAILURE);
        }
 
        if (strcmp(mot,"FIN") == 0)/*Si le mot vaut FIN on le serveur inutile d'utiliser la fonction de palindrome */
        {   memset( chaineAEcrire, '\0', sizeof(chaineAEcrire) );
            sprintf(chaineAEcrire,"Fin du serveur");
        }
        else
        {
            if(isPalindrome(mot))/* Le mot est-il un palindrome? */
            {   memset(chaineAEcrire, '\0', sizeof(chaineAEcrire) );/*remplace toutes les cases de la chaine par \0 : vide la chaine*/
                sprintf(chaineAEcrire,mot);/*on écrit le mot dans la chaine*/
                strcat(chaineAEcrire, " est un palaindrome."); /* on indique que c'est un palindrome */
            }
            else
            {   memset( chaineAEcrire, '\0', sizeof(chaineAEcrire) );
                sprintf(chaineAEcrire,mot);
                strcat(chaineAEcrire, " n'est pas un palaindrome.");
            }
        }
        write(entree_tube,chaineAEcrire, TAILLE_CHAINE);/* réponse au client */
    }
    while((strcmp(mot,"FIN") != 0) );
    /************** Programme terminé *****************************/
    unlink(tube_serveur);
    printf("fin du serveur");
    return EXIT_SUCCESS;
}

clientB.c : l'utilisateur peut lui même écrire les mots!

/*** Fichier ClientB ***/

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
 
#include "librairie.h"/* contient toute les librairies à inclure */
 
int main()
{   char tube_serveur[TAILLE_CHAINE]="tube_serveur.fifo"; /* tube pour envoyer des messages au serveur */
    char tube_client[TAILLE_CHAINE]="tube_client.fifo"; /* tube pour recevoir les message du serveur*/
    int entree_tube;/* pointera sur le tube du serveur */
    int sortieTube;/* pointera sur le tube du client */
    char chaineALire[TAILLE_CHAINE];
    char chaineAEcrire[TAILLE_CHAINE];/* chaine envoyée au serveur */
    char *mot="";/*obligation d'initialiser car pedantic indique une erreur sinon*/
 
    printf("Bienvenue sur mini-projet Palindrome Client/Serveur!\n");
    printf("Veuiller saisir un mot pour savoir si c'est un palindrome \n(pour quitter le programme saisissez : FIN)\n\n");
    do /* Pas de for car l'objectif d'optimisation est que le l'utilisateur tape les mot auquel cas on ne saurait pas combien il souhaite en tester(sauf s'il l'indique)*/
    {   memset(mot, '\0', sizeof(mot) );/*vide la variable mot*/
        memset(chaineAEcrire, '\0', sizeof(chaineAEcrire) );/*vide la variable mot*/
        printf("Saisir un mot : ");
        scanf("%s",mot); /*utilisateur entre le mot*/
        strcat(chaineAEcrire,tube_client); /*formation de la chaine "tube_client.fifo;mot" */
        strcat(chaineAEcrire,";");
        strcat(chaineAEcrire,mot);
        /************* Ecriture dans le tube serveur ********/
        while((entree_tube = open(tube_serveur, O_WRONLY)) == -1)
        {   sleep(1); /* on attend que le serveur soit disponnible avant d'écrire, permet aussi de pouvoir lancer le client avant le serveur sans plantage de celui-ci*/
            /*on peut imaginer un compteur qui abandonne au bout bout de cpt seconde : cpt=1;sleep(1); cpt++*/
        }
        write(entree_tube,chaineAEcrire, TAILLE_CHAINE);
 
        /****************  Lecture de la réponse du serveur ******************/
        while((sortieTube = open (tube_client, O_RDONLY)) == -1)
        {   sleep(1);/*idem que pour l'entrée, (plusieurs soucis ont été rencontré quand le client faisait lui meme sa fifo donc j'ai préférer donner la crétaion du tube client au serveur*/
        }
        read(sortieTube, chaineALire, TAILLE_CHAINE);
        printf("%s\n", chaineALire);
    }
    while((strcmp(mot,"FIN") != 0));
    /*************** FIN DU PROGRAMME ******************/
    unlink(tube_client);/* Bine que le serveur ne le fasse on n'est jamais trop prudent et ceci ne génère pas d'erreur de le supprimer alors qu'il n'existe plus*/
    return EXIT_SUCCESS;
}

/*** fichier librairie.h ***/
/* permet d'éviter de retaper plusieurs fois les includes dans chaque fichier */
/* centralise les librairie */

Code:

1
2
3
4
5
6
7
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>/*pour utiliser strtok par exemple*/
#define TAILLE_CHAINE   256

/*** fichier palindrome ***/
/* contient la fonction de test du palindrome */

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
 
int isPalindrome(char *t)
{   int i;/*emplacement de la lettre en commencant par le début (ex : t[0] puis t[1]...*/
    int j;/*emplacement de la lettre en commencant par le début (ex : t[n] puis t[n-1]...*/
    int n=strlen(t); /* taille de la chaine  */
    for(i=0,j=n-1;i<j;i++,j--)
    {   if(tolower(t[i])!=tolower(t[j])) /*on met en minuscule car A!=a or Anna est un palindrome */
        {     return 0;/*ce n'est pas un palindrome*/
        }
    }
    return 1;
}