RT-Thread-自行设置IP地址server_addr.sin_addr.s_addr = ip_addr.addr;绑定一定会失败RT-Thread问答社区

自行设置IP地址server_addr.sin_addr.s_addr = ip_addr.addr;绑定一定会失败

发布于 2023-11-30 16:53:11 浏览：258 订阅该版

```c
void tcpsevr_thread_entry(void *parameter)
{
    {
        char ip_id_buf[] = "192.168.1.100";
        ip_addr_t ip_addr = {0};
        int port = 5000;
        struct sockaddr_in server_addr, client_addr;
        int sock, connected;
        socklen_t sin_size;

int ret;
        tcp_msg_s recv_d = {.data = RT_NULL,.len=0};
        tcp_msg_s send_d = {.data = RT_NULL,.len=0};
        recv_d.data = rt_calloc(BUFSZ + 1,sizeof(char));  分配接收用的数据缓冲
        send_d.data = rt_calloc(BUFSZ + 1,sizeof(char));
        if (recv_d.data == RT_NULL||send_d.data  == RT_NULL)
        {
            rt_kprintf("No memory\n");
            return;
        }

一个socket在使用前，需要预先创建出来，指定SOCK_STREAM为TCP的socket
        if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        {
             创建失败的错误处理
            rt_kprintf("Socket error\n");
             释放已分配的接收缓冲
            rt_free(recv_d.data);
            recv_d.data = RT_NULL;
            return;
        }

inet_aton(ip_id_buf, &ip_addr);   //将一个字符串表示的点分十进制IP地址IP转换为网络字节序存储在ip_addr中

初始化服务端地址
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(port);  服务端工作的端口
        server_addr.sin_addr.s_addr = ip_addr.addr;
     //   server_addr.sin_addr.s_addr = INADDR_ANY;
        rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
         绑定socket到服务端地址
        if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
        {
             绑定失败
            rt_kprintf("Unable to bind\n");
             释放已分配的接收缓冲
            rt_free(recv_d.data);
            rt_free(send_d.data);
            send_d.data = RT_NULL;
            recv_d.data = RT_NULL;
            return;
        }
         在socket上进行监听
        if (listen(sock, 5) == -1)
        {
            rt_kprintf("Listen error\n");
             release recv buffer
            rt_free(recv_d.data);
            rt_free(send_d.data);
            send_d.data = RT_NULL;
            recv_d.data = RT_NULL;
            return;
        }
        rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
        while (1)
        {
            sin_size = sizeof(struct sockaddr_in);
             接受一个客户端连接socket的请求，这个函数调用是阻塞式的
            connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
             返回的是连接成功的socket
            if (connected < 0)
            {
                rt_kprintf("accept connection failed! errno = %d\n", errno);
                continue;
            }
             接受返回的client_addr指向了客户端的地址信息
            rt_kprintf("I got a connection from (%s , %d)\n",
                       inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
             客户端连接的处理
            while (1)
            {
                 从connected socket中接收数据，接收buffer是1024大小，但并不一定能够收到1024大小的数据
                recv_d.len = recv(connected, recv_d.data, BUFSZ, 0);

if (recv_d.len < 0)
                {
                     接收失败，关闭这个connected socket
                    closesocket(connected);
                    break;
                }
                else if (recv_d.len == 0)
                {
                     打印recv函数返回值为0的警告信息
                    rt_kprintf("\nReceived warning,recv function return 0.\r\n");
                    closesocket(connected);
                    break;
                }

有接收到数据，把末端清零
                recv_d.data[recv_d.len] = '\0';

在控制终端显示收到的数据
//                LOG_HEX("RECEIVED DATA",8, recv_d.data,recv_d.len);

memset(send_d.data,0,BUFSZ);
                send_d.len = 0;

//                handel_tcpsevr(&recv_d,&send_d);    //

发送数据到connected socket
          //      ret = send(connected, send_d.data,send_d.len, 0);
                ret = send(connected, recv_d.data,recv_d.len, 0);    //返回接收到的数据，调试使用
                if (ret < 0)
                {
                     发送失败，关闭这个连接
                    closesocket(connected);
                    rt_kprintf("\nsend error,close the socket.\r\n");
                    break;
                }
                else if (ret == 0)
                {
                     打印send函数返回值为0的警告信息
                    rt_kprintf("\n Send warning,send function return 0.\r\n");
                }
            }
        }
         退出服务
        closesocket(sock);
         释放接收缓冲
        rt_free(recv_d.data);
        rt_free(send_d.data);
        send_d.data = RT_NULL;
        recv_d.data = RT_NULL;
        return ;
    }
}
```