• 1.5.C++项目:仿muduo库实现并发服务器之socket模块的设计


    项目完整版在:

    一、socket模块:套接字模块

    在这里插入图片描述

    二、提供的功能

    Socket模块是对套接字操作封装的一个模块,主要实现的socket的各项操作。

    socket 模块:套接字的功能
    创建套接字
    绑定地址信息
    开始监听
    向服务器发起连接
    获取新连接
    接受数据
    发送数据
    关闭套接字
    创建一个监听链接
    创建一个客户端连接
    设置套接字选项——开启地址端口重用!
    设置套接字阻塞属性——设置为非阻塞!
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    三、实现思想

    (一)功能

    对socket套接字的操作进行封装。

    (二)意义

    对socket套接字的操作进行封装。

    (三)功能设计

    1. 创建套接字
    2. 绑定地址信息
    3. 开始监听
    4. 向服务器发起连接
    5. 获取新连接
    6. 接受数据
    7. 发送数据
    8. 关闭套接字
    9. 创建一个监听链接
    10. 创建一个客户端连接

    四、代码

    #define MAX_LISTEN 1024
    class Socket {
            private:
                    int _sockfd;
            public:
                    Socket() :_sockfd(-1) {}
                    Socket(int fd) : _sockfd(fd) {} 
                    ~Socket() {Close(); }
                    int fd() {return _sockfd;}
                    // 1.创建套接字
                    bool Create() {
                    
                            //int socket (int domain,int type,int protocol);
                            _sockfd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
                            if (_sockfd < 0) {
                                    ERR_LOG("CREATE SOCKET FAILED !!");
                                    return false;
                            }
                            return true;
                    } 
                    // 2.绑定地址信息
                    bool Bind(const std::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());
                            socklen_t len = sizeof(struct sockaddr_in);
                            // int bind(int sockfd,struct sockaddr * addr,socklen_t len);
                            int ret = bind(_sockfd,(struct sockaddr*)&addr,len);
                            if (ret < 0) {
                                    ERR_LOG("BIND ADDRESS FAILED!!!!");
                                    return false;
                            }
                            return true;
                    }
                     // 3.开始监听
                    bool Listen(int backlog = MAX_LISTEN) {
                            // int listen(int backlog)
                            int ret = listen(_sockfd,backlog);
                            if (ret < 0) {
                                    ERR_LOG("SOCKET LISTEN FAILED!!");
                                    return false;
                            }
                            return true;
                    }
                     // 4. 向服务器发起连接
                    bool Connect(const std:: 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());
                            socklen_t len = sizeof(struct sockaddr_in);
                            // int bind(int sockfd,struct sockaddr * addr,socklen_t len);
                            int ret = connect(_sockfd,(struct sockaddr*)&addr,len);
                            if (ret < 0) {
                                    ERR_LOG("CONNECT ADDRESS FAILED!!!!");
                                    return false;
                            }
                            return true;
                    } 
                    // 5. 获取新连接
                    int Accept() {
                    
                            // int accept(int sockfd,struct sockaddr* addr,socklen_t *len) /
                            int newfd = accept(_sockfd,NULL,NULL);
                            if (newfd < 0) {
                                    ERR_LOG("SOCKET ACCEPT FAILED!!!!");
                                    return false;
                            }
                            return newfd;
                    }
                    ssize_t Recv(void *buf,size_t len,int flag = 0){
                            // 6.接收数据
                            //有符号长整型 
                            //ssize_t Recv(int sockfd,void* buf,size_t len,int flag);
                            ssize_t ret = recv(_sockfd,buf,len,flag);
                            if (ret <= 0) {
                                    // EAGAIN 当前socket的接收缓冲区没有数据来,在非阻塞二点情况下才会有这个错误
                                    // ENTER 当前socket的阻塞等待,被信号打断了
                                    if (errno == EAGAIN || errno == EINTR) {
                                            return 0; // 没收到数据
                                    }
                                    ERR_LOG("SOCKET RECV FAILED!!");
                                    return -1; // 出错
                            }
                            return ret;
                    }
                    ssize_t nonBlockRecv(void* buf,size_t len) {
                            return Recv(buf,len,MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接受为非阻塞
                    }
    	        // 7.发送数据
                    ssize_t Send(const void* buf,size_t len,int flag = 0) {
                            // ssize_t send(int sockfd,void *data,size_t len,int flag) 
                            ssize_t ret = send(_sockfd,buf,len,flag);
                            if (ret < 0) {
                                    ERR_LOG("SOCKET SEND FAILED!!");
                                    return -1; // 出错
                            }
                            return ret; // 实际发送数据长度!!
                    }
                    ssize_t nonBlockSend(void* buf,size_t len) {
                            return Send(buf,len,MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接受为非阻塞
                    }
    	        // 8.关闭套接字
                    void Close() {
                            if (_sockfd != -1) {
                                    close(_sockfd);
                                    _sockfd = -1;
                            }
                    
                    }
    	        // 9.创建一个服务端链接
                    bool createServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) {
                            // 1.创建套接字 2. 绑定地址 3.开始监听 4.设置非阻塞 5.启动地址重用
                            if (Create() == false) return false;
                            if (Bind(ip,port) == false) return false;
                            if (Listen() == false) return false;
                           if (block_flag) NonBlock();
                            ReuseAddress();
                            return true;
                    }
                    // 10.创建一个客户端链接 
                    bool createClient(uint16_t port, const std::string &ip) {
                            if (Create() == false) return false;
                            if (Connect(ip,port) == false) return false;
                            return true;
                    }
    
                    // 11. 设置套接字选项——开启地址端口重用!
                    void ReuseAddress() {
                            // int setsockopt(int fd,int leve,int optname,void *val,int vallen)
                            int val = 1;
                            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
                            val = 1;
                            setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
                    }
                    // 12. 设置套接字阻塞属性——设置为非阻塞! 
                    void NonBlock() {
                            int flag = fcntl(_sockfd, F_GETFL, 0);
                            fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
                    }
    
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145

    五、测试

    (一)tcp_cli.cc

    #include "../source/server.hpp"
    
    int main() {
        Socket cli_sock;
        cli_sock.createClient(8500,"127.0.0.1");
        std::string str = "nihao";
        cli_sock.Send(str.c_str(),str.size());
        char buf[1024] = {0};
        cli_sock.Recv(buf,1023);
        DBG_LOG("%s",buf);
        return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    (二)tcp_srv.cc

    #include "../source/server.hpp"
    
    int main() {
        Socket lst_sock;
        bool ret = lst_sock.createServer(8500);
        while (1) {
            int newfd = lst_sock.Accept();
            if (newfd < 0) {
                continue;
            }
            Socket cli_sock(newfd);
            char buf[1024] = {0};
            int ret = cli_sock.Recv(buf,1023);
                if(ret < 0) {
                cli_sock.Close();
            }
            cli_sock.Send(buf,ret);
            cli_sock.Close();
        }
        lst_sock.Close();
        return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    (三)makefile

    all:client server
    client:tcp_cli.cc
    	g++ -std=c++11 $^ -o $@
    server:tcp_srv.cc
    	g++ -std=c++11 $^ -o $@
    
    • 1
    • 2
    • 3
    • 4
    • 5
  • 相关阅读:
    taro整体架构简析
    hadoop集群安装(一):创建模型虚拟机
    服务端请求伪造(SSRF)及漏洞复现
    肉豆蔻酰五肽-8/Myristoyl Pentapeptide-8/sympeptide222
    postgis函数学习
    Android移动安全攻防实战 第二章
    Hash Table Mock
    弱监督点云分割(论文解读:CVPR2020)
    SwiftUI 4.0 如何轻松在 iOS 16 中设置 TextEditor 背景色
    HTML5期末大作业:美妆网页主题网站设计——清新的手工肥皂网站展示(4页)HTML+CSS+JavaScript
  • 原文地址:https://blog.csdn.net/weixin_54447296/article/details/133435778