refactor and testing

agent/tactical/api/api.go

@@ -1 +1,54 @@
 package api
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/amidaware/rmmagent/agent/tactical/config"
+	"github.com/amidaware/rmmagent/shared"
+	"github.com/go-resty/resty/v2"
+)
+
+var restyC resty.Client
+
+func init() {
+	ac := config.NewAgentConfig()
+	headers := make(map[string]string)
+	if len(ac.Token) > 0 {
+		headers["Content-Type"] = "application/json"
+		headers["Authorization"] = fmt.Sprintf("Token %s", ac.Token)
+	}
+
+	restyC := resty.New()
+	restyC.SetBaseURL(ac.BaseURL)
+	restyC.SetCloseConnection(true)
+	restyC.SetHeaders(headers)
+	restyC.SetTimeout(15 * time.Second)
+	restyC.SetDebug(shared.DEBUG)
+
+	if len(ac.Proxy) > 0 {
+		restyC.SetProxy(ac.Proxy)
+	}
+
+	if len(ac.Cert) > 0 {
+		restyC.SetRootCertificate(ac.Cert)
+	}
+}
+
+func PostPayload(payload interface{}, url string) error {
+	_, err := restyC.R().SetBody(payload).Post("/api/v3/syncmesh/")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetResult(result interface{}, url string) (*resty.Response, error) {
+	r, err := restyC.R().SetResult(result).Get(url)
+	if err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}

agent/tactical/checks/checks_windows.go

@@ -3,50 +3,45 @@ package checks
 import (
 	"encoding/json"
 	"fmt"
-	"runtime"
 	"sync"
 	"time"
 
 	"github.com/amidaware/rmmagent/agent/system"
+	"github.com/amidaware/rmmagent/agent/tactical/api"
 	"github.com/amidaware/rmmagent/agent/utils"
-	rmm "github.com/amidaware/rmmagent/shared"
 	ps "github.com/elastic/go-sysinfo"
 	"github.com/go-resty/resty/v2"
 )
 
-func CheckRunner(agentID string) {
+func CheckRunner(agentID string) error {
 	sleepDelay := utils.RandRange(14, 22)
-	//a.Logger.Debugf("CheckRunner() init sleeping for %v seconds", sleepDelay)
 	time.Sleep(time.Duration(sleepDelay) * time.Second)
 	for {
 		interval, err := GetCheckInterval(agentID)
 		if err == nil && !ChecksRunning() {
-			if runtime.GOOS == "windows" {
-				_, err = system.CMD(system.GetProgramEXE(), []string{"-m", "checkrunner"}, 600, false)
-				if err != nil {
-					//a.Logger.Errorln("Checkrunner RunChecks", err)
-				}
-			} else {
-				RunChecks(agentID, false)
+			_, err = system.CMD(system.GetProgramEXE(), []string{"-m", "checkrunner"}, 600, false)
+			if err != nil {
+				return err
 			}
 		}
 
-		//a.Logger.Debugln("Checkrunner sleeping for", interval)
 		time.Sleep(time.Duration(interval) * time.Second)
 	}
+
+	return nil
 }
 
 func GetCheckInterval(agentID string) (int, error) {
-	r, err := a.rClient.R().SetResult(&rmm.CheckInfo{}).Get(fmt.Sprintf("/api/v3/%s/checkinterval/", a.AgentID))
+	r, err := api.GetResult(CheckInfo{}, fmt.Sprintf("/api/v3/%s/checkinterval/", agentID))
 	if err != nil {
-		a.Logger.Debugln(err)
 		return 120, err
 	}
+
 	if r.IsError() {
-		a.Logger.Debugln("Checkinterval response code:", r.StatusCode())
 		return 120, fmt.Errorf("checkinterval response code: %v", r.StatusCode())
 	}
-	interval := r.Result().(*rmm.CheckInfo).Interval
+
+	interval := r.Result().(*CheckInfo).Interval
 	return interval, nil
 }
 
@@ -90,7 +85,7 @@ func RunChecks(agentID string, force bool) error {
 	} else {
 		url = fmt.Sprintf("/api/v3/%s/checkrunner/", agentID)
 	}
-	
+
 	r, err := a.rClient.R().Get(url)
 	if err != nil {
 		//a.Logger.Debugln(err)
@@ -177,4 +172,4 @@ func RunChecks(agentID string, force bool) error {
 
 	wg.Wait()
 	return nil
-}
+}

agent/tactical/checks/structs.go

@@ -0,0 +1,6 @@
+package checks
+
+type CheckInfo struct {
+	AgentPK  int `json:"agent"`
+	Interval int `json:"check_interval"`
+}

agent/tactical/config/config_windows.go

@@ -0,0 +1,37 @@
+package config
+
+import (
+	"strconv"
+
+	"golang.org/x/sys/windows/registry"
+)
+
+func NewAgentConfig() *AgentConfig {
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\TacticalRMM`, registry.ALL_ACCESS)
+
+	if err != nil {
+		return &AgentConfig{}
+	}
+
+	baseurl, _, _ := k.GetStringValue("BaseURL")
+	agentid, _, _ := k.GetStringValue("AgentID")
+	apiurl, _, _ := k.GetStringValue("ApiURL")
+	token, _, _ := k.GetStringValue("Token")
+	agentpk, _, _ := k.GetStringValue("AgentPK")
+	pk, _ := strconv.Atoi(agentpk)
+	cert, _, _ := k.GetStringValue("Cert")
+	proxy, _, _ := k.GetStringValue("Proxy")
+	customMeshDir, _, _ := k.GetStringValue("MeshDir")
+
+	return &AgentConfig{
+		BaseURL:       baseurl,
+		AgentID:       agentid,
+		APIURL:        apiurl,
+		Token:         token,
+		AgentPK:       agentpk,
+		PK:            pk,
+		Cert:          cert,
+		Proxy:         proxy,
+		CustomMeshDir: customMeshDir,
+	}
+}

agent/tactical/config/structs.go

@@ -0,0 +1,13 @@
+package config
+
+type AgentConfig struct {
+	BaseURL       string
+	AgentID       string
+	APIURL        string
+	Token         string
+	AgentPK       string
+	PK            int
+	Cert          string
+	Proxy         string
+	CustomMeshDir string
+}

agent/tactical/mesh/mesh.go

@@ -0,0 +1,26 @@
+package mesh
+
+import (
+	"github.com/amidaware/rmmagent/agent/tactical/api"
+	"github.com/amidaware/rmmagent/agent/utils"
+)
+
+func SyncMeshNodeID(agentID string) error {
+	id, err := GetMeshNodeID()
+	if err != nil {
+		return err
+	}
+
+	payload := MeshNodeID{
+		Func:    "syncmesh",
+		Agentid: agentID,
+		NodeID:  utils.StripAll(id),
+	}
+
+	err = api.PostPayload(payload, "/api/v3/syncmesh/")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

agent/tactical/mesh/mesh_windows.go

@@ -0,0 +1,123 @@
+package mesh
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/amidaware/rmmagent/agent/system"
+	"github.com/amidaware/rmmagent/agent/tactical/config"
+	"github.com/amidaware/rmmagent/agent/utils"
+	ps "github.com/elastic/go-sysinfo"
+)
+
+// ForceKillMesh kills all mesh agent related processes
+func ForceKillMesh() error {
+	pids := make([]int, 0)
+	procs, err := ps.Processes()
+	if err != nil {
+		return err
+	}
+
+	for _, process := range procs {
+		p, err := process.Info()
+		if err != nil {
+			continue
+		}
+		if strings.Contains(strings.ToLower(p.Name), "meshagent") {
+			pids = append(pids, p.PID)
+		}
+	}
+
+	for _, pid := range pids {
+		if err := system.KillProc(int32(pid)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func GetMeshNodeID() (string, error) {
+	out, err := system.CMD(getMeshBinLocation(), []string{"-nodeid"}, 10, false)
+	if err != nil {
+		return "", err
+	}
+
+	stdout := out[0]
+	stderr := out[1]
+
+	if stderr != "" {
+		return "", err
+	}
+
+	if stdout == "" || strings.Contains(strings.ToLower(utils.StripAll(stdout)), "not defined") {
+		return "", errors.New("failed to get mesh node id")
+	}
+
+	return stdout, nil
+}
+
+func getMeshBinLocation() string {
+	ac := config.NewAgentConfig()
+	var MeshSysBin string
+	if len(ac.CustomMeshDir) > 0 {
+		MeshSysBin = filepath.Join(ac.CustomMeshDir, "MeshAgent.exe")
+	} else {
+		MeshSysBin = filepath.Join(os.Getenv("ProgramFiles"), "Mesh Agent", "MeshAgent.exe")
+	}
+
+	return MeshSysBin
+}
+
+func installMesh(meshbin, exe, proxy string) (string, error) {
+	var meshNodeID string
+	meshInstallArgs := []string{"-fullinstall"}
+	if len(proxy) > 0 {
+		meshProxy := fmt.Sprintf("--WebProxy=%s", proxy)
+		meshInstallArgs = append(meshInstallArgs, meshProxy)
+	}
+
+	//a.Logger.Debugln("Mesh install args:", meshInstallArgs)
+	meshOut, meshErr := system.CMD(meshbin, meshInstallArgs, int(90), false)
+	if meshErr != nil {
+		fmt.Println(meshOut[0])
+		fmt.Println(meshOut[1])
+		fmt.Println(meshErr)
+	}
+
+	fmt.Println(meshOut)
+	//a.Logger.Debugln("Sleeping for 5")
+	time.Sleep(5 * time.Second)
+
+	meshSuccess := false
+
+	for !meshSuccess {
+		//a.Logger.Debugln("Getting mesh node id")
+		pMesh, pErr := system.CMD(exe, []string{"-nodeid"}, int(30), false)
+		if pErr != nil {
+			//a.Logger.Errorln(pErr)
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		if pMesh[1] != "" {
+			//a.Logger.Errorln(pMesh[1])
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		meshNodeID = utils.StripAll(pMesh[0])
+		//a.Logger.Debugln("Node id:", meshNodeID)
+		if strings.Contains(strings.ToLower(meshNodeID), "not defined") {
+			//a.Logger.Errorln(meshNodeID)
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		meshSuccess = true
+	}
+
+	return meshNodeID, nil
+}

agent/tactical/mesh/structs.go

@@ -0,0 +1,7 @@
+package mesh
+
+type MeshNodeID struct {
+	Func    string `json:"func"`
+	Agentid string `json:"agent_id"`
+	NodeID  string `json:"nodeid"`
+}

agent/tactical/tactical.go

@@ -1,46 +1 @@
 package tactical
-
-import (
-	"time"
-
-	"github.com/amidaware/rmmagent/agent/utils"
-	"github.com/amidaware/rmmagent/shared"
-	"github.com/go-resty/resty/v2"
-)
-
-func PostRequest(url string, body interface{}, timeout time.Duration) (resty.Response, error) {
-	agentConfig := NewAgentConfig()
-	client := resty.New()
-	client.SetBaseURL(agentConfig.BaseURL)
-	client.SetTimeout(timeout * time.Second)
-	client.SetCloseConnection(true)
-	if len(agentConfig.Proxy) > 0 {
-		client.SetProxy(agentConfig.Proxy)
-	}
-
-	if shared.DEBUG {
-		client.SetDebug(true)
-	}
-
-	response, err := client.R().SetBody(body).Post(url)
-
-	return *response, err
-}
-
-func SyncMeshNodeID() bool {
-	id, err := GetMeshNodeID()
-	if err != nil {
-		//a.Logger.Errorln("SyncMeshNodeID() getMeshNodeID()", err)
-		return false
-	}
-
-	agentConfig := NewAgentConfig()
-	payload := shared.MeshNodeID{
-		Func:    "syncmesh",
-		Agentid: agentConfig.AgentID,
-		NodeID:  utils.StripAll(id),
-	}
-
-	_, err = PostRequest("/api/v3/syncmesh/", payload, 15)
-	return err == nil
-}

agent/tactical/tactical_windows.go

@@ -1,21 +1,19 @@
 package tactical
 
 import (
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
 	"time"
 
 	"github.com/amidaware/rmmagent/agent/patching"
 	"github.com/amidaware/rmmagent/agent/services"
-	"github.com/amidaware/rmmagent/agent/software"
 	"github.com/amidaware/rmmagent/agent/system"
+	"github.com/amidaware/rmmagent/agent/tactical/config"
 	"github.com/amidaware/rmmagent/agent/tactical/rpc"
 	"github.com/amidaware/rmmagent/agent/tasks"
 	"github.com/amidaware/rmmagent/agent/utils"
@@ -27,87 +25,6 @@ import (
 	"golang.org/x/sys/windows/registry"
 )
 
-func GetMeshBinary() string {
-	var MeshSysBin string
-	ac := NewAgentConfig()
-	if len(ac.CustomMeshDir) > 0 {
-		MeshSysBin = filepath.Join(ac.CustomMeshDir, "MeshAgent.exe")
-	} else {
-		MeshSysBin = filepath.Join(os.Getenv("ProgramFiles"), "Mesh Agent", "MeshAgent.exe")
-	}
-
-	return MeshSysBin
-}
-
-func NewAgentConfig() *rmm.AgentConfig {
-	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\TacticalRMM`, registry.ALL_ACCESS)
-
-	if err != nil {
-		return &rmm.AgentConfig{}
-	}
-
-	baseurl, _, _ := k.GetStringValue("BaseURL")
-	agentid, _, _ := k.GetStringValue("AgentID")
-	apiurl, _, _ := k.GetStringValue("ApiURL")
-	token, _, _ := k.GetStringValue("Token")
-	agentpk, _, _ := k.GetStringValue("AgentPK")
-	pk, _ := strconv.Atoi(agentpk)
-	cert, _, _ := k.GetStringValue("Cert")
-	proxy, _, _ := k.GetStringValue("Proxy")
-	customMeshDir, _, _ := k.GetStringValue("MeshDir")
-
-	return &rmm.AgentConfig{
-		BaseURL:       baseurl,
-		AgentID:       agentid,
-		APIURL:        apiurl,
-		Token:         token,
-		AgentPK:       agentpk,
-		PK:            pk,
-		Cert:          cert,
-		Proxy:         proxy,
-		CustomMeshDir: customMeshDir,
-	}
-}
-
-func GetMeshNodeID() (string, error) {
-	out, err := system.CMD(GetMeshBinary(), []string{"-nodeid"}, 10, false)
-	if err != nil {
-		//a.Logger.Debugln(err)
-		return "", err
-	}
-
-	stdout := out[0]
-	stderr := out[1]
-
-	if stderr != "" {
-		//a.Logger.Debugln(stderr)
-		return "", err
-	}
-
-	if stdout == "" || strings.Contains(strings.ToLower(utils.StripAll(stdout)), "not defined") {
-		//a.Logger.Debugln("Failed getting mesh node id", stdout)
-		return "", errors.New("failed to get mesh node id")
-	}
-
-	return stdout, nil
-}
-
-func SendSoftware() {
-	sw := software.GetInstalledSoftware()
-	//a.Logger.Debugln(sw)
-
-	config := NewAgentConfig()
-	payload := map[string]interface{}{
-		"agent_id": config.AgentID,
-		"software": sw,
-	}
-
-	_, err := PostRequest("/api/v3/software/", payload, 15)
-	if err != nil {
-		//a.Logger.Debugln(err)
-	}
-}
-
 func UninstallCleanup() {
 	registry.DeleteKey(registry.LOCAL_MACHINE, `SOFTWARE\TacticalRMM`)
 	patching.PatchMgmnt(false)
@@ -123,7 +40,7 @@ func AgentUpdate(url, inno, version string) {
 	//a.Logger.Infof("Agent updating from %s to %s", a.Version, version)
 	//a.Logger.Infoln("Downloading agent update from", url)
 
-	config := NewAgentConfig()
+	config := config.NewAgentConfig()
 	rClient := resty.New()
 	rClient.SetCloseConnection(true)
 	rClient.SetTimeout(15 * time.Minute)