netmaker/netclient/functions/join.go

package functions

import (
	"fmt"
	"errors"
	"context"
	"log"
	"net"
	"strconv"
        "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"
)

func JoinNetwork(cfg config.ClientConfig) error {

	hasnet := local.HasNetwork(cfg.Network)
	if hasnet { 
		   err := errors.New("ALREADY_INSTALLED. Netclient appears to already be installed for cfg.Network " + cfg.Network + ". To re-install, please remove by executing 'sudo netclient -c remove -n " + cfg.Network + "'. Then re-run the install command.")
		return err
	}
	err := config.Write(&cfg, cfg.Network)
	if err != nil {
		return err
	}

        wgclient, err := wgctrl.New()
        if err != nil {
		return err
        }
        defer wgclient.Close()

	if cfg.Node.LocalRange != "" {
	if cfg.Node.LocalAddress == "" {
		ifaces, err := net.Interfaces()
                if err != nil {
                        return err
                }
		_, localrange, err := net.ParseCIDR(cfg.Node.LocalRange)
                if err != nil {
                        return err
                }

		var local string
		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 err
			}
			for _, addr := range addrs {
				var ip net.IP
				switch v := addr.(type) {
				case *net.IPNet:
					if !found {
						ip = v.IP
						local = ip.String()
						if cfg.Node.IsLocal == "yes" {
							found = localrange.Contains(ip)
						} else {
							found = true
						}
					}
				case *net.IPAddr:
					if  !found {
						ip = v.IP
						local = ip.String()
						if cfg.Node.IsLocal == "yes" {
							found = localrange.Contains(ip)

						} else {
							found = true
						}
					}
				}
			}
		}
		cfg.Node.LocalAddress = local
	}
	}
        if cfg.Node.Endpoint == "" {
		if cfg.Node.IsLocal == "yes" && cfg.Node.LocalAddress != "" {
			cfg.Node.Endpoint = cfg.Node.LocalAddress
		} else {

			cfg.Node.Endpoint, err = getPublicIP()
			if err != nil {
				fmt.Println("Error setting cfg.Node.Endpoint.")
				return err
			}
		}
        } else {
                cfg.Node.Endpoint = cfg.Node.Endpoint
		fmt.Println("Endpoint set in config. Setting to address: " + cfg.Node.Endpoint)
        }
	if cfg.Node.PrivateKey == "" {
		privatekey, err := wgtypes.GeneratePrivateKey()
		if err != nil {
			log.Fatal(err)
		}
		cfg.Node.PrivateKey = privatekey.String()
		cfg.Node.PublicKey = privatekey.PublicKey().String()
	}

	if cfg.Node.MacAddress == "" {
		macs, err := getMacAddr()
		if err != nil {
			return err
		} else if len(macs) == 0 {
			log.Fatal()
		} else {
			cfg.Node.MacAddress  = macs[0]
		}
	}

	var wcclient nodepb.NodeServiceClient
	var requestOpts grpc.DialOption
        requestOpts = grpc.WithInsecure()
        conn, err := grpc.Dial(cfg.Server.Address, requestOpts)
        if err != nil {
                log.Fatalf("Unable to establish client connection to localhost:50051: %v", err)
        }
        wcclient = nodepb.NewNodeServiceClient(conn)

        postnode := &nodepb.Node{
                Password: cfg.Node.Password,
                Macaddress: cfg.Node.MacAddress,
                Accesskey: cfg.Server.AccessKey,
                Nodenetwork:  cfg.Network,
                Listenport: cfg.Node.Port,
                Postup: cfg.Node.PostUp,
                Postdown: cfg.Node.PostDown,
                Keepalive: cfg.Node.KeepAlive,
		Localaddress: cfg.Node.LocalAddress,
		Interface: cfg.Node.Interface,
                Publickey: cfg.Node.PublicKey,
                Name: cfg.Node.Name,
                Endpoint: cfg.Node.Endpoint,
        }
        err = config.ModConfig(postnode)
        if err != nil {
		return err
        }
        res, err := wcclient.CreateNode(
                context.TODO(),
                &nodepb.CreateNodeReq{
                        Node: postnode,
                },
        )
        if err != nil {
                return err
        }
        node := res.Node
        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 !(cfg.Node.IsLocal == "yes") && node.Islocal && node.Localrange != "" {
		node.Localaddress, err = getLocalIP(node.Localrange)
		if err != nil {
			return err
		}
		node.Endpoint = node.Localaddress
	}

        err = config.ModConfig(node)
        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)
	}
        if err != nil {
                return err
        }

	return err
}