服务端处理请求

现在TCP服务器已经能够获取连接请求了，下面当然就是要对获取到的连接进行处理。但此时为客户端提供服务的不是监听套接字，因为监听套接字获取到一个连接后会继续获取下一个请求连接，为对应客户端提供服务的套接字实际是accept函数返回的套接字，下面就将其称为“服务套接字”。

为了让通信双方都能看到对应的现象，我们这里就实现一个简单的回声TCP服务器，服务端在为客户端提供服务时就简单的将客户端发来的数据进行输出，并且将客户端发来的数据重新发回给客户端即可。当客户端拿到服务端的响应数据后再将该数据进行打印输出，此时就能确保服务端和客户端能够正常通信了。

read函数

TCP服务器读取数据的函数叫做read，该函数的函数原型如下：

ssize_t read(int fd, void *buf, size_t count);

参数说明：

fd：特定的文件描述符，表示从该文件描述符中读取数据。
buf：数据的存储位置，表示将读取到的数据存储到该位置。
count：数据的个数，表示从该文件描述符中读取数据的字节数。

返回值说明：

如果返回值大于0，则表示本次实际读取到的字节个数。
如果返回值等于0，则表示对端已经把连接关闭了。
如果返回值小于0，则表示读取时遇到了错误。

read返回值为0表示对端连接关闭

这实际和本地进程间通信中的管道通信是类似的，当使用管道进行通信时，可能会出现如下情况：

写端进程不写，读端进程一直读，此时读端进程就会被挂起，因为此时数据没有就绪。

读端进程不读，写端进程一直写，此时当管道被写满后写端进程就会被挂起，因为此时空间没有就绪。

写端进程将数据写完后将写端关闭，此时当读端进程将管道当中的数据读完后就会读到0。

读端进程将读端关闭，此时写端进程就会被操作系统杀掉，因为此时写端进程写入的数据不会被读取。

这里的写端就对应客户端，如果客户端将连接关闭了，那么此时服务端将套接字当中的信息读完后就会读取到0，因此如果服务端调用read函数后得到的返回值为0，此时服务端就不必再为该客户端提供服务了。

write函数

TCP服务器写入数据的函数叫做write，该函数的函数原型如下：

ssize_t write(int fd, const void *buf, size_t count);

参数说明：

fd：特定的文件描述符，表示将数据写入该文件描述符对应的套接字。
buf：需要写入的数据。
count：需要写入数据的字节个数。
返回值说明:

写入成功返回实际写入的字节数，写入失败返回-1，同时错误码会被设置。

当服务端调用read函数收到客户端的数据后，就可以再调用write函数将该数据再响应给客户端。

服务端处理请求

需要注意的是，服务端读取数据是服务套接字中读取的，而写入数据的时候也是写入进服务套接字的。也就是说这里为客户端提供服务的套接字，既可以读取数据也可以写入数据，这就是TCP全双工的通信的体现。

在从服务套接字中读取客户端发来的数据时，如果调用read函数后得到的返回值为0，或者读取出错了，此时就应该直接将服务套接字对应的文件描述符关闭。因为文件描述符本质就是数组的下标，因此文件描述符的资源是有限的，如果我们一直占用，那么可用的文件描述符就会越来越少，因此服务完客户端后要及时关闭对应的文件描述符，否则会导致文件描述符泄漏

class TcpServer
{
public:
    void Service(int sock, std::string client_ip, int client_port)
    {
        char buffer[1024];
        while (true){
            ssize_t size = read(sock, buffer, sizeof(buffer)-1);
            if (size > 0){ //读取成功
                buffer[size] = '\0';
                std::cout << "get a new link->" << sock << " [" << client_ip << "]:" << client_port << std::endl;
 
                write(sock, buffer, size);
            }
            else if (size == 0){ //对端关闭连接
                std::cout << client_ip << ":" << client_port << " close!" << std::endl;
                break;
            }
            else{ //读取失败
                std::cerr << sock << " read error!" << std::endl;
                break;
            }
        }
        close(sock); //归还文件描述符
        std::cout << client_ip << ":" << client_port << " service done!" << std::endl;
    }
    void Start()
    {
        for (;;){
            //获取连接
            struct sockaddr_in peer;
            memset(&peer, '\0', sizeof(peer));
            socklen_t len = sizeof(peer);
            int sock = accept(_listen_sock, (struct sockaddr*)&peer, &len);
            if (sock < 0){
                std::cerr << "accept error, continue next" << std::endl;
                continue;
            }
            std::string client_ip = inet_ntoa(peer.sin_addr);
            int client_port = ntohs(peer.sin_port);
            std::cout << "get a new link [" << client_ip << "]:" << client_port << std::endl;
 
            //处理请求
            Service(sock, client_ip, client_port);
        }
    }
private:
    int _listen_sock; //监听套接字
    int _port; //端口号
};

客户端

客户端创建套接字

同样的，我们将客户端也封装成一个类，当我们定义出一个客户端对象后也需要对其进行初始化，而初始化客户端唯一需要做的就是创建套接字。而客户端在调用socket函数创建套接字时，参数设置与服务端创建套接字时是一样的。

客户端不需要进行绑定和监听：

服务端要进行绑定是因为服务端的IP地址和端口号必须要众所周知，不能随意改变。而客户端虽然也需要IP地址和端口号，但是客户端并不需要我们进行绑定操作，客户端连接服务器时系统会自动指定一个端口号给客户端。
服务端需要进行监听是因为服务端需要通过监听来获取新连接，但是不会有人主动连接客户端，因此客户端是不需要进行监听操作的。

此外，客户端必须要知道它连接的服务端的IP地址和端口号，因此客户端除了要有自己的套接字之外，还需要知道服务端的IP地址和端口号，这样客户端才能够通过套接字向指定服务器进行通信。

class TcpClient
{
public:
    TcpClient(std::string server_ip, int server_port)
        : _sock(-1)
        , _server_ip(server_ip)
        , _server_port(server_port)
    {}
    void InitClient()
    {
        //创建套接字
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0){
            std::cerr << "socket error" << std::endl;
            exit(2);
        }
    }
    ~TcpClient()
    {
        if (_sock >= 0){
            close(_sock);
        }
    }
private:
    int _sock; //套接字
    std::string _server_ip; //服务端IP地址
    int _server_port; //服务端端口号
};

客户端连接服务器

由于客户端不需要绑定，也不需要监听，因此当客户端创建完套接字后就可以向服务端发起连接请求。

connect函数

发起连接请求的函数叫做connect，该函数的函数原型如下:

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

参数说明：

sockfd：特定的套接字，表示通过该套接字发起连接请求。
addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。
addrlen：传入的addr结构体的长度。

返回值说明:

连接或绑定成功返回0，连接失败返回-1，同时错误码会被设置。

客户端连接服务器

需要注意的是，客户端不是不需要进行绑定，而是不需要我们自己进行绑定操作，当客户端向服务端发起连接请求时，系统会给客户端随机指定一个端口号进行绑定。因为通信双方都必须要有IP地址和端口号，否则无法唯一标识通信双方。也就是说，如果connect函数调用成功了，客户端本地会随机给该客户端绑定一个端口号发送给对端服务器。

此外，调用connect函数向服务端发起连接请求时，需要传入服务端对应的网络信息，否则connect函数也不知道该客户端到底是要向哪一个服务端发起连接请求。

class TcpClient
{
public:
    void Start()
    {
        struct sockaddr_in peer;
        memset(&peer, '\0', sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(_server_port);
        peer.sin_addr.s_addr = inet_addr(_server_ip.c_str());
        
        if (connect(_sock, (struct sockaddr*)&peer, sizeof(peer)) == 0){ //connect success
            std::cout << "connect success..." << std::endl;
            Request(); //发起请求
        }
        else{ //connect error
            std::cerr << "connect failed..." << std::endl;
            exit(3);
        }
    }
private:
    int _sock; //套接字
    std::string _server_ip; //服务端IP地址
    int _server_port; //服务端端口号
};

客户端发起请求

由于我们实现的是一个简单的回声服务器，因此当客户端连接到服务端后，客户端就可以向服务端发送数据了，这里我们可以让客户端将用户输入的数据发送给服务端，发送时调用write函数向套接字当中写入数据即可。

当客户端将数据发送给服务端后，由于服务端读取到数据后还会进行回显，因此客户端在发送数据后还需要调用read函数读取服务端的响应数据，然后将该响应数据进行打印，以确定双方通信无误。

class TcpClient
{
public:
    void Request()
    {
        std::string msg;
        char buffer[1024];
        while (true){
            std::cout << "Please Enter# ";
            getline(std::cin, msg);
 
            write(_sock, msg.c_str(), msg.size());
 
            ssize_t size = read(_sock, buffer, sizeof(buffer)-1);
            if (size > 0){
                buffer[size] = '\0';
                std::cout << "server echo# " << buffer << std::endl;
            }
            else if (size == 0){
                std::cout << "server close!" << std::endl;
                break;
            }
            else{
                std::cerr << "read error!" << std::endl;
                break;
            }
        }
    }
    void Start()
    {
        struct sockaddr_in peer;
        memset(&peer, '\0', sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(_server_port);
        peer.sin_addr.s_addr = inet_addr(_server_ip.c_str());
        
        if (connect(_sock, (struct sockaddr*)&peer, sizeof(peer)) == 0){ //connect success
            std::cout << "connect success..." << std::endl;
            Request(); //发起请求
        }
        else{ //connect error
            std::cerr << "connect failed..." << std::endl;
            exit(3);
        }
    }
private:
    int _sock; //套接字
    std::string _server_ip; //服务端IP地址
    int _server_port; //服务端端口号
};

在运行客户端程序时我们就需要携带上服务端对应的IP地址和端口号，然后我们就可以通过服务端的IP地址和端口号构造出一个客户端对象，对客户端进行初始后启动客户端即可。

void Usage(std::string proc)
{
    std::cout << "Usage: " << proc << "server_ip server_port" << std::endl;
}
int main(int argc, char* argv[])
{
    if (argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    std::string server_ip = argv[1];
    int server_port = atoi(argv[2]);
    TcpClient* clt = new TcpClient(server_ip, server_port);
    clt->InitClient();
    clt->Start();
    return 0;
}