DSProxy/SProxy/CLashConfig.cpp

#include "stdafx.h"
#include "CLashConfig.h"
#include "CApp.h"
#include "comm.h"
#include "FileOperate.h"


CLashConfig::CLashConfig() : m_socks_port(9200), m_http_port(9300), m_c_port(9090), m_process(nullptr), m_Asyntask(1), m_AsyntaskProcessMonitor(1), m_is_qut(false), m_log(nullptr)
{
	SNotifyCenter::getSingleton().addEvent(EVENTID(EventClashPreOceeQut));
	_hEvent = nullptr;

}

CLashConfig::~CLashConfig(void)
{
	if (m_process)
	{
		delete m_process;
		m_process = nullptr;
	}
	if (m_log)
	{
		delete m_log;
		m_log = nullptr;
	}
}

BOOL CLashConfig::MakeClash()
{
	buildRules();
	YAML::Node root;
	root["port"] = m_http_port;
	root["socks-port"] = m_socks_port;
	root["allow-lan"] = true;
	root["external-controller"] = "127.0.0.1:" + std::to_string(m_c_port);
	if (CApp::getSingletonPtr()->GetRouteMode() == ROUT_MODE::cn_mode)
	{
		root["mode"] = "rule";
	}
	else {
		root["mode"] = "rule";
	}



#ifdef _DEBUG
	root["log-level"] = "debug";
#else
	root["log-level"] = "info";
#endif

	root["dns"] = buildDnsConfig();

	if (CApp::getSingletonPtr()->GetSysMode() == PROXY_MODE::tun_mode)
	{
		root["tun"] = builTunConfig();
	}

	//proxys.reserve(0);

	//CList_node::getSingletonPtr()->listnode;
	YAML::Node proxies;
	//for each (LISTNODE node in CList_node::getSingletonPtr()->listnode)
	//{
	//	if (node.type == "shadowsocks") {
	//		proxies.push_back(buildShadowsocks(&node));
	//	}
	//	else if (node.type == "trojan") {
	//		proxies.push_back(buildtrojan(&node));
	//	}
	//	else if (node.type == "v2ray") {
	//		proxies.push_back(buildv2ray(&node));
	//	}
	//}


	root["proxies"] = proxies;
	root["proxy-groups"] = buildProxyGroups();

	YAML::Node reject;
	YAML::Node google;
	YAML::Node gfw;
	YAML::Node proxy;
	YAML::Node cncidr;


	reject["type"] = "http";
	reject["behavior"] = "domain";
	reject["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/reject.txt";
	reject["path"] = "./ruleset/reject.yaml";
	reject["interval"] = 86400;

	google["type"] = "http";
	google["behavior"] = "domain";
	google["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/google.txt";
	google["path"] = "./ruleset/google.yaml";
	google["interval"] = 86400;


	gfw["type"] = "http";
	gfw["behavior"] = "domain";
	gfw["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/gfw.txt";
	gfw["path"] = "./ruleset/gfw.yaml";
	gfw["interval"] = 86400;




	proxy["type"] = "http";
	proxy["behavior"] = "domain";
	proxy["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/proxy.txt";
	proxy["path"] = "./ruleset/proxy.yaml";
	proxy["interval"] = 86400;


	cncidr["type"] = "http";
	cncidr["behavior"] = "domain";
	cncidr["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/cncidr.txt";
	cncidr["path"] = "./ruleset/cncidr.yaml";
	cncidr["interval"] = 86400;

	if (CApp::getSingletonPtr()->GetRouteMode() == ROUT_MODE::cn_mode)
	{
		root["rule-providers"]["reject"] = reject;
		root["rule-providers"]["cncidr"] = cncidr;
		root["rule-providers"]["proxy"] = proxy;
		root["rule-providers"]["gfw"] = gfw;
		root["rule-providers"]["google"] = google;
	}

	root["rules"] = m_rules;
	auto name_file = "config.yaml";

	if (CApp::getSingletonPtr()->GetSysMode() == PROXY_MODE::tun_mode) {
		name_file = "tun_config.yaml";
	}

	//std::ofstream ofstream(path + "\\config\\" + name_file);
	//// ÉèÖÃÅäÖÃÎļþnodeÊý
	//ofstream << root << std::endl;
	//ofstream.close();

	return TRUE;
}

BOOL CLashConfig::InitClash()
{
	if (!m_process)
	{
		m_process = new CProcess();
	}
	std::string logfile = std::filesystem::current_path().string() + "\\log\\log.log";
	if (m_log == nullptr)
	{
		m_log = new Logger(Logger::file_and_terminal, Logger::info, logfile);
	}
	m_http_port = CTool::getSingletonPtr()->FindAvailableTcpPort(9300,9500);
	m_socks_port = CTool::getSingletonPtr()->FindAvailableTcpPort(9600,9800);
	m_c_port = CTool::getSingletonPtr()->FindAvailableTcpPort(9900);

 ;

	/*std::string dir = CLASHCONFIGDIR;

	auto name_file = dir + "\\" + CLASHCONFIINIT;

	*/
	
	auto name_file = DSPROXY_CONFIG_INIT_ClASH_NAME;

	if (CApp::getSingletonPtr()->GetSysMode() == PROXY_MODE::tun_mode) {
		/*name_file = dir + "\\" + CLASHCONFIINIT;*/
		name_file = DSPROXY_CONFIG_TUN_ClASH_NAME;
	}
	YAML::Node root;
	root["port"] = m_http_port;
	root["socks-port"] = m_socks_port;
	root["allow-lan"] = true;
	root["external-controller"] = "127.0.0.1:" + std::to_string(m_c_port);


	try
	{
		auto config_path = CApp::getSingletonPtr()->GetConfigPath().wstring() + L"\\" + name_file;
		std::ofstream ofstream(config_path);
		ofstream << root << std::endl;
		ofstream.close();
		return TRUE;
	}
	catch (const std::exception&)
	{
		return FALSE;
	}


    return TRUE;
}

BOOL CLashConfig::StartClash()
{
	/*wil::unique_handle hEvent(CreateEventW(nullptr, FALSE, FALSE, nullptr));
	THROW_LAST_ERROR_IF_NULL(hEvent);*/
	//std::wstring config = path + L"\\" + WCLASHCONFIGDIR;
	////args.push_back("-d");
	//////args.push_back(std::filesystem::current_path().string() + "\\route");
	////args.push_back(path + "\\config");
	////args.push_back("-f");
	////args.push_back(path + "\\config\\configinit.yaml");
	//std::wstring run_config = config + L"\\" + S_CA2W(CLASHCONFIINIT).GetBuffer(0);
	//SStringW path_config;
	//path_config.Format(L"%s\\%s -d %s -f %s", config.c_str(),CLASHEXE,config.c_str(), run_config.c_str());



	auto assetsDir = std::filesystem::current_path() / CLASH_ASSETS_DIR_NAME;
	auto confg_path = CApp::getSingletonPtr()->GetConfigPath() / DSPROXY_CONFIG_INIT_ClASH_NAME;
	CProcessManager::getSingletonPtr()->SetArgs(assetsDir / DSPROXY_EXE_NAME, assetsDir, std::move(confg_path));

	/*ProcessManager::SetConfigFile(confg_path / DSPROXY_CONFIG_INIT_ClASH_NAME);*/
	/* m_Asyntask.AddTask(&CLashConfig::ThreadFun_process_Config, this, (LPARAM)CProcessManager::getSingletonPtr());*/

	if (CProcessManager::getSingletonPtr()->Start())
	{
		CApp::getSingletonPtr()->SetCLashRuning(true);
		m_AsyntaskProcessMonitor.AddTask(&CLashConfig::ThreadFun_ProcessMonitor_Config, this, (LPARAM)CProcessManager::getSingletonPtr());
	}
	
	/*if (m_process)
	{
		m_process->Create(CProcess::ASYNC);
		if (m_process->Execute(path_config.GetBuffer(0)))
		{
			
		}


	}*/
    return 0;
}

BOOL CLashConfig::StopClash()
{
	m_is_qut = true;
	/*SetEvent(_hEvent.get());*/

	//char ch[MAX_PATH];
	//memset(ch, 0, MAX_PATH);
	//sprintf_s(ch, "ok\n");
	//m_process->WriteSome(ch, sizeof(ch));
    return 0;
}

YAML::Node CLashConfig::buildShadowsocks()
{
    return YAML::Node();
}

YAML::Node CLashConfig::buildtrojan()
{
    return YAML::Node();
}

YAML::Node CLashConfig::buildv2ray()
{
    return YAML::Node();
}

std::vector<YAML::Node> CLashConfig::buildv2rayHost()
{
	std::vector<YAML::Node> p;
	/*if (node) {
		YAML::Node t_map;
		t_map["host"] = node->v2_host;
		p.push_back(t_map);
	}*/
	return p;
}

YAML::Node CLashConfig::builTunConfig()
{
	std::vector<std::string> dns;
	dns.push_back("198.18.0.2:53");
	YAML::Node node;
	node["enable"] = true;
	node["stack"] = "gvisor";
	node["dns-hijack"] = dns;
	node["auto-route"] = true;
	node["auto-detect-interface"] = true;
	return node;
}

YAML::Node CLashConfig::buildDnsConfig()
{
	YAML::Node dns;

	std::vector<std::string> dns_arr;
	dns_arr.push_back("114.114.114.114");
	dns_arr.push_back("8.8.8.8");
	dns_arr.push_back("tls://dns.rubyfish.cn:853");
	dns_arr.push_back("https://1.1.1.1/dns-query");
	dns["enable"] = true;
	if (CApp::getSingletonPtr()->GetSysMode() == PROXY_MODE::tun_mode)
	{

		dns["enhanced-mode"] = "redir-host";
	}
	else
	{
		//dns["enable"] = false;
	}
	dns["nameserver"] = dns_arr;
	//dns["use-hosts"] = true;


	return dns;
}

std::vector<YAML::Node> CLashConfig::buildProxyGroups()
{
	std::vector<YAML::Node> dns_arr;
	std::vector<std::string> proxy;
	YAML::Node proxies;
	/*for each (LISTNODE node in CList_node::getSingletonPtr()->listnode)
	{
		proxy.push_back(node.name.c_str());

	}*/
	YAML::Node li;
	li["name"] = "Proxy";
	li["type"] = "select";
	li["proxies"] = proxy;
	dns_arr.push_back(li);

	return dns_arr;
}

std::vector<YAML::Node> CLashConfig::buildRules()
{
	std::vector<YAML::Node> p;

	m_rules.clear();

	if (CApp::getSingletonPtr()->GetRouteMode() == ROUT_MODE::cn_mode)
	{
		m_rules.push_back("RULE-SET,proxy,Proxy");
		m_rules.push_back("RULE-SET,google,Proxy");
		m_rules.push_back("RULE-SET,gfw,Proxy");
		m_rules.push_back("RULE-SET,cncidr,DIRECT");

		m_rules.push_back("GEOIP,CN,DIRECT");
		m_rules.push_back("IP-CIDR,127.0.0.0/8,DIRECT");
		m_rules.push_back("IP-CIDR,172.16.0.0/12,DIRECT");
		m_rules.push_back("IP-CIDR,192.168.0.0/16,DIRECT");
		m_rules.push_back("IP-CIDR,10.0.0.0/8,DIRECT");
		m_rules.push_back("IP-CIDR,100.64.0.0/10,DIRECT");
	}
	else
	{
		// m_rules.push_back("RULE-SET,proxy,Proxy");
		// m_rules.push_back("RULE-SET,google,Proxy");
		// m_rules.push_back("RULE-SET,gfw,Proxy");
		// m_rules.push_back("RULE-SET,cncidr,Proxy");
		m_rules.push_back("GEOIP,CN,Proxy");
		m_rules.push_back("IP-CIDR,127.0.0.0/8,DIRECT");
		m_rules.push_back("IP-CIDR,172.16.0.0/12,DIRECT");
		m_rules.push_back("IP-CIDR,192.168.0.0/16,DIRECT");
		m_rules.push_back("IP-CIDR,10.0.0.0/8,DIRECT");
		m_rules.push_back("IP-CIDR,100.64.0.0/10,DIRECT");
	}

	m_rules.push_back("MATCH,Proxy");

	return p;
}

std::vector<YAML::Node> CLashConfig::buildruleproviders()
{
	std::vector<YAML::Node> pp;
	YAML::Node node;
	YAML::Node reject;
	YAML::Node google;
	YAML::Node gfw;
	YAML::Node proxy;
	YAML::Node cncidr;
	reject["type"] = "http";
	reject["behavior"] = "domain";
	reject["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/reject.txt";
	reject["path"] = "./ruleset/reject.yaml";
	reject["interval"] = 86400;
	node["reject"] = reject;
	pp.push_back(node);

	google["type"] = "http";
	google["behavior"] = "domain";
	google["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/google.txt";
	google["path"] = "./ruleset/google.yaml";
	google["interval"] = 86400;
	node["google"] = google;
	pp.push_back(node);


	gfw["type"] = "http";
	gfw["behavior"] = "domain";
	gfw["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/gfw.txt";
	gfw["path"] = "./ruleset/gfw.yaml";
	gfw["interval"] = 86400;
	node["gfw"] = gfw;
	pp.push_back(node);


	proxy["type"] = "http";
	proxy["behavior"] = "domain";
	proxy["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/proxy.txt";
	proxy["path"] = "./ruleset/proxy.yaml";
	proxy["interval"] = 86400;
	node["proxy"] = proxy;
	pp.push_back(node);

	cncidr["type"] = "http";
	cncidr["behavior"] = "domain";
	cncidr["url"] = "https://cdn.jsdelivr.net/gh/Loyalsoldier/clash-rules@release/cncidr.txt";
	cncidr["path"] = "./ruleset/cncidr.yaml";
	cncidr["interval"] = 86400;
	node["cncidr"] = proxy;
	pp.push_back(node);


	return pp;
}

void CLashConfig::ThreadFun_process_Config(LPARAM lParam)
{
	
	CProcessManager* p = (CProcessManager*)lParam;
	
	if (p->Start())
	{
	
	}

	 
	 WaitForSingleObject(_hEvent.get(),INFINITE);
}

void CLashConfig::ThreadFun_ProcessMonitor_Config(LPARAM lParam)
{
	CProcessManager* p = (CProcessManager*)lParam;
	if (p)
	{
		HANDLE hClashProcess = p->GetClashProcessInfo().hProcess;
		HANDLE hSubProcess = p->GetSubProcessInfo().hProcess;
 
		WaitForSingleObject(hClashProcess, INFINITE);

		CApp::getSingletonPtr()->SetCLashRuning(false);


		if (p->IsRunning() != State::Running)
		{
			return;
		}

		DWORD exitCode = 0;
		THROW_IF_WIN32_BOOL_FALSE(GetExitCodeProcess(hClashProcess, &exitCode));

		LOG_HR_MSG(E_FAIL, "syscode.exe exited with code: %ul", exitCode);

		FILETIME creationTime = {}, exitTime = {}, kernelTime = {}, userTime = {};
		THROW_IF_WIN32_BOOL_FALSE(GetProcessTimes(hClashProcess, &creationTime, &exitTime, &kernelTime, &userTime));
		auto creation = winrt::clock::from_FILETIME(creationTime);
		auto exit = winrt::clock::from_FILETIME(exitTime);
		if (exit - creation < 5s)
		{
			/*g_balloonClickAction = BalloonClickAction::ShowConsoleWindow;
			ShowBalloon(_(L"Clash process was alive less than 5 seconds\nTap to view console log"), _(L"Error"), NIIF_ERROR);
			co_await winrt::resume_on_signal(hSubProcess);*/
			WaitForSingleObject(hSubProcess, INFINITE);
		}

		if (p->IsRunning() != State::Running)
		{
			return;
		}

		p->Stop();

		EventClashPreOceeQut* pEvt = new EventClashPreOceeQut(nullptr);
		pEvt->status = 200;
		pEvt->msg = L"";
		SNotifyCenter::getSingleton().FireEventAsync(pEvt);
		pEvt->Release();

		
	}
	 
}

//winrt::fire_and_forget CLashConfig::_StartClash()
//{
//	if (CProcessManager::getSingletonPtr()->Start())
//	{
//		CApp::getSingletonPtr()->SetCLashRuning(true);
//
//
//
//		/*HANDLE hClashProcess = CProcessManager::getSingletonPtr()->GetClashProcessInfo().hProcess;
//
//		for (size_t i = 0; i < 5; ++i) {
//
//		}*/
//	}
//
//
// 
//}
//
//winrt::Windows::Foundation::IAsyncAction CLashConfig::ProcessMonitor()
//{
//	HANDLE hSubProcess = CProcessManager::getSingletonPtr()->GetClashProcessInfo().hProcess,
//		hClashProcess = CProcessManager::getSingletonPtr()->GetClashProcessInfo().hProcess;
//
//	 winrt::resume_on_signal(hClashProcess);
//
//	 /*std::future<void> f = std::async(std::launch::async, []() {
//		 })*/
//
//
//
// 
//}