AT_DEVICE TCP 接收大文件失败！

发布于 2020-08-27 17:01:02 浏览：1571 订阅该版

红枫认证专家 2020-08-27

这家伙很懒，什么也没写！

thrive 2020-08-28

这家伙很懒，什么也没写！

thrive 2020-08-28

这家伙很懒，什么也没写！

红枫 2020-08-28

这家伙很懒，什么也没写！

thrive 2020-08-28

这家伙很懒，什么也没写！

thrive 2020-08-28

这家伙很懒，什么也没写！

红枫 2020-08-29

这家伙很懒，什么也没写！

thrive 2020-08-29

这家伙很懒，什么也没写！

```c
//客户端代码
#define THREAD_PRIORITY      25
#define THREAD_STACK_SIZE    2048
#define THREAD_TIMESLICE     5

void thread1_entry(void *parameter)
{
    //char *ptr = RT_NULL;  //内存块的指针
    int ret;
    char *recv_data;
    struct hostent *host;
    int sock, bytes_received;
    struct sockaddr_in server_addr;
    char url[50] = {"192.168.0.200"};
    int port;
    fd_set readset;
    int i, maxfdp1;
    int fd = -1;

fd = open(LOCAL_FILE, O_WRONLY | O_CREAT | O_TRUNC |_FAPPEND, 0);
       if(-1 == fd)
           rt_kprintf("open is error [%d]\r\n",fd);
       else
           rt_kprintf("open is success [%d]\r\n",fd);

//url = "192.168.0.200";
    //port = strtoul(argv[2], 0, 10);
    port = 8000;

/* 通过函数入口参数url获得host地址（如果是域名，会做域名解析） */
    host = gethostbyname(url);

/* 分配用于存放接收数据的缓冲 */
    recv_data = rt_malloc(BUFSZ);
    if (recv_data == RT_NULL)
    {
        rt_kprintf("No memory\n");
        return;
    }
    else {
         printf("rt_malloc recv_data 4096 success");
    }

/* 创建一个socket，类型是SOCKET_STREAM，TCP类型 */
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        /* 创建socket失败 */
        rt_kprintf("Socket error\n");

/* 释放接收缓冲 */
        rt_free(recv_data);
        return;
    }

/* 初始化预连接的服务端地址 */
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr = *((struct in_addr *)host->h_addr);
    rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));

int nSendBuf=1*1024;//设置为1K
    setsockopt(sock,SOL_SOCKET,SO_RCVBUF,(const char*)&nSendBuf,sizeof(int));

/* 连接到服务端 */
    if (connect(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    {
        /* 连接失败 */
        rt_kprintf("Connect fail!\n");
        closesocket(sock);

/*释放接收缓冲 */
        rt_free(recv_data);
        return;
    }

/* 获取需要监听的描述符号最大值 */
    maxfdp1 = sock + 1;

while (1)
    {
        /* 清空可读事件描述符列表 */
        FD_ZERO(&readset);

/* 将需要监听可读事件的描述符加入列表 */
        FD_SET(sock, &readset);

/* 等待设定的网络描述符有事件发生 */
        i = select(maxfdp1, &readset, 0, 0, 0);

/* 至少有一个文件描述符有指定事件发生再向后运行 */
        if (i == 0) continue;

/* 查看 sock 描述符上有没有发生可读事件 */
        if (FD_ISSET(sock, &readset))
        {
            /* 从sock连接中接收最大BUFSZ - 1字节数据 */
            //bytes_received = recv(sock, recv_data, BUFSZ - 1, 0);
            bytes_received = recv(sock, recv_data, BUFSZ, 0);
            if (bytes_received < 0)
            {
                /* 接收失败，关闭这个连接 */
                closesocket(sock);
                rt_kprintf("\nreceived error,close the socket.\r\n");

/* 释放接收缓冲 */
                rt_free(recv_data);
                break;
            }
            else if (bytes_received == 0)
            {
                /* 默认 recv 为阻塞模式，此时收到0认为连接出错，关闭这个连接 */
                closesocket(sock);
                rt_kprintf("\nreceived error,close the socket.\r\n");

/* 释放接收缓冲 */
                rt_free(recv_data);
                break;
            }

/* 有接收到数据，把末端清零 */
            //recv_data[bytes_received] = '\0';

if (strncmp(recv_data, "q", 1) == 0 || strncmp(recv_data, "Q", 1) == 0)
            {
                /* 如果是首字母是q或Q，关闭这个连接 */
                closesocket(sock);
                rt_kprintf("\n got a 'q' or 'Q',close the socket.\r\n");

/* 释放接收缓冲 */
                rt_free(recv_data);
                close(fd);
                break;
            }
            else
            {
                /* 在控制终端显示收到的数据 */
                rt_kprintf("\nbytes_received = %d ", bytes_received);
                //open(LOCAL_FILE,O_RDWR);
                if(fd>0)
                {
                    rt_kprintf("open is success [%d]\r\n",fd);
                    write(fd,recv_data,bytes_received);

}
            }

}
    }

return;

}

int tcp_sample(void)
{
    rt_thread_t tid = RT_NULL;

/* 创建线程 1 */
    tid = rt_thread_create("thread1",
                           thread1_entry, RT_NULL,
                           THREAD_STACK_SIZE,
                           THREAD_PRIORITY,
                           THREAD_TIMESLICE);
    if (tid != RT_NULL)
        rt_thread_startup(tid);

return 0;
}
/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(tcp_sample, tcp sample);

//服务器端代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <errno.h>
#include <unistd.h>
#include<netinet/in.h>
#include<sys/types.h>
#include<sys/socket.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <fcntl.h>

#define HELLO_WORLD_SERVER_PORT    8000         //端口号
#define LENGTH_OF_LISTEN_QUEUE     5
#define BUFFER_SIZE                2048
#define FILE_NAME_MAX_SIZE         512

int main(int argc, char **argv)
{
    // set socket's address information
    // 设置一个socket地址结构server_addr,代表服务器internet的地址和端口
    char ip[100] = {0};
    char buffer[BUFFER_SIZE];
    struct sockaddr_in   server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);

// create a stream socket
    // 创建用于internet的流协议(TCP)socket，用server_socket代表服务器向客户端提供服务的接口
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket < 0)
    {
        printf("Create Socket Failed!\n");
        exit(1);
    }

//设置地址重用
	int opt = 1;
	int ret = setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
	if (ret == -1)
	{
		perror("setsockopt");
		return -1;
	}

int nSendBuf=2*1024;//设置为2K
       ret = setsockopt(server_socket,SOL_SOCKET,SO_SNDBUF,(const char*)&nSendBuf,sizeof(int));
	if (ret == -1)
	{
		perror("setsockopt 2");
		return -1;
	}
 
    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)))
    {
        printf("Server Bind Port: %d Failed!\n", HELLO_WORLD_SERVER_PORT);
        exit(1);
    }

if (listen(server_socket, LENGTH_OF_LISTEN_QUEUE))
    {
        printf("Server Listen Failed!\n");
        exit(1);
    }

// 服务器端一直运行用以持续为客户端提供服务
    while(1)
    {
      
        struct sockaddr_in client_addr;
        socklen_t          length = sizeof(client_addr);
	 memset(&client_addr,0,sizeof(client_addr));

int new_server_socket = accept(server_socket, (struct sockaddr*)&client_addr, &length);
        if (new_server_socket < 0)
        {
            printf("Server Accept Failed!\n");
            break;
        }
	else
       {
            printf("Server Accept success!22222\n");
            //break;

}
	char *ip=inet_ntoa(client_addr.sin_addr);
	int temport=ntohs(client_addr.sin_port);

printf("1ip=%s temport=%d\n",ip,temport);

memset(buffer,0, sizeof(buffer));
		//printf("00000000 %d\r\n",length);
	
        /*length = recv(new_server_socket, buffer, BUFFER_SIZE, 0);
		 //printf("11111111 %d\r\n",length);
        if (length < 0)
        {
            printf("Server Recieve Data Failed!\n");
            break;
        }*/

printf("22222222\r\n");

//char file_name[100] = {"/opt/work/GBK16.bin"};
      //  bzero(file_name, sizeof(file_name));
       // strncpy(file_name, buffer,
        //        strlen(buffer) > FILE_NAME_MAX_SIZE ? FILE_NAME_MAX_SIZE : strlen(buffer));

int fd = open("/opt/work/GBK16.bin", O_RDWR);
        if (fd == -1)
        {
            printf("open error!\r\n");
        }
        else
        {
            bzero(buffer, BUFFER_SIZE);
            int file_block_length = 0;
            while( (file_block_length = read(fd, buffer, BUFFER_SIZE)) > 0)
            {
                printf("file_block_length = %d\n", file_block_length);

// 发送buffer中的字符串到new_server_socket,实际上就是发送给客户端
                if (send(new_server_socket, buffer, file_block_length, 0) < 0)
                {
                    printf("Send File length:%d Failed!\n",file_block_length);
                    break;
                }

memset(buffer,0, sizeof(buffer));
		 // sleep(3);
            }
            close(fd);
            printf("File Transfer Finished!\n");
		//发送结束状态字
	     send(new_server_socket, "q", 1, 0);
			
        }

close(new_server_socket);
    }

close(server_socket);

return 0;
}

```

这个是2边开始运行后出错的log
![image.png](/uploads/20200829/e71bbf59465494940803dd9675cf00b6.png)