大家好,我是你们的老朋友彬哥,今天给大家贡献之前项目用到的本地脚本服务器,简单的说就是服务器实现win平台下的操作,包括注册表修改、启动本地exe等
部分代码 如下:
package main
import (
"encoding/base64"
"encoding/json"
"flag"
"fmt"
"glog-master"
"golangltd/go-concurrentMap-master"
"io"
"io/ioutil"
"net/http"
"os"
"os/exec"
"strconv"
"strings"
"time"
)
//dim fso,file,read,string_arr(),count,string_finally
//Set shell = Wscript.createobject("wscript.shell")
//set fso=createobject("scripting.filesystemobject")
//Function Encode(filePath)
//Set stm = CreateObject("Adodb.Stream")
//stm.Type = 2
//stm.mode = 3
//stm.charset = "utf-8"
//stm.Open
//stm.LoadFromFile filePath
//Encode = stm.readtext
//stm.close
//End Function
//a = shell.run (Encode("c:\YLG_config.ini")+"\YuleClient.exe",0)
//Wscript.Sleep 3000
//wscript.quit
// 将普通用户组加入到管理组权限
// netlocalgroup administrators 用户名 /add
var Key = "063FCA9EC7A2E41A80271DB1F99B1C3C"
var M *concurrent.ConcurrentMap // 并发安全的map
func init() {
// DD := fmt.Sprintf("%.2f", 1.23756)
// fmt.Println("----------", DD)
//--------------------------------------------------------------------------
// 初始化 日志系统
flag.Set("alsologtostderr", "true") // 日志写入文件的同时,输出到stderr
flag.Set("log_dir", "./log") // 日志文件保存目录
flag.Set("v", "3") // 配置V输出的等级。
flag.Parse()
//--------------------------------------------------------------------------
LunBoMap = make(map[string]interface{})
M = concurrent.NewConcurrentMap()
BShutGame = 0
//--------------------------------------------------------------------------
// 轮播获取
go GetLunBoList()
// 启动轮播游戏
go GetLunBoListQiDong()
//--------------------------------------------------------------------------
dd := []string{"112.74.201.179"} // 测试环境
// dd := []string{"120.25.83.66"} // 正式环境
// 开机
go KaiJiUpdate()
// ping值
go KaiJiUpdateTimebak()
go mainping(dd)
go KaiJiUpdateGamebak()
go KaiJiUpdateGamebakre()
// 上传游戏版本
go UpdateBenDiGameVer()
// 获取是否重启
go KaiJiAndChongQi()
// 每60分钟自动更新一次
go UpdateBenDiGameVerZd()
// 关游戏
go KaiJiUpdateGamebakreFalse()
// 定时清空
go Time_IsPlayer()
// 自启动环境配置
GGGMap_Ver = make(map[string]string)
WFile()
data, err := ioutil.ReadFile("c:/YLG_config.ini")
if err != nil || len(data) < 1 {
RunEXE("auto.vbs")
WFileexe()
return
}
fmt.Println(string(data))
//--------------------------------------------------------------------------
return
}
// 主函数
func main() {
fmt.Print(os.Args[1:])
http.HandleFunc("/DuliLogin", DuLiLogin) // 独立登陆
http.HandleFunc("/DuliServer", DuLiServer) // 启动游戏
http.HandleFunc("/BenDiV", DuLiBenDiV) // 获取本地版本号
http.HandleFunc("/BenDiIP", DuLiBenIP) // 获取本地服务器IP
http.HandleFunc("/BenTest", DuLiLoginbak) // 测试使用
http.HandleFunc("/BenGX", DuLiGX) // 本地、远程更新
http.HandleFunc("/BenShut", BenShut) // 本地、重启
http.HandleFunc("/BenPlayer", BenPlayer) // 有人在游戏中没有
http.HandleFunc("/BenPC", BenPC) // 游戏开启
err := http.ListenAndServe(":8765", nil)
if err != nil {
fmt.Println("ListenAndServe nil", err.Error())
return
}
glog.Flush()
return
}
// 轮播变量
var ListLunBo string
var ListWZ = 0
var IsPlayer string = ""
var IsPlayerConut int = 0
var IsPlayerConutbakre int = 0
var StrGameName string = ""
var LunBoMap map[string]interface{}
var IniName = ""
var PathData = ""
var BKaiF bool = false
var BShutGame int = 0
// 一体机结构
type YiTiJiData struct {
IsPost bool
Data []struct {
UserName string
GameRunState bool
GameRunName string
ComputerState bool
NetworkLatency int
Address string
EditNowGame bool
EditNewGame bool
EditGameName string
EditComputer bool
RestartState bool
}
Error string
}
// 游戏更新版本自动
func UpdateBenDiGameVerZd() {
GGameStartTimer := time.NewTicker(60 * 60 * time.Second) // 每一个小时
for {
select {
case <-GGameStartTimer.C:
{
url := "http://local.websocket.club:8765/BenDiV?GetVer=11"
resp, err := http.Get(url)
if err != nil {
glog.Info("err:", err.Error())
fmt.Println("err:", err.Error())
}
defer resp.Body.Close()
_, errre := ioutil.ReadAll(resp.Body)
if errre != nil {
glog.Info("errre:", errre.Error())
}
resp.Body.Close()
}
}
}
}
// 获取关机、重启
func KaiJiAndChongQi() {
GGameStartTimer := time.NewTicker(1 * time.Second) // 每1秒获取一个次轮播列表
for {
select {
case <-GGameStartTimer.C:
{
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=getstate&username=" + strLogin
resp, err := http.Get(url)
if err != nil {
fmt.Println("KaiJiAndChongQi:", err.Error())
glog.Info("err:", err.Error())
continue
}
body, err2 := ioutil.ReadAll(resp.Body)
if err2 != nil {
fmt.Println("playerdata", err2.Error())
continue
}
//fmt.Println("body:", string(body))
// 解析数据,保存数据库操作
stbtmp := &YiTiJiData{}
err3 := json.Unmarshal([]byte(body), &stbtmp)
if err3 != nil {
fmt.Println("Unmarshal faild", err3.Error())
} else {
//fmt.Println("Unmarshal success stbtmp.ComputerState:", stbtmp.Data[0].EditComputer)
// 判断所有的结构数据信息
if stbtmp.Data[0].EditComputer == true { // 重启电脑 RestartState 电脑是否重启完成
// 重启电脑
ReShutDownEXE()
} else if stbtmp.Data[0].EditNewGame == true { // 需要启动的新游戏名称
}
}
}
}
}
}
// 上传本地游戏版本
func UpdateBenDiGameVer() {
if len(GGGMap_Ver) == 0 {
url := "http://local.websocket.club:8765/BenDiV?GetVer=11"
_, err := http.Get(url)
if err != nil {
fmt.Println("err:", err.Error())
glog.Info("err:", err.Error())
}
}
data := ""
for key, second := range GGGMap_Ver {
//Data=游戏id:版本号,游戏id:版本号,
if len(data) == 0 {
data = key + ":" + second
} else {
data = data + "," + key + ":" + second
}
}
// 发送
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=uploadgamesversion&UserName=" + strLogin + "&Data=" + data
_, err := http.Get(url)
if err != nil {
fmt.Println("err:", err)
glog.Info("err:", err.Error())
}
}
// 开机状态
func KaiJiUpdate() {
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatalancher&username=" + strLogin + "&computerstate=true"
http.Get(url)
}
var BShutGamebak int = 0
var BShutGamebakre int = 0
// 游戏更新
func KaiJiUpdateGamebakreFalse() {
GGameStartTimer := time.NewTicker(1 * time.Second) // 每60秒
for {
select {
case <-GGameStartTimer.C:
{
if BShutGame == 0 {
continue
}
if BShutGamebak < BShutGame {
BShutGamebak = BShutGame
BShutGamebakre = BShutGame
} else {
BShutGamebakre++
}
glog.Info("判断-- ", BShutGamebakre)
if (BShutGamebakre - BShutGamebak) > 5 {
// 关闭游戏
glog.Info("web 无心跳,关闭游戏")
KillEXE(StrGameName)
KillEXE("文件管理")
LunBoMap = make(map[string]interface{})
StrGameName = ""
BShutGamebak = 0
BShutGamebakre = 0
BShutGame = 0
}
}
}
}
}
// 游戏更新
func KaiJiUpdateGamebakre() {
GGameStartTimer := time.NewTicker(1 * time.Second) // 每1秒
TOIsPlayerConutbakre := 0
IsPlayerConutbak := 0
for {
select {
case <-GGameStartTimer.C:
{
if len(StrGameName) == 0 {
continue
}
if IsPlayerConutbakre == 0 {
continue
}
fmt.Println("IsPlayerConutbakre:", IsPlayerConutbakre)
if IsPlayerConutbakre > IsPlayerConutbak {
IsPlayerConutbak = IsPlayerConutbakre
//IsPlayerConutbakre = 0
} else {
TOIsPlayerConutbakre++
}
if TOIsPlayerConutbakre > 5 {
// 更新游戏关闭状态
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatagame&username=" + strLogin + "&gamerunstate=false" + "&gamerunname=" + StrGameName
_, Err := http.Get(url)
if Err != nil {
glog.Info("http://www.yulegame.cn:81/API/", Err.Error())
continue
}
glog.Info("+++++++++++++++++++++++++++++ 游戏为发送数据,exe已经修改为关游戏状态!!!")
//KillEXE(StrGameName)
//StrGameName = ""
//IsPlayerConut = 0
IsPlayerConutbakre = 0
BKaiF = true
TOIsPlayerConutbakre = 0
}
}
}
}
}
// 游戏更新
func KaiJiUpdateGamebak() {
//kill
GGameStartTimer := time.NewTicker(2 * time.Second) // 每1秒
for {
select {
case <-GGameStartTimer.C:
{
if len(StrGameName) == 0 {
continue
}
// 更新游戏启动状态
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatagame&username=" + strLogin + "&gamerunstate=true" + "&gamerunname=" + StrGameName
_, Err := http.Get(url)
if Err != nil {
glog.Info("http://www.yulegame.cn:81/API/", Err.Error())
}
}
}
}
}
var iitme int = 0
// 开机时间更新
func KaiJiUpdateTimebak() {
fmt.Println("UpdateTime:", iitme, "s")
GGameStartTimer := time.NewTicker(1 * time.Second) // 每1秒获取一个次轮播列表
for {
select {
case <-GGameStartTimer.C:
{
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=getwebstate&username=" + strLogin
_, err := http.Get(url)
if err != nil {
fmt.Println("KaiJiUpdateTimebak:", err.Error())
}
iitme++
// fmt.Println("UpdateTime:", iitme, "s")
}
}
}
}
// 获取轮播列表
func GetLunBoList() {
GGameStartTimer := time.NewTicker(5 * 1 * time.Second) // 每5秒获取一个次轮播列表
for {
select {
case <-GGameStartTimer.C:
{
//IsPlayer = "" // 重置无人在游戏中
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=timerswitchbypc&UserName=" + strLogin
resp, err1 := http.Get(url)
if err1 != nil {
fmt.Println("Send_FirmGetAward_JiLu_By_Hsttp get error", err1.Error())
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("body err:", err.Error())
return
}
data := string(body)
// 轮播列表
//fmt.Println("轮播列表:", data)
if len(data) == 0 { //没有轮播数据
continue
}
// 判断数据相同不
if ListLunBo == data {
continue
}
// 更新数据
ListLunBo = data
ListWZ = 0 // 轮播位置回到初始位置
}
}
}
return
}
//IsPlayerConut
func Time_IsPlayer() {
GGameStartTimer := time.NewTicker(1 * time.Second) // 每1秒获取一个次轮播列表
IsPlayerConutre := 0
for {
select {
case <-GGameStartTimer.C:
{
if IsPlayerConut == 0 {
continue
}
if IsPlayerConutre < IsPlayerConut {
IsPlayerConutre = IsPlayerConut
} else {
IsPlayerConutre++
}
if (IsPlayerConutre - IsPlayerConut) > 5 {
IsPlayerConutre = 0
IsPlayerConut = 0
IsPlayer = ""
glog.Info("Time_IsPlayer----------无人在游戏中")
}
}
}
}
}
// 获取轮播列表
func GetLunBoListQiDong() {
GGameStartTimer := time.NewTicker(60 * 10 * time.Second) // 每分钟启动一次新游戏
for {
select {
case <-GGameStartTimer.C:
{
if len(LunBoMap) == 0 {
fmt.Println("登陆数据已被清空,无法轮播!!!")
continue
}
fmt.Println("开始执行轮播")
// 1 判断现在游戏有人在游戏中不
if len(IsPlayer) != 0 { // 有人在游戏中
fmt.Println("有人在游戏中----------")
continue
}
strLogin := ReadFile()
// 获取数据
var str string = ListLunBo
charray := []byte(str)
fmt.Println("开始执行轮播列表:", string(charray))
// 保存数据,确认获取的数据和现在数据相同不
// 2 拆分数据
strsplit := Strings_Split(string(charray), ",")
GameID := ""
bbret := false
B2bet := false
for i := 0; i < len(strsplit); i++ {
if bbret {
break
}
if len(strsplit) <= ListWZ {
ListWZ = 0
}
GameID = strsplit[ListWZ]
fmt.Println("开始执行轮播ID:", GameID, "-------ListWZ:", ListWZ)
//----------------------
for k, _ := range LunBoMap {
iGameID, _ := strconv.Atoi(GameID)
if int((LunBoMap[k].(map[string]interface{})["GameID"]).(float64)) == iGameID {
// 判断是不是本身的游戏,如果是就不做处理
if StrGameName == LunBoMap[k].(map[string]interface{})["GameName"].(string) {
ListWZ++
B2bet = true
break
}
// 判断文件存在不
strPath := getCurrentPath()
strPath = strPath + "\\YULEGAME\\" + LunBoMap[k].(map[string]interface{})["GameName"].(string)
dd := checkFileIsExist(strPath)
if !dd {
fmt.Println("轮播游戏不存在", strPath)
ListWZ++
B2bet = true
break
}
bbret = true
}
if bbret {
fmt.Println("开始执行轮播ID:", GameID)
// 关闭运行游戏
if len(StrGameName) != 0 {
KillEXE(StrGameName)
}
// 启动游戏
go CallEXE(strLogin+"|"+LunBoMap[k].(map[string]interface{})["GameName"].(string)+"|"+LunBoMap[k].(map[string]interface{})["XianChangName"].(string),
LunBoMap[k].(map[string]interface{})["IpAndPort"].(string), LunBoMap[k].(map[string]interface{})["GameName"].(string))
// 更新游戏启动状态
strLogin := ReadFile()
url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatagame&username=" + strLogin + "&gamerunstate=true" + "&gamerunname=" + LunBoMap[k].(map[string]interface{})["GameName"].(string)
_, Err := http.Get(url)
if Err != nil {
glog.Info("http://www.yulegame.cn:81/API/", Err.Error())
}
break
}
}
if B2bet {
continue
}
if len(LunBoMap) == 0 {
continue
}
///-----------------------------------------------
ListWZ++
//fmt.Println("-----------------------------ListWZ", ListWZ)
}
// fmt.Println("开始执行轮播ID:", GameID)
// 3 对比数据,获取现场数据
//fmt.Println("-----------------------------", (req2map["1"].(map[string]interface{}))["XianChangName"])
//----------------------------------------------------------
// 5 轮播位置 增加1
//ListWZ++
// 保存数据
// if len(LunBoMap) != 0 {
// fmt.Println("-----------------------------", key)
// // 关闭运行游戏
// KillEXE(StrGameName)
// // 启动游戏
// CallEXE(strLogin+"|"+LunBoMap[key].(map[string]interface{})["GameName"].(string)+"|"+LunBoMap[key].(map[string]interface{})["XianChangName"].(string),
// LunBoMap[key].(map[string]interface{})["IpAndPort"].(string), LunBoMap[key].(map[string]interface{})["GameName"].(string))
// // 更新游戏启动状态
// url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatagame&username=" + strLogin + "&gamerunstate=true" + "&gamerunname=" + LunBoMap[key].(map[string]interface{})["GameName"].(string)
// _, Err := http.Get(url)
// if Err != nil {
// glog.Info("http://www.yulegame.cn:81/API/", Err.Error())
// }
// }
//fmt.Println("开始执行轮LunBoMap:", LunBoMap)
// for k, _ := range LunBoMap {
// if bbret == true {
// GameID = strsplit[ListWZ]
// }
// fmt.Println("启动开启的游戏ID:", (LunBoMap[k].(map[string]interface{})["GameID"]).(float64))
// iGameID, _ := strconv.Atoi(GameID)
// if int((LunBoMap[k].(map[string]interface{})["GameID"]).(float64)) == iGameID {
// // 判断是不是本身的游戏,如果是就不做处理
// if StrGameName == LunBoMap[k].(map[string]interface{})["GameName"].(string) {
// continue
// }
// // 关闭运行游戏
// KillEXE(StrGameName)
// // 启动游戏
// CallEXE(strLogin+"|"+LunBoMap[k].(map[string]interface{})["GameName"].(string)+"|"+LunBoMap[k].(map[string]interface{})["XianChangName"].(string),
// LunBoMap[k].(map[string]interface{})["IpAndPort"].(string), LunBoMap[k].(map[string]interface{})["GameName"].(string))
// // 更新游戏启动状态
// strLogin := ReadFile()
// url := "http://www.yulegame.cn:81/API/AIO.ashx?method=updatagame&username=" + strLogin + "&gamerunstate=true" + "&gamerunname=" + LunBoMap[k].(map[string]interface{})["GameName"].(string)
// _, Err := http.Get(url)
// if Err != nil {
// glog.Info("http://www.yulegame.cn:81/API/", Err.Error())
// }
// bbret = false
// break
// }
// }
}
}
}
return
}
// 游戏中
func BenPC(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/BenPC?GameName=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
_, bIType := req.Form["GameName"]
if bIType {
IsPlayerConutbakre++
//fmt.Println("IsPlayerConutbakre----------------88888888888888888:", ss[0])
fmt.Fprint(w, "发送成功!!!")
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
// 是否有人在游戏中
func BenPlayer(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/BenPlayer?GameName=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
StrGameNamebak, bIType := req.Form["GameName"]
if bIType {
IsPlayerConut++
fmt.Println("IsPlayerConut----------------666666666666666--------:", IsPlayerConut)
IsPlayer = StrGameNamebak[0]
fmt.Fprint(w, "发送成功!!!")
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
func BenShut(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/BenShut?IType=
// IType =1 关机 IType =2 重启
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
StrIType, bIType := req.Form["IType"]
if bIType {
if StrIType[0] == "1" {
ShutDownEXE()
fmt.Fprint(w, "成功!!!")
return
} else if StrIType[0] == "2" {
ReShutDownEXE()
fmt.Fprint(w, "成功!!!")
return
}
fmt.Fprint(w, "IType 错误!!!")
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
// 独立登陆验证
//var BF1 string = "0%"
func DuLiGX(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/BenGX?GX=&IType=
// IType =1 更新 IType =2 获取进度 IType =3 更新进度
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
StrBF, bGX := req.Form["GX"]
StrIType, bIType := req.Form["IType"]
if bGX && bIType {
// 启动更新程序,
if StrIType[0] == "1" {
CallEXELP(StrBF[0])
fmt.Fprint(w, "成功!!!")
//BF = "0%"
M.Put("UPDATE", "0%")
return
} else if StrIType[0] == "2" {
// 返回web数据:已经更新文件,需要更新文件总数。
val, _ := M.Get("UPDATE")
// glog.Info("--------------------update:", val)
if val != nil {
fmt.Fprint(w, val)
return
}
fmt.Fprint(w, "0%")
return
} else if StrIType[0] == "3" {
// 返回web数据:已经更新文件,需要更新文件总数。
//BF = StrBF[0]
M.Put("UPDATE", StrBF[0])
//fmt.Println("返回web数据:已经更新文件,需要更新文件总数", StrBF[0])
// fmt.Fprint(w, "")
return
} else if StrIType[0] == "4" {
if len(StrGameName) != 0 {
KillEXE(StrGameName)
LunBoMap = make(map[string]interface{})
// IsPlayerConutbakre = 0
StrGameName = ""
}
//fmt.Fprint(w, "")
return
} else if StrIType[0] == "5" {
// http://local.websocket.club:8765/BenGX?GX=&IType=5
glog.Info("get web :", BShutGame)
BShutGame++
return
}
fmt.Fprint(w, "IType 错误!!!")
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
// 启动更新程序
func CallEXELP(StrGameName string) {
fmt.Println("开始更新游戏:", StrGameName)
strPath := getCurrentPath()
strPath = strPath + "\\AutoUpdater.exe"
arg := []string{StrGameName, Key}
cmd := exec.Command(strPath, arg...)
_, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("Error:", err)
glog.Info("err:", err.Error())
return
}
return
}
// 独立登陆验证
func DuLiLoginbak(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/DuliLogin?LoginName=&LoginPW=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
_, bLoginName := req.Form["LoginName"]
_, bLoginPW := req.Form["LoginPW"]
if bLoginPW && bLoginName {
// 临时定义
type ColorGroup struct {
ID int
Name string
Colors []string
}
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
b, err := json.Marshal(group)
if err != nil {
fmt.Println("error:", err)
}
fmt.Fprint(w, base64.StdEncoding.EncodeToString(b))
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
// 独立PC 游戏IP;web广播轮训
// http://172.0.0.1~127.0.0.225:8765/BenDiIP?GetIp=
func DuLiBenIP(w http.ResponseWriter, req *http.Request) {
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
_, bGetIp := req.Form["GetIp"]
if bGetIp {
dd := GetIP()
if len(dd) == 0 {
fmt.Fprint(w, "获取本机IP失败")
return
}
fmt.Fprint(w, dd)
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
// 获取数据,主要是针对于本地配置文件
func GetData_IsWeb_Config() {
fmt.Println("Entry GetData_IsWeb_Config")
// 获取数据
url1 := "www.websocket.club:9094/TJData?"
// 获取配置文件
namedata := ReadFile()
if len(namedata) == 0 {
return
}
// 解析数据
url := "http://" + url1 + "Protocol=11&Protocol2=2&FirmsName=" + namedata
resp, err1 := http.Get(url)
if err1 != nil {
glog.Error("Send_FirmGetAward_JiLu_By_Hsttp get error", err1.Error())
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
glog.Error("body err:", err.Error())
return
}
data := string(body)
fmt.Println("Entry GetData_IsWeb_Config", string(body))
if data == "y" {
// 不执行操作
return
} else {
// admin001|大航海|现场一|1|1
var data1, data2, data3, data4, data5 string = "", "", "", "", ""
strsplit := Strings_Split(data, "|")
for i := 0; i < len(strsplit); i++ {
if i == 0 {
data1 = strsplit[0]
} else if i == 1 {
data2 = strsplit[1]
} else if i == 2 {
data3 = strsplit[2]
} else if i == 3 {
data4 = strsplit[3]
} else if i == 4 {
data5 = strsplit[4]
}
}
fmt.Println("data5", data5)
// 判断是否远程关机
if data5 == "1" {
ShutDownEXE()
return
}
// 判断是否远程重启
if data5 == "2" {
ReShutDownEXE()
return
}
// 判断是不是开机启动游戏
if data4 == "1" {
// 启动游戏 CallEXE(strLoginName[0]+"|"+strGameName[0]+"|"+strXCName[0], strIPandPort[0], strGameName[0])
// kill 所有的游戏进程
CallEXE(data1+"|"+data2+"|"+data3, "", data2)
}
}
return
}
const (
base64Table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
)
var coder = base64.NewEncoding(base64Table)
func base64Encode(src []byte) []byte {
return []byte(coder.EncodeToString(src))
}
func base64Decode(src []byte) ([]byte, error) {
return coder.DecodeString(string(src))
}
// 字符串分割函数
func Strings_Split(Data string, Split string) []string {
return strings.Split(Data, Split)
}
// 读文件
func ReadFile() string {
if len(IniName) == 0 {
dat, err := ioutil.ReadFile("logindata.ini")
if err != nil {
fmt.Println("ReadFile():", err.Error())
return "admin001"
}
IniName = string(dat)
return string(dat)
}
return IniName
}
// 写文件
func WriteFile(strloginname string) {
d1 := []byte(strloginname)
ioutil.WriteFile("logindata.ini", d1, 0644)
return
}
// 获取本地版本号
func DuLiBenDiV(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/BenDiV?GetVer=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
_, bGetVer := req.Form["GetVer"]
if bGetVer {
//if len(GGGMap_Ver) == 0 {
strPath := getCurrentPath()
ListDir(strPath + "\\YULEGAME\\")
fmt.Println("Entry GGGMap_Ver", GGGMap_Ver)
b, _ := json.Marshal(GGGMap_Ver)
// 获取卡卷基础信息
fmt.Fprint(w, base64.StdEncoding.EncodeToString(b))
return
//} else {
// b, _ := json.Marshal(GGGMap_Ver)
// fmt.Fprint(w, base64.StdEncoding.EncodeToString(b))
// return
//}
//return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
fmt.Fprint(w, "非Get方式获取!!!")
return
}
// 独立登陆验证
func DuLiLogin(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/DuliLogin?LoginName=&LoginPW=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
strLoginName, bLoginName := req.Form["LoginName"]
strLoginPW, bLoginPW := req.Form["LoginPW"]
if bLoginPW && bLoginName {
// http://www.websocket.club:9094/DuliServer?Type=&LoginName=&LoginPW=
url1 := "www.websocket.club:9094/DuliServer?"
// 解析数据
url := "http://" + url1 + "&Type=6&LoginName=" + strLoginName[0] + "&LoginPW=" + strLoginPW[0]
resp, err1 := http.Get(url)
if err1 != nil {
glog.Error("Send_FirmGetAward_JiLu_By_Hsttp get error", err1.Error())
return
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
glog.Error("body err:", err.Error())
return
}
fmt.Fprint(w, string(body))
// 写文件
WriteFile(strLoginName[0])
BShutGame = 0
BShutGamebak = 0
BShutGamebakre = 0
IsPlayer = ""
// 重置配置缓存
if IniName != strLoginName[0] {
IniName = strLoginName[0]
// 关闭现在运行游戏
KillEXE(StrGameName)
}
// 保存数据到内存,作为轮播游戏的数据
enbyte, err := base64Decode(body)
if err != nil {
fmt.Println(err.Error())
} else {
//fmt.Println(" ========================== ", string(enbyte))
var r Requestbody
r.req = string(enbyte)
if req2map, err := r.Json2map(); err == nil {
//fmt.Println(req2map["1"])
//fmt.Println("-----------------------------", (req2map["1"].(map[string]interface{}))["XianChangName"])
//----------------------------------------------------------
// 保存数据
LunBoMap = req2map
// for k, v := range req2map {
// fmt.Printf("%s %s\n", k, v)
// }
//----------------------------------------------------------
} else {
fmt.Println("登陆数据解析错误@@@", err)
}
}
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
//把请求包定义成一个结构体
type Requestbody struct {
req string
}
//以指针的方式传入,但在使用时却可以不用关心
// result 是函数内的临时变量,作为返回值可以直接返回调用层
func (r *Requestbody) Json2map() (s map[string]interface{}, err error) {
var result map[string]interface{}
if err := json.Unmarshal([]byte(r.req), &result); err != nil {
return nil, err
}
return result, nil
}
// 独立服务器
func DuLiServer(w http.ResponseWriter, req *http.Request) {
// http://local.websocket.club:8765/DuliServer?LoginName=&LoginPW=&GameName=&XCName=
if req.Method == "GET" {
w.Header().Set("Access-Control-Allow-Origin", "*")
req.ParseForm()
// 获取函数
strLoginName, bLoginName := req.Form["LoginName"]
// strLoginPW, bLoginPW := req.Form["LoginPW"]
strGameName, bGameName := req.Form["GameName"]
strXCName, bXCName := req.Form["XCName"]
strIPandPort, bIPandPort := req.Form["IPandPort"]
// if bLoginPW && bLoginName && bGameName && bXCName && bIPandPort {
if bLoginName && bGameName && bXCName && bIPandPort {
fmt.Println("strLoginName:", strLoginName)
// fmt.Println("strLoginPW", strLoginPW)
fmt.Println("strGameName:", strGameName)
fmt.Println("strXCName", strXCName)
fmt.Println("strIPandPort", strIPandPort)
// 发送给游戏
// if len(StrGameName) != 0 {
// fmt.Fprint(w, "游戏已启动")
// return
// }
if IsPlayerConutbakre > 0 {
fmt.Fprint(w, "游戏已启动")
return
}
fmt.Fprint(w, "发送成功!!!")
go CallEXE(strLoginName[0]+"|"+strGameName[0]+"|"+strXCName[0], strIPandPort[0], strGameName[0])
return
}
fmt.Fprint(w, "启动失败,参数不对!!!")
return
}
}
func check(e error) {
if e != nil {
panic(e)
}
}
/**
* 判断文件是否存在 存在返回 true 不存在返回false
*/
func checkFileIsExist(filename string) bool {
var exist = true
if _, err := os.Stat(filename); os.IsNotExist(err) {
exist = false
}
return exist
}
//utf-8
//dim fso,file,read,string_arr(),count,string_finally
//Set shell = Wscript.createobject("wscript.shell")
//set fso=createobject("scripting.filesystemobject")
//Function Encode(filePath)
//Set stm = CreateObject("Adodb.Stream")
//stm.Type = 2
//stm.mode = 3
//stm.charset = "utf-8"
//stm.Open
//stm.LoadFromFile filePath
//Encode = stm.readtext
//stm.close
//End Function
//a = shell.run (Encode("c:\YLG_config.ini")+"\YuleClient.exe",0)
//Wscript.Sleep 3000
//wscript.quit
// cmd 命令如何文件显示扩展名
// reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced" /v HideFileExt /t reg_dword /d 00000000 /f
// 写配置文件
func WFile() {
var wireteString = "dim fso,file,read,string_arr(),count,string_finally" + "\r\n"
var wireteString2 = "Set shell = Wscript.createobject(\"wscript.shell\")" + "\r\n"
var wireteString3 = "set fso=createobject(\"scripting.filesystemobject\")" + "\r\n"
var wireteString4 = "Function Encode(filePath)" + "\r\n"
var wireteString5 = "Set stm = CreateObject(\"Adodb.Stream\")" + "\r\n"
var wireteString6 = "stm.Type = 2" + "\r\n"
var wireteString7 = "stm.mode = 3" + "\r\n"
var wireteString8 = "stm.charset = \"utf-8\"" + "\r\n"
var wireteString9 = "stm.Open" + "\r\n"
var wireteString10 = "stm.LoadFromFile filePath" + "\r\n"
var wireteString11 = "Encode = stm.readtext" + "\r\n"
var wireteString12 = "stm.close" + "\r\n"
var wireteString13 = "End Function" + "\r\n"
var wireteString14 = "a = shell.run (Encode(\"c:/YLG_config.ini\")+\"/YuleClient.exe\",0)" + "\r\n"
var wireteString15 = "Wscript.Sleep 3000" + "\r\n"
var wireteString16 = "wscript.quit" + "\r\n"
var filename = "C:/Windows/System32/auto.vbs"
var f *os.File
var err1 error
if checkFileIsExist(filename) { //如果文件存在
f, err1 = os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) //打开文件
fmt.Println("文件存在")
return
} else {
f, err1 = os.Create(filename) //创建文件
fmt.Println("文件不存在")
}
check(err1)
n, err1 := io.WriteString(f, wireteString) //写入文件(字符串)
check(err1)
fmt.Printf("写入 %d 个字节n", n)
io.WriteString(f, wireteString2) //写入文件(字符串)
io.WriteString(f, wireteString3) //写入文件(字符串)
io.WriteString(f, wireteString4) //写入文件(字符串)
io.WriteString(f, wireteString5) //写入文件(字符串)
io.WriteString(f, wireteString6) //写入文件(字符串)
io.WriteString(f, wireteString7) //写入文件(字符串)
io.WriteString(f, wireteString8) //写入文件(字符串)
io.WriteString(f, wireteString9) //写入文件(字符串)
io.WriteString(f, wireteString10) //写入文件(字符串)
io.WriteString(f, wireteString11) //写入文件(字符串)
io.WriteString(f, wireteString12) //写入文件(字符串)
io.WriteString(f, wireteString13) //写入文件(字符串)
io.WriteString(f, wireteString14) //写入文件(字符串)
io.WriteString(f, wireteString15) //写入文件(字符串)
io.WriteString(f, wireteString16) //写入文件(字符串)
return
}
// 写配置文件
func WFilebak() {
var wireteString = "dim fso,file,read,string_arr(),count,string_finally" + "\r\n"
var wireteString2 = "Set shell = Wscript.createobject(\"wscript.shell\")" + "\r\n"
var wireteString3 = "set fso=createobject(\"scripting.filesystemobject\")" + "\r\n"
var wireteString4 = "file=\"c:\\YLG_config.ini\"" + "\r\n"
var wireteString5 = "read=fso.opentextfile(file).readall" + "\r\n"
var wireteString6 = "set fso=nothing" + "\r\n"
var wireteString7 = "a = shell.run (read+\"\\YuleClient.exe\",0)" + "\r\n"
var wireteString8 = "Wscript.Sleep 3000" + "\r\n"
var wireteString9 = "wscript.quit" + "\r\n"
var filename = "C:/Windows/System32/auto.vbs"
var f *os.File
var err1 error
if checkFileIsExist(filename) { //如果文件存在
f, err1 = os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) //打开文件
fmt.Println("文件存在")
return
} else {
f, err1 = os.Create(filename) //创建文件
fmt.Println("文件不存在")
}
check(err1)
n, err1 := io.WriteString(f, wireteString) //写入文件(字符串)
check(err1)
fmt.Printf("写入 %d 个字节n", n)
io.WriteString(f, wireteString2) //写入文件(字符串)
io.WriteString(f, wireteString3) //写入文件(字符串)
io.WriteString(f, wireteString4) //写入文件(字符串)
io.WriteString(f, wireteString5) //写入文件(字符串)
io.WriteString(f, wireteString6) //写入文件(字符串)
io.WriteString(f, wireteString7) //写入文件(字符串)
io.WriteString(f, wireteString8) //写入文件(字符串)
io.WriteString(f, wireteString9) //写入文件(字符串)
return
}
// 写配置文件
func WFileexe() {
var wireteString = getCurrentPath()
var filename = "C:/YLG_config.ini"
var f *os.File
var err1 error
if checkFileIsExist(filename) { //如果文件存在
f, err1 = os.OpenFile(filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0666) //打开文件
fmt.Println("文件存在")
} else {
f, err1 = os.Create(filename) //创建文件
fmt.Println("文件不存在")
}
check(err1)
n, err1 := io.WriteString(f, wireteString) //写入文件(字符串)
check(err1)
fmt.Printf("写入 %d 个字节n", n)
return
}
//假如你要运行的程序名字为:"autorun.exe"使用命令为
//"reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /v AUTORUN /t REG_SZ /d C:\autorun.exe /f"
//(不包括引号)其中"C:\autorun.exe"为目标程序的路径.按着这样的命令就可以将你的程序添加到启动项中了
// RunEXE 参数---reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /v AUTORUN /t REG_SZ /d C:\autorun.exe /f
func RunEXE(strEXEName string) {
fmt.Println("开机启动")
//strPath := getCurrentPath()
strEXEName = "C:\\Windows\\System32\\auto.vbs"
arg := []string{"add", "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", "/v", "auto", "/t", "REG_SZ", "/d", strEXEName, "/f"}
cmd := exec.Command("reg", arg...)
d, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println(string(d))
return
}
// 隐藏调进程 参数---start /b notepad.exe
func YinCangEXE(strEXEName string) {
fmt.Println("隐藏进程")
cmd := exec.Command("auto.bat")
d, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println(string(d))
return
}
//// 隐藏调进程 参数---start /b notepad.exe
//func YinCangEXE(strEXEName string) {
// fmt.Println("隐藏进程")
// strPath := getCurrentPath()
// strPath = strPath + strEXEName
// cmd := exec.Command("auto.vbs")
// d, err := cmd.CombinedOutput()
// if err != nil {
// fmt.Println("Error:", err)
// return
// }
// fmt.Println(string(d))
// return
//}
// 启动exe 参数---账号|游戏名字|现场
func CallEXE(strGameName string, strIPandPort string, strGameNamedata string) {
fmt.Println("CallEXE 开始启动游戏")
// // arg := []string{strGameName, strIPandPort}
// // fmt.Println("------------", arg)
// // cmd := exec.Command("F:\\最新版本游戏\\test1\\test\\test.exe", arg...)
// strPath := getCurrentPath()
// strPath = strPath + "\\YULEGAME\\" + strGameNamedata + "\\" + strGameNamedata
// arg := []string{"start", strPath, strGameName, strIPandPort}
// fmt.Println("------------", arg)
// cmd := exec.Command("cmd", arg...)
// if err := cmd.Run(); err != nil {
// fmt.Println("Error: ", err)
// }
fmt.Println("轮播---->开始启动游戏。。。")
StrGameName = strGameNamedata
BKaiF = false
IsPlayerConut = 0
IsPlayer = ""
arg := []string{strGameName, strIPandPort}
fmt.Println("------------", arg)
// cmd := exec.Command("F:\\最新版本游戏\\test1\\test\\test.exe", arg...)
strPath := getCurrentPath()
strPath = strPath + "\\YULEGAME\\" + strGameNamedata + "\\" + strGameNamedata
cmd := exec.Command(strPath, arg...)
if err := cmd.Run(); err != nil {
fmt.Println("Error: ", err)
return
}
//cmd.CombinedOutput()
// _, err := cmd.CombinedOutput()
// if err != nil {
// fmt.Println("Error:", err)
// return
// }
return
}
// kill调进程 参数---taskkill /im notepad.exe /T /F
func KillEXE(strGameName string) bool {
fmt.Println("kill调进程游戏:", strGameName)
strGameName = strGameName + ".exe"
arg := []string{"/im", strGameName}
cmd := exec.Command("taskkill", arg...)
//d, err := cmd.CombinedOutput()
if err := cmd.Run(); err != nil {
fmt.Println("Error: ", err)
}
// if err != nil {
// fmt.Println("Error:", err)
// return false
// }
IsPlayerConutbakre = 0
//fmt.Println(string(d))
return true
}
// 远程重启主机 参数---shutdown -s -t 20
// 取消自动关机 shutdown -a
func ShutDownEXE() {
fmt.Println("远程主机")
arg := []string{"-s", "-t", "20"}
cmd := exec.Command("shutdown", arg...)
d, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("Error:", err)
glog.Info("err:", err.Error())
return
}
fmt.Println(string(d))
return
}
// 重启远程计算机
func ReShutDownEXE() {
fmt.Println("远程重启主机")
arg := []string{"-r", "-t", "20"}
cmd := exec.Command("shutdown", arg...)
d, err := cmd.CombinedOutput()
if err != nil {
fmt.Println("Error:", err)
glog.Info("err:", err.Error())
return
}
fmt.Println(string(d))
return
}
// 获取当前目录
func getCurrentPath() string {
if len(PathData) == 0 {
s, _ := exec.LookPath(os.Args[0])
i := strings.LastIndex(s, "\\")
path := string(s[0 : i+1])
PathData = path
return path
}
return PathData
}