rcpp_framework/libs/brynet/net/Socket.hpp

#pragma once

#include <brynet/base/NonCopyable.hpp>
#include <brynet/net/SocketLibFunction.hpp>
#include <exception>
#include <memory>
#include <stdexcept>
#include <string>

namespace brynet {
namespace net {

class TcpConnection;

class UniqueFd final : public brynet::base::NonCopyable {
public:
	explicit UniqueFd(BrynetSocketFD fd) :
			mFD(fd) {}

	~UniqueFd() {
		brynet::net::base::SocketClose(mFD);
	}

	UniqueFd(const UniqueFd &other) = delete;
	UniqueFd &operator=(const UniqueFd &other) = delete;

	BrynetSocketFD getFD() const {
		return mFD;
	}

private:
	BrynetSocketFD mFD;
};

class TcpSocket : public brynet::base::NonCopyable {
private:
	class TcpSocketDeleter {
	public:
		void operator()(TcpSocket *ptr) const {
			delete ptr;
		}
	};

public:
	using Ptr = std::unique_ptr<TcpSocket, TcpSocketDeleter>;

public:
	static Ptr Create(BrynetSocketFD fd, bool serverSide) {
		class make_unique_enabler : public TcpSocket {
		public:
			make_unique_enabler(BrynetSocketFD fd, bool serverSide) :
					TcpSocket(fd, serverSide) {}
		};

		return Ptr(new make_unique_enabler(fd, serverSide));
	}

public:
	void setNodelay() const {
		brynet::net::base::SocketNodelay(mFD);
	}

	bool setNonblock() const {
		return brynet::net::base::SocketNonblock(mFD);
	}

	void setSendSize(int sdSize) const {
		brynet::net::base::SocketSetSendSize(mFD, sdSize);
	}

	void setRecvSize(int rdSize) const {
		brynet::net::base::SocketSetRecvSize(mFD, rdSize);
	}

	std::string getRemoteIP() const {
		return brynet::net::base::GetIPOfSocket(mFD);
	}

	bool isServerSide() const {
		return mServerSide;
	}

protected:
	TcpSocket(BrynetSocketFD fd, bool serverSide) :
			mFD(fd),
			mServerSide(serverSide) {
	}

	virtual ~TcpSocket() {
		brynet::net::base::SocketClose(mFD);
	}

	BrynetSocketFD getFD() const {
		return mFD;
	}

private:
	const BrynetSocketFD mFD;
	const bool mServerSide;

	friend class TcpConnection;
};

class EintrError : public std::exception {
};

class AcceptError : public std::runtime_error {
public:
	explicit AcceptError(int errorCode) :
			std::runtime_error(std::to_string(errorCode)),
			mErrorCode(errorCode) {}

	int getErrorCode() const {
		return mErrorCode;
	}

private:
	int mErrorCode;
};

class ListenSocket : public brynet::base::NonCopyable {
private:
	class ListenSocketDeleter {
	public:
		void operator()(ListenSocket *ptr) const {
			delete ptr;
		}
	};

public:
	using Ptr = std::unique_ptr<ListenSocket, ListenSocketDeleter>;

public:
	TcpSocket::Ptr accept() {
		const auto clientFD = brynet::net::base::Accept(mFD, nullptr, nullptr);
		if (clientFD == BRYNET_INVALID_SOCKET) {
#if defined BRYNET_PLATFORM_LINUX || defined BRYNET_PLATFORM_DARWIN
			if (BRYNET_ERRNO == EMFILE) {
				// Thanks libev and muduo.
				// Read the section named "The special problem of
				// accept()ing when you can't" in libev's doc.
				// By Marc Lehmann, author of libev.
				mIdle.reset();
				TcpSocket::Create(brynet::net::base::Accept(mFD, nullptr, nullptr), true);
				mIdle = brynet::net::TcpSocket::Create(::open("/dev/null", O_RDONLY | O_CLOEXEC), true);
			}
#endif
			if (BRYNET_ERRNO == EINTR) {
				throw EintrError();
			} else {
				throw AcceptError(BRYNET_ERRNO);
			}
		}

		return TcpSocket::Create(clientFD, true);
	}

public:
	static Ptr Create(BrynetSocketFD fd) {
		class make_unique_enabler : public ListenSocket {
		public:
			explicit make_unique_enabler(BrynetSocketFD fd) :
					ListenSocket(fd) {}
		};

		return Ptr(new make_unique_enabler(fd));
	}

protected:
	explicit ListenSocket(BrynetSocketFD fd) :
			mFD(fd) {
#if defined BRYNET_PLATFORM_LINUX || defined BRYNET_PLATFORM_DARWIN
		mIdle = brynet::net::TcpSocket::Create(::open("/dev/null", O_RDONLY | O_CLOEXEC), true);
#endif
	}

	virtual ~ListenSocket() {
		brynet::net::base::SocketClose(mFD);
	}

private:
	const BrynetSocketFD mFD;
#if defined BRYNET_PLATFORM_LINUX || defined BRYNET_PLATFORM_DARWIN
	brynet::net::TcpSocket::Ptr mIdle;
#endif

	friend class TcpConnection;
};

} // namespace net
} // namespace brynet