Linux学习记录——삼십일 socket编程---TCP套接字

---

TCP套接字简单通信

本篇gitee

学习完udp套接字通信后，再来看TCP套接字。

四个文件tcp_server.hpp， tcp_server.cc，tcp_client.cc，makefile。

makefile

.PHONY: all
all:tcp_client tcp_servertcp_client:tcp_client.ccg++ -o $@ $^ -std=c++11 -lpthreadtcp_server:tcp_server.ccg++ -o $@ $^ -std=c++11 -lpthread.PHONY: clean
clean:rm -f tcp_client tcp_server

1、服务端

1、基本框架

和udp的有些一样。我们有些序列需要主机转网络，但发送的消息不需要，是因为操作系统会自动转大小端，处理交互用的消息。

tcp_server.hpp

#pragma once#include <iostream>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"namespace ns_server
{static const uint16_t defaultport = 8081;class TcpServer{public:TcpServer(uint16_t port = defaultport): port_(port){}void initDerver(){//1. 创建socketsock = socket(AF_INET, SOCK_STREAM, 0);if(sock < 0){std::cerr << "create socket fail" << std::endl;exit(SOCKET_ERR);}//2. 绑定struct sockaddr_in local;memset(&local, 0, sizeof(local));local.sin_family = AF_INET;local.sin_port = htons(port_);local.sin_addr.s_addr = htonl(INADDR_ANY);//也可以直接写INADDR_ANYif(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){std::cerr << "bind socket fail" << std::endl;exit(BIND_ERR);}}void start(){}~TcpServer(){}private:uint16_t port_;//只要是服务器，就要有端口号int sock;};
};

err.hpp

#pragma onceenum
{USAGE_ERR = 1,SOCKET_ERR,BIND_ERR
};

tcp_server.cc

#include "tcp_server.hpp"
using namespace std;
using namespace ns_server;int main()
{unique_ptr<TcpServer> tsvr(new TcpServer());tsvr->initServer();tsvr->start();return 0;
}

tcp_client.cc

#include <iostream>int main()
{return 0;
}

接下来开始就是tcp的部分了。tcp是面向连接的，它不像udp一样可以直接接发消息，它得需要先连接再通信。

backlog先不用管，设置成一个小的数字就行。在类前设置一下

    static const uint16_t defaultport = 8081;static const int backlog = 32;

            //3. 监听（先让客户端连接过来，才能通信，而服务端就得一直等着连接）if(listen(sock, backlog) < 0){std::cerr << "listen socket fail" << std::endl;exit(LISTEN_ERR);//err.hpp就得加一个LISTEN.ERR}

开始写start函数。

        void start(){quit_ = false;while(!quit_){//4. 客户端要连接，服务端就要先获取连接sleep(1);}}

写到这里就可以启动试试了。./tcp_server，用netstat命令来查看是否启动成功，后面的命令选项，-nltp，n把能显示成数字的显示成数字，l就是listen，t是指tcp，p是进程，打出来的内容中就有一个处于监听状态，IP地址是0.0.0.0的一个进程，显示出了它的PID，以及还有程序名字tcp_server。

2、获取连接

服务端必须处于监听状态，客户端才能来连接它。连接用的函数是accept。

addr和addrlen是客户端的数据。sockfd是一个套接字。

它的返回值实际也是一个文件描述符。accept接口，sockfd是用来监听的套接字，也就是用来连接客户端的，而它的返回值则是用来处理数据的。前面创建的sock就是这里的sockfd，为了方便，我们把它改名为listensock_。

                struct sockaddr_in client;socklen_t len = sizeof(client);//4. 客户端要连接，服务端就要先获取连接int sock = accept(listensock_, (struct sockaddr*)&client, &len);

连接有可能失败，比如客户端不连接这个服务端，但这对于服务端并没有什么，它继续连接其它客户端就好，所以即使失败也继续。

        void start(){quit_ = false;while(!quit_){struct sockaddr_in client;socklen_t len = sizeof(client);//4. 客户端要连接，服务端就要先获取连接int sock = accept(listensock_, (struct sockaddr*)&client, &len);if(sock < 0){std::cerr << "accept error" << std::endl;continue;}std::string clientip = inet_ntoa(client.sin_addr);uint16_t clientport = ntohs(client.sin_port);//5. 获取新连接成功，开始业务处理std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;service(sock);}}

写用来处理数据的函数service。先写一个读写操作。我们用socket创建的tcp套接字是流式套接字，访问时也是用字节流来访问的，想要读取数据，就用read系统调用来读取。read可以读文件，也可以读网络，就对应了Linux一切皆文件。

        void service(int sock){char buffer[1024];while(true){ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if(s > 0) {buffer[s] = 0;std::cout << buffer << std::endl;}else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了{close(sock);std::cout << "client quit, me too" << std::endl;break;}else{close(sock);std::cerr << "read error: " << strerror(errno) << std::endl;break;}}}

这里只写了打印语句。接下来用回调来完成对数据的处理。
引入头文件functional。

加上成员变量func_t func_。

命名空间里的类的前面加上using func_t = std::function<std::string(const std::string&)>。

在读取成功后，buffer[s] = 0下一行加上std::string res = func_(buffer)。

初始化里也得初始化TcpServer(func_t func, uint16_t port = defaultport): func_(func), port_(port), quit_(true)。

然后在tcp_server.cc中写上回调函数。

#include "tcp_server.hpp"
using namespace std;
using namespace ns_server;static void usage(string proc)
{cout << "Usage:\n\t" << proc << " port\n" << endl;
}string echo(const string& message)
{return message;//简单的返回
}int main(int argc, char* argv[])
{if(argc != 2){usage(argv[0]);exit(USAGE_ERR);}uint16_t port = atoi(argv[1]);unique_ptr<TcpServer> tsvr(new TcpServer(echo, port));tsvr->initServer();tsvr->start();return 0;
}

hpp文件中连接成功后调用回调函数，用的是res来接收，那么下面就不用打印buffer了，打印res就好了。然后再把res写给连接过来的客户端。

                if(s > 0) {buffer[s] = 0;std::string res = func_(buffer);std::cout << res << std::endl;write(sock, res.c_str(), res.size());}

2、客户端

客户端全部都写在一个tcp_client.cc文件中。

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
using namespace std;static void usage(string proc)
{cout << "Usage:\n\t" << proc << " port\n" << endl;
}int main(int argc, char* argv[])
{if(argc != 3){usage(argv[0]);exit(USAGE_ERR);}uint16_t serverport = atoi(argv[2]);string serverip = argv[1];//1. 创建套接字int sock = socket(AF_INET, SOCK_STREAM, 0);if(sock < 0){cerr << "socket error : " << strerror(errno) << endl;exit(SOCKET_ERR);}return 0;
}

客户端需要绑定吗？需要绑定，但不需要自己绑定，因为客户端来源于很多处，所以靠系统来绑定，防止端口冲突。客户端需要监听吗？服务端是监听的，客户端则不需要，客户端是连接服务端的，服务端是等待被连接的，所以客户端不需要监听listen，也不需要获取连接accept。

客户端需要做的是连接。用connect接口。

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "err.hpp"
using namespace std;static void usage(string proc)
{cout << "Usage:\n\t" << proc << " port\n" << endl;
}int main(int argc, char* argv[])
{if(argc != 3){usage(argv[0]);exit(USAGE_ERR);}uint16_t serverport = atoi(argv[2]);string serverip = argv[1];//1. 创建套接字int sock = socket(AF_INET, SOCK_STREAM, 0);if(sock < 0){cerr << "socket error : " << strerror(errno) << endl;exit(SOCKET_ERR);}//2. 发起连接struct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);inet_aton(serverip.c_str(), &server.sin_addr);int cnt = 5;while(connect(sock, (struct sockaddr*)&server, sizeof(server)) != 0){cout << "正在尝试重连，重连次数还有: " << cnt-- << endl;if(cnt <= 0) break;}if(cnt <= 0){cerr << "连接失败..." << endl;exit(CONNECT_ERR);}//3. 连接成功char buffer[1024];while(true){string line;cout << "Enter>> ";getline(cin, line);write(sock, line.c_str(), line.size());ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if(s > 0){buffer[s] = 0;cout << "server echo >>>" << buffer << endl;}else if(s == 0){cerr << "server quit" << endl;break;}else{cerr << "read error: " << strerror(errno) << endl;break;}}close(sock);return 0;
}

3、多进程

为了让效果更明显，我们对代码做一些变更。

服务端的这部分代码，对service改一下。除了传客户端的套接字，再传进去ip和port。

        void service(int sock, const std::string &clientip, const uint16_t &clientport){std::string who = clientip + "-" + std::to_string(clientport);char buffer[1024];while(true){ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if(s > 0) {buffer[s] = 0;std::string res = func_(buffer);std::cout << who << ">>>" << res << std::endl;write(sock, res.c_str(), res.size());}else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了{close(sock);std::cout << who << "quit, me too" << endl;break;}else{close(sock);std::cerr << "read error: " << strerror(errno) << std::endl;break;}}}

这样就能看出来连接的是哪个客户端，哪个客户端的消息，哪个客户端退出了。

当我们把现在所有的代码编译启动后，会发现有问题。同时开两个客户端，连接好后，只有一个在服务端那里出现了连接的消息，另一个没有，并且另一个发消息，服务端也没有打印出来，只有连接上的那个能打印消息；当把两个客户端都退出时，之前连接上的那个正常退出，而紧接着，没连接上的那个这时却打印了连接成功的消息，并且文件描述符和之前连接的那个一样，也就是说，它是在上一个文件取消连接后才去连接的，所以文件描述符是同一个数字，并且之前没有打印出来的消息这时也都打印出来了。

这就说明，目前的服务端无法处理多个客户端。我们得让服务端能多进程运行。

                //5. 获取新连接成功，开始业务处理std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;//service(sock, clientip, clientport); pid_t id = fork();if(id < 0){close(sock);continue;}//子进程会继承父进程的fd，但父子不是用同一张文件描述表的，子进程会拷贝父进程的//子进程一定有sock和listensock//分工明确一下，父进程负责获取连接，子进程处理数据，所以两个进程都要close不需要的部分else if(id == 0){close(listensock_);service(sock, clientip, clientport); exit(0);}close(sock);//如果父进程不关闭，一直accept，一直往下开文件描述符，文件描述符存储在数组中，总有满的时候，就会造成文件描述符泄漏pid_t ret = waitpid(id, nullptr, 0);if(ret == id) std::cout << "wait child " << id << " succeed" << std::endl;

这里面有个明显的问题，等待默认是阻塞的，所以父进程还是在串行运行的。我们可以用非阻塞式运行，0换成WHOHANG，但是假如最后一个客户端已经连接上了，子进程在处理，父进程回去继续accept，子进程退出后，父进程还卡在那里，没办法退出了，所以不行；还可以用signal函数，子进程退出时会发出SIG_CHILD信号，那么对它捕捉并用handler处理就行，但不如直接忽略掉这个信号更方便，所以这里采用忽略。

除了忽略，还有一个办法。

                else if(id == 0){close(listensock_);if(fork() > 0) exit(0);//到这里时，子进程已经退了，孙子进程在运行//子进程退，父进程就wait结束，也退了//这时候孙子进程是孤儿进程，由系统管理，所以不需要担心它的回收service(sock, clientip, clientport); exit(0);}

但fork太多，对系统要求也高，所以直接忽略就好。现在再次运行，会发现所有的客户端的文件描述符都是一个数字，这是因为有了多进程后，一个客户端连接上，子进程就会把这个客户端拿过来处理，而父进程那边给关闭了这个文件描述符，再去获取下一个连接，所以父进程给客户端分配的一直都是一个文件描述符。

4、多线程

多进程还是不够高效，把处理数据的部分换成多线程。

    class TcpServer;class ThreadData{public:ThreadData(int fd, const std::string &ip, const uint16_t &port, TcpServer* ts): sock(fd), clientip(ip), clientport(port), current(ts){}public:int sock;std::string clientip;uint16_t clientport;TcpServer *current;};

        void start(){//signal(SIGCHLD, SIG_IGN);quit_ = false;while(!quit_){struct sockaddr_in client;socklen_t len = sizeof(client);//4. 客户端要连接，服务端就要先获取连接int sock = accept(listensock_, (struct sockaddr*)&client, &len);if(sock < 0){std::cerr << "accept error" << std::endl; continue;}std::string clientip = inet_ntoa(client.sin_addr);uint16_t clientport = ntohs(client.sin_port);//5. 获取新连接成功，开始业务处理std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;pthread_t tid;ThreadData* td = new ThreadData(sock, clientip, clientport, this);pthread_create(&tid, nullptr, threadRoutine, td);}}static void* threadRoutine(void* args){ThreadData* td = static_cast<ThreadData*>(args);td->current->service(td->sock, td->clientip, td->clientport);delete td;//service完后退出}

线程要不要关闭不要的套接字？不需要，因为多个线程共享文件描述符，所以不能关掉，关掉后服务端就不能正常运行了。这里要不要回收线程？肯定要，但如果create完后join后，join会阻塞，又会出现多进程里的问题。应当在threadRoutine函数里先detach，分离出当前线程，那么主线程就不需要管理这个分离出去的线程了，它运行完自己结束，而服务端可以继续做自己的工作。

5、线程池

现在的程序是客户端连接过来了，服务端才建立线程，为了更高效，我们可以用线程池来优化。

之前已经写过线程池了。ThreadPool_V4.hpp

#pragma once#include <iostream>
#include <memory>//智能指针的头文件
#include <string>
#include <vector>
#include <queue>
#include <unistd.h>
#include <pthread.h>
#include "Thread.hpp"
#include "task.hpp"
#include "LockGuard.hpp"const static int N = 5;template <class T>
class ThreadPool
{
private:ThreadPool(int num = N) : _num(num)//也可以不初始化_threads，因为我们用的是库，直接push就行{pthread_mutex_init(&_lock, nullptr);pthread_cond_init(&_cond, nullptr);}ThreadPool(const ThreadPool<T> &tp) = delete;//去掉默认生成的拷贝构造void operator=(const ThreadPool<T> &tp) = delete;//去掉默认生成的拷贝赋值public:static ThreadPool<T> *getinstance()//这个要设置成静态的，因为如果cc文件中要调用这个静态对象的函数的话，函数也应当是静态的才行{if(nullptr == instance) //提高效率，减少加锁的次数{LockGuard lockguard(&instance_lock);//用锁类if (nullptr == instance){logMessage(Debug, "线程池单例形成");instance = new ThreadPool<T>();instance->init();instance->start();}}return instance;}pthread_mutex_t *getlock() {return &_lock; }void threadWait() {pthread_cond_wait(&_cond, &_lock); }void threadWakeup() {pthread_cond_signal(&_cond); }bool isEmpty() {return _tasks.empty(); }T popTask(){T t = _tasks.front();_tasks.pop();return t;}static void threadRoutine(void *args)//加static？类内的线程函数，要记得加static，放在静态区，因为在类内会有this指针，导致函数参数类型不对{// pthread_detach(pthread_self());ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);while (true){T t;{//括号里就是临界区//1、检测有没有任务，有就处理，无就等待，这里一定要加锁LockGuard lockguard(tp->getlock());//因为是静态函数，不能直接访问类内私有成员，所以init函数那里要传this指针就可以了while(tp->isEmpty()){tp->threadWait();  }t = tp->popTask();//从公共区域拿到私有区域}//测试t();}}void init(){//插入若干个线程for (int i = 0; i < _num; i++){_threads.push_back(Thread(i, threadRoutine, this));}}void start(){for (auto &t : _threads){t.run();}}void check(){for (auto& t : _threads){std::cout << t.threadname() << " running..." << std::endl;}}void pushTask(const T &t){LockGuard lockgrard(&_lock);//V2是调用系统接口，V3就是调用我们自己写的类，初始化，函数结束时自动析构，也就是释放锁_tasks.push(t);threadWakeup();}~ThreadPool(){for (auto &t : _threads){t.join();}pthread_mutex_destroy(&_lock);pthread_cond_destroy(&_cond);}
private:std::vector<Thread> _threads;//pthread_t是用库中的int _num;std::queue<T> _tasks; // 使用STL的自动扩容pthread_mutex_t _lock;pthread_cond_t _cond;//当没有任务，所有线程应当休息，挂起，所以用条件变量来控制static ThreadPool<T> *instance;//对象static pthread_mutex_t instance_lock;//静态锁
};template <class T>
ThreadPool<T> *ThreadPool<T>::instance = nullptr;template <class T>
pthread_mutex_t ThreadPool<T>::instance_lock = PTHREAD_MUTEX_INITIALIZER;

在tcp_server.hpp里引入这个头文件。这个线程池是默认有5个线程可供使用的。task.hpp要改，不同的场景有不同的任务。

task.hpp先写一个框架

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>class Task
{
public:Task(){}Task(int sock): _sock(sock){}void operator()()//仿函数，在tcp_server.hpp中用t()来调用{}~Task(){}
private:int _sock;
};

接着看tcp_server.hpp文件。

                //5. 获取新连接成功，开始业务处理std::cout << "获取新连接成功: " << sock << " from "<< listensock_ << ", " << clientip << "-" << clientport << std::endl;Task t(sock, clientip, clientport, std::bind(&TcpServer::service, this, std::placeholder::_1, std::placeholder::_2, std::placeholder::_3));//绑定类内用的方法，三个是占位符，前面三个是这个方法的参数ThreadPool<Task>::getinstance()->pushTask(t);

task.hpp中使用回调函数。

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <functional>using cb_t = std::function<void(int, const std::string&, const uint16_t&)>;class Task
{
public:Task(){}Task(int sock, const std::string& ip, const std::uint16_t& port, cb_t cb): _sock(sock), _ip(ip), _port(port), _cb(cb){}void operator()(){_cb(_sock, _ip, _port);}~Task(){}
private:int _sock;std::string _ip;std::uint16_t _port;cb_t _cb;
};

写好后整体运行起来，会有以下的现象。程序貌似不是很快；有的客户端会连接不上，只能重连；文件描述符依次增大，如果有客户端退出，紧接着连接上的客户端就会用上退出的客户端的文件描述符；连不上的客户端等其它客户端退出一些，它们才能连上。因为service函数是一个死循环，一个线程进去执行任务后就出不来了，没有执行任务才会break，线程池也只有5个线程，这样的设计就注定如果5个线程都用上了，其它来连接的就得等着，只能处理短任务。我们也可以使用多线程的办法，在service函数中要调用函数去处理数据时在动用线程池，这样就是多线程内带着线程池。

比较简单的做法就是service变成一次的，而不是死循环，去掉while。线程池的个数也加多一些。

        void service(int sock, const std::string &clientip, const uint16_t &clientport){std::string who = clientip + "-" + std::to_string(clientport);char buffer[1024];ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if(s > 0) {buffer[s] = 0;std::string res = func_(buffer);std::cout << who << ">>>" << res << std::endl;write(sock, res.c_str(), res.size());}else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了{close(sock);std::cout << who << "quit, me too" << endl;}else{close(sock);std::cerr << "read error: " << strerror(errno) << std::endl;}close(sock);}

这样的改动也只是处理简单的操作，IO数据的时候就要有更详细的做法。

6、简单的日志系统

上面的代码一直是用cout来打印消息，但实际上就写日志来记录这些信息。这里要写的日志不是完整的，而是简易版本，用来完成简单的TCP通信。创建一个log.hpp。日志中要使用v开头的几个函数。

日志是有等级的，编译器会给警告，会给报错，就是在打印日志消息。日志要处理多种类的信息。

#pragma once#include <cstdio>
#include <cstring>
#include <cstdarg>#define DEBUG 0//调试信息
#define INFO 1//正常信息
#define WARNING 2//告警，不影响运行
#define ERROR 3//一般错误
#define FATAL 4//严重错误void logMessage(int level, char* format, ...)//...就是可变参数，format是输出格式
{}

要用可变参数，需要用到几个宏

void logMessage(int level, char* format, ...)//...就是可变参数，format是输出格式
{//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数va_list p;//char* //下面是三个宏函数int a = va_arg(p, int);//根据类型提取参数va_start(p, format);//让p指向可变参数部分的起始地址va_end(p);//把p置为空, p = NULL
}

下面写出整个功能实现。

#pragma once#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdarg>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>enum
{Debug = 0,//调试信息Info,//正常信息Warning,//告警，不影响运行Error,//一般错误Fatal,//严重错误Unknown
};static std::string toLevelString(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";}
}static std::string getTime()
{time_t curr = time(nullptr);//拿到当前时间struct tm *tmp = localtime(&curr);//这个结构体有对于时间单位的int变量char buffer[128];snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, \tmp->tm_hour, tmp->tm_min, tmp->tm_sec);//这些tm_的变量就是结构体中自带的，tm_year是从1900年开始算的，所以+1900；月份从0开始，要+1return buffer;
}//日志格式: 日志等级 时间 pid 消息体
//logMessage(DEBUG, "hello: %d, %s", 12, s.c_str()); 12以%d形式打印, s.c_str()以%s形式打印
void logMessage(int level, const char* format, ...)//...就是可变参数，format是输出格式
{//写入到两个缓冲区中char logLeft[1024];//用来显示日志等级，时间，pidstd::string level_string = toLevelString(level);std::string curr_time = getTime();snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());char logRight[1024];//用来显示消息体va_list p;va_start(p, format);//直接用这个接口来对format进行操作，提取信息vsnprintf(logRight, sizeof(logRight), format, p);va_end(p);//打印printf("%s%s\n", logLeft, logRight);//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数//va_list p;//char*//下面是三个宏函数//int a = va_arg(p, int);//根据类型提取参数//va_start(p, format);//让p指向可变参数部分的起始地址//va_end(p);//把p置为空, p = NULL
}

tcp_server.hpp引入这个头文件，以及线程池头文件，都用日志来打印消息，这个在最后的代码链接中会看到。

先放上几句

//5. 获取新连接成功，开始业务处理
logMessage(Info, "获取新连接成功: %d from %d, who: %s - %d", sock, listensock_, clientip.c_str(), clientport);void service(int sock, const std::string &clientip, const uint16_t &clientport){std::string who = clientip + "-" + std::to_string(clientport);char buffer[1024];ssize_t s = read(sock, buffer, sizeof(buffer) - 1);if(s > 0) {buffer[s] = 0;std::string res = func_(buffer);logMessage(Debug, "%s# %s", who.c_str(), res.c_str());write(sock, res.c_str(), res.size());}else if(s == 0)//和管道一样，把写端关闭，如果读到文件结尾就会返回0，而网络这里读到0，说明对方将连接关闭了{close(sock);logMessage(Info, "%s quit,me too", who.c_str());}else{close(sock);logMessage(Error, "read error, %d:%s", errno, strerror(errno));}close(sock);}

7、守护进程

如果关闭服务端，整个程序就不能继续了，但服务端应当一直存在，无论什么时候访问都行，所以我们要写守护进程。创建daemon.hpp。

通常./运行起来程序后都是前台运行，还可以在命令后加上空格和&做到后台运行，但也不能解决问题。

系统有sleep进程，我们可以sleep 10000就可以打开这个可执行文件， 然后用ps ajx | head -1 && axj | grep sleep来查看。进程有进程组，组有组号PGID。SID是会话ID，TTY是终端，有问号的就是对应的进程和终端无关，不是问号的显示的就是终端文件，这个进程打开了这个终端，并向这个终端文件放入内容。用户使用命令ls，pwd这样的时候，就是进程运行时在用户这里打开了终端文件，向这个文件输入内容。

打开的几个程序，如果以管道连接起来，那么PGID，会话id（SID）和终端文件都是一样的，都是第一个进程的，第一个进程也是组长，不过如果我们分为几个前台工作，几个后台工作，假如都是sleep进程，那么后台和前台不同的是PGID，但都是一个会话，打开一个终端文件。sleep的会话id其实就是bash。

会话包含多个线程组，一个线程组包含多个线程；会话关联一个终端文件；进程之间有组关系，组长都是多个进程中的第一个。

当用户登录云服务器时，登录成功会分配一个命令行提示符，也就是用户输入命令时前面的[…@…]这部分，这本质也是一个进程，也属于一个进程组，组内只有它自己，也属于一个会话，这个会话是由bash创建的，这个会话以它来起名，之后所有的用户建立的进程都属于这个会话，只是进程组不同。进程组在会话中，一个会话里，操作系统就给用户创建多个进程组。每次登录都会创建一个新的会话。

为什么要有进程组？jobs命令可以查看当前会话中所有的后台程序，每个后台程序最前面都有1个数字，从1开始，只要增加一个程序就数字就加1，每次创建的一个程序，自成一个进程组，所以PGID不同。前面的数字编号，叫做任务编号，用命令fg 任务编号就可以把这个程序放到前台（后台的任务编号不变），用Ctrl + Z就会让这个程序停止，就会自动回到后台，用bg 任务编号会让这个程序再次运行起来。所以进程组创建是为了完成任务的，一个任务可以由多个进程完成，也可以由一个进程完成。所以用户用命令启动的一个进程，其实就是在启动一个任务。

进程组有前台和后台任务，如果把后台任务提到前台，老的前台任务就无法运行，前台任务只能有一个在运行，比如提到前台后，输入命令就不起作用了，所以用户在用命令行启动一个进程时，bash无法运行。登录云服务器时就是在创建一个会话，会话里有bash任务，启动进程时就是在当前会话中创建新的前台任务，而退出则是销毁会话，会影响会话内部的所有任务。销毁会话就是注销，通常的网络服务器，为了不受到用户登录注销的影响，会以守护进程的方式运行。既然创建的进程都会在一开始登录时创建的会话里，注销时也会注销这个会话，那就让被守护的进程放入另外一个会话，这样注销就不会受影响了，这就是守护进程的做法。

需要用到setsid接口

创建一个会话，设置进程组ID，谁调用这个接口，谁就是组长。返回新会话的ID，也就是这个进程的ID，失败返回-1，错误码被设置。

如何创建守护进程？

核心是setsid接口，但不止这点。要想调用这个接口，不能是组长调用，这样就得保证调用者不是组长。守护进程要忽略异常信号，并对文件描述符012做特殊处理，改变工作路径。进程的工作路径默认为当前路径，但守护进程不想这样，它会放在根目录下，不属于某个用户目录。更改路径这个操作用daemon这个接口，两个参数分别表示要不要更改路径，要不要关闭012。

不过一般是自己来更改路径，不用这个接口。外部的调用逻辑是这样的，也就是tcp_server.cc中

    tsvr->initServer();//将服务器守护进程化Daemon();tsvr->start();

err.hpp中加上SETSID_ERR这个错误

#pragma onceenum
{USAGE_ERR = 1,SOCKET_ERR,BIND_ERR,LISTEN_ERR,CONNECT_ERR,SETSID_ERR
};

如果daemon.hpp这样写

#pragma once#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include "log.hpp"
#include "err.hpp" void Daemon()
{pid_t ret = setsid();if((int)ret == -1){lodMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));exit(SETSID_ERR);}
}

./运行起服务端肯定出错，因为新创建的这个进程自成一组，它是组长，就不行，所以得先让它不是组长，只要不是第一个进程就好了。

void Daemon()
{if(fork() > 0) exit(0);//下面的就是子进程了pid_t ret = setid();if((int)ret == -1){lodMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));exit(SETSID_ERR);}
}

以及还需要忽略异常信号等其它。

#pragma once#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "log.hpp"
#include "err.hpp" void Daemon()
{//1. 忽略信号//这里就忽略两个信号，还可以忽略其它信号signal(SIGPIPE, SIG_IGN);signal(SIGCHLD, SIG_IGN);//2. 避免成为组长if(fork() > 0) exit(0);//下面的就是子进程了//3. 新建会话，自己成为会话的话首进程pid_t ret = setid();if((int)ret == -1){logMessage(Fatal, "daemon error, code: %d, string: %s", errno, strerror(errno));exit(SETSID_ERR);}//4. 可选: 更改守护进程的工作路径//因为我们自定义的一些头文件，这里就不改路径了//chdir("/")//更改为根目录//5. 处理012问题//Linux中有个/dev/null文件，任何向里面输入的内容都会被抛弃，不会被提取内容int fd = open("/dev/null", O_RDWR);//读写方式打开if(fd < 0){logMessage(Fatal, "open error, code: %d, string: %s", errno, strerror(errno));exit(OPEN_ERR);}dup2(fd, 0);dup2(fd, 1);dup2(fd, 2);close(fd);
}

在tcp_server.cc文件中，守护进程后还会有start函数，这个函数里可能有cout，cin等，守护进程后使用这些就会出错，所以要把错误重定向到/dev/null中。守护进程本质是孤儿进程的一种。这时候再次启动服务端就可以了。启动后用命令

ps ajx | head -1 && ps -axj | grep tcp_server

grep后面的就是进程名字。可以发现TTY是?，SID是一个新的组。关闭云服务器后，这个服务端依然可以提供服务。用jobs查看不到。

想要关闭服务端，kill -9 SID就可以。但是还有一个问题，把标准输入输出错误都重定向到/dev/null了，那么日志打印的消息程序员也就看不到了，就不知道服务器会出什么问题了，所以我们还得更改一下log.hpp，让它把消息打印到当前路径的一个文件中。

#pragma once#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdarg>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>const std::string filename0 = "log/tcpserver.log.Debug";
const std::string filename1 = "log/tcpserver.log.Info";
const std::string filename2 = "log/tcpserver.log.Warning";
const std::string filename3 = "log/tcpserver.log.Error";
const std::string filename4 = "log/tcpserver.log.Fatal";
const std::string filename5 = "log/tcpserver.log.Unknown";enum
{Debug = 0,//调试信息Info,//正常信息Warning,//告警，不影响运行Error,//一般错误Fatal,//严重错误Unknown
};static std::string toLevelString(int level, std::string& filename)
{switch(level){case Debug:filename = filename0;return "Debug";case Info:filename = filename1;return "Info";case Warning:filename = filename2;return "Warning";case Error:filename = filename3;return "Error";case Fatal:filename = filename4;return "Fatal";default:filename = filename5;return "Unknown";}
}static std::string getTime()
{time_t curr = time(nullptr);//拿到当前时间struct tm *tmp = localtime(&curr);//这个结构体有对于时间单位的int变量char buffer[128];snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, \tmp->tm_hour, tmp->tm_min, tmp->tm_sec);//这些tm_的变量就是结构体中自带的，tm_year是从1900年开始算的，所以+1900return buffer;
}//日志格式: 日志等级 时间 pid 消息体
//logMessage(DEBUG, "hello: %d, %s", 12, s.c_str()); 12以%d形式打印, s.c_str()以%s形式打印
void logMessage(int level, const char* format, ...)//...就是可变参数，format是输出格式
{//写入到两个缓冲区中char logLeft[1024];//用来显示日志等级，时间，pidstd::string filename;std::string level_string = toLevelString(level, filename);std::string curr_time = getTime();snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());char logRight[1024];//用来显示消息体va_list p;va_start(p, format);//直接用这个接口来对format进行操作，提取信息vsnprintf(logRight, sizeof(logRight), format, p);va_end(p);//打印printf("%s%s\n", logLeft, logRight);//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数//保存到文件中FILE* fp = fopen(filename.c_str(), "a");if(fp == nullptr) return ;fprintf(fp, "%s%s\n", logLeft, logRight);fflush(fp);fclose(fp);//va_list p;//char*//下面是三个宏函数//int a = va_arg(p, int);//根据类型提取参数//va_start(p, format);//让p指向可变参数部分的起始地址//va_end(p);//把p置为空, p = NULL
}

8、其它

man inet_addr会看到很多接口，inet_ntoa是把四字节IP转换为字符串，但它是C接口，返回类型是char*，也就是说返回了指针，返回了地址，而字符串是系统在内存中申请了一块空间来存储，这个位置不需要我们手动释放，但频繁调用，后面的会覆盖前面的地址，也就是说这个接口不是线程安全的，所以在多线程场景中会出问题。不过到现在为止，应当是加上了线程安全，可以用这段代码测试

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>void* Func1(void* p)
{struct sockaddr_in* addr = (struct sockaddr_in*)p;while (1){char* ptr = inet_ntoa(addr->sin_addr);printf("addr1: %s\n", ptr);}  return NULL;
}void* Func2(void* p) 
{struct sockaddr_in* addr = (struct sockaddr_in*)p;while (1) {char* ptr = inet_ntoa(addr->sin_addr);printf("addr2: %s\n", ptr);}return NULL;
}int main()
{pthread_t tid1 = 0;struct sockaddr_in addr1;struct sockaddr_in addr2;addr1.sin_addr.s_addr = 0;addr2.sin_addr.s_addr = 0xffffffff;pthread_create(&tid1, NULL, Func1, &addr1);pthread_t tid2 = 0;pthread_create(&tid2, NULL, Func2, &addr2);pthread_join(tid1, NULL);pthread_join(tid2, NULL);return 0;
}

四字节ip转为字符串还可以用inet_ntop，把IP地址转为字符串，把二进制转为文本，src参数就是IP地址，dst是一个char类型的缓冲区，定义一个buffer[]来保存转化好的字符串。

TCP协议中，服务器监听后，客户端就可以连接了，客户端的connect实际上是在发送报文，操作系统底层进行三次握手处理连接过程，处理完后服务端的accept接口就把这个创建好的连接给用户使用；close时是进行四次挥手来断开连接。建立和断开连接是用户让系统做的。建立时，客户端完成两次操作，服务端完成一次；断开时，双方都close，一次close对应两次操作。

结束。