int _listensock; // 監(jiān)聽(tīng)的文件描述符
string _ip;      // 服務(wù)端ip
uint16_t _port;  // 端口號(hào)
bool _isrunning; // 服務(wù)器是否在運(yùn)行

void InitServer() // 創(chuàng)建服務(wù)器
  {
    // 1/創(chuàng)建套接字
    _listensock = socket(AF_INET, SOCK_STREAM, 0); // 面向字節(jié)流;
    if (_listensock < 0)
    {
      lg(Fatal, "create socket,errno:%d,errstring:%s", errno, strerror(errno));
      exit(SocketError);
    }
    lg(Info, "create socket success,_listsock:%d", _listensock);
    // 2/開(kāi)始綁定
    struct sockaddr_in local;
    bzero(&local, sizeof(local)); // 先清空，然后再填進(jìn)去
    local.sin_family = AF_INET;
    local.sin_port = htons(_port); // 轉(zhuǎn)網(wǎng)絡(luò)序列
    inet_aton(_ip.c_str(), &local.sin_addr);
    // 開(kāi)始綁定
    if (bind(_listensock, (sockaddr *)&local, sizeof(local)) < 0) // 如果綁定失敗
    {
      lg(Fatal, "bind errno,errno:%d,errstring:%s", errno, strerror(errno));
      exit(BindError);
    }
    lg(Info, "bind socket success,_listsock:%d", _listensock);
    // 3/tcp和udp的區(qū)別就是要面向連接 要被動(dòng)地等待別人來(lái)連接
    if (listen(_listensock, backlog) < 0)
    {
      lg(Fatal, "listen errno,errno:%d,errstring:%s", errno, strerror(errno));
    }
    lg(Info, "listen socket success,_listsock:%d", _listensock);
  }

apple:蘋(píng)果...
banana:香蕉...
red:紅色...
yellow:黃色...
the: 這
be: 是
to: 朝向/給/對(duì)
and: 和
I: 我
in: 在...里
that: 那個(gè)
have: 有
will: 將
for: 為了
but: 但是
as: 像...一樣
what: 什么
so: 因此
he: 他
her: 她
his: 他的
they: 他們
we: 我們
their: 他們的
his: 它的
with: 和...一起
she: 她
he: 他（賓格）
it: 它

#pragma once

#include <iostream>
#include <string>
#include <fstream>
#include <unordered_map>
#include "Log.hpp"

const std::string dictname = "./dict.txt";
const std::string sep = ":";

//yellow:黃色...
static bool Split(std::string &s, std::string *part1, std::string *part2)
{
    auto pos = s.find(sep);
    if(pos == std::string::npos) return false;
    *part1 = s.substr(0, pos);
    *part2 = s.substr(pos+1);
    return true;
}

class Init
{
public:
    Init()
    {
        std::ifstream in(dictname);
        if(!in.is_open())
        {
            lg(Fatal, "ifstream open %s error", dictname.c_str());
            exit(1);
        }
        std::string line;
        while(std::getline(in, line))
        {
            std::string part1, part2;
            Split(line, &part1, &part2);
            dict.insert({part1, part2});
        }
        in.close();
    }
    std::string translation(const std::string &key)
    {
        auto iter = dict.find(key);
        if(iter == dict.end()) return "Unknow";
        else return iter->second;
    }
private:
    std::unordered_map<std::string, std::string> dict;
};

#pragma once
#include <iostream>
#include <string>
#include "Log.hpp"
#include "Init.hpp"

extern Log lg;
Init init;

class Task
{
public:
    Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
        : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
    {
    }
    Task()
    {
    }
    void run()
    {
        // 測(cè)試代碼
        char buffer[4096];
        // Tcp是面向字節(jié)流的，你怎么保證，你讀取上來(lái)的數(shù)據(jù)，是"一個(gè)" "完整" 的報(bào)文呢？
        ssize_t n = read(sockfd_, buffer, sizeof(buffer)); // BUG?
        if (n > 0)
        {
            buffer[n] = 0;
            std::cout << "client key# " << buffer << std::endl;
            std::string echo_string = init.translation(buffer);

            // sleep(5);
            // // close(sockfd_);
            // lg(Warning, "close sockfd %d done", sockfd_);

            // sleep(2);
            n = write(sockfd_, echo_string.c_str(), echo_string.size()); // 100 fd 不存在
            if(n < 0)
            {
                lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
            }
        }
        else if (n == 0)
        {
            lg(Info, "%s:%d quit, server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
        }
        else
        {
            lg(Warning, "read error, sockfd: %d, client ip: %s, client port: %d", sockfd_, clientip_.c_str(), clientport_);
        }
        close(sockfd_);
    }
    void operator()()
    {
        run();
    }
    ~Task()
    {
    }

private:
    int sockfd_;
    std::string clientip_;
    uint16_t clientport_;
};

#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include <unistd.h>

struct ThreadInfo
{
    pthread_t tid;
    std::string name;
};

static const int defalutnum = 10;

template <class T>
class ThreadPool
{
public:
    void Lock()
    {
        pthread_mutex_lock(&mutex_);
    }
    void Unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }
    void Wakeup()
    {
        pthread_cond_signal(&cond_);
    }
    void ThreadSleep()
    {
        pthread_cond_wait(&cond_, &mutex_);
    }
    bool IsQueueEmpty()
    {
        return tasks_.empty();
    }
    std::string GetThreadName(pthread_t tid)
    {
        for (const auto &ti : threads_)
        {
            if (ti.tid == tid)
                return ti.name;
        }
        return "None";
    }

public:
    static void *HandlerTask(void *args)
    {
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
        std::string name = tp->GetThreadName(pthread_self());
        while (true)
        {
            tp->Lock();

            while (tp->IsQueueEmpty())
            {
                tp->ThreadSleep();
            }
            T t = tp->Pop();
            tp->Unlock();

            t();
        }
    }
    void Start()
    {
        int num = threads_.size();
        for (int i = 0; i < num; i++)
        {
            threads_[i].name = "thread-" + std::to_string(i + 1);
            pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
        }
    }
    T Pop()
    {
        T t = tasks_.front();
        tasks_.pop();
        return t;
    }
    void Push(const T &t)
    {
        Lock();
        tasks_.push(t);
        Wakeup();
        Unlock();
    }
    static ThreadPool<T> *GetInstance()
    {
        if (nullptr == tp_) // ???
        {
            pthread_mutex_lock(&lock_);
            if (nullptr == tp_)
            {
                std::cout << "log: singleton create done first!" << std::endl;
                tp_ = new ThreadPool<T>();
            }
            pthread_mutex_unlock(&lock_);
        }

        return tp_;
    }

private:
    ThreadPool(int num = defalutnum) : threads_(num)
    {
        pthread_mutex_init(&mutex_, nullptr);
        pthread_cond_init(&cond_, nullptr);
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&cond_);
    }
    ThreadPool(const ThreadPool<T> &) = delete;
    const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:
    std::vector<ThreadInfo> threads_;
    std::queue<T> tasks_;

    pthread_mutex_t mutex_;
    pthread_cond_t cond_;

    static ThreadPool<T> *tp_;
    static pthread_mutex_t lock_;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h> //套接字類型的頭文件
#include <strings.h>    //bzero的頭文件
#include <cstring>
#include <arpa/inet.h>
#include "Log.hpp"
#include <functional>
#include <sys/wait.h>
#include <signal.h>
#include <pthread.h>
#include"ThreadPool.hpp"
#include "Task.hpp"
using namespace std;

typedef function<string(const string &)> func_t;
Log lg; // 命令對(duì)象 用來(lái)打印日志信息
enum
{
  UsageError = 1, // 使用有誤
  SocketError,    // 創(chuàng)建套接字有誤
  BindError,      // 綁定有誤
  ListenError,    // 監(jiān)聽(tīng)有誤
};

const int defaultfd = -1;
const uint16_t defaultport = 8080;
const string defaultip = "0.0.0.0";
const int size = 1024;
const int backlog = 10; // 但是一般不要設(shè)置的太大

class ThreadData
{
public:
  ThreadData(int fd, uint16_t &port, const string &ip, TcpServer *t) : sockfd(fd), clientport(port),clientip(ip), tsvr(t)
  {
  }
  public:
  int sockfd;
  string clientip;
  uint16_t clientport;
  TcpServer *tsvr;//通過(guò)對(duì)象讓靜態(tài)成員函數(shù)調(diào)用 非靜態(tài)成員方法
};

class TcpServer
{
public:
  TcpServer(uint16_t &port, const string &ip = defaultip) : _listensock(defaultfd), _port(port), _ip(ip), _isrunning(false)
  {
  }

  static void *Routine(void *args)
  {
    pthread_detach(pthread_self());
    ThreadData *td = static_cast<ThreadData *>(args);
    td->tsvr->Service(td->sockfd, td->clientport, td->clientip); //通過(guò)傳一個(gè)對(duì)象指針來(lái)調(diào)用類內(nèi)的成員函數(shù)
    delete td;
    return nullptr;
  }

  void Service(int sockfd, uint16_t clientport, string clientip)
  {
    char buffer[size];
    while (true)
    {
      // 服務(wù)端要先接收客戶端的數(shù)據(jù)
      ssize_t n = read(sockfd, buffer, sizeof(buffer)); // 讀到緩沖區(qū)中
      if (n > 0)                                        // 大于0表示讀取成功 =0表示當(dāng)前沒(méi)有數(shù)據(jù)可讀了  <0說(shuō)明讀取失敗
      {
        buffer[n] = 0; // 把我們讀到的信息當(dāng)成是字符串的形式來(lái)處理
        cout << "client say#" << buffer << endl;
        string echo_string = "tcpserver echo#";
        echo_string += buffer;
        // 對(duì)buffer簡(jiǎn)單加工完之后往客戶端寫(xiě)入
        write(sockfd, echo_string.c_str(), echo_string.size());
      }
      else if (n == 0) // 沒(méi)有什么數(shù)據(jù)可讀的了 所以八成是客戶端鏈接斷開(kāi)了 我服務(wù)端不能崩
      {
        lg(Info, "client quit, sockfd: %d, client ip: %s, client port: %d", sockfd, clientip.c_str(), clientport);
        break;
      }
      else // 讀取失敗  可能是文件描述符被關(guān)閉了
      {
        lg(Warning, "read error, sockfd: %d, client ip: %s, client port: %d", sockfd, clientip.c_str(), clientport);
      }
    }
  }

  void InitServer() // 創(chuàng)建服務(wù)器
  {
    // 1/創(chuàng)建套接字
    _listensock = socket(AF_INET, SOCK_STREAM, 0); // 面向字節(jié)流;
    if (_listensock < 0)
    {
      lg(Fatal, "create socket,errno:%d,errstring:%s", errno, strerror(errno));
      exit(SocketError);
    }
    lg(Info, "create socket success,_listsock:%d", _listensock);
    // 2/開(kāi)始綁定
    struct sockaddr_in local;
    bzero(&local, sizeof(local)); // 先清空，然后再填進(jìn)去
    local.sin_family = AF_INET;
    local.sin_port = htons(_port); // 轉(zhuǎn)網(wǎng)絡(luò)序列
    inet_aton(_ip.c_str(), &local.sin_addr);
    // 開(kāi)始綁定
    if (bind(_listensock, (sockaddr *)&local, sizeof(local)) < 0) // 如果綁定失敗
    {
      lg(Fatal, "bind errno,errno:%d,errstring:%s", errno, strerror(errno));
      exit(BindError);
    }
    lg(Info, "bind socket success,_listsock:%d", _listensock);
    // 3/tcp和udp的區(qū)別就是要面向連接 要被動(dòng)地等待別人來(lái)連接
    if (listen(_listensock, backlog) < 0)
    {
      lg(Fatal, "listen errno,errno:%d,errstring:%s", errno, strerror(errno));
    }
    lg(Info, "listen socket success,_listsock:%d", _listensock);
  }
  ///
  void Run() // 啟動(dòng)服務(wù)器
  {
ThreadPool<Task>::GetInstance()->Start();
    signal(SIGPIPE,SIG_IGN);
    _isrunning = true;
    lg(Info, "tcpServer is running....");
    // 1、accept嘗試獲取新鏈接
    while (_isrunning) // 不斷獲取新鏈接
    {
      struct sockaddr_in client;
      socklen_t len = sizeof(client);
      int sockfd = accept(_listensock, (struct sockaddr *)&client, &len); // 這個(gè)id是用來(lái)做服務(wù)的?。?
      if (sockfd < 0)                                                     // 如果獲取失敗 應(yīng)該獲取下一個(gè) 而不是直接結(jié)束
      {
        lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno));
        continue;
      }
      lg(Info, "accept success,sockfd:%d", sockfd);
      // 2、將客戶端的信息弄出來(lái)
      uint16_t clientport = ntohs(client.sin_port);
      char clientip[32]; // 輸出型參數(shù)
      inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
      // 根據(jù)新連接來(lái)進(jìn)行通信服務(wù)-version單進(jìn)程版
      // Service(sockfd, clientport, clientip);
      // close(sockfd);
      // version2 多進(jìn)程版-讓子進(jìn)程幫我做服務(wù)，而我繼續(xù)去鏈接
      // pid_t id=fork();
      // if(id==0) //child 讓他去服務(wù)
      // {
      //    close(_listensock);//關(guān)掉 防止誤操作
      //    if(fork()>0) exit(0);//子進(jìn)程退掉 讓孫子進(jìn)程來(lái)做
      //    Service(sockfd, clientport, clientip);//孫子進(jìn)程此時(shí)已經(jīng)被 system領(lǐng)養(yǎng)了
      //    close(sockfd);
      //    exit(0);
      // }
      // //father
      // pid_t rid=waitpid(id,nullptr,0);//子進(jìn)程一進(jìn)去就退出了，所以父進(jìn)程會(huì)馬上返回繼續(xù)去鏈接
      // (void)rid;//rid沒(méi)用過(guò) 所以用一下防止警告
      // //signal(SIGCHLD,SIG_IGN);
      // version3 多線程版??！
      // ThreadData *td = new ThreadData(sockfd, clientport, clientip, this);
      // pthread_t tid;
      // pthread_create(&tid, nullptr, Routine, td);
      //version4 線程池英漢詞典
       Task t(sockfd, clientip, clientport);
       ThreadPool<Task>::GetInstance()->Push(t);
    }
  }
  ~TcpServer()
  {
  }

private:
  int _listensock; // 監(jiān)聽(tīng)的文件描述符
  string _ip;      // 服務(wù)端ip
  uint16_t _port;  // 端口號(hào)
  bool _isrunning; // 服務(wù)器是否在運(yùn)行
};

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

using namespace std;

void Usage(std::string proc)
{
    std::cout << "\n\rUsage: " << proc << " serverip serverport\n"
              << std::endl;
}

// ./tcpclient serverip serverport
int main(int argc,char* argv[]) //必須知道服務(wù)器的ip和端口號(hào)
{
    if(argc!=3)
    {
      Usage(argv[0]);
      exit(0);
    }
    string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    //1、第一步 創(chuàng)建套接字
    int sockfd=socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd<0)
    {
        cerr << "socker error" << endl;
        return 1;
    }
    //2/OS幫助們bind
    struct sockaddr_in server;//輸出型參數(shù)
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport); 
   // server.sin_addr.s_addr = inet_addr(serverip.c_str());//字符串轉(zhuǎn)四字節(jié)
    inet_pton(AF_INET,serverip.c_str(), &(server.sin_addr));
    socklen_t len = sizeof(server);
    //3、向服務(wù)端發(fā)送鏈接請(qǐng)求 
    int n=connect(sockfd,(struct sockaddr*)&server,len);
    if(n<0)//如果鏈接失敗
    {
      cerr<<"connect error……" <<endl;
      return 2;
    }
    //鏈接成功
    cout<<"connect sucess"<<endl;
    string message; //用來(lái)
    char inbuffer[1024];//接收讀取的緩沖區(qū)
    while(true)
    {
        cout<<"please enter@";
        getline(cin,message); //將獲取的信息放到message中 發(fā)到服務(wù)端
       // 1. 數(shù)據(jù) 2. 給誰(shuí)發(fā) 
        ssize_t n=write(sockfd,message.c_str(),message.size());//可以直接通過(guò)write寫(xiě)到文件里
        //一般不會(huì)寫(xiě)失敗，因?yàn)榉?wù)器一般都不關(guān)
        //從文件里讀
        ssize_t s = read(sockfd,inbuffer,sizeof(inbuffer));//讀到我們的緩沖區(qū)里
        //會(huì)將結(jié)果帶回來(lái)
        if(s > 0)
        {
            inbuffer[s] = 0;
            cout << inbuffer << endl;
        }
    } 
    close(sockfd);
}

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

using namespace std;

void Usage(std::string proc)
{
    std::cout << "\n\rUsage: " << proc << " serverip serverport\n"
              << std::endl;
}

// ./tcpclient serverip serverport
int main(int argc, char *argv[]) // 必須知道服務(wù)器的ip和端口號(hào)
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(0);
    }
    string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    // 2/OS幫助們bind
    struct sockaddr_in server; // 輸出型參數(shù)
    bzero(&server, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    // server.sin_addr.s_addr = inet_addr(serverip.c_str());//字符串轉(zhuǎn)四字節(jié)
    inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));
    // 3、向服務(wù)端發(fā)送鏈接請(qǐng)求
    while (true)
    {
        int cnt = 5;             // 重連次數(shù)
        int isreconnect = false; // 是否要嘗試重連
        // 創(chuàng)建套接字
        int sockfd =0; 
        sockfd=socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0)
        {
            cerr << "socker error" << endl;
            return 1;
        }
        do
        {
            int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));
            if (n < 0) // 如果鏈接失敗
            {
                isreconnect = true;
                --cnt;
                cerr << "connect error……" << endl;
            }
            else
                break; // 鏈接成功就跳出去
        } while (cnt && isreconnect);
        if (cnt == 0)
        {
            cerr << "user ofline" << endl;
            break;
        }
        // 鏈接成功
        cout << "connect sucess" << endl;
        string message;      // 用來(lái)
        char inbuffer[1024]; // 接收讀取的緩沖區(qū)
        cout << "please enter@";
        getline(cin, message); // 將獲取的信息放到message中 發(fā)到服務(wù)端
        // 1. 數(shù)據(jù) 2. 給誰(shuí)發(fā)
        ssize_t n = write(sockfd, message.c_str(), message.size()); // 可以直接通過(guò)write寫(xiě)到文件里
        if (n < 0)
        {
            std::cerr << "write error..." << std::endl;
            // break; 短服務(wù)不用出去
        }
        // 一般不會(huì)寫(xiě)失敗，因?yàn)榉?wù)器一般都不關(guān)
        // 從文件里讀
        n = read(sockfd, inbuffer, sizeof(inbuffer)); // 讀到我們的緩沖區(qū)里
        // 會(huì)將結(jié)果帶回來(lái)
        if (n > 0)
        {
            inbuffer[n] = 0;
            cout << inbuffer << endl;
        }
    close(sockfd);
}
     return 0;
}