Linux网络——套接字编程

最新推荐文章于 2024-08-12 15:00:16 发布
最新推荐文章于 2024-08-12 15:00:16 发布
阅读量676 收藏 3
点赞数
分类专栏： Linux的网络学习 文章标签： 网络通信 linux socket socket编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jokersorry/article/details/116852053
版权

目录

基本知识

通信两端
  • 在网络通信程序中，通信两端被分为：
    • 客户端：通常是提供给客户的通信端，是编写通信程序中主动发起请求的一端；
    • 服务端：通常指被动接受请求，提供服务的通信端，在接受到客户端的请求之后，进行处理并返回；
  • 客户端是主动发送请求的一端，这也就意味着客户端必须提前知道服务端的地址信息（IP + port），通常情况下，服务端的地址信息是固定的，并且提前提供（写入）客户端；
    在这里插入图片描述
查看网络信息
  • netstat：查看当前的网络状态信息；
    • -a：查看所有的网络信息；
    • -t：查看 TCP 网络信息；
    • -u：查看 UDP 网络信息；
    • -n：不以服务名称显示，也就是说将网络的地址信息显示出来，而不是以一些固定的服务名称显示；
    • -p：查看当前网络状态相对应的进程；

sockaddr结构

概念
  • socket API 是一层抽象的网络编程接口，适用于各种底层网络协议，如 IPv4、IPv6，以及后面会学到的 UNIX Domain Socket 等等，这些网络协议的地址信息结构各不相同，但是却可以使用 socket API 来适用；
介绍
  • 虽然不同协议底层的地址结构各不相同，但是地址结构体的前两个字节所存放的东西都是确定的，它所存放的就是地址域类型，IPv4、IPv6 地址域类型分别定义为宏 AF_INET、AF_INET6，这样只要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址域类型字段确定结构体中的内容；
  • IPv4 和 IPv6 的地址格式定义在<netinet/in.h>中，IPv4 地址用sockaddr_in结构体表示，包括 16 位地址类型，16 位端口号和 32 位 IP 地址，以及 8 字节的填充位，IPv6 使用面较少，所以不做过多介绍；
  • 在接口的参数中，socket API 族的所有地址结构体都可以使用struct sockaddr*类型表示，在使用的时候只需要强制转化成所需的类型即可，如强转为sockaddr_in，这样的好处是增加了程序的通用性，这样一来接口就可以接收 IPv4、IPv6 以及 UNIX Domain Socket 等各种类型的sockaddr结构体指针做为参数，而不用写很多种接口，十分的方便；
    在这里插入图片描述
  • 下面来看看这些地址结构体的底层代码：
    在这里插入图片描述

辅助接口介绍

字节序转换接口
  • 下面是一些字节序转换接口，需要说明的是IP 地址的字节序转换只能用以 l 结尾的转换接口，端口的字节序转换只能用以 s 结尾的转换接口，这是因为他们的大小不一样，如果不使用对应的接口，那么可能会有数据的混乱；
    • uint32_t htonl(uint32_t hostlong);：32 位数据，主机字节序到网络字节序的转换；
    • uint16_t htons(uint16_t hostshort);：16 位数据，主机字节序到网络字节序的转换；
    • uint32_t ntonl(uint32_t netlong);：32 位数据，网络字节序到主机字节序的转换；
    • uint16_t ntons(uint32_t netlong);：16 位数据，网络字节序到主机字节序的转换；
地址转换接口

下面这两个接口局限于 ipv4 的地址转换的；

  • in_addr_t inet_addr(const char* cp);：将字符串点分十进制 IPv4 地址转换为整形的网络字节序 IPv4 地址，例如192.168.2.2 ——> 0xc0a80202；
  • char* inet_ntoa(struct in_addr in);：将整型的网络字节序 IPv4 地址转换为字符串点分十进制 IPv4 地址；
    • 注意事项：这个接口返回了一个char*类型的数据，很显然是这个函数自己在内部为我们申请了一块内存来保存转换后的结果，那么这块内存是否需要我们手动释放呢?
      man手册上进行了说明：inet_ntoa函数是把这个返回结果放到了静态存储区，这个时候不需要我们手动进行释放，但是需要注意的是，如果多次调用这个函数，那么这块静态内存是会被覆盖的；

下面这两个接口不局限于某一个协议的地址转换，只要指定地址域类型就可进行转换；

  • const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);：通用的转换接口，不局限于 IPv4，是将网络字节序二进制地址转换为字符串地址；
    • af：地址域类型，可以是AF_INET、AF_INET6等；
    • scr：指向待转换的网络字节序二进制地址的指针；
    • dst：指向转换后的字符串地址的指针；
    • size：地址域类型所对应的地址信息结构体的大小；
  • int inet_pton(int af, const char* src, void* dst);：通用的转换接口，不局限于 IPv4，是将字符串地址转换为网络字节序二进制地址；
    • af：地址域类型；
    • src：指向待转换的字符串地址的指针；
    • dst：指向转换后的网络字节序二进制地址的指针；

UDP协议

概念
  • 概念：UDP 协议又叫用户数据报协议，是在传输层的协议；
  • 特性：无连接、不可靠传输、面向数据报；
  • 应用场景：实时性要求大于安全性的要求的场景；
UDP通信流程
  • 服务端流程
    1. 创建套接字，在内存中创建一个socket结构体；
    2. 为套接字绑定地址信息（组织地址结构体），在创建套接字时，在内存中所创建的socket结构体中加入 IP + port 信息，加入 port 信息目的是为了告诉操作系统，主机接收到的很多数据中，哪些数据应该交给当前的这个socket的接收缓冲区，加入 IP 地址信息是为了确定该套接字的源端地址信息；
    3. 接收数据，客户端向服务端发送数据后，服务端根据这个数据的地址信息来确定将数据放到哪个套接字的接收缓冲区，然后进程再从与其绑定的固定端口号的socket接收缓冲区中取出数据，一般来说，服务端的地址信息是固定的，这样客户端才能准确地将信息发送给服务端，并且服务端也能准确地接收数据；
    4. 发送数据，服务端在接收到数据后，根据数据中的信息确定要发往的对端地址，然后将要发送的数据放到socket的发送缓冲区中，内核选择合适的时候封装发送；
    5. 关闭套接字，套接字是内核中的结构体，占据一定资源关闭套接字会释放内核中占用的资源；
  • 客户端流程
    1. 创建套接字，在内存中创建一个socket结构体；
    2. 为套接字绑定地址，大部分情况下会忽略该步骤，因为当客户端将数据发送出去后，服务端就会拥有你的地址信息了，并且客户端的地址信息并不需要提供给谁，所以没有必要指定特定的地址信息；
    3. 发送数据，此时客户端已经确定了服务端的 IP + port，于是向固定的服务器发送数据，在发送时若socket没有绑定地址信息，则操作系统会选择合适的地址信息进行绑定；
    4. 接收数据；
    5. 关闭套接字；
UDP通信接口
创建套接字
  • int socket(int domain, int type, int protocol);
    • domain：地址域类型，AF_INET表示 IPV4，AF_INET6表示 IPV6，AF_UNIX表示本地通信；
    • type：SOCK_STREAM——流式套接字，TCP 网络协议可用，SOCK_DGRAM——数据报套接字，UDP 网络协议可用；
    • protocol：表示本次的通信协议，在头文件中是用宏来表示的，IPPROTO_TCP（宏：6）——TCP 协议，IPPROTO_UDP（宏：17）——UDP 协议；
    • 返回值：成功创建则返回套接字文件描述符——操作句柄，失败返回 -1；
绑定地址信息
  • int bind(int sockfd, const struct sockaddr* addr, socklen_t addrlen);
    • sockfd：创建套接字所返回的操作句柄；
    • addr：当前绑定的地址信息，也就是在传入参数之前，先对该地址结构体的成员赋值（赋值指：确定地址域类型、确定端口号、确定 IP 地址），然后在传参时强转为sockaddr*类型；
    • addrlen：所绑定的地址信息的长度，也就是所使用的协议所对应的地址结构体的大小；
    • 返回值：成功返回 0，失败返回 -1；
接收数据
  • ssize_t recvfrom(int sockfd, void *buf, size_t len, int flag, struct sockaddr *src_addr, socklen_t *addrlen);
    • sockfd：创建套接字所返回的操作句柄；
    • buf：存放接收到的数据的缓冲区指针
    • len：所要接收的数据长度；
    • flag：标志位，默认为 0——阻塞接收数据，缓冲区无数据则阻塞，MSG_DONTWAIT——非阻塞接收，如果缓冲区没有数据则报错返回；
    • src_addr：获取源端地址信息，也就是通过类型强转获取到源端的地址结构体，然后从该地址结构体中拿到发送数据方的 IP + port；
    • addrlen：输入输出型参数，输入——指定要接收多大的对端地址信息结构体，输出——实际接收到的地址结构体大小；
    • 返回值：成功返回实际接收到的数据长度，失败返回 -1；
发送数据
  • ssize_t sendto(int sockfd, const void *buf, size_t len, int flag, const struct sockaddr *dest_addr, socklen_t addrlen);
    • sockfd：创建套接字所返回的操作句柄；
    • buf：要发送数据的缓冲区的首地址；
    • len：要发送数据的长度；
    • flags：标志位，默认为 0——阻塞发送，缓冲区满了则阻塞；
    • dest_addr：对端地址信息结构体，用来指定要将数据发送给谁；
    • addrlen：对端地址信息结构体的大小；
    • 返回值：成功返回实际发送的数据长度，失败返回 -1；
关闭套接字
  • int close(int sockfd);
    • sockfd：创建套接字所返回的操作句柄；
实例
  • 在实例过程中，我们在运行程序时，使用命令参数来为程序提供地址信息，例如./test.exe 192.168.122.132 9000；
使用C语言完成服务端功能
#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char* argv[]){
	//获取命令参数中的地址信息
	if(argc != 3){
		printf("Usage: ./main 192.168.122.132 9000\n");
		return -1;
	}
	//创建UDP通信的套接字
	int sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if(sockfd < 0){
		perror("socket error\n");
		return -1;
	}
	//组织一个IPV4的地址信息结构
	struct sockaddr_in addr;
	addr.sin_family = AF_INET; //地址域类型
	addr.sin_port = htons(atoi(argv[2])); //将端口从主机字节序转换为网络字节序
	//inet_addr将点分十进制ip地址转换为网络字节序ip地址
	addr.sin_addr.s_addr = inet_addr(argv[1]);
	socklen_t len = sizeof(struct sockaddr_in);
	//为服务端的套接字绑定地址信息
	int ret = bind(sockfd, (struct sockaddr*)&addr, len);
	if(ret < 0){
	  	perror("bind error");
	  	return -1;
	}
	//接下来就是开始循环接收数据、发送数据
	while(1){
		char buf[1024] = {0}; //接收数据的缓冲区
		struct sockaddr_in cliaddr; //用来保存客户端的地址信息，后面发送数据要用到
		socklen_t len = sizeof(struct sockaddr_in);
		int ret = recvfrom(sockfd, buf, 1023, 0, (struct sockaddr*)&cliaddr, &len);
		if(ret < 0){
			perror("recvfrom error");
			close(sockfd);
			return -1;
		}
		printf("client say: %s\n", buf);
		memset(buf, 0, 1024); //清空缓冲区内容，用来存放发送的数据
		scanf("%s", buf);
		len = sizeof(struct sockaddr_in);
		//发送数据
		ret = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr*)&cliaddr, len);
		if(ret < 0){
			perror("sendto error");
			close(sockfd);
			return -1;
		}
	}
	close(sockfd); //关闭套接字
}
使用C++对接口进行封装
  • 下面对 UDP 通信流程进行封装，并用封装好的类来创建客户端程序；
#include <iostream>   
#include <string>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdlib.h>
using std::string;
class UdpSocket {
public:
    //构造函数，这里其实只要对封装的套接字描述符进行初始化即可
    UdpSocket()
        :_sockfd(-1)
    {}
    ~UdpSocket(){
        Close();
    }
    //创建套接字
    bool Socket(){
        //创建IPV4网络通信的套接字
        _sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (_sockfd < 0){
            std::cerr << "socket error" << std::endl;
            return false;
        }
        return true;
    }
    //绑定本机ip地址及端口信息
    bool Bind(const string& ip, uint16_t port){
        //组织地址信息结构
        struct sockaddr_in addr;
        addr.sin_family = AF_INET; //地址域类型
        addr.sin_port = htons(port); //绑定端口信息，需要主机字节序到网络字节序的转换
        addr.sin_addr.s_addr = inet_addr(ip.c_str()); //绑定IP地址
        socklen_t len = sizeof(struct sockaddr_in);
        //绑定地址信息
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0){
            std::cerr << "bind error" << std::endl;
            return false;
        }
        return true;
    }
    //接收数据并获取对端的ip地址及端口信息
    bool Recv(string& buf, string* ip = nullptr, uint16_t* port = nullptr){
        //由于缓冲区的大小未知，缓冲区中的数据大小未知，所以我们先设置一块内存来接收数据，然后将接收的数据放到接收区中
        char tmp[4096];
        //组织地址信息结构
        struct sockaddr_in peeraddr;
        socklen_t len = sizeof(peeraddr);
        int ret = recvfrom(_sockfd, tmp, 4096, 0, (struct sockaddr*)&peeraddr, &len);
        if (ret < 0){
            std::cerr << "recvfrom error" << std::endl;
            return false;
        }
        //将数据放到接收区中
        buf.assign(tmp, ret);
        //如果不想获取数据发送方的地址信息，可以不传后面两个参数，默认为nullptr
        if (ip != nullptr) {
            *ip = inet_ntoa(addr.sin_addr);
        }
        if (port != nullptr) {
            *port = ntohs(addr.sin_port);
        }
        return true;
    }
    //发送数据
    bool Send(const string& data, const string& ip, const uint16_t& port){
        //根据传入的参数来组织接收方的地址信息结构
        struct sockaddr_in addr;
        addr.sin_family = AF_INET; //IPV4地址域类型
        addr.sin_port = htons(port); //端口从主机字节序转换为网络字节序
        addr.sin_addr.s_addr = inet_addr(ip.c_str()); //IP地址从主机字节序转换为网络字节序
        socklen_t len = sizeof(struct sockaddr_in);
        //发送数据
        int ret = sendto(_sockfd, &data[0], data.size(), 0, (struct sockaddr*)&addr, len);
        if (ret < 0){
            std::cerr << "send error" << std::endl;
            return false;
        }
        return true;
    }
    //关闭套接字
    bool Close(){
        if (_sockfd >= 0){
            close(_sockfd);
            _sockfd = -1;
        }
        return true;
    }
private:
    //该类实例化的任何一个对象都是一个socket，所以我们封装一个套接字描述符
    int _sockfd;
};


//接下来使用上面的类来创建一个客户端程序
//这里使用宏定义了一个返回值判断机制，如果返回值错误，则直接退出程序
#define CHECK_RET(q) if((q) == false){return -1;}
int main(int argc, char* argv[]){
    //接收命令参数，命令之后的两个参数分别为IP地址、端口号
    if (argc != 3){
        std::cerr << "./udp_cli serverip serverport" << std::endl;
        return -1;
    }
    //创建客户端套接字对象
    UdpSocket sock;
    //创建套接字
    CHECK_RET(sock.Socket());
    //CHECK_RET(sock.Bind("192.168.11.128", 8000));
    while (1){
        //客户端先写入要发送的数据
        std::cout << "client say: ";
        string buf;
        std::cin >> buf;
        //发送数据
        CHECK_RET(sock.Send(buf, argv[1], atoi(argv[2])));
        buf.clear();
        //对于服务端地址信息的接收可有可无，因为客户端是事先就知道服务端的地址信息的
        string ip;
        uint16_t port;
        CHECK_RET(sock.Recv(buf, &ip, &port));
        std::cout << "server say: " << buf << std::endl;
    }
    return 0;
}

TCP协议

概念
  • 概念：TCP 协议又叫传输控制协议，是在传输层的协议；
  • 特性：有连接、可靠传输、面向字节流；
  • 应用场景：安全性要求大于实时性要求的场景；
TCP通信流程
  • 服务端
    1. 创建套接字，这个套接字当做监听套接字使用；
    2. 为监听套接字绑定地址信息；
    3. 开始监听，将监听套接字置为 listen 状态，目的在于告诉系统可以处理客户端的连接请求了，从此刻开始，只要有一个新客户端连接请求，那么系统会为新客户端创建一个新的套接字，往后服务端与该客户端的通信就只靠这个套接字来完成；
    4. 获取新建连接，过程：利用监听套接字复制出新的套接字 s，然后为 s 绑定发送请求的客户端的地址信息，因为监听套接字原本就被绑定了服务端的地址信息了，所以 s 也拥有服务端的地址信息，这样一来，s 套接字就拥有了网络通信中的五元组（源端IP + 源端port + 对端IP + 对端port + TCP通信），此时就已完成建立连接了；
    5. 使用新的套接字收发数据；
    6. 一般关闭套接字的是新建的套接字，当服务端不在运行时，才会关闭监听套接字；
  • 客户端
    1. 创建套接字；
    2. 为套接字绑定地址信息，一般不绑定，等进行通信时系统会自动寻找合适的地址信息绑定；
    3. 向服务端发起连接请求，需要事先知道服务端的地址信息；
    4. 收发数据；
    5. 关闭套接字；
TCP通信接口
创建套接字
  • int socket(int domain, int type, int protocol);
    • domain：地址域类型，AF_INET表示 IPV4，AF_INET6表示 IPV6，AF_UNIX表示本地通信；
    • type：SOCK_STREAM——流式套接字，TCP 网络协议可用，SOCK_DGRAM——数据报套接字，UDP 网络协议可用；
    • protocol：表示本次的通信协议，在头文件中是用宏来表示的，IPPROTO_TCP（宏：6）——TCP 协议，IPPROTO_UDP（宏：17）——UDP 协议；
    • 返回值：成功创建则返回套接字文件描述符——操作句柄，失败返回 -1；
绑定地址信息
  • int bind(int sockfd, const struct sockaddr* addr, socklen_t addrlen);
    • sockfd：创建套接字所返回的操作句柄；
    • addr：当前绑定的地址信息，也就是在传入参数之前，先对该地址结构体的成员赋值（赋值指：确定地址域类型、确定端口号、确定 IP 地址），然后在传参时强转为sockaddr*类型；
    • addrlen：所绑定的地址信息的长度，也就是所使用的协议所对应的地址结构体的大小；
    • 返回值：成功返回 0，失败返回 -1；
服务端监听
  • int listen(int sockfd, int backlog);
    • sockfd：前面创建的用来监听的套接字描述符；
    • backlog：服务端同一时间所能处理的最大连接数，在系统中有一个已连接节点队列，用来记录那些正连接着的套接字，但是资源有限，所以队列大小有限制，backlog就是设置这个队列有多大；
    • 返回值：成功返回 0，失败返回 -1；
客户端请求连接
  • int connect(int sockfd, sockaddr* srvaddr, socklen_t addrlen);
    • sockfd：客户端套接字描述符；
    • srvaddr：服务端地址信息；
    • addrlen：服务端地址信息大小；
    • 返回值：成功返回 0，失败返回 -1；
服务端新建连接
  • int accept(int sockfd, sockaddr* srcaddr, socklen_t* len);
    • sockfd：监听套接字描述符；
    • srcaddr：输出型参数，用来获取客户端地址信息；
    • len：输入输出型参数，指定客户端地址信息长度，返回实际获取到的长度；
    • 返回值：返回新建立的套接字描述符，以后通信就靠该描述符，失败返回 -1；
接收数据
  • int recv(int sockfd, void* buf, int len, int flags);
    • sockfd：当前套接字描述符；
    • buf：接收数据的缓冲区；
    • len：要接收数据的长度；
    • flags：默认 0，阻塞接收；
    • 返回值：实际接收字节数，失败返回 -1， 连接断开返回 0；
发送数据
  • int send(int sockfd, void* buf, int len, int flags);
    • sockfd：当前套接字描述符；
    • buf：要发送数据的缓冲区；
    • len：要发送数据的长度；
    • flags：默认 0，阻塞发送；
    • 返回值：实际发送的字节数，失败返回 -1，连接主动断开方发送数据会触发 SIGPIPE 异常；
关闭套接字
  • int close(int sockfd);
    • sockfd：创建套接字所返回的操作句柄；
实例
封装TCP程序流程
#include <cstdio>                                                                         
#include <iostream>    
#include <string>    
#include <unistd.h>    
#include <arpa/inet.h>    
#include <netinet/in.h>    
#include <sys/socket.h>    
//用宏来进行函数返回值的检查，失败则直接退出程序    
#define CHECK_RET(q) if((q)==false){return -1;}    
#define LISTEN_BACKLOG 5 //TCP通信中，同一时间所能连接的最大数    
class TcpSocket {
private:
    //封装一个套接字描述符
    int _sockfd;
public:
    //构造函数
    TcpSocket() :_sockfd(-1) {}
    //创建套接字
    bool Socket() {
        //此处需要注意一下传输的方式
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0) {
            perror("socket error");
            return false;
        }
        return true;
    }
    //绑定地址信息
    bool Bind(const std::string& ip, const uint16_t port) {
        //组织地址信息结构
        sockaddr_in addr;
        addr.sin_family = AF_INET; //IPV4地址域类型
        addr.sin_port = htons(port); //端口从主机字节序转换为网络字节序
        addr.sin_addr.s_addr = inet_addr(&ip[0]); //IP地址从主机字节序转换为网络字节序
        socklen_t len = sizeof(sockaddr_in);
        //绑定地址信息
        int ret = bind(_sockfd, (sockaddr*)&addr, len);
        if (ret < 0) {
            perror("bind error");
            return false;
        }
        return true;
    }
    //服务端开始监听
    bool Listen(int backlog = LISTEN_BACKLOG) {
        //listen(描述符，同一时间最大连接数)
        int ret = listen(_sockfd, backlog);
        if (ret < 0) {
            perror("listen error");
            return false;
        }
        return true;
    }
    //客户端发送连接请求
    bool Connect(const std::string& ip, const int port) {
        //组织服务端的地址信息结构
        sockaddr_in addr;
        addr.sin_family = AF_INET;//IPV4地址域类型
        addr.sin_port = htons(port);//端口从主机字节序转换为网络字节序
        addr.sin_addr.s_addr = inet_addr(&ip[0]);//IP地址从主机字节序转换为网络字节序
        socklen_t len = sizeof(sockaddr_in);
        //connect(描述符，服务端地址， 地址长度)
        int ret = connect(_sockfd, (sockaddr*)&addr, len);
        if (ret < 0) {
            perror("connect error");
            return false;
        }
        return true;
    }
    //服务端新建连接
    bool Accept(TcpSocket* sock, std::string* ip = NULL, uint16_t* port = NULL) {
        //int accept(监听套接字， 获取客户端地址， 长度)
        sockaddr_in addr;
        socklen_t len = sizeof(sockaddr_in);
        //新创建一个套接字来建立连接
        int newfd = accept(_sockfd, (sockaddr*)&addr, &len);
        if (newfd < 0) {
            perror("accept error");
            return false;
        }
        sock->_sockfd = newfd;
        //建立连接时创建的套接字是包含五元组的，所以地址信息的接收可有可无
        if (ip != NULL) {
            *ip = inet_ntoa(addr.sin_addr);
        }
        if (port != NULL) {
            *port = ntohs(addr.sin_port);
        }
        return true;
    }
    //接收数据
    bool Recv(std::string* buf) {
        //int recv(描述符，空间，数据长度，标志位)
        //返回值：实际获取大小， 0-连接断开； -1-出错了
        char tmp[4096] = { 0 };
        //接收数据
        int ret = recv(_sockfd, tmp, 4096, 0);
        if (ret < 0) {
            perror("recv error");
            return false;
        }
        //如果返回 0，则说明连接断开了
        else if (ret == 0) {
            printf("peer shutdown");
            return false;
        }
        //使用临时空间接收数据，然后再传给接收区，这样可以保证接收区不会被创建的很大，而临时空间接着就会被销毁
        buf->assign(tmp, ret);
        return true;
    }
    //发送数据
    bool Send(const std::string& data) {
        //int send(描述符，数据，长度，标志位)
        //TCP是字节流传输，所以可能数据没有一次性发送完毕，所以需要循环发送
        //total记录了总共发送了多少字节数据
        int total = 0;
        //如果总共发送的数据比数据实际大小要小，则需要继续发送
        while (total < data.size()) {
            //发送数据
            int ret = send(_sockfd, &data[0] + total, data.size() - total, 0);
            if (ret < 0) {
                perror("send error");
                return false;
            }
            //累加总共发送了多少数据
            total += ret;
        }
        return true;
    }
    //关闭套接字
    bool Close() {
        if (_sockfd != -1) {
            close(_sockfd);
        }
        return true;
    }
};
客户端程序
#include "tcpsocket.hpp"                                                                    
    
int main(int argc, char *argv[])    {    
    //通过命令参数传入要连接的服务端的地址信息    
    if (argc != 3) {    
        printf("usage: ./tcp_cli srvip srvport\n");    
        return -1;    
    }    
    std::string srvip = argv[1]; //第一个命令参数为IP地址
    uint16_t srvport = std::stoi(argv[2]); //第二个命令参数为端口号
    TcpSocket cli_sock;    
    //1. 创建套接字    
    CHECK_RET(cli_sock.Socket());    
    //2. 绑定地址信息，客户端不推荐绑定地址信息 
    //3. 向服务端发起连接请求
    CHECK_RET(cli_sock.Connect(srvip, srvport));    
    while(1) {    
        //4. 收发数据    
        std::string buf;    
        std::cout << "client say: ";    
        std::cin >> buf;    
        CHECK_RET(cli_sock.Send(buf));    
        buf.clear();    
        CHECK_RET(cli_sock.Recv(&buf));    
        std::cout << "server say: " << buf << std::endl;    
    }    
    //5. 关闭套接字    
    CHECK_RET(cli_sock.Close());    
    return 0;    
}
服务端程序
  • 首先我们知道 TCP 通信是需要建立连接的，也就是一对一进行通信，那么如果在服务端只用一个循环来建立多个连接，会有什么情况呢？
    在这里插入图片描述
  • 所以我们需要对于上面的情况做出处理，上面的问题就是一个执行流程不能完成多连接任务，所以可以考虑多执行流程序来解决该问题，而多执行流也有两种方法来实现：多线程、多进程；
  • 多线程程序：多线程中主线程与子线程资源是共享的，所以在主线程中不需要关闭子线程的套接字，否则会出错，另外要么thread_join等待线程退出，要么将线程属性设置为detach，这样可以避免资源泄露；
#include "tcpsocket.hpp"                                                                    
#include <pthread.h>    
//线程执行接口，在其中进行收发数据，参数传入的是套接字对象指针
void *thr_entry(void *arg)    {    
    bool ret;    
    //获取套接字对象指针
    TcpSocket *clisock = (TcpSocket*)arg;
    //循环收发数据    
    while(1) {    
        //5. 收发数据--使用获取的新建套接字进行通信    
        std::string buf;    
        ret = clisock->Recv(&buf);    
        //接收数据失败的话，那么就关闭该套接字，并结束该线程（并不影响主线程的监听套接字）
        if (ret == false) {    
            clisock->Close();    
            delete clisock;    
            return NULL;    
        }    
        //成功就把数据打印出来
        std::cout << "client say: " << buf << std::endl;    
        buf.clear();    
        //然后进行数据回复
        std::cout << "server say: ";    
        std::cin >> buf;    
        ret = clisock->Send(buf);    
        //如果回复数据失败也将套接字关闭，并结束该线程
        if (ret == false) {    
            clisock->Close();    
            delete clisock;    
            return NULL;    
        }    
    }    
    //最终结束时关闭套接字
    clisock->Close();    
    delete clisock;    
    return NULL;    
}    
int main(int argc, char *argv[])    {    
    //通过程序运行参数指定服务端要绑定的地址
    // ./tcp_srv 192.168.2.2 9000
    if (argc != 3) {
        printf("usage: ./tcp_src 192.168.2.2 9000\n");
        return -1;
    }
    std::string srvip = argv[1];
    uint16_t srvport = std::stoi(argv[2]);
    TcpSocket lst_sock;//监听套接字
    //1. 创建套接字
    CHECK_RET(lst_sock.Socket());
    //2. 绑定地址信息
    CHECK_RET(lst_sock.Bind(srvip, srvport));
    //3. 开始监听
    CHECK_RET(lst_sock.Listen());
    while(1) {
        //4. 获取新建连接，创建新的套接字
        TcpSocket *clisock = new TcpSocket();
        std::string cliip;
        uint16_t cliport;
        bool ret = lst_sock.Accept(clisock, &cliip,&cliport);
        if (ret == false) {
            continue;
        }
        std::cout<<"get newconn:"<< cliip<<"-"<<cliport<<"\n";
        //创建线程专门负责与指定客户端的通信
        pthread_t tid;
        pthread_create(&tid, NULL, thr_entry, (void*)clisock);
        pthread_detach(tid);
    }
    //6. 关闭套接字
    lst_sock.Close();
}
  • 多进程程序：由于父进程与子进程之间资源独有，所以在创建新的套接字之后，父子进程中都回有一份，但是父进程中的那个套接字描述符我们用不到，所以需要将它关闭，另外我们还要关注子进程的退出，等待子进程退出或者显示忽略子进程的退出，可以避免子进程成为僵尸进程；
#include "tcpsocket.hpp"                                                                  
#include <signal.h>    
#include <sys/wait.h>    
//信号处理函数，用来处理进程退出之后发给父进程的信号
void sigcb(int no){    
    while(waitpid(-1, NULL, WNOHANG) > 0);    
}    
//进程工作函数
void worker(TcpSocket &clisock){  //child process    
    bool ret;    
    while(1) {    
        //5. 收发数据--使用获取的新建套接字进行通信    
        std::string buf;    
        ret = clisock.Recv(&buf);    
        if (ret == false) {    
            clisock.Close();    
            exit(0);    
        }    
        std::cout <<"client say: "<<buf<<std::endl;    
        buf.clear();    
        std::cout << "server say: ";    
        std::cin >> buf;    
        ret = clisock.Send(buf);    
        if (ret == false) {    
            clisock.Close();    
            exit(0);    
        }    
    }    
    clisock.Close();//释放的是子进程的clisock    
    exit(0);    
    return;    
}    
int main(int argc, char *argv[]){    
    //通过程序运行参数指定服务端要绑定的地址    
    // ./tcp_srv 192.168.2.2 9000
    if (argc != 3) {
        printf("usage: ./tcp_src 192.168.2.2 9000\n");
        return -1;
    }
    //以下为两种进程退出信号的处理方式
    signal(SIGCHLD, SIG_IGN); //直接将退出信号置为显式忽略
    signal(SIGCHLD, sigcb); //使用信号处理函数来等待进程退出
    std::string srvip = argv[1];
    uint16_t srvport = std::stoi(argv[2]);
    TcpSocket lst_sock;//监听套接字
    //1. 创建套接字
    CHECK_RET(lst_sock.Socket());
    //2. 绑定地址信息
    CHECK_RET(lst_sock.Bind(srvip, srvport));
    //3. 开始监听
    CHECK_RET(lst_sock.Listen());
    while(1) {
        //4. 获取新建连接，创建新的套接字
        TcpSocket clisock;
        std::string cliip;
        uint16_t cliport;
        bool ret = lst_sock.Accept(&clisock, &cliip,&cliport);
        if (ret == false) {
            continue;
        }
        std::cout<<"get newconn:"<< cliip<<"-"<<cliport<<"\n";
        pid_t pid = fork();
        //如果进程创建失败，则关闭该套接字
        if (pid < 0) {
            clisock.Close();                                                              
            continue;
        }
        //子进程中执行循环数据收发
        else if (pid == 0) {
            worker(clisock);
        }
        //父子进程数据独有，父进程关闭不会对子进程造成影响，不关闭反而会导致套接字描述符资源减少
        clisock.Close();//释放的是父进程中的clisock
    }
    //6. 关闭套接字
    lst_sock.Close();
}
bfsm
关注
专栏目录
Linux------网络套接字编程（二）
xiaobai_hellow的博客
06-19 784
由于TCP的协议的服务，他是提供一个可靠的，面向字节流，有连接的传输服务，所以他与UDP协议是有部分不同的，但是还是右部分是相同的。具体工作的步骤如下：1.TCP服务端通信服务的步骤：2.TCP客户端通信的操作步骤：TCP通信程序的函数接口和UDP通信程序的函数接口有相同的也有不同的，如下： 1.创建套接字： 其中：domain：地址域类型，由于我们目前学习是IPV4地址域类型，所以填写AF_INET。type：数据传输方式，因为是TCP协议的通信，所以需要的可以提供面向字节流，可靠的，基于连接的流式套接字
linux系统编程——套接字相关API学习
qq_45652092的博客
09-10 282
socket(协议方案，数据流/快形式，附加协议)函数介绍： #include<sys/types.h> #include<sys/socket.h> int socket(int domain, int type, int protocol);//设置网络协议创建一个句柄，成功调用返回套接字描述符，失败返回错误码 domain参数指明所使用的协议族，通常为AF_INET，表示互联网协议族（TCP/IP协议族）；通信协议族在文件sys/socket.h中定义。 AF_INE
Linux套接字
热门推荐
取而代之的专栏
05-04 1万+
套接字是一种通信机制，凭借这种机制，客户/服务器系统的开发工作既可以在本地单机上进行，也可以跨网络进行。 套接字的特性有三个属性确定，它们是：域（domain），类型（type），和协议（protocol）。套接字还用地址作为它的名字。地址的格式随域（又被称为协议族，protocol family）的不同而不同。每个协议族又可以使用一个或多个地址族定义地址格式。 1.套接字的域 域指定套接字
【Linux网络编程】02---网络编程套接字---socket编程常用接口
最新发布
RO-BERRY
08-12 1065
🍁你好，我是📗 致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识。
网络套接字
m346759541的专栏
08-27 721
Linux网络编程 套接字     一：概述     Socket 的英文原意就是“孔”或“插座”，现在，作为BSD UNIX 的进程通讯机制，取其后一种意义。日常生活中常见的插座，有的是信号插座，有的是电源插座，有的可以接受信号（或能量），有的可以发送信号（或能量）。假如电话线与电话机之间安放一个插座（相当于二者之间的接口，这一部分装置物理上是存在的）则Socket 非常相似于电话插座。     将电话系统与面向连接的Socket 机制相比，有着惊人相似的地方。以一个国家级的电话网为例。电话的通话双
Linux-网络编程套接字
yummy_alice的博客
06-29 148
理解源IP地址和目的IP地址 在IP数据报头部中，有两个IP地址，分别叫做源IP地址和目的IP地址。 认识端口号 端口号是传输层协议的内容 端口号是一个2字节十六位的整数 端口号用来标识一个进程，告诉操作系统，当前的这个数据要交给哪一个进程来处理； IP地址+端口号能被标识网络上的某一台主机的某一个进程 一个端口号只能被一个进程占用 一个进程可以绑定多个端口号，但是一个端口号不能被...
Linux进程间通信——使用流套接字
09-15
【Linux进程间通信——使用流套接字】这篇文章主要介绍了如何利用socket进行进程间通信，尤其是跨网络的通信。Socket，又称套接字，是一种通信机制，它允许不同计算机或同一计算机上的进程通过网络进行通信。以下是...
Linux——网络编程套接字
m0_46657980的博客
01-11 250
1.UDP协议 UDP：用户数据报协议，不可靠的传输通信协议，应用于实时性要求大于安全性的场景——视频/音频数据传输 特点：无连接，不可靠，面向数据报 简单的UDP网络程序实现以及接口 网络通信程序的编写都使用的是套接字接口——socket接口 客户端：主动发起请求的一方，用户的一端 服务端：被动接受请求的一方，向用户提供服务的一端 在通信时，客户端的主要工作为： （1）创建套接字，使进程与网卡之间建立联系 （2）为套接字绑定地址信息，每条数据中都有源端地址和对端地址，绑定的地址信息就是源
python套接字编程_Python套接字编程（1）——socket模块与套接字编程
weixin_36223355的博客
12-24 541
在Python网络编程系列，我们主要学习以下内容：5. 常见的Python异步编程框架6. 协程在Python网络编程中的使用本文介绍Python下的基本套接字编程，主要基于 socket 模块，包括简单的TCP/UDP套接字编程。通过调用 socket 模块的 socket() 函数创建一个新的套接字对象，在创建套接字时需要指定新 socket 对象使用的地址族和套接字类型，下文将分别予以介绍。...
linux套接字
封茗世香
03-26 1913
套接字（Socket）是一种用于在计算机之间进行通信的软件组件或接口。它提供了一种标准化的方式，使得应用程序能够通过网络连接进行相互之间的通信。在计算机网络中，每台计算机都有一个唯一的IP地址，用于标识这台计算机。当应用程序需要在网络上进行通信时，它们可以使用套接字来建立连接并进行数据交换。套接字可以使用不同的传输协议，例如TCP和UDP，以实现不同的通信需求。套接字有两种类型：客户端套接字和服务器套接字。客户端套接字通常用于向服务器请求服务，而服务器套接字则用于接受客户端的请求并提供服务。
Linux编程---套接字
G11176593的博客
10-20 559
函数会为第一个參数建立一个连接请求的侦听队列,然后这个队列就会成为一个server套接字,也叫被动套接字.第二个參数则是用来设置其队列的最大长度的.假设设置的值大于系统规定的最大限制值时,这样的情况下,当侦听队列的连接请求超过系统的限制值时,系统会自己主动的截断backlog的值为系统最大值.假设设置为小于0,则自己主动设置为0。前几个參数基本上和recv和send差点儿相同.没什么太多说的.后面的參数添加了发送和接受的地址和其长度.当中recv得到的地址是发送方的.sendto得到的地址是对方的.
Linux下套接字详解（四）----简单的TCP套接字应用（迭代型）
OSKernelLAB(gatieme)
06-07 5558
前面我们已经将了TCP/UDP的基本知识，还说了并发服务器与迭代服务器的区别，我们大致了解大多数TCP服务器是并发的，大多数UDP服务器是迭代的 ，即我们在进行数据传送的时候，往往使用服务器与客户但之间无连接的UDP报文，但是在用户需要上传下载文件时，就会在客户端和服务器之间建立一条TCP连接，进行文件的传送 那么我们下面就来实现一个简单的TCP服务器。TCP套接字编程模型图我们首先看一下TCP客
Linux网络编程套接字
qq_56663697的博客
04-14 2697
文章目录预备知识理解源IP地址和目的IP地址理解 "端口号" 和 "进程ID"理解源端口号和目的端口号认识TCP协议认识UDP协议网络字节序点分十进制IP和uint32_t整数相互转换 预备知识 理解源IP地址和目的IP地址 在IP数据包头部中, 有两个IP地址, 分别叫做源IP地址, 和目的IP地址 源IP地址： 表示该条信息来源于哪个机器。 目的IP地址： 表示该条信息去往于哪个进程 理解 “端口号” 和 “进程ID” 我们之前在学习系统编程的时候, 学习了 pid 表示唯一一个进程; 此处我们的端口号
Linux网络编程之套接字
baobao1767640830的博客
05-19 674
预备知识 1、了解IP地址 1）IP协议有两个版本，IPv4和IPv6，现在用得比较多的是IPv4。 2）IP地址是在IP协议中用来标识网络中不同主机的地址。 3）对于IPv4版本来说，IP地址是一个4字节，32位的整数。 4）通常使用“点分十进制”的字符串表示IP地址，例如：“192.168.181.129”，其中用点分割的每一个数字表示一个字节，范围为0-255。 5）在IP数据报头部，有两个IP地址，分别叫做原IP地址和目的IP地址。 IP地址能够把信息发送到对方的机器上，但是还需要一个其他的标识符来
linux - 套接字编程
sYstemk1t
12-13 552
文章目录套接字编程socket函数connect函数bind函数listenaccept函数 套接字编程 套接字，也叫socket，是操作系统内核中的一个数据结构，它是网络中的节点进行相互通信的门户。网络通信，说白了就是进程间的通信（同一台机器上不同进程或者不同计算机上的进程间通信）。 在网络中，每一台计算机或者路由都有一个网络地址，就是IP地址。两个进程通信时，首先要确定各自所在的网络节点的网络地址。但是，网络地址只能确定进程所在的计算机，而一台计算机上一般都是同时运行着多个进程，所以仅凭网络地址还不能确
Linux网络编程笔记 - 08 创建套接字
我思故我在！
11-07 237
#include <sys/socket.h> int socket(int domain, int type, int protocol); 功能：创建一个socket套接字 创建缓冲区，缓冲区为文件描述符fd Name Purpose Man page AF_UNIX, AF_LOCAL Local communication unix(7) ..
Linux创建套接字和绑定套接字
qq_42108074的博客
05-06 559
【代码】Linux网络编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值