在套接字编程TCP中发送文件

Question

I am trying to implement a simple file transfer. Below here is two methods that i have been testing:

Method one: sending and receiving without splitting the file. I hard coded the file size for easier testing.

sender:

send(sock,buffer,107,NULL); //sends a file with 107 size

receiver:

char * buffer = new char[107];                      
recv(sock_CONNECTION,buffer,107,0);

std::ofstream outfile (collector,std::ofstream::binary);
outfile.write (buffer,107); 

The output is as expected, the file isn't corrupted because the .txt file that i sent contains the same content as the original.

Method two: sending and receiving by splitting the contents on receiver's side. 5 bytes each loop.

sender:

send(sock,buffer,107,NULL);   

Receiver:

char * buffer = new char[107];                      //total file buffer
char * ptr = new char[5];                           //buffer
int var = 5;                
int sizecpy = size; //orig size

while(size > var ){                                //collect bytes

    recv(sock_CONNECTION,ptr,5,0);

    strcat(buffer,ptr);                     //concatenate
    size= size-var;     //decrease
    std::cout<<"Transferring.."<<std::endl;

    }

    std::cout<<"did it reach here?"<<std::endl;
    char*last = new char[size];

    recv(sock_CONNECTION,last,2,0);    //last two bytes
    strcat(buffer,last);    
    std::ofstream outfile (collector,std::ofstream::binary);
    outfile.write (buffer,107); 

Output: The text file contains invalid characters especially at the beginning and the end.

Questions: How can i make method 2 work? The sizes are the same but they yield different results. the similarity of the original file and the new file on method 2 is about 98~99% while it's 100% on method one. What's the best method for transferring files?

Answer 1

What's the best method for transferring files?

Usually I'm not answering questions like What's the best method . But in this case it's obvious:

1. You sent the file size and a checksum in network byte order, when starting a transfer
2. Sent more header data (eg filename) optionally
3. The client reads the file size and the checksum, and decodes it to host byte order
4. You sent the file's data in reasonably sized chunks (5 bytes isn't a reasonable size), chunks should match tcp/ip frames maximum available payload size
5. You receive chunk by chunk at the client side until the previously sent file size is matched
6. You calculate the checksum for the received data at the client side, and check if it matches the one that was received beforhand

---

Note: You don't need to combine all chunks in memory at the client side, but just append them to a file at a storage medium. Also the checksum (CRC) usually can be calculated from running through data chunks.

Answer 2

The initial problems I see are with std::strcat . You can't use it on an uninitialized buffer. Also you are not copying a null terminated c-string. You are copying a sized buffer. Better to use std::strncat for that:

char * buffer = new char[107];                      //total file buffer
char * ptr = new char[5];                           //buffer
int var = 5;                
int sizecpy = size; //orig size

// initialize buffer
*buffer = '\0'; // add null terminator

while(size > var ){                                //collect bytes

    recv(sock_CONNECTION,ptr,5,0);

    strncat(buffer, ptr, 5); // strncat only 5 chars

    size= size-var;     //decrease
    std::cout<<"Transferring.."<<std::endl;

}

beyond that you should really as error checking so the sockets library can tell you if anything went wrong with the communication.

Answer 3

Disagree with Galik. Better not to use strcat, strncat, or anything but the intended output buffer.

TCP is knda fun. You never really know how much data you are going to get, but you will get it or an error.

This will read up to MAX bytes at a time. #define MAX to whatever you want.

std::unique_ptr<char[]> buffer (new char[size]);
int loc = 0; // where in buffer to write the next batch of data
int bytesread; //how much data was read? recv will return -1 on error                        

while(size > MAX)
{                                //collect bytes
    bytesread = recv(sock_CONNECTION,&buffer[loc],MAX,0);
    if (bytesread < 0)
    {
         //handle error.
    }
    loc += bytesread;
    size= size-bytesread;     //decrease
    std::cout<<"Transferring.."<<std::endl;
}
bytesread = recv(sock_CONNECTION,&buffer[loc],size,0);
if (bytesread < 0)
{
     //handle error
}

std::ofstream outfile (collector,std::ofstream::binary);
outfile.write (buffer.get(),size); 

Even more fun, write into the output buffer so you don't have to store the whole file. In this case MAX should be a bigger number.

std::ofstream outfile (collector,std::ofstream::binary);
char buffer[MAX];
int bytesread; //how much data was read? recv will return -1 on error                        

while(size)
{                                //collect bytes
    bytesread = recv(sock_CONNECTION,buffer,MAX>size?size:MAX,0);
    // MAX>size?size:MAX is like a compact if-else: if (MAX>size){size}else{MAX}
    if (bytesread < 0)
    {
         //handle error.
    }
    outfile.write (buffer,bytesread); 
    size -= bytesread;     //decrease
    std::cout<<"Transferring.."<<std::endl;
}