Bonjour, je suis en train de me prendre la tête sur un problème de mappage de fichier pour transférer des fichiers depuis un client vers un serveur. Les fichiers à transférer doivent se faire via mmap, et par bloc de 4Ko.
Pour une requête PUT, le client envois un fichier vers le serveur. Je commence donc par envoyer le nom ainsi que la taille du fichier. Ensuite, je map chaque blocs et je les envois vers le serveur avec send. voici le code :
//On parcours le fichier en transmetant chaque bloc
char* fmap;
int bloc;
bloc= 1;
while (bloc<=nbBloc){
//s'il reste moins que MAXDATA bytes à transferer
if ((bloc*MAXDATA) > infoFile.st_size){
int tmp;
tmp = infoFile.st_size- (bloc*(MAXDATA-1));
fmap = mmap(NULL, tmp, PROT_READ, MAP_PRIVATE, fileDescriptor, bloc*MAXDATA);
}
else{
fmap = mmap(NULL, MAXDATA, PROT_READ, MAP_PRIVATE, fileDescriptor, bloc*MAXDATA);
}
if (fmap == MAP_FAILED){
printf("Erreur lors du mappage du fichier.");
return -1;
}
//Envois du bloc
len = strlen(fmap);
bytesSend = send(socketfd, fmap, len, 0);
printf("Envois du bloc %i/%i.",bloc,nbBloc);
bloc++;
}
Coté serveur, c’est à peu près la même chose, sauf qu’on créé le fichier, et on alloue l’espace disque avec ftruncate avant de le récupérer :
//ouverture du fichier
content_Fd = open(fileName, O_CREAT | O_WRONLY);
if (content_Fd<0){
printf("Server: Open file %s failled \n", fileName);
return -1;
}
//reservation de la memoire
if (ftruncate(content_Fd, taille) != 0){
printf("Server: Ftruncate failled \n");
return -1;
}
int nbBloc; //nombre de bloc a transmettre
nbBloc = ceil((double)taille/(double)MAXDATASIZE);
//boucle de reception du fichier
int bloc;
bloc= 1;
while (bloc<=nbBloc){
//attente donnée
if ((numbytes=recv(new_fd, buf, MAXDATASIZE, 0)) == -1) {
printf("Server: received failled \n");
return -1;
}
//s'il reste moins que MAXDATASIZE bytes à transferer
if ((bloc*MAXDATASIZE) > taille){
int tmp;
tmp = taille - (bloc*(MAXDATASIZE-1));
addr = mmap(NULL, tmp, PROT_WRITE, MAP_SHARED, content_Fd, bloc*MAXDATASIZE);
}
else{
addr = mmap(NULL, MAXDATASIZE, PROT_WRITE, MAP_SHARED, content_Fd, bloc*MAXDATASIZE);
}
if (addr == MAP_FAILED){
printf("Erreur lors du mappage du fichier.");
return -1;
}
char *ptr;
int i = 0;//iterateur du buffeur
//on mappe le contenu
for (ptr = addr; ptr <= addr + numbytes -1; ptr++){
*ptr = buf[i];
i++;
}
printf("Server: Reception du bloc %i/%i.",bloc,nbBloc);
bloc++;
}//fin reception donnee
Lorsque ce code est exécuté, le serveur plante au moment du mappage. Ma question est donc : Comment marche ce foutu mappage? Lors que j’appelle la fonction mmap, le paramètre size correspond a la taille totale du fichier ou simplement au bloc transféré?
A noter que MAXDATAFILE ou MAXDATA correspond aux 4Ko.
Merci pour votre aide.
)