Débutant en socket

Version imprimable

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:

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>

28/04/2008, 01h25
Emmanuel Delahaye

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>

Je crois que tu prends le problème à l'envers...

http://emmanuel-delahaye.developpez.com/reseaux.htm
28/04/2008, 08h18
Melem

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>

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

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:

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);
	}
}

Citation:

Envoyé par dot-_-net

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:

printf("serveur en attente \n);

manque un ". Merci de poster du code compilable...
Code:

1 2 3 int *t; recv(sockfd_client,&t,1, 0);
Ceci, equivallent portable de ton code d'origine

Code:

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:

1 2 3 4 /* int = 4 bytes MSB first <nb_int:int><ints:int> */
le tableau d'int

Code:

int tab[] = {123, 456, 789};

Serait codé comme ceci :

Code:

00 00 00 03 00 00 00 7B 00 00 01 C8 00 00 03 15 '.......{........'

C'est à dire :
Code:

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:

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:

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:

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

08/05/2008, 12h33
dot-_-net

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:

read(sockfd_client,&t,sizeof(int)*nombre_de_case);
08/05/2008, 13h07
Emmanuel Delahaye

Citation:

Envoyé par dot-_-net

maintenant je suppose que je connais la taille de mon tableau qui est dynamique
Est ce que ça est juste ?

Code:

read(sockfd_client,&t,sizeof(int)*nombre_de_case);

Pourquoi &t ? Tu penses que de passer l'adresse d'un pointeur est d'une utilité quelconque.

Code:

read (sockfd_client, t, sizeof (int) * nombre_de_case);

Ceci fonctionne mais n'est pas portable. De plus, l'information 'taille' n'a pas été transmise, donc en réception, on ne saura pas quoi faire des données reçues... J'ai passé beaucoup de temps à expliquer comment faire une transmission correcte... Je perds mon temps ?