【网络】网络编程套接字

// 创建 socket 
// 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address,
                   socklen_t address_len);

// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,
                   socklen_t* address_len);

// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);

2、sockaddr结构

socket API 是一层抽象的网络编程接口，适用于各种底层网络协议，如IPv4、 IPv6，以及后面要讲的UNIX Domain Socket。然而，各种网络协议的地址格式并不相同：

IPv4和IPv6的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in结构体表示，包括16位地址类型，16位端口号和32位IP地址。
IPv4、 IPv6地址类型分别定义为常数AF_INET、 AF_INET6。这样，只要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址类型字段确定结构体中的内容。
socket API可以都用struct sockaddr* 类型表示，在使用的时候需要强制转化成sockaddr_in。这样的好处是程序的通用性，可以接收IPv4，IPv6，以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数。
socket API之所以不用 void* 类型表示，仅仅是因为当时没有 void*，后来有了void* 之后，也就没有必要专门再改了。

3、sockaddr结构体

3.1、sockaddr结构体

3.2、sockaddr_in结构体

虽然socket api的接口是sockaddr，但是我们真正在基于IPv4编程时，使用的数据结构是sockaddr_in。这个结构里主要有三部分信息：地址类型（__SOCKADDR_COMMON (sin_)），端口号（sin_port），IP地址（sin_addr）。

__SOCKADDR_COMMON是一个宏：

## 可以把它两边的符号合成一个符号。所以最终整个 __SOCKADDR_COMMON (sin_) 语句会被替换为 sa_family_t sin_family 。sa_family_t是类型，sin_family 是变量。

in_addr 类型用来表示一个IPv4的IP地址，其实就是一个32位的整数。

下面的 sin_zero 是填充字段。

地址转换函数：

只介绍基于IPv4的socket网络编程，sockaddr_in中的成员struct in_addr sin_addr表示32位的IP地址。但是我们通常用点分十进制的字符串表示IP地址，以下函数可以在字符串表示和in_addr表示之间转换。

因为我们常见的IP地址都是字符串风格的，而 in_addr_t 是四字节整数类型，所以需要进行类型转化。字符串转in_addr的函数：

in_addr_t inet_addr(const char *cp);

inet_addr 函数在把字符串风格数据转换成四字节整数的同时，也把主机序列转换成了网络序列。

in_addr转字符串的函数：

四、简单的UDP网络程序

1、创建套接字接口

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

socket 函数中， domain 是 16 位地址类型。 type 是套接字服务类型可设为 SOCK_STREAM （流式套接）、SOCK_DGRAM（用户数据报）。 protocol 表明使用哪种协议，指明了 type 后， protocol 设置为 0 ，系统自动判定是 TCP 还是 UDP。函数运行成功，返回值是文件描述符。失败则返回 -1，并且错误码会被设置。

void InitServer()
{
    _sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(_sock < 0)
    {
        cerr << "create socket error: " << strerror(errno) << endl;
        exit(1);
    }
    cout << "create socket success: " << _sock << endl;
}

编译运行：

2、绑定端口号

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

bind 函数中， sockfd 是 socket 函数的返回值。 addr 是 sockaddr 结构体指针。 addrlen 是结构体大小。 bind 函数执行成功，返回 0，失败返回 -1，并且错误码会被设置。

void InitServer()
{
    //1.创建socket接口，打开网络文件
    _sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (_sock < 0)
    {
        cerr << "create socket error: " << strerror(errno) << endl;
        exit(SOCKET_ERR);
    }
    cout << "create socket success: " << _sock << endl;

    //2.给服务器指明IP地址和端口号
    struct sockaddr_in local; // 这个local是一个局部变量，被定义在用户空间的特定函数的栈帧上，不    
                              //在内核中。
    bzero(&local, sizeof(local));//清零

    local.sin_family = AF_INET;
    local.sin_port = htons(_port); //把本地主机构建的port序列转成网络序列

    //1.字符串风格的IP地址，转换成4字节int类型
    //2.将主机序列转化称为网络序列
    local.sin_addr.s_addr = inet_addr(_ip.c_str());

    //int n = bind(_sock, (struct sockaddr*)&local, sizeof(local));
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0) //把local绑定到了内核中
    {
        cerr << "bind socket error: " << strerror(errno) << endl;
        exit(BIND_ERR);
    }
    cout << "bind socket success: " << _sock << endl;
}

编译运行：

云服务器不需要bind IP地址，需要让服务器自己指定IP地址。

因为一个服务器中可能有多张网卡，如果指定了其中一个IP，那么服务器就只能接收该IP递交的数据报，会导致服务器处理的数据量变少。为了使服务器能够接收所有发送到这台机器上的数据，只需要指定端口号就可以了。

3、服务器运行

从套接字中获取数据报：

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

recvfrom 函数的参数列表中， sockfd 是服务端绑定的套接字。 buf 是我们自己定义的用于接收数据的缓冲区。 len 是缓冲区长度。 flags 表示读取方式，默认以阻塞方式读取。 src_addr 是客户端的IP地址+端口号，目的是为了找到是谁发来的数据，这是一个输入输出型参数，在输入时，就应该加上输入接收缓冲区，输出时，包含客户端的IP和端口号。 addrlen 是实际输出时，结构体的大小。返回值是实际读取到的字节数。

编写服务端接收数据的代码：

void Start()
{
    char buffer[1024];
    while (1)
    {
        //接收
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int n = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&peer, &len);
        if (n > 0)
            buffer[n] = '\0';
        else continue;

        //提取client信息
        string clientip = inet_ntoa(peer.sin_addr);
        uint16_t clientport = ntohs(peer.sin_port);
        cout << clientip << " - " << clientport << " # "  << buffer << endl;
    }
}

发送数据函数接口：

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

sendto 函数的参数列表基本与 recvfrom 函数一一对应。

sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, sizeof(peer));

在发送时，不需要手动把本地序列转换成网络序列，因为sendto函数会自动进行转换。

4、创建客户端

因为一台设备上可以运行很多客户端，即运行着很多进程，这些进程都是独立的，这就意味着每一个客户端的端口号一定不能是固定的，以防止新启动客户端的端口号已经被别人占用。

所以客户端绑定端口号，不能自己绑定，而是需要OS来分配，防止客户端出现启动冲突。

至于为什么client的端口号不能自己绑定，但是server的端口号就可以自己绑定呢？

这是因为server的端口号必须要众所周知，且不能随意改变。另外，同一家公司的端口号需要统一规范化，如果发生冲突，可以很快的内部解决。

在我们首次使用系统调用发送数据的时候，OS会在底层随机选择客户端端口号与IP，进行绑定操作，并构建发送的数据报文。

创建代码：

static void usage(string proc)
{
    cout << "Usage: \n\t" << proc << " serverip serverport\n" << endl;
}

// udp_client IP 端口号 命令+命令选项一共三个
int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(USAGE_ERR);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        cerr << "create socket error" << endl;
        exit(SOCKET_ERR);
    }

    //client不需要自己绑定，由OS自动进行绑定

    //明确server是谁
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    while (1)
    {
        //用户输入
        string message;
        cout << "please Enter# ";
        cin >> message;

        //发送数据
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));

        //接收数据
        char buffer[1024];
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        int n = recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&temp, &len);
        if (n > 0)
        {
            buffer[n] = 0;
            cout << "server echo# " << buffer << endl;
        }
    }

    return 0;
}

5、数据传输

5.1、本地数据传输

127.0.0.1 ：本地环回，表示当前主机，通常用来进行本地通信或测试。

运行程序观察结果：

client发送的数据，server可以接收到。

5.2、网络数据传输

6、业务处理

我们编写的网络服务器刚刚解决的是网络IO的问题，要进行业务处理才是我们真正的目的。

现在实现一个小写转大写的服务，只需要在server发送数据之前对数据进行相应处理就可以了：

//server.cc

//上层的业务处理，不需要关心网络发送，只负责信息处理即可
string transactionString(string request)
{
    string result;
    char c;
    for(auto& r : request)
    {
        if(islower(r))
            c = toupper(r);

        result.push_back(c);
    }
    return result;
}

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);
    unique_ptr<UdpServer> usvr(new UdpServer(transactionString,port)); 

    usvr->InitServer();
    usvr->Start();

    return 0;
}

//server.hpp
//...
using func_t = function<string(string)>;
class UdpServer
{
public:
    UdpServer(func_t cb, uint16_t port = default_port)
        :_service(cb)
        , _port(port)
    {
        cout << "server addr: " << _port << endl;
    }

    //....

    void Start()
    {
        char buffer[1024];
        while (1)
        {
            //接收
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int n = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&peer, &len);
            if (n > 0)
                buffer[n] = '\0';
            else continue;

            //提取client信息
            string clientip = inet_ntoa(peer.sin_addr);
            uint16_t clientport = ntohs(peer.sin_port);
            cout << clientip << " - " << clientport << " # " << buffer << endl;

            //做业务处理
            string response = _service(buffer);

            //发送
            sendto(_sock, response.c_str(), response.size(), 0, (struct sockaddr*)&peer, sizeof(peer));
        }
    }

    ~UdpServer()
    {}
private:
    int _sock;
    uint16_t _port;
    func_t _service;
    //string _ip;
};

运行观察结果：

7、多线程业务处理

现在实现一个消息收发服务器，在服务器与客户端中分别创建两个线程，一个只用来收消息，另一个只用来发消息。

完整实现代码：

//Thread.hpp
#pragma once

#include <iostream>
#include <pthread.h>
#include <functional>
#include <string>
#include <cstdlib>

using namespace std;


class Thread
{
public:
    typedef enum
    {
        NEW = 0,
        RUNNING,
        EXITED
    }ThreadStatus;
    // typedef void (*func_t)(void*);
    using func_t = function<void ()>;

public:
    Thread(int num, func_t func)
    :_tid(0)
    ,_status(NEW)
    ,_func(func)
    {
        char name[128];
        snprintf(name, sizeof(name), "thread-%d", num);
        _name = name;
    }

    int status()
    {
        return _status;
    }

    string threadname()
     {
        return _name;
     }

    pthread_t threadid()
    {
        return _tid;
    }

    //因为类的成员函数有this指针，占用了回调函数的void*类型的参数，所以要定义成static类型
    static void* runHelper(void* args)
    {
        Thread* ts = (Thread*)args;
        //_func(ts->_args );
        (*ts)(); //使用仿函数的形式调用func函数

        return nullptr;
    }

    void operator()()
    {
        _func();
    }

    void run()
    {
        int n = pthread_create(&_tid, nullptr, runHelper, this); //这里传参传的是 this 指针，为了static类型的回调函数可以访问类属性和其他成员函数
        if(n != 0)
            exit(1);
        _status = RUNNING;
    }

    void join()
    {
        int n = pthread_join(_tid, nullptr);
        if(n != 0)
        {
            cerr << "main thread join thread " << _name << " error" << endl;
            return;
        }
        _status = EXITED;
    }

    ~Thread()
    {}

private:
    pthread_t _tid;
    string _name;
    func_t _func; //线程未来要执行的回调

    ThreadStatus _status;
};


//RingQueue.hpp
#pragma once

#include <iostream>
#include <vector>
#include <mutex>
#include <semaphore.h>

using namespace std;

static const int N = 5;

template<class T>
class RingQueue
{
public:
    RingQueue(int num = N)
    :_ring(num)
    ,_cap(num)
    ,_c_step(0)
    ,_p_step(0)
    {
        sem_init(&_data_sem, 0, 0);
        sem_init(&_space_sem, 0, num);

        pthread_mutex_init(&_c_mtx, nullptr);
        pthread_mutex_init(&_p_mtx, nullptr);
    }

    //生产
    void push(const T& in)
    {
        P(_space_sem);
        Lock(_p_mtx);
        //一定拿到了对应的空间资源！不用再做判断
        
        //确定拿到了哪一个资源
        _ring[_p_step++] = in;
        _p_step %= _cap;
        Unlock(_p_mtx);
        V(_data_sem);
    }

    //消费
    void pop(T* out)
    {
        P(_data_sem);
        Lock(_c_mtx);

        *out = _ring[_c_step++];
        _c_step %= _cap;
        Unlock(_c_mtx);
        V(_space_sem);
    }

    ~RingQueue()
    {
        sem_destroy(&_data_sem);
        sem_destroy(&_space_sem);

        pthread_mutex_destroy(&_c_mtx);
        pthread_mutex_destroy(&_p_mtx);
    }

private:
    void P(sem_t& s)
    {
        sem_wait(&s);
    }

    void V(sem_t& s)
    {
        sem_post(&s);
    }

    void Lock(pthread_mutex_t& m)
    {
        pthread_mutex_lock(&m);
    }

    void Unlock(pthread_mutex_t& m)
    {
        pthread_mutex_unlock(&m);
    }

private:
    std::vector<T> _ring;
    int _cap; //环形队列的容量
    sem_t _data_sem; //只有消费者关心
    sem_t _space_sem; //只有生产者关心
    int _c_step;     //消费位置
    int _p_step;     //生产位置

    pthread_mutex_t _c_mtx;  //消费者的锁
    pthread_mutex_t _p_mtx;  //生产者的锁
};

//LockGuard.hpp
#pragma once

#include <iostream>
#include <pthread.h>

using namespace std;

class Mutex //自己不维护锁，由外部传入
{
public:
    Mutex(pthread_mutex_t* mutex)
    :_pmutex(mutex)
    {}

    void lock()
    {
        pthread_mutex_lock(_pmutex); 
    }

    void unlock()
    {
        pthread_mutex_unlock(_pmutex);
    }

    ~Mutex()
    {}

private:
    pthread_mutex_t* _pmutex;
};

class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mutex)
    :_mutex(mutex)
    {
        _mutex.lock();
    }

    ~LockGuard()
    {
        _mutex.unlock();
    }
private:
    Mutex _mutex;
};

//error.hpp
#pragma once

enum
{
    USAGE_ERR = 1,
    SOCKET_ERR,
    BIND_ERR
};


//udp_server.hpp
#pragma once

#include <iostream>
#include <strings.h>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unordered_map>
#include "error.hpp"
#include "RingQueue.hpp"
#include "lockGuard.hpp"
#include "Thread.hpp"
using namespace std;
namespace ns_server
{
    const static uint16_t default_port = 8080;
    using func_t = function<string(string)>;

    class UdpServer
    {
    public:
        UdpServer(uint16_t port = default_port)
            : _port(port)
        {
            cout << "server addr: " << _port << endl;
            pthread_mutex_init(&_lock, nullptr);

            p = new Thread(1, bind(&UdpServer::Recv, this));
            c = new Thread(1, bind(&UdpServer::Broadcast, this));
        }

        void start()
        {
            // 1.创建socket接口，打开网络文件
            _sock = socket(AF_INET, SOCK_DGRAM, 0);
            if (_sock < 0)
            {
                cerr << "create socket error: " << strerror(errno) << endl;
                exit(SOCKET_ERR);
            }
            cout << "create socket success: " << _sock << endl;

            // 2.给服务器指明IP地址和端口号
            struct sockaddr_in local;     // 这个local是一个局部变量，被定义在用户空间的特定函数的栈帧上，不在内核中。
            bzero(&local, sizeof(local)); // 清零

            local.sin_family = AF_INET;
            local.sin_port = htons(_port); // 把本地主机构建的port序列转成网络序列
            // 1.字符串风格的IP地址，转换成4字节int类型
            // 2.将主机序列转化称为网络序列
            // local.sin_addr.s_addr = inet_addr(_ip.c_str());

            // 3.云服务器，一般不要指明某一个确定的IP
            local.sin_addr.s_addr = INADDR_ANY; // 让服务器在启动时，bind本主机上的任意IP

            // int n = bind(_sock, (struct sockaddr*)&local, sizeof(local));
            if (bind(_sock, (struct sockaddr *)&local, sizeof(local)) < 0) // 把local绑定到了内核中
            {
                cerr << "bind socket error: " << strerror(errno) << endl;
                exit(BIND_ERR);
            }
            cout << "bind socket success: " << _sock << endl;

            p->run();
            c->run();
        }

        void addUser(const string &name, const struct sockaddr_in &peer)
        {
            LockGuard lockguard(&_lock);
            auto iter = onlineuser.find(name);
            if (iter != onlineuser.end())
                return;

            onlineuser.insert(pair<const string, const struct sockaddr_in>(name, peer));
        }

        void Recv()
        {
            char buffer[1024];
            while (1)
            {
                // 接收
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int n = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
                if (n > 0)
                    buffer[n] = '\0';
                else
                    continue;

                // 提取client信息
                string clientip = inet_ntoa(peer.sin_addr);
                uint16_t clientport = ntohs(peer.sin_port);
                cout << clientip << " - " << clientport << " # " << buffer << endl;

                // 构建一个用户，并进行检查
                string name = clientip;
                name += "-";
                name += to_string(clientport);
                // 如果不存在就插入，存在就什么都不做。
                addUser(name, peer);

                string message = name + ">> " + buffer;
                rq.push(message);

                // //做业务处理
                // string response = _service(buffer);

                // //发送
                // sendto(_sock, response.c_str(), response.size(), 0, (struct sockaddr*)&peer, sizeof(peer));
            }
        }

        void Broadcast()
        {
            while (1)
            {
                string sendstring;
                rq.pop(&sendstring);

                vector<struct sockaddr_in> v;
                {
                    LockGuard lockguard(&_lock);
                    for (auto user : onlineuser)
                    {
                        v.push_back(user.second);
                    }
                }
                for (auto &user : v)
                {
                    // cout << "Broadcast message to " << user.first << " : " << sendstring << endl;
                    sendto(_sock, sendstring.c_str(), sendstring.size(), 0, (struct sockaddr *)&(user), sizeof(user));
                }
            }
        }

        ~UdpServer()
        {
            pthread_mutex_destroy(&_lock);
            c->join();
            p->join();

            delete c;
            delete p;
        }

    private:
        int _sock;
        uint16_t _port;
        // func_t _service;
        unordered_map<string, struct sockaddr_in> onlineuser;
        pthread_mutex_t _lock;
        RingQueue<string> rq;
        Thread *c;
        Thread *p;
        // string _ip;
    };
}



//udp_server.cc

namespace ns_server
{
    const static uint16_t default_port = 8080;
    using func_t = function<string(string)>;

    class UdpServer
    {
    public:
        UdpServer(uint16_t port = default_port)
            : _port(port)
        {
            cout << "server addr: " << _port << endl;
            pthread_mutex_init(&_lock, nullptr);

            p = new Thread(1, bind(&UdpServer::Recv, this));
            c = new Thread(1, bind(&UdpServer::Broadcast, this));
        }

        void start()
        {
            // 1.创建socket接口，打开网络文件
            _sock = socket(AF_INET, SOCK_DGRAM, 0);
            if (_sock < 0)
            {
                cerr << "create socket error: " << strerror(errno) << endl;
                exit(SOCKET_ERR);
            }
            cout << "create socket success: " << _sock << endl;

            // 2.给服务器指明IP地址和端口号
            struct sockaddr_in local;     // 这个local是一个局部变量，被定义在用户空间的特定函数的栈帧上，不在内核中。
            bzero(&local, sizeof(local)); // 清零

            local.sin_family = AF_INET;
            local.sin_port = htons(_port); // 把本地主机构建的port序列转成网络序列
            // 1.字符串风格的IP地址，转换成4字节int类型
            // 2.将主机序列转化称为网络序列
            // local.sin_addr.s_addr = inet_addr(_ip.c_str());

            // 3.云服务器，一般不要指明某一个确定的IP
            local.sin_addr.s_addr = INADDR_ANY; // 让服务器在启动时，bind本主机上的任意IP

            // int n = bind(_sock, (struct sockaddr*)&local, sizeof(local));
            if (bind(_sock, (struct sockaddr *)&local, sizeof(local)) < 0) // 把local绑定到了内核中
            {
                cerr << "bind socket error: " << strerror(errno) << endl;
                exit(BIND_ERR);
            }
            cout << "bind socket success: " << _sock << endl;

            p->run();
            c->run();
        }

        void addUser(const string &name, const struct sockaddr_in &peer)
        {
            LockGuard lockguard(&_lock);
            auto iter = onlineuser.find(name);
            if (iter != onlineuser.end())
                return;

            onlineuser.insert(pair<const string, const struct sockaddr_in>(name, peer));
        }

        void Recv()
        {
            char buffer[1024];
            while (1)
            {
                // 接收
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int n = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
                if (n > 0)
                    buffer[n] = '\0';
                else
                    continue;

                // 提取client信息
                string clientip = inet_ntoa(peer.sin_addr);
                uint16_t clientport = ntohs(peer.sin_port);
                cout << clientip << " - " << clientport << " # " << buffer << endl;

                // 构建一个用户，并进行检查
                string name = clientip;
                name += "-";
                name += to_string(clientport);
                // 如果不存在就插入，存在就什么都不做。
                addUser(name, peer);

                string message = name + ">> " + buffer;
                rq.push(message);

                // //做业务处理
                // string response = _service(buffer);

                // //发送
                // sendto(_sock, response.c_str(), response.size(), 0, (struct sockaddr*)&peer, sizeof(peer));
            }
        }

        void Broadcast()
        {
            while (1)
            {
                string sendstring;
                rq.pop(&sendstring);

                vector<struct sockaddr_in> v;
                {
                    LockGuard lockguard(&_lock);
                    for (auto user : onlineuser)
                    {
                        v.push_back(user.second);
                    }
                }
                for (auto &user : v)
                {
                    // cout << "Broadcast message to " << user.first << " : " << sendstring << endl;
                    sendto(_sock, sendstring.c_str(), sendstring.size(), 0, (struct sockaddr *)&(user), sizeof(user));
                }
            }
        }

        ~UdpServer()
        {
            pthread_mutex_destroy(&_lock);
            c->join();
            p->join();

            delete c;
            delete p;
        }

    private:
        int _sock;
        uint16_t _port;
        // func_t _service;
        unordered_map<string, struct sockaddr_in> onlineuser;
        pthread_mutex_t _lock;
        RingQueue<string> rq;
        Thread *c;
        Thread *p;
        // string _ip;
    };
}

//udp_client.cc
#include "udp_client.hpp"
#include "error.hpp"
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstring>
#include <pthread.h>
static void usage(string proc)
{
    cout << "Usage: \n\t" << proc << " serverip serverport\n" << endl;
}

void* recver(void* args)
{
    int sock = *(static_cast<int*>(args));
    while(1)
    {
        //接收数据
        char buffer[1024];  
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        int n = recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&temp, &len);
        if(n > 0)
        {
            buffer[n] = 0;
            cout << "server echo# " << buffer << endl;
        }
    }
}

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(USAGE_ERR);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock < 0)
    {
        cerr << "create socket error" << endl;
        exit(SOCKET_ERR);
    }

    //client不需要自己绑定，由OS自动进行绑定
    
    //明确server是谁
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());


    pthread_t tid;
    pthread_create(&tid, nullptr, recver, &sock);
    while(1)
    {
        //用户输入
        string message;
        cout << "please Enter# ";
        cin >> message;

        //发送数据
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));
    }

    return 0;
}

五、简单的TCP网络程序

1、创建套接字与绑定

这部分代码与UDP相同：

void initServer()
{
    //1.创建socket文件
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if (_sock < 0)
    {
        cerr << " create socket error " << 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 = INADDR_ANY;
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cerr << "bind socket error" << endl;
        exit(BIND_ERR);
    }

    //3.监听
}

但是与UDP不同的是，TCP需要增加一段监听代码，用于和用户端进行连接。

2、监听

int listen(int sockfd, int backlog);

listen 函数的参数列表中， sockfd 是刚刚创建的套接字。 backlog 是。函数调用成功返回 0 ，失败返回 -1，并且错误码被设置。

static const int backlog = 32;
void initServer()
{
    //1.创建socket文件
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if (_sock < 0)
    {
        cerr << " create socket error " << 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 = INADDR_ANY;
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cerr << "bind socket error" << endl;
        exit(BIND_ERR);
    }

    //3.监听
    if (listen(_sock, backlog) < 0)
    {
        cerr << "listen socket error" << endl;
        exit(LISTEN_ERR);
    }
}

3、获取连接

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

accept 函数的参数列表中， sockfd 是套接字。 addr 用来记录连接该服务器的客户端。 addrlen 是 addr 的长度。

accept 函数的返回值：调用成功返回给客户端提供服务的套接字。调用失败返回 -1，并且错误码被设置。

4、服务器运行

void start()
{
    _quit = false;
    while (!_quit)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // 4.获取连接，accept
        int sock = accept(_listensock, (struct sockaddr*)&client, &len);
        if (sock < 0)
        {
            cerr << "accept error" << endl;
            continue;
        }

        //提取client信息
        string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);

        //5.获取新连接成功,开始进行业务处理
        cout << "获取新连接成功： " << sock << " from " << _listensock << " , "
            << clientip << "-" << clientport << endl;
        service(sock, clientip, clientport);
    }
}

void service(int sock, const string& clientip, const uint16_t& clientport)
{
    string who = clientip + "-" + to_string(clientport);

    char buffer[1024];
    while (1)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            string res = _func(buffer); //进行回调
            cout << who << ">>" << res << endl;
            write(sock, res.c_str(), res.size());
        }

        else if (s == 0)
        {
            //对方将连接关闭了
            close(sock);
            cout << who << " quit" << endl;
            break;
        }

        else
        {
            close(sock);
            cout << "read error " << strerror(errno) << endl;
            break;
        }
    }
}

这种写法有一个问题，那就是程序获取连接后，会直接执行service函数，而没办法继续获取连接。导致一个服务器只能连接到一个客户端。

解决办法是使用多进程来运行程序，但是创建子进程之后，因为父进程又要等待子进程，会造成阻塞等待。就算设置参数WNOHANG，来进行非阻塞等待，也会因为最后没有要连接的客户端，而阻塞在accept函数处，无法执行wait函数。

有多种方法解决这个问题，如下是其中两种：

4.1、创建子进程的子进程

void start()
{
    _quit = false;
    while (!_quit)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // 4.获取连接，accept
        int sock = accept(_listensock, (struct sockaddr*)&client, &len);
        if (sock < 0)
        {
            cerr << "accept error" << endl;
            continue;
        }

        //提取client信息
        string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);

        //5.获取新连接成功,开始进行业务处理
        cout << "获取新连接成功： " << sock << " from " << _listensock << " , "
            << clientip << "-" << clientport << endl;

        // v2：多进程版本
        pid_t id = fork();
        if (id < 0)
        {
            close(sock);
            continue;
        }
        else if (id == 0) //子进程。子进程继承父进程的fd table
        {
            //建议关闭掉不需要的fd
            close(_listensock);
            if (fork() > 0) break;
            service(sock, clientip, clientport);

            exit(0);
        }

        //父进程，一定要关闭不需要的fd，否则父进程的描述符越来越多，造成文件描述符泄漏，导致浪费
        close(sock);
        pid_t ret = waitpid(id, nullptr, 0);
        if (ret == id)
        {
            cout << "wait child " << id << "success" << endl;
        }
    }
}

创建了一个孙子进程，子进程自己退出，并被父进程回收。孙子进程被OS领养，由OS负责，自然不用我们自己回收了。

4.2、设置信号回收

void start()
{
    signal(SIGCHLD, SIG_IGN);

    _quit = false;
    while (!_quit)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // 4.获取连接，accept
        int sock = accept(_listensock, (struct sockaddr*)&client, &len);
        if (sock < 0)
        {
            cerr << "accept error" << endl;
            continue;
        }

        //提取client信息
        string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);

        //5.获取新连接成功,开始进行业务处理
        cout << "获取新连接成功： " << sock << " from " << _listensock << " , "
            << clientip << "-" << clientport << endl;

        // v2：多进程版本
        pid_t id = fork();
        if (id < 0)
        {
            close(sock);
            continue;
        }
        else if (id == 0) //子进程。子进程继承父进程的fd table
        {
            //建议关闭掉不需要的fd
            close(_listensock);
            // if(fork() > 0) break;
            service(sock, clientip, clientport);

            exit(0);
        }

        //父进程，一定要关闭不需要的fd，否则父进程的描述符越来越多，造成文件描述符泄漏，导致浪费
        close(sock);
    }
}

通过信号的方式，使子进程直接被OS回收。

以上是使用多进程实现一个服务器对应多个客户端的办法。但是多进程终究成本较高，因此，我们还可以实现多线程对应的方法：

4.3、多线程服务器

需要注意的是，在实现多线程时，由于回调函数要设置成static类型，所以内部没有this指针。此处是通过定义一个类的方式封装this指针。

//封装this指针
//class TcpServer;
//class ThreadData
//{
//public:
//    ThreadData(int fd, const string& ip, const uint16_t& port, TcpServer* ts)
//        :sock(fd)
//        , clientip{ ip }
//        , clientport(port)
//        , current(ts)
//     {}
//public:
//    int sock;
//    string clientip;
//    uint16_t clientport;

//    TcpServer* current;
//};

static void* threadRoutine(void* args)
{
    pthread_detach(pthread_self());
    ThreadData* td = static_cast<ThreadData*>(args);
    td->current->service(td->sock, td->clientip, td->clientport);
    delete td;
    return nullptr;
}

void start()
{
    signal(SIGCHLD, SIG_IGN);

    _quit = false;
    while (!_quit)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // 4.获取连接，accept
        int sock = accept(_listensock, (struct sockaddr*)&client, &len);
        if (sock < 0)
        {
            cerr << "accept error" << endl;
            continue;
        }

        //提取client信息
        string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);

        //5.获取新连接成功,开始进行业务处理
        cout << "获取新连接成功： " << sock << " from " << _listensock << " , "
            << clientip << "-" << clientport << endl;

        // v3：多线程版本
        pthread_t tid;
        ThreadData* td = new ThreadData(sock, clientip, clientport, this);
        pthread_create(&tid, nullptr, threadRoutine, td);
    }
}

这里实现的多线程服务器，是在客户端访问时，才临时创建线程的。如果以后客户端非常多的话，这样临时创建线程的方式效率就会非常低了。

所以我们再来实现一个线程池服务器的版本。

4.4、线程池服务器

//ThreadPool.hpp
#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include <string>
#include <unistd.h>
#include <pthread.h>
#include "Thread.hpp"
#include "lockGuard.hpp"

using namespace std;

const static int N = 5;

template <class T>
class ThreadPool
{
private:
    ThreadPool(int num = N)
        : _num(num)
    {
        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()
    {
        if (instance == nullptr)
        {
            LockGuard lockguard(&instance_lock);
            if (instance == nullptr)
            {
                cout << "线程池单例形成" << endl;
                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)
    {
        ThreadPool<T>* tp = static_cast<ThreadPool<T> *>(args);
        while (1)
        {
            // 1、检测有没有任务
            // 2、有：处理
            // 3、无：等待
            // 必须要加锁
            T t;
            {
                LockGuard lockguard(tp->getlock());
                while (tp->isEmpty())
                {
                    // 等待，cond
                    tp->threadWait();
                }
                t = tp->popTask(); // 从公共区域拿到私有区域
            }
            // t.run(); //处理任务不应该在临界区中进行
            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)
        {
            cout << t.threadname() << " runing... " << endl;
        }
    }

    void pushTask(const T& t)
    {
        LockGuard lockguard(&_lock);
        _tasks.push(t);
        threadWakeup();
    }

    ~ThreadPool()
    {
        for (auto& t : _threads)
        {
            t.join();
        }
        pthread_mutex_destroy(&_lock);
        pthread_cond_destroy(&_cond);
    }

private:
    vector<Thread> _threads;
    int _num;

    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;


//Thread.hpp
#pragma once

#include <iostream>
#include <pthread.h>
#include <functional>
#include <string>
#include <cstdlib>

using namespace std;


class Thread
{
public:
    typedef enum
    {
        NEW = 0,
        RUNNING,
        EXITED
    }ThreadStatus;
    // typedef void (*func_t)(void*);
    using func_t = function<void()>;

public:
    Thread(int num, func_t func)
        :_tid(0)
        , _status(NEW)
        , _func(func)
    {
        char name[128];
        snprintf(name, sizeof(name), "thread-%d", num);
        _name = name;
    }

    int status()
    {
        return _status;
    }

    string threadname()
    {
        return _name;
    }

    pthread_t threadid()
    {
        return _tid;
    }

    //因为类的成员函数有this指针，占用了回调函数的void*类型的参数，所以要定义成static类型
    static void* runHelper(void* args)
    {
        Thread* ts = (Thread*)args;
        //_func(ts->_args );
        (*ts)(); //使用仿函数的形式调用func函数

        return nullptr;
    }

    void operator()()
    {
        _func();
    }

    void run()
    {
        int n = pthread_create(&_tid, nullptr, runHelper, this); //这里传参传的是 this 指针，为了static类型的回调函数可以访问类属性和其他成员函数
        if (n != 0)
            exit(1);
        _status = RUNNING;
    }

    void join()
    {
        int n = pthread_join(_tid, nullptr);
        if (n != 0)
        {
            cerr << "main thread join thread " << _name << " error" << endl;
            return;
        }
        _status = EXITED;
    }

    ~Thread()
    {}

private:
    pthread_t _tid;
    string _name;
    func_t _func; //线程未来要执行的回调

    ThreadStatus _status;
};

//task.hpp
#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <functional>
using namespace std;

using cb_t = function<void(int, const string&, const uint16_t&)>;

class Task
{
public:
    Task()
    {
    }

    Task(int sock, const string& ip, const uint16_t& port, cb_t cb)
        :_sock(sock)
        , _ip(ip)
        , _port(port)
        , _cb(cb)
    {}

    void operator()()
    {
        _cb(_sock, _ip, _port);
    }

    ~Task()
    {

    }

private:
    int _sock;
    string _ip;
    uint16_t _port;
    cb_t _cb;
};


//tcp_server.hpp部分代码
void start()
{
    signal(SIGCHLD, SIG_IGN);

    _quit = false;
    while (!_quit)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // 4.获取连接，accept
        int sock = accept(_listensock, (struct sockaddr*)&client, &len);
        if (sock < 0)
        {
            cerr << "accept error" << endl;
            continue;
        }

        //提取client信息
        string clientip = inet_ntoa(client.sin_addr);
        uint16_t clientport = ntohs(client.sin_port);

        //5.获取新连接成功,开始进行业务处理
        cout << "获取新连接成功： " << sock << " from " << _listensock << " , "
            << clientip << "-" << clientport << endl;

        //v4：线程池
        //使用线程池的时候，一定是有限的线程个数，一定要处理短任务
        //这里让线程执行的service函数是死循环，实际上这样是不合理的。
        Task t(sock, clientip, clientport, std::bind(&TcpServer::service, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        ThreadPool<Task>::getinstance()->pushTask(t);
    }
}

void service(int sock, const string& clientip, const uint16_t& clientport)
{
    string who = clientip + "-" + to_string(clientport);

    char buffer[1024];
    while (1)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            string res = _func(buffer); //进行回调
            cout << who << ">>" << res << endl;
            write(sock, res.c_str(), res.size());
        }

        else if (s == 0)
        {
            //对方将连接关闭了
            close(sock);
            cout << who << " quit" << endl;
            break;
        }

        else
        {
            close(sock);
            cout << "read error " << strerror(errno) << endl;
            break;
        }
    }
}

5、创建客户端

客户端需要对服务器获取的连接进行申请：

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

客户端首次向服务端发起连接请求时，会自动进行绑定端口。函数成功返回 0，失败返回 -1，并且错误码被设置。

static void userage(string proc)
{
    cout << "Usage:\n\t" << proc << " port\n" << endl;
}

//./tcp_client serverip serverport
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        userage(argv[0]);
        exit(USAGE_ERR);
    }

    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    //1.创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if(sock < 0)
    {
        cerr << "socket error : " << strerror(errno) << endl;
        exit(SOCKET_ERR);
    }

    //client 不需要自己绑定端口号，由OS自动生成
    //client 不需要获取连接（accept），获取连接是server要做的事

    //2.连接
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    int cnt = 5;
    while(connect(sock, (struct sockaddr*)&server, sizeof(server)) != 0)
    {
        cout << "正在重新连接，剩余重连次数： " << cnt-- << endl;
        sleep(1);
        if(cnt <= 0)
            break;
    }
    if(cnt <= 0)
    {
        cerr << "连接失败" << endl;
        exit(CONNECT_ERR);
    }

    //3.连接成功
    char buffer[1024];
    while(1)
    {
        string line;
        cout << "Enter>> " << endl;
        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;
        }
        else
        {
            cerr << "read error: " << strerror(errno) << endl;
            break;
        }
    }

    close(sock);

    return 0;
}

运行观察结果：

六、 TCP协议通讯流程

下图是基于TCP协议的客户端/服务器程序的一般流程：

服务器初始化：

调用socket，创建文件描述符。
调用bind，将当前的文件描述符和ip/port绑定在一起。如果这个端口已经被其他进程占用了，就会bind失败。
调用listen，声明当前这个文件描述符作为一个服务器的文件描述符，为后面的accept做好准备。
调用accecpt，并阻塞，等待客户端连接过来。

建立连接的过程：

调用socket, 创建文件描述符;
调用connect, 向服务器发起连接请求;
connect会发出SYN段并阻塞等待服务器应答; (第一次)
服务器收到客户端的SYN, 会应答一个SYN-ACK段表示"同意建立连接"; (第二次)
客户端收到SYN-ACK后会从connect()返回, 同时应答一个ACK段; (第三次)

这个建立连接的过程, 通常称为三次握手。

数据传输的过程：

建立连接后，TCP协议提供全双工的通信服务。所谓全双工的意思是，在同一条连接中，同一时刻，通信双方可以同时写数据。相对的概念叫做半双工，同一条连接在同一时刻，只能由一方来写数据。
服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待。
这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答。
服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求。
客户端收到后从read()返回，发送下一条请求，如此循环下去。

断开连接的过程：