【Linux】Socket 编程 TCP

一.TCP socket API 详解

1. int socket(int domain, int type, int protocol);

复制代码

• socket() 打开一个网络通讯端口，如果成功的话，就像 open()一样返回一个文件描述符。
  
• 应用程序可以像读写文件一样用 read/write 在网络上收发数据。
  
• 如果 socket() 调用出错则返回-1。
  
• 对于 IPv4 网络通信，domain 参数指定为 AF_INET。
  
• 对于 TCP 协议，type 参数指定为 SOCK_STREAM，表示面向字节流的传输协议。
  
• protocol 参数的先容从略，指定为 0 即可。
  

1. int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

复制代码

• 服务器程序所监听的网络地址和端口号通常是固定稳固的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接。服务器需要调用 bind 绑定网络地址(INADDR_ANY)和固定的端口号。
  
• bind()成功返回 0，失败返回-1。
  
• bind()的作用是将参数 sockfd 和 myaddr 绑定在一起，使 sockfd 这个用于网络通讯的文件描述符监听 myaddr 所描述的地址和端口号。
  
• struct sockaddr* 是一个通用指针类型，myaddr 参数现实上可以接受多种协议的 sockaddr 结构体(例如网络通信用 struct sockaddr_in*)，而它们的长度各不雷同，以是需要第三个参数 addrlen指定结构体的长度。
  

我们的程序中对 myaddr 参数是如许初始化的：

• 将整个结构体清零。
  
• 设置地址类型为 AF_INET。
  
• 网络地址为 INADDR_ANY，这个宏表示本地的任意 IP 地址，由于服务器可能有多个网卡，每个网卡也可能绑定多个 IP 地址，如许设置可以在所有的 IP 地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个 IP 地址。
  
• 端口号为 SERV_PORT，我们界说为 8080。
  

1. int listen(int sockfd, int backlog);

复制代码

• listen()声明 sockfd 处于监听状态，而且最多答应有 backlog 个客户端处于连接等待状态(它们位于监听队列中)，如果接收到更多的连接哀求就忽略，这里设置不会太大，一样平常是 5。
  
• listen()成功返回 0，失败返回-1。
  

1. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

复制代码

• 三次握手完成后，服务器调用 accept()接受连接。
  
• 如果服务器调用 accept()时还没有客户端的连接哀求，就阻塞等待直到有客户端连接上来。
  
• addr 是一个输出型参数，accept()返回时传出客户端的地址和端口号。
  
• 如果给 addr 参数传 nullptr，表示不关心客户端的地址。
  
• addrlen 参数是一个输入输出参数，输入的是调用者提供的，缓冲区 addr 的长度以避免缓冲区溢出题目，输出的是客户端地址结构体的现实长度。
  
• 留意：输入的 sockfd 是监听套接字，accept 成功时：返回的是现实进行网络通信的套接字。
  

1. int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

复制代码

• 客户端需要调用 connect()连接服务器。
  
• connect 和 bind 的参数形式一致，区别在于 bind 的参数是本身的地址，而connect 的参数是对方的地址。
  
• connect()成功返回 0,出错返回-1。
  

二.EchoServer（单历程/多历程/多线程/线程池）

1.Makefile

1. .PHONY:all
2. all:server_tcp client_tcp
4. client_tcp:TcpClient.cc
5.         g++ -o $@ $^ -std=c++17
6. server_tcp:TcpServer.cc
7.         g++ -o $@ $^ -std=c++17 -lpthread
9. .PHONY:clean
10. clean:
11.         rm -f client_tcp server_tcp

复制代码

2.Mutex.hpp

1. #pragma once
3. #include <pthread.h>
5. namespace MutexModule
6. {
7.     class Mutex
8.     {
9.         Mutex(const Mutex &m) = delete;
10.         const Mutex &operator=(const Mutex &m) = delete;
12.     public:
13.         Mutex()
14.         {
15.             ::pthread_mutex_init(&_mutex, nullptr);
16.         }
18.         ~Mutex()
19.         {
20.             ::pthread_mutex_destroy(&_mutex);
21.         }
23.         void Lock()
24.         {
25.             ::pthread_mutex_lock(&_mutex);
26.         }
28.         void Unlock()
29.         {
30.             ::pthread_mutex_unlock(&_mutex);
31.         }
33.         pthread_mutex_t *LockAddr() { return &_mutex; }
35.     private:
36.         pthread_mutex_t _mutex;
37.     };
39.     class LockGuard
40.     {
41.     public:
42.         LockGuard(Mutex &mutex)
43.             : _mutex(mutex)
44.         {
45.             _mutex.Lock();
46.         }
48.         ~LockGuard()
49.         {
50.             _mutex.Unlock();
51.         }
53.     private:
54.         Mutex &_mutex; // 使用引用: 互斥锁不支持拷贝
55.     };
56. }

复制代码

3.Cond.hpp

1. #pragma
3. #include <pthread.h>
4. #include "Mutex.hpp"
6. namespace CondModule
7. {
8.     using namespace MutexModule;
10.     class Cond
11.     {
12.     public:
13.         Cond()
14.         {
15.             ::pthread_cond_init(&_cond, nullptr);
16.         }
18.         ~Cond()
19.         {
20.             ::pthread_cond_destroy(&_cond);
21.         }
23.         void Wait(Mutex &mutex) // 线程释放曾经持有的锁, 不能拷贝
24.         {
25.             ::pthread_cond_wait(&_cond, mutex.LockAddr());
26.         }
28.         void Signal()
29.         {
30.             ::pthread_cond_signal(&_cond);
31.         }
33.         void Broadcast()
34.         {
35.             ::pthread_cond_broadcast(&_cond);
36.         }
38.     private:
39.         pthread_cond_t _cond;
40.     };
41. }

复制代码

4.Log.hpp

1. #pragma once
3. #include <iostream>
4. #include <cstdio>
5. #include <string>
6. #include <filesystem>
7. #include <fstream>
8. #include <sstream>
9. #include <memory>
10. #include <unistd.h>
11. #include <time.h>
12. #include "Mutex.hpp"
14. namespace LogModule
15. {
16.     using namespace MutexModule;
18.     // 获取系统时间
19.     std::string CurrentTime()
20.     {
21.         time_t time_stamp = ::time(nullptr); // 获取时间戳
22.         struct tm curr;
23.         localtime_r(&time_stamp, &curr); // 将时间戳转化为可读性强的信息
25.         char buffer[1024];
26.         snprintf(buffer, sizeof(buffer), "%4d-%02d-%02d %02d:%02d:%02d",
27.                  curr.tm_year + 1900,
28.                  curr.tm_mon + 1,
29.                  curr.tm_mday,
30.                  curr.tm_hour,
31.                  curr.tm_min,
32.                  curr.tm_sec);
34.         return buffer;
35.     }
37.     // 日志文件: 默认路径和默认文件名
38.     const std::string defaultlogpath = "./log/";
39.     const std::string defaultlogname = "log.txt";
41.     // 日志等级
42.     enum class LogLevel
43.     {
44.         DEBUG = 1,
45.         INFO,
46.         WARNING,
47.         ERROR,
48.         FATAL
49.     };
51.     std::string Level2String(LogLevel level)
52.     {
53.         switch (level)
54.         {
55.         case LogLevel::DEBUG:
56.             return "DEBUG";
57.         case LogLevel::INFO:
58.             return "INFO";
59.         case LogLevel::WARNING:
60.             return "WARNING";
61.         case LogLevel::ERROR:
62.             return "ERROR";
63.         case LogLevel::FATAL:
64.             return "FATAL";
65.         default:
66.             return "NONE";
67.         }
68.     }
70.     // 3. 策略模式: 刷新策略
71.     class LogStrategy
72.     {
73.     public:
74.         virtual ~LogStrategy() = default;
75.         // 纯虚函数: 无法实例化对象, 派生类可以重载该函数, 实现不同的刷新方式
76.         virtual void SyncLog(const std::string &message) = 0;
77.     };
79.     // 3.1 控制台策略
80.     class ConsoleLogStrategy : public LogStrategy
81.     {
82.     public:
83.         ConsoleLogStrategy() {}
84.         ~ConsoleLogStrategy() {}
86.         void SyncLog(const std::string &message) override
87.         {
88.             LockGuard lockguard(_mutex);
89.             std::cout << message << std::endl;
90.         }
92.     private:
93.         Mutex _mutex;
94.     };
96.     // 3.2 文件级(磁盘)策略
97.     class FileLogStrategy : public LogStrategy
98.     {
99.     public:
100.         FileLogStrategy(const std::string &logpath = defaultlogpath, const std::string &logname = defaultlogname)
101.             : _logpath(logpath), _logname(logname)
102.         {
103.             // 判断_logpath目录是否存在
104.             if (std::filesystem::exists(_logpath))
105.             {
106.                 return;
107.             }
108.             try
109.             {
110.                 std::filesystem::create_directories(_logpath);
111.             }
112.             catch (std::filesystem::filesystem_error &e)
113.             {
114.                 std::cerr << e.what() << std::endl;
115.             }
116.         }
117.         ~FileLogStrategy() {}
119.         void SyncLog(const std::string &message) override
120.         {
121.             LockGuard lockguard(_mutex);
122.             std::string log = _logpath + _logname;
123.             std::ofstream out(log, std::ios::app); // 以追加的方式打开文件
124.             if (!out.is_open())
125.             {
126.                 return;
127.             }
128.             out << message << "\n"; // 将信息刷新到out流中
129.             out.close();
130.         }
132.     private:
133.         std::string _logpath;
134.         std::string _logname;
135.         Mutex _mutex;
136.     };
138.     // 4. 日志类: 构建日志字符串, 根据策略进行刷新
139.     class Logger
140.     {
141.     public:
142.         Logger()
143.         {
144.             // 默认往控制台上刷新
145.             _strategy = std::make_shared<ConsoleLogStrategy>();
146.         }
147.         ~Logger() {}
149.         void EnableConsoleLog()
150.         {
151.             _strategy = std::make_shared<ConsoleLogStrategy>();
152.         }
154.         void EnableFileLog()
155.         {
156.             _strategy = std::make_shared<FileLogStrategy>();
157.         }
159.         // 内部类: 记录完整的日志信息
160.         class LogMessage
161.         {
162.         public:
163.             LogMessage(LogLevel level, const std::string &filename, int line, Logger &logger)
164.                 : _currtime(CurrentTime()), _level(level), _pid(::getpid())
165.                 , _filename(filename), _line(line), _logger(logger)
166.             {
167.                 std::stringstream ssbuffer;
168.                 ssbuffer << "[" << _currtime << "] "
169.                          << "[" << Level2String(_level) << "] "
170.                          << "[" << _pid << "] "
171.                          << "[" << _filename << "] "
172.                          << "[" << _line << "] - ";
174.                 _loginfo = ssbuffer.str();
175.             }
176.             ~LogMessage()
177.             {
178.                 if(_logger._strategy)
179.                 {
180.                     _logger._strategy->SyncLog(_loginfo);
181.                 }
182.             }
184.             template <class T>
185.             LogMessage &operator<<(const T &info)
186.             {
187.                 std::stringstream ssbuffer;
188.                 ssbuffer << info;
189.                 _loginfo += ssbuffer.str();
190.                 return *this;
191.             }
193.         private:
194.             std::string _currtime;  // 当前日志时间
195.             LogLevel _level;       // 日志水平
196.             pid_t _pid;            // 进程pid
197.             std::string _filename; // 文件名
198.             uint32_t _line;        // 日志行号
199.             Logger &_logger;       // 负责根据不同的策略进行刷新
200.             std::string _loginfo;  // 日志信息
201.         };
203.         // 故意拷贝, 形成LogMessage临时对象, 后续在被<<时，会被持续引用,
204.         // 直到完成输入，才会自动析构临时LogMessage, 至此完成了日志的刷新,
205.         // 同时形成的临时对象内包含独立日志数据, 未来采用宏替换, 获取文件名和代码行数
206.         LogMessage operator()(LogLevel level, const std::string &filename, int line)
207.         {
208.             return LogMessage(level, filename, line, *this);
209.         }
211.     private:
212.         // 纯虚类不能实例化对象, 但是可以定义指针
213.         std::shared_ptr<LogStrategy> _strategy; // 日志刷新策略方案
214.     };
216.     // 定义全局logger对象
217.     Logger logger;
219. // 编译时进行宏替换: 方便随时获取行号和文件名
220. #define LOG(level) logger(level, __FILE__, __LINE__)
222. // 提供选择使用何种日志策略的方法
223. #define ENABLE_CONSOLE_LOG() logger.EnableConsoleLog()
224. #define ENABLE_FILE_LOG() logger.EnableFileLog()
225. }

复制代码

5.Thread.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <functional>
6. #include <pthread.h>
7. #include <sys/types.h>
8. #include <unistd.h>
10. namespace ThreadModule
11. {
12.     using func_t = std::function<void(std::string)>;
13.     static int number = 1;
15.     // 强类型枚举: 枚举的成员名称被限定在枚举类型的作用域内
16.     enum class TSTATUS
17.     {
18.         NEW,
19.         RUNNING,
20.         STOP
21.     };
23.     class Thread
24.     {
25.     private:
26.         // 成员方法: 需要加上static表示不需要this指针, 否则回调函数报错
27.         // 而要执行_func()函数又需要由this指针, 所以Routine函数传this指针
28.         static void *Routine(void *args)
29.         {
30.             Thread *t = static_cast<Thread *>(args);
31.             t->_func(t->Name());
32.             return nullptr;
33.         }
35.         void EnableDetach() { _joinable = false; }
37.     public:
38.         Thread(func_t func)
39.             : _func(func), _status(TSTATUS::NEW), _joinable(true)
40.         {
41.             _name = "Thread-" + std::to_string(number++);
42.             _pid = getpid();
43.         }
45.         ~Thread() {}
47.         // 线程创建
48.         bool Start()
49.         {
50.             if (_status != TSTATUS::RUNNING)
51.             {
52.                 int n = pthread_create(&_tid, nullptr, Routine, this);
53.                 if (n != 0)
54.                     return false;
55.                 _status = TSTATUS::RUNNING;
56.                 return true;
57.             }
58.             return false;
59.         }
61.         // 线程退出
62.         bool Stop()
63.         {
64.             if (_status == TSTATUS::RUNNING)
65.             {
66.                 int n = ::pthread_cancel(_tid);
67.                 if (n != 0)
68.                     return false;
69.                 _status = TSTATUS::STOP;
70.                 return true;
71.             }
72.             return false;
73.         }
75.         // 线程等待
76.         bool Join()
77.         {
78.             if (_joinable)
79.             {
80.                 int n = ::pthread_join(_tid, nullptr);
81.                 if (n != 0)
82.                     return false;
83.                 _status = TSTATUS::STOP;
84.                 return true;
85.             }
86.             return false;
87.         }
89.         // 线程分离
90.         bool Detach()
91.         {
92.             EnableDetach();
93.             int n = ::pthread_detach(_tid);
94.             if (n != 0)
95.                 return false;
96.             return true;
97.         }
99.         // 线程是否分离
100.         bool IsJoinable() {  return _joinable; }
101.         std::string Name() { return _name; }
103.     private:
104.         std::string _name;
105.         pthread_t _tid;
106.         pid_t _pid;
107.         bool _joinable; // 线程是否是分离的, 默认不是
108.         func_t _func;
109.         TSTATUS _status;
110.     };
111. }

复制代码

6.ThreadPool.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <vector>
6. #include <queue>
7. #include <memory>
8. #include "Mutex.hpp"
9. #include "Cond.hpp"
10. #include "Thread.hpp"
11. #include "Log.hpp"
13. namespace ThreadPoolModule
14. {
15.     using namespace MutexModule;
16.     using namespace CondModule;
17.     using namespace ThreadModule;
18.     using namespace LogModule;
20.     using thread_t = std::shared_ptr<Thread>;
21.     const static int defaultnum = 15;
23.     template <class T>
24.     class ThreadPool
25.     {
26.     private:
27.         bool IsEmpty() { return _taskq.empty(); }
29.         void HandlerTask(std::string name)
30.         {
31.             LOG(LogLevel::INFO) << "线程: " << name << ", 进入HandlerTask执行逻辑";
32.             while (true)
33.             {
34.                 // 1. 拿任务: 访问共享资源, 需要加锁
35.                 T task;
36.                 {
37.                     LockGuard lockguard(_mutex);
38.                     while (IsEmpty() && _isrunning) // while替代if: 防止伪唤醒
39.                     {
40.                         _wait_num++;
41.                         _cond.Wait(_mutex); // 没任务时: 线程在条件变量上阻塞等待
42.                         _wait_num--;
43.                     }
44.                     // 2. 任务队列不为空 && 线程池退出
45.                     if (IsEmpty() && !_isrunning)
46.                         break;
48.                     task = _taskq.front();
49.                     _taskq.pop();
50.                 }
52.                 // 3. 处理任务: 并发处理, 不需要持有锁
53.                 task();
54.             }
55.             LOG(LogLevel::INFO) << "线程: " << name << ", 退出";
56.         }
58.         ThreadPool(int num = defaultnum)
59.             : _num(num), _wait_num(0), _isrunning(false)
60.         {
61.             for (int i = 0; i < _num; i++)
62.             {
63.                 // 在类中: bind类的公有方法, 需要取地址 + 传入this指针
64.                 // 在类外: bind类的公有方法, 需要取地址 + 传入类的匿名对象
65.                 _threads.push_back(std::make_shared<Thread>(std::bind(&ThreadPool::HandlerTask, this, std::placeholders::_1))); // push_back()会调用移动构造
66.                 LOG(LogLevel::INFO) << "构建线程" << _threads.back()->Name() << "对象...成功";
67.             }
68.         }
70.         ThreadPool<T>(const ThreadPool<T> &) = delete;
71.         ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;
73.     public:
74.         ~ThreadPool() {}
76.         // 获取单例对象
77.         static ThreadPool<T> *GetInstance()
78.         {
79.             // 若单例为空: 需要加锁创建单例对象
80.             if(instance == nullptr)
81.             {
82.                 LockGuard lockguard(_lock);
83.                 if(instance == nullptr)
84.                 {
85.                     LOG(LogLevel::INFO) << "单例首次被执行, 需要加载对象...";
86.                     instance = new ThreadPool<T>();
87.                     instance->Start();
88.                 }
89.             }
90.             // 若单例不为空: 直接返回单例对象
91.             return instance;
92.         }
94.         void Equeue(T in)
95.         {
96.             LockGuard lockguard(_mutex);
97.             if (!_isrunning) return;
98.             _taskq.push(in);
99.             if (_wait_num > 0)
100.             {
101.                 _cond.Signal(); // 唤醒线程
102.             }
103.         }
105.         void Start()
106.         {
107.             if (_isrunning) return;
108.             _isrunning = true;
109.             for (auto &thread_ptr : _threads)
110.             {
111.                 thread_ptr->Start();
112.                 LOG(LogLevel::INFO) << "启动线程" << thread_ptr->Name() << "...成功";
113.             }
114.         }
116.         void Stop()
117.         {
118.             LockGuard lockguard(_mutex);
119.             if (_isrunning)
120.             {
121.                 // 1. 不能再新增任务了
122.                 _isrunning = false;
124.                 // 2. 让线程自己退出(唤醒所有的线程) && 历史任务被执行完
125.                 if (_wait_num > 0)
126.                 {
127.                     _cond.Broadcast();
128.                 }
129.             }
130.         }
132.         void Wait()
133.         {
134.             for (auto &thread_ptr : _threads)
135.             {
136.                 thread_ptr->Join();
137.                 LOG(LogLevel::INFO) << "回收线程" << thread_ptr->Name() << "...成功";
138.             }
139.         }
141.     private:
142.         int _num;                       // 线程的个数
143.         std::vector<thread_t> _threads; // 线程池
144.         std::queue<T> _taskq;           // 共享资源: 任务队列
145.         int _wait_num;                  // 等待的线程数目
146.         bool _isrunning;                // 线程池是否运行
148.         Mutex _mutex; // 锁
149.         Cond _cond;   // 条件变量
151.         static ThreadPool<T> *instance; // 单例对象
152.         static Mutex _lock;             // 用来保护单例
153.     };
155.     // 静态成员: 类内声明, 类外定义
156.     template<class T>
157.     ThreadPool<T> *ThreadPool<T>::instance = nullptr;
158.    
159.     template<class T>
160.     Mutex ThreadPool<T>::_lock;
161. }

复制代码

7.InetAddr.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
6. #include <sys/types.h>
7. #include <sys/socket.h>
8. #include <netinet/in.h>
9. #include <arpa/inet.h>
11. #include "Common.hpp"
13. class InetAddr
14. {
15. private:
16.     // 端口号: 网络序列->主机序列
17.     void PortNetToHost()
18.     {
19.         _port = ::ntohs(_net_addr.sin_port);
20.     }
22.     // IP: 网络序列->主机序列
23.     void IpNetToHost()
24.     {
25.         char ipbuffer[64];
26.         ::inet_ntop(AF_INET, &_net_addr.sin_addr, ipbuffer, sizeof(ipbuffer));
27.         _ip = ipbuffer;
28.     }
30. public:
31.     InetAddr() {}
33.     InetAddr(const struct sockaddr_in &addr)
34.         : _net_addr(addr)
35.     {
36.         PortNetToHost();
37.         IpNetToHost();
38.     }
40.     InetAddr(uint16_t port)
41.         : _port(port), _ip("")
42.     {
43.         _net_addr.sin_family = AF_INET;
44.         _net_addr.sin_port = ::htons(_port);
45.         _net_addr.sin_addr.s_addr = INADDR_ANY;
46.     }
48.     ~InetAddr() {}
50.     bool operator==(const InetAddr& addr) { return _ip == addr._ip && _port == addr._port; }
52.     struct sockaddr *NetAddr() { return CONV(&_net_addr); }
53.     socklen_t NetAddrLen() { return sizeof(_net_addr); }
55.     std::string Ip() { return _ip; }
56.     uint16_t Port() { return _port; }
57.     std::string Addr() { return Ip() + ":" + std::to_string(Port()); }
59. private:
60.     struct sockaddr_in _net_addr;
61.     std::string _ip; // 主机序列: IP
62.     uint16_t _port;  // 主机序列: 端口号
63. };

复制代码

7.CommandExecute.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <set>
6. #include <cstdlib>
8. const int line_size = 1024;
10. class Command
11. {
12. public:
13.     Command()
14.     {
15.         _white_list.insert("ls");
16.         _white_list.insert("pwd");
17.         _white_list.insert("ls -l");
18.         _white_list.insert("touch file.txt");
19.         _white_list.insert("who");
20.         _white_list.insert("whoami");
21.     }
23.     bool SafeCheck(const std::string &cmdstr)
24.     {
25.         auto iter = _white_list.find(cmdstr);
26.         return iter == _white_list.end() ? false : true;
27.     }
29.     // 给出命令字符串, 返回执行后的结果
30.     std::string Execute(std::string cmdstr)
31.     {
32.         // 1. pipe
33.         // 2. fork + dup2(pipe[1], 1) + exec*, 执行结果给父进程, pipe[0]
34.         // 3. return
36.         // FILE *popen(const char *command, const char *type);
37.         // int pclose(FILE * stream);
39.         if(!SafeCheck(cmdstr))
40.         {
41.             return std::string(cmdstr + "不支持");
42.         }
44.         // 以读模式打开管道，执行命令
45.         FILE *fp = ::popen(cmdstr.c_str(), "r");
46.         if (fp == nullptr)
47.         {
48.             return std::string("fail");
49.         }
51.         char buffer[line_size];
52.         std::string result;
53.         while (true)
54.         {
55.             // 从管道中读取命令的输出
56.             char *ret = ::fgets(buffer, sizeof(buffer), fp); // 自动添加'\0'
57.             if (ret == nullptr) break;
58.             result += ret;
59.         }
60.         ::pclose(fp);
62.         return result.empty() ? std::string("Done") : result;
63.     }
65. private:
66.     std::set<std::string> _white_list; // 命令白名单: 允许执行白名单中的命令
67. };

复制代码

9.TcpServer.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <cstring>
6. #include <cerrno>
7. #include <functional>
9. #include <pthread.h>
10. #include <signal.h>
11. #include <sys/wait.h>
12. #include <sys/types.h>
13. #include <sys/socket.h>
14. #include <netinet/in.h>
15. #include <arpa/inet.h>
17. #include "Log.hpp"
18. #include "Common.hpp"
19. #include "InetAddr.hpp"
20. #include "ThreadPool.hpp"
22. using namespace LogModule;
23. using namespace ThreadPoolModule;
25. using task_t = std::function<void()>;
26. using handler_t = std::function<std::string(std::string)>;
28. #define BACKLOG 8
30. uint16_t gport = 8080;
32. class TcpServer
33. {
34. public:
35.     TcpServer(handler_t handler, int port = gport)
36.         : _handler(handler), _port(port), _isrunning(false)
37.     {}
39.     ~TcpServer() {}
41.     void InitServer()
42.     {
43.         // 1. 创建TCP套接字
44.         _listensockfd = ::socket(AF_INET, SOCK_STREAM, 0);
45.         if (_listensockfd < 0)
46.         {
47.             LOG(LogLevel::FATAL) << "socket error";
48.             Die(SOCKET_ERR);
49.         }
50.         LOG(LogLevel::INFO) << "socket create success, listensockfd is: " << _listensockfd;
52.         // 2. 绑定
53.         struct sockaddr_in local;
54.         memset(&local, 0, sizeof(local));
55.         local.sin_family = AF_INET;
56.         local.sin_port = ::htons(_port);
57.         local.sin_addr.s_addr = INADDR_ANY;
59.         int n = ::bind(_listensockfd, CONV(&local), sizeof(local));
60.         if (n < 0)
61.         {
62.             LOG(LogLevel::FATAL) << "bind error";
63.             Die(BIND_ERR);
64.         }
65.         LOG(LogLevel::INFO) << "bind success";
67.         // 3. Tcp是面向连接的, 就要求Tcp随时随地等待被客户端连接, Tcp需要将socket设置为监听状态
68.         //    客户端请求连接时: 将客户端连接请求放入一个监听队列中
69.         n = ::listen(_listensockfd, BACKLOG);
70.         if (n < 0)
71.         {
72.             LOG(LogLevel::FATAL) << "listen error";
73.             Die(LISTEN_ERR);
74.         }
75.         LOG(LogLevel::INFO) << "listen success";
77.         // ::signal(SIGCHLD, SIG_IGN); // 子进程退出, 父进程无需wait, 操作系统自动回收资源
78.     }
80.     // Tcp也是全双工的: 在同一个文件描述符中, 既可以读又可以写
81.     void HandlerRequest(int sockfd)
82.     {
83.         LOG(LogLevel::INFO) << "开始处理客户端请求...";
84.         char inbuffer[4096];
85.         while (true)
86.         {
87.             // 约定: 客户端发过来的是一条完整的命令string
89.             // 1. 读取客户端发送来的消息
90.             // ssize_t n = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1); // 读取是不完善的
91.             ssize_t n = ::recv(sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
92.             if (n > 0)
93.             {
94.                 LOG(LogLevel::INFO) << inbuffer;
96.                 inbuffer[n] = 0;
97.                 // std::string message = "server echo# ";
98.                 // message += inbuffer;
100.                 std::string cmd_reault = _handler(inbuffer);
102.                 // 2. 向客户端发送消息
103.                 // ::write(sockfd, message.c_str(), message.size()); // 写入也是不完善的
104.                 // ::send(sockfd, message.c_str(), message.size(), 0);
106.                 ::send(sockfd, cmd_reault.c_str(), cmd_reault.size(), 0);
107.             }
108.             else if (n == 0)
109.             {
110.                 // read如果读取的返回值是0, 表示客户端退出
111.                 LOG(LogLevel::INFO) << "客户端退出: " << sockfd;
112.                 break;
113.             }
114.             else
115.             {
116.                 // 读取失败
117.                 break;
118.             }
119.         }
120.         ::close(sockfd); // 关闭fd, 防止fd泄漏问题
121.     }
123.     void Start()
124.     {
125.         _isrunning = true;
126.         while (_isrunning)
127.         {
128.             // 1. Tcp不能直接获取数据: 需要获取新连接
129.             // 阻塞等待, 直到有客户端连接请求进入监听队列, 然后从队列中取出一个请求, 为该客户端建立连接,
130.             // 并返回一个新的套接字描述符, 通过这个新的套接字描述符就可以与客户端进行数据的发送和接收
131.             struct sockaddr_in peer;
132.             socklen_t peerlen = sizeof(peer);
133.             int sockfd = ::accept(_listensockfd, CONV(&peer), &peerlen);
134.             if (sockfd < 0)
135.             {
136.                 LOG(LogLevel::WARNING) << "accept error: " << strerror(errno);
137.                 continue;
138.             }
139.             LOG(LogLevel::INFO) << "accept success, sockfd is: " << sockfd;
141.             // 获取客户端的信息: IP + 端口号
142.             InetAddr addr(peer);
143.             LOG(LogLevel::INFO) << "client info: " << addr.Addr();
145.             // version1->单进程版本: 单客户端访问
146.             // HandlerRequest(sockfd);
148.             // version2->多进程版本: 多客户端访问
149.             // pid_t id = fork();
150.             // if (id == 0)
151.             // {
152.             //     // 子进程: 继承父进程的文件描述符表, 有两张表
153.             //     ::close(_listensockfd); // 关闭不需要的文件描述符: 监听套接字
155.             //     if(fork() > 0) exit(0); // 子进程退出
157.             //     // 孙子进程->孤儿进程: 不断与客户端的数据传输, 退出后被操作系统自动回收
158.             //     HandlerRequest(sockfd);
160.             //     exit(0);
161.             // }
162.             // // 父进程: 不断与客户端建立连接
163.             // ::close(sockfd); // 关闭不需要的文件描述符: socket
165.             // // waitpid不会阻塞
166.             // int rid = ::waitpid(id, nullptr, 0);
167.             // if(rid < 0)
168.             // {
169.             //     LOG(LogLevel::WARNING) << "waitpid error";
170.             // }
172.             // version3->多线程版本: 多客户端访问
173.             // 主线程和新线程共享同一张文件描述符表
174.             // pthread_t tid;
175.             // ThreadData *data = new ThreadData();
176.             // data->sockfd = sockfd;
177.             // data->self = this;
178.             // pthread_create(&tid, nullptr, ThreadEntry, (void *)data);
180.             // version4->线程池版本: 多客户端访问(适合处理短任务)
181.             task_t task = std::bind(&TcpServer::HandlerRequest, this, sockfd); // 构建任务
182.             ThreadPool<task_t>::GetInstance()->Equeue(task);
184.             // ThreadPool<task_t>::GetInstance()->Equeue([this, &sockfd](){
185.             //     this->HandlerRequest(sockfd);
186.             // });
187.         }
188.     }
190.     struct ThreadData
191.     {
192.         int sockfd;
193.         TcpServer *self;
194.     };
196.     // 类中ThreadEntry函数带有this指针, 需要加上static
197.     // 而没有this指针, 又无法调用HandlerReques函数
198.     // 解决方法: 封装ThreadData结构体
199.     static void *ThreadEntry(void *argc)
200.     {
201.         pthread_detach(pthread_self()); // 线程分离: 线程退出时由操作系统自动回收, 防止类似僵尸进程的问题
202.         ThreadData *data = (ThreadData *)argc;
203.         data->self->HandlerRequest(data->sockfd);
204.         return nullptr;
205.     }
207.     void Stop()
208.     {
209.         _isrunning = false;
210.     }
212. private:
213.     int _listensockfd; // 监听套接字
214.     uint16_t _port;
215.     bool _isrunning;
217.     handler_t _handler; // 处理客户端发来的任务
218. };

复制代码

10.TcpServer.cc

1. #include <memory>
3. #include "TcpServer.hpp"
4. #include "CommandExecute.hpp"
6. int main()
7. {
8.     ENABLE_CONSOLE_LOG();
10.     Command cmd;
11.     std::shared_ptr<TcpServer> tsvr = std::make_shared<TcpServer>([&cmd](std::string cmdstr){
12.         return cmd.Execute(cmdstr);
13.     });
14.    
15.     tsvr->InitServer();
16.     tsvr->Start();
18.     return 0;
19. }

复制代码

11.TcpClient.cc

1. #include <iostream>
2. #include <string>
3. #include <cstring>
4. #include <unistd.h>
6. #include <sys/types.h>
7. #include <sys/socket.h>
8. #include <netinet/in.h>
9. #include <arpa/inet.h>
11. #include "Common.hpp"
13. // ./client_tcp server_ip server_port
14. int main(int argc, char *argv[])
15. {
16.     if (argc != 3)
17.     {
18.         std::cout << "Usage: ./client_tcp server_ip server_port" << std::endl;
19.         return 1;
20.     }
22.     std::string server_ip = argv[1];
23.     int server_port = std::stoi(argv[2]);
25.     // 1. 创建套接字
26.     int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
27.     if (sockfd < 0)
28.     {
29.         std::cout << "socket error" << std::endl;
30.         return 2;
31.     }
33.     // 2. 客户端不需要显示的进行绑定, 但是需要连接服务器, 在建立连接的过程由操作系统进行绑定IP和端口号
34.     struct sockaddr_in server;
35.     memset(&server, 0, sizeof(server));
36.     server.sin_family = AF_INET;
37.     server.sin_port = ::htons(server_port);
38.     server.sin_addr.s_addr = ::inet_addr(server_ip.c_str());
40.     int n = ::connect(sockfd, CONV(&server), sizeof(server));
41.     if (n < 0)
42.     {
43.         std::cout << "connect error" << std::endl;
44.         return 3;
45.     }
47.     std::string message;
48.     while (true)
49.     {
50.         char inbuffer[1024];
51.         std::cout << "input message: ";
52.         std::getline(std::cin, message);
54.         // 3. 向服务器发送消息
55.         n = ::write(sockfd, message.c_str(), message.size());
56.         if (n > 0)
57.         {
58.             // 4. 读取服务器发送来的消息
59.             int m = ::read(sockfd, inbuffer, sizeof(inbuffer) - 1);
60.             if (m > 0)
61.             {
62.                 inbuffer[m] = 0;
63.                 std::cout << inbuffer << std::endl;
64.             }
65.             else break;
66.         }
67.         else break;
68.     }
70.     ::close(sockfd);
72.     return 0;
73. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。