c envoyer et recevoir des fichiers

Essayez ce code:

Côté Client:

/* Client code */
/* TODO : Modify to meet your need */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#define PORT_NUMBER     5000
#define SERVER_ADDRESS  "192.168.1.7"
#define FILENAME        "/home/toc/foo.c"
int main(int argc, char **argv)
{
int client_socket;
ssize_t len;
struct sockaddr_in remote_addr;
char buffer[BUFSIZ];
int file_size;
FILE *received_file;
int remain_data = 0;
/* Zeroing remote_addr struct */
memset(&remote_addr, 0, sizeof(remote_addr));
/* Construct remote_addr struct */
remote_addr.sin_family = AF_INET;
inet_pton(AF_INET, SERVER_ADDRESS, &(remote_addr.sin_addr));
remote_addr.sin_port = htons(PORT_NUMBER);
/* Create client socket */
client_socket = socket(AF_INET, SOCK_STREAM, 0);
if (client_socket == -1)
{
fprintf(stderr, "Error creating socket --> %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
/* Connect to the server */
if (connect(client_socket, (struct sockaddr *)&remote_addr, sizeof(struct sockaddr)) == -1)
{
fprintf(stderr, "Error on connect --> %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
/* Receiving file size */
recv(client_socket, buffer, BUFSIZ, 0);
file_size = atoi(buffer);
//fprintf(stdout, "\nFile size : %d\n", file_size);
received_file = fopen(FILENAME, "w");
if (received_file == NULL)
{
fprintf(stderr, "Failed to open file foo --> %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
remain_data = file_size;
while ((remain_data > 0) && ((len = recv(client_socket, buffer, BUFSIZ, 0)) > 0))
{
fwrite(buffer, sizeof(char), len, received_file);
remain_data -= len;
fprintf(stdout, "Receive %d bytes and we hope :- %d bytes\n", len, remain_data);
}
fclose(received_file);
close(client_socket);
return 0;
}

Côté serveur:

/* Server code */
/* TODO : Modify to meet your need */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/sendfile.h>
#define PORT_NUMBER     5000
#define SERVER_ADDRESS  "192.168.1.7"
#define FILE_TO_SEND    "hello.c"
int main(int argc, char **argv)
{
int server_socket;
int peer_socket;
socklen_t       sock_len;
ssize_t len;
struct sockaddr_in      server_addr;
struct sockaddr_in      peer_addr;
int fd;
int sent_bytes = 0;
char file_size[256];
struct stat file_stat;
int offset;
int remain_data;
/* Create server socket */
server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket == -1)
{
fprintf(stderr, "Error creating socket --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
/* Zeroing server_addr struct */
memset(&server_addr, 0, sizeof(server_addr));
/* Construct server_addr struct */
server_addr.sin_family = AF_INET;
inet_pton(AF_INET, SERVER_ADDRESS, &(server_addr.sin_addr));
server_addr.sin_port = htons(PORT_NUMBER);
/* Bind */
if ((bind(server_socket, (struct sockaddr *)&server_addr, sizeof(struct sockaddr))) == -1)
{
fprintf(stderr, "Error on bind --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
/* Listening to incoming connections */
if ((listen(server_socket, 5)) == -1)
{
fprintf(stderr, "Error on listen --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
fd = open(FILE_TO_SEND, O_RDONLY);
if (fd == -1)
{
fprintf(stderr, "Error opening file --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
/* Get file stats */
if (fstat(fd, &file_stat) < 0)
{
fprintf(stderr, "Error fstat --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
fprintf(stdout, "File Size: \n%d bytes\n", file_stat.st_size);
sock_len = sizeof(struct sockaddr_in);
/* Accepting incoming peers */
peer_socket = accept(server_socket, (struct sockaddr *)&peer_addr, &sock_len);
if (peer_socket == -1)
{
fprintf(stderr, "Error on accept --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
fprintf(stdout, "Accept peer --> %s\n", inet_ntoa(peer_addr.sin_addr));
sprintf(file_size, "%d", file_stat.st_size);
/* Sending file size */
len = send(peer_socket, file_size, sizeof(file_size), 0);
if (len < 0)
{
fprintf(stderr, "Error on sending greetings --> %s", strerror(errno));
exit(EXIT_FAILURE);
}
fprintf(stdout, "Server sent %d bytes for the size\n", len);
offset = 0;
remain_data = file_stat.st_size;
/* Sending file data */
while (((sent_bytes = sendfile(peer_socket, fd, &offset, BUFSIZ)) > 0) && (remain_data > 0))
{
fprintf(stdout, "1. Server sent %d bytes from file's data, offset is now : %d and remaining data = %d\n", sent_bytes, offset, remain_data);
remain_data -= sent_bytes;
fprintf(stdout, "2. Server sent %d bytes from file's data, offset is now : %d and remaining data = %d\n", sent_bytes, offset, remain_data);
}
close(peer_socket);
close(server_socket);
return 0;
}

MODIFIER : Ajout d'explication de la part de l'homme sur la offset

La page de man d'envoyer le fichier a dit:

Si le décalage n'est pas NULL, alors il pointe vers une variable contenant le fichier
décalage à partir de laquelle sendfile() démarre la lecture des données à partir de in_fd.

Quand sendfile() renvoie, cette variable sera mis à l'offset de l'octet qui suit le dernier octet lu.

OriginalL'auteur TOC

Je pense que vous devriez obtenir une image plus détaillée de code avec au moins les variables utilisées déclarations et d'initialisation.

Comment fonctionne la partie client d'obtenir la fsize valeur ?

Vous devriez également vérifier la condition du while comme ceci :

while(((uint32_t)total_bytes_read < fsize) && ( .....

N'utilisez pas "!=", parce que si (pour une raison inconnue) total_bytes_read devenir plus grand que fsize, vous serez coincé dans une boucle infinie jusqu'à ce que la connexion de socket est fermé (et renvoie une erreur).

Je pense aussi (mais pas sûr) que vous devez utiliser recv au lieu de lire dans votre partie client.

OriginalL'auteur phsym

Vous utilisez le sendfile API de manière incorrecte. Puisque vous êtes de passage dans une valeur non NULLE dans le troisième paramètre, sendfile permettra de mettre à jour le décalage pour vous. Mais parce que votre envoyer boucle est également mise à jour le décalage, vous serez en sautant sur quelques octets dans le cas que sendfile n'a pas été en mesure d'envoyer l'ensemble du dossier en un seul appel.

De la page de man:

Si offset n'est pas NULL, alors il pointe vers une variable contenant le fichier offset à partir de laquelle sendfile() va commencer la lecture des données à partir de in_fd. Lorsque sendfile() revient, cette variable sera mis à l'offset de l'octet qui suit le dernier octet lu.

Vous devriez supprimer cette ligne à partir de votre envoyer boucle:

  offset += rc;

Edit: Dans votre mise à jour, vous utilisez fpl pour obtenir le fstat informations à partir de votre fichier, mais dans votre sendfile code, vous utilisez fd. Je voudrais vous assurer que ces sont ce à quoi vous vous attendez à les trouver. (Ceci a été corrigé dans encore une autre mise à jour.) En tout cas, j'ai écrit un programme de test à l'aide du code que vous avez fourni (avec ma suggestion de correction), et il semble bien fonctionner avec un peu moins de 2 KO fichier et un fichier de 3 mo.

OriginalL'auteur jxh