在 c++ 中通过套接字发送图片(发送函数），但未收到完整(Windows）

Send Picture by socket (send func) in c++ , but do not recive complete(Windows)!

本文关键字：Windows c++ 套接字 函数      更新时间：2023-10-16

我正在从客户端发送到服务器，但图片没有收到完整。

客户端代码： 

FILE *fr = fopen(tmppicsend, "rb");
char* buffer;
buffer = (char*) malloc(sizeof(char)*size);
fread(buffer, size, 1, fr);
send_len_pic = send( m_socket_pic, buffer, size, 0 );
recv( m_socket_pic, rec_end_check, 32, 0 );
fclose(fr);
free(buffer);

服务器代码：

FILE *fw = fopen(fname, "wb");
char* buffer;
buffer = (char*) malloc(sizeof(char)*size);
int rec_len = recv( current_client, buffer, size, 0 );
buffer[size]='';
fwrite(buffer, size, 1, fw);
size -= size;
free(buffer);
fclose(fw);

配置套接字：

WSADATA wsaData_pic;
SOCKET m_socket_pic;
SOCKET m_backup_pic;
sockaddr_in con_pic;
 // Initialize Winsock.
int iResult = WSAStartup( MAKEWORD(2,2), &wsaData_pic );
if ( iResult != NO_ERROR ){
    //printf("Error at WSAStartup()n");
}
// Create a socket.
m_socket_pic = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
if ( m_socket_pic == INVALID_SOCKET ) {
    //printf( "Error at socket(): %ldn", WSAGetLastError() );
    //WSACleanup();
}
m_backup_pic = m_socket_pic;
// Connect to a server.
con_pic.sin_family = AF_INET;
con_pic.sin_addr.s_addr = inet_addr( ip );
con_pic.sin_port = htons( 2200 );
if ( connect( m_backup_pic, (SOCKADDR*) &con_pic, sizeof(con_pic) ) == SOCKET_ERROR) {
    //printf( "Failed to connect.n" );
    //WSACleanup();
}else
{   
    m_socket_pic=m_backup_pic;
}

}

当我比较这张图片时，我在序列号数据包中看到错误(数据包不定期接收(。图片(来自客户端和服务器的图片(大小相同。我想发送 JPEG 图片。

请帮助我，坦克。

你犯了通常的错误。你不能假设 recv(( 填充缓冲区。你必须循环，直到你拥有你需要的所有数据，你必须利用 recv(( 返回的计数值。

你怎么知道服务器端要接收的数据的大小？您应该在服务器和客户端之间建立某种协议(由您自己定义(。最简单的方法是首先发送uint64_t(8字节(，它将保存图片大小，然后发送数据本身。然后在服务器读取前 8 个字节后 - 它将知道需要多少数据。然后你只需重复 recv(( 调用，直到你得到客户端发送的所有数据。最好在服务器端使用select()来等待下一个数据部分可用。顺便说一句，如果您尝试发送的图片足够大(在大多数情况下是真的(，它会通过 tcp 或 udp 连接逐部分发送，而不是通过一大块发送。而且无法预测(硬件决定(发送多大或发送多少碎片。因此，您绝对应该准备好重复调用 recv(( 来接收客户端发送到服务器的所有数据。

我认为

原因是您发送的数据大小，因为当您通过网络发送大数据包时，底层会将这个大数据包分成小数据包，然后通过网络发送这些数据包。

因此，当您收到这些数据包时，这些数据包的顺序可能会更改，这就是为什么您收到相同大小的数据，但图像不正确的原因。

我会给你一个快速的解决方案，你可以试试，

将你的文件分成小数组，假设每个数组是 1024 字节，首先发送这些数组的

计数，然后开始发送第一个数组(1024 字节(，然后等待另一端的确认，重复直到发送所有数据。

您可以在不确认的情况下执行此操作，但在每次发送之间留出一些时间。

您是否尝试过将图像缓冲区转换为 base64，将其发送到代码的接收器部分，然后取消 base 并对其进行 malloc

？

以上方式是我们的屏幕截图程序的工作方式(用于远程管理(，它就像一个魅力。

客户端代码

    /*
     * Send size of the file first.
     */
    n = sizeof(filesize);
    r = send(m_socket_pic, &filesize, n);
    if (r != n) {
        printf("error sending %d bytesn", n);
    }       
    /*
     * Now send the file.
     */
    n = filesize;
    while (n > 0) {
        r = send(m_socket_pic, buffer, n, 0);
        buffer += r;
        n -= r;    
    }

服务器代码

    /*
     * Recv size of the file first.
     */
    n = sizeof(filesize);
    r = recv(current_client, &filefsize, n);
    if (r != n) {
        printf("error receiving %d bytesn", n);
    }
    /*
     * Now recv the file.
     */
    n = filesize;
    while (n > 0) {
        r = recv(current_client, buffer, n, 0);
        buffer += r;
        n -= r;
    }

感谢大家，

问题是，通过套接字发送大文件。

我测试了很多方法，但没有回答问题。

众所周知，我应该使用循环来发送拆分数据。

最好的拆分大小是 512 或 1500，很大的问题在于recv()函数，这个函数比send()函数慢很多。当我在循环块中使用Sleep(1000)时，减少了损坏照片的数量。

我有很多次尝试来回答。

这个问题的最佳答案是：

将客户端与服务器同步以进行发送流。

由于 recv(( 函数 i 比 send(( 函数慢，因此客户端发送服务器能够接收的数据量。

客户端代码： 

char* bufferCMP;
bufferCMP = (char*)malloc(sizeof(char) * size);
p_file = fopen(tmppicsend,"rb");
fread(bufferCMP, 1, size , p_file);
fclose(p_file);

int chunkcount = size / DEFAULT_BUFLEN;
int lastchunksize = size - (chunkcount * DEFAULT_BUFLEN);
int fileoffset=0;
//Sending Actual Chunks
while (chunkcount > 0)
{
    iResult = send( m_socket_pic, bufferCMP + (fileoffset * DEFAULT_BUFLEN) , DEFAULT_BUFLEN , 0 );
    fileoffset++;
    chunkcount--;
    if (iResult != DEFAULT_BUFLEN)
    {
        //printf("Sending Buffer size <> Default buffer length  ::: %dn",WSAGetLastError());
    }
    else
    {
        //printf("Sending Buffer size = %d n", iResult);
    }
}
//Sending last Chunk
iResult = send( m_socket_pic, bufferCMP + (fileoffset * DEFAULT_BUFLEN) , lastchunksize , 0 );

服务器代码：

int FileCounter=0;
bool flg=true;
char * fileComplete;
char * filesizeBuffer;
FILE *temp;
int iResult;
int receiveBuffer = 0;
int desiredRecBuffer = size ;
//int desiredRecBuffer = DEFAULT_BUFLEN ; 
fileComplete = (char*) malloc (sizeof(char)* size );
while (desiredRecBuffer > 0)
{
    iResult = recv( current_client, fileComplete + receiveBuffer , desiredRecBuffer , 0 );
    //iResult = recv( ClientSocket, fileComplete + receiveBuffer , fileSize , 0 );
    if (iResult < 1)
    {
        //printf("Reveive Buffer Error  %d n", WSAGetLastError());
    }
    else
    {
        receiveBuffer += iResult;
        desiredRecBuffer = size - receiveBuffer ;
        //printf("Reveived Data size :  %d n", iResult);
    }
}
FILE *File = fopen(fname, "wb");
fwrite(fileComplete,1, size , File);
//flg = true;
free(fileComplete);
fclose(File);
相关文章：