【Linux】基于tcp的简单服务器程序

服务端

成员变量

成员函数

工作流程

客户端

头文件和命名空间

信号处理函数

使用说明和重试机制

访问服务器的函数

主函数

总结和注意事项

所用到的其他类

线程池

线程类

翻译业务类

禁止拷贝类

守护锁类

网络地址转换类

日志类

守护进程类

服务端

这个TcpServer类是一个简单的TCP服务器实现，用于监听指定端口上的连接请求，并处理客户端的连接和数据交互。

成员变量

_port: 服务器监听的端口号，默认为8080。
_listensock: 监听套接字的文件描述符。
_isrunning: 表示服务器是否正在运行的布尔变量。
funcs: 一个无序映射，用于存储注册的服务函数。键是服务名称，值是对应的服务处理函数。

成员函数

构造函数 (TcpServer): 接收监听套接字和端口号作为参数，但都有默认值，因此可以无参构造。构造函数仅初始化成员变量。
Init(): 初始化服务器，包括创建套接字、设置套接字选项、绑定到指定端口、开始监听等步骤。如果在任何步骤中发生错误，程序会记录错误并退出。
Start(): 启动服务器的主循环，接受连接请求。对于每个接受的连接，都会创建一个新的任务并将其添加到线程池中执行。
Read(int sockfd): 从给定的套接字读取数据。如果读取成功，返回读取到的字符串；如果读取失败或连接已关闭，记录相应的日志。
Routine(int sockfd, InetAddr addr): 处理来自客户端的连接。首先调用默认服务，然后读取客户端发送的数据类型，并根据数据类型调用相应的服务函数。
DefaultService(int sockfd, InetAddr &addr): 默认服务函数，向客户端发送可用的服务列表。
Service(int sockfd, InetAddr addr): 一个示例服务函数，接收来自客户端的消息并将其回显。
RegisterFunc(const std::string &name, callback_t func): 允许用户注册自定义的服务函数。这些函数可以根据从客户端接收到的数据类型被调用。
析构函数 (~TcpServer): 目前析构函数为空，但在实际应用中，通常会在这里关闭套接字和释放资源。

工作流程

服务器通过Init()函数进行初始化，包括套接字的创建、绑定和监听。
调用Start()函数开始接受连接。对于每个接受的连接，都会创建一个新的任务来处理它。
在任务中，首先调用DefaultService向客户端发送可用的服务列表。
然后读取客户端发送的数据类型，并根据该类型调用相应的服务函数。
服务函数处理完客户端的请求后，关闭与客户端的连接。

这个类提供了一个基本的TCP服务器框架，用户可以通过注册自定义的服务函数来扩展其功能。注意，这个实现是同步的，每个连接都会占用一个线程来处理，因此在高并发环境下可能需要更高效的IO模型，如异步IO或多线程/多进程模型。

#pragma once

#include "ErrInfo.hpp"
#include "Log.hpp"
#include "NoCopy.hpp"
#include <arpa/inet.h>
#include <cstring>
#include <iostream>
#include <netinet/in.h>
#include <signal.h>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <unordered_map>

#include "Thread.hpp"
#include "ThreadPool.hpp"
#include"InetAddr.hpp"
#include"LockGuard.hpp"
#include"Translate.hpp"


static const int default_backlog = 5;
static const int DefaultListenSocket = -1;
static const uint16_t DefaultPort = 8080;

using task_t = std::function<void()>;
using callback_t = std::function<void(int, InetAddr&)>;

class TcpServer : public NoCopy
{
public:
  TcpServer(int listensocket = DefaultListenSocket, uint16_t port = DefaultPort)
      : _port(port),
        _listensock(listensocket),
        _isrunning(false)
  {
  }

  void Init()
  {
    // 创建套接字
    _listensock = socket(AF_INET, SOCK_STREAM, 0);
    if (_listensock < 0)
    {
      lg.LogMessage(Fatal, "创建套接字失败 错误码：%d  错误信息:%s \n", errno, strerror(errno));
      exit(Socket_Err);
    }
    lg.LogMessage(Info, "创建套接字成功！套接字：%d\n", _listensock);

    // 减少bind错误
    int opt = 1;
    setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

    // 填充信息
    sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_port = htons(_port);
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);

    // 进行绑定
    int n = bind(_listensock, (sockaddr *)&local, sizeof(local));
    if (n != 0)
    {
      lg.LogMessage(Fatal, "绑定失败！ 错误码：%d, 错误信息：%s\n", errno, strerror(errno));
      exit(Bind_Err);
    }
    lg.LogMessage(Info, "绑定成功！\n");

    // 设置监听状态
    n = listen(_listensock, default_backlog);
    if (n != 0)
    {
      lg.LogMessage(Fatal, "监听失败！错误码：%d，错误信息：%s\n", errno, strerror(errno));
      exit(Listen_Err);
    }
    lg.LogMessage(Info, "监听成功！\n");

    ThreadPool<task_t>::GetInstance()->Start();
    funcs.insert(std::make_pair("defaultService", std::bind(&TcpServer::DefaultService, this, std::placeholders::_1, std::placeholders::_2)));
  }
  void Start()
  {
    _isrunning = true;
    signal(SIGCHLD, SIG_IGN);

    while (_isrunning)
    {
      sockaddr_in peer;
      memset(&peer, 0, sizeof(peer));
      socklen_t len = sizeof(peer);
      int sockfd = accept(_listensock, (sockaddr *)&peer, &len);
      if (sockfd < 0)
      {
        lg.LogMessage(Warning, "接受套接字失败, 错误码: %d, 错误信息: %s\n", errno, strerror(errno));
        continue;
      }
      lg.LogMessage(Debug, "接受套接字成功，新的套接字为: %d\n", sockfd);

      // 处理信息
      task_t t = std::bind(&TcpServer::Routine, this, sockfd, InetAddr(peer));
      ThreadPool<task_t>::GetInstance()->Push(t);
    }
  }

  std::string Read(int sockfd)
  {
    char type[1024];
    ssize_t n = read(sockfd, type, sizeof(type) - 1);
    if (n > 0)
    {
      type[n] = 0;
    }
    else if (n == 0) // read如果返回值是0，表示读到了文件结尾(对端关闭了连接！)
    {
      lg.LogMessage(Info, "client quit...\n");
    }
    else
    {
      lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", errno, strerror(errno));
    }
    return type;
  }

  void Routine(int sockfd, InetAddr addr)
  {
    funcs["defaultService"](sockfd, addr);
    std::string type = Read(sockfd);
    lg.LogMessage(Debug, "%s select %s\n", addr.PrintDebug().c_str(), type.c_str());

    if (type == "ping")
      funcs[type](sockfd, addr);
    else if (type == "translate")
      funcs[type](sockfd, addr);
    else if (type == "transform")
      funcs[type](sockfd, addr);
    else
    {
    }

    close(sockfd);
  }
  void DefaultService(const int sockfd, const InetAddr &addr)
  {
    (void)addr;
    std::string service_list = " |";
    for (auto func : funcs)
    {
      service_list += func.first;
      service_list += "|";
    }

    write(sockfd, service_list.c_str(), service_list.size());
  }

  void Service(int sockfd, InetAddr addr)
  {
    char buffer[1024];

    // 一直进行IO
    while (true)
    {
      ssize_t n = read(sockfd, buffer, sizeof(buffer) - 1);
      if (n > 0)
      {
        buffer[n] = 0;
        std::cout << addr.PrintDebug() << "# " << buffer << std::endl;

        std::string echo_string = "server echo# ";
        echo_string += buffer;
        write(sockfd, echo_string.c_str(), echo_string.size());
      }
      else if (n == 0) // read如果返回值是0，表示读到了文件结尾(对端关闭了连接！)
      {
        lg.LogMessage(Info, "client quit...\n");
        break;
      }
      else
      {
        lg.LogMessage(Error, "read socket error, errno code: %d, error string: %s\n", errno, strerror(errno));
        break;
      }
    }
  }
  void RegisterFunc(const std::string &name, callback_t func)
  {
    funcs[name] = func;
  }
  ~TcpServer()
  {
  }

private:
  uint16_t _port;
  int _listensock;
  bool _isrunning;

  std::unordered_map<std::string, callback_t> funcs;
};

客户端

这个代码实现了一个简单的TCP客户端，用于连接到一个TCP服务器，获取服务器提供的服务列表，发送用户选择的服务，然后发送和接收消息。下面是对这个客户端类的详细介绍：

头文件和命名空间

代码首先包含了一系列必要的头文件，这些头文件提供了网络编程、字符串处理、输入输出等功能。然后使用了std命名空间，以简化代码中的标准库类型和函数的调用。

信号处理函数

handler函数是一个信号处理函数，用于处理接收到的信号。在这个例子中，它仅仅打印出接收到的信号编号，并退出程序。但这个函数在main函数中被设置为忽略SIGPIPE信号，这是为了防止在写已关闭的socket时程序异常退出。

使用说明和重试机制

Usage函数提供了程序的使用说明。如果用户没有提供正确的命令行参数，这个函数会被调用，显示如何使用这个程序。

程序中定义了一个重试计数Retry_Count，设置为5。这意味着如果连接服务器失败，客户端会尝试重新连接最多5次。

访问服务器的函数

visitServer函数是客户端的核心功能。它尝试连接到指定的服务器，并交换数据。这个函数的主要步骤如下：

创建Socket：使用socket函数创建一个TCP socket。
连接到服务器：使用服务器的IP地址和端口号连接到服务器。如果连接失败，会打印错误信息并返回false。
读取服务列表：从服务器读取提供的服务列表，并显示给用户。
用户交互：提示用户选择一个服务，并将选择发送给服务器。然后等待用户输入一条消息，并将其发送给服务器。
接收服务器响应：读取并显示服务器的响应。如果服务器的响应是“quit”，则函数返回true，表示交互结束。
错误处理和资源清理：在函数结束时，关闭socket。

主函数

main函数是程序的入口点。它首先检查命令行参数的数量，确保用户提供了服务器的IP地址和端口号。然后，它进入一个循环，尝试连接到服务器。如果连接失败，会等待一秒钟后重试，直到达到最大重试次数。如果成功连接到服务器并完成了交互，循环会提前结束。