网络套接字编程(二)

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->"<<" ["<

 服务端处理请求

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" <=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" <

我们在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;
}

我们简单测试一下。 

网络套接字编程(二)_第1张图片

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

你可能感兴趣的:(网络,网络,linux,c++)