saving docker compose changes

controllers/extClientHttpController.go

@@ -3,8 +3,10 @@ package controller
 import (
 	"context"
 	"encoding/json"
+	"io"
 	"errors"
 	"fmt"
+        "math/rand"
 
 	// "fmt"
 	"net/http"
@@ -256,8 +258,6 @@ Endpoint = %s
 }
 
 func CreateExtClient(extclient models.ExtClient) error {
-	fmt.Println(extclient)
-	// Generate Private Key for new ExtClient
 	if extclient.PrivateKey == "" {
 		privateKey, err := wgtypes.GeneratePrivateKey()
 		if err != nil {
@@ -275,6 +275,11 @@ func CreateExtClient(extclient models.ExtClient) error {
 		}
 		extclient.Address = newAddress
 	}
+        if extclient.ClientID == "" {
+                clientid := StringWithCharset(7, charset)
+                clientname := "client-" + clientid
+                extclient.ClientID = clientname
+        }
 
         if extclient.ClientID == "" {
                 cid := StringWithCharset(7, charset)
@@ -314,10 +319,15 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 	var extclient models.ExtClient
 	extclient.Network = networkName
 	extclient.IngressGatewayID = macaddress
+	node, err := functions.GetNodeByMacAddress(networkName, macaddress)
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+	extclient.IngressGatewayEndpoint = node.Endpoint + ":" + strconv.FormatInt(int64(node.ListenPort), 10)
 
-	//get extclient from body of request
-	err := json.NewDecoder(r.Body).Decode(&extclient)
-	if err != nil {
+	err = json.NewDecoder(r.Body).Decode(&extclient)
+	if err != nil && !errors.Is(err, io.EOF) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
@@ -326,7 +336,6 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
 	}
-
 	err = CreateExtClient(extclient)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -432,3 +441,7 @@ func StringWithCharset(length int, charset string) string {
         return string(b)
 }
 
+const charset = "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+var seededRand *rand.Rand = rand.New(
+        rand.NewSource(time.Now().UnixNano()))

controllers/networkHttpController.go

@@ -606,9 +606,10 @@ func CreateAccessKey(accesskey models.AccessKey, network models.Network) (models
 	}
 
 	netID := network.NetID
-	address := servercfg.GetGRPCHost() + ":" + servercfg.GetGRPCPort()
+	grpcaddress := servercfg.GetGRPCHost() + ":" + servercfg.GetGRPCPort()
+	apiaddress := servercfg.GetAPIHost() + ":" + servercfg.GetAPIPort()
 
-	accessstringdec := address + "|" + netID + "|" + accesskey.Value + "|" + privAddr
+	accessstringdec := grpcaddress + "|" + apiaddress + "|" + netID + "|" + accesskey.Value + "|" + privAddr
 	accesskey.AccessString = base64.StdEncoding.EncodeToString([]byte(accessstringdec))
 	//validate accesskey
 	v := validator.New()

controllers/serverClient.go

@@ -140,6 +140,7 @@ func RegisterClient(client models.ServerClient) (models.ServerClient, error) {
 		return client, err
 	}
 	client.ServerEndpoint = server.ServerEndpoint
+	client.ServerAddress = server.ServerAddress
 	client.ServerPort = server.ServerPort
 	client.ServerKey = server.ServerKey
 

models/extclient.go

@@ -41,5 +41,5 @@ type ExtClient struct {
 	Address        string             `json:"address" bson:"address"`
 	LastModified   int64              `json:"lastmodified" bson:"lastmodified"`
 	IngressGatewayID string             `json:"ingressgatewayid" bson:"ingressgatewayid"`
-	IngressGatewayEnpoint string             `json:"ingressgatewayendpoint" bson:"ingressgatewayendpoint"`
+	IngressGatewayEndpoint string             `json:"ingressgatewayendpoint" bson:"ingressgatewayendpoint"`
 }

models/returnNode.go

@@ -18,9 +18,9 @@ type ReturnNode struct {
 	SaveConfig	*bool `json:"saveconfig" bson:"saveconfig"`
 	Interface	string `json:"interface" bson:"interface"`
 	Network	string `json:"network" bson:"network"`
-	IsPending	*bool `json:"ispending" bson:"ispending"`
-	IsEgressGateway	*bool `json:"isegressgateway" bson:"isegressgateway"`
-	IsIngressGateway	*bool `json:"isingressgateway" bson:"isingressgateway"`
+	IsPending	bool `json:"ispending" bson:"ispending"`
+	IsEgressGateway	bool `json:"isegressgateway" bson:"isegressgateway"`
+	IsIngressGateway	bool `json:"isingressgateway" bson:"isingressgateway"`
 	EgressGatewayRange	string `json:"egressgatewayrange" bson:"egressgatewayrange"`
         LocalAddress    string `json:"localaddress" bson:"localaddress" validate:"localaddress_check"`
         ExpirationDateTime      int64 `json:"expdatetime" bson:"expdatetime"`

models/serverclient.go

@@ -10,6 +10,7 @@ type ServerClient struct {
 	Address6        string             `json:"address6" bson:"address6"`
 	Network        string             `json:"network" bson:"network"`
 	ServerEndpoint  string             `json:"serverendpoint" bson:"serverendpoint"`
+	ServerAddress  string             `json:"serveraddress" bson:"serveraddress"`
 	ServerPort     string             `json:"serverport" bson:"serverport"`
 	ServerKey      string             `json:"serverkey" bson:"serverkey"`
 	IsServer       string             `json:"isserver" bson:"isserver"`

netclient/command/commands.go

@@ -2,7 +2,6 @@ package command
 
 import (
         "github.com/gravitl/netmaker/netclient/functions"
-        "github.com/gravitl/netmaker/models"
         "github.com/gravitl/netmaker/netclient/config"
         "github.com/gravitl/netmaker/netclient/local"
         "golang.zx2c4.com/wireguard/wgctrl"
@@ -20,8 +19,7 @@ var (
         wcclient nodepb.NodeServiceClient
 )
 
-func Register(cfg config.ClientConfig) error {
-
+func Register(cfg config.GlobalConfig) error {
         err := functions.Register(cfg)
         return err
 }

netclient/config/config.go

@@ -11,7 +11,11 @@ import (
 	"log"
 	"gopkg.in/yaml.v3"
 	nodepb "github.com/gravitl/netmaker/grpc"
+	"github.com/gravitl/netmaker/models"
 )
+type GlobalConfig struct {
+	Client models.ServerClient
+}
 
 type ClientConfig struct {
 	Server ServerConfig `yaml:"server"`
@@ -21,7 +25,8 @@ type ClientConfig struct {
 	OperatingSystem string `yaml:"operatingsystem"`
 }
 type ServerConfig struct {
-        Address string `yaml:"address"`
+        GRPCAddress string `yaml:"grpcaddress"`
+        APIAddress string `yaml:"apiaddress"`
         AccessKey string `yaml:"accesskey"`
 }
 
@@ -79,6 +84,29 @@ func Write(config *ClientConfig, network string) error{
 	}
         return err
 }
+//reading in the env file
+func WriteGlobal(config *GlobalConfig) error{
+        _, err := os.Stat("/etc/netclient") 
+        if os.IsNotExist(err) {
+                      os.Mkdir("/etc/netclient", 744)
+        } else if err != nil {
+                return err
+        }
+        home := "/etc/netclient"
+
+        if err != nil {
+                log.Fatal(err)
+        }
+        file := fmt.Sprintf(home + "/netconfig-global-001")
+        f, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
+        defer f.Close()
+
+        err = yaml.NewEncoder(f).Encode(config)
+        if err != nil {
+                return err
+        }
+        return err
+}
 func WriteServer(server string, accesskey string, network string) error{
         if network == "" {
                 err := errors.New("No network provided. Exiting.")
@@ -136,7 +164,7 @@ func WriteServer(server string, accesskey string, network string) error{
                         fmt.Println(err)
                 }
 
-		cfg.Server.Address = server
+		cfg.Server.GRPCAddress = server
 		cfg.Server.AccessKey = accesskey
 
 		err = yaml.NewEncoder(f).Encode(cfg)
@@ -148,7 +176,7 @@ func WriteServer(server string, accesskey string, network string) error{
 	} else {
                 fmt.Println("Creating new config file at " + home + "/netconfig-" + network)
 
-                cfg.Server.Address = server
+                cfg.Server.GRPCAddress = server
                 cfg.Server.AccessKey = accesskey
 
                 newf, err := os.Create(home + "/netconfig-" + network)
@@ -194,6 +222,48 @@ func(config *ClientConfig) ReadConfig() {
 		}
 	}
 }
+func ModGlobalConfig(cfg models.ServerClient) error{
+        var modconfig GlobalConfig
+        var err error
+        if FileExists("/etc/netclient/netconfig-global-001") {
+                useconfig, err := ReadGlobalConfig()
+                if err != nil {
+                        return err
+                }
+                modconfig = *useconfig
+        }
+        if cfg.ServerPort != ""{
+                modconfig.Client.ServerPort = cfg.ServerPort
+        }
+        if cfg.PublicKey != ""{
+                modconfig.Client.PublicKey = cfg.PublicKey
+        }
+        if cfg.PrivateKey != ""{
+                modconfig.Client.PrivateKey = cfg.PrivateKey
+        }
+        if cfg.ServerEndpoint != ""{
+                modconfig.Client.ServerEndpoint = cfg.ServerEndpoint
+        }
+        if cfg.ServerAddress != ""{
+                modconfig.Client.ServerAddress = cfg.ServerAddress
+        }
+	if cfg.Address != ""{
+                modconfig.Client.Address = cfg.Address
+        }
+        if cfg.Address6 != ""{
+                modconfig.Client.Address6 = cfg.Address6
+        }
+        if cfg.Network != ""{
+                modconfig.Client.Network = cfg.Network
+        }
+        if cfg.ServerKey != ""{
+                modconfig.Client.ServerKey = cfg.ServerKey
+        }
+        err = WriteGlobal(&modconfig)
+        return err
+}
+
+
 
 func ModConfig(node *nodepb.Node) error{
         network := node.Nodenetwork
@@ -285,15 +355,19 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, error){
                 }
                 token := string(tokenbytes)
                 tokenvals := strings.Split(token, "|")
-                cfg.Server.Address = tokenvals[0]
-                cfg.Network = tokenvals[1]
-                cfg.Node.Network = tokenvals[1]
-                cfg.Server.AccessKey = tokenvals[2]
-                cfg.Node.LocalRange = tokenvals[3]
-
-		if c.String("server") != "" {
-			cfg.Server.Address = c.String("server")
+                cfg.Server.GRPCAddress = tokenvals[0]
+                cfg.Server.APIAddress = tokenvals[1]
+                cfg.Network = tokenvals[2]
+                cfg.Node.Network = tokenvals[2]
+                cfg.Server.AccessKey = tokenvals[3]
+                cfg.Node.LocalRange = tokenvals[4]
+
+		if c.String("grpcserver") != "" {
+			cfg.Server.GRPCAddress = c.String("grpcserver")
 		}
+                if c.String("apiserver") != "" {
+                        cfg.Server.APIAddress = c.String("apiserver")
+                }
 		if c.String("key") != "" {
 			cfg.Server.AccessKey = c.String("key")
 		}
@@ -305,7 +379,8 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, error){
 			cfg.Node.LocalRange = c.String("localrange")
 		}
 	} else {
-		cfg.Server.Address = c.String("server")
+		cfg.Server.GRPCAddress = c.String("grpcserver")
+		cfg.Server.APIAddress = c.String("apiserver")
 		cfg.Server.AccessKey = c.String("key")
                 cfg.Network = c.String("network")
                 cfg.Node.Network = c.String("network")
@@ -336,6 +411,46 @@ func GetCLIConfig(c *cli.Context) (ClientConfig, error){
 	return cfg, nil
 }
 
+func GetCLIConfigRegister(c *cli.Context) (GlobalConfig, error){
+        var cfg GlobalConfig
+        if c.String("token") != "" {
+                tokenbytes, err := base64.StdEncoding.DecodeString(c.String("token"))
+                if err  != nil {
+                        log.Println("error decoding token")
+                        return cfg, err
+                }
+                token := string(tokenbytes)
+                tokenvals := strings.Split(token, "|")
+                cfg.Client.ServerAddress = tokenvals[0]
+                cfg.Client.ServerEndpoint = tokenvals[1]
+                cfg.Client.ServerKey = tokenvals[3]
+
+                if c.String("grpcserver") != "" {
+                        cfg.Client.ServerAddress = c.String("grpcserver")
+                }
+                if c.String("apiserver") != "" {
+                        cfg.Client.ServerEndpoint = c.String("apiserver")
+                }
+                if c.String("key") != "" {
+                        cfg.Client.ServerKey = c.String("key")
+                }
+                if c.String("network") != "all" {
+                        cfg.Client.Network = c.String("network")
+                }
+        } else {
+                cfg.Client.ServerAddress = c.String("grpcserver")
+                cfg.Client.ServerEndpoint = c.String("apiserver")
+                cfg.Client.ServerKey = c.String("key")
+                cfg.Client.Network = c.String("network")
+        }
+        cfg.Client.Address = c.String("address")
+        cfg.Client.Address6 = c.String("addressIPV6")
+        cfg.Client.PublicKey = c.String("pubkey")
+        cfg.Client.PrivateKey = c.String("privkey")
+
+        return cfg, nil
+}
+
 
 func ReadConfig(network string) (*ClientConfig, error) {
         if network == "" {
@@ -365,6 +480,30 @@ func ReadConfig(network string) (*ClientConfig, error) {
 	return &cfg, err
 }
 
+func ReadGlobalConfig() (*GlobalConfig, error) {
+        nofile := false
+        home := "/etc/netclient"
+        file := fmt.Sprintf(home + "/netconfig-global-001")
+        f, err := os.Open(file)
+
+        if err != nil {
+                nofile = true
+        }
+        defer f.Close()
+
+        var cfg GlobalConfig
+
+        if !nofile {
+                decoder := yaml.NewDecoder(f)
+                err = decoder.Decode(&cfg)
+                if err != nil {
+                        fmt.Println("trouble decoding file")
+                        return nil, err
+                }
+        }
+        return &cfg, err
+}
+
 func FileExists(f string) bool {
     info, err := os.Stat(f)
     if os.IsNotExist(err) {

netclient/functions/checkin.go

@@ -25,7 +25,7 @@ func CheckIn(network string) error {
         }
 	nodecfg := cfg.Node
 	servercfg := cfg.Server
-	fmt.Println("Checking into server: " + servercfg.Address)
+	fmt.Println("Checking into server: " + servercfg.GRPCAddress)
 
 	setupcheck := true
 	ipchange := false
@@ -124,7 +124,7 @@ func CheckIn(network string) error {
         var wcclient nodepb.NodeServiceClient
         var requestOpts grpc.DialOption
         requestOpts = grpc.WithInsecure()
-        conn, err := grpc.Dial(servercfg.Address, requestOpts)
+        conn, err := grpc.Dial(servercfg.GRPCAddress, requestOpts)
         if err != nil {
 		fmt.Printf("Cant dial GRPC server: %v", err)
 		return err
@@ -244,7 +244,7 @@ func CheckIn(network string) error {
         if checkinres.Checkinresponse.Needkeyupdate {
                 fmt.Println("Server has requested that node update key pairs.")
                 fmt.Println("Proceeding to re-generate key pairs for Wiregard.")
-                err = wireguard.SetWGKeyConfig(network, servercfg.Address)
+                err = wireguard.SetWGKeyConfig(network, servercfg.GRPCAddress)
                 if err != nil {
                         return err
                         log.Fatalf("Unable to process reset keys request: %v", err)
@@ -274,7 +274,7 @@ func CheckIn(network string) error {
 	_, err := net.InterfaceByName(iface)
         if err != nil {
 		fmt.Println("interface " + iface + " does not currently exist. Setting up WireGuard.")
-                err = wireguard.SetWGKeyConfig(network, servercfg.Address)
+                err = wireguard.SetWGKeyConfig(network, servercfg.GRPCAddress)
                 if err != nil {
                         return err
                         log.Fatalf("Error: %v", err)

netclient/functions/common.go

@@ -272,9 +272,9 @@ func LeaveNetwork(network string) error {
         var wcclient nodepb.NodeServiceClient
         var requestOpts grpc.DialOption
         requestOpts = grpc.WithInsecure()
-        conn, err := grpc.Dial(servercfg.Address, requestOpts)
+        conn, err := grpc.Dial(servercfg.GRPCAddress, requestOpts)
 	if err != nil {
-                log.Printf("Unable to establish client connection to " + servercfg.Address + ": %v", err)
+                log.Printf("Unable to establish client connection to " + servercfg.GRPCAddress + ": %v", err)
         }else {
 		wcclient = nodepb.NewNodeServiceClient(conn)
 

netclient/functions/join.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"log"
 	"net"
-	"strconv"
         "github.com/gravitl/netmaker/netclient/config"
         "github.com/gravitl/netmaker/netclient/wireguard"
         "github.com/gravitl/netmaker/netclient/server"
@@ -128,7 +127,7 @@ func JoinNetwork(cfg config.ClientConfig) error {
 	var wcclient nodepb.NodeServiceClient
 	var requestOpts grpc.DialOption
         requestOpts = grpc.WithInsecure()
-        conn, err := grpc.Dial(cfg.Server.Address, requestOpts)
+        conn, err := grpc.Dial(cfg.Server.GRPCAddress, requestOpts)
         if err != nil {
                 log.Fatalf("Unable to establish client connection to localhost:50051: %v", err)
         }
@@ -167,26 +166,6 @@ func JoinNetwork(cfg config.ClientConfig) error {
                 return err
         }
 
-       fmt.Println("Node Settings: ")
-       fmt.Println("     Password: " + node.Password)
-       fmt.Println("     WG Address: " + node.Address)
-       fmt.Println("     WG ipv6 Address: " + node.Address6)
-       fmt.Println("     Network: " + node.Nodenetwork)
-       fmt.Println("     Public  Endpoint: " + node.Endpoint)
-       fmt.Println("     Local Address: " + node.Localaddress)
-       fmt.Println("     Name: " + node.Name)
-       fmt.Println("     Interface: " + node.Interface)
-       fmt.Println("     PostUp: " + node.Postup)
-       fmt.Println("     PostDown: " + node.Postdown)
-       fmt.Println("     Port: " + strconv.FormatInt(int64(node.Listenport), 10))
-       fmt.Println("     KeepAlive: " + strconv.FormatInt(int64(node.Keepalive), 10))
-       fmt.Println("     Public Key: " + node.Publickey)
-       fmt.Println("     Mac Address: " + node.Macaddress)
-       fmt.Println("     Is Local?: " + strconv.FormatBool(node.Islocal))
-       fmt.Println("     Is Dual Stack?: " + strconv.FormatBool(node.Isdualstack))
-       fmt.Println("     Is Ingress Gateway?: " + strconv.FormatBool(node.Isingressgateway))
-       fmt.Println("     Local Range: " + node.Localrange)
-
        if node.Dnsoff==true  {
 		cfg.Node.DNS = "yes"
 	}
@@ -213,7 +192,7 @@ func JoinNetwork(cfg config.ClientConfig) error {
 		}
 	}
 
-	peers, hasGateway, gateways, err := server.GetPeers(node.Macaddress, cfg.Network, cfg.Server.Address, node.Isdualstack, node.Isingressgateway)
+	peers, hasGateway, gateways, err := server.GetPeers(node.Macaddress, cfg.Network, cfg.Server.GRPCAddress, node.Isdualstack, node.Isingressgateway)
 
 	if err != nil {
                 return err

netclient/functions/register.go

@@ -1,111 +1,51 @@
 package functions
 
 import (
-	"fmt"
-	"errors"
-	"context"
-	"log"
-	"net"
-	"strconv"
+	"io/ioutil"
+	"bytes"
         "github.com/gravitl/netmaker/netclient/config"
         "github.com/gravitl/netmaker/netclient/wireguard"
-        "github.com/gravitl/netmaker/netclient/server"
-        "github.com/gravitl/netmaker/netclient/local"
-        nodepb "github.com/gravitl/netmaker/grpc"
-	"golang.zx2c4.com/wireguard/wgctrl"
-        "google.golang.org/grpc"
-	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
-	//homedir "github.com/mitchellh/go-homedir"
+        "github.com/gravitl/netmaker/models"
+	"encoding/json"
+	"net/http"
+	"errors"
 )
 
-func Register(cfg config.ClientConfig) error {
-
-        if err != nil {
-                log.Fatalf("Unable to establish client connection to localhost:50051: %v", err)
-        }
-        wcclient = nodepb.NewNodeServiceClient(conn)
+func Register(cfg config.GlobalConfig) error {
 
         postclient := &models.ServerClient{
-                AccessKey: cfg.Server.AccessKey,
-                Publickey: cfg.Node.PublicKey,
-                Privatekey: cfg.Node.PublicKey,
-		Address: cfg.Node.Address,
-		Address6: cfg.Node.Address6,
-		Network: "comms"
+                AccessKey: cfg.Client.AccessKey,
+                PublicKey: cfg.Client.PublicKey,
+                PrivateKey: cfg.Client.PublicKey,
+		Address: cfg.Client.Address,
+		Address6: cfg.Client.Address6,
+		Network: "comms",
 	}
-	bytes, err := json.Marshal(postclient)
-	body := bytes.NewBuffer(bytes)
-	res, err := http.Post("http://"+cfg.Server.Address+""jsonplaceholder.typicode.com/posts/1")
+	jsonstring, err := json.Marshal(postclient)
         if err != nil {
                 return err
         }
-        node := res.Node
+	jsonbytes := []byte(jsonstring)
+	body := bytes.NewBuffer(jsonbytes)
+	res, err := http.Post("http:/"+cfg.Client.ServerEndpoint+"/api/register","application/json",body)
         if err != nil {
                 return err
         }
-
-       fmt.Println("Node Settings: ")
-       fmt.Println("     Password: " + node.Password)
-       fmt.Println("     WG Address: " + node.Address)
-       fmt.Println("     WG ipv6 Address: " + node.Address6)
-       fmt.Println("     Network: " + node.Nodenetwork)
-       fmt.Println("     Public  Endpoint: " + node.Endpoint)
-       fmt.Println("     Local Address: " + node.Localaddress)
-       fmt.Println("     Name: " + node.Name)
-       fmt.Println("     Interface: " + node.Interface)
-       fmt.Println("     PostUp: " + node.Postup)
-       fmt.Println("     PostDown: " + node.Postdown)
-       fmt.Println("     Port: " + strconv.FormatInt(int64(node.Listenport), 10))
-       fmt.Println("     KeepAlive: " + strconv.FormatInt(int64(node.Keepalive), 10))
-       fmt.Println("     Public Key: " + node.Publickey)
-       fmt.Println("     Mac Address: " + node.Macaddress)
-       fmt.Println("     Is Local?: " + strconv.FormatBool(node.Islocal))
-       fmt.Println("     Is Dual Stack?: " + strconv.FormatBool(node.Isdualstack))
-       fmt.Println("     Is Ingress Gateway?: " + strconv.FormatBool(node.Isingressgateway))
-       fmt.Println("     Local Range: " + node.Localrange)
-
-       if node.Dnsoff==true  {
-		cfg.Node.DNS = "yes"
+	if res.StatusCode != http.StatusOK {
+		return errors.New("request to server failed: " + res.Status)
 	}
-	if !(cfg.Node.IsLocal == "yes") && node.Islocal && node.Localrange != "" {
-		node.Localaddress, err = getLocalIP(node.Localrange)
-		if err != nil {
-			return err
-		}
-		node.Endpoint = node.Localaddress
+	bodyBytes, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
 	}
-
-        err = config.ModConfig(node)
+	var wgclient models.ServerClient
+	json.Unmarshal(bodyBytes, &wgclient)
+        err = config.ModGlobalConfig(wgclient)
         if err != nil {
                 return err
         }
 
-	if node.Ispending {
-		fmt.Println("Node is marked as PENDING.")
-		fmt.Println("Awaiting approval from Admin before configuring WireGuard.")
-	        if cfg.Daemon != "no" {
-			fmt.Println("Configuring Netmaker Service.")
-			err = local.ConfigureSystemD(cfg.Network)
-			return err
-		}
-	}
-
-	peers, hasGateway, gateways, err := server.GetPeers(node.Macaddress, cfg.Network, cfg.Server.Address, node.Isdualstack, node.Isingressgateway)
-
-	if err != nil {
-                return err
-        }
-	err = wireguard.StorePrivKey(cfg.Node.PrivateKey, cfg.Network)
-        if err != nil {
-                return err
-        }
-	err = wireguard.InitWireguard(node, cfg.Node.PrivateKey, peers, hasGateway, gateways)
-        if err != nil {
-                return err
-        }
-	if cfg.Daemon == "off" {
-		err = local.ConfigureSystemD(cfg.Network)
-	}
+	err = wireguard.InitGRPCWireguard(wgclient)
         if err != nil {
                 return err
         }

netclient/main.go

@@ -184,14 +184,14 @@ func main() {
     app.Commands = []*cli.Command{
         {
             Name:  "register",
-            Usage: "Register with Netmaker Server for secure GRPC communications."
+            Usage: "Register with Netmaker Server for secure GRPC communications.",
             Flags: cliFlags,
             Action: func(c *cli.Context) error {
-                cfg, err := config.GetCLIConfig(c)
+                cfg, err := config.GetCLIConfigRegister(c)
                 if err != nil {
                         return err
                 }
-                if cfg.Server.Address == "" {
+                if cfg.Client.ServerAddress == "" {
                         err = errors.New("No server address provided.")
                         return err
                 }
@@ -212,7 +212,7 @@ func main() {
 			err = errors.New("No network provided.")
 			return err
 		}
-                if cfg.Server.Address == "" {
+                if cfg.Server.GRPCAddress == "" {
                         err = errors.New("No server address provided.")
                         return err
                 }

netclient/main.go.old

@@ -1,196 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/urfave/cli"
-        "github.com/gravitl/netmaker/netclient/functions"
-        "golang.zx2c4.com/wireguard/wgctrl"
-        nodepb "github.com/gravitl/netmaker/grpc"
-	"flag"
-	"os"
-        "os/exec"
-        "strconv"
-	"strings"
-	"log"
-)
-
-const (
-	// name of the service
-	name        = "netclient"
-	description = "Netmaker Daemon Service"
-)
-
-var password string
-var network string
-var server string
-var accesskey string
-
-var (
-        wgclient *wgctrl.Client
-)
-
-var (
-        wcclient nodepb.NodeServiceClient
-)
-
-func main() {
-
-	tpassword := flag.String("p", "changeme", "This node's password for accessing the server regularly")
-	taccesskey := flag.String("k", "badkey", "an access key generated by the server and used for one-time access (install only)")
-	taccesstoken := flag.String("t", "badtoken", "an token generated by the server and used for one-time access (install only)")
-	tname := flag.String("name", "noname", "give the node a name at runtime")
-	tserver := flag.String("s", "localhost:50051", "The location (including port) of the remote gRPC server.")
-	tnetwork := flag.String("n", "nonetwork", "The node network you are attempting to join.")
-	tdnsoff := flag.Bool("dnsoff", false, "DNS Mode. If true, netclient will not alter system dns. false by default.")
-	tpublicip := flag.String("ip4", "nopubip", "The node network you are attempting to join.")
-	tnoauto := flag.Bool("na", false, "No auto mode. If true, netmclient will not be installed as a system service and you will have to retrieve updates manually via checkin command.")
-	tipforward := flag.String("nf", "on", "No Forward mode. If true, netclient will not check for IP forwarding. This may break functionality")
-	command := flag.String("c", "required", "The command to run")
-
-
-        flag.Parse()
-
-
-
-         getID := exec.Command("id", "-u")
-         out, err := getID.Output()
-
-         if err != nil {
-                 log.Fatal(err)
-         }
-         id, err := strconv.Atoi(string(out[:len(out)-1]))
-
-         if err != nil {
-                 log.Fatal(err)
-         }
-
-         if id != 0 {
-                 log.Fatal("This program must be run with elevated privileges (sudo). This program installs a SystemD service and configures WireGuard and networking rules. Please re-run with sudo/root.")
-         }
-
-
-	_, err = exec.LookPath("wg")
-	if err != nil {
-		log.Println(err)
-		log.Fatal("WireGuard not installed. Please install WireGuard (wireguard-tools) and try again.")
-	}
-
-        switch *command {
-		case "getport":
-			portno, err := functions.GetFreePort(51821)
-			fmt.Printf("Port Number: %v", portno)
-			fmt.Println("")
-			if err != nil {
-				log.Fatal(err)
-			}
-		case "required":
-                        fmt.Println("command flag 'c' is required. Pick one of |install|checkin|update|remove|")
-                        os.Exit(1)
-			log.Fatal("Exiting")
-                case "install":
-
-                        if *taccesstoken == "badtoken" && (*tnetwork == "nonetwork"  || *tnetwork == "") {
-                                fmt.Println("Required, '-n'. No network provided. Exiting.")
-                                os.Exit(1)
-                        }
-			/*
-			if !*tnoforward {
-				forward := exec.Command("sysctl", "net.ipv4.ip_forward")
-				out, err := forward.Output()
-
-				if err != nil {
-					log.Fatal(err)
-				}
-				//s := strings.Split(string(out), " ", "\n")
-				s := strings.Fields(string(out))
-				if err != nil {
-					log.Fatal(err)
-				}
-				if s[2] != "1" {
-					log.Fatal("It is recommended to enable IP Forwarding. Current status is: " +  s[2] + ", but should be 1. if you would like to run without IP Forwarding, re-run with flag '-nf true'")
-				}
-			}
-			*/
-			fmt.Println("Beginning agent installation.")
-			err := functions.Install(*taccesskey, *tpassword, *tserver, *tnetwork, *tnoauto, *taccesstoken, *tname, *tpublicip, *tdnsoff, *tipforward)
-			if err != nil {
-				fmt.Println("Error encountered while installing.")
-				if !strings.Contains(err.Error(), "ALREADY_INSTALLED") {
-				fmt.Println("Error installing: ", err)
-				fmt.Println("Cleaning up (uninstall)")
-				err = functions.Remove(*tnetwork)
-				if err != nil {
-                                        fmt.Println("Error uninstalling: ", err)
-                                        fmt.Println("Wiping local.")
-					err = functions.WipeLocal(*tnetwork)
-					if err != nil {
-						fmt.Println("Error removing artifacts: ", err)
-					}
-                                        err = functions.RemoveSystemDServices(*tnetwork)
-                                        if err != nil {
-                                                fmt.Println("Error removing services: ", err)
-                                        }
-				}
-				os.Exit(1)
-				} else {
-					fmt.Println(err.Error())
-					os.Exit(1)
-				}
-			}
-		/*
-		case "service-install":
-                        fmt.Println("Beginning service installation.")
-                        err := functions.ConfigureSystemD()
-                        if err != nil {
-                                fmt.Println("Error installing service: ", err)
-                                os.Exit(1)
-                        }
-                case "service-uninstall":
-                        fmt.Println("Beginning service uninstall.")
-                        err := functions.RemoveSystemDServices()
-                        if err != nil {
-                                fmt.Println("Error installing service: ", err)
-                                os.Exit(1)
-                        }
-		*/
-		case "checkin":
-                        if *tnetwork == "nonetwork" || *tnetwork == "" {
-                                fmt.Println("Required, '-n'. No network provided. Exiting.")
-                                os.Exit(1)
-                        }
-			fmt.Println("Beginning node check in for network " + *tnetwork)
-			err := functions.CheckIn(*tnetwork)
-			if err != nil {
-				fmt.Println("Error checking in: ", err)
-				os.Exit(1)
-			}
-		case "remove":
-			if *tnetwork == "nonetwork" || *tnetwork == "" {
-                                fmt.Println("Required, '-n'. No network provided. Exiting.")
-                                os.Exit(1)
-			}
-                        fmt.Println("Beginning node cleanup.")
-			err := functions.Remove(*tnetwork)
-                        if err != nil {
-					/*
-                                        fmt.Println("Error uninstalling: ", err)
-                                        fmt.Println("Wiping local.")
-                                        err = functions.WipeLocal()
-                                        if err != nil {
-                                                fmt.Println("Error removing artifacts: ", err)
-                                        }
-                                        err = functions.RemoveSystemDServices()
-                                        if err != nil {
-                                                fmt.Println("Error removing services: ", err)
-                                        }
-					*/
-                                fmt.Println("Error deleting node: ", err)
-                                os.Exit(1)
-                        }
-		default:
-			fmt.Println("You must select from the following commands: install|remove|checkin", err)
-			os.Exit(1)
-
-	}
-	fmt.Println("Command " + *command + " Executed Successfully")
-}

netclient/server/grpc.go

@@ -77,9 +77,9 @@ func RemoveNetwork(network string) error {
         var wcclient nodepb.NodeServiceClient
         var requestOpts grpc.DialOption
         requestOpts = grpc.WithInsecure()
-        conn, err := grpc.Dial(servercfg.Address, requestOpts)
+        conn, err := grpc.Dial(servercfg.GRPCAddress, requestOpts)
 	if err != nil {
-                log.Printf("Unable to establish client connection to " + servercfg.Address + ": %v", err)
+                log.Printf("Unable to establish client connection to " + servercfg.GRPCAddress + ": %v", err)
 		//return err
         }else {
         wcclient = nodepb.NewNodeServiceClient(conn)

netclient/wireguard/kernel.go

@@ -2,6 +2,8 @@ package wireguard
 
 import (
 	"fmt"
+	"strconv"
+	"errors"
 	"context"
         "io/ioutil"
 	"strings"
@@ -14,12 +16,120 @@ import (
         "github.com/gravitl/netmaker/netclient/auth"
         "github.com/gravitl/netmaker/netclient/server"
         nodepb "github.com/gravitl/netmaker/grpc"
+        "github.com/gravitl/netmaker/models"
 	"golang.zx2c4.com/wireguard/wgctrl"
         "google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	//homedir "github.com/mitchellh/go-homedir"
 )
+func InitGRPCWireguard(client models.ServerClient) error {
+        key, err := wgtypes.ParseKey(client.PrivateKey)
+        if err !=  nil {
+                return err
+        }
+        serverkey, err := wgtypes.ParseKey(client.ServerKey)
+        if err !=  nil {
+                return err
+        }
+	serverport, err := strconv.Atoi(client.ServerPort)
+        if err !=  nil {
+                return err
+        }
+
+        wgclient, err := wgctrl.New()
+        if err != nil {
+                log.Fatalf("failed to open client: %v", err)
+        }
+        defer wgclient.Close()
+
+        ifacename := "grpc-wg-001"
+        if client.Address6 == "" && client.Address == "" {
+                return errors.New("no address to configure")
+        }
+        cmdIPDevLinkAdd := exec.Command("ip","link", "add", "dev", ifacename, "type",  "wireguard" )
+        cmdIPAddrAdd := exec.Command("ip", "address", "add", "dev", ifacename, client.Address+"/24")
+        cmdIPAddr6Add := exec.Command("ip", "address", "add", "dev", ifacename, client.Address+"/24")
+        currentiface, err := net.InterfaceByName(ifacename)
+        if err != nil {
+                err = cmdIPDevLinkAdd.Run()
+	        if  err  !=  nil && !strings.Contains(err.Error(), "exists") {
+	                log.Println("Error creating interface")
+	        }
+        }
+        match := false
+        addrs, _ := currentiface.Addrs()
+
+	//Add IPv4Address (make into separate function)
+        for _, a := range addrs {
+                if strings.Contains(a.String(), client.Address){
+                        match = true
+                }
+        }
+        if !match {
+		err = cmdIPAddrAdd.Run()
+	        if  err  !=  nil {
+	                log.Println("Error adding address")
+	        }
+        }
+
+	//Add IPv6 Address (make into separate function)
+        for _, a := range addrs {
+                if strings.Contains(a.String(), client.Address6){
+                        match = true
+                }
+        }
+        if !match {
+                err = cmdIPAddr6Add.Run()
+                if  err  !=  nil {
+                        log.Println("Error adding address")
+                }
+        }
+	var peers []wgtypes.PeerConfig
+        var peeraddr = net.IPNet{
+                 IP: net.ParseIP(client.ServerAddress),
+                 Mask: net.CIDRMask(32, 32),
+        }
+	var allowedips []net.IPNet
+        allowedips = append(allowedips, peeraddr)
+
+	peer := wgtypes.PeerConfig{
+               PublicKey: serverkey,
+               Endpoint: &net.UDPAddr{
+                         IP:   net.ParseIP(client.ServerEndpoint),
+                         Port: serverport,
+               },
+               ReplaceAllowedIPs: true,
+               AllowedIPs: allowedips,
+        }
+	peers = append(peers, peer)
+        conf := wgtypes.Config{
+                PrivateKey: &key,
+                ReplacePeers: true,
+                Peers: peers,
+        }
+        _, err = wgclient.Device(ifacename)
+        if err != nil {
+                if os.IsNotExist(err) {
+                        log.Println("Device does not exist: ")
+                        log.Println(err)
+                } else {
+                        return err
+                }
+        }
+        err = wgclient.ConfigureDevice(ifacename, conf)
+
+        if err != nil {
+                if os.IsNotExist(err) {
+                        log.Println("Device does not exist: ")
+                        log.Println(err)
+                } else {
+                        log.Printf("This is inconvenient: %v", err)
+                }
+        }
+	return err
+}
+
 
 func InitWireguard(node *nodepb.Node, privkey string, peers []wgtypes.PeerConfig, hasGateway bool, gateways []string) error  {
 
@@ -36,7 +146,7 @@ func InitWireguard(node *nodepb.Node, privkey string, peers []wgtypes.PeerConfig
 	//modcfg := config.Config
 	//modcfg.ReadConfig()
 	modcfg, err := config.ReadConfig(node.Nodenetwork)
-        if err != nil {
+	if err != nil {
                 return err
         }
 
@@ -50,7 +160,6 @@ func InitWireguard(node *nodepb.Node, privkey string, peers []wgtypes.PeerConfig
         }
         defer wgclient.Close()
 
-
 	ifacename := node.Interface
 	if nodecfg.Interface != "" {
 		ifacename = nodecfg.Interface
@@ -62,7 +171,7 @@ func InitWireguard(node *nodepb.Node, privkey string, peers []wgtypes.PeerConfig
 	if node.Address == "" {
 		log.Fatal("no address to configure")
 	}
-	nameserver := servercfg.Address
+	nameserver := servercfg.GRPCAddress
 	nameserver = strings.Split(nameserver, ":")[0]
 	network := node.Nodenetwork
         if nodecfg.Network != "" {
@@ -111,7 +220,6 @@ func InitWireguard(node *nodepb.Node, privkey string, peers []wgtypes.PeerConfig
 	var nodeport int
 	nodeport = int(node.Listenport)
 
-
 	//pubkey := privkey.PublicKey()
 	conf := wgtypes.Config{
 		PrivateKey: &key,
@@ -293,7 +401,7 @@ func SetWGConfig(network string) error {
         nodecfg := cfg.Node
         node := server.GetNode(network)
 
-	peers, hasGateway, gateways, err := server.GetPeers(node.Macaddress, nodecfg.Network, servercfg.Address, node.Isdualstack, node.Isingressgateway)
+	peers, hasGateway, gateways, err := server.GetPeers(node.Macaddress, nodecfg.Network, servercfg.GRPCAddress, node.Isdualstack, node.Isingressgateway)
         if err != nil {
                 return err
         }