modify access key

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/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/\\

@@ -0,0 +1,54 @@
+package functions
+
+import (
+	"io/ioutil"
+	"bytes"
+        "github.com/gravitl/netmaker/netclient/config"
+        "github.com/gravitl/netmaker/netclient/wireguard"
+        "github.com/gravitl/netmaker/models"
+	"encoding/json"
+	"net/http"
+	"errors"
+)
+
+func Register(cfg config.GlobalConfig) error {
+
+        postclient := &models.ServerClient{
+                AccessKey: cfg.Client.AccessKey,
+                PublicKey: cfg.Client.PublicKey,
+                PrivateKey: cfg.Client.PublicKey,
+		Address: cfg.Client.Address,
+		Address6: cfg.Client.Address6,
+		Network: "comms",
+	}
+	jsonstring, err := json.Marshal(postclient)
+        if err != nil {
+                return err
+        }
+	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
+        }
+	if res.StatusCode != http.StatusOK {
+		return errors.New("request to server failed: " + res.Status)
+	}
+	bodyBytes, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+	var wgclient models.ServerClient
+	json.Unmarshal(bodyBytes, &wgclient)
+        err = config.ModGlobalConfig(wgclient)
+        if err != nil {
+                return err
+        }
+
+	err = wireguard.InitGRPCWireguard(wgclient)
+        if err != nil {
+                return err
+        }
+
+	return err
+}

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/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
         }