midware_ws/NetLib/Server/WebSocketSer...

#include "stdafx.h"
#include "WebSocketServer.h"
#include <json/json.h>

CWebSocketServer::CWebSocketServer() 
{
	endpoint_plain.clear_access_channels(websocketpp::log::alevel::all);
	endpoint_plain.set_access_channels(websocketpp::log::alevel::none | websocketpp::log::alevel::none);
	endpoint_plain.set_open_handler(bind(&CWebSocketServer::on_open<server_plain>, this, &endpoint_plain, std::placeholders::_1, WEBSOCKET_TYPE::NORMAL));
	endpoint_plain.set_close_handler(bind(&CWebSocketServer::on_close<server_plain>, this, &endpoint_plain, std::placeholders::_1, WEBSOCKET_TYPE::NORMAL));
	endpoint_plain.set_message_handler(bind(&CWebSocketServer::on_message<server_plain>, this, &endpoint_plain, std::placeholders::_1, std::placeholders::_2));

	endpoint_plain.init_asio(&ios);
	endpoint_plain.set_reuse_addr(true);

	endpoint_tls.clear_access_channels(websocketpp::log::alevel::all);
	endpoint_tls.set_access_channels(websocketpp::log::alevel::none | websocketpp::log::alevel::none);
	endpoint_tls.set_open_handler(bind(&CWebSocketServer::on_open<server_tls>, this, &endpoint_tls, std::placeholders::_1, WEBSOCKET_TYPE::TLS));
	endpoint_tls.set_close_handler(bind(&CWebSocketServer::on_close<server_tls>, this, &endpoint_tls, std::placeholders::_1, WEBSOCKET_TYPE::TLS));
	endpoint_tls.set_message_handler(bind(&CWebSocketServer::on_message<server_tls>, this, &endpoint_tls, std::placeholders::_1, std::placeholders::_2));
	// TLS endpoint has an extra handler for the tls init
	endpoint_tls.set_tls_init_handler(bind(&CWebSocketServer::on_tls_init, this, std::placeholders::_1));

	endpoint_tls.init_asio(&ios);
	endpoint_tls.set_reuse_addr(true);
}

CWebSocketServer::~CWebSocketServer()
{
	stop();
}

bool CWebSocketServer::init(uint16_t port, uint16_t tlsPort, std::string sslFile, std::string sslPwd)
{
	try
	{
		m_sslFile = sslFile;
		m_sslPwd = sslPwd;

		endpoint_plain.listen(port);
		endpoint_plain.start_accept();

		endpoint_tls.listen(tlsPort);
		endpoint_tls.start_accept();
	}
	catch (const std::exception& e)
	{
		std::cout << e.what() << std::endl;
		return false;
	}
	return true;
}

bool CWebSocketServer::sendMsg(websocketpp::connection_hdl hdl, std::string msg)
{
	try
	{
	//	ConvertGBKToUtf8(msg);
		msg = ansi_to_utf8(msg);
		std::unique_lock<std::mutex>lock(m_mut);
		auto type = m_servers[hdl.lock().get()];
		lock.unlock();
		if (WEBSOCKET_TYPE::NORMAL == type)
		{
			endpoint_plain.send(hdl, msg, websocketpp::frame::opcode::TEXT);
		}
		else if (WEBSOCKET_TYPE::TLS == type)
		{
			endpoint_tls.send(hdl, msg, websocketpp::frame::opcode::TEXT);
		}
		else
		{
			return false;
		}
	}
	catch (websocketpp::exception const & e) {
		stringstream str;
		str << "Echo failed because: "
			<< "(" << e.what() << ")";
		std::cout << str.str() << std::endl;
		return false;
	}
	return true;
}

bool CWebSocketServer::sendMsg(long conID, std::string msg)
{
	try
	{
		msg = ansi_to_utf8(msg);
		std::unique_lock<std::mutex>lock(m_mut);
		auto it = m_conIds.find(conID);
		if (it == m_conIds.end()) return false;
		auto type = m_servers[it->second.lock().get()];
		auto hdl = it->second;
		lock.unlock();
		if (WEBSOCKET_TYPE::NORMAL == type)
		{
			endpoint_plain.send(hdl, msg, websocketpp::frame::opcode::TEXT);
		}
		else if (WEBSOCKET_TYPE::TLS == type)
		{
			endpoint_tls.send(hdl, msg, websocketpp::frame::opcode::TEXT);
		}
		else
		{
			return false;
		}
	}
	catch (websocketpp::exception const & e) {
		stringstream str;
		str << "Echo failed because: "
			<< "(" << e.what() << ")";
		std::cout << str.str() << std::endl;
		return false;
	}
	catch (std::exception e) {
		return false;
	}
	return true;
}

void CWebSocketServer::run()
{
	// Start the Asio io_service run loop
	ios.run();
}

void CWebSocketServer::asyncRun()
{
	// 独立运行client::run()的线程，主要是避免阻塞
	//m_Thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&websocketpp::server<websocketpp::config::asio>::run, &endpoint_plain);
	m_Thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(boost::bind(&boost::asio::io_service::run, &ios));
}

void CWebSocketServer::close(websocketpp::connection_hdl hdl)
{
	std::unique_lock<std::mutex>lock(m_mut);
	auto type = m_servers[hdl.lock().get()];
	lock.unlock();
	if (WEBSOCKET_TYPE::NORMAL == type)
	{
		endpoint_plain.close(hdl, websocketpp::close::status::normal, "");
	}
	else if (WEBSOCKET_TYPE::NORMAL == TLS)
	{
		endpoint_tls.close(hdl, websocketpp::close::status::normal, "");
	}
}

void CWebSocketServer::stop()
{
	if (!ios.stopped()) {
		ios.stop();
	}
	if (endpoint_plain.is_listening()) {
		endpoint_plain.stop_listening();
	}
	if (endpoint_tls.is_listening()) {
		endpoint_tls.stop_listening();
	}
	if(m_Thread->joinable())
	m_Thread->join();
}