IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Socket + fork


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2014
    Messages : 29
    Par défaut Socket + fork
    Bonjour à tous,

    Voici mon problème, je dois monter une architecture serveur client multi connexion (avec gestion de processus).

    Le code Serveur
    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
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
     
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include<unistd.h> 
    #define SOCKET_ERROR -1
     
     
    void traitementclient(int connfd)
    {
                     time_t tempo;
                     char buff[50];
                     tempo=time(NULL);//releve le temps courant (en s)
                     snprintf(buff,sizeof(buff),"%.24s\n",ctime(&tempo));//convertit le temps en date
                     write(connfd,buff,sizeof(buff));
                     //sleep(7)
     
                     int n,sock_err;
                     while((n=read(connfd,buff,50))>0)
                     {
                             printf("Reception message serveur");
                             buff[n]='\0';
                             fputs(buff,stdout);
                             if(recv(connfd,buff,32,0)!= SOCKET_ERROR)
                                     printf("\nRecu:%s\n",buff);
                     }
     
     
     
     
     
    }
     
    main(int argc, char *argv[])
    {
    int listenfd,connfd,port,i;
    socklen_t len;
    struct sockaddr_in servaddr,cliaddr;
    char adresseIP[16],buff[50];
    time_t tempo;
     
    // s'il n'y a pas 2 arguments sur la ligne de commande, on sort
     
    if (argc!=2)
            {
            printf("Usage : serveur Port\n");
            exit(-1);
     
    // creation de la socket TCP(SOCK_STREAM) sur IPv4(AF_INET)
    // recuperation du descripteur de socket listenfd 
    listenfd=socket(AF_INET,SOCK_STREAM,0);
     
    // mise a zero de la structure servaddr
    bzero(&servaddr,sizeof(servaddr));
     
    // famille d'adresses : IPv4
    servaddr.sin_family=AF_INET;
    // adresse IP d'ecoute du serveur : INADDR_ANY (adresse wildcard)
    // c'est-a-dire que le serveur ecoutera sur toutes ses interfaces
    // on la range en ordre réseau avec htonl
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    // port d'ecoute du serveur : l'argument n°1
    // on le convertit en entier avec atoi
    // puis on le range en ordre reseau avec htons
    servaddr.sin_port=htons(atoi(argv[1]));
     
    // on lie la structure servaddr a la socket listenfd
    // pour definir le port et l'adresse d'ecoute du serveur
    if (bind(listenfd,(struct sockaddr *)& servaddr,sizeof(servaddr))<0)
            {
            perror("Erreur de bind");
            exit(-1);
            }
     
    // on passe la socket en mode passif : elle devient capable d'attendre une connexion
    listen(listenfd,10);
    // boucle infinie du serveur
    for(i=0;i<3;i++)
            {
            len=sizeof(cliaddr);
            // mise en attente de connexion
            // on recuperera dans cliaddr les coordonnees (adresse et port du client)
            // accept retourne un descripteur de socket connectée avec lequel on lire et ecrira dans la socket
            connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&len);
            // On recupere dans port le port de connexion du client
            // on le passe en ordre machine avec ntohs
            port=ntohs(cliaddr.sin_port);
            // on convertit l'adresse IP stockee en numerique dans cliaddr
            // en decimale pointee
            inet_ntop(AF_INET,&cliaddr.sin_addr,adresseIP,sizeof(adresseIP));
            // on affiche les coordonnees du client
            printf("connexion de %s, port %d\n",adresseIP,port);
     
     
     
    ////////Gestion processus////////
            pid_t n;
            printf("\nDebut processus\n");
            n=fork()
            printf("\n Le processus actuel est le n°%d, i=%d\n",getpid(),i); //père //fils
            if(n==0)
            {
                    printf("\nJe suis le le fils :pid=%d, mon père est %d\n",getpid());
                    i=10;
                    printf("\nFils: pour moi, i=%d\n",i);
                    printf("\n///////////////////////////////////////////////////////////\n");
                    //Dans tempo le nombre de secondes ecoulees depuis le 01/01/1970
                    tempo=time(NULL);
                    //tranforme tempo en chaine de caracteres buff contenant date et l'heur
                    snprintf(buff,sizeof(buff),"%.24s\n",ctime(&tempo));
                    // on ecrit dans la socket la chaine buff
                    write(connfd,buff,strlen(buff));
     
                    close(listenfd);
                    traitementclient(connfd);
                    close(connfd);
                    exit(0);
            }
            else if(n>0)
            {
                    printf("Je suis le père : pid=%d, mon fils est %d\n",getpid(), n);
                    printf("père : pour moi, i=%d\n",i);
            }
            else
            {
                    printf("Erreur fork\n");
                    exit(-1);
            }
     
     
            }
    }

    Le code client:
    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 <arpa/inet.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
     
    main(int argc, char **argv)
    {
    int sockfd,n,i;
    char recu[50];
    struct sockaddr_in servaddr;
     
    if (argc!=3)
            {
            printf("Usage : client AdresseIP Port\n");
            exit(-1);
            }
     
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(atoi(argv[2]));
    inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
    //transforme l'adresse IP X.X.X.X passée en parametre en adresse comprehensible
    //par le systeme (32 bits)
     
    for ( i = 0 ; i < 5 ; i++)
    {
            if ( fork() == 0 )
            {
                    if((sockfd=socket(AF_INET,SOCK_STREAM,0))!=0)
                    {
                            char texte[32]="Hello world";
                            write(socket,texte,strlen(texte));      
     
                    }
                    if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
                    {
                            printf("Erreur de socket\n");
                            exit(-1);
                    }
     
                    if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
                            printf("erreur de connexion");
     
                    // le sleep n 
                    sleep(5);
                    while((n=read(sockfd,recu,50))>0)//quand le serveur clot la connexion, n=0
                    {
                            recu[n]='\0';
                            fputs(recu,stdout);
                    }
     
                    char tempo[32]="Bonjour serveur";
                    char buff[32];
                    write(sockfd,tempo,strlen(tempo));      
                    exit(0);
            }
    }
    }
    Ma question est que le serveur écrit bien dans la socket d'envoyer la variable buff (le client la reçois bien) mais comment le client peu lui répondre ???
    A l'aide d'un sendp ou lui ausi dois passer par le write.

    Merci,

  2. #2
    Membre très actif
    Avatar de sambia39
    Homme Profil pro
    No Comment
    Inscrit en
    Mai 2010
    Messages
    548
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : No Comment
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Mai 2010
    Messages : 548
    Par défaut
    Bonjour

    Le client peut répondre au serveur en utilisant la primitive d’écriture « write » (Attention, l’appel de ces primitives « write » et « read » sont succesptiblement d’être bloquantes) en mode connecté ou « sendto » en mode datagramme.

    Personnellement, je ne connais pas "sendp", mais plutôt « sendto » et « recvfrom » quand on est en mode datagramme.
    Et les primitives « write » et« read » en mode connecté.

    Cependant, il y a pas mal de chose qui m’interpelle dans votre code source, à en croire son implémentation on dirait un brainstorming sans compter que certaines notions élémentaires sont absentes.
    Pour vous répondre franchement, je doute que le code soit fonctionnelle.

    /!\: Quand on écrit le code d'un serveur qui gère ou utilise un processus par connexion, faut s’assurer que l’on ai une balayette zombie qui se charge de tuer le processus orphelin (zombie).

    à bientôt.

  3. #3
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2014
    Messages
    29
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2014
    Messages : 29
    Par défaut
    Bonjour,

    Merci pour votre réponse , pour la suite de mon projet je vais devoir être en mode connecté car le serveur doit être à l'écoute du client.

    Effectivement le code n'était pas fonctionnel j'ai travaillé dessus et cela est déjà un peu plus propre.

    Serveur:
    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
    105
    106
    107
    108
    109
    #include<sys/socket.h>
    #include<netinet/in.h>
    #include<arpa/inet.h>
    #include<sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>
    #include<unistd.h> 
     
     
     
    void traitementclient(int connfd)
    {
    int z,n;
    char recu[50];
     
     
    char bonjour[50]="\nBonjour client\n";
    write(connfd,bonjour,sizeof(bonjour));
    char qui[50]="\nWHO?\n";
    write(connfd,qui,sizeof(qui));
     
     
    while(connfd>0)
            {
     
                    read(connfd,recu,50);
                    fputs(recu,stdout);
                    /*char bonjour[50]="\nBonjour client\n";
                    write(connfd,bonjour,sizeof(bonjour));
                    recu[z]='\0';
     
                    char qui[50]="\nWHO?\n";
                    write(connfd,qui,sizeof(qui));*/
            }
    }
     
    main(int argc, char *argv[])
    {
    int listenfd,connfd,port;
    socklen_t len;
    struct sockaddr_in servaddr,cliaddr;
    char adresseIP[16],buff[50];
    time_t tempo;
     
    // s'il n'y a pas 2 arguments sur la ligne de commande, on sort
     
    if (argc!=2)
            {
            printf("Usage : serveur Port\n");
    exit(-1);
            }
     
    // creation de la socket TCP(SOCK_STREAM) sur IPv4(AF_INET)
    // recuperation du descripteur de socket listenfd 
    listenfd=socket(AF_INET,SOCK_STREAM,0);
     
    // mise a zero de la structure servaddr
    bzero(&servaddr,sizeof(servaddr));
     
    // famille d'adresses : IPv4
    servaddr.sin_family=AF_INET;
    // adresse IP d'ecoute du serveur : INADDR_ANY (adresse wildcard)
    // c'est-a-dire que le serveur ecoutera sur toutes ses interfaces
    // on la range en ordre réseau avec htonl
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    // port d'ecoute du serveur : l'argument n°1
    // on le convertit en entier avec atoi
    // puis on le range en ordre reseau avec htons
    servaddr.sin_port=htons(atoi(argv[1]));
     
    // on lie la structure servaddr a la socket listenfd
    // pour definir le port et l'adresse d'ecoute du serveur
    if (bind(listenfd,(struct sockaddr *)& servaddr,sizeof(servaddr))<0)
            {
            perror("Erreur de bind");
    // on passe la socket en mode passif : elle devient capable d'attendre une connexion
    listen(listenfd,2);
    // boucle infinie du serveur
    for(;;)
            {
            len=sizeof(cliaddr);
            // mise en attente de connexion
            // on recuperera dans cliaddr les coordonnees (adresse et port du client)
            // accept retourne un descripteur de socket connectée avec lequel on lire et ecrira dans la socket
            connfd=accept(listenfd,(struct sockaddr*)&cliaddr,&len);
            // On recupere dans port le port de connexion du client
            // on le passe en ordre machine avec ntohs
            port=ntohs(cliaddr.sin_port);
            // on convertit l'adresse IP stockee en numerique dans cliaddr
            // en decimale pointee
            inet_ntop(AF_INET,&cliaddr.sin_addr,adresseIP,sizeof(adresseIP));
            // on affiche les coordonnees du client
            printf("connexion de %s, port %d\n",adresseIP,port);
     
            int n;
            n=fork();
     
            if(n==0)
            {
                    close(listenfd);
                    traitementclient(connfd);
                    close(connfd);
                    exit(0);
            }
     
            }
    }

    Client:
    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
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
     
     
    main(int argc, char **argv)
    {
    int sockfd,n,i;
    char recu[50];
    struct sockaddr_in servaddr;
     
    if (argc!=3)
            {
            printf("Utilisation : client AdresseIP Port\n");
            exit(-1);
            }
     
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(atoi(argv[2]));
    inet_pton(AF_INET,argv[1],&servaddr.sin_addr);
    //transforme l'adresse IP X.X.X.X passée en parametre en adresse comprehensible
    //par le systeme (32 bits)
     
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
    {
            printf("Erreur de socket\n");
            exit(-1);
    }
     
    if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
    {       
            printf("erreur de connexion");
    }
    // le sleep n 
    sleep(5);
    while((n=read(sockfd,recu,50))>0)//quand le serveur clot la connexion, n=0
    {
                    char reponse[30]="\nBonjour serveur\n";
                    write(sockfd,reponse,sizeof(reponse));
                    recu[n]='\0';
                    fputs(recu,stdout);
    }
    }
    Il me manque la baleyette pour les processus zombie.

  4. #4
    Membre très actif
    Avatar de sambia39
    Homme Profil pro
    No Comment
    Inscrit en
    Mai 2010
    Messages
    548
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : No Comment
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Mai 2010
    Messages : 548
    Par défaut
    Bonjour
    il manque pas mal de choses.
    voici un de mes codes source a toi de t’en inspiré pour faire des améliorations nécessaires (et surtout de le comprendre).
    Le serveur envoie uniquement le time local de la machine sur lequel il s’exécute il est multiclients.

    Attention s’il s’agit d’un projet d’étude universitaire n’oublie pas de mettre les sources de la provenance du code en l’occurrence le site http://www.developpez.net/forums/d15...k/#post8675430 et s'il s'agit d'un autre site la licence qui va avec.

    Attention, le code source ci-dessous est susceptible de comporter des erreurs
    Le serveur:
    Code C : 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
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
     
    /*
     ============================================================================
     Name        : Untitled 2.c
     Author      : SAMBIA39
     Version     : 0.1 
     Copyright   : Copyright (c) 27/06/2016 SAMBIA39 GPL
     Description : Ansi-style
     ============================================================================
     */
     
    #define DEF_CLTM    15
    #define DEF_PORT    8888
     
    #include <time.h>
    #include <errno.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <sys/wait.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
     
    int f_error( char *p_msg ){
     
        extern int errno;
        extern const int sys_nerr;
        extern const char *const sys_errlist[];
     
        fprintf( stderr, "(%d)\t:%s\n", errno,
                (!p_msg) ? "inconnue" : p_msg );
        if( 0 < errno && errno < sys_nerr )
            fprintf( stderr, "info\t:%s\n",
                    sys_errlist[errno] );
        return -1;
    }
     
    /*    Fonction fatal error a revoir    */
    void f_fatal_error( char *p_msg ){
        if( -1 == f_error(p_msg) )
            exit( EXIT_FAILURE );
        exit( EXIT_FAILURE );
    }
     
    char *f_get_time_msg( void ){
        time_t t_time;
        if( time(&t_time) != (time_t)-1 )
            return ctime(&t_time);
        return NULL;  // code a revoir 
    }
     
    //fonction socket 
    int f_get_socket( int iPort, int inb_clt ){
     
        int isock = -1;
        const int ioptSock;
        struct sockaddr_in addr_sock;
     
        if( -1 == (isock = socket(AF_INET, SOCK_STREAM, 0) ) )
            return f_error("Erreur socket");
        if( -1 == setsockopt(isock, SOL_SOCKET, SO_REUSEADDR,
                             &ioptSock, sizeof(int) ) ){
            close( isock );
            return f_error("Erreur set option socket" );
        }
     
        iPort = ( 1024 > iPort ) ? DEF_PORT : iPort;
        memset((char*)&addr_sock, 0, sizeof(struct sockaddr_in) );
        addr_sock.sin_family = AF_INET;
        addr_sock.sin_port = htons(iPort);
        addr_sock.sin_addr.s_addr = htonl(INADDR_ANY);
     
        if( -1 == bind( isock, (struct sockaddr*)&addr_sock,
                       sizeof(struct sockaddr_in))){
            close( isock );
            return f_error("Erreur bind socket" );
        }
     
        inb_clt = ( !inb_clt ) ? DEF_CLTM : inb_clt;
        if( -1 == listen(isock, inb_clt) ){
            close( isock );
            return f_error("Erreur listen");
        }
        return isock;
    }
     
     
    int main( void ){
     
        long lflag;
        int isock = -1;
        extern int errno;
        char *ptime = NULL;
        int isock_client = -1;
     
        errno = 0;
        if( -1 == ( isock = f_get_socket(DEF_PORT, DEF_CLTM) ) )
            exit( EXIT_FAILURE );
     
        /*  socket non bloquante    */
        fcntl( isock, F_GETFL, &lflag );
        lflag |= O_NONBLOCK;
        fcntl( isock, F_SETFL, lflag );
     
        // boucle serveur  
        for( ;; ){
            pid_t pid;
            isock_client = -1;
            while( -1 == isock_client ){
                if( -1 == ( isock_client = accept(isock, NULL, 0)) &&
                   (EWOULDBLOCK != errno )){
                    close( isock );
                    if( -1 == f_error("Erreur accept") )
                        exit(EXIT_FAILURE);
                    exit( EXIT_FAILURE);
                }
                while( 0 < waitpid(-1, NULL, WNOHANG) ); //wait kill zombie
            }
     
            //code a revoir si possible "allégé"
            switch ((pid = fork()) ){
                case -1:
                    if( -1 == f_error("Erreur fork"))
                        exit( EXIT_FAILURE );
                    exit( EXIT_FAILURE );
                    break;
                case 0:
                    close( isock );
                    if( NULL == (ptime = f_get_time_msg()) ){
                        fprintf( stdout, "SERV_ERROR\t: SEND TIME CLIENT\n" ); //teste
                        write(isock_client, "ERROR SEND TIME/ NO TIME",
                              strlen("ERROR SEND TIME/ NO TIME") );
                        shutdown(isock_client, 2 );   //disconnect clients
                        close( isock_client ); //close socket
                        exit( EXIT_SUCCESS ); // exit proccess 
                    }
                    fprintf( stdout, "SERV_SEND\t:%s\n", ptime );
                    write(isock_client, ptime, strlen(ptime) );
                    shutdown(isock_client, 2 );
                    close( isock_client );
                    exit( EXIT_SUCCESS );
                default:
                    close( isock_client );  // close socket
                    break;
            }
        }
        return EXIT_SUCCESS;
    }

    Le client
    Code C : 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
     
     
     
    int f_error( char *p_msg ){
     
        extern int errno;
        extern const int sys_nerr;
        extern const char *const sys_errlist[];
     
        fprintf( stderr, "(%d)\t:%s\n", errno,
                (!p_msg) ? "inconnue" : p_msg );
        if( 0 < errno && errno < sys_nerr )
            fprintf( stderr, "info\t:%s\n",
                    sys_errlist[errno] );
        return -1;
    }
     
    void f_fatal_error( char *p_msg ){
        if( -1 == f_error(p_msg) )
            exit( EXIT_FAILURE );
        exit( EXIT_FAILURE );
    }
     
    int f_new_sock_client( char *pAddr, int iPort ){
     
        int isock = -1;
        const int iopt_sock = 1;
        struct hostent *pHost_adr;
        struct sockaddr_in addr_sock;
     
        if( NULL ==( pHost_adr = gethostbyname(pAddr) ) )
            return f_error("host inconnue");
     
           //code a revoir 
        if( -1 == ( isock = socket(AF_INET, SOCK_STREAM, 0) ) ){
            free( pHost_adr );
            pHost_adr = NULL;
            return f_error("Erreur socket");
        }
     
        if( -1 == setsockopt(isock, SOL_SOCKET, SO_REUSEADDR,
                             &iopt_sock, sizeof(int) ) ){
            close( isock );
            free( pHost_adr );
            pHost_adr = NULL;
            return f_error("Erreur option socket");
        }
     
        iPort = ( 1024 > iPort ) ? DEF_PORT : iPort;
        addr_sock.sin_family = pHost_adr->h_addrtype;
        addr_sock.sin_port = htons(iPort);
        memcpy((char*)&addr_sock.sin_addr.s_addr,
               pHost_adr->h_addr, pHost_adr->h_length );
     
        if( -1 == connect(isock, (struct sockaddr*)&addr_sock,
                          sizeof(struct sockaddr_in))){
            close( isock );
            free( pHost_adr );
            pHost_adr = NULL;
            return f_error("Erreur connect" );
        }
        return isock;
    }
     
    int main( void ){
     
        int i = 0;
        int isock;
        char c_str = '\0';
        char buff[BUFSIZ];
     
        if( -1 == ( isock = f_new_sock_client("localhost", DEF_PORT) ))
            exit( EXIT_FAILURE );
     
        //code a revoire
        while( 1 == read( isock, &c_str, sizeof(char) ) )
            *(buff+(i++) ) = c_str;
        fprintf( stdout, "SERVEUR_SEND\t:%s\n", buff );
        shutdown(isock, 2);
        close(isock);
        return EXIT_SUCCESS;
    }

    Code OUT SERVEUR : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    SERV_SEND	:Mon Jun 27 15:26:59 2016
    Code OUT CLIENTS : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    SERVEUR_SEND	:Mon Jun 27 15:26:59 2016

    à bientôt

Discussions similaires

  1. Réponses: 3
    Dernier message: 11/04/2014, 00h42
  2. Socket + Thread + Fork.
    Par gheaeckkseqrz dans le forum Linux
    Réponses: 0
    Dernier message: 30/06/2012, 01h50
  3. Un client irc avec socket et fork
    Par cybersplash dans le forum POSIX
    Réponses: 6
    Dernier message: 12/04/2007, 20h22
  4. problème chat avec socket/fork/pipe
    Par cedricdd dans le forum Réseau
    Réponses: 10
    Dernier message: 08/03/2007, 14h56
  5. socket et fork() sous Windows avec Cygwin
    Par Djakisback dans le forum Autres Logiciels
    Réponses: 1
    Dernier message: 20/12/2005, 00h33

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo