Sending images over sockets - c

Question

I'm trying to send an image file through a TCP socket in C, but the image isn't being reassembled correctly on the server side. I was wondering if anyone can point out the mistake?
I know that the server is receiving the correct file size and it constructs a file of that size, but it isn't an image file.
Client
//Get Picture Size
printf("Getting Picture Size\n");
FILE *picture;
picture = fopen(argv[1], "r");
int size;
fseek(picture, 0, SEEK_END);
size = ftell(picture);
//Send Picture Size
printf("Sending Picture Size\n");
write(sock, &size, sizeof(size));
//Send Picture as Byte Array
printf("Sending Picture as Byte Array\n");
char send_buffer[size];
while(!feof(picture)) {
fread(send_buffer, 1, sizeof(send_buffer), picture);
write(sock, send_buffer, sizeof(send_buffer));
bzero(send_buffer, sizeof(send_buffer));
}
Server
//Read Picture Size
printf("Reading Picture Size\n");
int size;
read(new_sock, &size, sizeof(int));
//Read Picture Byte Array
printf("Reading Picture Byte Array\n");
char p_array[size];
read(new_sock, p_array, size);
//Convert it Back into Picture
printf("Converting Byte Array to Picture\n");
FILE *image;
image = fopen("c1.png", "w");
fwrite(p_array, 1, sizeof(p_array), image);
fclose(image);
Edit: Fixed sizeof(int) in server code.

Answer 1

you need to seek to the beginning of the file before you read
fseek(picture, 0, SEEK_END);
size = ftell(picture);
fseek(picture, 0, SEEK_SET);
or use fstat to get the file size.

Answer 2

Check fread and fwrite syntax:
size_t fread(void *ptr, size_t size, size_t n, FILE *fp);
size_t fwrite(const void *ptr, size_t size, size_t n, FILE *fp);
In your case correct statement should be:
fread(send_buffer, sizeof(send_buffer), 1, picture);
fwrite(p_array, sizeof(p_array), 1,image);

Answer 3

Although it's an old post, I must highlight a few problems in the original code :
feof(picture) is always false after fopen. You must always make a read before calling feof
read(new_sock, p_array, size) is not guaranteed to read size bytes, it depends on the value of size, network load, server load,...
A correct (at least more robust) version would be :
//Send Picture as Byte Array (without need of a buffer as large as the image file)
printf("Sending Picture as Byte Array\n");
char send_buffer[BUFSIZE]; // no link between BUFSIZE and the file size
int nb = fread(send_buffer, 1, sizeof(send_buffer), picture);
while(!feof(picture)) {
write(sock, send_buffer, nb);
nb = fread(send_buffer, 1, sizeof(send_buffer), picture);
// no need to bzero
}
Same problem on server side :
//Read Picture Byte Array
printf("Reading Picture Byte Array\n");
char p_array[size];
char* current = p_array;
int nb = read(new_sock, current, size);
while (nb >= 0) {
current = current + nb;
nb = read(new_sock, current, size);
}
On server side you can avoid the creation of a buffer as large a image file (which might be a problem with large images) :
//Read Picture Byte Array and Copy in file
printf("Reading Picture Byte Array\n");
char p_array[BUFSIZE];
FILE *image = fopen("c1.png", "w");
int nb = read(new_sock, p_array, BUFSIZE);
while (nb > 0) {
fwrite(p_array, 1, nb, image);
nb = read(new_sock, p_array, BUFSIZE);
}
fclose(image);