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

Réseau C Discussion :

Débutant en socket


Sujet :

Réseau C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé
    Homme Profil pro
    Inscrit en
    Octobre 2007
    Messages
    487
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Octobre 2007
    Messages : 487
    Par défaut Débutant en socket
    Je suis entrain d’apprendre la programmation réseau sous Linux et j’ai commencé par les sockets.
    Voici un code que j’ai trouvé dans le net et j’ai quelque question à poser.
    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
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<stdio.h>
    #include<sys/un.h>
    #include<unistd.h>
     
     
    int main(){
     
    		int sockfd_serveur , sockfd_client;
    		int long_serveur,long_client;
    		struct sockaddr_un adress_serveur;
    		struct sockaddr_un adresse_client;
     
     
    		//suppresion tout ancien socket
     
    		unlink("socket_serveur");
     
    		sockfd_serveur = socket(AF_UNIX , SOCK_STREAM,0);//af , type, protocol
    		adress_serveur.sun.family=AF_UNIX;
    		strcpy(adresse_serveur.sun_path,"socket_serveur");
    		long_serveur=sizeof(adresse_serveur);
    		bind(sockfd_serveur,(struct sockaddr *) & adresse_serveur,long_serveur);
    		listen(sockfd_serveur,5);
    		while(1){
    			int l;
    			printf("serveur att le client \a\n");
    			long_client =sizeof(adress_client);
    			sockfd_client=accept(sockfd_serveur,(struct sockaddr*)&adresse_client,&long_client);
     
    		read(sockfd_client,& l,1);
    		l--;
    		write(sockfd_client,& l , 1),
    			close(sockfd_client);
    		}
    }
    1 -Ca sert a quoi AF_UNIX
    2 – ca sert a quoi de savoir la tailles de l’adresse serveur
    3 – a quoi sert la fonction bind et qu’elles sont ses champs
    4 – a quoi sert la fonction listen ?
    5 -Elle contient quoi la biblio <sys/un.h>

  2. #2
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par dot-_-net Voir le message
    1 -Ca sert a quoi AF_UNIX
    2 – ca sert a quoi de savoir la tailles de l’adresse serveur
    3 – a quoi sert la fonction bind et qu’elles sont ses champs
    4 – a quoi sert la fonction listen ?
    5 -Elle contient quoi la biblio <sys/un.h>
    Je crois que tu prends le problème à l'envers...

    http://emmanuel-delahaye.developpez.com/reseaux.htm

  3. #3
    Expert confirmé
    Avatar de Melem
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Janvier 2006
    Messages
    3 656
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Janvier 2006
    Messages : 3 656
    Par défaut
    Citation Envoyé par dot-_-net
    Je suis entrain d’apprendre la programmation réseau sous Linux
    Alors il faut commencer par lire ton cours avant de poser des questions ...
    Citation Envoyé par dot-_-net
    1 - Ca sert a quoi AF_UNIX
    2 – ca sert a quoi de savoir la tailles de l’adresse serveur
    3 – a quoi sert la fonction bind et qu’elles sont ses champs
    4 – a quoi sert la fonction listen ?
    5 - Elle contient quoi la biblio <sys/un.h>

    http://broux.developpez.com/articles/c/sockets/

  4. #4
    Membre éclairé
    Homme Profil pro
    Inscrit en
    Octobre 2007
    Messages
    487
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Octobre 2007
    Messages : 487
    Par défaut
    Dans mon programme le serveur lit un tableau de type int *t;
    read(sockfd_client,&t,1); mon problème c’est que je sais pas combien d’élément se trouve dans se tableau

    y a-t-il une solution de savoir la longueur de mon tableau sans le passée dans une structure ?

    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
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <stdio.h>
    #include <sys/un.h>
    #include <unistd.h>
     
     
    int main()
    {
    	int sockfd_serveur,sockfd_client;
    	int long_serveur,long_client;
    	struct sockaddr_un adresse_serveur;
    	struct sockaddr_un adresse_client;
    	unlink("socket_serveur");
    	sockfd_serveur=socket(AF_UNIX,SOCK_STREAM,0);
    	adresse_serveur.sun_family = AF_UNIX;
     
    	strcpy(adresse_serveur.sun_path,"socket_serveur");
     
    	long_serveur=sizeof(adresse_serveur);
    	bind(sockfd_serveur, (struct sockaddr *) &adresse_serveur , long_serveur);
    	listen(sockfd_serveur,5);
    	while(1){
    		int *t;
    		printf("serveur en attente \n);
    		long_client = sizeof(adresse_client);
    		sockfd_client = accept(sockfd_serveur,(struct sockaddr *) & adresse_client , &long_client);
    		read(sockfd_client,&t,1);
    		close(sockfd_client);
    	}
    }

  5. #5
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par dot-_-net Voir le message
    Dans mon programme le serveur lit un tableau de type int *t;
    read(sockfd_client,&t,1); mon problème c’est que je sais pas combien d’élément se trouve dans se tableau

    y a-t-il une solution de savoir la longueur de mon tableau sans le passée dans une structure ?
    Je convertis ton code (socket unix) en code portable (socket internet) pour pouvoir le tester sous Windows

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    		printf("serveur en attente \n);
    manque un ". Merci de poster du code compilable...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    		int *t;
    		recv(sockfd_client,&t,1, 0);
    Ceci, equivallent portable de ton code d'origine
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    		read(sockfd_client,&t,1);
    n'a aucun sens.

    Le 2ème paramètre de read()/recv() attend l'adresse d'une zone mémoire, et le 3ème paramètre attend la taille de cette zone en bytes.

    Tel quel, la zone mémoire fournie est un malheureux pointeur sur int qui doit faire 2 ou 4 bytes environ selon les architectures. La taille fournie est 1 ce qui fait que la fonction va lire un byte et le placer dans ce pointeur. La valeur du pointeur sera donc indéfinie (pas une adresse valide) et donc inutilisable.

    Il faut savoir que les transferts de données par sockets se font exclusivement par blocs de bytes.

    Si tu cherches à récupérer un tableau d'int, il faut faire autrement.

    1 - Définir la manière dont le tableau d'int est codé (largeur d'un int, endianness etc.)
    2 - Définir un moyen de transmettre le nombre d'int transmis (taille + données, marque de fin...)
    3 - Implémenter ce protocole applicatif à l'émission.
    4 - Implémenter ce protocole applicatif à la reception

    Par exemple, avec ce protocole :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    /* int = 4 bytes MSB first
       <nb_int:int><ints:int>
    */
    le tableau d'int
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
       int tab[] = {123, 456, 789};
    Serait codé comme ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    00 00 00 03 00 00 00 7B 00 00 01 C8 00 00 03 15  '.......{........'
    C'est à dire :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    00000003 : nombre d'entiers
    0000007B : tab[0] = 123
    000001C8 : tab[1] = 456
    00000315 : tab[2] = 789
    Exemple d'implémentation :

    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
     
    /* int = 4 bytes MSB first
       <nb_int:int><ints:int>
    */
     
    unsigned char *uint32_write(unsigned char *p_data, int integer)
    {
       unsigned long val = integer;
     
       p_data[0] = (val >> (3 * 8)) & 0xFF; /* MSB first */
       p_data[1] = (val >> (2 * 8)) & 0xFF;
       p_data[2] = (val >> (1 * 8)) & 0xFF;
       p_data[3] = (val >> (0 * 8)) & 0xFF;
     
       return p_data + 4;
    }
     
    int encode (unsigned char *data, size_t data_size, int const *tab, size_t nb)
    {
       #define INT_WIDTH 4
       int data_len = -1;
     
       if ((1 + nb ) * INT_WIDTH <= data_size)
       {
          data_len = 0;
          size_t i;
          unsigned char *p_data = data;
     
          p_data = uint32_write(p_data, nb);
          data_len += INT_WIDTH;
     
          for (i = 0; i < nb; i++)
          {
             p_data = uint32_write(p_data, tab[i]);
             data_len += INT_WIDTH;
          }
       }
       return data_len;
    }
     
    unsigned char *uint32_read (unsigned long *p_integer,
                                unsigned char const *p_data)
    {
       unsigned long val = 0;
     
       val |= (p_data[0] & 0xFF) << (3 * 8); /* MSB first */
       val |= (p_data[1] & 0xFF) << (2 * 8);
       val |= (p_data[2] & 0xFF) << (1 * 8);
       val |= (p_data[3] & 0xFF) << (0 * 8);
     
       if (p_integer != NULL)
       {
          *p_integer = val;
       }
     
       return p_data + 4;
    }
     
    int decode (int tab[], size_t tab_size, unsigned char const *data)
    {
       int nb = -1;
     
       unsigned long nb_int = 0;
       unsigned char *p_data = uint32_read (&nb_int, data);
     
       if (nb_int != 0 && nb_int < INT_MAX && nb_int <= tab_size)
       {
          nb = nb_int;
          {
             int i;
             for (i = 0; i < nb; i++)
             {
                unsigned long val = 0;
                p_data = uint32_read (&val, p_data);
                tab[i] = val;
             }
          }
       }
     
       return nb;
    }
    Avec le code approprié, on obtient :
    Client :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    Connection a 127.0.0.1 sur le port 23
    16 bytes sent
    Appuyez sur une touche pour continuer...
    Serveur :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    WIN: winsock2: OK
    socket 1960 is now opened in TCP/IP mode
    listening on port 23...
    serveur en attente
    0022FD00 00 00 00 03 00 00 00 7B 00 00 01 C8 00 00 03 15  '.......{........'
    tab[0] = 123
    tab[1] = 456
    tab[2] = 789
    serveur en attente

  6. #6
    Membre éclairé
    Homme Profil pro
    Inscrit en
    Octobre 2007
    Messages
    487
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Octobre 2007
    Messages : 487
    Par défaut
    Merci beaucoup Emmanuel Delahaye maintenant je suppose que je connais la taille de mon tableau qui est dynamique
    Est ce que ça est juste ?


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    read(sockfd_client,&t,sizeof(int)*nombre_de_case);

Discussions similaires

  1. [Débutant] Les Sockets, petite question
    Par fantomasmusic dans le forum Entrée/Sortie
    Réponses: 4
    Dernier message: 13/06/2007, 19h22
  2. Débutant Java, Sockets et observers
    Par nouknouk dans le forum Entrée/Sortie
    Réponses: 8
    Dernier message: 19/12/2006, 14h01
  3. Problème hyper débutant en socket
    Par Gwipi dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 4
    Dernier message: 06/05/2006, 14h36
  4. [Net][Débutant(e)] socket c <-> socket java
    Par JulienT dans le forum Entrée/Sortie
    Réponses: 4
    Dernier message: 25/11/2005, 16h46
  5. [Débutant] Envoi de fichier par socket
    Par zapho dans le forum Entrée/Sortie
    Réponses: 13
    Dernier message: 26/05/2004, 18h58

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