mirror of
https://github.com/kenzok8/openwrt-packages.git
synced 2025-10-30 07:50:37 +08:00
443 lines
14 KiB
Lua
443 lines
14 KiB
Lua
module("luci.controller.clash", package.seeall)
|
|
local fs=require"nixio.fs"
|
|
local http=require"luci.http"
|
|
local uci=require"luci.model.uci".cursor()
|
|
|
|
|
|
|
|
function index()
|
|
|
|
if not nixio.fs.access("/etc/config/clash") then
|
|
return
|
|
end
|
|
|
|
local page = entry({"admin", "services", "clash"},alias("admin", "services", "clash", "overview"), _("Clash"), 1)
|
|
page.dependent = true
|
|
page.acl_depends = {"luci-app-clash"}
|
|
|
|
entry({"admin", "services", "clash", "overview"},cbi("clash/overview"),_("Overview"), 10).leaf = true
|
|
entry({"admin", "services", "clash", "client"},cbi("clash/client/client"),_("Client"), 20).leaf = true
|
|
|
|
entry({"admin", "services", "clash", "config"}, firstchild(),_("Config"), 25)
|
|
entry({"admin", "services", "clash", "config", "import"},cbi("clash/config/import"),_("Import Config"), 25).leaf = true
|
|
entry({"admin", "services", "clash", "config", "config"},cbi("clash/config/config"),_("Select Config"), 30).leaf = true
|
|
|
|
entry({"admin", "services", "clash", "config", "create"},cbi("clash/config/create"),_("Create Config"), 35).leaf = true
|
|
entry({"admin", "services", "clash", "proxyprovider"},cbi("clash/config/proxy_provider"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "servers"},cbi("clash/config/servers-config"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "ruleprovider"},cbi("clash/config/rule_provider"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "rules"},cbi("clash/config/rules"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "pgroups"},cbi("clash/config/groups"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "rulemanager"},cbi("clash/config/ruleprovider_manager"), nil).leaf = true
|
|
|
|
|
|
entry({"admin", "services", "clash", "settings"}, firstchild(),_("Settings"), 40)
|
|
entry({"admin", "services", "clash", "settings", "port"},cbi("clash/dns/port"),_("Proxy Ports"), 60).leaf = true
|
|
entry({"admin", "services", "clash", "settings", "geoip"},cbi("clash/geoip/geoip"),_("Update GeoIP"), 80).leaf = true
|
|
entry({"admin", "services", "clash", "settings", "grules"},cbi("clash/game/game-settings"),_("Game Rules"), 91).dependent = false
|
|
entry({"admin", "services", "clash", "g-rules"},cbi("clash/game/game-rule"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "settings", "other"},cbi("clash/other"),_("Other Settings"), 92).leaf = true
|
|
entry({"admin", "services", "clash", "ip-rules"},cbi("clash/config/ip-rules"), nil).leaf = true
|
|
entry({"admin", "services", "clash", "settings", "dns"},firstchild(),_("DNS Settings"), 65)
|
|
entry({"admin", "services", "clash", "settings", "dns", "dns"},cbi("clash/dns/dns"),_("Clash DNS"), 70).leaf = true
|
|
entry({"admin", "services", "clash", "settings", "dns", "advance"},cbi("clash/dns/advance"),_("Advance DNS"), 75).leaf = true
|
|
|
|
|
|
|
|
entry({"admin", "services", "clash", "update"},cbi("clash/update/update"),_("Update"), 45).leaf = true
|
|
entry({"admin", "services", "clash", "log"},cbi("clash/logs/log"),_("Log"), 50).leaf = true
|
|
|
|
|
|
entry({"admin","services","clash","check_status"},call("check_status")).leaf=true
|
|
entry({"admin", "services", "clash", "ping"}, call("act_ping")).leaf=true
|
|
entry({"admin", "services", "clash", "readlog"},call("action_read")).leaf=true
|
|
entry({"admin","services","clash", "status"},call("action_status")).leaf=true
|
|
entry({"admin", "services", "clash", "check"}, call("check_update_log")).leaf=true
|
|
entry({"admin", "services", "clash", "doupdate"}, call("do_update")).leaf=true
|
|
entry({"admin", "services", "clash", "start"}, call("do_start")).leaf=true
|
|
entry({"admin", "services", "clash", "stop"}, call("do_stop")).leaf=true
|
|
entry({"admin", "services", "clash", "reload"}, call("do_reload")).leaf=true
|
|
entry({"admin", "services", "clash", "geo"}, call("geoip_check")).leaf=true
|
|
entry({"admin", "services", "clash", "geoipupdate"}, call("geoip_update")).leaf=true
|
|
entry({"admin", "services", "clash", "check_geoip"}, call("check_geoip_log")).leaf=true
|
|
entry({"admin", "services", "clash", "corelog"},call("down_check")).leaf=true
|
|
entry({"admin", "services", "clash", "logstatus"},call("logstatus_check")).leaf=true
|
|
entry({"admin", "services", "clash", "conf"},call("action_conf")).leaf=true
|
|
entry({"admin", "services", "clash", "update_config"},call("action_update")).leaf=true
|
|
entry({"admin", "services", "clash", "game_rule"},call("action_update_rule")).leaf=true
|
|
entry({"admin", "services", "clash", "ruleproviders"},call("action_update_rule_providers")).leaf=true
|
|
entry({"admin", "services", "clash", "ping_check"},call("action_ping_status")).leaf=true
|
|
|
|
end
|
|
|
|
local fss = require "luci.clash"
|
|
|
|
local function download_rule_provider()
|
|
local filename = luci.http.formvalue("filename")
|
|
local status = luci.sys.call(string.format('/usr/share/clash/create/clash_rule_provider.sh "%s" >/dev/null 2>&1',filename))
|
|
return status
|
|
end
|
|
|
|
|
|
function action_update_rule_providers()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
rulep = download_rule_provider();
|
|
})
|
|
end
|
|
|
|
|
|
local function uhttp_port()
|
|
local uhttp_port = luci.sys.exec("uci get uhttpd.main.listen_http |awk -F ':' '{print $NF}'")
|
|
if uhttp_port ~= "80" then
|
|
return ":" .. uhttp_port
|
|
end
|
|
end
|
|
|
|
local function download_rule()
|
|
local filename = luci.http.formvalue("filename")
|
|
local rule_file_dir="/usr/share/clash/rules/g_rules/" .. filename
|
|
luci.sys.call(string.format('sh /usr/share/clash/clash_game_rule.sh "%s" >/dev/null 2>&1',filename))
|
|
if not fss.isfile(rule_file_dir) then
|
|
return "0"
|
|
else
|
|
return "1"
|
|
end
|
|
end
|
|
|
|
function action_update_rule()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
game_rule = download_rule()
|
|
})
|
|
end
|
|
|
|
function action_update()
|
|
luci.sys.exec("kill $(pgrep /usr/share/clash/update.sh) ; (bash /usr/share/clash/update.sh >/usr/share/clash/clash.txt 2>&1) &")
|
|
end
|
|
|
|
|
|
local function in_use()
|
|
return luci.sys.exec("uci get clash.config.config_type")
|
|
end
|
|
|
|
|
|
local function conf_path()
|
|
if nixio.fs.access(string.sub(luci.sys.exec("uci get clash.config.use_config"), 1, -2)) then
|
|
return fss.basename(string.sub(luci.sys.exec("uci get clash.config.use_config"), 1, -2))
|
|
else
|
|
return ""
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function typeconf()
|
|
return luci.sys.exec("uci get clash.config.config_type")
|
|
end
|
|
|
|
|
|
function action_conf()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
conf_path = conf_path(),
|
|
typeconf = typeconf()
|
|
|
|
})
|
|
end
|
|
|
|
|
|
local function dash_port()
|
|
return luci.sys.exec("uci get clash.config.dash_port 2>/dev/null")
|
|
end
|
|
local function dash_pass()
|
|
return luci.sys.exec("uci get clash.config.dash_pass 2>/dev/null")
|
|
end
|
|
|
|
local function is_running()
|
|
return luci.sys.call("pidof clash >/dev/null") == 0
|
|
end
|
|
|
|
local function is_web()
|
|
return luci.sys.call("pidof clash >/dev/null") == 0
|
|
end
|
|
|
|
local function localip()
|
|
return luci.sys.exec("uci get network.lan.ipaddr")
|
|
end
|
|
|
|
local function check_version()
|
|
return luci.sys.exec("sh /usr/share/clash/check_luci_version.sh")
|
|
end
|
|
|
|
local function check_core()
|
|
return luci.sys.exec("sh /usr/share/clash/check_core_version.sh")
|
|
end
|
|
|
|
|
|
local function check_clashtun_core()
|
|
return luci.sys.exec("sh /usr/share/clash/check_clashtun_core_version.sh")
|
|
end
|
|
|
|
local function current_version()
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/luci_version")
|
|
end
|
|
|
|
local function new_version()
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/new_luci_version")
|
|
end
|
|
|
|
local function new_core_version()
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/new_core_version")
|
|
end
|
|
|
|
|
|
local function new_clashtun_core_version()
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/new_clashtun_core_version")
|
|
end
|
|
|
|
local function check_dtun_core()
|
|
return luci.sys.call(string.format("sh /usr/share/clash/check_dtun_core_version.sh"))
|
|
end
|
|
|
|
local function new_dtun_core()
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/new_clashdtun_core_version")
|
|
end
|
|
|
|
local function e_mode()
|
|
return luci.sys.exec("egrep '^ {0,}enhanced-mode' /etc/clash/config.yaml |grep enhanced-mode: |awk -F ': ' '{print $2}'")
|
|
end
|
|
|
|
|
|
local function clash_core()
|
|
if nixio.fs.access("/etc/clash/clash") then
|
|
local core=luci.sys.exec("/etc/clash/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
if core ~= "" then
|
|
return luci.sys.exec("/etc/clash/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
else
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/core_version")
|
|
end
|
|
else
|
|
return "0"
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
local function clashtun_core()
|
|
if nixio.fs.access("/etc/clash/clashtun/clash") then
|
|
local tun=luci.sys.exec("/etc/clash/clashtun/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
if tun ~= "" then
|
|
return luci.sys.exec("/etc/clash/clashtun/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
else
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/tun_version")
|
|
end
|
|
else
|
|
return "0"
|
|
end
|
|
end
|
|
|
|
|
|
local function dtun_core()
|
|
if nixio.fs.access("/etc/clash/dtun/clash") then
|
|
local tun=luci.sys.exec("/etc/clash/dtun/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
if tun ~= "" then
|
|
return luci.sys.exec("/etc/clash/dtun/clash -v 2>/dev/null |awk -F ' ' '{print $2}'")
|
|
else
|
|
return luci.sys.exec("sed -n 1p /usr/share/clash/dtun_core_version")
|
|
end
|
|
else
|
|
return "0"
|
|
end
|
|
end
|
|
|
|
|
|
local function readlog()
|
|
return luci.sys.exec("sed -n '$p' /usr/share/clash/clash_real.txt 2>/dev/null")
|
|
end
|
|
|
|
local function geo_data()
|
|
return os.date("%Y-%m-%d %H:%M:%S",fss.mtime("/etc/clash/Country.mmdb"))
|
|
end
|
|
|
|
local function downcheck()
|
|
if nixio.fs.access("/var/run/core_update_error") then
|
|
return "0"
|
|
elseif nixio.fs.access("/var/run/core_update") then
|
|
return "1"
|
|
elseif nixio.fs.access("/usr/share/clash/core_down_complete") then
|
|
return "2"
|
|
end
|
|
end
|
|
|
|
function action_read()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
readlog = readlog();
|
|
})
|
|
end
|
|
|
|
function down_check()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
downcheck = downcheck();
|
|
})
|
|
end
|
|
|
|
local function geoipcheck()
|
|
if nixio.fs.access("/var/run/geoip_update_error") then
|
|
return "0"
|
|
elseif nixio.fs.access("/var/run/geoip_update") then
|
|
return "1"
|
|
elseif nixio.fs.access("/var/run/geoip_down_complete") then
|
|
return "2"
|
|
end
|
|
end
|
|
|
|
function geoip_check()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
geoipcheck = geoipcheck();
|
|
})
|
|
end
|
|
|
|
|
|
|
|
|
|
function check_status()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
check_version = check_version(),
|
|
check_core = check_core(),
|
|
current_version = current_version(),
|
|
new_version = new_version(),
|
|
clash_core = clash_core(),
|
|
check_dtun_core = check_dtun_core(),
|
|
new_dtun_core = new_dtun_core(),
|
|
clashtun_core = clashtun_core(),
|
|
dtun_core = dtun_core(),
|
|
new_core_version = new_core_version(),
|
|
new_clashtun_core_version =new_clashtun_core_version(),
|
|
check_clashtun_core = check_clashtun_core(),
|
|
conf_path = conf_path(),
|
|
typeconf = typeconf()
|
|
})
|
|
end
|
|
function action_status()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
web = is_web(),
|
|
clash = is_running(),
|
|
localip = localip(),
|
|
dash_port = dash_port(),
|
|
current_version = current_version(),
|
|
new_dtun_core = new_dtun_core(),
|
|
new_core_version = new_core_version(),
|
|
new_clashtun_core_version =new_clashtun_core_version(),
|
|
new_version = new_version(),
|
|
clash_core = clash_core(),
|
|
dtun_core = dtun_core(),
|
|
dash_pass = dash_pass(),
|
|
clashtun_core = clashtun_core(),
|
|
e_mode = e_mode(),
|
|
in_use = in_use(),
|
|
conf_path = conf_path(),
|
|
uhttp_port = uhttp_port(),
|
|
typeconf = typeconf()
|
|
})
|
|
end
|
|
|
|
function action_ping_status()
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json({
|
|
ping_enable = ping_enable()
|
|
})
|
|
end
|
|
|
|
function act_ping()
|
|
local e={}
|
|
e.index=luci.http.formvalue("index")
|
|
e.ping=luci.sys.exec("ping -c 1 -W 1 -w 5 %q 2>&1 | grep -o 'time=[0-9]*.[0-9]' | awk -F '=' '{print$2}'"%luci.http.formvalue("domain"))
|
|
luci.http.prepare_content("application/json")
|
|
luci.http.write_json(e)
|
|
end
|
|
|
|
|
|
function geoip_update()
|
|
fs.writefile("/var/run/geoiplog","0")
|
|
luci.sys.exec("(rm /var/run/geoip_update_error ; touch /var/run/geoip_update ; sh /usr/share/clash/geoip.sh >/tmp/geoip_update.txt 2>&1 || touch /var/run/geoip_update_error ;rm /var/run/geoip_update) &")
|
|
end
|
|
|
|
|
|
function do_update()
|
|
fs.writefile("/var/run/clashlog","0")
|
|
luci.sys.exec("(rm /var/run/core_update_error ; touch /var/run/core_update ; sh /usr/share/clash/core_download.sh >/tmp/clash_update.txt 2>&1 || touch /var/run/core_update_error ;rm /var/run/core_update) &")
|
|
end
|
|
|
|
function do_start()
|
|
luci.sys.exec('uci set clash.config.enable="1" && uci commit clash')
|
|
luci.sys.exec("/etc/init.d/clash restart 2>&1 &")
|
|
end
|
|
|
|
function do_stop()
|
|
luci.sys.exec('uci set clash.config.enable="0" && uci commit clash')
|
|
luci.sys.exec("/etc/init.d/clash stop 2>&1 &")
|
|
end
|
|
|
|
function do_reload()
|
|
if luci.sys.call("pidof clash >/dev/null") == 0 then
|
|
luci.sys.exec("/etc/init.d/clash reload 2>&1 &")
|
|
end
|
|
end
|
|
|
|
function check_update_log()
|
|
luci.http.prepare_content("text/plain; charset=utf-8")
|
|
local fdp=tonumber(fs.readfile("/var/run/clashlog")) or 0
|
|
local f=io.open("/tmp/clash_update.txt", "r+")
|
|
f:seek("set",fdp)
|
|
local a=f:read(2048000) or ""
|
|
fdp=f:seek()
|
|
fs.writefile("/var/run/clashlog",tostring(fdp))
|
|
f:close()
|
|
if fs.access("/var/run/core_update") then
|
|
luci.http.write(a)
|
|
else
|
|
luci.http.write(a.."\0")
|
|
end
|
|
end
|
|
|
|
function check_geoip_log()
|
|
luci.http.prepare_content("text/plain; charset=utf-8")
|
|
local fdp=tonumber(fs.readfile("/var/run/geoiplog")) or 0
|
|
local f=io.open("/tmp/geoip_update.txt", "r+")
|
|
f:seek("set",fdp)
|
|
local a=f:read(2048000) or ""
|
|
fdp=f:seek()
|
|
fs.writefile("/var/run/geoiplog",tostring(fdp))
|
|
f:close()
|
|
if fs.access("/var/run/geoip_update") then
|
|
luci.http.write(a)
|
|
else
|
|
luci.http.write(a.."\0")
|
|
end
|
|
end
|
|
|
|
|
|
function logstatus_check()
|
|
luci.http.prepare_content("text/plain; charset=utf-8")
|
|
local fdp=tonumber(fs.readfile("/usr/share/clash/logstatus_check")) or 0
|
|
local f=io.open("/usr/share/clash/clash.txt", "r+")
|
|
f:seek("set",fdp)
|
|
local a=f:read(2048000) or ""
|
|
fdp=f:seek()
|
|
fs.writefile("/usr/share/clash/logstatus_check",tostring(fdp))
|
|
f:close()
|
|
if fs.access("/var/run/logstatus") then
|
|
luci.http.write(a)
|
|
else
|
|
luci.http.write(a.."\0")
|
|
end
|
|
end
|
|
|