diff --git a/base/pref-new.yml b/base/pref-new.yml index afb49ee..226d1c6 100644 --- a/base/pref-new.yml +++ b/base/pref-new.yml @@ -135,7 +135,6 @@ advanced: max_allowed_rulesets: 0 max_allowed_rules: 0 max_allowed_download_size: 0 - enable_base_gen: false enable_cache: false cache_subscription: 60 cache_config: 300 diff --git a/base/pref.ini b/base/pref.ini index c91b24b..18baf74 100644 --- a/base/pref.ini +++ b/base/pref.ini @@ -259,7 +259,6 @@ max_concurrent_threads=2 max_allowed_rulesets=0 max_allowed_rules=0 max_allowed_download_size=0 -enable_base_gen=false enable_cache=false cache_subscription=60 cache_config=300 diff --git a/src/interfaces.cpp b/src/interfaces.cpp index 4ac2174..f2d6d68 100644 --- a/src/interfaces.cpp +++ b/src/interfaces.cpp @@ -23,61 +23,57 @@ #include "script_duktape.h" //common settings -std::string pref_path = "pref.ini", def_ext_config; -string_array def_exclude_remarks, def_include_remarks, rulesets, stream_rules, time_rules; -std::vector ruleset_content_array; -std::string listen_address = "127.0.0.1", default_url, insert_url, managed_config_prefix; -int listen_port = 25500, max_pending_connections = 10, max_concurrent_threads = 4; -bool prepend_insert_url = true, skip_failed_links = false; -bool api_mode = true, write_managed_config = false, enable_rule_generator = true, update_ruleset_on_request = false, overwrite_original_rules = true; -bool print_debug_info = false, cfw_child_process = false, append_userinfo = true, enable_base_gen = false, async_fetch_ruleset = false, surge_ssr_resolve = true; -std::string access_token, base_path = "base"; +std::string gPrefPath = "pref.ini", gDefaultExtConfig; +string_array gExcludeRemarks, gIncludeRemarks, gCustomRulesets, gStreamNodeRules, gTimeNodeRules; +std::vector gRulesetContent; +std::string gListenAddress = "127.0.0.1", gDefaultUrls, gInsertUrls, gManagedConfigPrefix; +int gListenPort = 25500, gMaxPendingConns = 10, gMaxConcurThreads = 4; +bool gPrependInsert = true, gSkipFailedLinks = false; +bool gAPIMode = true, gWriteManagedConfig = false, gEnableRuleGen = true, gUpdateRulesetOnRequest = false, gOverwriteOriginalRules = true; +bool gPrintDbgInfo = false, gCFWChildProcess = false, gAppendUserinfo = true, gAsyncFetchRuleset = false, gSurgeResolveHostname = true; +std::string gAccessToken, gBasePath = "base"; extern std::string custom_group; -extern int global_log_level; -extern long max_allowed_download_size; -string_map aliases_map; +extern int gLogLevel; +extern long gMaxAllowedDownloadSize; +string_map gAliases; //global variables for template -std::string template_path = "templates"; -string_map global_vars; +std::string gTemplatePath = "templates"; +string_map gTemplateVars; //generator settings -bool generator_mode = false; -std::string gen_profile; +bool gGeneratorMode = false; +std::string gGenerateProfiles; //multi-thread lock -std::mutex on_configuring; +std::mutex gMutexConfigure; //preferences -string_array renames, emojis; -bool add_emoji = false, remove_old_emoji = false, append_proxy_type = false, filter_deprecated = true; -tribool udp_flag, tfo_flag, scv_flag, tls13_flag, enable_insert; -bool do_sort = false, config_update_strict = false; -bool clash_use_new_field_name = false; -std::string clash_proxies_style = "flow"; -std::string proxy_config, proxy_ruleset, proxy_subscription; -int config_update_interval = 0; -std::string sort_script, filter_script; +string_array gRenames, gEmojis; +bool gAddEmoji = false, gRemoveEmoji = false, gAppendType = false, gFilterDeprecated = true; +tribool gUDP, gTFO, gSkipCertVerify, gTLS13, gEnableInsert; +bool gEnableSort = false, gUpdateStrict = false; +bool gClashUseNewField = false; +std::string gClashProxiesStyle = "flow"; +std::string gProxyConfig, gProxyRuleset, gProxySubscription; +int gUpdateInterval = 0; +std::string gSortScript, gFilterScript; -std::string clash_rule_base; -string_array clash_extra_group; -std::string surge_rule_base, surfboard_rule_base, mellow_rule_base, quan_rule_base, quanx_rule_base, loon_rule_base, sssub_rule_base; -std::string surge_ssr_path, quanx_script_id; - -//pre-compiled rule bases -YAML::Node clash_base; -INIReader surge_base, mellow_base; +std::string gClashBase; +string_array gCustomProxyGroups; +std::string gSurgeBase, gSurfboardBase, gMellowBase, gQuanBase, gQuanXBase, gLoonBase, gSSSubBase; +std::string gSurgeSSRPath, gQuanXDevID; //cache system -bool serve_cache_on_fetch_fail = false; -int cache_subscription = 60, cache_config = 300, cache_ruleset = 21600; +bool gServeCacheOnFetchFail = false; +int gCacheSubscription = 60, gCacheConfig = 300, gCacheRuleset = 21600; //limits -size_t max_allowed_rulesets = 64, max_allowed_rules = 32768; +size_t gMaxAllowedRulesets = 64, gMaxAllowedRules = 32768; -string_array regex_blacklist = {"(.*)*"}; +string_array gRegexBlacklist = {"(.*)*"}; -void refreshRulesets(string_array &ruleset_list, std::vector &rca); +void refreshRulesets(string_array &ruleset_list, std::vector &ruleset_content_array); std::string parseProxy(const std::string &source) { @@ -89,8 +85,8 @@ std::string parseProxy(const std::string &source) return proxy; } -extern string_array clash_rule_type, surge_rule_type, quanx_rule_type; -const std::map ruleset_types = {{"clash-domain:", RULESET_CLASH_DOMAIN}, {"clash-ipcidr:", RULESET_CLASH_IPCIDR}, {"clash-classic:", RULESET_CLASH_CLASSICAL}, \ +extern string_array ClashRuleTypes, SurgeRuleTypes, QuanXRuleTypes; +const std::map RulesetTypes = {{"clash-domain:", RULESET_CLASH_DOMAIN}, {"clash-ipcidr:", RULESET_CLASH_IPCIDR}, {"clash-classic:", RULESET_CLASH_CLASSICAL}, \ {"quanx:", RULESET_QUANX}, {"surge:", RULESET_SURGE}}; struct UAProfile @@ -258,7 +254,7 @@ std::string convertRuleset(const std::string &content, int type) std::string getConvertedRuleset(RESPONSE_CALLBACK_ARGS) { std::string url = UrlDecode(getUrlArg(request.argument, "url")), type = getUrlArg(request.argument, "type"); - return convertRuleset(fetchFile(url, parseProxy(proxy_ruleset), cache_ruleset), to_int(type)); + return convertRuleset(fetchFile(url, parseProxy(gProxyRuleset), gCacheRuleset), to_int(type)); } std::string getRuleset(RESPONSE_CALLBACK_ARGS) @@ -276,7 +272,7 @@ std::string getRuleset(RESPONSE_CALLBACK_ARGS) return "Invalid request!"; } - std::string proxy = parseProxy(proxy_ruleset); + std::string proxy = parseProxy(gProxyRuleset); string_array vArray = split(url, "|"); for(std::string &x : vArray) x.insert(0, "ruleset,"); @@ -332,11 +328,11 @@ std::string getRuleset(RESPONSE_CALLBACK_ARGS) switch(type_int) { case 2: - if(!std::any_of(quanx_rule_type.begin(), quanx_rule_type.end(), [&strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(QuanXRuleTypes.begin(), QuanXRuleTypes.end(), [&strLine](std::string type){return startsWith(strLine, type);})) continue; break; case 1: - if(!std::any_of(surge_rule_type.begin(), surge_rule_type.end(), [&strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(SurgeRuleTypes.begin(), SurgeRuleTypes.end(), [&strLine](std::string type){return startsWith(strLine, type);})) continue; break; case 3: @@ -368,7 +364,7 @@ std::string getRuleset(RESPONSE_CALLBACK_ARGS) output_content += '\n'; continue; case 6: - if(!std::any_of(clash_rule_type.begin(), clash_rule_type.end(), [&strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(ClashRuleTypes.begin(), ClashRuleTypes.end(), [&strLine](std::string type){return startsWith(strLine, type);})) continue; output_content += " - "; } @@ -428,12 +424,12 @@ int importItems(string_array &target, bool scope_limit = true) path = x.substr(x.find(":") + 1); writeLog(0, "Trying to import items from " + path); - std::string proxy = parseProxy(proxy_config); + std::string proxy = parseProxy(gProxyConfig); if(fileExist(path)) content = fileGet(path, scope_limit); else if(isLink(path)) - content = webGet(path, proxy, cache_config); + content = webGet(path, proxy, gCacheConfig); else writeLog(0, "File not found or not a valid URL: " + path, LOG_LEVEL_ERROR); if(!content.size()) @@ -609,13 +605,13 @@ void readRuleset(YAML::Node node, string_array &dest, bool scope_limit = true) importItems(dest, scope_limit); } -void refreshRulesets(string_array &ruleset_list, std::vector &rca) +void refreshRulesets(string_array &ruleset_list, std::vector &ruleset_content_array) { - eraseElements(rca); + eraseElements(ruleset_content_array); std::string rule_group, rule_url, rule_url_typed, interval; ruleset_content rc; - std::string proxy = parseProxy(proxy_ruleset); + std::string proxy = parseProxy(gProxyRuleset); for(std::string &x : ruleset_list) { @@ -639,18 +635,18 @@ void refreshRulesets(string_array &ruleset_list, std::vector &r interval.clear(); ruleset_type type = RULESET_SURGE; rule_url_typed = rule_url; - auto iter = std::find_if(ruleset_types.begin(), ruleset_types.end(), [rule_url](auto y){ return startsWith(rule_url, y.first); }); - if(iter != ruleset_types.end()) + auto iter = std::find_if(RulesetTypes.begin(), RulesetTypes.end(), [rule_url](auto y){ return startsWith(rule_url, y.first); }); + if(iter != RulesetTypes.end()) { rule_url.erase(0, iter->first.size()); type = iter->second; } writeLog(0, "Updating ruleset url '" + rule_url + "' with group '" + rule_group + "'.", LOG_LEVEL_INFO); - rc = {rule_group, rule_url, rule_url_typed, type, fetchFileAsync(rule_url, proxy, cache_ruleset, async_fetch_ruleset), to_int(interval, 0)}; + rc = {rule_group, rule_url, rule_url_typed, type, fetchFileAsync(rule_url, proxy, gCacheRuleset, gAsyncFetchRuleset), to_int(interval, 0)}; } - rca.emplace_back(std::move(rc)); + ruleset_content_array.emplace_back(std::move(rc)); } - rca.shrink_to_fit(); + ruleset_content_array.shrink_to_fit(); } void readYAMLConf(YAML::Node &node) @@ -659,8 +655,8 @@ void readYAMLConf(YAML::Node &node) std::string strLine; string_array tempArray; - section["api_mode"] >> api_mode; - section["api_access_token"] >> access_token; + section["api_mode"] >> gAPIMode; + section["api_access_token"] >> gAccessToken; if(section["default_url"].IsSequence()) { section["default_url"] >> tempArray; @@ -670,11 +666,11 @@ void readYAMLConf(YAML::Node &node) { return std::move(a) + "|" + std::move(b); }); - default_url = strLine; + gDefaultUrls = strLine; eraseElements(tempArray); } } - enable_insert = safe_as(section["enable_insert"]); + gEnableInsert = safe_as(section["enable_insert"]); if(section["insert_url"].IsSequence()) { section["insert_url"] >> tempArray; @@ -684,33 +680,33 @@ void readYAMLConf(YAML::Node &node) { return std::move(a) + "|" + std::move(b); }); - insert_url = strLine; + gInsertUrls = strLine; eraseElements(tempArray); } } - section["prepend_insert_url"] >> prepend_insert_url; + section["prepend_insert_url"] >> gPrependInsert; if(section["exclude_remarks"].IsSequence()) - section["exclude_remarks"] >> def_exclude_remarks; + section["exclude_remarks"] >> gExcludeRemarks; if(section["include_remarks"].IsSequence()) - section["include_remarks"] >> def_include_remarks; - filter_script = safe_as(section["enable_filter"]) ? safe_as(section["filter_script"]) : ""; - if(startsWith(filter_script, "path:")) - filter_script = fileGet(filter_script.substr(5), false); - section["base_path"] >> base_path; - section["clash_rule_base"] >> clash_rule_base; - section["surge_rule_base"] >> surge_rule_base; - section["surfboard_rule_base"] >> surfboard_rule_base; - section["mellow_rule_base"] >> mellow_rule_base; - section["quan_rule_base"] >> quan_rule_base; - section["quanx_rule_base"] >> quanx_rule_base; - section["loon_rule_base"] >> loon_rule_base; - section["sssub_rule_base"] >> sssub_rule_base; + section["include_remarks"] >> gIncludeRemarks; + gFilterScript = safe_as(section["enable_filter"]) ? safe_as(section["filter_script"]) : ""; + if(startsWith(gFilterScript, "path:")) + gFilterScript = fileGet(gFilterScript.substr(5), false); + section["base_path"] >> gBasePath; + section["clash_rule_base"] >> gClashBase; + section["surge_rule_base"] >> gSurgeBase; + section["surfboard_rule_base"] >> gSurfboardBase; + section["mellow_rule_base"] >> gMellowBase; + section["quan_rule_base"] >> gQuanBase; + section["quanx_rule_base"] >> gQuanXBase; + section["loon_rule_base"] >> gLoonBase; + section["sssub_rule_base"] >> gSSSubBase; - section["default_external_config"] >> def_ext_config; - section["append_proxy_type"] >> append_proxy_type; - section["proxy_config"] >> proxy_config; - section["proxy_ruleset"] >> proxy_ruleset; - section["proxy_subscription"] >> proxy_subscription; + section["default_external_config"] >> gDefaultExtConfig; + section["append_proxy_type"] >> gAppendType; + section["proxy_config"] >> gProxyConfig; + section["proxy_ruleset"] >> gProxyRuleset; + section["proxy_subscription"] >> gProxySubscription; if(node["userinfo"].IsDefined()) { @@ -737,16 +733,16 @@ void readYAMLConf(YAML::Node &node) section["tcp_fast_open_flag"] >> tfo_flag; section["skip_cert_verify_flag"] >> scv_flag; */ - udp_flag.set(safe_as(section["udp_flag"])); - tfo_flag.set(safe_as(section["tcp_fast_open_flag"])); - scv_flag.set(safe_as(section["skip_cert_verify_flag"])); - tls13_flag.set(safe_as(section["tls13_flag"])); - section["sort_flag"] >> do_sort; - section["sort_script"] >> sort_script; - section["filter_deprecated_nodes"] >> filter_deprecated; - section["append_sub_userinfo"] >> append_userinfo; - section["clash_use_new_field_name"] >> clash_use_new_field_name; - section["clash_proxies_style"] >> clash_proxies_style; + gUDP.set(safe_as(section["udp_flag"])); + gTFO.set(safe_as(section["tcp_fast_open_flag"])); + gSkipCertVerify.set(safe_as(section["skip_cert_verify_flag"])); + gTLS13.set(safe_as(section["tls13_flag"])); + section["sort_flag"] >> gEnableSort; + section["sort_script"] >> gSortScript; + section["filter_deprecated_nodes"] >> gFilterDeprecated; + section["append_sub_userinfo"] >> gAppendUserinfo; + section["clash_use_new_field_name"] >> gClashUseNewField; + section["clash_proxies_style"] >> gClashProxiesStyle; } if(section["rename_node"].IsSequence()) @@ -759,24 +755,24 @@ void readYAMLConf(YAML::Node &node) if(node["managed_config"].IsDefined()) { section = node["managed_config"]; - section["write_managed_config"] >> write_managed_config; - section["managed_config_prefix"] >> managed_config_prefix; - section["config_update_interval"] >> config_update_interval; - section["config_update_strict"] >> config_update_strict; - section["quanx_device_id"] >> quanx_script_id; + section["write_managed_config"] >> gWriteManagedConfig; + section["managed_config_prefix"] >> gManagedConfigPrefix; + section["config_update_interval"] >> gUpdateInterval; + section["config_update_strict"] >> gUpdateStrict; + section["quanx_device_id"] >> gQuanXDevID; } if(node["surge_external_proxy"].IsDefined()) { - node["surge_external_proxy"]["surge_ssr_path"] >> surge_ssr_path; - node["surge_external_proxy"]["resolve_hostname"] >> surge_ssr_resolve; + node["surge_external_proxy"]["surge_ssr_path"] >> gSurgeSSRPath; + node["surge_external_proxy"]["resolve_hostname"] >> gSurgeResolveHostname; } if(node["emojis"].IsDefined()) { section = node["emojis"]; - section["add_emoji"] >> add_emoji; - section["remove_old_emoji"] >> remove_old_emoji; + section["add_emoji"] >> gAddEmoji; + section["remove_old_emoji"] >> gRemoveEmoji; if(section["rules"].IsSequence()) { readEmoji(section["rules"], tempArray, false); @@ -789,38 +785,38 @@ void readYAMLConf(YAML::Node &node) if(node[rulesets_title].IsDefined()) { section = node[rulesets_title]; - section["enabled"] >> enable_rule_generator; - if(!enable_rule_generator) + section["enabled"] >> gEnableRuleGen; + if(!gEnableRuleGen) { - overwrite_original_rules = false; - update_ruleset_on_request = false; + gOverwriteOriginalRules = false; + gUpdateRulesetOnRequest = false; } else { - section["overwrite_original_rules"] >> overwrite_original_rules; - section["update_ruleset_on_request"] >> update_ruleset_on_request; + section["overwrite_original_rules"] >> gOverwriteOriginalRules; + section["update_ruleset_on_request"] >> gUpdateRulesetOnRequest; } const char *ruleset_title = section["rulesets"].IsDefined() ? "rulesets" : "surge_ruleset"; if(section[ruleset_title].IsSequence()) - readRuleset(section[ruleset_title], rulesets, false); + readRuleset(section[ruleset_title], gCustomRulesets, false); } const char *groups_title = node["proxy_groups"].IsDefined() ? "proxy_groups" : "proxy_group"; if(node[groups_title].IsDefined() && node[groups_title]["custom_proxy_group"].IsDefined()) - readGroup(node[groups_title]["custom_proxy_group"], clash_extra_group, false); + readGroup(node[groups_title]["custom_proxy_group"], gCustomProxyGroups, false); if(node["template"].IsDefined()) { - node["template"]["template_path"] >> template_path; + node["template"]["template_path"] >> gTemplatePath; if(node["template"]["globals"].IsSequence()) { - eraseElements(global_vars); + eraseElements(gTemplateVars); for(size_t i = 0; i < node["template"]["globals"].size(); i++) { std::string key, value; node["template"]["globals"][i]["key"] >> key; node["template"]["globals"][i]["value"] >> value; - global_vars[key] = value; + gTemplateVars[key] = value; } } } @@ -839,77 +835,76 @@ void readYAMLConf(YAML::Node &node) if(node["server"].IsDefined()) { - node["server"]["listen"] >> listen_address; - node["server"]["port"] >> listen_port; + node["server"]["listen"] >> gListenAddress; + node["server"]["port"] >> gListenPort; } if(node["advanced"].IsDefined()) { std::string log_level; node["advanced"]["log_level"] >> log_level; - node["advanced"]["print_debug_info"] >> print_debug_info; - if(print_debug_info) - global_log_level = LOG_LEVEL_VERBOSE; + node["advanced"]["print_debug_info"] >> gPrintDbgInfo; + if(gPrintDbgInfo) + gLogLevel = LOG_LEVEL_VERBOSE; else { switch(hash_(log_level)) { case "warn"_hash: - global_log_level = LOG_LEVEL_WARNING; + gLogLevel = LOG_LEVEL_WARNING; break; case "error"_hash: - global_log_level = LOG_LEVEL_ERROR; + gLogLevel = LOG_LEVEL_ERROR; break; case "fatal"_hash: - global_log_level = LOG_LEVEL_FATAL; + gLogLevel = LOG_LEVEL_FATAL; break; case "verbose"_hash: - global_log_level = LOG_LEVEL_VERBOSE; + gLogLevel = LOG_LEVEL_VERBOSE; break; case "debug"_hash: - global_log_level = LOG_LEVEL_DEBUG; + gLogLevel = LOG_LEVEL_DEBUG; break; default: - global_log_level = LOG_LEVEL_INFO; + gLogLevel = LOG_LEVEL_INFO; } } - node["advanced"]["max_pending_connections"] >> max_pending_connections; - node["advanced"]["max_concurrent_threads"] >> max_concurrent_threads; - node["advanced"]["enable_base_gen"] >> enable_base_gen; - node["advanced"]["max_allowed_rulesets"] >> max_allowed_rulesets; - node["advanced"]["max_allowed_rules"] >> max_allowed_rules; - node["advanced"]["max_allowed_download_size"] >> max_allowed_download_size; + node["advanced"]["max_pending_connections"] >> gMaxPendingConns; + node["advanced"]["max_concurrent_threads"] >> gMaxConcurThreads; + node["advanced"]["max_allowed_rulesets"] >> gMaxAllowedRulesets; + node["advanced"]["max_allowed_rules"] >> gMaxAllowedRules; + node["advanced"]["max_allowed_download_size"] >> gMaxAllowedDownloadSize; if(node["advanced"]["enable_cache"].IsDefined()) { if(safe_as(node["advanced"]["enable_cache"])) { - node["advanced"]["cache_subscription"] >> cache_subscription; - node["advanced"]["cache_config"] >> cache_config; - node["advanced"]["cache_ruleset"] >> cache_ruleset; - node["advanced"]["serve_cache_on_fetch_fail"] >> serve_cache_on_fetch_fail; + node["advanced"]["cache_subscription"] >> gCacheSubscription; + node["advanced"]["cache_config"] >> gCacheConfig; + node["advanced"]["cache_ruleset"] >> gCacheRuleset; + node["advanced"]["serve_cache_on_fetch_fail"] >> gServeCacheOnFetchFail; } else - cache_subscription = cache_config = cache_ruleset = 0; //disable cache + gCacheSubscription = gCacheConfig = gCacheRuleset = 0; //disable cache } - node["advanced"]["async_fetch_ruleset"] >> async_fetch_ruleset; - node["advanced"]["skip_failed_links"] >> skip_failed_links; + node["advanced"]["async_fetch_ruleset"] >> gAsyncFetchRuleset; + node["advanced"]["skip_failed_links"] >> gSkipFailedLinks; } } void readConf() { - guarded_mutex guard(on_configuring); + guarded_mutex guard(gMutexConfigure); //std::cerr<<"Reading preference settings..."< max_allowed_rulesets) + readRuleset(section[ruleset_name], ext.surge_ruleset, gAPIMode); + if(gMaxAllowedRulesets && ext.surge_ruleset.size() > gMaxAllowedRulesets) { writeLog(0, "Ruleset count in external config has exceeded limit.", LOG_LEVEL_WARNING); eraseElements(ext.surge_ruleset); @@ -1209,13 +1203,13 @@ int loadExternalYAML(YAML::Node &node, ExternalConfig &ext) } if(section["rename_node"].size()) - readRegexMatch(section["rename_node"], "@", ext.rename, api_mode); + readRegexMatch(section["rename_node"], "@", ext.rename, gAPIMode); ext.add_emoji = safe_as(section["add_emoji"]); ext.remove_old_emoji = safe_as(section["remove_old_emoji"]); const char *emoji_name = section["emojis"].IsDefined() ? "emojis" : "emoji"; if(section[emoji_name].size()) - readEmoji(section[emoji_name], ext.emoji, api_mode); + readEmoji(section[emoji_name], ext.emoji, gAPIMode); section["include_remarks"] >> ext.include; section["exclude_remarks"] >> ext.exclude; @@ -1236,8 +1230,8 @@ int loadExternalYAML(YAML::Node &node, ExternalConfig &ext) int loadExternalConfig(std::string &path, ExternalConfig &ext) { - std::string base_content, proxy = parseProxy(proxy_config), config = fetchFile(path, proxy, cache_config); - if(render_template(config, *ext.tpl_args, base_content, template_path) != 0) + std::string base_content, proxy = parseProxy(gProxyConfig), config = fetchFile(path, proxy, gCacheConfig); + if(render_template(config, *ext.tpl_args, base_content, gTemplatePath) != 0) base_content = config; try @@ -1265,14 +1259,14 @@ int loadExternalConfig(std::string &path, ExternalConfig &ext) if(ini.ItemPrefixExist("custom_proxy_group")) { ini.GetAll("custom_proxy_group", ext.custom_proxy_group); - importItems(ext.custom_proxy_group, api_mode); + importItems(ext.custom_proxy_group, gAPIMode); } std::string ruleset_name = ini.ItemPrefixExist("ruleset") ? "ruleset" : "surge_ruleset"; if(ini.ItemPrefixExist(ruleset_name)) { ini.GetAll(ruleset_name, ext.surge_ruleset); - importItems(ext.surge_ruleset, api_mode); - if(max_allowed_rulesets && ext.surge_ruleset.size() > max_allowed_rulesets) + importItems(ext.surge_ruleset, gAPIMode); + if(gMaxAllowedRulesets && ext.surge_ruleset.size() > gMaxAllowedRulesets) { writeLog(0, "Ruleset count in external config has exceeded limit. ", LOG_LEVEL_WARNING); eraseElements(ext.surge_ruleset); @@ -1295,14 +1289,14 @@ int loadExternalConfig(std::string &path, ExternalConfig &ext) if(ini.ItemPrefixExist("rename")) { ini.GetAll("rename", ext.rename); - importItems(ext.rename, api_mode); + importItems(ext.rename, gAPIMode); } ext.add_emoji = ini.Get("add_emoji"); ext.remove_old_emoji = ini.Get("remove_old_emoji"); if(ini.ItemPrefixExist("emoji")) { ini.GetAll("emoji", ext.emoji); - importItems(ext.emoji, api_mode); + importItems(ext.emoji, gAPIMode); } if(ini.ItemPrefixExist("include_remarks")) ini.GetAll("include_remarks", ext.include); @@ -1323,54 +1317,22 @@ int loadExternalConfig(std::string &path, ExternalConfig &ext) void checkExternalBase(const std::string &path, std::string &dest) { - if(isLink(path) || (startsWith(path, base_path) && fileExist(path))) + if(isLink(path) || (startsWith(path, gBasePath) && fileExist(path))) dest = path; } -void generateBase() -{ - if(!enable_base_gen) - return; - std::string base_content, proxy = parseProxy(proxy_config); - //std::cerr<<"Generating base content for Clash/R...\n"; - writeLog(0, "Generating base content for Clash/R...", LOG_LEVEL_INFO); - base_content = fetchFile(clash_rule_base, proxy, cache_config); - - try - { - clash_base = YAML::Load(base_content); - rulesetToClash(clash_base, ruleset_content_array, overwrite_original_rules, clash_use_new_field_name); - } - catch (YAML::Exception &e) - { - //std::cerr<<"Unable to load Clash base content. Reason: "< rca; + string_array lCustomProxyGroups = gCustomProxyGroups, lCustomRulesets = gCustomRulesets, lIncludeRemarks = gIncludeRemarks, lExcludeRemarks = gExcludeRemarks; + std::vector lRulesetContent; extra_settings ext; std::string subInfo, dummy; - int interval = interval_str.size() ? to_int(interval_str, config_update_interval) : config_update_interval; - bool ruleset_updated = false, authorized = !api_mode || getUrlArg(argument, "token") == access_token, strict = strict_str.size() ? strict_str == "true" : config_update_strict; + int interval = argUpdateInterval.size() ? to_int(argUpdateInterval, gUpdateInterval) : gUpdateInterval; + bool authorized = !gAPIMode || getUrlArg(argument, "token") == gAccessToken, strict = argUpdateStrict.size() ? argUpdateStrict == "true" : gUpdateStrict; - if(std::find(regex_blacklist.cbegin(), regex_blacklist.cend(), include) != regex_blacklist.cend() || std::find(regex_blacklist.cbegin(), regex_blacklist.cend(), exclude) != regex_blacklist.cend()) + if(std::find(gRegexBlacklist.cbegin(), gRegexBlacklist.cend(), argIncludeRemark) != gRegexBlacklist.cend() || std::find(gRegexBlacklist.cbegin(), gRegexBlacklist.cend(), argExcludeRemark) != gRegexBlacklist.cend()) return "Invalid request!"; //for external configuration - std::string ext_clash_base = clash_rule_base, ext_surge_base = surge_rule_base, ext_mellow_base = mellow_rule_base, ext_surfboard_base = surfboard_rule_base; - std::string ext_quan_base = quan_rule_base, ext_quanx_base = quanx_rule_base, ext_loon_base = loon_rule_base, ext_sssub_base = sssub_rule_base; + std::string lClashBase = gClashBase, lSurgeBase = gSurgeBase, lMellowBase = gMellowBase, lSurfboardBase = gSurfboardBase; + std::string lQuanBase = gQuanBase, lQuanXBase = gQuanXBase, lLoonBase = gLoonBase, lSSSubBase = gSSSubBase; //validate urls - add_insert.define(enable_insert); - if(!url.size() && (!api_mode || authorized)) - url = default_url; - if((!url.size() && !(insert_url.size() && add_insert)) || !target.size()) + argEnableInsert.define(gEnableInsert); + if(!argUrl.size() && (!gAPIMode || authorized)) + argUrl = gDefaultUrls; + if((!argUrl.size() && !(gInsertUrls.size() && argEnableInsert)) || !argTarget.size()) { *status_code = 400; return "Invalid request!"; @@ -1425,11 +1387,10 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) //load request arguments as template variables string_array req_args = split(argument, "&"); - string_size pos; string_map req_arg_map; for(std::string &x : req_args) { - pos = x.find("="); + string_size pos = x.find("="); if(pos == x.npos) { req_arg_map[x] = ""; @@ -1442,163 +1403,128 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) //save template variables template_args tpl_args; - tpl_args.global_vars = global_vars; + tpl_args.global_vars = gTemplateVars; tpl_args.request_params = req_arg_map; //check for proxy settings - std::string proxy = parseProxy(proxy_subscription); + std::string proxy = parseProxy(gProxySubscription); //check other flags - ext.append_proxy_type = append_type.get(append_proxy_type); - if((target == "clash" || target == "clashr") && clash_script.is_undef()) - expand.define(true); + ext.append_proxy_type = argAppendType.get(gAppendType); + if((argTarget == "clash" || argTarget == "clashr") && argGenClashScript.is_undef()) + argExpandRulesets.define(true); - ext.clash_proxies_style = clash_proxies_style; + ext.clash_proxies_style = gClashProxiesStyle; /// read preference from argument, assign global var if not in argument - ext.tfo.parse(tfo).parse(tfo_flag); - ext.udp.parse(udp).parse(udp_flag); - ext.skip_cert_verify.parse(scv).parse(scv_flag); - ext.tls13.parse(tls13).parse(tls13_flag); + ext.tfo.parse(argTFO).parse(gTFO); + ext.udp.parse(argUDP).parse(gUDP); + ext.skip_cert_verify.parse(argSkipCertVerify).parse(gSkipCertVerify); + ext.tls13.parse(argTLS13).parse(gTLS13); - ext.sort_flag = sort_flag.get(do_sort); - use_sort_script.define(sort_script.size() != 0); - if(ext.sort_flag && use_sort_script) - ext.sort_script = sort_script; - ext.filter_deprecated = fdn.get(filter_deprecated); - ext.clash_new_field_name = clash_new_field.get(clash_use_new_field_name); - ext.clash_script = clash_script.get(); - ext.clash_classical_ruleset = classical.get(); - if(!expand) + ext.sort_flag = argSort.get(gEnableSort); + argUseSortScript.define(gSortScript.size() != 0); + if(ext.sort_flag && argUseSortScript) + ext.sort_script = gSortScript; + ext.filter_deprecated = argFilterDeprecated.get(gFilterDeprecated); + ext.clash_new_field_name = argClashNewField.get(gClashUseNewField); + ext.clash_script = argGenClashScript.get(); + ext.clash_classical_ruleset = argGenClassicalRuleProvider.get(); + if(!argExpandRulesets) ext.clash_new_field_name = true; else ext.clash_script = false; - ext.nodelist = nodelist; - ext.surge_ssr_path = surge_ssr_path; - ext.quanx_dev_id = dev_id.size() ? dev_id : quanx_script_id; - ext.enable_rule_generator = enable_rule_generator; - ext.overwrite_original_rules = overwrite_original_rules; - if(!expand) - ext.managed_config_prefix = managed_config_prefix; + ext.nodelist = argGenNodeList; + ext.surge_ssr_path = gSurgeSSRPath; + ext.quanx_dev_id = argDeviceID.size() ? argDeviceID : gQuanXDevID; + ext.enable_rule_generator = gEnableRuleGen; + ext.overwrite_original_rules = gOverwriteOriginalRules; + if(!argExpandRulesets) + ext.managed_config_prefix = gManagedConfigPrefix; //load external configuration - if(config.empty()) - config = def_ext_config; - if(config.size()) + if(argExternalConfig.empty()) + argExternalConfig = gDefaultExtConfig; + if(argExternalConfig.size()) { //std::cerr<<"External configuration file provided. Loading...\n"; writeLog(0, "External configuration file provided. Loading...", LOG_LEVEL_INFO); - //read predefined data first - extra_group = clash_extra_group; - extra_ruleset = rulesets; - //then load external configuration ExternalConfig extconf; extconf.tpl_args = &tpl_args; - if(loadExternalConfig(config, extconf) == 0) + if(loadExternalConfig(argExternalConfig, extconf) == 0) { if(!ext.nodelist) { - checkExternalBase(extconf.clash_rule_base, ext_clash_base); - checkExternalBase(extconf.surge_rule_base, ext_surge_base); - checkExternalBase(extconf.surfboard_rule_base, ext_surfboard_base); - checkExternalBase(extconf.mellow_rule_base, ext_mellow_base); - checkExternalBase(extconf.quan_rule_base, ext_quan_base); - checkExternalBase(extconf.quanx_rule_base, ext_quanx_base); - checkExternalBase(extconf.loon_rule_base, ext_loon_base); - checkExternalBase(extconf.sssub_rule_base, ext_sssub_base); + checkExternalBase(extconf.clash_rule_base, lClashBase); + checkExternalBase(extconf.surge_rule_base, lSurgeBase); + checkExternalBase(extconf.surfboard_rule_base, lSurfboardBase); + checkExternalBase(extconf.mellow_rule_base, lMellowBase); + checkExternalBase(extconf.quan_rule_base, lQuanBase); + checkExternalBase(extconf.quanx_rule_base, lQuanXBase); + checkExternalBase(extconf.loon_rule_base, lLoonBase); + checkExternalBase(extconf.sssub_rule_base, lSSSubBase); + if(extconf.surge_ruleset.size()) + lCustomRulesets = extconf.surge_ruleset; + if(extconf.custom_proxy_group.size()) + lCustomProxyGroups = extconf.custom_proxy_group; + ext.enable_rule_generator = extconf.enable_rule_generator; + ext.overwrite_original_rules = extconf.overwrite_original_rules; } if(extconf.rename.size()) ext.rename_array = extconf.rename; if(extconf.emoji.size()) ext.emoji_array = extconf.emoji; - ext.enable_rule_generator = extconf.enable_rule_generator; - //load custom group - if(extconf.custom_proxy_group.size()) - extra_group = extconf.custom_proxy_group; - //load custom rules - ext.overwrite_original_rules = extconf.overwrite_original_rules; if(extconf.include.size()) - include_remarks = extconf.include; + lIncludeRemarks = extconf.include; if(extconf.exclude.size()) - exclude_remarks = extconf.exclude; - emoji_add.define(extconf.add_emoji); - emoji_remove.define(extconf.remove_old_emoji); - } - if(extconf.surge_ruleset.size() && !ext.nodelist) - { - extra_ruleset = extconf.surge_ruleset; - refreshRulesets(extra_ruleset, rca); - ruleset_updated = true; - } - else - { - if(ext.enable_rule_generator && !ext.nodelist) - { - if(update_ruleset_on_request) - refreshRulesets(rulesets, ruleset_content_array); - rca = ruleset_content_array; - } + lExcludeRemarks = extconf.exclude; + argAddEmoji.define(extconf.add_emoji); + argRemoveEmoji.define(extconf.remove_old_emoji); } + } else { //loading custom groups - if(groups.size() && !ext.nodelist) - { - extra_group = split(groups, "@"); - if(!extra_group.size()) - extra_group = clash_extra_group; - } - else - extra_group = clash_extra_group; + if(argCustomGroups.size() && !ext.nodelist) + lCustomProxyGroups = split(argCustomGroups, "@"); //loading custom rulesets - if(ruleset.size() && !ext.nodelist) - { - extra_ruleset = split(ruleset, "@"); - if(!extra_ruleset.size()) - { - if(update_ruleset_on_request) - refreshRulesets(rulesets, ruleset_content_array); - rca = ruleset_content_array; - } - else - { - refreshRulesets(extra_ruleset, rca); - ruleset_updated = true; - } - } + if(argCustomRulesets.size() && !ext.nodelist) + lCustomRulesets = split(argCustomRulesets, "@"); + } + if(ext.enable_rule_generator && !ext.nodelist) + { + if(lCustomRulesets != gCustomRulesets) + refreshRulesets(lCustomRulesets, lRulesetContent); else { - if(enable_rule_generator && !ext.nodelist) - { - if(update_ruleset_on_request || cfw_child_process) - refreshRulesets(rulesets, ruleset_content_array); - rca = ruleset_content_array; - } + if(gUpdateRulesetOnRequest) + refreshRulesets(gCustomRulesets, gRulesetContent); + lRulesetContent = gRulesetContent; } } - if(!emoji.is_undef()) + if(!argEmoji.is_undef()) { - emoji_add.set(emoji); - emoji_remove.set(true); + argAddEmoji.set(argEmoji); + argRemoveEmoji.set(true); } - ext.add_emoji = emoji_add.get(add_emoji); - ext.remove_emoji = emoji_remove.get(remove_old_emoji); + ext.add_emoji = argAddEmoji.get(gAddEmoji); + ext.remove_emoji = argRemoveEmoji.get(gRemoveEmoji); if(ext.add_emoji && ext.emoji_array.empty()) ext.emoji_array = safe_get_emojis(); - if(ext_rename.size()) - ext.rename_array = split(ext_rename, "`"); + if(argRenames.size()) + ext.rename_array = split(argRenames, "`"); else if(ext.rename_array.empty()) ext.rename_array = safe_get_renames(); //check custom include/exclude settings - if(include.size() && regValid(include)) - include_remarks = string_array{include}; - if(exclude.size() && regValid(exclude)) - exclude_remarks = string_array{exclude}; + if(argIncludeRemark.size() && regValid(argIncludeRemark)) + lIncludeRemarks = string_array{argIncludeRemark}; + if(argExcludeRemark.size() && regValid(argExcludeRemark)) + lExcludeRemarks = string_array{argExcludeRemark}; //start parsing urls string_array stream_temp = safe_get_streams(), time_temp = safe_get_times(); @@ -1607,18 +1533,18 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) string_array urls; std::vector nodes, insert_nodes; int groupID = 0; - if(insert_url.size() && add_insert) + if(gInsertUrls.size() && argEnableInsert) { groupID = -1; - urls = split(insert_url, "|"); + urls = split(gInsertUrls, "|"); importItems(urls, true); for(std::string &x : urls) { x = regTrim(x); writeLog(0, "Fetching node data from url '" + x + "'.", LOG_LEVEL_INFO); - if(addNodes(x, insert_nodes, groupID, proxy, exclude_remarks, include_remarks, stream_temp, time_temp, subInfo, authorized, request.headers) == -1) + if(addNodes(x, insert_nodes, groupID, proxy, lExcludeRemarks, lIncludeRemarks, stream_temp, time_temp, subInfo, authorized, request.headers) == -1) { - if(skip_failed_links) + if(gSkipFailedLinks) writeLog(0, "The following link doesn't contain any valid node info: " + x, LOG_LEVEL_WARNING); else { @@ -1629,7 +1555,7 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) groupID--; } } - urls = split(url, "|"); + urls = split(argUrl, "|"); importItems(urls, true); groupID = 0; for(std::string &x : urls) @@ -1637,9 +1563,9 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) x = regTrim(x); //std::cerr<<"Fetching node data from url '"< dummy_ruleset; std::string managed_url = base64_decode(UrlDecode(getUrlArg(argument, "profile_data"))); if(managed_url.empty()) - managed_url = managed_config_prefix + "/sub?" + argument; + managed_url = gManagedConfigPrefix + "/sub?" + argument; //std::cerr<<"Generate target: "; - proxy = parseProxy(proxy_config); - switch(hash_(target)) + proxy = parseProxy(gProxyConfig); + switch(hash_(argTarget)) { case "clash"_hash: case "clashr"_hash: - writeLog(0, target == "clashr" ? "Generate target: ClashR" : "Generate target: Clash", LOG_LEVEL_INFO); + writeLog(0, argTarget == "clashr" ? "Generate target: ClashR" : "Generate target: Clash", LOG_LEVEL_INFO); tpl_args.local_vars["clash.new_field_name"] = ext.clash_new_field_name ? "true" : "false"; if(ext.nodelist) { YAML::Node yamlnode; - netchToClash(nodes, yamlnode, dummy_group, target == "clashr", ext); + netchToClash(nodes, yamlnode, dummy_group, argTarget == "clashr", ext); output_content = YAML::Dump(yamlnode); } - else if(ruleset_updated || update_ruleset_on_request || ext_clash_base != clash_rule_base || !enable_base_gen) + else { - if(render_template(fetchFile(ext_clash_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lClashBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_clash_base, proxy, cache_config); - output_content = netchToClash(nodes, base_content, rca, extra_group, target == "clashr", ext); - } - else - { - YAML::Node yamlnode = safe_get_clash_base(); - netchToClash(nodes, yamlnode, extra_group, target == "clashr", ext); - output_content = YAML::Dump(yamlnode); + output_content = netchToClash(nodes, base_content, lRulesetContent, lCustomProxyGroups, argTarget == "clashr", ext); } - if(upload) - uploadGist(target, upload_path, output_content, false); + if(argUpload) + uploadGist(argTarget, argUploadPath, output_content, false); break; case "surge"_hash: - writeLog(0, "Generate target: Surge " + std::to_string(surge_ver), LOG_LEVEL_INFO); + writeLog(0, "Generate target: Surge " + std::to_string(intSurgeVer), LOG_LEVEL_INFO); if(ext.nodelist) { - output_content = netchToSurge(nodes, base_content, dummy_ruleset, dummy_group, surge_ver, ext); + output_content = netchToSurge(nodes, base_content, dummy_ruleset, dummy_group, intSurgeVer, ext); - if(upload) - uploadGist("surge" + version + "list", upload_path, output_content, true); + if(argUpload) + uploadGist("surge" + argSurgeVer + "list", argUploadPath, output_content, true); } else { - if(render_template(fetchFile(ext_surge_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lSurgeBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_surge_base, proxy, cache_config); - output_content = netchToSurge(nodes, base_content, rca, extra_group, surge_ver, ext); + output_content = netchToSurge(nodes, base_content, lRulesetContent, lCustomProxyGroups, intSurgeVer, ext); - if(upload) - uploadGist("surge" + version, upload_path, output_content, true); + if(argUpload) + uploadGist("surge" + argSurgeVer, argUploadPath, output_content, true); - if(write_managed_config && managed_config_prefix.size()) + if(gWriteManagedConfig && gManagedConfigPrefix.size()) output_content = "#!MANAGED-CONFIG " + managed_url + (interval ? " interval=" + std::to_string(interval) : "") \ + " strict=" + std::string(strict ? "true" : "false") + "\n\n" + output_content; } @@ -1775,145 +1693,127 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) case "surfboard"_hash: writeLog(0, "Generate target: Surfboard", LOG_LEVEL_INFO); - if(render_template(fetchFile(ext_surfboard_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lSurfboardBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_surfboard_base, proxy, cache_config); - output_content = netchToSurge(nodes, base_content, rca, extra_group, -3, ext); - if(upload) - uploadGist("surfboard", upload_path, output_content, true); + output_content = netchToSurge(nodes, base_content, lRulesetContent, lCustomProxyGroups, -3, ext); + if(argUpload) + uploadGist("surfboard", argUploadPath, output_content, true); - if(write_managed_config && managed_config_prefix.size()) + if(gWriteManagedConfig && gManagedConfigPrefix.size()) output_content = "#!MANAGED-CONFIG " + managed_url + (interval ? " interval=" + std::to_string(interval) : "") \ + " strict=" + std::string(strict ? "true" : "false") + "\n\n" + output_content; break; case "mellow"_hash: writeLog(0, "Generate target: Mellow", LOG_LEVEL_INFO); - // mellow base generator removed for now - //if(ruleset_updated || update_ruleset_on_request || ext_mellow_base != mellow_rule_base || !enable_base_gen) - { - if(render_template(fetchFile(ext_mellow_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) - { - *status_code = 400; - return base_content; - } - //base_content = fetchFile(ext_mellow_base, proxy, cache_config); - output_content = netchToMellow(nodes, base_content, rca, extra_group, ext); - } - /* - else - { - INIReader ini; - ini = safe_get_mellow_base(); - netchToMellow(nodes, ini, rca, extra_group, ext); - output_content = ini.ToString(); - } - */ - if(upload) - uploadGist("mellow", upload_path, output_content, true); - break; - case "sssub"_hash: - writeLog(0, "Generate target: SS Subscription", LOG_LEVEL_INFO); - - if(render_template(fetchFile(ext_sssub_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lMellowBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) + { + *status_code = 400; + return base_content; + } + output_content = netchToMellow(nodes, base_content, lRulesetContent, lCustomProxyGroups, ext); + + if(argUpload) + uploadGist("mellow", argUploadPath, output_content, true); + break; + case "sssub"_hash: + writeLog(0, "Generate target: SS Subscription", LOG_LEVEL_INFO); + + if(render_template(fetchFile(lSSSubBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_sssub_base, proxy, cache_config); output_content = netchToSSSub(base_content, nodes, ext); - if(upload) - uploadGist("sssub", upload_path, output_content, false); + if(argUpload) + uploadGist("sssub", argUploadPath, output_content, false); break; case "ss"_hash: writeLog(0, "Generate target: SS", LOG_LEVEL_INFO); output_content = netchToSingle(nodes, 1, ext); - if(upload) - uploadGist("ss", upload_path, output_content, false); + if(argUpload) + uploadGist("ss", argUploadPath, output_content, false); break; case "ssr"_hash: writeLog(0, "Generate target: SSR", LOG_LEVEL_INFO); output_content = netchToSingle(nodes, 2, ext); - if(upload) - uploadGist("ssr", upload_path, output_content, false); + if(argUpload) + uploadGist("ssr", argUploadPath, output_content, false); break; case "v2ray"_hash: writeLog(0, "Generate target: v2rayN", LOG_LEVEL_INFO); output_content = netchToSingle(nodes, 4, ext); - if(upload) - uploadGist("v2ray", upload_path, output_content, false); + if(argUpload) + uploadGist("v2ray", argUploadPath, output_content, false); break; case "trojan"_hash: writeLog(0, "Generate target: Trojan", LOG_LEVEL_INFO); output_content = netchToSingle(nodes, 8, ext); - if(upload) - uploadGist("trojan", upload_path, output_content, false); + if(argUpload) + uploadGist("trojan", argUploadPath, output_content, false); break; case "mixed"_hash: writeLog(0, "Generate target: Standard Subscription", LOG_LEVEL_INFO); output_content = netchToSingle(nodes, 15, ext); - if(upload) - uploadGist("sub", upload_path, output_content, false); + if(argUpload) + uploadGist("sub", argUploadPath, output_content, false); break; case "quan"_hash: writeLog(0, "Generate target: Quantumult", LOG_LEVEL_INFO); if(!ext.nodelist) { - if(render_template(fetchFile(ext_quan_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lQuanBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_quan_base, proxy, cache_config); } - output_content = netchToQuan(nodes, base_content, rca, extra_group, ext); + output_content = netchToQuan(nodes, base_content, lRulesetContent, lCustomProxyGroups, ext); - if(upload) - uploadGist("quan", upload_path, output_content, false); + if(argUpload) + uploadGist("quan", argUploadPath, output_content, false); break; case "quanx"_hash: writeLog(0, "Generate target: Quantumult X", LOG_LEVEL_INFO); if(!ext.nodelist) { - if(render_template(fetchFile(ext_quanx_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lQuanXBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_quanx_base, proxy, cache_config); } - output_content = netchToQuanX(nodes, base_content, rca, extra_group, ext); + output_content = netchToQuanX(nodes, base_content, lRulesetContent, lCustomProxyGroups, ext); - if(upload) - uploadGist("quanx", upload_path, output_content, false); + if(argUpload) + uploadGist("quanx", argUploadPath, output_content, false); break; case "loon"_hash: writeLog(0, "Generate target: Loon", LOG_LEVEL_INFO); if(!ext.nodelist) { - if(render_template(fetchFile(ext_loon_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) + if(render_template(fetchFile(lLoonBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { *status_code = 400; return base_content; } - //base_content = fetchFile(ext_loon_base, proxy, cache_config); } - output_content = netchToLoon(nodes, base_content, rca, extra_group, ext); + output_content = netchToLoon(nodes, base_content, lRulesetContent, lCustomProxyGroups, ext); - if(upload) - uploadGist("loon", upload_path, output_content, false); + if(argUpload) + uploadGist("loon", argUploadPath, output_content, false); break; case "ssd"_hash: writeLog(0, "Generate target: SSD", LOG_LEVEL_INFO); - output_content = netchToSSD(nodes, group, subInfo, ext); - if(upload) - uploadGist("ssd", upload_path, output_content, false); + output_content = netchToSSD(nodes, argGroupName, subInfo, ext); + if(argUpload) + uploadGist("ssd", argUploadPath, output_content, false); break; default: writeLog(0, "Generate target: Unspecified", LOG_LEVEL_INFO); @@ -1921,8 +1821,8 @@ std::string subconverter(RESPONSE_CALLBACK_ARGS) return "Unrecognized target"; } writeLog(0, "Generate completed.", LOG_LEVEL_INFO); - if(filename.size()) - response.headers.emplace("Content-Disposition", "attachment; filename=\"" + filename + "\""); + if(argFilename.size()) + response.headers.emplace("Content-Disposition", "attachment; filename=\"" + argFilename + "\""); return output_content; } @@ -1955,12 +1855,12 @@ std::string surgeConfToClash(RESPONSE_CALLBACK_ARGS) string_array dummy_str_array; std::vector nodes; std::string base_content, url = argument.size() <= 5 ? "" : argument.substr(5); - const std::string proxygroup_name = clash_use_new_field_name ? "proxy-groups" : "Proxy Group", rule_name = clash_use_new_field_name ? "rules" : "Rule"; + const std::string proxygroup_name = gClashUseNewField ? "proxy-groups" : "Proxy Group", rule_name = gClashUseNewField ? "rules" : "Rule"; ini.store_any_line = true; if(!url.size()) - url = default_url; + url = gDefaultUrls; if(!url.size() || argument.substr(0, 5) != "link=") { *status_code = 400; @@ -1973,30 +1873,22 @@ std::string surgeConfToClash(RESPONSE_CALLBACK_ARGS) } writeLog(0, "SurgeConfToClash called with url '" + url + "'.", LOG_LEVEL_INFO); - std::string proxy = parseProxy(proxy_config); + std::string proxy = parseProxy(gProxyConfig); YAML::Node clash; template_args tpl_args; - tpl_args.global_vars = global_vars; - tpl_args.local_vars["clash.new_field_name"] = clash_use_new_field_name ? "true" : "false"; + tpl_args.global_vars = gTemplateVars; + tpl_args.local_vars["clash.new_field_name"] = gClashUseNewField ? "true" : "false"; tpl_args.request_params["target"] = "clash"; tpl_args.request_params["url"] = url; - if(!enable_base_gen) + if(render_template(fetchFile(gClashBase, proxy, gCacheConfig), tpl_args, base_content, gTemplatePath) != 0) { - if(render_template(fetchFile(clash_rule_base, proxy, cache_config), tpl_args, base_content, template_path) != 0) - { - *status_code = 400; - return base_content; - } - //base_content = fetchFile(clash_rule_base, proxy, cache_config); - clash = YAML::Load(base_content); - } - else - { - clash = safe_get_clash_base(); + *status_code = 400; + return base_content; } + clash = YAML::Load(base_content); - base_content = fetchFile(url, proxy, cache_config); + base_content = fetchFile(url, proxy, gCacheConfig); if(ini.Parse(base_content) != INIREADER_EXCEPTION_NONE) { @@ -2049,7 +1941,7 @@ std::string surgeConfToClash(RESPONSE_CALLBACK_ARGS) clash[proxygroup_name].push_back(singlegroup); } - proxy = parseProxy(proxy_subscription); + proxy = parseProxy(gProxySubscription); eraseElements(dummy_str_array); std::string subInfo; @@ -2057,9 +1949,9 @@ std::string surgeConfToClash(RESPONSE_CALLBACK_ARGS) { //std::cerr<<"Fetching node data from url '"<= 2 && strLine[0] == '/' && strLine[1] == '/')) //empty lines and comments are ignored continue; - else if(!std::any_of(clash_rule_type.begin(), clash_rule_type.end(), [&strLine](std::string type){return startsWith(strLine, type);})) //remove unsupported types + else if(!std::any_of(ClashRuleTypes.begin(), ClashRuleTypes.end(), [&strLine](std::string type){return startsWith(strLine, type);})) //remove unsupported types continue; strLine += strArray[2]; if(count_least(strLine, ',', 3)) @@ -2149,7 +2041,7 @@ std::string surgeConfToClash(RESPONSE_CALLBACK_ARGS) ss.clear(); continue; } - else if(!std::any_of(clash_rule_type.begin(), clash_rule_type.end(), [&strLine](std::string type){return startsWith(strLine, type);})) + else if(!std::any_of(ClashRuleTypes.begin(), ClashRuleTypes.end(), [&strLine](std::string type){return startsWith(strLine, type);})) continue; rule.push_back(x); } @@ -2206,11 +2098,11 @@ std::string getProfile(RESPONSE_CALLBACK_ARGS) *status_code = 403; return "Forbidden"; } - token = access_token; + token = gAccessToken; } else { - if(token != access_token) + if(token != gAccessToken) { *status_code = 403; return "Forbidden"; @@ -2252,7 +2144,7 @@ std::string getProfile(RESPONSE_CALLBACK_ARGS) } contents.emplace("token", token); - contents.emplace("profile_data", base64_encode(managed_config_prefix + "/getprofile?" + argument)); + contents.emplace("profile_data", base64_encode(gManagedConfigPrefix + "/getprofile?" + argument)); std::string query = std::accumulate(contents.begin(), contents.end(), std::string(), [](const std::string &x, auto y){ return x + y.first + "=" + UrlEncode(y.second) + "&"; }); query += argument; request.argument = query; @@ -2266,12 +2158,12 @@ std::string getScript(RESPONSE_CALLBACK_ARGS) std::string url = urlsafe_base64_decode(getUrlArg(argument, "url")), dev_id = getUrlArg(argument, "id"); std::string output_content; - std::string proxy = parseProxy(proxy_config); + std::string proxy = parseProxy(gProxyConfig); - output_content = fetchFile(url, proxy, cache_config); + output_content = fetchFile(url, proxy, gCacheConfig); if(!dev_id.size()) - dev_id = quanx_script_id; + dev_id = gQuanXDevID; const std::string pattern = "(\\/\\*[\\s\\S]*?)^(.*?@supported )(.*?\\s?)$([\\s\\S]*\\*\\/\\s?"; if(dev_id.size()) @@ -2291,12 +2183,12 @@ std::string getRewriteRemote(RESPONSE_CALLBACK_ARGS) std::string url = urlsafe_base64_decode(getUrlArg(argument, "url")), dev_id = getUrlArg(argument, "id"); std::string output_content; - std::string proxy = parseProxy(proxy_config); + std::string proxy = parseProxy(gProxyConfig); - output_content = fetchFile(url, proxy, cache_config); + output_content = fetchFile(url, proxy, gCacheConfig); if(!dev_id.size()) - dev_id = quanx_script_id; + dev_id = gQuanXDevID; if(dev_id.size()) { @@ -2316,7 +2208,7 @@ std::string getRewriteRemote(RESPONSE_CALLBACK_ARGS) if(!strLine.empty() && regMatch(strLine, pattern)) { - url = managed_config_prefix + "/qx-script?id=" + dev_id + "&url=" + urlsafe_base64_encode(regReplace(strLine, pattern, "$2")); + url = gManagedConfigPrefix + "/qx-script?id=" + dev_id + "&url=" + urlsafe_base64_encode(regReplace(strLine, pattern, "$2")); strLine = regReplace(strLine, pattern, "$1") + url; } output_content.append(strLine + "\n"); @@ -2333,10 +2225,10 @@ std::string parseHostname(inja::Arguments &args) if(!urls.size()) return std::string(); - std::string input_content, output_content, proxy = parseProxy(proxy_config); + std::string input_content, output_content, proxy = parseProxy(gProxyConfig); for(std::string &x : urls) { - input_content = webGet(x, proxy, cache_config); + input_content = webGet(x, proxy, gCacheConfig); regGetMatch(input_content, matcher, 2, 0, &hostname); if(hostname.size()) { @@ -2357,16 +2249,16 @@ std::string parseHostname(inja::Arguments &args) std::string template_webGet(inja::Arguments &args) { - std::string data = args.at(0)->get(), proxy = parseProxy(proxy_config); + std::string data = args.at(0)->get(), proxy = parseProxy(gProxyConfig); writeLog(0, "Template called fetch with url '" + data + "'.", LOG_LEVEL_INFO); - return webGet(data, proxy, cache_config); + return webGet(data, proxy, gCacheConfig); } std::string jinja2_webGet(const std::string &url) { - std::string proxy = parseProxy(proxy_config); + std::string proxy = parseProxy(gProxyConfig); writeLog(0, "Template called fetch with url '" + url + "'.", LOG_LEVEL_INFO); - return webGet(url, proxy, cache_config); + return webGet(url, proxy, gCacheConfig); } static inline std::string intToStream(unsigned long long stream) @@ -2434,11 +2326,11 @@ int simpleGenerator() writeLog(0, "Read generator configuration completed.\n", LOG_LEVEL_INFO); string_array sections = ini.GetSections(); - if(gen_profile.size()) + if(gGenerateProfiles.size()) { //std::cerr<<"Generating with specific artifacts: \""< &rca); void readConf(); -void generateBase(); int simpleGenerator(); std::string convertRuleset(const std::string &content, int type); diff --git a/src/logger.cpp b/src/logger.cpp index cfd4260..e3615d8 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -7,8 +7,8 @@ #include "logger.h" -extern bool print_debug_info; -int global_log_level = LOG_LEVEL_INFO; +extern bool gPrintDbgInfo; +int gLogLevel = LOG_LEVEL_INFO; std::string getTime(int type) { @@ -38,7 +38,7 @@ std::string getTime(int type) void writeLog(int type, const std::string &content, int level) { - if(level > global_log_level) + if(level > gLogLevel) return; const char *levels[] = {"[FATL]", "[ERRO]", "[WARN]", "[INFO]", "[DEBG]", "[VERB]"}; std::cerr< ruleset_content_array; +extern std::string gPrefPath, gAccessToken, gListenAddress, gGenerateProfiles, gManagedConfigPrefix; +extern bool gAPIMode, gGeneratorMode, gCFWChildProcess, gUpdateRulesetOnRequest; +extern int gListenPort, gMaxConcurThreads, gMaxPendingConns; +extern string_array gCustomRulesets; +extern std::vector gRulesetContent; #ifndef _WIN32 void SetConsoleTitle(const std::string &title) @@ -54,22 +54,22 @@ void chkArg(int argc, char *argv[]) { if(strcmp(argv[i], "-cfw") == 0) { - cfw_child_process = true; - update_ruleset_on_request = true; + gCFWChildProcess = true; + gUpdateRulesetOnRequest = true; } else if(strcmp(argv[i], "-f") == 0 || strcmp(argv[i], "--file") == 0) { if(i < argc - 1) - pref_path.assign(argv[++i]); + gPrefPath.assign(argv[++i]); } else if(strcmp(argv[i], "-g") == 0 || strcmp(argv[i], "--gen") == 0) { - generator_mode = true; + gGeneratorMode = true; } else if(strcmp(argv[i], "--artifact") == 0) { if(i < argc - 1) - gen_profile.assign(argv[++i]); + gGenerateProfiles.assign(argv[++i]); } else if(strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--log") == 0) { @@ -104,9 +104,9 @@ int main(int argc, char *argv[]) setcd(prgpath); //first switch to program directory #endif // _DEBUG if(fileExist("pref.yml")) - pref_path = "pref.yml"; + gPrefPath = "pref.yml"; chkArg(argc, argv); - setcd(pref_path); //then switch to pref directory + setcd(gPrefPath); //then switch to pref directory writeLog(0, "SubConverter " VERSION " starting up..", LOG_LEVEL_INFO); #ifdef _WIN32 WSADATA wsaData; @@ -130,18 +130,17 @@ int main(int argc, char *argv[]) SetConsoleTitle("SubConverter " VERSION); readConf(); - if(!update_ruleset_on_request) - refreshRulesets(rulesets, ruleset_content_array); - generateBase(); + if(!gUpdateRulesetOnRequest) + refreshRulesets(gCustomRulesets, gRulesetContent); std::string env_api_mode = GetEnv("API_MODE"), env_managed_prefix = GetEnv("MANAGED_PREFIX"), env_token = GetEnv("API_TOKEN"); - api_mode = tribool().parse(toLower(env_api_mode)).get(api_mode); + gAPIMode = tribool().parse(toLower(env_api_mode)).get(gAPIMode); if(env_managed_prefix.size()) - managed_config_prefix = env_managed_prefix; + gManagedConfigPrefix = env_managed_prefix; if(env_token.size()) - access_token = env_token; + gAccessToken = env_token; - if(generator_mode) + if(gGeneratorMode) return simpleGenerator(); append_response("GET", "/", "text/plain", [](RESPONSE_CALLBACK_ARGS) -> std::string @@ -156,42 +155,40 @@ int main(int argc, char *argv[]) append_response("GET", "/refreshrules", "text/plain", [](RESPONSE_CALLBACK_ARGS) -> std::string { - if(access_token.size()) + if(gAccessToken.size()) { std::string token = getUrlArg(request.argument, "token"); - if(token != access_token) + if(token != gAccessToken) { response.status_code = 403; return "Forbidden\n"; } } - refreshRulesets(rulesets, ruleset_content_array); - generateBase(); + refreshRulesets(gCustomRulesets, gRulesetContent); return "done\n"; }); append_response("GET", "/readconf", "text/plain", [](RESPONSE_CALLBACK_ARGS) -> std::string { - if(access_token.size()) + if(gAccessToken.size()) { std::string token = getUrlArg(request.argument, "token"); - if(token != access_token) + if(token != gAccessToken) { response.status_code = 403; return "Forbidden\n"; } } readConf(); - generateBase(); return "done\n"; }); append_response("POST", "/updateconf", "text/plain", [](RESPONSE_CALLBACK_ARGS) -> std::string { - if(access_token.size()) + if(gAccessToken.size()) { std::string token = getUrlArg(request.argument, "token"); - if(token != access_token) + if(token != gAccessToken) { response.status_code = 403; return "Forbidden\n"; @@ -199,9 +196,9 @@ int main(int argc, char *argv[]) } std::string type = getUrlArg(request.argument, "type"); if(type == "form") - fileWrite(pref_path, getFormData(request.postdata), true); + fileWrite(gPrefPath, getFormData(request.postdata), true); else if(type == "direct") - fileWrite(pref_path, request.postdata, true); + fileWrite(gPrefPath, request.postdata, true); else { response.status_code = 501; @@ -209,9 +206,8 @@ int main(int argc, char *argv[]) } readConf(); - if(!update_ruleset_on_request) - refreshRulesets(rulesets, ruleset_content_array); - generateBase(); + if(!gUpdateRulesetOnRequest) + refreshRulesets(gCustomRulesets, gRulesetContent); return "done\n"; }); @@ -233,7 +229,7 @@ int main(int argc, char *argv[]) append_response("GET", "/convert", "text/plain;charset=utf-8", getConvertedRuleset); - if(!api_mode) + if(!gAPIMode) { append_response("GET", "/get", "text/plain;charset=utf-8", [](RESPONSE_CALLBACK_ARGS) -> std::string { @@ -249,10 +245,10 @@ int main(int argc, char *argv[]) std::string env_port = GetEnv("PORT"); if(env_port.size()) - listen_port = to_int(env_port, listen_port); - listener_args args = {listen_address, listen_port, max_pending_connections, max_concurrent_threads}; + gListenPort = to_int(env_port, gListenPort); + listener_args args = {gListenAddress, gListenPort, gMaxPendingConns, gMaxConcurThreads}; //std::cout<<"Serving HTTP @ http://"< fetchFileAsync(const std::string &path, const std::string &proxy, int cache_ttl, bool async) diff --git a/src/nodemanip.cpp b/src/nodemanip.cpp index b2c327e..99ded5e 100644 --- a/src/nodemanip.cpp +++ b/src/nodemanip.cpp @@ -12,7 +12,7 @@ std::string override_conf_port; bool ss_libev, ssr_libev; -extern int cache_subscription; +extern int gCacheSubscription; void copyNodes(std::vector &source, std::vector &dest) { @@ -90,7 +90,7 @@ int addNodes(std::string link, std::vector &allNodes, int groupID, con writeLog(LOG_TYPE_INFO, "Downloading subscription data..."); if(startsWith(link, "surge:///install-config")) //surge config link link = UrlDecode(getUrlArg(link, "url")); - strSub = webGet(link, proxy, cache_subscription, &extra_headers, &request_headers); + strSub = webGet(link, proxy, gCacheSubscription, &extra_headers, &request_headers); /* if(strSub.size() == 0) { diff --git a/src/script.cpp b/src/script.cpp index 24e3898..9f44fca 100644 --- a/src/script.cpp +++ b/src/script.cpp @@ -9,8 +9,8 @@ #include "socket.h" #include "webget.h" -extern int cache_config; -extern std::string proxy_config; +extern int gCacheConfig; +extern std::string gProxyConfig; std::string parseProxy(const std::string &source); @@ -109,7 +109,7 @@ static duk_ret_t fetch(duk_context *ctx) { std::string filepath, proxy; duktape_get_arguments_str(ctx, 1, 2, &filepath, &proxy); - std::string content = fetchFile(filepath, proxy, cache_config); + std::string content = fetchFile(filepath, proxy, gCacheConfig); duk_push_lstring(ctx, content.c_str(), content.size()); return 1; } @@ -138,7 +138,7 @@ static duk_ret_t getGeoIP(duk_context *ctx) if(address.empty()) duk_push_undefined(ctx); else - duk_push_string(ctx, fetchFile("https://api.ip.sb/geoip/" + address, parseProxy(proxy), cache_config).c_str()); + duk_push_string(ctx, fetchFile("https://api.ip.sb/geoip/" + address, parseProxy(proxy), gCacheConfig).c_str()); return 1; } diff --git a/src/subexport.cpp b/src/subexport.cpp index bece5d9..21aaadd 100644 --- a/src/subexport.cpp +++ b/src/subexport.cpp @@ -24,9 +24,9 @@ #include "yamlcpp_extra.h" #include "interfaces.h" -extern bool api_mode, surge_ssr_resolve; +extern bool gAPIMode, gSurgeResolveHostname; extern string_array ss_ciphers, ssr_ciphers; -extern size_t max_allowed_rules; +extern size_t gMaxAllowedRules; const string_array clashr_protocols = {"origin", "auth_sha1_v4", "auth_aes128_md5", "auth_aes128_sha1", "auth_chain_a", "auth_chain_b"}; const string_array clashr_obfs = {"plain", "http_simple", "http_post", "random_head", "tls1.2_ticket_auth", "tls1.2_ticket_fastauth"}; @@ -34,11 +34,11 @@ const string_array clash_ssr_ciphers = {"rc4-md5", "aes-128-ctr", "aes-192-ctr", /// rule type lists #define basic_types "DOMAIN", "DOMAIN-SUFFIX", "DOMAIN-KEYWORD", "IP-CIDR", "SRC-IP-CIDR", "GEOIP", "MATCH", "FINAL" -string_array clash_rule_type = {basic_types, "IP-CIDR6", "SRC-PORT", "DST-PORT"}; -string_array surge2_rule_type = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; -string_array surge_rule_type = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "AND", "OR", "NOT", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; -string_array quanx_rule_type = {basic_types, "USER-AGENT", "HOST", "HOST-SUFFIX", "HOST-KEYWORD"}; -string_array surfb_rule_type = {basic_types, "IP-CIDR6", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; +string_array ClashRuleTypes = {basic_types, "IP-CIDR6", "SRC-PORT", "DST-PORT"}; +string_array Surge2RuleTypes = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; +string_array SurgeRuleTypes = {basic_types, "IP-CIDR6", "USER-AGENT", "URL-REGEX", "AND", "OR", "NOT", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; +string_array QuanXRuleTypes = {basic_types, "USER-AGENT", "HOST", "HOST-SUFFIX", "HOST-KEYWORD"}; +string_array SurfRuleTypes = {basic_types, "IP-CIDR6", "PROCESS-NAME", "IN-PORT", "DEST-PORT", "SRC-IP"}; std::string hostnameToIPAddr(const std::string &host) { @@ -649,7 +649,7 @@ void rulesetToClash(YAML::Node &base_rule, std::vector &ruleset for(ruleset_content &x : ruleset_content_array) { - if(max_allowed_rules && total_rules > max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; rule_group = x.rule_group; retrieved_rules = x.rule_content.get(); @@ -678,7 +678,7 @@ void rulesetToClash(YAML::Node &base_rule, std::vector &ruleset std::string::size_type lineSize; while(getline(strStrm, strLine, delimiter)) { - if(max_allowed_rules && total_rules > max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; lineSize = strLine.size(); /* @@ -696,7 +696,7 @@ void rulesetToClash(YAML::Node &base_rule, std::vector &ruleset if(strLine.find("USER-AGENT") == 0 || strLine.find("URL-REGEX") == 0 || strLine.find("PROCESS-NAME") == 0 || strLine.find("AND") == 0 || strLine.find("OR") == 0) //remove unsupported types continue; */ - if(!std::any_of(clash_rule_type.begin(), clash_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(ClashRuleTypes.begin(), ClashRuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; /* if(strLine.find("IP-CIDR") == 0) @@ -737,7 +737,7 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; rule_group = x.rule_group; retrieved_rules = x.rule_content.get(); @@ -766,7 +766,7 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; lineSize = strLine.size(); if(lineSize && strLine[lineSize - 1] == '\r') @@ -776,7 +776,7 @@ std::string rulesetToClashStr(YAML::Node &base_rule, std::vector= 2 && strLine[0] == '/' && strLine[1] == '/')) //empty lines and comments are ignored continue; - if(std::none_of(clash_rule_type.begin(), clash_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(std::none_of(ClashRuleTypes.begin(), ClashRuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; strLine += "," + rule_group; if(count_least(strLine, ',', 3)) @@ -828,7 +828,7 @@ void rulesetToSurge(INIReader &base_rule, std::vector &ruleset_ for(ruleset_content &x : ruleset_content_array) { - if(max_allowed_rules && total_rules > max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; rule_group = x.rule_group; rule_path = x.rule_path; @@ -939,7 +939,7 @@ void rulesetToSurge(INIReader &base_rule, std::vector &ruleset_ std::string::size_type lineSize; while(getline(strStrm, strLine, delimiter)) { - if(max_allowed_rules && total_rules > max_allowed_rules) + if(gMaxAllowedRules && total_rules > gMaxAllowedRules) break; lineSize = strLine.size(); if(lineSize && strLine[lineSize - 1] == '\r') //remove line break @@ -955,22 +955,22 @@ void rulesetToSurge(INIReader &base_rule, std::vector &ruleset_ continue; [[fallthrough]]; case -1: - if(!std::any_of(quanx_rule_type.begin(), quanx_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(QuanXRuleTypes.begin(), QuanXRuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; break; case -3: - if(!std::any_of(surfb_rule_type.begin(), surfb_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(SurfRuleTypes.begin(), SurfRuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; break; default: if(surge_ver > 2) { - if(!std::any_of(surge_rule_type.begin(), surge_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(SurgeRuleTypes.begin(), SurgeRuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; } else { - if(!std::any_of(surge2_rule_type.begin(), surge2_rule_type.end(), [strLine](std::string type){return startsWith(strLine, type);})) + if(!std::any_of(Surge2RuleTypes.begin(), Surge2RuleTypes.end(), [strLine](std::string type){return startsWith(strLine, type);})) continue; } } @@ -1645,7 +1645,7 @@ std::string netchToSurge(std::vector &nodes, const std::string &base_c proxy += "\", local-port=" + std::to_string(local_port); if(isIPv4(hostname) || isIPv6(hostname)) proxy += ", addresses=" + hostname; - else if(surge_ssr_resolve) + else if(gSurgeResolveHostname) proxy += ", addresses=" + hostnameToIPAddr(hostname); local_port++; break; diff --git a/src/templates.cpp b/src/templates.cpp index 17962a0..52ef7fa 100644 --- a/src/templates.cpp +++ b/src/templates.cpp @@ -11,7 +11,7 @@ #include "misc.h" #include "webget.h" -extern std::string managed_config_prefix; +extern std::string gManagedConfigPrefix; namespace inja { @@ -133,7 +133,7 @@ int render_template(const std::string &content, const template_args &vars, std:: }); m_callbacks.add_callback("getLink", 1, [](inja::Arguments &args) { - return managed_config_prefix + args.at(0)->get(); + return gManagedConfigPrefix + args.at(0)->get(); }); m_callbacks.add_callback("startsWith", 2, [](inja::Arguments &args) { diff --git a/src/webget.cpp b/src/webget.cpp index 89368fa..36db3bd 100644 --- a/src/webget.cpp +++ b/src/webget.cpp @@ -16,13 +16,13 @@ #endif // _stat #endif // _WIN32 -extern bool print_debug_info, serve_cache_on_fetch_fail; -extern int global_log_level; +extern bool gPrintDbgInfo, gServeCacheOnFetchFail; +extern int gLogLevel; typedef std::lock_guard guarded_mutex; std::mutex cache_rw_lock; -long max_allowed_download_size = 1048576L; +long gMaxAllowedDownloadSize = 1048576L; //std::string user_agent_str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36"; std::string user_agent_str = "subconverter/" VERSION " cURL/" LIBCURL_VERSION; @@ -60,7 +60,7 @@ static int dummy_writer(char *data, size_t size, size_t nmemb, void *writerData) return size * nmemb; } -static int size_checker(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow) +static int size_checker(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow) { if(clientp) { @@ -77,7 +77,7 @@ static int size_checker(void *clientp, double dltotal, double dlnow, double ulto static inline void curl_set_common_options(CURL *curl_handle, const char *url, curl_progress_data *data) { curl_easy_setopt(curl_handle, CURLOPT_URL, url); - curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, global_log_level == LOG_LEVEL_VERBOSE ? 1L : 0L); + curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, gLogLevel == LOG_LEVEL_VERBOSE ? 1L : 0L); curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 0L); curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1L); curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1L); @@ -117,7 +117,8 @@ static int curlGet(const FetchArgument &argument, FetchResult &result) else curl_easy_setopt(curl_handle, CURLOPT_PROXY, argument.proxy.data()); } - curl_progress_data limit = {max_allowed_download_size}; + curl_progress_data limit; + limit.size_limit = gMaxAllowedDownloadSize; curl_set_common_options(curl_handle, new_url.data(), &limit); if(argument.request_headers) @@ -234,7 +235,7 @@ std::string webGet(const std::string &url, const std::string &proxy, unsigned in } else { - if(fileExist(path) && serve_cache_on_fetch_fail) // failed, check if cache exist + if(fileExist(path) && gServeCacheOnFetchFail) // failed, check if cache exist { writeLog(0, "Fetch failed. Serving cached content."); // cache exist, serving cache guarded_mutex guard(cache_rw_lock);