MyRCON

package main

import (
    "flag"
    "fmt"
    "net"
    "os"
    "os/exec"
    "regexp"
    "runtime"

    "github.com/common-nighthawk/go-figure"
)

// Адрес вашего сервера
var host   string = "localhost:27015"
// RCON пароль сервера
var passwd string = "123123"
// Команда по умолчанию
var command string = "status"

var app_name string = "MyRCON"

var clear map[string]func()

func init() {
    clear = make(map[string]func())
    clear["linux"] = func() {
        cmd := exec.Command("clear")
        cmd.Stdout = os.Stdout
        cmd.Run()
    }
    clear["windows"] = func() {
        cmd := exec.Command("cmd", "/c", "cls")
        cmd.Stdout = os.Stdout
        cmd.Run()
    }
}

func CallClear() {
    value, ok := clear[runtime.GOOS]
    if ok {
        value()
    } else {
        panic("Your platform is unsupported! I can't clear terminal screen :(")
    }
}

func main() {
    CallClear()
  
    myFigure := figure.NewColorFigure(app_name, "", "red", true)
    myFigure.Print()
    fmt.Println("\n")
    
    rconHost := flag.String("s", host, "server host")
    rconPassword := flag.String("r", passwd, "rcon password")
    rconCommand := flag.String("c", command, "remote command")
    flag.Usage = usageHelp
    flag.Parse()

    if len(os.Args) <= 0 {
        usageHelp()
        return
    }

    serverConnection, err := net.Dial("udp", *rconHost)
    if err != nil {
        fmt.Errorf("Error trying to connect to %v ==> %v", *rconHost, err.Error())
        return
    }
    defer serverConnection.Close()

    fmt.Println(sendRCON(serverConnection, *rconPassword, *rconCommand))

}

func prepareCommand(command string) []byte {
    var bytesSequence []byte
    bytesSequence = append(bytesSequence, []byte{255, 255, 255, 255}...)
    bytesSequence = append(bytesSequence, []byte(command)...)
    return bytesSequence
}

func sendRCON(serverConnection net.Conn, rconPassword string, rconCommand string) string {
    bufferSend := prepareCommand("challenge rcon\n")
    _, err := serverConnection.Write(bufferSend)
    if err != nil {
        fmt.Errorf("Error trying to request challenge to %v ==> %v",serverConnection.RemoteAddr().String(), err.Error())
        return "Error"
    }

    var bufferReceive [4000]byte
    _, err = serverConnection.Read(bufferReceive[:])
    if err != nil {
        fmt.Errorf("Error trying to receive challenge from %v ==> %v",
            serverConnection.RemoteAddr().String(), err.Error())
        return "Error"
    }

    challengeRCON := string(bufferReceive[:])
    challengeRCONSplitted := regexp.MustCompile("[^\\d]").Split(challengeRCON, -1)[:]
    challengeRCON = ""
    for i := 0; i < len(challengeRCONSplitted); i++ {
        challengeRCON += challengeRCONSplitted[i]
    }

    commandToSend := "rcon \"" + challengeRCON + "\" " + rconPassword + " " + rconCommand + "\n"

    bufferSend = prepareCommand(commandToSend)

    _, err = serverConnection.Write(bufferSend)
    if err != nil {
        fmt.Errorf("Error trying to send the command to %v ==> %v",
            serverConnection.RemoteAddr().String(), err.Error())
        return "Error"
    }

    _, err = serverConnection.Read(bufferReceive[:])
    if err != nil {
        fmt.Errorf("Error trying to get the command result from %v ==> %v",
            serverConnection.RemoteAddr().String(), err.Error())
        return "Error"
    }

    var stringResponse string
    if bufferReceive[0] == 255 && bufferReceive[1] == 255 &&
        bufferReceive[2] == 255 && bufferReceive[3] == 255 && bufferReceive[4] == 'l' {
        stringResponse = string(bufferReceive[5:])
    } else {
        stringResponse = string(bufferReceive[:])
    }
    return stringResponse
}


func usageHelp() {
    //flag.PrintDefaults()
    fmt.Println(" Default server: " + host + "\n")
    fmt.Println(" Usage: -s [server:port] -r [rcon_password] -c [command]\n")
    
}

#!/bin/bash

# set -e

MyRCON="./myrcon"
RCON_LOG="/tmp/myrcon.log"
USER="Утилизатор"
MAP="de_dust2"
MAP_C=$(${MyRCON} -c status | sed -n 12,12p | grep ${MAP})

if [[ ! -f ${RCON_LOG} ]]; then
touch ${RCON_LOG}
fi

# Если на сервер зашел игрок под ником Утилизатор, меняем карту на ${MAP} при условии что карта неактивна.
if [[ ${MAP_C} != ${MAP} ]]; then
    ${MyRCON} -c status | grep "${USER}" >/dev/null
        if [ $? -eq 0 ]; then
            ${MyRCON} -с amx_map ${MAP}
            exit
        fi
fi

# Если на сервере никого нет, то меняем карту на ${MAP} при условии что карта неактивна.
${MyRCON} -c stats > ${RCON_LOG}
STATS=$(cat ${RCON_LOG} | sed -n 10,10p | grep [0-9] | awk '{print $7}')

if [[ ${MAP_C} != ${MAP} ]]; then
        if [[ ${STATS} == 0 ]]; then
            ${MyRCON} -с amx_map ${MAP}
            exit
        fi
fi