began adding macos service/daemon

netclient/functions/checkin.go

@@ -3,7 +3,6 @@ package functions
 import (
 	"encoding/json"
 	"errors"
-	"log"
 	"os"
 	"runtime"
 	"strings"
@@ -13,7 +12,7 @@ import (
 	"github.com/gravitl/netmaker/netclient/auth"
 	"github.com/gravitl/netmaker/netclient/config"
 	"github.com/gravitl/netmaker/netclient/local"
-	"github.com/gravitl/netmaker/netclient/netclientutils"
+	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/netclient/wireguard"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	"google.golang.org/grpc"
@@ -30,37 +29,37 @@ func checkIP(node *models.Node, servercfg config.ServerConfig, cliconf config.Cl
 	var err error
 	if node.Roaming == "yes" && node.IsStatic != "yes" {
 		if node.IsLocal == "no" {
-			extIP, err := netclientutils.GetPublicIP()
+			extIP, err := ncutils.GetPublicIP()
 			if err != nil {
-				log.Println("error encountered checking ip addresses:", err)
+				ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
 			}
 			if node.Endpoint != extIP && extIP != "" {
-				log.Println("Endpoint has changed from " +
-					node.Endpoint + " to " + extIP)
-				log.Println("Updating address")
+				ncutils.PrintLog("endpoint has changed from "+
+					node.Endpoint+" to "+extIP, 1)
+				ncutils.PrintLog("updating address", 1)
 				node.Endpoint = extIP
 				ipchange = true
 			}
 			intIP, err := getPrivateAddr()
 			if err != nil {
-				log.Println("error encountered checking ip addresses:", err)
+				ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
 			}
 			if node.LocalAddress != intIP && intIP != "" {
-				log.Println("Local Address has changed from " +
-					node.LocalAddress + " to " + intIP)
-				log.Println("Updating address")
+				ncutils.PrintLog("local Address has changed from "+
+					node.LocalAddress+" to "+intIP, 1)
+				ncutils.PrintLog("updating address", 1)
 				node.LocalAddress = intIP
 				ipchange = true
 			}
 		} else {
-			localIP, err := netclientutils.GetLocalIP(node.LocalRange)
+			localIP, err := ncutils.GetLocalIP(node.LocalRange)
 			if err != nil {
-				log.Println("error encountered checking ip addresses:", err)
+				ncutils.PrintLog("error encountered checking ip addresses: "+err.Error(), 1)
 			}
 			if node.Endpoint != localIP && localIP != "" {
-				log.Println("Endpoint has changed from " +
-					node.Endpoint + " to " + localIP)
-				log.Println("Updating address")
+				ncutils.PrintLog("endpoint has changed from "+
+					node.Endpoint+" to "+localIP, 1)
+				ncutils.PrintLog("updating address", 1)
 				node.Endpoint = localIP
 				node.LocalAddress = localIP
 				ipchange = true
@@ -70,12 +69,12 @@ func checkIP(node *models.Node, servercfg config.ServerConfig, cliconf config.Cl
 	if ipchange {
 		err = config.ModConfig(node)
 		if err != nil {
-			log.Println("Error:", err)
+			ncutils.PrintLog("error modifying config file: "+err.Error(), 1)
 			return false
 		}
 		err = wireguard.SetWGConfig(network, false)
 		if err != nil {
-			log.Println("Error:", err)
+			ncutils.PrintLog("error setting wireguard config: "+err.Error(), 1)
 			return false
 		}
 	}
@@ -96,14 +95,14 @@ func checkNodeActions(node *models.Node, networkName string, servercfg config.Se
 		node.IsStatic != "yes" {
 		err := wireguard.SetWGKeyConfig(networkName, servercfg.GRPCAddress)
 		if err != nil {
-			log.Println("Unable to process reset keys request:", err)
+			ncutils.PrintLog("unable to process reset keys request: "+err.Error(), 1)
 			return ""
 		}
 	}
 	if node.Action == models.NODE_DELETE || localNode.Action == models.NODE_DELETE {
 		err := RemoveLocalInstance(cfg, networkName)
 		if err != nil {
-			log.Println("Error:", err)
+			ncutils.PrintLog("error deleting locally: "+err.Error(), 1)
 		}
 		return models.NODE_DELETE
 	}
@@ -161,22 +160,22 @@ func Pull(network string, manual bool) (*models.Node, error) {
 	servercfg := cfg.Server
 	var header metadata.MD
 
-	if cfg.Node.IPForwarding == "yes" && !netclientutils.IsWindows() {
+	if cfg.Node.IPForwarding == "yes" && !ncutils.IsWindows() {
 		if err = local.SetIPForwarding(); err != nil {
 			return nil, err
 		}
 	}
 	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		netclientutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
 	if err != nil {
-		log.Println("Cant dial GRPC server:", err)
+		ncutils.PrintLog("Cant dial GRPC server: "+err.Error(), 1)
 		return nil, err
 	}
 	wcclient := nodepb.NewNodeServiceClient(conn)
 
 	ctx, err := auth.SetJWT(wcclient, network)
 	if err != nil {
-		log.Println("Failed to authenticate:", err)
+		ncutils.PrintLog("Failed to authenticate: "+err.Error(), 1)
 		return nil, err
 	}
 
@@ -198,7 +197,7 @@ func Pull(network string, manual bool) (*models.Node, error) {
 		// check for interface change
 		if cfg.Node.Interface != resNode.Interface {
 			if err = DeleteInterface(cfg.Node.Interface, cfg.Node.PostDown); err != nil {
-				log.Println("could not delete old interface", cfg.Node.Interface)
+				ncutils.PrintLog("could not delete old interface "+cfg.Node.Interface, 1)
 			}
 		}
 		resNode.PullChanges = "no"
@@ -230,7 +229,7 @@ func Pull(network string, manual bool) (*models.Node, error) {
 			}
 		}
 	}
-	if netclientutils.IsLinux() {
+	if ncutils.IsLinux() {
 		setDNS(&resNode, servercfg, &cfg.Node)
 	}
 
@@ -249,16 +248,16 @@ func Push(network string) error {
 
 	var wcclient nodepb.NodeServiceClient
 	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		netclientutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
 	if err != nil {
-		log.Println("Cant dial GRPC server:", err)
+		ncutils.PrintLog("Cant dial GRPC server: "+err.Error(), 1)
 		return err
 	}
 	wcclient = nodepb.NewNodeServiceClient(conn)
 
 	ctx, err := auth.SetJWT(wcclient, network)
 	if err != nil {
-		log.Println("Failed to authenticate:", err)
+		ncutils.PrintLog("Failed to authenticate with server: "+err.Error(), 1)
 		return err
 	}
 	if postnode.IsPending != "yes" {

netclient/functions/common.go

@@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"log"
 	"net"
+	"os"
 	"os/exec"
 	"strings"
 
@@ -15,8 +16,9 @@ import (
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/auth"
 	"github.com/gravitl/netmaker/netclient/config"
-	"github.com/gravitl/netmaker/netclient/local"
-	"github.com/gravitl/netmaker/netclient/netclientutils"
+	"github.com/gravitl/netmaker/netclient/daemon"
+	"github.com/gravitl/netmaker/netclient/ncutils"
+	"github.com/gravitl/netmaker/netclient/wireguard"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
@@ -92,21 +94,21 @@ func GetNode(network string) models.Node {
 func Uninstall() error {
 	networks, err := GetNetworks()
 	if err != nil {
-		log.Println("unable to retrieve networks: ", err)
-		log.Println("continuing uninstall without leaving networks")
+		ncutils.PrintLog("unable to retrieve networks: "+err.Error(), 1)
+		ncutils.PrintLog("continuing uninstall without leaving networks", 1)
 	} else {
 		for _, network := range networks {
 			err = LeaveNetwork(network)
 			if err != nil {
-				log.Println("Encounter issue leaving network "+network+": ", err)
+				ncutils.PrintLog("Encounter issue leaving network "+network+": "+err.Error(), 1)
 			}
 		}
 	}
 	// clean up OS specific stuff
-	if netclientutils.IsWindows() {
-		local.CleanupWindows()
-	} else if netclientutils.IsWindows() {
-		local.CleanupMac()
+	if ncutils.IsWindows() {
+		daemon.CleanupWindows()
+	} else if ncutils.IsWindows() {
+		daemon.CleanupMac()
 	}
 
 	return err
@@ -123,7 +125,7 @@ func LeaveNetwork(network string) error {
 
 	var wcclient nodepb.NodeServiceClient
 	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
-		netclientutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
 	if err != nil {
 		log.Printf("Unable to establish client connection to "+servercfg.GRPCAddress+": %v", err)
 	} else {
@@ -134,9 +136,9 @@ func LeaveNetwork(network string) error {
 		if err != nil {
 			log.Printf("Failed to authenticate: %v", err)
 		} else {
-			if netclientutils.IsWindows() {
-				local.RemoveWindowsConf(node.Interface)
-				log.Println("removed Windows tunnel " + node.Interface)
+			if !ncutils.IsKernel() {
+				//wireguard.RemoveConf(node.Interface, true)
+				//ncutils.PrintLog("removed network tunnel "+node.Interface, 1)
 			}
 			node.SetID()
 			var header metadata.MD
@@ -149,10 +151,9 @@ func LeaveNetwork(network string) error {
 				grpc.Header(&header),
 			)
 			if err != nil {
-				log.Printf("Encountered error deleting node: %v", err)
-				log.Println(err)
+				ncutils.PrintLog("encountered error deleting node: "+err.Error(), 1)
 			} else {
-				log.Println("Removed machine from " + node.Network + " network on remote server")
+				ncutils.PrintLog("removed machine from "+node.Network+" network on remote server", 1)
 			}
 		}
 	}
@@ -160,17 +161,19 @@ func LeaveNetwork(network string) error {
 }
 
 func RemoveLocalInstance(cfg *config.ClientConfig, networkName string) error {
-	err := local.WipeLocal(networkName)
+	err := WipeLocal(networkName)
 	if err != nil {
-		log.Printf("Unable to wipe local config: %v", err)
+		ncutils.PrintLog("unable to wipe local config", 1)
 	} else {
-		log.Println("Removed " + networkName + " network locally")
+		ncutils.PrintLog("removed "+networkName+" network locally", 1)
 	}
 	if cfg.Daemon != "off" {
-		if netclientutils.IsWindows() {
+		if ncutils.IsWindows() {
 			// TODO: Remove job?
+		} else if ncutils.IsMac() {
+			//TODO: Delete mac daemon
 		} else {
-			err = local.RemoveSystemDServices(networkName)
+			err = daemon.RemoveSystemDServices(networkName)
 		}
 	}
 	return err
@@ -178,18 +181,18 @@ func RemoveLocalInstance(cfg *config.ClientConfig, networkName string) error {
 
 func DeleteInterface(ifacename string, postdown string) error {
 	var err error
-	if netclientutils.IsWindows() {
-		err = local.RemoveWindowsConf(ifacename)
+	if !ncutils.IsKernel() {
+		err = wireguard.RemoveConf(ifacename, true)
 	} else {
 		ipExec, errN := exec.LookPath("ip")
 		err = errN
 		if err != nil {
-			log.Println(err)
+			ncutils.PrintLog(err.Error(), 1)
 		}
-		_, err = local.RunCmd(ipExec+" link del "+ifacename, false)
+		_, err = ncutils.RunCmd(ipExec+" link del "+ifacename, false)
 		if postdown != "" {
 			runcmds := strings.Split(postdown, "; ")
-			err = local.RunCmds(runcmds, true)
+			err = ncutils.RunCmds(runcmds, true)
 		}
 	}
 	return err
@@ -212,9 +215,9 @@ func List() error {
 					"PrivateIPv6":    cfg.Node.Address6,
 					"PublicEndpoint": cfg.Node.Endpoint,
 				})
-			log.Println(network + ": " + string(jsoncfg))
+			fmt.Println(network + ": " + string(jsoncfg))
 		} else {
-			log.Println(network + ": Could not retrieve network configuration.")
+			ncutils.PrintLog(network+": Could not retrieve network configuration.", 1)
 		}
 	}
 	return nil
@@ -222,7 +225,7 @@ func List() error {
 
 func GetNetworks() ([]string, error) {
 	var networks []string
-	files, err := ioutil.ReadDir(netclientutils.GetNetclientPath())
+	files, err := ioutil.ReadDir(ncutils.GetNetclientPath())
 	if err != nil {
 		return networks, err
 	}
@@ -247,3 +250,107 @@ func stringAfter(original string, substring string) string {
 	}
 	return original[adjustedPosition:len(original)]
 }
+
+func WipeLocal(network string) error {
+	cfg, err := config.ReadConfig(network)
+	if err != nil {
+		return err
+	}
+	nodecfg := cfg.Node
+	ifacename := nodecfg.Interface
+
+	if ifacename != "" {
+		if !ncutils.IsKernel() {
+			if err = wireguard.RemoveConf(ifacename, true); err == nil {
+				ncutils.PrintLog("removed WireGuard interface: "+ifacename, 1)
+			}
+		} else {
+			ipExec, err := exec.LookPath("ip")
+			if err != nil {
+				return err
+			}
+			out, err := ncutils.RunCmd(ipExec+" link del "+ifacename, false)
+			dontprint := strings.Contains(out, "does not exist") || strings.Contains(out, "Cannot find device")
+			if err != nil && !dontprint {
+				ncutils.PrintLog("error running command: "+ipExec+" link del "+ifacename, 1)
+				ncutils.PrintLog(out, 1)
+			}
+			if nodecfg.PostDown != "" {
+				runcmds := strings.Split(nodecfg.PostDown, "; ")
+				_ = ncutils.RunCmds(runcmds, false)
+			}
+		}
+	}
+	home := ncutils.GetNetclientPathSpecific()
+	if ncutils.FileExists(home + "netconfig-" + network) {
+		_ = os.Remove(home + "netconfig-" + network)
+	}
+	if ncutils.FileExists(home + "nettoken-" + network) {
+		_ = os.Remove(home + "nettoken-" + network)
+	}
+	if ncutils.FileExists(home + "secret-" + network) {
+		_ = os.Remove(home + "secret-" + network)
+	}
+	if ncutils.FileExists(home + "wgkey-" + network) {
+		_ = os.Remove(home + "wgkey-" + network)
+	}
+	if ncutils.FileExists(home + "nm-" + network + ".conf") {
+		_ = os.Remove(home + "nm-" + network + ".conf")
+	}
+	return err
+}
+
+func getLocalIP(node models.Node) string {
+
+	var local string
+
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return local
+	}
+	_, localrange, err := net.ParseCIDR(node.LocalRange)
+	if err != nil {
+		return local
+	}
+
+	found := false
+	for _, i := range ifaces {
+		if i.Flags&net.FlagUp == 0 {
+			continue // interface down
+		}
+		if i.Flags&net.FlagLoopback != 0 {
+			continue // loopback interface
+		}
+		addrs, err := i.Addrs()
+		if err != nil {
+			return local
+		}
+		for _, addr := range addrs {
+			var ip net.IP
+			switch v := addr.(type) {
+			case *net.IPNet:
+				if !found {
+					ip = v.IP
+					local = ip.String()
+					if node.IsLocal == "yes" {
+						found = localrange.Contains(ip)
+					} else {
+						found = true
+					}
+				}
+			case *net.IPAddr:
+				if !found {
+					ip = v.IP
+					local = ip.String()
+					if node.IsLocal == "yes" {
+						found = localrange.Contains(ip)
+
+					} else {
+						found = true
+					}
+				}
+			}
+		}
+	}
+	return local
+}

netclient/functions/install.go

@@ -1,13 +0,0 @@
-package functions
-
-import (
-	"github.com/gravitl/netmaker/netclient/config"
-	"github.com/gravitl/netmaker/netclient/local"
-)
-
-func InstallDaemon(cfg config.ClientConfig) error {
-
-	var err error
-	err = local.ConfigureSystemD(cfg.Network)
-	return err
-}

netclient/functions/join.go

@@ -11,8 +11,9 @@ import (
 	"github.com/gravitl/netmaker/models"
 	"github.com/gravitl/netmaker/netclient/auth"
 	"github.com/gravitl/netmaker/netclient/config"
+	"github.com/gravitl/netmaker/netclient/daemon"
 	"github.com/gravitl/netmaker/netclient/local"
-	"github.com/gravitl/netmaker/netclient/netclientutils"
+	"github.com/gravitl/netmaker/netclient/ncutils"
 	"github.com/gravitl/netmaker/netclient/server"
 	"github.com/gravitl/netmaker/netclient/wireguard"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
@@ -27,7 +28,7 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 		return err
 	}
 
-	netclientutils.Log("attempting to join " + cfg.Network + " at " + cfg.Server.GRPCAddress)
+	ncutils.Log("joining " + cfg.Network + " at " + cfg.Server.GRPCAddress)
 	err := config.Write(&cfg, cfg.Network)
 	if err != nil {
 		return err
@@ -42,20 +43,20 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 		cfg.Node.LocalAddress = getLocalIP(cfg.Node)
 	}
 	if cfg.Node.Password == "" {
-		cfg.Node.Password = netclientutils.GenPass()
+		cfg.Node.Password = ncutils.GenPass()
 	}
 	auth.StoreSecret(cfg.Node.Password, cfg.Node.Network)
 
-	// set endpoint if blank. set to local if local net, retrieve from function if not 
+	// set endpoint if blank. set to local if local net, retrieve from function if not
 	if cfg.Node.Endpoint == "" {
 		if cfg.Node.IsLocal == "yes" && cfg.Node.LocalAddress != "" {
 			cfg.Node.Endpoint = cfg.Node.LocalAddress
 		} else {
-			cfg.Node.Endpoint, err = netclientutils.GetPublicIP()
+			cfg.Node.Endpoint, err = ncutils.GetPublicIP()
 
 		}
 		if err != nil || cfg.Node.Endpoint == "" {
-			netclientutils.Log("Error setting cfg.Node.Endpoint.")
+			ncutils.Log("Error setting cfg.Node.Endpoint.")
 			return err
 		}
 	}
@@ -71,7 +72,7 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 
 	// Find and set node MacAddress
 	if cfg.Node.MacAddress == "" {
-		macs, err := netclientutils.GetMacAddr()
+		macs, err := ncutils.GetMacAddr()
 		if err != nil {
 			return err
 		} else if len(macs) == 0 {
@@ -83,8 +84,8 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 
 	var wcclient nodepb.NodeServiceClient
 
-	conn, err := grpc.Dial(cfg.Server.GRPCAddress, 
-		netclientutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
+	conn, err := grpc.Dial(cfg.Server.GRPCAddress,
+		ncutils.GRPCRequestOpts(cfg.Server.GRPCSSL))
 
 	if err != nil {
 		log.Fatalf("Unable to establish client connection to "+cfg.Server.GRPCAddress+": %v", err)
@@ -129,7 +130,7 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 	if err != nil {
 		return err
 	}
-	log.Println("node created on remote server...updating configs")
+	ncutils.PrintLog("node created on remote server...updating configs", 1)
 
 	nodeData := res.Data
 	var node models.Node
@@ -138,14 +139,14 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 	}
 
 	// get free port based on returned default listen port
-	node.ListenPort, err = netclientutils.GetFreePort(node.ListenPort)
+	node.ListenPort, err = ncutils.GetFreePort(node.ListenPort)
 	if err != nil {
 		fmt.Printf("Error retrieving port: %v", err)
 	}
-	
+
 	// safety check. If returned node from server is local, but not currently configured as local, set to local addr
 	if cfg.Node.IsLocal != "yes" && node.IsLocal == "yes" && node.LocalRange != "" {
-		node.LocalAddress, err = netclientutils.GetLocalIP(node.LocalRange)
+		node.LocalAddress, err = ncutils.GetLocalIP(node.LocalRange)
 		if err != nil {
 			return err
 		}
@@ -161,45 +162,35 @@ func JoinNetwork(cfg config.ClientConfig, privateKey string) error {
 		return err
 	}
 
-	// pushing any local changes to server before starting wireguard 
+	// pushing any local changes to server before starting wireguard
 	err = Push(cfg.Network)
 	if err != nil {
 		return err
 	}
 
 	if node.IsPending == "yes" {
-		netclientutils.Log("Node is marked as PENDING.")
-		netclientutils.Log("Awaiting approval from Admin before configuring WireGuard.")
+		ncutils.Log("Node is marked as PENDING.")
+		ncutils.Log("Awaiting approval from Admin before configuring WireGuard.")
 		if cfg.Daemon != "off" {
-			if netclientutils.IsWindows() {
-				// handle daemon here..
-				err = local.CreateAndRunWindowsDaemon()
-			} else {
-				err = local.ConfigureSystemD(cfg.Network)
-			}
-			return err
+			return daemon.InstallDaemon(cfg)
 		}
 	}
 
-	netclientutils.Log("retrieving remote peers")
+	ncutils.Log("retrieving remote peers")
 	peers, hasGateway, gateways, err := server.GetPeers(node.MacAddress, cfg.Network, cfg.Server.GRPCAddress, node.IsDualStack == "yes", node.IsIngressGateway == "yes")
 
-	if err != nil && !netclientutils.IsEmptyRecord(err) {
-		netclientutils.Log("failed to retrieve peers")
+	if err != nil && !ncutils.IsEmptyRecord(err) {
+		ncutils.Log("failed to retrieve peers")
 		return err
 	}
 
-	netclientutils.Log("starting wireguard")
+	ncutils.Log("starting wireguard")
 	err = wireguard.InitWireguard(&node, privateKey, peers, hasGateway, gateways)
 	if err != nil {
 		return err
 	}
 	if cfg.Daemon != "off" {
-		if netclientutils.IsWindows() {
-			err = local.CreateAndRunWindowsDaemon()
-		} else {
-			err = local.ConfigureSystemD(cfg.Network)
-		}
+		err = daemon.InstallDaemon(cfg)
 	}
 	if err != nil {
 		return err

netclient/functions/joinutils.go

@@ -1,62 +0,0 @@
-package functions
-
-import (
-	"github.com/gravitl/netmaker/models"
-	"net"
-)
-
-
-func getLocalIP(node models.Node) string{
-
-	var local string
-
-	ifaces, err := net.Interfaces()
-	if err != nil {
-		return local
-	}
-	_, localrange, err := net.ParseCIDR(node.LocalRange)
-	if err != nil {
-		return local
-	}
-
-	found := false
-	for _, i := range ifaces {
-		if i.Flags&net.FlagUp == 0 {
-			continue // interface down
-		}
-		if i.Flags&net.FlagLoopback != 0 {
-			continue // loopback interface
-		}
-		addrs, err := i.Addrs()
-		if err != nil {
-			return local
-		}
-		for _, addr := range addrs {
-			var ip net.IP
-			switch v := addr.(type) {
-			case *net.IPNet:
-				if !found {
-					ip = v.IP
-					local = ip.String()
-					if node.IsLocal == "yes" {
-						found = localrange.Contains(ip)
-					} else {
-						found = true
-					}
-				}
-			case *net.IPAddr:
-				if !found {
-					ip = v.IP
-					local = ip.String()
-					if node.IsLocal == "yes" {
-						found = localrange.Contains(ip)
-
-					} else {
-						found = true
-					}
-				}
-			}
-		}
-	}
-	return local
-}

netclient/functions/logging.go

@@ -1,12 +0,0 @@
-package functions
-
-import (
-	"log"
-)
-
-func PrintLog(message string, loglevel int) {
-	log.SetFlags(log.Flags() &^ (log.Llongfile | log.Lshortfile))
-	if loglevel == 0 {
-			log.Println(message)
-	}
-}