mirror of
https://github.com/JamesonHuang/OpenWrt_Luci_Lua.git
synced 2024-11-24 06:10:11 +00:00
1599 lines
53 KiB
Lua
1599 lines
53 KiB
Lua
module("luci.controller.api.xqsystem", package.seeall)
|
|
|
|
function index()
|
|
local page = node("api","xqsystem")
|
|
page.target = firstchild()
|
|
page.title = ("")
|
|
page.order = 100
|
|
page.sysauth = "admin"
|
|
page.sysauth_authenticator = "jsonauth"
|
|
page.index = true
|
|
entry({"api", "xqsystem"}, firstchild(), (""), 100)
|
|
entry({"api", "xqsystem", "login"}, call("actionLogin"), (""), 109, 0x08)
|
|
entry({"api", "xqsystem", "init_info"}, call("getInitInfo"), (""), 101, 0x09)
|
|
entry({"api", "xqsystem", "fac_info"}, call("getFacInfo"), (""), 101, 0x09)
|
|
entry({"api", "xqsystem", "token"}, call("getToken"), (""), 103, 0x08)
|
|
entry({"api", "xqsystem", "set_inited"}, call("setInited"), (""), 103, 0x08)
|
|
entry({"api", "xqsystem", "system_info"}, call("getSysInfo"), (""), 104, 0x01)
|
|
entry({"api", "xqsystem", "set_name_password"}, call("setPassword"), (""), 105)
|
|
entry({"api", "xqsystem", "check_rom_update"}, call("checkRomUpdate"), (""), 106)
|
|
entry({"api", "xqsystem", "lan_wan"}, call("getLanWanSta"), (""), 106)
|
|
-- for Web only
|
|
entry({"api", "xqsystem", "flash_rom"}, call("flashRom"), (""), 108)
|
|
|
|
-- deprecated
|
|
entry({"api", "xqsystem", "router_name"}, call("getRouterName"), (""), 110)
|
|
|
|
entry({"api", "xqsystem", "device_list"}, call("getDeviceList"), (""), 112)
|
|
entry({"api", "xqsystem", "set_device_nickname"}, call("setDeviceNickName"), (""), 113)
|
|
entry({"api", "xqsystem", "internet_connect"}, call("isInternetConnect"), (""), 114)
|
|
entry({"api", "xqsystem", "upload_rom"}, call("uploadRom"), (""), 115)
|
|
entry({"api", "xqsystem", "get_languages"}, call("getLangList"), (""), 118, 0x01)
|
|
entry({"api", "xqsystem", "get_main_language"}, call("getMainLang"), (""), 119, 0x01)
|
|
entry({"api", "xqsystem", "set_language"}, call("setLang"), (""), 120)
|
|
|
|
entry({"api", "xqsystem", "upload_log"}, call("uploadLogFile"), (""), 124)
|
|
entry({"api", "xqsystem", "backup_config"}, call("uploadConfigFile"), (""), 125)
|
|
entry({"api", "xqsystem", "config_recovery"}, call("configRecovery"), (""), 126)
|
|
entry({"api", "xqsystem", "router_init"}, call("setRouter"), (""), 126, 0x08)
|
|
entry({"api", "xqsystem", "information"}, call("getAllInfo"), (""), 127)
|
|
entry({"api", "xqsystem", "status"}, call("getStatusInfo"), (""), 128)
|
|
entry({"api", "xqsystem", "count"}, call("getConDevCount"), (""), 129)
|
|
entry({"api", "xqsystem", "reboot"}, call("reboot"), (""), 130)
|
|
entry({"api", "xqsystem", "reset"}, call("reset"), (""), 131)
|
|
entry({"api", "xqsystem", "passport_bind_info"}, call("getPassportBindInfo"), (""), 132, 0x01)
|
|
entry({"api", "xqsystem", "set_passport_bound"}, call("setPassportBound"), (""), 133, 0x08)
|
|
entry({"api", "xqsystem", "get_sys_avg_load"}, call("getSysAvgLoad"), (""), 134)
|
|
entry({"api", "xqsystem", "set_mac_filter"}, call("setMacFilter"), (""), 135)
|
|
entry({"api", "xqsystem", "renew_token"}, call("renewToken"), (""), 136)
|
|
entry({"api", "xqsystem", "remove_passport_info"}, call("removePassportBindInfo"), (""), 137)
|
|
entry({"api", "xqsystem", "upgrade_rom"}, call("upgradeRom"), (""), 138)
|
|
entry({"api", "xqsystem", "wps"}, call("openWps"), (""), 139, 0x08)
|
|
entry({"api", "xqsystem", "wps_status"}, call("getWpsStatus"), (""), 140)
|
|
entry({"api", "xqsystem", "stop_nginx"}, call("stopNginx"), (""), 141)
|
|
entry({"api", "xqsystem", "check_router_name_pending"}, call("checkRouterNamePending"), (""), 142)
|
|
entry({"api", "xqsystem", "clear_router_name_pending"}, call("clearRouterNamePending"), (""), 143)
|
|
entry({"api", "xqsystem", "web_url"}, call("redirectUrl"), (""), 144)
|
|
entry({"api", "xqsystem", "start_nginx"}, call("startNginx"), (""), 145)
|
|
entry({"api", "xqsystem", "nginx"}, call("nginxCacheStatus"), (""), 146)
|
|
entry({"api", "xqsystem", "flash_status"}, call("flashStatus"), (""), 147, 0x01)
|
|
entry({"api", "xqsystem", "upgrade_status"}, call("upgradeStatus"), (""), 148, 0x0d)
|
|
entry({"api", "xqsystem", "create_sandbox"}, call("createSandbox"), (""), 149)
|
|
entry({"api", "xqsystem", "is_sandbox_created"}, call("isSandboxCreated"), (""), 150)
|
|
entry({"api", "xqsystem", "mount_things"}, call("mountThings"), (""), 151)
|
|
entry({"api", "xqsystem", "umount_things"}, call("umountThings"), (""), 152)
|
|
entry({"api", "xqsystem", "are_things_mounted"}, call("areThingsMounted"), (""), 153)
|
|
entry({"api", "xqsystem", "start_dropbear"}, call("startDropbear"), (""), 154)
|
|
entry({"api", "xqsystem", "stop_dropbear"}, call("stopDropbear"), (""), 155)
|
|
entry({"api", "xqsystem", "is_dropbear_started"}, call("isDropbearStarted"), (""), 156)
|
|
entry({"api", "xqsystem", "main_status_for_app"}, call("mainStatusForApp"), (""), 157)
|
|
entry({"api", "xqsystem", "mode"}, call("getMacfilterMode"), (""), 158)
|
|
entry({"api", "xqsystem", "set_mode"}, call("setMacfilterMode"), (""), 159)
|
|
entry({"api", "xqsystem", "cancel"}, call("cancelUpgrade"), (""), 160, 0x0d)
|
|
entry({"api", "xqsystem", "shutdown"}, call("shutdown"), (""), 161)
|
|
entry({"api", "xqsystem", "upnp"}, call("upnpList"), (""), 162)
|
|
entry({"api", "xqsystem", "upnp_switch"}, call("upnpSwitch"), (""), 163)
|
|
entry({"api", "xqsystem", "app_limit"}, call("appLimit"), (""), 164)
|
|
entry({"api", "xqsystem", "app_limit_switch"}, call("appLimitSwitch"), (""), 165)
|
|
entry({"api", "xqsystem", "set_app_limit"}, call("setAppLimit"), (""), 166)
|
|
entry({"api", "xqsystem", "vpn"}, call("vpnInfo"), (""), 167)
|
|
entry({"api", "xqsystem", "vpn_status"}, call("vpnStatus"), (""), 168)
|
|
entry({"api", "xqsystem", "vpn_switch"}, call("vpnSwitch"), (""), 169)
|
|
entry({"api", "xqsystem", "set_vpn"}, call("setVpn"), (""), 170)
|
|
entry({"api", "xqsystem", "device_mac"}, call("getDeviceMacaddr"), (""), 171, 0x01)
|
|
entry({"api", "xqsystem", "wps_cancel"}, call("stopWps"), (""), 172)
|
|
entry({"api", "xqsystem", "detection_ts"}, call("getDetectionTimestamp"), (""), 173)
|
|
entry({"api", "xqsystem", "wifi_log"}, call("getWifiLog"), (""), 174)
|
|
entry({"api", "xqsystem", "sys_recovery"}, call("sysRecovery"), (""), 175)
|
|
entry({"api", "xqsystem", "smart_shutdown"}, call("smartShutdown"), (""), 177)
|
|
|
|
-- include zigbee dongle device only
|
|
entry({"api", "xqsystem", "device_list_zigbee"}, call("getDeviceListZigbee"), (""), 176)
|
|
-- Noflushd
|
|
entry({"api", "xqsystem", "noflushd"}, call("getNofStatus"), (""), 178)
|
|
entry({"api", "xqsystem", "nof_switch"}, call("nofSwitch"), (""), 179)
|
|
entry({"api", "xqsystem", "pred_status"}, call("predownloadInfo"), (""), 180)
|
|
entry({"api", "xqsystem", "pred_switch"}, call("predownloadSwitch"), (""), 181)
|
|
end
|
|
|
|
local LuciHttp = require("luci.http")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local XQErrorUtil = require("xiaoqiang.util.XQErrorUtil")
|
|
|
|
function getInitInfo()
|
|
local XQCountryCode = require("xiaoqiang.XQCountryCode")
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local monitor = XQLanWanUtil.getWanMonitorStat()
|
|
local connect = 0
|
|
if monitor.WANLINKSTAT == "UP" then
|
|
connect = 1
|
|
end
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["connect"] = connect
|
|
result["inited"] = XQSysUtil.getInitInfo() and 1 or 0
|
|
result["bound"] = XQSysUtil.getPassportBindInfo() and 1 or 0
|
|
result["id"] = XQNetUtil.getSN()
|
|
result["routerId"] = XQNetUtil.getDeviceId()
|
|
result["hardware"] = XQSysUtil.getHardware()
|
|
result["romversion"] = XQSysUtil.getRomVersion()
|
|
result["modules"] = XQSysUtil.getModulesList()
|
|
result["language"] = XQSysUtil.getLang()
|
|
result["countrycode"] = XQCountryCode.getCurrentCountryCode()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getFacInfo()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
LuciHttp.write_json(XQSysUtil.facInfo())
|
|
end
|
|
|
|
function actionLogin()
|
|
local result = {}
|
|
local init = tonumber(LuciHttp.formvalue("init"))
|
|
result["code"] = 0
|
|
if init and init == 1 then
|
|
result["url"] = luci.dispatcher.build_url("web", "init", "guide")
|
|
else
|
|
result["url"] = luci.dispatcher.build_url("web", "home")
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getToken()
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local sid = LuciHttp.formvalue("sid")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["token"] = luci.dispatcher.context.urltoken.stok
|
|
result["id"] = XQNetUtil.getSN()
|
|
result["name"] = XQSysUtil.getRouterName()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function renewToken()
|
|
local sauth = require "luci.sauth"
|
|
local result = {}
|
|
local session = sauth.available()
|
|
if session then
|
|
result["token"] = session.token
|
|
else
|
|
local token = luci.sys.uniqueid(16)
|
|
sauth.write(token, {
|
|
user="admin",
|
|
token=token,
|
|
ltype="1",
|
|
secret=luci.sys.uniqueid(16)
|
|
})
|
|
result["token"] = token
|
|
end
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setInited()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local client = LuciHttp.formvalue("client")
|
|
if client == "ios" then
|
|
XQLog.check(0, XQLog.KEY_GEL_INIT_IOS, 1)
|
|
elseif client == "android" then
|
|
XQLog.check(0, XQLog.KEY_GEL_INIT_ANDROID, 1)
|
|
elseif client == "other" then
|
|
XQLog.check(0, XQLog.KEY_GEL_INIT_OTHER, 1)
|
|
end
|
|
local result = {}
|
|
local inited = XQSysUtil.setInited()
|
|
if not inited then
|
|
result["code"] = 1501
|
|
result["msg"] = XQErrorUtil.getErrorMessage(1501)
|
|
else
|
|
result["code"] = 0
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getLanWanSta()
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["lan"] = XQDeviceUtil.getWanLanNetworkStatistics("lan")
|
|
result["wan"] = XQDeviceUtil.getWanLanNetworkStatistics("wan")
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getPassportBindInfo()
|
|
local result = {}
|
|
local bind = XQSysUtil.getPassportBindInfo()
|
|
result["code"] = 0
|
|
if bind then
|
|
result["bound"] = 1
|
|
result["uuid"] = bind
|
|
else
|
|
result["bound"] = 0
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setPassportBound()
|
|
local uuid = LuciHttp.formvalue("uuid")
|
|
local result = {}
|
|
local inited = XQSysUtil.setPassportBound(true,uuid)
|
|
if not inited then
|
|
result["code"] = 1501
|
|
result["msg"] = XQErrorUtil.getErrorMessage(1501)
|
|
else
|
|
result["code"] = 0
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function removePassportBindInfo()
|
|
local uuid = LuciHttp.formvalue("uuid")
|
|
local result = {}
|
|
XQSysUtil.setPassportBound(false,uuid)
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getSysInfo()
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["upTime"] = XQSysUtil.getSysUptime()
|
|
result["routerName"] = XQSysUtil.getRouterName()
|
|
result["romVersion"] = XQSysUtil.getRomVersion()
|
|
result["romChannel"] = XQSysUtil.getChannel()
|
|
result["hardware"] = XQSysUtil.getHardware()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getAllInfo()
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local result = {}
|
|
local monitor = XQLanWanUtil.getWanMonitorStat()
|
|
local connect = 0
|
|
if monitor.WANLINKSTAT == "UP" then
|
|
connect = 1
|
|
end
|
|
result["connect"] = connect
|
|
result["wifi"] = XQWifiUtil.getAllWifiInfo()
|
|
result["wan"] = XQLanWanUtil.getLanWanInfo("wan")
|
|
result["lan"] = XQLanWanUtil.getLanWanInfo("lan")
|
|
result["code"] = 0
|
|
result.wifi[1].channel = XQWifiUtil.getWifiWorkChannel(1)
|
|
result.wifi[2].channel = XQWifiUtil.getWifiWorkChannel(2)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getStatusInfo()
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local result = {}
|
|
local monitor = XQLanWanUtil.getWanMonitorStat()
|
|
if monitor.WANLINKSTAT == "UP" then
|
|
result["connect"] = 1
|
|
end
|
|
if monitor.VPNLINKSTAT == "UP" then
|
|
result["vpn"] = 1
|
|
end
|
|
local wifiConCount = {}
|
|
table.insert(wifiConCount,#XQWifiUtil.getWifiConnectDeviceList(1))
|
|
table.insert(wifiConCount,#XQWifiUtil.getWifiConnectDeviceList(2))
|
|
local statList = XQDeviceUtil.getDevNetStatisticsList()
|
|
if #statList > 0 then
|
|
table.sort(statList, function(a, b) return tonumber(a.download) > tonumber(b.download) end)
|
|
end
|
|
if #statList > XQConfigs.DEVICE_STATISTICS_LIST_LIMIT then
|
|
local item = {}
|
|
item["mac"] = ""
|
|
item["ip"] = ""
|
|
for i=1,#statList - XQConfigs.DEVICE_STATISTICS_LIST_LIMIT + 1 do
|
|
local deleteElement = table.remove(statList, XQConfigs.DEVICE_STATISTICS_LIST_LIMIT)
|
|
item["onlinets"] = deleteElement.onlinets
|
|
item["activets"] = deleteElement.activets
|
|
item["upload"] = tonumber(deleteElement.upload) + tonumber(item.upload or 0)
|
|
item["upspeed"] = tonumber(deleteElement.upspeed) + tonumber(item.upspeed or 0)
|
|
item["download"] = tonumber(deleteElement.download) + tonumber(item.download or 0)
|
|
item["downspeed"] = tonumber(deleteElement.downspeed) + tonumber(item.downspeed or 0)
|
|
item["online"] = deleteElement.online
|
|
item["idle"] = deleteElement.idle
|
|
item["devname"] = "Others"
|
|
item["initail"] = deleteElement.initail
|
|
item["maxuploadspeed"] = deleteElement.maxuploadspeed
|
|
item["maxdownloadspeed"] = deleteElement.maxdownloadspeed
|
|
end
|
|
table.insert(statList,item)
|
|
end
|
|
|
|
result["lanLink"] = XQLanWanUtil.getLanLinkList()
|
|
result["count"] = XQDeviceUtil.getConnectDeviceCount()
|
|
result["upTime"] = XQSysUtil.getSysUptime()
|
|
result["wifiCount"] = wifiConCount
|
|
result["wanStatistics"] = XQDeviceUtil.getWanLanNetworkStatistics("wan")
|
|
result["devStatistics"] = statList
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getConDevCount()
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local result = {}
|
|
result["code"]= 0
|
|
result["count"] = XQDeviceUtil.getConnectDeviceCount()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function _savePassword(nonce, oldpwd, newpwd)
|
|
local XQSecureUtil = require("xiaoqiang.util.XQSecureUtil")
|
|
local code = 0
|
|
local mac = luci.dispatcher.getremotemac()
|
|
local checkNonce = XQSecureUtil.checkNonce(nonce, mac)
|
|
if checkNonce then
|
|
local check = XQSecureUtil.checkUser("admin", nonce, oldpwd)
|
|
if check then
|
|
if XQSecureUtil.saveCiphertextPwd("admin", newpwd) then
|
|
code = 0
|
|
else
|
|
code = 1553
|
|
end
|
|
else
|
|
code = 1552
|
|
end
|
|
else
|
|
code = 1582
|
|
end
|
|
return code
|
|
end
|
|
|
|
function setPassword()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local result = {}
|
|
local code
|
|
local nonce = LuciHttp.formvalue("nonce")
|
|
local oldPassword = LuciHttp.formvalue("oldPwd")
|
|
local newPassword = LuciHttp.formvalue("newPwd")
|
|
if XQFunction.isStrNil(oldPassword) or XQFunction.isStrNil(newPassword) then
|
|
code = 1502
|
|
else
|
|
if nonce then
|
|
code = _savePassword(nonce, oldPassword, newPassword)
|
|
else
|
|
local XQSecureUtil = require("xiaoqiang.util.XQSecureUtil")
|
|
local check = XQSysUtil.checkSysPassword(oldPassword) or XQSecureUtil.checkPlaintextPwd("admin", oldPassword)
|
|
if check then
|
|
local setPwd = XQSysUtil.setSysPassword(newPassword)
|
|
if setPwd then
|
|
code = 0
|
|
else
|
|
code = 1553
|
|
end
|
|
else
|
|
code = 1552
|
|
end
|
|
end
|
|
end
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function checkRomUpdate()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local result = {}
|
|
local status = {status = 0, percent = 0}
|
|
local code = 0
|
|
local check = XQNetUtil.checkUpgrade()
|
|
local upgrade = XQSysUtil.checkUpgradeStatus()
|
|
if check == false then
|
|
code = 1504
|
|
else
|
|
code = 0
|
|
result = check
|
|
end
|
|
result["status"] = status
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
-- 直接执行升级脚本
|
|
function upgradeRom()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local XQSecureUtil = require("xiaoqiang.util.XQSecureUtil")
|
|
|
|
local url = LuciHttp.formvalue("url")
|
|
local filesize = tostring(LuciHttp.formvalue("filesize"))
|
|
local hash = tostring(LuciHttp.formvalue("hash"))
|
|
|
|
local result = {}
|
|
local code = 0
|
|
if XQSysUtil.checkBeenUpgraded() then
|
|
code = 1577
|
|
elseif XQSysUtil.isUpgrading() then
|
|
code = 1568
|
|
elseif not XQSecureUtil.cmdSafeCheck(url) or not XQSecureUtil.cmdSafeCheck(filesize) or not XQSecureUtil.cmdSafeCheck(hash) then
|
|
code = 1523
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
if code == 0 then
|
|
XQFunction.sysLock()
|
|
if url and filesize and hash then
|
|
XQFunction.forkExec(string.format("/usr/sbin/crontab_rom.sh '%s' '%s' '%s'", url, hash, filesize))
|
|
else
|
|
XQFunction.forkExec("/usr/sbin/crontab_rom.sh")
|
|
end
|
|
end
|
|
end
|
|
|
|
function cancelUpgrade()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local code = 0
|
|
local result = {}
|
|
local succeed = XQSysUtil.cancelUpgrade()
|
|
if not succeed then
|
|
code = 1579
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function flashRom()
|
|
local LuciFs = require("luci.fs")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQPreference = require("xiaoqiang.XQPreference")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local LuciUtil = require("luci.util")
|
|
local custom = tonumber(LuciHttp.formvalue("custom") or 0)
|
|
local result = {}
|
|
local code = 0
|
|
local filePath = XQConfigs.ROM_CACHE_FILEPATH
|
|
if custom == 1 then
|
|
filePath = XQConfigs.CROM_DISK_CACHE_FILEPATH
|
|
end
|
|
local flashStatus = XQSysUtil.getFlashStatus()
|
|
if flashStatus == 1 then
|
|
code = 1560
|
|
elseif flashStatus == 2 then
|
|
code = 1577
|
|
elseif not LuciFs.access(filePath) then
|
|
code = 1507
|
|
elseif not XQSysUtil.verifyImage(filePath) then
|
|
code = 1554
|
|
end
|
|
XQFunction.ledFlashAlert(false)
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
if code == 0 then
|
|
LuciHttp.close()
|
|
XQFunction.sysLock()
|
|
XQFunction.forkFlashRomFile(filePath)
|
|
end
|
|
end
|
|
|
|
function flashStatus()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["status"] = XQSysUtil.getFlashStatus()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function upgradeStatus()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["status"] = XQSysUtil.checkUpgradeStatus()
|
|
if result.status == 3 then
|
|
local LuciFs = require("luci.fs")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQPreference = require("xiaoqiang.XQPreference")
|
|
local XQDownloadUtil = require("xiaoqiang.util.XQDownloadUtil")
|
|
local downloadId = XQPreference.get(XQConfigs.PREF_ROM_DOWNLOAD_ID, nil)
|
|
if downloadId then
|
|
result["percent"] = XQDownloadUtil.downloadPercent(downloadId)
|
|
else
|
|
result["percent"] = 0
|
|
end
|
|
elseif result.status == 5 then
|
|
result["percent"] = 100
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getRouterName()
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["routerName"] = XQSysUtil.getRouterName()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setRouterName()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local routerName = LuciHttp.xqformvalue("routerName")
|
|
local result = {}
|
|
local code = 0
|
|
if XQFunction.isStrNil(routerName) then
|
|
code = 1502
|
|
else
|
|
local newName = XQSysUtil.setRouterName(routerName)
|
|
if newName == false then
|
|
code = 1503
|
|
else
|
|
result["routerName"] = newName
|
|
end
|
|
end
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setRouter()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local result = {}
|
|
local code = 0
|
|
local msg = {}
|
|
local needRestartWifi = false
|
|
local nonce = LuciHttp.formvalue("nonce")
|
|
local newPwd = LuciHttp.formvalue("newPwd")
|
|
local oldPwd = LuciHttp.formvalue("oldPwd")
|
|
local wifiPwd = LuciHttp.formvalue("wifiPwd")
|
|
local wifi24Ssid = LuciHttp.formvalue("wifi24Ssid")
|
|
local wifi50Ssid = LuciHttp.formvalue("wifi50Ssid")
|
|
local wanType = LuciHttp.formvalue("wanType")
|
|
local pppoeName = LuciHttp.formvalue("pppoeName")
|
|
local pppoePwd = LuciHttp.formvalue("pppoePwd")
|
|
|
|
XQFunction.nvramSet("Router_unconfigured", "0")
|
|
XQFunction.nvramCommit()
|
|
|
|
local checkssid = XQWifiUtil.checkSSID(wifi24Ssid,28)
|
|
if not XQFunction.isStrNil(wifi24Ssid) and checkssid == 0 then
|
|
XQSysUtil.setRouterName(wifi24Ssid)
|
|
end
|
|
if not XQFunction.isStrNil(newPwd) and not XQFunction.isStrNil(oldPwd) then
|
|
if nonce then
|
|
code = _savePassword(nonce, oldPwd, newPwd)
|
|
else
|
|
local check = XQSysUtil.checkSysPassword(oldPwd)
|
|
if check then
|
|
local succeed = XQSysUtil.setSysPassword(newPwd)
|
|
if not succeed then
|
|
code = 1515
|
|
end
|
|
else
|
|
code = 1552
|
|
end
|
|
end
|
|
if code ~= 0 then
|
|
table.insert(msg,XQErrorUtil.getErrorMessage(code))
|
|
end
|
|
end
|
|
if not XQFunction.isStrNil(wanType) then
|
|
local succeed
|
|
if wanType == "pppoe" and not XQFunction.isStrNil(pppoeName) and not XQFunction.isStrNil(pppoePwd) then
|
|
succeed = XQLanWanUtil.setWanPPPoE(pppoeName,pppoePwd)
|
|
elseif wanType == "dhcp" then
|
|
succeed = XQLanWanUtil.setWanStaticOrDHCP(wanType)
|
|
end
|
|
if not succeed then
|
|
code = 1518
|
|
table.insert(msg,XQErrorUtil.getErrorMessage(code))
|
|
else
|
|
needRestartWifi = true
|
|
end
|
|
end
|
|
if not XQFunction.isStrNil(wifiPwd) and checkssid == 0 then
|
|
local succeed1 = XQWifiUtil.setWifiBasicInfo(1, wifi24Ssid, wifiPwd, "mixed-psk", nil, nil, 0)
|
|
local succeed2 = XQWifiUtil.setWifiBasicInfo(2, wifi50Ssid, wifiPwd, "mixed-psk", nil, nil, 0)
|
|
if succeed1 or succeed2 then
|
|
needRestartWifi = true
|
|
end
|
|
if not succeed1 or not succeed2 then
|
|
code = XQWifiUtil.checkWifiPasswd(wifiPwd, "mixed-psk")
|
|
table.insert(msg,XQErrorUtil.getErrorMessage(code))
|
|
end
|
|
end
|
|
if checkssid ~= 0 then
|
|
code = checkssid
|
|
end
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(1519)
|
|
result["errorDetails"] = msg
|
|
end
|
|
XQSysUtil.setSPwd()
|
|
XQSysUtil.setInited()
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
if needRestartWifi then
|
|
LuciHttp.close()
|
|
XQFunction.forkRestartWifi()
|
|
end
|
|
end
|
|
|
|
function getDeviceList()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["mac"] = luci.dispatcher.getremotemac()
|
|
result["list"] = XQDeviceUtil.getConnectDeviceList()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getDeviceListZigbee()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local XQZigbeeUtil = require("xiaoqiang.util.XQZigbeeUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["mac"] = luci.dispatcher.getremotemac()
|
|
local list = {}
|
|
-- add zigbee device
|
|
XQZigbeeUtil.append_yeelink_list(list)
|
|
result["list"] = list
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function isInternetConnect()
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local result = {}
|
|
local monitor = XQLanWanUtil.getWanMonitorStat()
|
|
local connect = 0
|
|
if monitor.WANLINKSTAT == "UP" then
|
|
connect = 1
|
|
end
|
|
result["code"] = 0
|
|
result["connect"] = connect
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setDeviceNickName()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local LuciDatatypes = require("luci.cbi.datatypes")
|
|
local result = {}
|
|
local code = 0
|
|
local mac = LuciHttp.formvalue("mac")
|
|
local nickName = LuciHttp.formvalue("name")
|
|
if XQFunction.isStrNil(mac) or XQFunction.isStrNil(nickName) then
|
|
code = 1502
|
|
-- allow none ip device to set nick name (zigbee device)
|
|
-- elseif not LuciDatatypes.macaddr(mac) then
|
|
-- code = 1508
|
|
else
|
|
XQDeviceUtil.saveDeviceName(mac,nickName)
|
|
end
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
|
|
function _prepare()
|
|
local FS = require("nixio.fs")
|
|
FS.mkdir(XQConfigs.USERDISK_UPLOAD_DIR, 777)
|
|
if not _sane() then
|
|
error("Upload Rom Exception: /userdisk/upload path is not sane!")
|
|
end
|
|
end
|
|
|
|
function _sane()
|
|
local FS = require("nixio.fs")
|
|
local LuciSys = require("luci.sys")
|
|
return LuciSys.process.info("uid")
|
|
== FS.stat(XQConfigs.USERDISK_UPLOAD_DIR, "uid")
|
|
end
|
|
|
|
function uploadRom()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local LuciSys = require("luci.sys")
|
|
local LuciFs = require("luci.fs")
|
|
|
|
local fp
|
|
local code = 0
|
|
if not _sane() then
|
|
_prepare()
|
|
end
|
|
local tmpfile = XQConfigs.USERDISK_UPLOAD_DIR..LuciSys.uniqueid(16)
|
|
local fileSize = tonumber(LuciHttp.getenv("CONTENT_LENGTH"))
|
|
local canupload = XQSysUtil.checkDiskSpace(fileSize)
|
|
LuciHttp.setfilehandler(
|
|
function(meta, chunk, eof)
|
|
if canupload then
|
|
if not fp then
|
|
if meta and meta.name == "image" then
|
|
fp = io.open(tmpfile, "w")
|
|
end
|
|
end
|
|
if chunk then
|
|
fp:write(chunk)
|
|
end
|
|
if eof then
|
|
fp:close()
|
|
if LuciFs.access(XQConfigs.CROM_DISK_CACHE_FILEPATH) then
|
|
LuciFs.unlink(XQConfigs.CROM_DISK_CACHE_FILEPATH)
|
|
end
|
|
LuciFs.rename(tmpfile, XQConfigs.CROM_DISK_CACHE_FILEPATH)
|
|
end
|
|
else
|
|
code = 1578
|
|
end
|
|
end)
|
|
if LuciHttp.formvalue("image") and fp then
|
|
code = 0
|
|
else
|
|
if code == 0 then
|
|
XQLog.log(6, "upload failed, file not exist: "..tostring(filepath))
|
|
code = 1509
|
|
end
|
|
end
|
|
local result = {}
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getLangList()
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["list"] = XQSysUtil.getLangList()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getMainLang()
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["lang"] = XQSysUtil.getLang()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setLang()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local code = 0
|
|
local result = {}
|
|
local lang = LuciHttp.formvalue("language")
|
|
if XQFunction.isStrNil(lang) then
|
|
code = 1502
|
|
end
|
|
local succeed = XQSysUtil.setLang()
|
|
if not succeed then
|
|
code = 1511
|
|
end
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
result["code"] = code
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function uploadLogFile()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local LuciUtil = require("luci.util")
|
|
local code = 0
|
|
local result = {}
|
|
LuciUtil.exec("/usr/sbin/log_collection.sh")
|
|
local succeed = XQNetUtil.uploadLogFile(XQConfigs.LOG_ZIP_FILEPATH,"B")
|
|
if not succeed then
|
|
code = 1512
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
LuciUtil.exec("rm "..XQConfigs.LOG_ZIP_FILEPATH)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function uploadConfigFile()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local LuciUtil = require("luci.util")
|
|
local code = 0
|
|
local result = {}
|
|
LuciUtil.exec("/usr/sbin/config_collection.sh")
|
|
local succeed = XQNetUtil.uploadConfigFile(XQConfigs.CONFIG_ZIP_FILEPATH)
|
|
if not succeed then
|
|
code = 1512
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
LuciUtil.exec("rm "..XQConfigs.CONFIG_ZIP_FILEPATH)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function configRecovery()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQNetUtil = require("xiaoqiang.util.XQNetUtil")
|
|
local LuciUtil = require("luci.util")
|
|
local code = 0
|
|
local result = {}
|
|
local succeed = XQNetUtil.getConfigFile(XQConfigs.CONFIG_ZIP_FILEPATH)
|
|
if not succeed then
|
|
code = 1513
|
|
else
|
|
LuciUtil.exec("/usr/bin/unzip -o "..XQConfigs.CONFIG_ZIP_FILEPATH.." -d //")
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
LuciUtil.exec("/bin/rm "..XQConfigs.CONFIG_ZIP_FILEPATH)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function reboot()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local client = LuciHttp.formvalue("client")
|
|
local lanIp = XQLanWanUtil.getLanWanIp("lan")
|
|
local result = {}
|
|
if client == "web" then
|
|
XQLog.check(0, XQLog.KEY_REBOOT, 1)
|
|
end
|
|
result["code"] = 0
|
|
result["lanIp"] = lanIp
|
|
LuciHttp.write_json(result)
|
|
LuciHttp.close()
|
|
XQFunction.forkReboot()
|
|
end
|
|
|
|
function reset()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local LuciUtil = require("luci.util")
|
|
local LuciJson = require("json")
|
|
local format = tonumber(LuciHttp.formvalue("format") or 0)
|
|
local code = 0
|
|
local result = {}
|
|
if format == 1 then
|
|
local formatResult = XQFunction.thrift_tunnel_to_datacenter([[{"api":28}]])
|
|
if formatResult then
|
|
if formatResult.code == 0 then
|
|
code = 0
|
|
else
|
|
code = 1558
|
|
end
|
|
else
|
|
code = 1559
|
|
end
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
LuciHttp.close()
|
|
if result.code == 0 then
|
|
-- reset smart controller database and config
|
|
XQFunction.thrift_tunnel_to_smarthome_controller([[{"command":"reset_scenes"}]])
|
|
-- set restore default and reboot
|
|
XQFunction.forkResetAll()
|
|
end
|
|
end
|
|
|
|
function getSysAvgLoad()
|
|
local LuciUtil = require("luci.util")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
XQSysUtil.setDetectionTimestamp()
|
|
local result = {}
|
|
result["code"] = 0
|
|
local avg = LuciUtil.exec("/usr/sbin/sysapi system_info get cpuload")
|
|
result["loadavg"] = tonumber(avg)
|
|
result["processCount"] = tonumber(LuciUtil.exec("cat /proc/cpuinfo | grep -c 'processor'"))
|
|
LuciHttp.write_json(result)
|
|
LuciHttp.close()
|
|
end
|
|
|
|
function setMacFilter()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local LuciUtil = require("luci.util")
|
|
local LuciDatatypes = require("luci.cbi.datatypes")
|
|
local result = {}
|
|
local code = 0
|
|
local mac = LuciHttp.formvalue("mac")
|
|
local wan = LuciHttp.formvalue("wan")
|
|
local lan = LuciHttp.formvalue("lan")
|
|
local admin = LuciHttp.formvalue("admin")
|
|
local pridisk = LuciHttp.formvalue("pridisk")
|
|
|
|
if not XQFunction.isStrNil(mac) and LuciDatatypes.macaddr(mac) then
|
|
if wan then
|
|
wan = tonumber(wan) == 1 and "1" or "0"
|
|
end
|
|
if lan then
|
|
lan = tonumber(lan) == 1 and "1" or "0"
|
|
end
|
|
if admin then
|
|
admin = tonumber(admin) == 1 and "1" or "0"
|
|
end
|
|
if pridisk then
|
|
pridisk = tonumber(pridisk) == 1 and "1" or "0"
|
|
end
|
|
XQSysUtil.setMacFilter(mac,lan,wan,admin,pridisk)
|
|
else
|
|
code = 1508
|
|
end
|
|
result["code"] = code
|
|
if code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function openWps()
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["timestamp"] = XQWifiUtil.openWifiWps()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function stopWps()
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
XQWifiUtil.stopWps()
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function _checkConnection(mac, try)
|
|
local cmac
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
if not mac then
|
|
cmac = XQWifiUtil.getWpsConDevMac()
|
|
else
|
|
cmac = mac
|
|
end
|
|
if XQWifiUtil.isDeviceWifiConnect(cmac, 1) or XQWifiUtil.isDeviceWifiConnect(cmac, 2) then
|
|
return cmac
|
|
else
|
|
if try > 0 then
|
|
os.execute("sleep 3")
|
|
_checkConnection(cmac, try - 1)
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function getWpsStatus()
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local XQPreference = require("xiaoqiang.XQPreference")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local result = {}
|
|
local status = XQWifiUtil.getWifiWpsStatus()
|
|
if status == 2 then
|
|
local device = {}
|
|
local mac = XQWifiUtil.getWpsConDevMac()
|
|
if mac then
|
|
if XQWifiUtil.isDeviceWifiConnect(mac, 1) or XQWifiUtil.isDeviceWifiConnect(mac, 2) then
|
|
device["mac"] = mac
|
|
device["company"] = XQDeviceUtil.getDeviceCompany(mac)
|
|
else
|
|
local cmac = _checkConnection(mac, 2)
|
|
if cmac then
|
|
device["mac"] = cmac
|
|
device["company"] = XQDeviceUtil.getDeviceCompany(cmac)
|
|
result["device"] = device
|
|
else
|
|
status = 9
|
|
end
|
|
end
|
|
else
|
|
local cmac = _checkConnection(mac, 2)
|
|
if cmac then
|
|
device["mac"] = cmac
|
|
device["company"] = XQDeviceUtil.getDeviceCompany(cmac)
|
|
result["device"] = device
|
|
else
|
|
status = 9
|
|
end
|
|
end
|
|
end
|
|
if status >= 3 and status <= 7 then
|
|
status = 3
|
|
end
|
|
result["code"] = 0
|
|
result["status"] = status
|
|
result["startTime"] = XQPreference.get(XQConfigs.PREF_WPS_TIMESTAMP,"")
|
|
result["currentTime"] = tostring(os.time())
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function createSandbox()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.LAMP_CREATE_SANDBOX)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function mountThings()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.LAMP_MOUNT_THINGS)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function umountThings()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.LAMP_UMOUNT_THINGS)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function startDropbear()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.LAMP_START_DROPBEAR)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function stopDropbear()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.LAMP_STOP_DROPBEAR)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function isSandboxCreated()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["isSandboxCreated"] = (0 == tonumber(os.execute(XQConfigs.LAMP_IS_SANDBOX_CREATED)))
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function areThingsMounted()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["areThingsMounted"] = (0 == tonumber(os.execute(XQConfigs.LAMP_ARE_THINGS_MOUNTED)))
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function isDropbearStarted()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["isDropbearStarted"] = (0 == tonumber(os.execute(XQConfigs.LAMP_IS_DROPBEAR_STARTED)))
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function stopNginx()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.NGINX_CACHE_STOP)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function startNginx()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciUtil.exec(XQConfigs.NGINX_CACHE_START)
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function nginxCacheStatus()
|
|
local LuciUtil = require("luci.util")
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["status"] = 1
|
|
local status = LuciUtil.exec(XQConfigs.NGINX_CACHE_STATUS)
|
|
if status then
|
|
result["status"] = LuciUtil.trim(status) == "NGINX_CACHE=off" and 0 or 1
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function checkRouterNamePending()
|
|
local XQConfigs = require("xiaoqiang.common.XQConfigs")
|
|
local cmd = XQConfigs.THRIFT_TO_MQTT_GET_DEVICEID
|
|
local LuciUtil = require("luci.util")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result['pending'] = XQSysUtil.getRouterNamePending()
|
|
result["routerId"] = LuciUtil.exec(cmd)
|
|
result['routerName'] = XQSysUtil.getRouterName()
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function clearRouterNamePending()
|
|
XQSysUtil.setRouterNamePending('0')
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function redirectUrl()
|
|
local XQSecureUtil = require("xiaoqiang.util.XQSecureUtil")
|
|
local cookieValue = LuciHttp.getcookie("psp")
|
|
local result = {}
|
|
result["code"] = 0
|
|
if cookieValue then
|
|
local loginType = cookieValue:match("|||(%S)|||")
|
|
result["redirectUrl"] = "http://miwifi.com/cgi-bin/luci/web/home?redirectKey="..XQSecureUtil.generateRedirectKey(loginType)
|
|
else
|
|
result["redirectUrl"] = "http://miwifi.com/cgi-bin/luci/web/home?redirectKey="..XQSecureUtil.generateRedirectKey(2)
|
|
end
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function mainStatusForApp()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local XQDeviceUtil = require("xiaoqiang.util.XQDeviceUtil")
|
|
local XQZigbeeUtil = require("xiaoqiang.util.XQZigbeeUtil")
|
|
local result = {}
|
|
local lan = XQDeviceUtil.getWanLanNetworkStatistics("lan")
|
|
local wan = XQDeviceUtil.getWanLanNetworkStatistics("wan")
|
|
local count = XQFunction.thrift_tunnel_to_smarthome_controller([[{"command":"get_scene_count"}]])
|
|
if count and count.code == 0 then
|
|
result["smartSceneCount"] = count.count
|
|
else
|
|
result["smartSceneCount"] = 0
|
|
end
|
|
-- userdisk
|
|
local disk = XQFunction.thrift_tunnel_to_datacenter([[{"api":26}]])
|
|
if disk and disk.code == 0 then
|
|
result["useableSpace"] = math.floor(tonumber(disk.free) / 1024)
|
|
else
|
|
result["useableSpace"] = 0
|
|
end
|
|
-- plugin
|
|
local plugin = XQFunction.thrift_tunnel_to_datacenter([[{"api":601}]])
|
|
if plugin and plugin.code == 0 then
|
|
result["installedPluginCount"] = #plugin.data
|
|
else
|
|
result["installedPluginCount"] = 0
|
|
end
|
|
-- downloading
|
|
local downloads = 0
|
|
local downloading = 0
|
|
local download = XQFunction.thrift_tunnel_to_datacenter([[{"api":503}]])
|
|
if download and download.code == 0 then
|
|
table.foreach(download.uncompletedList,
|
|
function(i,v)
|
|
downloads = downloads + 1
|
|
if v.downloadStatus == 1 then
|
|
downloading = downloading + 1
|
|
end
|
|
end
|
|
)
|
|
end
|
|
-- zigbee
|
|
local zigbeecount = XQZigbeeUtil.get_zigbee_count();
|
|
result["code"] = 0
|
|
result["connectDeviceCount"] = zigbeecount + XQDeviceUtil.getConnectDeviceCount()
|
|
|
|
|
|
result["upTime"] = XQSysUtil.getSysUptime()
|
|
result["maxWanSpeed"] = tonumber(wan.maxdownloadspeed)
|
|
result["maxLanSpeed"] = tonumber(lan.maxdownloadspeed)
|
|
result["wanSpeed"] = tonumber(wan.downspeed)
|
|
result["lanSpeed"] = tonumber(lan.downspeed)
|
|
result["hasDownloading"] = downloading > 0 and 1 or 0
|
|
result["downloadingCount"] = downloads
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
--[[
|
|
filter : lan/wan/admin
|
|
]]--
|
|
function getMacfilterMode()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local code = 0
|
|
local result = {}
|
|
|
|
local filter = LuciHttp.formvalue("filter") or "lan"
|
|
local mode = XQSysUtil.getMacfilterMode(filter)
|
|
if mode then
|
|
result["mode"] = mode
|
|
else
|
|
code = 1574
|
|
end
|
|
result["code"] = code
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
--[[
|
|
filter : lan/wan/admin
|
|
mode : 0/1 (whitelist/blacklist)
|
|
]]--
|
|
function setMacfilterMode()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local code = 0
|
|
local result = {}
|
|
|
|
local filter = LuciHttp.formvalue("filter") or "lan"
|
|
local mode = tonumber(LuciHttp.formvalue("mode") or 0)
|
|
local setMode = XQSysUtil.setMacfilterMode(filter,mode)
|
|
if not setMode then
|
|
code = 1575
|
|
end
|
|
result["code"] = code
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function shutdown()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
LuciHttp.close()
|
|
XQFunction.forkShutdown()
|
|
end
|
|
|
|
function upnpList()
|
|
local XQUPnPUtil = require("xiaoqiang.util.XQUPnPUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["status"] = XQUPnPUtil.getUPnPStatus() and 1 or 0
|
|
local upnp = XQUPnPUtil.getUPnPList()
|
|
if upnp then
|
|
result["list"] = upnp
|
|
else
|
|
result["list"] = {}
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function upnpSwitch()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local XQUPnPUtil = require("xiaoqiang.util.XQUPnPUtil")
|
|
local switch = tonumber(LuciHttp.formvalue("switch") or 1)
|
|
local result = {}
|
|
XQLog.check(0, XQLog.KEY_FUNC_UPNP, switch == 1 and 0 or 1)
|
|
XQUPnPUtil.switchUPnP(switch == 1)
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function appLimit()
|
|
local XQQoSUtil = require("xiaoqiang.util.XQQoSUtil")
|
|
local info = XQQoSUtil.appInfo()
|
|
info.code = 0
|
|
LuciHttp.write_json(info)
|
|
end
|
|
|
|
function appLimitSwitch()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local XQQoSUtil = require("xiaoqiang.util.XQQoSUtil")
|
|
local switch = tonumber(LuciHttp.formvalue("switch") or 1)
|
|
local result = {}
|
|
XQLog.check(0, XQLog.KEY_FUNC_APPQOS, switch == 1 and 0 or 1)
|
|
XQQoSUtil.appSpeedlimitSwitch(switch == 1)
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setAppLimit()
|
|
local XQQoSUtil = require("xiaoqiang.util.XQQoSUtil")
|
|
local result = {}
|
|
local xlmaxdownload = LuciHttp.formvalue("xlmaxdownload")
|
|
local xlmaxupload = LuciHttp.formvalue("xlmaxupload")
|
|
local kpmaxdownload = LuciHttp.formvalue("kpmaxdownload")
|
|
local kpmaxupload = LuciHttp.formvalue("kpmaxupload")
|
|
XQQoSUtil.setXunlei(xlmaxdownload, xlmaxupload)
|
|
XQQoSUtil.setKuaipan(kpmaxdownload, kpmaxupload)
|
|
XQQoSUtil.reload()
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function vpnInfo()
|
|
local XQVPNUtil = require("xiaoqiang.util.XQVPNUtil")
|
|
local result = XQVPNUtil.getVPNInfo("vpn")
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function setVpn()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local XQVPNUtil = require("xiaoqiang.util.XQVPNUtil")
|
|
local code = 0
|
|
local result = {}
|
|
local server = LuciHttp.formvalue("server")
|
|
local username = LuciHttp.formvalue("username")
|
|
local password = LuciHttp.formvalue("password")
|
|
local proto = LuciHttp.formvalue("proto")
|
|
local auto = LuciHttp.formvalue("auto")
|
|
local set = XQVPNUtil.setVpn("vpn", server, username, password, proto, auto)
|
|
if proto and string.upper(proto) == "PPTP" then
|
|
XQLog.check(0, XQLog.KEY_FUNC_PPTP, 0)
|
|
elseif proto and string.upper(proto) == "L2TP" then
|
|
XQLog.check(0, XQLog.KEY_FUNC_L2TP, 0)
|
|
end
|
|
if set then
|
|
code = 0
|
|
else
|
|
code = 1583
|
|
end
|
|
result["code"] = code
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function _vpnErrorCodeHelper(code)
|
|
local errorA = {
|
|
["507"] = 1,["691"] = 1,["509"] = 1,["514"] = 1,["520"] = 1,
|
|
["646"] = 1,["647"] = 1,["648"] = 1,["649"] = 1,["691"] = 1,
|
|
["646"] = 1
|
|
}
|
|
local errorB = {
|
|
["516"] = 1,["650"] = 1,["601"] = 1,["510"] = 1
|
|
}
|
|
local errorC = {
|
|
["501"] = 1,["502"] = 1,["503"] = 1,["504"] = 1,["505"] = 1,
|
|
["506"] = 1,["507"] = 1,["508"] = 1,["511"] = 1,["512"] = 1,
|
|
["515"] = 1,["517"] = 1,["518"] = 1,["519"] = 1
|
|
}
|
|
local errcode = tostring(code)
|
|
if errcode then
|
|
if errorA[errcode] then
|
|
return 1584
|
|
end
|
|
if errorB[errcode] then
|
|
return 1585
|
|
end
|
|
if errorC[errcode] then
|
|
return 1586
|
|
end
|
|
return 1584
|
|
end
|
|
end
|
|
|
|
-- status: 0 connected 1 connecting 2 failed 3 close 4 none
|
|
function vpnStatus()
|
|
local XQVPNUtil = require("xiaoqiang.util.XQVPNUtil")
|
|
local status = XQVPNUtil.vpnStatus()
|
|
local result = {}
|
|
if status then
|
|
local up = status.up
|
|
local autostart = status.autostart
|
|
local uptime = tonumber(status.uptime)
|
|
local stat = status.stat
|
|
if up then
|
|
result["status"] = 0
|
|
result["uptime"] = uptime
|
|
else
|
|
if autostart then
|
|
if stat and stat.code ~= 0 then
|
|
result["status"] = 2
|
|
result["uptime"] = 0
|
|
result["errcode"] = stat.code
|
|
result["errmsg"] = XQErrorUtil.getErrorMessage(_vpnErrorCodeHelper(stat.code)).." "..tostring(stat.code)
|
|
else
|
|
result["status"] = 1
|
|
result["uptime"] = 0
|
|
end
|
|
else
|
|
result["status"] = 3
|
|
result["uptime"] = 0
|
|
end
|
|
end
|
|
else
|
|
result["status"] = 4
|
|
result["uptime"] = 0
|
|
end
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function vpnSwitch()
|
|
local XQVPNUtil = require("xiaoqiang.util.XQVPNUtil")
|
|
local conn = tonumber(LuciHttp.formvalue("conn"))
|
|
local result = {}
|
|
if conn and conn == 1 then
|
|
XQVPNUtil.vpnSwitch(true)
|
|
else
|
|
XQVPNUtil.vpnSwitch(false)
|
|
end
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getDeviceMacaddr()
|
|
local remoteaddr = luci.http.getenv("REMOTE_ADDR") or ""
|
|
local result = {}
|
|
local code = 0
|
|
if remoteaddr ~= "127.0.0.1" then
|
|
result["mac"] = luci.dispatcher.getremotemac()
|
|
else
|
|
code = 1587
|
|
end
|
|
result["code"] = code
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getDetectionTimestamp()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local result = {}
|
|
result["code"] = 0
|
|
result["timestamp"] = XQSysUtil.getDetectionTimestamp()
|
|
result["currentTime"] = tostring(os.time())
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getWifiLog()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local result = {}
|
|
XQSysUtil.getWifiLog()
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function sysRecovery()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local XQWifiUtil = require("xiaoqiang.util.XQWifiUtil")
|
|
local XQLanWanUtil = require("xiaoqiang.util.XQLanWanUtil")
|
|
local ssid = LuciHttp.formvalue("ssid")
|
|
local enc = LuciHttp.formvalue("enc")
|
|
local key = LuciHttp.formvalue("pwd")
|
|
local wanType = LuciHttp.formvalue("wanType")
|
|
local pppoeName = LuciHttp.formvalue("pppoeName")
|
|
local pppoePwd = LuciHttp.formvalue("pppoePwd")
|
|
if ssid then
|
|
XQWifiUtil.setWifiBasicInfo(1, ssid, key, enc, nil, nil, 0)
|
|
XQWifiUtil.setWifiBasicInfo(2, ssid.."_5G", key, enc, nil, nil, 0)
|
|
end
|
|
XQFunction.forkRestartWifi()
|
|
if wanType == "pppoe" then
|
|
XQLanWanUtil.setWanPPPoE(pppoeName,pppoePwd,nil,nil,nil)
|
|
elseif wanType == "dhcp" then
|
|
XQLanWanUtil.setWanStaticOrDHCP(wanType,nil,nil,nil,nil,nil,nil)
|
|
end
|
|
local result = {}
|
|
result["code"] = 0
|
|
LuciHttp.write_json(result)
|
|
end
|
|
--flag定时wifi开关
|
|
function smartShutdown()
|
|
local XQFunction = require("xiaoqiang.common.XQFunction")
|
|
local result = {}
|
|
local code = 0
|
|
local delay1 = LuciHttp.formvalue("delay1")
|
|
local delay2 = LuciHttp.formvalue("delay2")
|
|
if delay1 and delay2 then
|
|
XQFunction.forkShutdownAndRebootWithDelay(delay1, delay2)
|
|
else
|
|
code = 1502
|
|
end
|
|
result["code"] = code
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function getNofStatus()
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local status = tonumber(XQSysUtil.noflushdStatus())
|
|
if status == 0 then
|
|
status = 1
|
|
else
|
|
status = 0
|
|
end
|
|
local result = {
|
|
["code"] = 0,
|
|
["status"] = status
|
|
}
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function nofSwitch()
|
|
local XQLog = require("xiaoqiang.XQLog")
|
|
local XQSysUtil = require("xiaoqiang.util.XQSysUtil")
|
|
local switch = tonumber(LuciHttp.formvalue("switch")) or 0
|
|
local result = {}
|
|
local success = XQSysUtil.noflushdSwitch(switch == 1 and true or false)
|
|
XQLog.check(0, XQLog.KEY_FUNC_NOFLUSHED, switch == 1 and 0 or 1)
|
|
if switch == 1 then
|
|
XQLog.check(0, XQLog.KEY_DISKSLEEP_OPEN, 1)
|
|
else
|
|
XQLog.check(0, XQLog.KEY_DISKSLEEP_CLOSE, 1)
|
|
end
|
|
if success then
|
|
result["code"] = 0
|
|
else
|
|
result["code"] = 1606
|
|
end
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function predownloadInfo()
|
|
local Predownload = require("xiaoqiang.module.XQPredownload")
|
|
local result = {}
|
|
local info = Predownload.predownloadInfo()
|
|
result["code"] = 0
|
|
result["status"] = info.enable
|
|
result["priority"] = info.priority
|
|
LuciHttp.write_json(result)
|
|
end
|
|
|
|
function predownloadSwitch()
|
|
local Predownload = require("xiaoqiang.module.XQPredownload")
|
|
local switch = tonumber(LuciHttp.formvalue("switch")) or 0
|
|
local result = {}
|
|
local success = Predownload.switch(switch == 1 and true or false)
|
|
if success then
|
|
result["code"] = 0
|
|
else
|
|
result["code"] = 1606
|
|
end
|
|
if result.code ~= 0 then
|
|
result["msg"] = XQErrorUtil.getErrorMessage(result.code)
|
|
end
|
|
LuciHttp.write_json(result)
|
|
end
|