Discussion :

[bit_o]

Bonjour,

je réalise un programme qui permet d'envoyer un fichier depuis un serveur (machine qui émet) vers un client (machine qui reçoit).
Pour l'instant, ce que j'essaye d'envoyer c'est un fichier texte. Le serveur et le client sont bien connectés, mon problème réside dans le premier send() que je vais faire.
Ce send() doit envoyer la longueur de la chaine qui va etre transmise par la suite. Ce que je n'arrive pas à faire, c'est envoyer un long et le récupérer du coté client ..

Voici le bout de code qui me permet de (ne pas) faire ce que je veux

Code :

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

1
2
3
4
5
6
 
//Les tests sur les valeurs de retour sont faits mais ceci n'est qu'un code allégé
 
/// Coté serveur : envoi de la taille de la chaine
long taille = 0;
send(_fd, (long *) &taille, 1, 0);

Code :

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

1
2
3
4
 
/// Coté client : réception de la taille de la chaine
long *taille  = NULL;
recv(sockfd, (long *) taille, sizeof(long), 0);

merci de vos réponses

[Gruik]

Salux,

Il faut que tu geres le changement d'endianess. (l'ordre des 4 octets de l'entier sont inversés en passant sur le reseau).
Une solution : envoyer une chaine de taille fixe representant le nombre

Code :

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

1
2
3
4
5
6
7
8
 
#define COM_NB_LG  10
/* ... */
char nb_buff[COM_NB_LG + 1];
const long ton_long = 42L;
sprintf (nb_buff, "%010ld", ton_long);
 
send(_fd, nb_buff, COM_NB_LG, 0);

[crocodilex]

Code :

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

1
2
3
long taille = 0;
send(_fd, (long *) &taille, 1, 0);

A mon avis c'est plutôt :

Code :

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

send(_fd, (long *) &taille, sizeof(long), 0);

[crocodilex]

Code :

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

1
2
3
4
 
/// Coté client : réception de la taille de la chaine
long *taille  = NULL;
recv(sockfd, (long *) taille, sizeof(long), 0);

Le pointeur taille n'est pas initialisé !!!

[hedi07]

salut

pour envoyer des fichier, je crois qu'il existe une fonction trasmit_file().

après pour envoyer tu fait send(socket_qui_reçoit, (char)message, sizeof(message),0);

la tu envoie un char (ou une chaine), mais rien ne t'empêche de le caster ensuite.

en esperant t'avoir aidé
hedi07

[Skyounet]

salut
pour envoyer des fichier, je crois qu'il existe une fonction trasmit_file().

Gné ?

Non y'a pas de fonction de ce nom qui existe.

Pour répondre au P.O, pas besoin d'envoyer la taille du fichier au serveur.
Tu envois 4096 octets par 4096 et le serveur lire ce dont il a besoin, tu reperes la fin de l'envoi lorsqu'il reçoit moins de 4096 octets.

[granquet]

salut

pour envoyer des fichier, je crois qu'il existe une fonction trasmit_file().

y'as bien un appel systéme qui s'appelle sendfile() sous linux 2.2+
ça permet de se passer d'un echange userspace//kernelspace.

pour en revenir au sujet, j'aurais tendance a transmettre la taille du fichier sous forme ascii (voir faire du benconded pour transmettre taille + nom + path + sha1 + ... )

recevoir par paquet de 4k jusqu'a ce qu'on en reçoive moins. ça me parait risqué ... surtout si on veux profiter d'un debit correct en utilisant UDP

[hedi07]

ah bon, il me semblait l'avoir vu. tant pis...
a+
hedi07

[Emmanuel Delahaye]

je réalise un programme qui permet d'envoyer un fichier depuis un serveur (machine qui émet) vers un client (machine qui reçoit).
Pour l'instant, ce que j'essaye d'envoyer c'est un fichier texte. Le serveur et le client sont bien connectés, mon problème réside dans le premier send() que je vais faire.
Ce send() doit envoyer la longueur de la chaine qui va etre transmise par la suite. Ce que je n'arrive pas à faire, c'est envoyer un long et le récupérer du coté client ..

Le principe est d'envoyer des séquences d'octets définies par une adresse et une longueur :

Code :

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

   send (sock, data, length, 0);

On construit donc un tableau de unsigned char contenant les données à émettre. Si on souhaite transmettre une valeur binaire qui occupe plus que 8-bit, on utilise le format 'réseau' (MSB en tête) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
   unsigned long val = 0xDEADBEEF;
   unsigned char data[4];
 
   printf ("%08X\n", val);
 
   data[0] = (val >> (8 * 3)) & 0xFF; /* MSB */
   data[1] = (val >> (8 * 2)) & 0xFF;
   data[2] = (val >> (8 * 1)) & 0xFF;
   data[3] = (val >> (8 * 0)) & 0xFF; /* LSB */
 
   send (sock, data, sizeof data, 0);

en réception, on fait l'opération inverse :

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
 
   unsigned char data[4];
   int n = recv (sock, data, sizeof data, 0);
 
   if (n > 0)
   {
      unsigned long val = 0;
 
      val |= (data[0] << (8 * 3)); /* MSB */
      val |= (data[1] << (8 * 2));     
      val |= (data[2] << (8 * 1));     
      val |= (data[3] << (8 * 0)); /* LSB */
 
      printf ("%08X\n", val);
 
   }

Nota : ces opération sont portables (indépendantes de l'endianness, de la taille des types etc.) et inter-opérables entre machines différentes.

[Gruik]

Tu viens de reecrire htonl et ntohl
http://man.developpez.com/man3/htonl.3.php
(mais bon c'est pas standard)

[Emmanuel Delahaye]

Tu viens de reecrire htonl et ntohl

C'est ce que je croyais, mais les fonctions hton*() font des hypothèses sur la taille des types (short = 16-bit, long = 32-bit), ce que je ne fais pas.

Code :

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

1
2
3
4
5
 
   long val = 0xDEADBEEF;
   long val_net = htonl(val);
 
   send (sock, val_net, sizeof val_net, 0);

ne fonctionne pas si un long fait 64 bit, ce qui ne manquera pas d'arriver sur les architectures 64-bit...

Les types des données réseaux ont des tailles fixes, chose qui n'existe pas de manière portable en C. (même en C99, ou les types de taille fixes sont des options, donc non portables, par définition).