Discussion :

[SASARITA]

Bonsoir je dois remettre un client serveur à la fin du mois de Mai sdv;mon programme est fonctionnel;mais notre professeur voudrait qu'on fasse l'équivalent de notre programme avec des tubes nommés;mais je ne maîtrise pas trop cette notion la;j'aimerais que vous m'aider;me guider afin de pouvoir faire l'équivalent de mon projet en tube nommés.SVP;merci.

Client.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include<sys/types.h>
int main()
{
 
    pid_t pid;
    int id;
    char msg[255];//variable qui contiendrat les messages
 
    struct sockaddr_in informations;  //structure donnant les informations sur le serveur
 
    /*initialisation du protocole, TCP  l'adresse de connection 127.0.0.1 (en local) et du port du serveur (1400)*/
    informations.sin_family = AF_INET;
    informations.sin_port = htons(2500);
    informations.sin_addr.s_addr = inet_addr("127.0.0.1");
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0); // creation du socket propre au client
 
    if (socketID == -1)    //test de création du socket
    {
        perror("socket");
        exit (-1);
    }
 
    if ((connect(socketID, (struct sockaddr *) &informations, sizeof(struct sockaddr_in))) == -1)   //connexion au serveur
    {
        perror("connect");
        exit (-1);
    }
 
    if (strcmp(msg, "aurevoir") != 0)
    {
        memset(msg, 0, 255);
        recv(socketID, msg, 255, 0);
        printf ("%s\n", msg);
    }
 
    do
    {
        id+=1;
        printf ("moi : ");
        fgets(msg, 255, stdin);// le client ecrit son message
        msg[strlen(msg) - 1] = '\0';
 
        if ((send(socketID, msg, strlen(msg), 0)) == -1)
            perror("send");
 
 
    }
    while (strcmp(msg, "aurevoir") != 0);    // tant que le client n'envoie pas "aurevoir" la conversation n'est pas fini
 
    shutdown(socketID, SHUT_RDWR);// fermeture du socket
 
    return 0;
 
}

Serveur.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
#include<signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    //structure donnant les informations sur le serveur et sur le client
    struct sockaddr_in information_server;
    struct sockaddr_in information_client;
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
    int connexion = 0;
    int pid;
    int id;
    char msg[255];
 
    id=0;
    socklen_t len = sizeof(struct sockaddr_in); //déclaration d' une variable du type socklen_t qui contiendra la taille de la structure
 
    if (socketID == -1)
    {
        perror("socket");
        exit(-1);
    }
 
    /*initialisation du protocole, TCP  l'adresse de connection 127.0.0.1 (en local) et du port du serveur (1400)*/
    memset(&information_server, 0, sizeof(struct sockaddr_in));
    information_server.sin_port = htons(2500);
    information_server.sin_family = AF_INET;
 
    /* création de la connexion*/
    if ((bind(socketID, (struct sockaddr *) &information_server, sizeof(struct sockaddr))) == -1)
    {
        perror("bind");
        exit(-1);
    }
 
    /* le serveur écoute si un client cherche à se connecter*/
    if ((listen(socketID, 5)) == -1)
    {
        perror("listen");
        exit (-1);
    }
    while (1)
    {
 
        memset(&information_client, 0, sizeof(struct sockaddr_in));
        connexion = accept(socketID, (struct sockaddr *) &information_client, &len); //le serveur accepte la connexion
 
        if (connexion == -1)
        {
            perror("accept");
            exit(-1);
        }
        id+=1;
        /* Create child process */
        pid = fork();
 
        if (pid < 0)
        {
            perror("ERROR on fork");
            exit(1);
        }
        if (pid == 0)
        {
            /* This is the client process */
            close(socketID);
            printf ("Connexion acceptée de : client %i\n",id);
            memset(msg, 0, 255);
            sprintf(msg,"bienvenu! client %i",id);
            send(connexion, msg, strlen(msg), 0);
            do
            {
                memset(msg, 0, 255);
                recv(connexion, msg, 255, 0);
 
                if (strcmp(msg, "aurevoir") == 0)    //si le client ecrit aurevoir il est deconnecté du chat
                {
                    printf ("Connexion fermée pour le client %i\n",id);
                    shutdown(socketID, SHUT_RDWR);
                    exit (0);
                }
 
                printf ("client %d : %s\n",id,msg);
                send(connexion, msg, strlen(msg), 0);
 
            }
            while(1);
        }
        else
        {
            close(connexion);
 
        }
 
    }
    return 0;
 
}

[skeud]

2 petits conseil, ne met pas tout dans le main, c'est horrible à lire, et pour faire la modification que tu veux faire, tu vas galéré.

Ensuite regarde sur internet, il y a beaucoup de tuto la dessus.

Je te conseillerais de faire au moins:
_ une fonction d'initialisation
_ une fonction de lecture
_ une fonction d'écriture.

De cette manière, tu pourras facilement remplacer les socket par des "tube nommé" (perso j'appelle named pipe, c'est plus parlant ^^).

Le fonctionnement est pratiquement le meme que pour les socket, à la différence que l'échange se passe sur le disque et non pas par le reseau.

<horsSujet>
Quel est l'interet de faire un client/serveur en named pipe?
</horsSujet>

[SASARITA]

Merci pour tes conseils;finalement mon professeur a changé d'avis.Merci d'avoir regardé quand même ma discussion.