zishuo/netmaker
1
0
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-07 09:41:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

saving docker compose changes

Browse Source
This commit is contained in:
root
2021-05-26 11:57:13 +00:00
parent 1001d43abe aaf184fabd
commit 0517fa399d
19 changed files with 335 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
controllers/.serverClient.go.swp
View File

Binary file not shown.

25
controllers/extClientHttpController.go
View File

@@ -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,19 +319,23 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
var extclient models.ExtClient
extclient.Network = networkName
extclient.IngressGatewayID = macaddress
//get extclient from body of request
err := json.NewDecoder(r.Body).Decode(&extclient)
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)
err = json.NewDecoder(r.Body).Decode(&extclient)
if err != nil && !errors.Is(err, io.EOF) {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
err = ValidateExtClientCreate(params["network"], extclient)
if err != nil {
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()))

5
controllers/networkHttpController.go
View File

@@ -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()

1
controllers/serverClient.go
View File

@@ -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

BIN
models/.serverclient.go.swp
View File

Binary file not shown.

2
models/extclient.go
View File

@@ -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"`
}

6
models/returnNode.go
View File

@@ -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"`

1
models/serverclient.go
View File

@@ -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"`

4
netclient/command/commands.go
View File

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

161
netclient/config/config.go
View File

@@ -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,14 +355,18 @@ 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]
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("server") != "" {
cfg.Server.Address = c.String("server")
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) {

BIN
netclient/functions/.register.go.swp
View File

Binary file not shown.

8
netclient/functions/checkin.go
View File

@@ -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)

4
netclient/functions/common.go
View File

@@ -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)

25
netclient/functions/join.go
View File

@@ -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

122
netclient/functions/register.go
View File

@@ -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
}
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
}
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)
}
err = wireguard.InitGRPCWireguard(wgclient)
if err != nil {
return err
}

8
netclient/main.go
View File

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

196
netclient/main.go.old
View File

@@ -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")
}

4
netclient/server/grpc.go
View File

@@ -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)

116
netclient/wireguard/kernel.go
View File

@@ -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 {
@@ -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
}