TCP编程详解

目录

• 数据包格式
• 创建链接（三次握手）
• 数据传输
• 断开链接（四次挥手）
• 基础
• 客户端流程
• 编码
• TCP服务端流程
• TCP服务端编码
• 参考文献

---

TCP把链接做为最基本的对象，每一条TCP链接都有两个端点，这种端点咱们称为套接字(socket)。端口号拼接到IP地址后面就构成了套接字，例如192.0.0.32：80。IP协议虽然能把数据报文送到目的主机，可是并无交付给主机的具体应用进程，而端到端的通讯才是应用进程之间的通讯。

数据包格式

TCP报文是TCP层传输的数据单元，也叫报文段。TCP报文的格式以下图：

TCP报文中的标志位：

1. URG:紧急指针标志，为1时表示紧机指针有效，为0时则忽略紧急指针
2. ACK: 确认序号标志。为1时表示确认号有效，为0时表示报文中不含确认信息，忽略确认号字段。
3. PSH: push标志，为1表示是带有push标志的数据，指示接收方在接收到该报文段之后，应尽快将这个报文段交给应用程序，而不是在缓冲区排队
4. RST: 重置链接标志，用于重置因为主机崩溃或其余缘由而出现错误的链接。或者用于拒绝非法的报文段和拒绝链接请求。
5. SYN: 同步序号，用于创建链接过程，在链接请求中，SYN=1和ACK=0表示该数据段没有使用捎带的确认域，而链接应答捎带一个确认，即SYN=1和ACK=1
6. FIN: finish标志，用于释放链接，为1时表示发送方已经没有数据发送了，即关闭本方数据流

创建链接（三次握手）

TCP通讯时的创建链接须要三次握手，意思是创建链接的时候，客户端与服务器之间须要三次数据包的交流。

1. 客户端发送给服务器一个请求链接数据包，即发送了一个指向服务器目标端口的一个SYN位为1的TCP报文
2. 服务器接收到客户端的链接请求以后，会回应一个SYN位为1的TCP报文，表示赞成链接。而且会把ACK位也置1表示确认收到上次消息
3. 客户端收到服务器的赞成链接的数据包以后，还要回复一个ACK位1的TCP报文，表示确认收到

数据传输

TCP是以段为单位发送数据的，在创建TCP链接的同时，每一个数据包的长度也被肯定下来，通常称其为最大消息长度（MSS: Maximum Segment Size）。TCP在传输大量数据时，是以MSS的大小将数据进行分割发送的，进行重发时也是以MSS为单位。两端的主机在发出创建链接的请求时，会在TCP首部中写入MSS选项，告诉对方本身的接口可以适应的MSS的大小。为附加MSS选项，TCP的首部将再也不是20字节，而是4字节的整数倍。会在二者之间选择一个较小的值投入使用。

断开链接（四次挥手）

四次挥手，意思就是释放链接的时候客户端与服务器之间须要四次数据包的交流。

1. 客户端发送给服务器一个请求释放链接的数据包，即发送了一个指向服务器目标端口的一个FIN位为1的TCP报文，表示客户端没有数据要发送了，可是仍然能够接收数据。而且ACK位也为1，表示对上次传输数据结果的确认。而且以后处于等待状态，等待服务器的两次回应
2. 服务器接收到客户端的释放链接请求以后，会先回应一个ACK位为1的报文，表示确认收到。可是这时服务器可能还有数据没有发送完成，继续发送数据
3. 服务器发送完数据以后，发送一个FIN为1的TCP报文，表示我也没有要发送的数据了，你能够释放链接了，固然ACK位仍为1
4. 客户端接受到服务器的赞成释放链接的数据包以后，回复一个ACK为1的TCP报文，表示数据收到

基础

socket编程通常采用客户端-服务器模式（即由客户进程向服务器进程发出请求，服务器进程执行请求的任务并将执行结果返回给客户进程的模式）

客户端流程

TCP客户端socket编程流程

1. 建立socket:Socket()
2. 创建链接:Connect()
3. 通讯:Send()Recv()
4. 关闭socket: CloseSocket()

编码

1. hostent结构体

hostent结构体

The hostent structure is defined in <netdb.h> as follows:

struct hostent {
   char  *h_name;            /* official name of host */
   char **h_aliases;         /* alias list */
   int    h_addrtype;        /* host address type */
   int    h_length;          /* length of address */
   char **h_addr_list;       /* list of addresses */
}
#define h_addr h_addr_list[0] /* for backward compatibility */

The members of the hostent structure are:

h_name 
  The official name of the host.

h_aliases
  An array of alternative names for the host, terminated by a NULL pointer.

h_addrtype
  The type of address; always AF_INET or AF_INET6 at present.

h_length
  The length of the address in bytes.

h_addr_list
  An array of pointers to network addresses for the host (in network byte order), terminated by a NULL pointer.

h_addr The first address in h_addr_list for backward compatibility.

2. gethostbyname & gethostbyaddr 过期了，应用应该使用getaddrinfo和getnameinfo.TCP客户端

static const char send_data[] = "This is TCP Client from RT-Thread."; /* 发送用到的数据 */
void tcpclient(int argc, char **argv)
{
    int ret;
    char *recv_data;
    struct hostent *host;
    int sock, bytes_received;
    struct sockaddr_in server_addr;
    const char *url;
    int port;

    if (argc < 3)
    {
        rt_kprintf("Usage: tcpclient URL PORT\n");
        rt_kprintf("Like: tcpclient 192.168.12.44 5000\n");
        return ;
    }

    url = argv[1];
    port = strtoul(argv[2], 0, 10);

    /* 经过函数入口参数url得到host地址（若是是域名，会作域名解析） */
    host = gethostbyname(url);

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

    /* 建立一个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));

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

        /*释放接收缓冲 */
        rt_free(recv_data);
        return;
    }
    else
    {
        /* 链接成功 */
        rt_kprintf("Connect successful\n");
    }

    while (1)
    {
        /* 从sock链接中接收最大BUFSZ - 1字节数据 */
        bytes_received = recv(sock, recv_data, BUFSZ - 1, 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);
            break;
        }
        else
        {
            /* 在控制终端显示收到的数据 */
            rt_kprintf("\nReceived data = %s ", recv_data);
        }

        /* 发送数据到sock链接 */
        ret = send(sock, send_data, strlen(send_data), 0);
        if (ret < 0)
        {
            /* 接收失败，关闭这个链接 */
            closesocket(sock);
            rt_kprintf("\nsend error,close the socket.\r\n");

            rt_free(recv_data);
            break;
        }
        else if (ret == 0)
        {
            /* 打印send函数返回值为0的警告信息 */
            rt_kprintf("\n Send warning,send function return 0.\r\n");
        }
    }
    return;
}

TCP服务端流程

1. 建立socket：socket()
2. 将建立的socket绑定到一个IP地址和端口号上:bind()
3. 设置socket为监听模式:listen()
4. 接受请求并返回socket:accept()。accept会阻塞住等待接收消息
5. 与客户端进行通讯recv() & send()
6. 关闭socket:close()

TCP服务端编码

static void tcpserv(int argc, char **argv)
{
    char *recv_data; /* 用于接收的指针，后面会作一次动态分配以请求可用内存 */
    socklen_t sin_size;
    int sock, connected, bytes_received;
    struct sockaddr_in server_addr, client_addr;
    rt_bool_t stop = RT_FALSE; /* 中止标志 */
    int ret;

    recv_data = rt_malloc(BUFSZ + 1); /* 分配接收用的数据缓冲 */
    if (recv_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_data);
        return;
    }

    /* 初始化服务端地址 */
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(5000); /* 服务端工做的端口 */
    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_data);
        return;
    }

    /* 在socket上进行监听 */
    if (listen(sock, 5) == -1)
    {
        rt_kprintf("Listen error\n");

        /* release recv buffer */
        rt_free(recv_data);
        return;
    }

    rt_kprintf("\nTCPServer Waiting for client on port 5000...\n");
    while (stop != RT_TRUE)
    {
        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 */
            ret = send(connected, send_data, strlen(send_data), 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");
            }

            /* 从connected socket中接收数据，接收buffer是1024大小，但并不必定可以收到1024大小的数据 */
            bytes_received = recv(connected, recv_data, BUFSZ, 0);
            if (bytes_received < 0)
            {
                /* 接收失败，关闭这个connected socket */
                closesocket(connected);
                break;
            }
            else if (bytes_received == 0)
            {
                /* 打印recv函数返回值为0的警告信息 */
                rt_kprintf("\nReceived warning,recv function return 0.\r\n");
                closesocket(connected);
                break;
            }

            /* 有接收到数据，把末端清零 */
            recv_data[bytes_received] = '\0';
            if (strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
            {
                /* 若是是首字母是q或Q，关闭这个链接 */
                closesocket(connected);
                break;
            }
            else if (strcmp(recv_data, "exit") == 0)
            {
                /* 若是接收的是exit，则关闭整个服务端 */
                closesocket(connected);
                stop = RT_TRUE;
                break;
            }
            else
            {
                /* 在控制终端显示收到的数据 */
                rt_kprintf("RECEIVED DATA = %s \n", recv_data);
            }
        }
    }

    /* 退出服务 */
    closesocket(sock);

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

    return ;
}

参考文献

1. RT-Thread视频中心内核入门
2. RT-Thread文档中心

---

本文做者: CrazyCatJack

本文连接: https://www.cnblogs.com/CrazyCatJack/p/14408903.html

版权声明:本博客全部文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

关注博主:若是您以为该文章对您有帮助，能够点击文章右下角推荐一下，您的支持将成为我最大的动力！