当前位置： 首页 > article >正文

计算机网络socket编程(6)_TCP实网络编程现 Command_server

article 2024/11/25 5:14:12

个人主页：C++忠实粉丝
欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 C++忠实粉丝 原创

计算机网络socket编程(6)_TCP实网络编程现 Command_server

收录于专栏【计算机网络】
本专栏旨在分享学习计算机网络的一点学习笔记，欢迎大家在评论区交流讨论💌   

目录

功能介绍 

1. InetAddr.hpp

2. LockGuard.hpp

3. Log.hpp

4. Command.hpp

5. TcpServer.hpp

6. TcpServerMain.cc

7. TcpClientMain.cc

功能介绍 

和上回 TCP 网络编程一样, 实现简单的 Command_server

还有就是网络编程代码真的是又多又杂, 有的时候我自己都烦, 没办法网络部分就是这样的, 我最近会尽快更完这个 socket 编程, 提早进入概念部分, 一直编程感觉少了什么~ 还得跟概念结合起来看, 感兴趣的宝子们不要忘记了点赞关注哦! 我现在在网络部分真的待不了一点, 希望我能尽快挣脱网络, 更新数据库 MySQL 的东西吧!  

1. InetAddr.hpp

 老演员了, InetAddr 类封装了 IP 地址和端口号，提供了转换网络字节序和主机字节序的方法，支持比较、获取 IP 地址、端口号、地址字符串等功能。这个类的设计是典型的用于网络编程，特别是在处理 IPv4 地址时非常有用。

#pragma once

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

class InetAddr
{
private:
    void ToHost(const struct sockaddr_in &addr)
    {
        _port = ntohs(addr.sin_port);
        // _ip = inet_ntoa(addr.sin_addr);
        char ip_buf[32];
        // inet_p to n
        // p: process
        // n: net
        // inet_pton(int af, const char *src, void *dst);
        // inet_pton(AF_INET, ip.c_str(), &addr.sin_addr.s_addr);
        ::inet_ntop(AF_INET, &addr.sin_addr, ip_buf, sizeof(ip_buf));
        _ip = ip_buf;
    }

public:
    InetAddr(const struct sockaddr_in &addr):_addr(addr)
    {
        ToHost(addr);
    }
    InetAddr()
    {}
    bool operator == (const InetAddr &addr)
    {
        return (this->_ip == addr._ip && this->_port == addr._port);
    }
    std::string Ip()
    {
        return _ip;
    }
    uint16_t Port()
    {
        return _port;
    }
    struct sockaddr_in Addr()
    {
        return _addr;
    }
    std::string AddrStr()
    {
        return _ip + ":" + std::to_string(_port);
    }
    ~InetAddr()
    {
    }

private:
    std::string _ip;
    uint16_t _port;
    struct sockaddr_in _addr;
};

2. LockGuard.hpp

老演员 +1, LockGuard 类是一个封装了互斥锁的RAII对象，提供了简化的锁管理功能。它确保在对象生命周期结束时自动释放锁，从而避免了忘记解锁和潜在的死锁问题。它特别适用于多线程程序中对共享资源的保护，能显著提高代码的可读性和可靠性。 

#pragma once

#include <pthread.h>

class LockGuard
{
public:
    LockGuard(pthread_mutex_t *mutex):_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }
    ~LockGuard()
    {
        pthread_mutex_unlock(_mutex);
    }
private:
    pthread_mutex_t *_mutex;
};

3. Log.hpp

 老演员+1, 这段代码是一个 C++ 日志系统的实现，它提供了日志记录功能，可以将日志输出到屏幕或写入文件。系统使用了互斥锁（pthread_mutex_t）来保证日志输出的线程安全，并且提供了多种日志级别（DEBUG, INFO, WARNING, ERROR, FATAL）。

#pragma once

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <ctime>
#include <cstdarg>
#include <fstream>
#include <cstring>
#include <pthread.h>
#include "LockGuard.hpp"

namespace log_ns
{

    enum
    {
        DEBUG = 1,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };

    std::string LevelToString(int level)
    {
        switch (level)
        {
        case DEBUG:
            return "DEBUG";
        case INFO:
            return "INFO";
        case WARNING:
            return "WARNING";
        case ERROR:
            return "ERROR";
        case FATAL:
            return "FATAL";
        default:
            return "UNKNOWN";
        }
    }

    std::string GetCurrTime()
    {
        time_t now = time(nullptr);
        struct tm *curr_time = localtime(&now);
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "%d-%02d-%02d %02d:%02d:%02d",
                 curr_time->tm_year + 1900,
                 curr_time->tm_mon + 1,
                 curr_time->tm_mday,
                 curr_time->tm_hour,
                 curr_time->tm_min,
                 curr_time->tm_sec);
        return buffer;
    }

    class logmessage
    {
    public:
        std::string _level;
        pid_t _id;
        std::string _filename;
        int _filenumber;
        std::string _curr_time;
        std::string _message_info;
    };

#define SCREEN_TYPE 1
#define FILE_TYPE 2

    const std::string glogfile = "./log.txt";
    pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;

    // log.logMessage("", 12, INFO, "this is a %d message ,%f, %s hellwrodl", x, , , );
    class Log
    {
    public:
        Log(const std::string &logfile = glogfile) : _logfile(logfile), _type(SCREEN_TYPE)
        {
        }
        void Enable(int type)
        {
            _type = type;
        }
        void FlushLogToScreen(const logmessage &lg)
        {
            printf("[%s][%d][%s][%d][%s] %s",
                   lg._level.c_str(),
                   lg._id,
                   lg._filename.c_str(),
                   lg._filenumber,
                   lg._curr_time.c_str(),
                   lg._message_info.c_str());
        }
        void FlushLogToFile(const logmessage &lg)
        {
            std::ofstream out(_logfile, std::ios::app);
            if (!out.is_open())
                return;
            char logtxt[2048];
            snprintf(logtxt, sizeof(logtxt), "[%s][%d][%s][%d][%s] %s",
                     lg._level.c_str(),
                     lg._id,
                     lg._filename.c_str(),
                     lg._filenumber,
                     lg._curr_time.c_str(),
                     lg._message_info.c_str());
            out.write(logtxt, strlen(logtxt));
            out.close();
        }
        void FlushLog(const logmessage &lg)
        {
            // 加过滤逻辑 --- TODO

            LockGuard lockguard(&glock);
            switch (_type)
            {
            case SCREEN_TYPE:
                FlushLogToScreen(lg);
                break;
            case FILE_TYPE:
                FlushLogToFile(lg);
                break;
            }
        }
        void logMessage(std::string filename, int filenumber, int level, const char *format, ...)
        {
            logmessage lg;

            lg._level = LevelToString(level);
            lg._id = getpid();
            lg._filename = filename;
            lg._filenumber = filenumber;
            lg._curr_time = GetCurrTime();

            va_list ap;
            va_start(ap, format);
            char log_info[1024];
            vsnprintf(log_info, sizeof(log_info), format, ap);
            va_end(ap);
            lg._message_info = log_info;

            // 打印出来日志
            FlushLog(lg);
        }
        ~Log()
        {
        }

    private:
        int _type;
        std::string _logfile;
    };

    Log lg;

#define LOG(Level, Format, ...)                                        \
    do                                                                 \
    {                                                                  \
        lg.logMessage(__FILE__, __LINE__, Level, Format, ##__VA_ARGS__); \
    } while (0)
#define EnableScreen()          \
    do                          \
    {                           \
        lg.Enable(SCREEN_TYPE); \
    } while (0)
#define EnableFILE()          \
    do                        \
    {                         \
        lg.Enable(FILE_TYPE); \
    } while (0)
};

4. Command.hpp

这个代码实现了一个简单的命令执行器，允许客户端通过网络发送命令并执行，同时对命令进行安全检查，确保执行的是在白名单中的安全命令。 

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <set>
#include "Log.hpp"
#include "InetAddr.hpp"

class Command
{
public:
    Command()
    {
        // 白名单
        _safe_command.insert("ls");
        _safe_command.insert("touch"); // touch filename
        _safe_command.insert("pwd");
        _safe_command.insert("whoami");
        _safe_command.insert("which"); // which pwd
    }
    ~Command() {}
    // ls;rm -rf /
    bool SafeCheck(const std::string &cmdstr)
    {
        for(auto &cmd : _safe_command)
        {
            if(strncmp(cmd.c_str(), cmdstr.c_str(), cmd.size()) == 0)
            {
                return true;
            }
        }

        return false;
    }
    std::string Excute(const std::string &cmdstr)
    {
        if(!SafeCheck(cmdstr))
        {
            return "unsafe";
        }
        std::string result;
        FILE *fp = popen(cmdstr.c_str(), "r");
        if(fp)
        {
            char line[1024];
            while(fgets(line, sizeof(line), fp))
            {
                result += line;
            }
            return result.empty() ? "success" : result;
        }
        return "execute error";
    }
    void HandlerCommand(int sockfd, InetAddr addr)
    {
        // 我们把他当做一个长服务
        while (true)
        {
            char commandbuf[1024]; // 当做字符串, ls -a -l -> os --> ls -
            ssize_t n = ::recv(sockfd, commandbuf, sizeof(commandbuf) - 1, 0); // TODO
            if (n > 0)
            {
                commandbuf[n] = 0;
                LOG(INFO, "get command from client %s, command: %s\n", addr.AddrStr().c_str(), commandbuf);
                std::string result = Excute(commandbuf);
                ::send(sockfd, result.c_str(), result.size(), 0);
            }
            else if (n == 0)
            {
                LOG(INFO, "client %s quit\n", addr.AddrStr().c_str());
                break;
            }
            else
            {
                LOG(ERROR, "read error: %s\n", addr.AddrStr().c_str());
                break;
            }
        }
    }
private:
    std::set<std::string> _safe_command;
};

Command 构造函数

构造函数初始化时，构建了一个白名单 safe_command，该白名单包括允许执行的命令。只有这些命令可以在后续的调用中被安全地执行。

"ls"：列出目录内容。

"touch"：创建空文件（命令格式如 touch filename）。

"pwd"：显示当前工作目录。

"whoami"：显示当前用户。

"which"：显示命令的完整路径。

这些命令一般是无害的，可以允许远程执行。其他的命令（例如 rm -rf /）则会被拒绝。

SafeCheck 函数

这个函数用于检查命令是否安全。它遍历白名单中的每个命令，使用 strncmp 判断是否有命令前缀匹配。如果有匹配的命令前缀（例如 ls -l），则认为这个命令是安全的，返回 true，否则返回 false。

strncmp 的作用：strncmp 比较两个字符串的前 n 个字符，cmd.size() 是匹配的字符长度，因此如果 cmdstr 以白名单命令的某个前缀开始，它将被认为是一个安全命令

Excute 函数

这个函数用于执行实际的命令。首先，它会调用 SafeCheck 函数来确保命令是安全的。如果命令不在白名单中，返回 "unsafe"。

如果命令安全，它通过 popen 调用操作系统的命令行执行命令，并读取命令输出：

popen(cmdstr.c_str(), "r") 会执行命令，并返回一个文件指针，可以通过它读取命令的标准输出。

使用 fgets 一行一行地读取命令输出，直到没有输出为止。

最后将结果返回。如果命令有输出，则返回输出内容；如果命令没有输出，则返回 "success"。

如果执行命令时发生错误（例如，popen 失败），返回 "execute error"。

HandlerCommand 函数

这个函数处理与客户端的交互。它是一个长连接服务，持续接收和处理客户端发送的命令。

工作流程：

使用 recv 函数接收来自客户端的命令，存储在 commandbuf 中。recv 会返回接收到的字节数，如果接收到有效数据（n > 0），继续处理。

通过 LOG(INFO, ...) 记录从客户端接收到的命令。

使用 Excute 函数执行命令并获取执行结果。

使用 send 将命令的执行结果返回给客户端。

如果接收到的数据为 0（即客户端关闭连接），则记录日志并结束循环。

如果发生读取错误（n < 0），记录错误日志并结束循环。

这个方法基本上是一个长连接的服务器循环，不断接收和执行命令，直到客户端断开连接或发生错误。

5. TcpServer.hpp

这段代码实现了一个基本的 TCP 服务器 类 (TcpServer)，通过多线程处理客户端的连接。 

#pragma once
#include <iostream>
#include <cstring>
#include <functional>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>
#include "Log.hpp"
#include "InetAddr.hpp"

using namespace log_ns;

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    LISTEN_ERR
};

const static int gport = 8888;
const static int gsock = -1;
const static int gblcklog = 8;

using command_service_t = std::function<void(int sockfd, InetAddr addr)>;

class TcpServer
{
public:
    TcpServer(command_service_t service, uint16_t port = gport)
        : _port(port),
          _listensockfd(gsock),
          _isrunning(false),
          _service(service)
    {
    }
    void InitServer()
    {
        // 1. 创建socket
        _listensockfd = ::socket(AF_INET, SOCK_STREAM, 0);
        if (_listensockfd < 0)
        {
            LOG(FATAL, "socket create error\n");
            exit(SOCKET_ERROR);
        }
        LOG(INFO, "socket create success, sockfd: %d\n", _listensockfd); // 3

        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;

        // 2. bind sockfd 和 Socket addr
        if (::bind(_listensockfd, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            LOG(FATAL, "bind error\n");
            exit(BIND_ERROR);
        }
        LOG(INFO, "bind success\n");

        // 3. 因为tcp是面向连接的，tcp需要未来不断地能够做到获取连接
        if (::listen(_listensockfd, gblcklog) < 0)
        {
            LOG(FATAL, "listen error\n");
            exit(LISTEN_ERR);
        }
        LOG(INFO, "listen success\n");
    }
    class ThreadData
    {
    public:
        int _sockfd;
        TcpServer *_self;
        InetAddr _addr;
    public:
        ThreadData(int sockfd, TcpServer *self, const InetAddr &addr):_sockfd(sockfd), _self(self), _addr(addr)
        {}
    };
    void Loop()
    {
        // signal(SIGCHLD, SIG_IGN);
        _isrunning = true;
        while (_isrunning)
        {
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            // 4. 获取新连接
            int sockfd = ::accept(_listensockfd, (struct sockaddr *)&client, &len);
            if (sockfd < 0)
            {
                LOG(WARNING, "accept error\n");
                continue;
            }
            InetAddr addr(client);
            LOG(INFO, "get a new link, client info : %s, sockfd is : %d\n", addr.AddrStr().c_str(), sockfd);

            // version 2 ---- 多线程版本 --- 不能关闭fd了，也不需要了
            pthread_t tid;
            ThreadData *td = new ThreadData(sockfd, this, addr);
            pthread_create(&tid, nullptr, Execute, td); // 新线程进行分离
        }
        _isrunning = false;
    }
    static void *Execute(void *args)
    {
        pthread_detach(pthread_self());
        ThreadData *td = static_cast<ThreadData *>(args);
        td->_self->_service(td->_sockfd, td->_addr);
        ::close(td->_sockfd);
        delete td;
        return nullptr;
    }
    // void Service(int sockfd, InetAddr addr)
    // {
    //     // 长服务
    //     while (true)
    //     {
    //         char inbuffer[1024]; // 当做字符串
    //         ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
    //         if (n > 0)
    //         {
    //             inbuffer[n] = 0;
    //             LOG(INFO, "get message from client %s, message: %s\n", addr.AddrStr().c_str(), inbuffer);

    //             std::string echo_string = "[server echo] #";
    //             echo_string += inbuffer;
    //             write(sockfd, echo_string.c_str(), echo_string.size());
    //         }
    //         else if (n == 0)
    //         {
    //             LOG(INFO, "client %s quit\n", addr.AddrStr().c_str());
    //             break;
    //         }
    //         else
    //         {
    //             LOG(ERROR, "read error: %s\n", addr.AddrStr().c_str());
    //             break;
    //         }
    //     }
    // }

    ~TcpServer() {}

private:
    uint16_t _port;
    int _listensockfd;
    bool _isrunning;

    command_service_t _service;
};

常量定义

定义了一些常量，用于表示不同阶段可能发生的错误类型（如 SOCKET_ERROR, BIND_ERROR, LISTEN_ERR）

gport：默认的服务器端口号 8888。

gsock：默认的套接字文件描述符值，表示未初始化的套接字。

gblcklog：listen() 系统调用的 backlog（最大连接数），即服务器在开始接收连接之前，内核的连接队列最大容量。

command_service_t 类型定义

定义了一个类型别名 command_service_t，它是一个 std::function 类型，表示一个接受两个参数（sockfd 和 addr）并返回 void 的函数。这个函数在实际的应用中将用于处理每个客户端的连接请求。

TcpServer 类构造函数

command_service_t service：构造函数接收一个处理客户端请求的回调函数 service，即每当一个客户端连接建立后，服务器就调用该函数来处理连接。

uint16_t port：默认端口为 8888，服务器将监听该端口。

初始化服务器 (InitServer 方法)

创建 Socket：使用 ::socket() 创建一个 TCP 套接字 (SOCK_STREAM)。

如果创建失败（socket 返回值小于 0），日志记录错误并退出程序。

绑定 Socket 地址：通过 ::bind() 将创建的套接字与指定的端口和 IP 地址绑定。

服务器绑定到本机所有可用 IP 地址 (INADDR_ANY)，并监听指定的端口。

监听连接：通过 ::listen() 开始监听传入的连接，gblcklog 参数指定了等待连接的最大队列长度。

ThreadData 类

ThreadData：用于保存每个客户端连接的信息，包含：

_sockfd：客户端的套接字文件描述符。

_self：指向当前 TcpServer 实例的指针。

_addr：客户端的地址信息（封装在 InetAddr 对象中）。

Loop 方法

Loop：这是服务器的主循环，主要功能是：

使用 ::accept() 接受新的客户端连接。

每当接收到一个新连接时，使用 pthread_create 创建一个新线程，线程通过 Execute 函数处理客户端的请求。

每个连接的信息（套接字和客户端地址）封装在 ThreadData 中传递给线程。

pthread_create：创建一个新线程来处理客户端的请求。线程通过 Execute 方法执行指定的服务函数。

Execute 方法

Execute：线程的入口函数，执行以下操作：

使用 pthread_detach(pthread_self()) 将线程设为分离状态，确保线程结束后自动回收资源。

调用传入的回调函数 td->_self->_service(td->_sockfd, td->_addr)，即执行传递给服务器的具体业务逻辑。

关闭客户端连接的套接字。

删除 ThreadData 对象。

6. TcpServerMain.cc

#include "TcpServer.hpp"
#include "Command.hpp"

#include <memory>

// ./tcpserver 8888
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " local-port" << std::endl;
        exit(0);
    }
    uint16_t port = std::stoi(argv[1]);

    Command cmdservice;
    std::unique_ptr<TcpServer> tsvr = std::make_unique<TcpServer>(
        std::bind(&Command::HandlerCommand,
                  &cmdservice, std::placeholders::_1,
                  std::placeholders::_2),
        port);
    tsvr->InitServer();
    tsvr->Loop();

    return 0;
}

7. TcpClientMain.cc

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// ./tcpclient server-ip server-port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << " server-ip server-port" << std::endl;
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    // 1. 创建socket
    int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "create socket error" << std::endl;
        exit(1);
    }

    // 注意：不需要显示的bind，但是一定要有自己的IP和port，所以需要隐式的bind，OS会自动bind sockfd，用自己的IP和随机端口号
    // 什么时候进行自动bind？If the connection or binding succeeds
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    ::inet_pton(AF_INET, serverip.c_str(), &server.sin_addr);

    int n = ::connect(sockfd, (struct sockaddr *)&server, sizeof(server));
    if (n < 0)
    {
        std::cerr << "connect socket error" << std::endl;
        exit(2);
    }

    while(true)
    {
        std::string message;
        std::cout << "Enter #";
        std::getline(std::cin, message);

        write(sockfd, message.c_str(), message.size());

        char echo_buffer[1024];
        n = read(sockfd, echo_buffer, sizeof(echo_buffer));
        if(n > 0)
        {
            echo_buffer[n] = 0;
            std::cout << echo_buffer << std::endl;
        }
        else
        {
            break;
        }
    }
    ::close(sockfd);
    return 0;
}

 效果展示 : 

虽然命令有些少, 但是整体还是没有问题的~ 


http://www.kler.cn/a/408158.html

相关文章：

  • 安装 Docker（使用国内源）
  • manin动画编程（安装+入门）
  • CH595 驱动数码管
  • 快速获取镜像包的方法
  • Windows11深度学习环境配置
  • Android mk/bp构建工具介绍
  • node报错：cb.apply is not a function
  • 附录 9A 计量经济学实验室#5
  • 二号交叉学科楼的英文表达是什么？No. 2 Interdisciplinary Research Building
  • 电子应用设计方案-22：智能门禁系统方案设计
  • React 表单Form 中的 useForm
  • Linux内核
  • 创建可重用React组件的实用指南
  • 算法模板2：位运算+离散化+区间合并
  • 【Qt流式布局改造支持任意位置插入和删除】
  • CoAP 协议介绍：特性、应用与优劣势
  • 大语言模型---RewardBench 介绍；RewardBench 的主要功能；适用场景
  • 使用Python编写一个简单的网页爬虫，从网站抓取标题和内容。
  • windows C#-异步编程模型(下)
  • 使用go实现流式输出
  • Mac 环境变量配置基础教程
  • 贪心算法 day07
  • 嵌入式学习-C嘎嘎-Day08
  • 第三百二十九节 Java网络教程 - Java网络UDP套接字
  • Let‘s Encrypt SSL证书：acmessl.cn申请免费3个月证书
  • opencv-python 分离边缘粘连的物体（距离变换）