Pb Socket et fichier

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Pb Socket et fichier

xelad

Bonsoir,

J'ai un souci avec un probleme de socket pour envoyer un fichier binaire entre 1 serveur en C et un client Java.
Le but et d'envoyer un fichier JPG à la demande du client Java.

Voici le code permettant l'envoi du fichier capture.jpg :

Code :

int SIZE=1024;
int j;
size_t nb_lu;
FILE *fichier_a_envoyer;
FILE *fichier_socket=fdopen(msgsock,"w" );
char *chaine=(char *)malloc(sizeof(char)*SIZE);
fichier_a_envoyer=fopen("capture.jpg","r" );
if(fichier_a_envoyer){
while((nb_lu=fread(chaine,1,SIZE,fichier_a_envoyer))>0){
for(j=0;j<nb_lu;j++) printf("%o\n",chaine[j]);
fwrite(chaine, nb_lu, 1, fichier_socket);
}
send(msgsock,fichier_socket,sizeof(fichier_socket),0);
fclose(fichier_a_envoyer);
fclose(fichier_socket);
free(chaine);
}

Le problème (accrochez-vous...) c'est qu'il y a 4 octets qui sont ajoutés comme par magie au début du dernier bloc, c'est à dire qui si le fichier fait 1030o par ex, le client va recevoir 1034o avec les blocs suivant : [1024, 10] au lieu de [1024, 6]. Il faut préciser aussi que les 4 octets en question sont toujours identiques en valeur. Pour les tests, j'ai mis HELLO dans capture.jpg, la sortie du printf("%o\n",chaine[j]); correspond bien au code ASCII de HELLO donc le "fichier_a_envoyer" semble bon.

Si vous avez une idée de test pour isoler plus précisement le pb ou carrément la solution... merci pour vos réponses.

Message cité 1 fois
Message édité par xelad le 08-12-2005 à 00:49:34

Publicité

Sve@r

xelad a écrit :

Code :

int SIZE=1024;
int j;
size_t nb_lu;
FILE *fichier_a_envoyer;
FILE *fichier_socket=fdopen(msgsock,"w" );
char *chaine=(char *)malloc(sizeof(char)*SIZE);
fichier_a_envoyer=fopen("capture.jpg","r" );
if(fichier_a_envoyer){
while((nb_lu=fread(chaine,1,SIZE,fichier_a_envoyer))>0){
for(j=0;j<nb_lu;j++) printf("%o\n",chaine[j]);
fwrite(chaine, nb_lu, 1, fichier_socket);
}
send(msgsock,fichier_a_envoyer,sizeof(fichier_a_envoyer),0);
fclose(fichier_a_envoyer);
fclose(fichier_socket);
free(chaine);
}

Hum... quand tu fais "send(msgsock, fichier_a_envoyer, sizeof(fichier_a_envoyer), 0)"; tu envoies sur ta socket une variable de type "FILE *" et la fonction "send" (qui envoie le pointé de ce qu'on lui passe) va envoyer benoitement le contenu de la structure "FILE" (qui doit sûrement commencer par 4 octets bien particuliers...) :heink:
Bon, tu y envoies ce que tu veux sur ta socket... mais moi j'aurais plutôt fait "send(msgsock, chaine, nb_lu, 0)" :sol:

Idée de test ? T'as qu'à afficher la valeur hexa des 4 premiers octets de "*fichier_a_envoyer"

Message édité par Sve@r le 07-12-2005 à 22:10:54

xelad

merci sve@r,

Le probleme doit se situer dans les environs en effet. mais comme il s'agit de l'envoi d'un fichier binaire apprement on est obligé de passer par "FILE *fichier_socket=fdopen(msgsock,"w" );" sinon d'apres ce que j'ai cru comprendre dans d'autres topics y'a des problemes avec des \n attendus qu'il n'y a pas dans les fichiers binaires. Je vais essayer quand meme...

Message cité 1 fois

Sve@r

xelad a écrit :

Pas du tout !!!
Tu ouvres ton "capture.jpg" en mode "rb" et c'est tout. De plus je ne sais pas à quoi sert "fdopen()" mais je m'en suis jamais servi pour transférer des infos via socket...

T'as qq exemples simples sur ce document http://fr.lang.free.fr/cours/SocketCsyst_v1.0.pdf

Message édité par Sve@r le 07-12-2005 à 23:16:25

xelad

Merci je suis en train de lire le pdf....

xelad

Bon bah j'ai beau tout essayer j'ai toujours 4 octets de trop, et toujours les memes.

Message cité 1 fois
Message édité par xelad le 08-12-2005 à 00:48:42

Sve@r

xelad a écrit :

Bon bah j'ai beau tout essayer j'ai toujours 4 octets de trop, et toujours les memes.

Essaye ce 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 */

#define SERVEUR_DEFAULT ("localhost" ) /* Nom serveur utilisé par défaut */
#define SERVICE_LABEL ("essai" ) /* Nom service requis */
#define SERVICE_PROTOCOL ("tcp" ) /* Protocole service requis */
#define SZ_BUF (256) /* Taille buffer */

int main(
int argc, /* Nbre arg. */
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;

/* Récuperation nom machine locale (juste pour l'exemple) */
if (gethostname(hostname, MAXHOSTNAMELEN) != 0)
{
fprintf(stderr, "ligne %u - gethostname(%s) - %s\n", __LINE__, hostname, strerror(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, strerror(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, strerror(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=%hu\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__, strerror(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__, strerror(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);
fgets(buf, SZ_BUF, stdin);

/* Suppression de la chaîne saisie du caractère '\n' s'il y est */
if ((pt=strchr(buf, '\n')) != NULL)
*pt='\0';

/* Envoi de la chaîne sur la socket */
if (write(sk_dialog, buf, strlen(buf) + 1) == (-1))
fprintf(stderr, "ligne %u - write(%s) - %s\n", __LINE__, buf, strerror(errno));
} while (strcmp(buf, "EOT" ) != 0);

/* Fermeture socket et fin du programme */
close(sk_dialog);
return(0);
}

C'est un client destiné à communiquer avec un serveur via un n° de port défini dans le fichier "/etc/services" sous le label "essai/tcp"
Il attend un argument qui est le nom du serveur mais prend "localhost" par défaut
Une fois le client connecté sur le serveur, il attend une chaîne et l'envoie au serveur. Normallement, le serveur associé est censé attendre un client et afficher ensuite la chaîne reçue.
Le client s'arrête dès qu'on tape la chaine "EOT"

Ptet que tu devras l'adapter un peu (je suis pas certain que la structure "hostent" contienne un membre "h_length" sous Linux) mais il fonctionne.
Moi j'utilisais "write" pour envoyer mes infos au serveur mais tu peux utiliser "send" si t'en as envie...

Message édité par Sve@r le 08-12-2005 à 06:54:32

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

xelad

Merci pour toutes ces réponses Sve@r. Mon binome qui travaille sur le client Java à "contourné" le probleme en extrayant les 4 octets en question après la récéption du fichier. C'est pas terrible mais ça marche maintenant. Merci encore
A++++++++++

Message cité 1 fois

Sve@r

xelad a écrit :

Merci pour toutes ces réponses Sve@r. Mon binome qui travaille sur le client Java

Tu veux dire "serveur Java" !!!

xelad a écrit :

à "contourné" le probleme en extrayant les 4 octets en question après la récéption du fichier. C'est pas terrible mais ça marche maintenant. Merci encore
A++++++++++

Euh... très dangereux ce truc !!! Si l'erreur vient d'un bug de ton code, le bug est resté !!!
C'est comme si on soignait un bras cassé en donnant des anti-douleurs... la douleur disparait mais le bras reste cassé !!!

Passe-moi via msg privé le code complet de ton client. Je le compilerai et le mettrai en dialogue avec mon serveur voir ce qu'il reçoit...

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

xelad

En fait c'est le serveur qui est en C, je m'explique :
Le but du projet (scolaire) est de faire un serveur qui créé des screenshots à la demande du client. Le serveur reçoit une demande de screenshot, créé le screenshot et l'envoie au client java. C'est donc bien le serveur qui est en C puisqu'il reste tout le temps 'à l'écoute'.
Je te poste mon code ce soir (je l'ai pas sous la main), meme si le projet est terminé (en bricolant coté client, c'est vraiment pas terrible, tu as raison) j'aimerai bien savoir ce qui se passe...
Merci

Publicité

xelad

Le fichier main_server.c

Code :

#include "mod_datagram_srv.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
void bzero();
int read();
int write();
int main(){
int sock, msgsock;
size_t length;
socklen_t lemis;
struct sockaddr_in name;
struct sockaddr_in emis;
char buf[1024];
int rval,i;
/*creation de la socket AF_INET entre machine*/
sock=socket(AF_INET,SOCK_STREAM,0);
/*initialisation de la socket*/
bzero(&name,sizeof(name));
lemis=sizeof(emis);
bzero(&emis,lemis);
name.sin_family=AF_INET;
name.sin_addr.s_addr=INADDR_ANY;
name.sin_port=htons(9999);
length=sizeof(name);
bind(sock,(struct sockaddr *)&name,length);
printf("socket serveur TCP port #%d\n",
ntohs(name.sin_port));
listen(sock,5);
do{
msgsock=accept(sock,(struct sockaddr *)&emis,&lemis);
if(msgsock<0){
perror("accept\n" );
}
else do{
if (getsockname(msgsock,(struct sockaddr *)&emis,&lemis)<0){
perror ("getsockname" );
close(sock);
return 1;
}
//mise a zero du buffer
bzero(buf,sizeof(buf));
if ((rval=read(msgsock,buf,1024))<0){
perror("read" );
i=1;
}
i=0;
if(rval==0){
fprintf(stderr,"fin connexion\n" );
}
else{
interpreter_datagram(buf,msgsock);
rval=0;
}
}
while(rval!=0);
close (msgsock);
printf("\nFin de connexion\n" );
}
while(1);
}

xelad

Le fichier mod_datagram_srv.h

Code :

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
char *tab[4];
void DMDSCR();
void FINCOM();
void INCONNU();
int decomposer_datagram();
void interpreter_datagram();
void ajouter_champs();
char *fincom();
char *demande();
char *init_datagram();
char *str_sub();
void DMDSCR(const char *datagram,int msgsock){
int SIZE=1024;
printf("demande d'envoi d'un screenshot\n" );
// make screenshot
// system("import -window root capture.jpg -quality 25" );
//SP
int j;
size_t nb_lu;
FILE *fichier_a_envoyer;
FILE *fichier_socket=fdopen(msgsock,"w" );
char *chaine=(char *)malloc(sizeof(char)*SIZE);
//SP
//memset(chaine,'\0',sizeof(chaine));
fichier_a_envoyer=fopen("capture.jpg","r" );
if(fichier_a_envoyer){
while((nb_lu=fread(chaine,1,SIZE,fichier_a_envoyer))>0){
for(j=0;j<nb_lu;j++) printf("%o\n",chaine[j]);
if (nb_lu!=SIZE){
fwrite(str_sub(chaine,4,nb_lu), nb_lu-4, 1, fichier_socket);
}
else fwrite(chaine, nb_lu, 1, fichier_socket);
}
}else printf("Pas de fichier" );
send(msgsock,fichier_socket,sizeof(fichier_socket),0);
fclose(fichier_a_envoyer);
fclose(fichier_socket);
free(chaine);
}
char *str_sub(const char *s, unsigned int start, unsigned int end){
char *new_s=NULL;
if(s && start < end){
new_s=malloc(sizeof(*new_s)*(end-start+2));
int i;
for (i=start; i<=end; i++) new_s[i-start]=s[i];
}
return new_s;
}
// SCINDE LE DATAGRAM data DANS UN TABLEAU tab
int decomposer_datagram(char *data,char *tab[]){
char *p;
int i=0;
p=(char *)strtok(data,"&&" );
while(p != NULL){
tab[i]=p;
p=(char *)strtok(NULL,"&&" );
i++;
}
i--;
return i;
}
void interpreter_datagram(const char *datagram,int msgsock){
char *code=(char *)malloc(sizeof(char)*7);
code=strncpy(code,datagram,sizeof(char)*6);
code[6]='\0';
printf("\n\n----RECEPTION TRAME : --> %s \nORDRE : %s\n",datagram,code);
if(strcmp(code,"DMDSCR" )==0) DMDSCR(datagram,msgsock);
else if(strcmp(code,"FINCOM" )==0) FINCOM(datagram,msgsock);
else INCONNU(datagram);
free(code);
}
// ALLOUE UN CHAMPS DE DATAGRAM
void ajouter_champs(char *data, const char *champs){
strcat(data,"&&" );
strcat(data,champs);
}
// FABRIQUE UNE FIN DE COMMUNICATION
char *fincom(){
char *data=(char *)malloc(sizeof(char)*7);
strcpy(data,"FINCOM" );
return data;
}
// FABRIQUE UNE DEMANDE
char *demande(const char *code){
char *data=(char *)malloc(sizeof(char)*7);
strcpy(data,code);
return data;
}
// INITIALSIE UN DATAGRAM
char *init_datagram(const char *code){
char *data=(char *)malloc(sizeof(char)*100);
strcpy(data,code);
return data;
}
void INCONNU(const char *datagram){
printf("Code inconnu\n" );
}
void FINCOM(const char *datagram, int msgsock){
char *reponse;
reponse=fincom();
send(msgsock,reponse,strlen(reponse),0);
free(reponse);
}

Message édité par xelad le 14-12-2005 à 19:05:39

xelad

J'avais fait ce code pour faire un serveur qui executait des requetes SQL et qui formatait les réponses pour les renvoyer à un client C. Je l'ai réutilisé pour ce nouveau projet.

FORUM HardWare.fr

Programmation

Pb Socket et fichier

Sujets relatifs
Gestion des données d'un fichier TXT	supprimer un fichier sous unix
script tranférer dans un fichier	[c++] DLL fichier de logs
lire et écrire à partir d'un fichier	Récupérer les infos d'un fichier txt en batch
fichier HEX	Lecture d'un fichier texte en boucle C++
Locker un fichier	Ecrire un fichier texte sur un serveur distant
Plus de sujets relatifs à : Pb Socket et fichier

Page générée en 0.133 secondes