Socket Linux

Marsh Posté le 11-10-2009 à 02:56:13

Bonjour à tous,
Je suis nouveau sur ce forum et j'ai fini mes études info il y a trois ans. Mais je continu en cours du soir au CNAM.
J'ai fait des études info en réseau et pour mes cours j'ai un projet que je doit faire sous Linux en C, et la programmation, c'est pas mon fort !!!
Je vous soumets donc mon sujet :

« Écrire un programme permettant la mise en place de services bancaires. Les services sont les suivants :
- affichage du solde de compte (valeur et débit/crédit)
- affichage de l'intitulé du compte (nom, prénom, adresse, numéro de compte)
Le fonctionnement de ces services est un mode client/serveur qui permet un fonctionnement en réseau de l'application. Le port d'écoute du serveur est 1444.
Le serveur permet de traiter plusieurs opérations en parallèle. Lors d'une même transaction le client peut demander la réalisation des 2 services ou d'un seul. La communication entre le serveur et le client doit donc prendre en compte une demande identifiée de service.
Sur le serveur, un processus de gestion des appels doit être actif, il permet de tracer l'ensemble des appels et les demandes de service réalisé. Ce processus doit pouvoir afficher, le contenu de son journal sur demande.
Pour simplifier, le travail de programmation les structures correspondant aux informations des comtes bancaires sont stockées en mémoire centrale. Les demandes de services sont réalisés à partir du numéro de compte bancaire.
1) Décrivez le mode de fonctionnement de cette application en précisant le outils de communication utilisés. Précisez, pour chaque outil les raisons de votre choix.
2) Écrivez l'ensemble des programmes permettant de réaliser l'ensemble de ces services. Les programmes doivent être commentés afin d'en faciliter la lecture. »

Si quelqu'un se sent peut m'aider...je n'ai pas besoin d'un programme super compliqué, mais au contraire plus il sera simple, mieux j'aurai des chance de le comprendre...et comme demandé dans le sujet, les commentaires sont indispensable pour moi...

Un dernier petit détail, j'habite en Nouvelle Calédonie, donc si je ne répond pas rapidement àvos questions éventuelles, c'est sûrement du au décalage horaire...quand vous vous couchez, je part au boulot...

Merci d'avance à tous ceux qui pourront m'aider...

Marsh Posté le 11-10-2009 à 02:56:13

Marsh Posté le 12-10-2009 à 10:53:20

J'ai un ami qui peut vous aider. Il s'appelle Google.

(Désolé, mais ne peut pas écrire de très longs messages sur un forum comme celui-ci, et donc on ne peut pas expliquer toute la théorie de TCP/IP ou d'UDP/IP. Voyer plutôt les tutoriaux, sur TCP/IP ou UDP/IP (en premier lieu, il faut choisir l'un de ces deux modes) et voir aussi les exemples de codes source qui existent aussi certainement sur internet.)

Marsh Posté le 12-10-2009 à 21:53:38

Ici tu trouveras le cours que je donnais en 2000 sur les socket Unix: http://fr.lang.free.fr/cours/SocketCsyst_v1.0.pdf

Et voici plusieurs exemples simplistes de communications via socket. Tous ces programmes font la même chose: le client fait saisir une chaine et l'envoie au serveur qui l'affiche.
Ils sont un peu vieux (2000) mais devraient quand-même se compiler sans problème. Ptet qq warnings mais rien de plus.

Exemple1: communication à travers un fichier socket - Ca ne fonctionne que si le client et le serveur sont sur la même machine
Le serveur

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/un.h>                            // Spécifications socket unix     
#include <stdio.h>                            // I/O fichiers classiques        
#include <signal.h>                            // Signaux de communication       
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define NAME_SOCKET            ("socket_file" )    // Nom fichier socket             
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    int sk_creat;                            // Socket de création             
    int sk_dialog;                            // Socket de dialogue             
    int pid;                                // Process créé                   
    int sz_read;                            // Nombre octets lus              
 
    char buf[SZ_BUF];                        // Buffer texte                   
 
    struct sockaddr_un adr_serveur;            // Adresse socket serveur         
 
    // Détournement du signal émis à la mort du fils (il ne reste pas zombie) 
    signal(SIGCHLD, SIG_IGN);
 
    // Effacement fichier socket résiduel 
    unlink(NAME_SOCKET);
 
    // Création socket 
    if ((sk_creat=socket(AF_UNIX, SOCK_STREAM, 0)) == (-1))
    {
        fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_un));
    adr_serveur.sun_len=strlen(NAME_SOCKET) + 1;
    adr_serveur.sun_family=AF_UNIX;
    memcpy(&(adr_serveur.sun_path), NAME_SOCKET, strlen(NAME_SOCKET));
 
    // Identification socket/réseau 
    if (bind(sk_creat, &adr_serveur, sizeof(struct sockaddr_un)) == (-1))
    {
        fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
 
    // Prise de la ligne 
    listen(sk_creat, 1);
 
    // Ecoute permanente 
    fputc('\n', stdout);
    while (1)
    {
        printf("ppid=%u, pid=%u\tAttente entrée...", getppid(), getpid());
        fflush(stdout);
 
        // Attente connexion client 
        if ((sk_dialog=accept(sk_creat, NULL, NULL)) == (-1))
        {
            fprintf(stderr, "ligne %u - accept() - %s\n", __LINE__, sys_errlist[errno]);
            exit(errno);
        }
        fputs("Entrée émise\n", stdout);
        
        // Duplication du process 
        switch (pid=fork())
        {
            case (-1): // Erreur de fork 
                close(sk_creat);
                close(sk_dialog);
                fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, sys_errlist[errno]);
                exit(errno);
 
            case 0: // Fils 
                // Fermeture socket inutilisée 
                close(sk_creat);
 
                // Lecture en boucle sur la socket 
                while ((sz_read=read(sk_dialog, buf, SZ_BUF)) > 0)
                {
                    printf("\n\tppid=%u, pid=%u\tLe serveur a lu '%s'%s\n", getppid(), getpid(), buf, strcmp(buf, "EOT" ) != 0 ?"" :"=> Fin de communication" );
 
                    // Si la chaine contient "EOT" 
                    if (strcmp(buf, "EOT" ) == 0)
                        break;
                }
 
                // Si l'arrêt de la lecture est dû à ne erreur 
                if (sz_read == (-1))
                {
                    close(sk_dialog);
                    fprintf(stderr, "ligne %u - read() - %s\n", __LINE__, sys_errlist[errno]);
                    exit(errno);
                }
 
                // Fin du fils 
                close(sk_dialog);
                exit(0);
 
            default: // Père 
                close(sk_dialog);
        }
    }
    // Pas de sortie du programme - Boucle infinie 
 
    // Fermeture socket et fin théorique du programme (pour être propre) 
    close(sk_creat);
}

Le client

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/un.h>                            // Spécifications socket unix     
#include <stdio.h>                            // I/O fichiers classiques        
#include <string.h>                            // Gestion chaines de caractères  
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define NAME_SOCKET            ("socket_file" )    // Nom fichier socket             
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    int sk_connect;                            // Socket de connection           
    int sk_dialog;                            // Socket de dialogue             
 
    char buf[SZ_BUF];                        // Buffer texte                   
    char *pt;                                // Ptr vers un caractère qcq.     
 
    struct sockaddr_un adr_serveur;            // Adresse socket serveur         
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_un));
    adr_serveur.sun_len=strlen(NAME_SOCKET) + 1;
    adr_serveur.sun_family=AF_UNIX;
    memcpy(&adr_serveur.sun_path, NAME_SOCKET, strlen(NAME_SOCKET));
 
    // Tentative de connection en boucle permanente 
    fputc('\n', stdout);
    do
    {
        // Création socket 
        if ((sk_dialog=socket(AF_UNIX, SOCK_STREAM, 0)) == (-1))
        {
            fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
            exit(errno);
        }
 
        // Connection au serveur 
        if ((sk_connect=connect(sk_dialog, &adr_serveur, sizeof(struct sockaddr_un))) == (-1))
        {
            fprintf(stderr, "ligne %u - connect() - %s\n", __LINE__, sys_errlist[errno]);
            sleep(5);
        }
    }
    while (sk_connect == (-1));
    printf("Connection réussie\n" );
 
    // Saisie et envoi de la chaîne en boucle 
    do
    {
        // Saisie de la chaîne 
        fputs("Entrer chaine (EOT pour finir) :", stdout); fflush(stdout);
        fflush(stdin); fgets(buf, SZ_BUF, stdin);
 
        // Suppression de la chaîne saisie le caractère '\n' s'il y est 
        if ((pt=strchr(buf, '\n')) != NULL)
            *pt='\0';
 
        // Envoi de la chaîne modifiée sur la socket 
        if (write(sk_dialog, buf, strlen(buf) + 1) == (-1))
            fprintf(stderr, "ligne %u - write(%s) - %s\n", __LINE__, buf, sys_errlist[errno]);
    }
    while (strcmp(buf, "EOT" ) != 0);
 
    // Fermeture socket et fin du programme 
    close(sk_dialog);
}

Exemple2: communication en tcp.
Le serveur

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/param.h>                        // Paramètres et limites système  
#include <netinet/in.h>                        // Spécifications socket internet 
#include <arpa/inet.h>                        // Adresses format "arpanet"      
#include <signal.h>                            // Signaux de communication       
#include <stdio.h>                            // I/O fichiers classiques        
#include <netdb.h>                            // Gestion network database       
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define SERVICE_LABEL        ("toto" )        // Nom service requis             
#define SERVICE_PROTOCOL    ("tcp" )            // Protocole service requis       
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    ushort i;                                // Indice de boucle               
    ushort j;                                // Indice de boucle               
 
    int sk_creat;                            // Socket de création             
    int sk_dialog;                            // Socket de dialogue             
    int pid;                                // Process créé                   
    int len_adr;                            // Taille adresse                 
    int sz_read;                            // Nbre octets lus                
 
    char buf[SZ_BUF];                        // Buffer texte                   
    char hostname[MAXHOSTNAMELEN + 1];        // Nom machine locale             
 
    struct sockaddr_in adr_serveur;            // Adresse socket serveur         
    struct sockaddr_in adr_client;            // Adresse socket client          
    struct hostent *host_info;                // Info. host client connecté     
    struct servent *service_info;            // Info. service demandé          
 
    char *adr_ascii;                        // Adresse client mode ascii      
 
    // Détournement du signal émis à la mort du fils (il ne reste pas zombie) 
    signal(SIGCHLD, SIG_IGN);
 
    // Récuperation nom machine locale (juste pour l'exemple) 
    if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    {
        fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, sys_errlist[errno]);
        exit(errno);
    }
    printf("gethostname='%s'\n", hostname);
 
    // Récuperation port dans "/etc/services" 
    if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) == NULL)
    {
        fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("service_name='%s'\n", service_info->s_name);
    for (i=0; service_info->s_aliases[i] != NULL; i++)
        printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
    printf("service_port=%u\n", ntohs(service_info->s_port));
    printf("service_protocole='%s'\n", service_info->s_proto);
 
    // Création socket 
    if ((sk_creat=socket(AF_INET, SOCK_STREAM, 0)) == (-1))
    {
        fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
    printf("Socket créée\n" );
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    adr_serveur.sin_family=AF_INET;
    adr_serveur.sin_port=service_info->s_port;
    adr_serveur.sin_addr.s_addr=INADDR_ANY;
 
    // Identification socket/réseau 
    if (bind(sk_creat, &adr_serveur, sizeof(struct sockaddr_in)) == (-1))
    {
        fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
    printf("Socket connectée au réseau\n" );
 
    // Ecoute de la ligne 
    listen(sk_creat, 1);
 
    // Attente permanente 
    fputc('\n', stdout);
    while (1)
    {
        printf("ppid=%u, pid=%u\tAttente entrée...", getppid(), getpid());
        fflush(stdout);
 
        // Attente connexion client 
        len_adr=sizeof(struct sockaddr_in);
        if ((sk_dialog=accept(sk_creat, &adr_client, &len_adr)) == (-1))
        {
            fprintf(stderr, "ligne %u - accept() - %s\n", __LINE__, sys_errlist[errno]);
            exit(errno);
        }
 
        // Client connecté 
        fputs("Entrée émise ", stdout);
 
        // Transformation adresse net en ascii 
        if ((adr_ascii=inet_ntoa(adr_client.sin_addr)) > (char*)0)
        {
            printf("(adr=%s", adr_ascii);
 
            // Récupération informations sur client par son adresse 
            if ((host_info=gethostbyaddr((char*)&adr_client.sin_addr.s_addr, sizeof(struct in_addr), AF_INET)) != NULL)
                printf(" - %s)\n", host_info->h_name);
            else
            {
                fputs("- ???)\n", stdout);
                fprintf(stderr, "ligne %u - gethostbyaddr() - %s\n", __LINE__, sys_errlist[errno]);
            }
        }
        else
        {
            fputs("(adr=???)\n", stdout);
            fprintf(stderr, "ligne %u - inet_ntoa() - %s\n", __LINE__, sys_errlist[errno]);
        }
        
        // Duplication du process 
        switch (pid=fork())
        {
            case (-1): // Erreur de fork 
                close(sk_creat);
                close(sk_dialog);
                fprintf(stderr, "ligne %u - fork() - %s\n", __LINE__, sys_errlist[errno]); 
                exit(errno);
 
            case 0: // Fils 
                // Fermeture socket inutilisée 
                close(sk_creat);
 
                // Lecture en boucle sur la socket 
                while ((sz_read=read(sk_dialog, buf, SZ_BUF)) > 0)
                {
                    printf("\n\tppid=%u, pid=%u\tLe serveur a lu '%s'%s\n", getppid(), getpid(), buf, strcmp(buf, "EOT" ) != 0 ?"" :"=> Fin de communication" );
 
                    // Si la chaine contient "EOT" 
                    if (strcmp(buf, "EOT" ) == 0)
                        break;
                }
 
                // Si l'arrêt de la lecture est dû à une erreur 
                if (sz_read == (-1))
                {
                    close(sk_dialog);
                    fprintf(stderr, "ligne %u - read() - %s\n", __LINE__, sys_errlist[errno]);
                    exit(errno);
                }
 
                // Fin du fils 
                close(sk_dialog);
                exit(0);
 
            default: // Père 
                close(sk_dialog);
        }
    }
    // Pas de sortie de programme - Boucle infinie 
 
    // Fermeture socket et fin théorique du programme (pour être propre) 
    close(sk_creat);
}

Le client

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/param.h>                        // Paramètres et limites système  
#include <netinet/in.h>                        // Spécifications socket internet 
#include <stdio.h>                            // I/O fichiers classiques        
#include <string.h>                            // Gestion chaines de caractères  
#include <netdb.h>                            // Gestion network database       
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define SERVEUR_DEFAULT        ("localhost" )    // Nom serveur utilisé par défaut 
#define SERVICE_LABEL        ("toto" )        // Nom service requis             
#define SERVICE_PROTOCOL    ("tcp" )            // Protocole service requis       
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    ushort i;                                // Indice de boucle               
    ushort j;                                // Indice de boucle               
 
    int sk_connect;                            // Socket de connection           
    int sk_dialog;                            // Socket de dialogue             
 
    char buf[SZ_BUF];                        // Buffer texte                   
    char hostname[MAXHOSTNAMELEN + 1];        // Nom machine locale             
    char *serveur;                            // Ptr vers le nom du serveur     
    char *pt;                                // Ptr vers un caractère qcq.     
 
    struct sockaddr_in adr_serveur;            // Adresse socket serveur         
    struct hostent *host_info;                // Info. host                     
    struct servent *service_info;            // Info. service demandé          
 
    // Remplissage du nom du serveur 
    if (argc > 1)
        // Le nom du serveur est l'argument n° 1 
        serveur=argv[1];
    else
    {
        // Le nom du serveur est pris par défaut 
        serveur=SERVEUR_DEFAULT;
        printf("Pas d'argument pour %s - Utilisation de %s\n", *argv, SERVEUR_DEFAULT);
    }
 
    // Récuperation nom machine locale (juste pour l'exemple) 
    if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    {
        fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, sys_errlist[errno]);
        exit(errno);
    }
    printf("gethostname='%s'\n", hostname);
 
    // Récuperation informations serveur 
    if ((host_info=gethostbyname(serveur)) == NULL)
    {
        fprintf(stderr, "ligne %u - gethostbyname(%s) - %s\n", __LINE__, serveur, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("host_info.h_name='%s'\n", host_info->h_name);
    for (i=0; host_info->h_aliases[i] != NULL; i++)
        printf("host_info.h_aliase[%hu]='%s'\n", i, host_info->h_aliases[i]);
    printf("host_info.h_addrtype=%u\n", host_info->h_addrtype);
    printf("host_info.h_length=%u\n", host_info->h_length);
    for (i=0; host_info->h_addr_list[i] != NULL; i++)
    {
        printf("host_info.h_addr_list[%hu]=", i);
        for (j=0; j < host_info->h_length; j++)
            printf("%hu ", (unsigned char)host_info->h_addr_list[i][j]);
        fputc('\n', stdout);
    }
 
    // Récuperation port dans "/etc/services" 
    if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) ==NULL)
    {
        fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("service_name='%s'\n", service_info->s_name);
    for (i=0; service_info->s_aliases[i] != NULL; i++)
        printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
    printf("service_port=%u\n", ntohs(service_info->s_port));
    printf("service_protocole='%s'\n", service_info->s_proto);
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    adr_serveur.sin_len=host_info->h_length;
    adr_serveur.sin_family=AF_INET;
    adr_serveur.sin_port=service_info->s_port;
    memcpy(&adr_serveur.sin_addr.s_addr, host_info->h_addr, host_info->h_length);
 
    // Tentative de connection en boucle permanente 
    fputc('\n', stdout);
    do {
        // Création socket 
        if ((sk_dialog=socket(AF_INET, SOCK_STREAM, 0)) == (-1))
        {
            fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
            exit(errno);
        }
 
        // Connection au serveur 
        if ((sk_connect=connect(sk_dialog, &adr_serveur, sizeof(struct sockaddr_in))) == (-1))
        {
            fprintf(stderr, "ligne %u - connect() - %s\n", __LINE__, sys_errlist[errno]);
            sleep(5);
        }
    } while (sk_connect == (-1));
    printf("Connection réussie\n" );
 
    // Saisie et envoi de la chaîne en boucle 
    do {
        // Saisie de la chaîne 
        fputs("Entrer chaine (EOT pour finir) :", stdout); fflush(stdout);
        fflush(stdin); fgets(buf, SZ_BUF, stdin);
 
        // Suppression de la chaîne saisie le caractère '\n' s'il y est 
        if ((pt=strchr(buf, '\n')) != NULL)
            *pt='\0';
 
        // Envoi de la chaîne modifiée sur la socket 
        if (write(sk_dialog, buf, strlen(buf) + 1) == (-1))
            fprintf(stderr, "ligne %u - write(%s) - %s\n", __LINE__, buf, sys_errlist[errno]);
    } while (strcmp(buf, "EOT" ) != 0);
 
    // Fermeture socket et fin du programme 
    close(sk_dialog);
    exit(0);
}

Il faudra créer une entrée "toto" en mode "tcp" dans "/etc/services" pour que le client et le serveur puissent récupérer un n° de port

Exemple3: communication en udp
Le serveur

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/param.h>                        // Paramètres et limites système  
#include <netinet/in.h>                        // Spécifications socket internet 
#include <arpa/inet.h>                        // Adresses format "arpanet"      
#include <stdio.h>                            // I/O fichiers classiques        
#include <netdb.h>                            // Gestion network database       
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define SERVICE_LABEL        ("toto" )        // Nom service requis             
#define SERVICE_PROTOCOL    ("udp" )            // Protocole service requis       
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    ushort i;                                // Indice de boucle               
    ushort j;                                // Indice de boucle               
 
    int sk_dialog;                            // Socket de dialogue             
    int len_adr;                            // Taille adresse                 
 
    char buf[SZ_BUF];                        // Buffer texte                   
    char hostname[MAXHOSTNAMELEN + 1];        // Nom machine locale             
 
    struct sockaddr_in adr_serveur;            // Adresse socket serveur         
    struct sockaddr_in adr_client;            // Adresse socket client          
    struct hostent *host_info;                // Info. host client connecté     
    struct servent *service_info;            // Info. service demandé          
 
    char *adr_ascii;                        // Adresse client mode ascii      
 
    // Récuperation nom machine locale (juste pour l'exemple) 
    if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    {
        fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, sys_errlist[errno]);
        exit(errno);
    }
    printf("gethostname='%s'\n", hostname);
 
    // Récuperation port dans "/etc/services" 
    if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) == NULL)
    {
        fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("service_name='%s'\n", service_info->s_name);
    for (i=0; service_info->s_aliases[i] != NULL; i++)
        printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
    printf("service_port=%u\n", ntohs(service_info->s_port));
    printf("service_protocole='%s'\n", service_info->s_proto);
 
    // Création socket 
    if ((sk_dialog=socket(AF_INET, SOCK_DGRAM, 0)) == (-1))
    {
        fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
    fputs("Socket créée\n", stdout);
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    adr_serveur.sin_family=AF_INET;
    adr_serveur.sin_port=service_info->s_port;
    adr_serveur.sin_addr.s_addr=INADDR_ANY;
 
    // Identification socket/réseau 
    if (bind(sk_dialog, &adr_serveur, sizeof(struct sockaddr_in)) == (-1))
    {
        fprintf(stderr, "ligne %u - bind() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
    fputs("Socket reliée au réseau\n", stdout);
 
    // Lecture en boucle sur la socket 
    len_adr=sizeof(struct sockaddr_in);
    while (1)
    {
        if (recvfrom(sk_dialog, buf, SZ_BUF, 0, &adr_client, &len_adr) == (-1))
            fprintf(stderr, "ligne %u - recvfrom() - %s\n", __LINE__, sys_errlist[errno]);
 
        // Transformation adresse client en ascii 
        if ((adr_ascii=inet_ntoa(adr_client.sin_addr)) > (char*)0)
        {
            printf("From client %s ", adr_ascii);
 
            // Récupération informations sur client par son adresse 
            if ((host_info=gethostbyaddr((char*)&adr_client.sin_addr.s_addr, sizeof(struct in_addr), AF_INET)) != NULL)
                printf("(%s)", host_info->h_name);
            else
            {
                fputs("(???)", stdout);
                fprintf(stderr, "ligne %u - gethostbyaddr() - %s\n", __LINE__, sys_errlist[errno]);
            }
        }
        else
        {
            fputs("From client ???", stdout);
            fprintf(stderr, "ligne %u - inet_ntoa() - %s\n", __LINE__, sys_errlist[errno]);
        }
        printf(" - Le serveur a lu '%s'%s\n", buf, strcmp(buf, "EOT" ) != 0 ?"" :"=> Fin de communication" );
    }
    // Pas de sortie de programme - Boucle infinie 
 
    // Fermeture socket et fin théorique du programme (pour être propre) 
    close(sk_dialog);
    exit(0);
}

Le client

Code :

#include <sys/types.h>                        // Types prédéfinis "c"           
#include <sys/socket.h>                        // Généralités sockets            
#include <sys/param.h>                        // Paramètres et limites système  
#include <netinet/in.h>                        // Spécifications socket internet 
#include <stdio.h>                            // I/O fichiers classiques        
#include <string.h>                            // Gestion chaines de caractères  
#include <netdb.h>                            // Gestion network database       
#include <errno.h>                            // Erreurs système                
 
extern const char* const sys_errlist[];        // Liste messages erreurs         
 
#define SERVEUR_DEFAULT        ("localhost" )    // Nom serveur utilisé par défaut 
#define SERVICE_LABEL        ("toto" )        // Nom service requis             
#define SERVICE_PROTOCOL    ("udp" )            // Protocole service requis       
#define SZ_BUF                (256)            // Taille buffer                  
 
main(
    int argc,                                 // Nbre arguments                 
    char *argv[])                            // Ptr arguments                  
{
    // Déclaration des variables 
    ushort i;                                // Indice de boucle               
    ushort j;                                // Indice de boucle               
 
    int sk_dialog;                            // Socket de dialogue             
 
    char buf[SZ_BUF];                        // Buffer texte                   
    char hostname[MAXHOSTNAMELEN + 1];        // Nom machine locale             
    char *pt;                                // Ptr vers un caractère qcq.     
    char *serveur;                            // Ptr vers le nom du serveur     
 
    struct sockaddr_in adr_serveur;            // Adresse socket serveur         
    struct hostent *host_info;                // Info. host                     
    struct servent *service_info;            // Info. service demandé          
 
    // Remplissage du nom du serveur 
    if (argc > 1)
        // Le nom du serveur est l'argument n° 1 
        serveur=argv[1];
    else
    {
        // Le nom du serveur est pris par défaut 
        serveur=SERVEUR_DEFAULT;
        printf("Pas d'argument pour %s - Utilisation de %s\n", *argv, serveur);
    }
 
    // Récuperation nom machine locale (juste pour l'exemple) 
    if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
    {
        fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, sys_errlist[errno]);
        exit(errno);
    }
    printf("gethostname='%s'\n", hostname);
 
    // Récuperation informations serveur 
    if ((host_info=gethostbyname(serveur)) == NULL)
    {
        fprintf(stderr, "ligne %u - gethostbyname(%s) - %s\n", __LINE__, serveur, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("host_info.h_name='%s'\n", host_info->h_name);
    for (i=0; host_info->h_aliases[i] != NULL; i++)
        printf("host_info.h_aliase[%hu]='%s'\n", i, host_info->h_aliases[i]);
    printf("host_info.h_addrtype=%u\n", host_info->h_addrtype);
    printf("host_info.h_length=%u\n", host_info->h_length);
    for (i=0; host_info->h_addr_list[i] != NULL; i++)
    {
        printf("host_info.h_addr_list[%hu]=", i);
        for (j=0; j < host_info->h_length; j++)
            printf("%hu ", (unsigned char)host_info->h_addr_list[i][j]);
        fputc('\n', stdout);
    }
 
    // Récuperation port dans "/etc/services" 
    if ((service_info=getservbyname(SERVICE_LABEL, SERVICE_PROTOCOL)) == NULL)
    {
        fprintf(stderr, "ligne %u - getservbyname(%s, %s) - %s\n", __LINE__, SERVICE_LABEL, SERVICE_PROTOCOL, sys_errlist[errno]);
        exit(errno);
    }
    fputc('\n', stdout);
    printf("service_name='%s'\n", service_info->s_name);
    for (i=0; service_info->s_aliases[i] != NULL; i++)
        printf("service_s_aliase[%hu]='%s'\n", i, service_info->s_aliases[i]);
    printf("service_port=%u\n", ntohs(service_info->s_port));
    printf("service_protocole='%s'\n", service_info->s_proto);
 
    // Création socket 
    if ((sk_dialog=socket(AF_INET, SOCK_DGRAM, 0)) == (-1))
    {
        fprintf(stderr, "ligne %u - socket() - %s\n", __LINE__, sys_errlist[errno]);
        exit(errno);
    }
    printf("Socket créée\n" );
 
    // Remplissage adresse socket 
    memset(&adr_serveur, 0, sizeof(struct sockaddr_in));
    adr_serveur.sin_len=host_info->h_length;
    adr_serveur.sin_family=AF_INET;
    adr_serveur.sin_port=service_info->s_port;
    memcpy(&adr_serveur.sin_addr.s_addr, host_info->h_addr, host_info->h_length);
 
    // Saisie et envoi de la chaîne en boucle 
    do
    {
        // Saisie de la chaîne 
        fputs("Entrer chaine (EOT pour finir) :", stdout); fflush(stdout);
        fflush(stdin); fgets(buf, SZ_BUF, stdin);
 
        // Suppression de la chaîne saisie le caractère '\n' s'il y est 
        if ((pt=strchr(buf, '\n')) != NULL)
            *pt='\0';
 
        // Envoi de la chaîne modifiée sur la socket 
        if (sendto(sk_dialog, buf, strlen(buf) + 1, 0, &adr_serveur, sizeof(struct sockaddr_in)) == (-1))
            fprintf(stderr, "ligne %u - sendto(%s) - %s\n", __LINE__, buf, sys_errlist[errno]);
    }
    while (strcmp(buf, "EOT" ) != 0);
 
    // Fermeture socket et fin du programme 
    close(sk_dialog);
    exit(0);
}

Ici il faudra créer une entrée "toto" en mode "udp" dans "/etc/services" pour que le client et le serveur puissent récupérer un n° de port

Message édité par Sve@r le 12-10-2009 à 21:57:08

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Marsh Posté le 17-10-2009 à 00:40:14

Super c'est exatement ces bouts de code que j'avais besoin pour commencer mon projet.
J'ai donc choisi les sockets serveur/client en TCP.
Par contre quand je compile j'ai des erreurs...j'en ai corrigé une en rajoutant en include stdlib.h mais les erreurs dans le main je n'arrive pas à les corriger.
Voilà les erreurs que j'ai :
"serveur.c: In function ‘main’:
serveur.c:82: attention : passing argument 2 of ‘bind’ from incompatible pointer type
serveur.c:101: attention : passing argument 2 of ‘accept’ from incompatible pointer type
serveur.c:120:34: attention : trigraphe ??) ignoré, utilisez -trigraphs pour le permettre
serveur.c:126:33: attention : trigraphe ??) ignoré, utilisez -trigraphs pour le permettre
/tmp/ccuGFSZS.o: In function `main':
serveur.c.text+0x5e): warning: `sys_errlist' is deprecated; use `strerror' or `strerror_r' instead"
Si quelqu'un peut m'aider !!!
merci à lui...

Marsh Posté le 17-10-2009 à 00:44:25

Et pour le client, j'ai le même type d'erreur :
"client.c: In function ‘main’:
client.c:52: attention : incompatible implicit declaration of built-in function ‘exit’
client.c:60: attention : incompatible implicit declaration of built-in function ‘exit’
client.c:80: attention : incompatible implicit declaration of built-in function ‘exit’
client.c:91: erreur: ‘struct sockaddr_in’ has no member named ‘sin_len’
client.c:103: attention : incompatible implicit declaration of built-in function ‘exit’
client.c:107: attention : passing argument 2 of ‘connect’ from incompatible pointer type
client.c:132: attention : incompatible implicit declaration of built-in function ‘exit’"
???

Marsh Posté le 17-10-2009 à 02:48:42

J'ai oublié de préciser, je suis sous Ubuntu...

Message cité 1 fois

Marsh Posté le 19-10-2009 à 23:11:03

Ccabrel a écrit :

J'ai oublié de préciser, je suis sous Ubuntu...

Oui, il y a des trucs qui ont changé depuis que j'ai développé ces exemples
1) pour la fonction exit, faut inclure stdlib.h
2) sys_errlist est devenu déprécié. Faut remplacer sys_errlist[errno] par strerror(errno)
3) sin_len a disparu de la structure sockaddr_in => pas de souci, partout où j'y fais référence tu le supprimes (surtout que je ne m'en sers jamais sauf dans un printf)

Quand aux erreurs concernant accept et bind, c'est parce que ces fonctions sont des fonctions générales qui acceptent en entrée des pointeurs vers de simples "struct sockaddr"
Cette attitude permet d'utiliser bind et accept avec des socket unix (utilisant une struct sockaddr_un) ou des socket inet (utilisant une struct sockaddr_in)
Et donc à l'époque, le compilo ne disait rien. Aujourd'hui, il est plus chiant donc faut lui expliquer que tu sais ce que tu fais et quand t'appelles bind() et accept(), tu castes le pointeur passé en "struct sockaddr *"
Tout ça est expliqué dans mon cours sur les socket

L'erreur des trigraphs, je vois pas de quoi il s'agit.

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Marsh Posté le 20-10-2009 à 00:08:33

merci pour ces 2000 lignes de code, l'erreur est à la ligne 42, colonne 69

Message cité 1 fois

Marsh Posté le 20-10-2009 à 23:31:54

Taz a écrit :

merci pour ces 2000 lignes de code

Elles ne te sont pas destinées donc je vois pas ce que tu ramènes ton grain de sel

Taz a écrit :

l'erreur est à la ligne 42, colonne 69

Povtyp. T'as même pas vu qu'on ne te demande pas d'y trouver quoi que ce soit car les quelques erreurs dues à l'ancienneté du code ont été expliquées et sont facilement rectifiables !!!

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Marsh Posté le 08-03-2010 à 01:54:00

merci beaucoup cher Sve@r!!

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed

Name *

Email *

URL

Message *