tcp echo_server

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>

////
#include  <netinet/in.h>      /* sockaddr_in{} and other Internet defns */
#include  <arpa/inet.h>       /* inet(3) functions */
#include <sys/epoll.h> /* epoll function */
#include <fcntl.h>     /* nonblocking */
#include <sys/resource.h> /*setrlimit */
#include <iostream>
#include <string>
#include <thread>

#define MAXEPOLLSIZE 10000
// #define MAXLINE 10240

const int MAXLINE = 1024; 

namespace echo {
class EchoServer {
 public:
  EchoServer() = default;
  ~EchoServer() = default;

  void Run();
  void Wait() {
    if (worker_.joinable()) {
      worker_.join();
    }
  }
  
protected:
  void Init();
  // Thread add fd.
  int DoAccept(struct epoll_event& ev);

  // recv
  int DoRecieve();

  int DoListen();
  int DoBind();
  int DoSetSocket();
  int SetNoBlock(int fd);
  int CreateSocket();
  int CreateEpoll();
  void DoRun();
  int Process(struct epoll_event& ev);
  int DoProcess(struct epoll_event& ev);

 protected:
  int listen_fd_;
  int cur_fds_{1};
  int epoll_fd_;
  short port_{6666};
  struct epoll_event ev_;
  struct sockaddr_in servaddr_;
  bool exit_{false};
  std::thread worker_;
};


void EchoServer::Init() {
  auto ret = CreateSocket();
  if (ret < 0) {
    return;
  }
  ret = DoSetSocket();
  if (ret < 0) {
    return;
  }
  ret = DoBind();
  if (ret < 0) {
    return;
  }
  ret = DoListen();
  if (ret < 0) {
    return;
  }
  ret = CreateEpoll();
  if (ret < 0) {
    return;
  }
}

void EchoServer::Run() {
  Init();
  std::thread t([this]() {
      DoRun();
      });
  worker_ = std::move(t);
}

void EchoServer::DoRun() {
  std::cout << "EchoServer run." << std::endl;
  std::cout << "epoll_fd_ = " << epoll_fd_ << std::endl;
  struct epoll_event events[MAXEPOLLSIZE];
  while (!exit_) {
    int nfds = epoll_wait(epoll_fd_, events, cur_fds_, -1);
    if (-1 == nfds) {
      std::cout << "epoll_wait error!" << std::endl;
      continue;
    }
    std::cout << "nfds = " << nfds << std::endl;
    for (size_t i = 0; i < nfds; ++i) {
      Process(events[i]);
    }
    usleep(1000);
  }
}

int EchoServer::Process(struct epoll_event& ev) {
  if (ev.data.fd == listen_fd_) {
    auto ret = DoAccept(ev);
    if (ret < 0) return -1;
  } else {
    return DoProcess(ev);
  }
  return 0;
}

int EchoServer::DoProcess(struct epoll_event& ev) {
  if (ev.events & EPOLLOUT) {
    return 0;
  }
  std::cout << __func__ << std::endl;
  int fd = ev.data.fd;
  char buf[MAXLINE];
  auto ret = read(fd, buf, MAXLINE);
  // auto ret = recv(fd, buf, 3, 0);

  if (ret == 0) {
    std::cout << "client close the connection." << std::endl;
    close(fd);
    return -1;
  } 
  if (ret < 0) {
    std:: cout << "read error, fd = " << fd << ", ret=" << ret << std::endl;
    // close(fd);
    return -1;
  }    
  buf[ret] = 0x0;
  std::cout << "recv message: " << buf << std::endl;
 
  return 0;
}

// Thread add fd.
int EchoServer::DoAccept(struct epoll_event& ev) {
  std::cout << __func__ << std::endl;
  struct sockaddr_in cli_addr;
  socklen_t socklen = sizeof(struct sockaddr_in);
  int connfd = accept(listen_fd_, (struct sockaddr *)&cli_addr, &socklen);
  if (connfd < 0) {
    std::cout << "accept error." << std::endl;
    return -1;
  }
  std::cout << "accept from " << inet_ntoa(cli_addr.sin_addr)
            << ":" << cli_addr.sin_port
            << ", fd = " << connfd << std::endl;

  if (cur_fds_ >= MAXEPOLLSIZE) {
    std::cout << "too many connection, more than " << MAXEPOLLSIZE << std::endl;
    close(connfd);
    return -1;
  }

  if (SetNoBlock(connfd) < 0) {
    std::cout << "set no block failed." << std::endl;
    // return -1;
  }

  ev.events = EPOLLIN;  // | EPOLLOUT;
  ev.data.fd = connfd;
  if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, connfd, &ev) < 0) {
    std::cout << "add socket " << connfd
              << " to epoll failed: " << strerror(errno) << std::endl;
    close(connfd);
    return -1;
  }
  cur_fds_++;

  return connfd;
}

// recv
int EchoServer::DoRecieve() {
  return 0;
}

int EchoServer::DoListen() {
  if (listen(listen_fd_, 1024) == -1) 
  {
    std::cout << "listen error" << std::endl;
    return -1;
  }
  return 0;
}

int EchoServer::DoBind() {
  auto ret = bind(listen_fd_, (struct sockaddr *) &servaddr_, sizeof(struct sockaddr));
  if (ret == -1) {
    std::cout << "bind error" << std::endl;
    return -1;
  }
  return 0; 
}

int EchoServer::DoSetSocket() {
  int opt = 1;
  setsockopt(listen_fd_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
  return 0;
}

int EchoServer::SetNoBlock(int fd) {
  if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0)|O_NONBLOCK) == -1) {
    return -1;
  }
  return 0;
}

int EchoServer::CreateSocket() {
  socklen_t socklen = sizeof(struct sockaddr_in);
  struct rlimit rt;
  char buf[MAXLINE];
  
  rt.rlim_max = rt.rlim_cur = 10000;  // MAXEPOLLSIZE;
  if (setrlimit(RLIMIT_NOFILE, &rt) == -1) 
  {
    std::cout << "setrlimit error" << std::endl;
    return -1;
  }


  bzero(&servaddr_, sizeof(servaddr_));
  servaddr_.sin_family = AF_INET; 
  servaddr_.sin_addr.s_addr = htonl (INADDR_ANY);
  servaddr_.sin_port = htons (port_);

  listen_fd_ = socket(AF_INET, SOCK_STREAM, 0); 
  if (listen_fd_== -1) {
    std::cout << "create socket failed." << std::endl;
    return -1;
  }
  return 0;
}

int EchoServer::CreateEpoll() {
  epoll_fd_ = epoll_create(MAXEPOLLSIZE);
  ev_.events = EPOLLIN | EPOLLET;
  ev_.data.fd = listen_fd_;
  if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, listen_fd_, &ev_) < 0) 
  {
    std::cout << "epoll set error: fd=" <<  listen_fd_ << std::endl;
    return -1;
  }

  return 0;
}

}  // namespace echo

int main() {
  echo::EchoServer server;
  server.Run();
  server.Wait();
  return 0;
}