simple udp server with libevent

1.socket_config.hpp

#ifndef SOCKET_CONFIG_HPP_
#define SOCKET_CONFIG_HPP_
#include <string>
using namespace std;
enum {
	TCP,
	UDP
};
class socket_config {
public:
	socket_config() {
		port_ = 8080;
		backlog_ = 1024;
		type_ = UDP;
		ip_ = "127.0.0.1";
	}
	virtual ~socket_config() = default;
public:
	int port_;
	int backlog_;
	unsigned char type_;
	string ip_;
};

#endif /* SOCKET_CONFIG_HPP_ */

2.sockect_utility.hpp

#ifndef SOCKET_UTILITY_HPP_
#define SOCKET_UTILITY_HPP_
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <iostream>
#include "socket_config.hpp"
class sockect_utility {
public:
	inline static sockect_utility &get_instance() {
		static sockect_utility obj;
		return obj;
	}
private:
	sockect_utility() = default;
	virtual ~sockect_utility() = default;
public:
	int bind_socket(const socket_config &config) {
		int sock_fd = init_socket(config.type_);
		if (-1 == sock_fd) {
			return -1;
		}
		struct sockaddr_in addr = {0};
		addr.sin_family = AF_INET;
		addr.sin_addr.s_addr = inet_addr(config.ip_.c_str());
		addr.sin_port = htons(config.port_);
		if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
			cerr << "socket bind failed on ip = " << config.ip_ << " port = " << config.port_ << endl;
			return -1;
		}
		if (TCP == config.type_) {
			if (listen(sock_fd, config.backlog_) < 0) {
				cerr << "socket listen failed on backlog = " << config.backlog_ << endl;
				return -1;
			}
		}
		int flag = 0;
		flag = fcntl(sock_fd, F_GETFL, 0);
		if (flag < 0) {
			cerr << "fcntl F_GETFL on socket = " << sock_fd << " failed...!" << endl;
			return -1;
		}
		if (fcntl(sock_fd, F_SETFL, flag | O_NONBLOCK) < 0) {
			cerr << "fcntl F_SETFL non block on socket = " << sock_fd << " failed...!" << endl;
			return -1;
		}
		return sock_fd;
	}
	bool close_socket(int &sock_fd) {
		if (sock_fd >= 0) {
			close(sock_fd);
			sock_fd = -1;
			return true;
		}
		return false;
	}
private:
	int init_socket(unsigned char type) {
		int sock_fd = -1;
		switch (type) {
		case UDP:
			sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
			break;
		case TCP:
			sock_fd = socket(AF_INET, SOCK_STREAM, 0);
			break;
		default:
			cerr << "unknown socket type...!" << endl;
			return -1;
		}
		if (sock_fd < 0) {
			cerr << "socket fd create failed...!" << endl;
			return -1;
		}
		int on = 1;
		if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0) {
			cerr << "set socket to resue failed...!" << endl;
			return -1;
		}
		if (setsockopt(sock_fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&on, sizeof(on)) < 0) {
			cerr << "set socket to keep alive failed...!" << endl;
			return -1;
		}
		return sock_fd;
	}
};


#endif /* SOCKET_UTILITY_HPP_ */

3.udp_thread.hpp

#ifndef UDP_THREAD_HPP_
#define UDP_THREAD_HPP_
#include "socket_utility.hpp"
#include <event.h>
#include <event2/listener.h>
class udp_thread {
public:
	udp_thread() {
		sock_fd_ = -1;
		base_ = nullptr;
		event_ = nullptr;
	}
	virtual ~udp_thread() {
		if (base_ != nullptr) {
			event_base_loopexit(base_, NULL);
			event_base_free(base_);
			base_ = nullptr;
		}
		if (event_ != nullptr) {
			event_free(event_);
			event_ = nullptr;
		}
	}
public:
	bool init(int fd) {
		if (fd < 0) {
			return false;
		}
		sock_fd_ = fd;
		base_ = event_base_new();
		if (nullptr == base_) {
			return false;
		}
		event_ = event_new(base_, sock_fd_, EV_READ | EV_PERSIST, read_udp_cb, this);
		if (nullptr == event_) {
			return false;
		}
		return 0 == event_add(event_, NULL);
	}
	void udp_dispatch_event() {
		if (base_ != nullptr) {
			event_base_dispatch(base_);
		}
	}
	virtual bool deal_udp_message(int fd) = 0;
public:
	static void read_udp_cb(int fd, short event, void *arg) {
		udp_thread *p = reinterpret_cast<udp_thread *>(arg);
		if (nullptr == p) {
			return;
		}
		p->deal_udp_message(fd);
	}
protected:
	int sock_fd_;
	event_base *base_;
	event *event_;
protected:
	const int buffer_size = 1024;
};

#endif /* UDP_THREAD_HPP_ */

4._thead_for_transaction.hpp

#ifndef UDP_THREAD_FOR_TRANSACTION_HPP_
#define UDP_THREAD_FOR_TRANSACTION_HPP_
#include "udp_thread.hpp"
class udp_thead_for_transaction : public udp_thread {
public:
	udp_thead_for_transaction() = default;
	virtual ~udp_thead_for_transaction() = default;
public:
	virtual bool deal_udp_message(int fd) {
		char buf[buffer_size] = "";
		socklen_t size = sizeof(struct sockaddr);
		struct sockaddr_in client_addr = {0};
		int len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &size);
		if (len < 0) {
			cerr << "server recv message error...!" << endl;
			return false;
		}
		if (0 == len) {
			cerr << "connection closed...!" << endl;
		}
		cout << "connection port = " << client_addr.sin_port << endl;
		cout << "connection ip = " << inet_ntoa(client_addr.sin_addr) << endl;
		cout << "server recv message len = " << len << endl;
		cout << "sever send back message now...!" << endl;
		sendto(fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, size);
		return true;
	}
};


#endif /* UDP_THREAD_FOR_TRANSACTION_HPP_ */

5.udp_server.hpp

#ifndef UDP_SERVER_HPP_
#define UDP_SERVER_HPP_
#include <vector>
#include <thread>
#include <memory>
#include "udp_thread_for_transaction.hpp"

class udp_server {
public:
	udp_server(const socket_config &config) : sock_fd_(-1), config_(config) {
	}
	virtual ~udp_server() {
		for (auto &it : threads_) {
			if (it.joinable()) {
				it.join();
			}
		}
		sockect_utility::get_instance().close_socket(sock_fd_);
	}
public:
	bool init(int network_size) {
		if (network_size <= 0 || network_size > network_capacity) {
			return false;
		}
		sock_fd_ = sockect_utility::get_instance().bind_socket(config_);
		if (sock_fd_ < 0) {
			return false;
		}
		threads_.resize(network_size);
		for (int i = 0;i < network_size;i++) {
			udp_threads_.emplace_back(unique_ptr<udp_thread>(new udp_thead_for_transaction));
			if (false == udp_threads_[i]->init(sock_fd_)) {
				cerr << "udp thread init failed...!" << endl;
				continue;
			}
			try {
				threads_[i] = thread(std::bind(&udp_server::start_udp_thread, this, i));
			}
			catch (...) {
				return false;
			}
		}
		return true;
	}
private:
	void start_udp_thread(int index) {
		udp_threads_[index]->udp_dispatch_event();
	}
private:
	socket_config config_;
	vector<unique_ptr<udp_thread> >udp_threads_;
	vector<thread>threads_;
private:
	int sock_fd_;
private:
	const int network_capacity = 128;
};

#endif /* UDP_SERVER_HPP_ */

6.main.cpp

#include "udp_server.hpp"
int main() {
	socket_config config;
	udp_server server(config);
	cout << server.init(thread::hardware_concurrency()) << endl;

	return 0;
}

7.udp_client.cpp

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <iostream>
using namespace std;
int main() {
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    char buf[] = "hello server I am client...!";
    for (int i = 0;i < 10;i++) {
        sendto(sockfd, &buf, strlen(buf), 0, (struct sockaddr*)&addr,sizeof(addr));
        socklen_t len = sizeof(addr);
        char tmp[1024] = "";
        recvfrom(sockfd, tmp, sizeof(tmp), 0,(struct sockaddr*)&addr,&len);
        if (tmp[0])
        {
            cout << "client recv = " << tmp << endl;
        }
    }
    close(sockfd);
}

7.make.sh

g++ -std=c++11 -g -o udpserver main.cpp socket_config.hpp socket_utility.hpp udp_thread.hpp udp_thread_for_transaction.hpp udp_server.hpp -levent -pthread
g++ -std=c++11 -g -o udpclient udp_client.cpp