一.前言

TCP和UDP的区别

UDP : 用户数据报协议，面向无连接，可以单播，多播，广播，面向数据报，不可靠,适用于音视频传输
TCP : 传输控制协议，面向连接的协议，可靠的，基于字节流，仅支持单播传输，点对点传输

                    UDP                                           TCP
是否创建连接        无                                             有
是否可靠            不可靠                                         可靠
连接的对象个数      一对一 一对多 多对多                             一对一
传输的方式          面向数据报                                      面向字节流
首部开销            8个字节                                         最少20个字节
适用场景            实时性要求比较高的场景（qq 电话会议 直播）         可靠性高的应用(文件传输)
 

 TCP客户端和服务端的通信流程

TCP客户端:
    1.socket : 创建一个用于通信的套接字fd
    2.connect ： 连接服务器，需要指定连接的服务器的ip和端口
    3.send : 发送数据
    4.recv : 接收数据
    5.close : 断开连接

TCP服务端
    1.socket
    2.bind：将监听文件描述符和本地的ip和端口绑定（ip和端口就是服务器的地址信息）--客户端连接服务器的时候适用的就是这个ip和端口
    3.listen : 监听fd的开始工作
    4.accept : 阻塞等待，当有客户端发起连接，接触阻塞，接收客户端的连接,得到一个和客户端通信的套接字fd
    4.send : 发送数据
    5.recv ： 接收数据
    6.close : 通信结束，断开连接

 相关的socketAPI函数介绍

socket函数
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> //包含了这个头文件，上面两个就可以省略

int socket(int domain, int type. int protocol)
    -功能：创建一个套接字
    -参数:
        -domain:协议族
            AF_INET IPV4
            AF_INET6 IPV6
            AF_UNIX,AF_LOCAL : 本地套接字通信（进程间通信）
        -type:通信过程中适用的协议类型
            SOCK_STREAM : 流式协议
            SOCK_DGRAM : 报式协议
        -protocol:具体的一个协议，一般为： 0
            -SOCK_STREAM :  流式协议默认使用TCP
            -SOCK_DGRAM : 报式协议默认适用UDP
    -返回值:
        成功: 返回文件描述符
        失败: -1

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    -功能：绑定，将fd和本地的ip端口绑定
    -参数:
        -sockfd
        -addr:  需要绑定的socket地址，这个地址封装了ip和端口号
        -addrlen: 结构体占有的内存大小
    -返回值:
        成功: 0
        失败: -1

int listen(int sockfd, int backlog);  会有两个队列：已经连接队列，未连接队列
    -功能：监听这个socket上的连接
    -sockfd : 通过socket()函数得到的文件描述符
    -backlog: 未连接的和已经连接的和的最大值(给个5即可)(4096)    // 通过 cat /proc/sys/net/core/somaxconn  查看

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    -功能：接受客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接进来
    -参数：
        -sockfd : 通过socket()函数得到的文件描述符
        -addr : 传出参数，记录了连接成功后客户端的地址信息(ip port)
        -addrlen: 指定第二个参数的对应的内存大小
    -返回值:
        -成功：返回用于通信的文件描述符
        -失败：-1

 int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    -功能：客户端口连接服务器
    -参数：
        -sockfd : 用于通信的文件描述符,socket()创建
        -addr : 客户端要连接的服务器的地址信息
        -addrlen : 第二个参数的内存大小
    -返回值:
        成功: 0
        失败: -1

二.TCP客户端和服务端通信实例代码

服务端

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define PORT    8000
#define IP      "127.0.0.1"
/*
TCP 通信的服务器端
*/

int main()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0); //创建用于监听的套接子
    if(sockfd == -1)
    {
        perror("create socket");
        exit(-1);
    }
    //绑定
    struct sockaddr_in server;

    server.sin_family = AF_INET;
    // inet_pton(AF_INET,"127.0.0.1", server.sin_addr.s_addr);
    server.sin_addr.s_addr = INADDR_ANY; //0.0.0.0
    server.sin_port = htons(PORT);
    
    if(bind(sockfd,(const struct sockaddr  *)&server,sizeof(server)) == -1)
    {
        perror("bind");
        exit(-1);
    }

    //3.监听
    if(listen(sockfd,8) == -1)
    {
        perror("listen");
        exit(-1);
    }

    //接收客户端连接
    struct sockaddr_in clientaddr;
    int len = sizeof(clientaddr);
    int cfd = accept(sockfd,(struct sockaddr*)&clientaddr,&len);
    if(cfd == -1)
    {
        perror("accept");
        exit(-1);
    }

    //输出客户端信息,获取过来的是网络字节序
    char cip[16] = {0};
    inet_ntop(AF_INET,&clientaddr.sin_addr.s_addr,cip,sizeof(cip));
    unsigned short cport = ntohs(clientaddr.sin_port);
    printf("client ip is %s, client port is %d\n",cip,cport);

    //获取客户端信息
    char recvbuf[1024] = {0};
    char *send_data = "hello, i am server";
    while(1)
    {
        memset(recvbuf,0,sizeof(recvbuf));
        int fd = read(cfd,recvbuf,sizeof(recvbuf));
        if(fd == -1)
        {
            perror("read");
        }
        else if(fd > 0)
        {
            printf("recv client data : %s\n",recvbuf);
        }
        else if(fd == 0)
        {
            printf("客户端断开连接\n");
            break;
        }
        //给客户端发送数据
        
        fd = write(cfd,send_data,strlen(send_data));
        if(fd == -1)
        {
            perror("write");
        }
    }

    //关闭文件
    close(cfd);
    close(sockfd);
    return 0;
}

客户端

#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd == -1)
    {
        perror("create socket");
        exit(-1);
    }
    //2.连接服务器
    struct sockaddr_in client;
    client.sin_family = AF_INET;
    client.sin_addr.s_addr = inet_addr("127.0.0.1");
    client.sin_port = htons(8000);
    int ret = connect(sockfd,(const struct sockaddr*)&client,sizeof(client));
    if(ret == -1)
    {
        perror("connect");
        exit(-1);
    }
    //进行通信
    char *send_data = "hello, i am client";
    char recvbuf[1024] = {0};
    while(1)
    {
        int len = write(sockfd,send_data,strlen(send_data));
        if(len == -1)
        {
            perror("write");
        }
        sleep(1);
        memset(recvbuf,0,sizeof(recvbuf));

        int fd = read(sockfd,recvbuf,sizeof(recvbuf));
        if(fd == -1)
        {
            perror("read");
        }
        else if(fd > 0)
        {
            printf("recv server data : %s\n",recvbuf);
        }
        else if(fd == 0)
        {
            printf("服务器端断开连接\n");
            break;
        }

    }

    //关闭连接
    close(sockfd);
    return 0;
}

三.使用TCP实现数据回射

服务端

// #include <stdio.h>
// #include <arpa/inet.h>
// #include <string.h>
// #include <unistd.h>
// #include <stdlib.h>


// int main()
// {
//     int sockfd = socket(AF_INET,SOCK_STREAM,0);
//     if(sockfd == -1)
//     {
//         perror("create sockfd");
//         exit(-1);
//     }
//     struct sockaddr_in server;
//     server.sin_family = AF_INET;
//     server.sin_addr.s_addr = INADDR_ANY;
//     server.sin_port = htons(8000);
//     int len = sizeof(server);
//     int ret = bind(sockfd,(const struct sockaddr*)&server,len);
//     if(ret == -1)
//     {
//         perror("bind");
//         exit(-1);
//     }
//     ret = listen(sockfd,8);
//     if(ret == -1)
//     {
//         perror("listen");
//         exit(-1);
//     }
//     struct sockaddr_in client;
//     len = sizeof(client);
//     int clientfd = accept(sockfd,(struct sockaddr*)&client,&len);
//     if(clientfd == -1)
//     {
//         perror("accept");
//         exit(-1);
//     }
//     //建立连接成功
//     char client_ip[16] = {0};
//     inet_ntop(AF_INET,(const void*)&client.sin_addr.s_addr,client_ip,sizeof(client_ip));
//     unsigned short port = ntohs(client.sin_port);
//     printf("接收到一个连接,新的连接的地址:%s,端口:%d\n",client_ip,port);

//     //读
//     char recvbuf[1024];
//     while(1)
//     {
//         memset(recvbuf,0,sizeof(recvbuf));
//         len = read(clientfd,recvbuf,sizeof(recvbuf));
//         if(len == -1)
//         {
//             perror("read");
//             break;
//         }
//         else if(len > 0)
//         {
//             printf("接收到了客户端发来的数据:%s\n",recvbuf);
//             printf("下面进行数据回射\n");
//             len = write(clientfd,recvbuf,strlen(recvbuf));
//             if(len == -1)
//             {
//                 perror("write");
//                 break;
//             }
//         }
//         else if(len == 0)
//         {
//             printf("客户端断开连接\n");
//             break;
//         }
//     }
//     close(clientfd);
//     close(sockfd);
//     return 0;
// }

#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
int main()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd == -1)
    {
        perror("socket");
        return -1;
    }
    //绑定
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_port = htons(8000);
    int len = sizeof(server);
    if(bind(sockfd,(const struct sockaddr*)&server,len) == -1)
    {
        perror("bind");
        return -1;
    }

    //监听
    if(listen(sockfd, 8) == -1)
    {
        perror("listen");
        return -1;
    }
    //阻塞接收
    struct sockaddr_in recv_message;
    len = sizeof(recv_message);
    int recv_fd = accept(sockfd,(struct sockaddr*)&recv_message,&len);
    if(recv_fd == -1)
    {
        perror("accept");
        return -1;
    }
    char client_ip[16] = {0};
    inet_ntop(AF_INET,(const void *)&recv_message.sin_addr.s_addr,client_ip,sizeof(client_ip));
    unsigned short  client_port = ntohs(recv_message.sin_port);

    printf("接收到新的客户端连接,他的ip:%s,端口是:%d\n",client_ip,client_port);

    //接收
    char recv_buff[1024];
    while(1)
    {
        memset(recv_buff,0,sizeof(recv_buff));
        len = read(recv_fd,recv_buff,sizeof(recv_buff));
        if(len == -1)
        {
            perror("read");
            break;
        }
        else if(len > 0)
        {
            printf("接收到客户端数据:%s\n",recv_buff);

            len  =write(recv_fd,recv_buff,strlen(recv_buff));
            if(len == -1)
            {
                perror("write");
                break;
            }
        }
        else if(len == 0)
        {
            printf("客户端断开连接\n");
            break;
        }
    }
    close(sockfd);
    close(recv_fd);
}

客户端

#include <stdio.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>


int main()
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd == -1)
    {
        perror("socket");
        exit(-1);
    }
    struct sockaddr_in client;
    client.sin_family = AF_INET;
    client.sin_addr.s_addr = inet_addr("127.0.0.1");
    client.sin_port = htons(8000);
    if(connect(sockfd,(const struct sockaddr*)&client,sizeof(client)) == -1)
    {
        perror("connect");
        exit(-1);
    }

    //写
    char *client_send_data;
    char client_recv_buf[1024];
    int len;
    while(1)
    {
        printf("亲爱的用户，请发送你要发送给服务器的数据:");
        scanf("%s",client_send_data);
        len = write(sockfd,client_send_data,strlen(client_send_data));
        if(len == -1)
        {
            perror("write");
            break;
        }
        sleep(1);
        memset(client_recv_buf,0,sizeof(client_recv_buf));
        len = read(sockfd,client_recv_buf,sizeof(client_recv_buf));
        if(len == -1)
        {
            perror("read");
            break;
        }
        else if(len > 0)
        {
            printf("接收到服务器端的回射数据:%s\n",client_recv_buf);
        }
        else if(len == 0)
        {
            printf("服务器断开连接\n");
            break;
        }
    }
    close(sockfd);
    return 0;
}