网络套接字编程（二）

socket常见API

创建套接字：（TCP/UDP，客户端+服务器）

int socket(int domain, int type, int protocol);

绑定端口号：（TCP/UDP，服务器）

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

监听套接字：（TCP，服务器）

int listen(int sockfd, int backlog);

接收请求：（TCP，服务器）

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

建立连接：（TCP，客户端）

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

基于TCP协议实现网络通信

与学习UDP的接口相同，我们通过实现一个简单的TCP服务器与TCP客户端学习这些接口。首先我们编写服务器。

TCP服务器

我们同样使用一个类来实现服务器，TCP下的网络通信同样需要创建套接字，使用TCP创建套接字的与UDP下大致相同


//UDP
int socket_fd=socket(AF_INET,SOCK_DGRAM,0);
 
//TCP
int socket_fd=socker(AF_TNET,SOCK_STREAM,0);

与UDP协议不同，TCP创建套接字的第二个参数应该选择 SOCK_STREAM。

SOCK_DGRAM：套接字提供的数据传输方式为数据报。
SOCK_STREAM：套接字提供的数据传输方式为字节流。
连接性：SOCK_DGRAM无连接，SOCK_STREAM面向连接。
数据完整性：SOCK_STREAM保证数据的顺序和完整性，而SOCK_DGRAM不保证。
速度：SOCK_DGRAM可能更快，因为它减少了协议开销，但牺牲了可靠性。
用途：SOCK_DGRAM适用于小数据量和可以容忍一定数据丢失的场景，SOCK_STREAM适用于需要可靠传输大量数据的场景。

UDP是无连接的，TCP是有连接的。所以UDP采用的是数据报传输方式，TCP采用的是字节流传输方式。

创建套接字


 
class Server
{
public:
    Server(std::string ip,uint16_t port)
        :_sockfd(-1);
        :_ip(ip);
        :_port(port);
    {}
 
    bool init()
    {
        //创建套接字
        _sockfd = socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            std::cerr << "socket flase" << std::endl;
            return false;
        }
        
    }
 
    ~Server()
    {
        if(_sockfd>=0)
        {
            close(_sockfd);
        }
    }
 
private:
    int _sockfd;
    std::string _ip;
    uint16_t _port;
};

绑定ip与端口

与我们编写的UDP服务端相同我们需要绑定IP与端口。流程与UDP协议相同。


    bool init()
    {
        //创建套接字
        _sockfd = socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            std::cerr << "socket flase" << std::endl;
            return false;
        }
        //绑定端口
        struct sockaddr_in local;
        memset(&local,'\0',sizeof(local));
        //协议家族
        local.sin_family=AF_INET;
        //端口号
        local.sin_port=htons(_port);
        //ip
        local.sin_addr.s_addr = inet_addr(_ip.c_str());
        //绑定
        if(bind(_sockfd,(struct sockaddr*)&local,sizeof(struct sockaddr_in)) < 0 )
        {
            //绑定失败
            std::cerr << "bind error" << std::endl;     
            return false;
        }
    }

设置为监听

TCP是面向连接的，客户端与服务端需要建立连接后才能通信。所以TCP服务器需要时刻注意有无客户端的连接请求。我们需要将套接字设置为监听状态。

监听套接字：（TCP，服务器）

int listen(int sockfd, int backlog);

参数说明：

sockfd 参数是要监听的套接字的文件描述符。
backlog 参数是系统应该允许的，处于未完成连接队列中的连接请求的最大数量

如果有多个客户端同时发来连接请求，此时未被服务器处理的连接就会放入连接队列，backlog代表的就是这个全连接队列的最大长度，一般不要设置太大，设置为5或10即可。

返回值：

监听成功返回0，监听失败返回-1，同时错误码会被设置。

在初始化中我们将套接字设置为监听套接字。


    bool init()
    {
        //创建套接字
        _sockfd = socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            std::cerr << "socket flase" << std::endl;
            return false;
        }
        std::cerr << "socket succes" << std::endl;
        //绑定端口
        struct sockaddr_in local;
        memset(&local,'\0',sizeof(local));
        //协议家族
        local.sin_family=AF_INET;
        //端口号
        local.sin_port=htons(_port);
        //ip
        local.sin_addr.s_addr = inet_addr(_ip.c_str());
 
        //绑定
        if(bind(_sockfd,(struct sockaddr*)&local,sizeof(struct sockaddr_in)) < 0 )
        {
            //绑定失败
            std::cerr << "bind error" << std::endl;     
            return false;
        }
        std::cerr << "bind succes" << std::endl;     
 
        if(listen(_sockfd,5) < 0 )
        {
            //监听失败
            std::cerr << "listen error" << std::endl;     
            return false;
        }
        std::cerr << "listen succes" << std::endl;     
    }

获取连接

在设置完监听状态后，我们需要接受客户端的连接请求。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

参数说明：

sockfd 参数是监听套接字的文件描述符。
addr 参数是一个指向 sockaddr 结构的指针，该结构用于接收连接客户端的地址信息。如果调用者不需要地址信息，可以将此参数设置为 NULL。
addrlen 参数是一个指向 socklen_t 类型的变量的指针，它在调用时指定 addr 缓冲区的长度，并在调用成功后更新为实际接收的地址结构长度。

返回值：

成功时，函数返回一个新的套接字文件描述符，用于与客户端进行通信。这个新的套接字会继承监听套接字的一些属性，如类型和协议。
出错时，函数返回 -1 并设置全局变量以指示错误类型。


    void start()
    {
        while(1)
        {
            struct sockaddr_in sendfrom;
            memset(&sendfrom,'\0',sizeof(sendfrom));
            int client;
            socklen_t len=sizeof(struct sockaddr_in);
            client=accept(_sockfd,(struct sockaddr*)&sendfrom,&len);
            if(client<0)
            {
                std::cerr << "accept error" << std::endl;     
                continue;;
            }
            std::string client_ip = inet_ntoa(sendfrom.sin_addr);
			int client_port = ntohs(sendfrom.sin_port);
			std::cout<<"new link->"<<" ["<<client_ip<<"]:"<< client_port <<std::endl;
            server(client);
        }
    }

服务端处理请求

accept返回的是一个描述符套接字·，我们在上一节讲到套接字描述符实际上就是文件描述符，同时文件的读写方式是字节流，而TCP协议的传输也是字节流，所以我们可以使用文件的读写函数接受和发送信息。

使用 read 函数从TCP套接字读取数据：

ssize_t read(int fd, void *buf, size_t count);

参数说明：

fd：特定的文件描述符，表示从该文件描述符中读取数据。
buf：数据的存储位置，表示将读取到的数据存储到该位置。
count：数据的个数，表示从该文件描述符中读取数据的字节数。

返回值说明：

如果返回值大于0，则表示本次实际读取到的字节个数。
如果返回值等于0，则表示对端已经把连接关闭了。
如果返回值小于0，则表示读取时遇到了错误。

使用 write 函数向TCP套接字写入数据：

ssize_t write(int fd, const void *buf, size_t count);

参数说明：

fd：特定的文件描述符，表示将数据写入该文件描述符对应的套接字。
buf：需要写入的数据。
count：需要写入数据的字节个数。

返回值说明：

写入成功返回实际写入的字节数，写入失败返回-1，同时错误码会被设置。


    bool server(int sock)
    {
        char buffer[1024];
        while (true)
        {
			ssize_t size = read(sock, buffer, sizeof(buffer)-1);
			if (size > 0)
            { //读取成功
				buffer[size] = '\0';
				std::cout << sock << " [client]:" << buffer << std::endl;
 
				write(sock, buffer, size);
			}
			else if (size == 0)
            { //对端关闭连接
				std::cout << " close!" << std::endl;
				break;
			}
			else
            { //读取失败
				std::cerr << sock << " read error!" << std::endl;
				break;
			}
		}
		close(sock); //归还文件描述符
	}

我们在start中调用，在mian函数中实例化。


#include"tcp_server.hpp"
 
int main(int argc,char** argv)
{
    if(argc<2)
    {
        std::cerr << "port" << std::endl;
        return -1;
    }
 
    //端口号转化
 
    uint16_t port=atoi(argv[1]);
    std::string ip="127.0.0.1";
    Server server(ip,port);
 
    server.init();
    server.start();
 
    return 0;
}

客户端

客户端也与UDP客户端相似，客户端不需要绑定与监听，首先我们创建套接字。

创建套接字


class Client
{
public:
    Client(std::string server_ip , uint16_t server_port)
        :_sockfd(-1)
        ,_server_ip(server_ip)
        ,_server_port(server_port)
    {}
 
    bool init()
    {
        //创建套接字
 
        _sockfd=socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            std::cerr << "socket error" <<std::endl;
            return false;
        }
        return true;
    }
 
 
    ~Client()
    {
        if(_sockfd>=0)
        {
            close(_sockfd);
        }
    }
private:
    uint16_t _server_port;
    std::string _server_ip;
    int _sockfd;
};

连接服务器

发起连接请求的函数叫做connect，该函数的函数原型如下：

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数说明：

sockfd：特定的套接字，表示通过该套接字发起连接请求。
addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。
addrlen：传入的addr结构体的长度。

返回值说明：

连接或绑定成功返回0，连接失败返回-1，同时错误码会被设置。


    void start()
    {
        char buffer[1024];
        struct sockaddr_in server;
        memset(&server, '\0', sizeof(server));
        //协议家族
        server.sin_family = AF_INET;
        //端口号
        server.sin_port=htons(_server_port);
        //IP
        server.sin_addr.s_addr = inet_addr(_server_ip.c_str());
        socklen_t len=sizeof(server);
        //连接
        if(connect(_sockfd,(struct sockaddr*)&server,len) <0)
        {
            std::cout << "connect false" <<std::endl;
            return;
        }
        
        while (1)
        {
            std::cout << "Please enter# ";
            std::cin.getline(buffer, sizeof(buffer));
            std::string s=buffer;
            write(_sockfd,s.c_str(),s.size());   
        }
    }

我们在main中实例化并调用。


#include"tcp_client.hpp"
 
int main(int argc,char** argv)
{
    if(argc < 3)
    {
        std::cout << "name  ip  port" << std::endl;
        return -1;
    }
    uint16_t port=atoi(argv[2]);
    std::string ip=argv[1];
    Client client(ip,port);
 
    client.init();
    client.start();
 
    return 0;
}

我们简单测试一下。

可以看到他们成功完成了通讯。

相关阅读:
收发电子邮件
 第二篇------Virtual I/O Device (VIRTIO) Version 1.1
钉钉h5微应用调试整理
 [AR Foundation] AR Foundation学习之路（持续记录）
MySQL表的增删改查--你都知道吗?
linux系统ELK组件介绍
 从“白人饭”到美味佳肴，拓世AI为你打造独一无二的饮食计划
 Prometheus系列第十篇一核心之micrometer源码分析一micrometer-registry-prometheus核心实现
 计算机网络五层协议的体系结构
 图神经网络 | 混合神经网络模型GCTN地铁客流预测
原文地址：https://blog.csdn.net/2301_80926085/article/details/140986191