27-remove-client-grpc-endpoint

Removed a client's grpc endpoint value. Client's aren't publicly available so there is no need for a client's gRPC endpoint. Also changed a node ID's to their public key. A node id's public address is an issue for mobility of clients as their endpoint is subject to change
Only updating WireGuard config if node exists
2025-07-07 15:56:47 +02:00 · 2023-11-24 12:07:03 +00:00 · 2023-11-22 13:08:02 +00:00 · 2023-11-22 12:45:01 +00:00 · 2023-11-22 10:42:48 +00:00 · 2023-11-22 10:41:54 +00:00
33 changed files with 857 additions and 494 deletions
--- a/1
+++ b/1
@ -8,4 +8,5 @@ RUN apt-get update && apt-get install -y \
    tmux \
    vim
 WORKDIR /wgmesh
+RUN go mod tidy
 RUN go build -o /usr/local/bin ./...
--- a/cmd/api/main.go
+++ b/cmd/api/main.go
@ -7,11 +7,13 @@ import (
 )

 func main() {
-	apiServer, err := api.NewSmegServer()
+	apiServer, err := api.NewSmegServer(api.ApiServerConf{
+		WordsFile: "./cmd/api/words.txt",
+	})

 	if err != nil {
 		log.Fatal(err.Error())
 	}

-	apiServer.Run(":40000")
+	apiServer.Run(":8080")
 }
--- a/cmd/api/words.txt
+++ b/cmd/api/words.txt
@ -0,0 +1,257 @@
+be
+to
+of
+it
+in
+we
+do
+he
+on
+go
+at
+if
+or
+up
+by
+hi
+the
+and
+you
+not
+for
+but
+say
+get
+she
+one
+all
+can
+out
+who
+now
+see
+way
+how
+lot
+yes
+use
+any
+day
+try
+put
+let
+why
+new
+off
+big
+too
+ask
+man
+bit
+end
+may
+own
+run
+pay
+job
+old
+kid
+bad
+few
+ago
+far
+buy
+set
+guy
+car
+sit
+war
+win
+yet
+top
+law
+cut
+low
+die
+eat
+age
+hit
+air
+add
+boy
+act
+tax
+oil
+eye
+son
+key
+fun
+dad
+dog
+arm
+fly
+box
+gas
+lie
+hot
+gun
+per
+art
+red
+fit
+bed
+fan
+mix
+mom
+sex
+bus
+fix
+bar
+lay
+ice
+bet
+bag
+due
+aid
+tie
+leg
+ban
+odd
+cup
+dry
+cry
+rid
+pop
+sir
+cat
+map
+sad
+sea
+aim
+sun
+fat
+row
+egg
+tea
+god
+wed
+tip
+ear
+hat
+net
+ill
+dig
+fee
+mad
+gap
+nor
+bid
+era
+toy
+sky
+bin
+owe
+wet
+tap
+pro
+ski
+cow
+pen
+van
+web
+pot
+sum
+cap
+log
+pub
+pig
+joy
+raw
+rat
+via
+lip
+two
+six
+ten
+lab
+ton
+mid
+bat
+hip
+gut
+sin
+non
+rub
+sub
+par
+pre
+ray
+cue
+dye
+fin
+ion
+neo
+hey
+wow
+mum
+bye
+aye
+jet
+sue
+pet
+flu
+cop
+ooh
+rip
+spy
+pie
+bug
+gum
+wan
+rap
+nut
+beg
+pin
+pit
+jam
+tag
+fax
+vet
+fry
+pad
+lad
+mud
+bay
+con
+pan
+gee
+toe
+dip
+shy
+gym
+zoo
+fox
+bow
+tin
+hop
+wee
+kit
+opt
+vow
+sew
+cab
+bee
+rob
+rig
+yep
+ego
+rib
+nod
+hug
+lap
+ash
+hum
+dam
+bum
+yen
+jar
--- a/cmd/wg-mesh/main.go
+++ b/cmd/wg-mesh/main.go
@ -16,7 +16,6 @@ const SockAddr = "/tmp/wgmesh_ipc.sock"

 type CreateMeshParams struct {
 	Client   *ipcRpc.Client
-	IfName   string
 	WgPort   int
 	Endpoint string
 }
@ -24,7 +23,6 @@ type CreateMeshParams struct {
 func createMesh(args *CreateMeshParams) string {
 	var reply string
 	newMeshParams := ipc.NewMeshArgs{
-		IfName:   args.IfName,
 		WgPort:   args.WgPort,
 		Endpoint: args.Endpoint,
 	}
@ -68,7 +66,6 @@ func joinMesh(params *JoinMeshParams) string {
 	args := ipc.JoinMeshArgs{
 		MeshId:   params.MeshId,
 		IpAdress: params.IpAddress,
-		IfName:   params.IfName,
 		Port:     params.WgPort,
 	}

@ -240,7 +237,6 @@ func main() {
 	newMeshCmd := parser.NewCommand("new-mesh", "Create a new mesh")
 	listMeshCmd := parser.NewCommand("list-meshes", "List meshes the node is connected to")
 	joinMeshCmd := parser.NewCommand("join-mesh", "Join a mesh network")
-	// getMeshCmd := parser.NewCommand("get-mesh", "Get a mesh network")
 	enableInterfaceCmd := parser.NewCommand("enable-interface", "Enable A Specific Mesh Interface")
 	getGraphCmd := parser.NewCommand("get-graph", "Convert a mesh into DOT format")
 	leaveMeshCmd := parser.NewCommand("leave-mesh", "Leave a mesh network")
@ -251,14 +247,12 @@ func main() {
 	deleteServiceCmd := parser.NewCommand("delete-service", "Remove a service from your advertisements")
 	getNodeCmd := parser.NewCommand("get-node", "Get a specific node from the mesh")

-	var newMeshIfName *string = newMeshCmd.String("f", "ifname", &argparse.Options{Required: true})
-	var newMeshPort *int = newMeshCmd.Int("p", "wgport", &argparse.Options{Required: true})
+	var newMeshPort *int = newMeshCmd.Int("p", "wgport", &argparse.Options{})
 	var newMeshEndpoint *string = newMeshCmd.String("e", "endpoint", &argparse.Options{})

 	var joinMeshId *string = joinMeshCmd.String("m", "mesh", &argparse.Options{Required: true})
 	var joinMeshIpAddress *string = joinMeshCmd.String("i", "ip", &argparse.Options{Required: true})
-	var joinMeshIfName *string = joinMeshCmd.String("f", "ifname", &argparse.Options{Required: true})
-	var joinMeshPort *int = joinMeshCmd.Int("p", "wgport", &argparse.Options{Required: true})
+	var joinMeshPort *int = joinMeshCmd.Int("p", "wgport", &argparse.Options{})
 	var joinMeshEndpoint *string = joinMeshCmd.String("e", "endpoint", &argparse.Options{})

 	var enableInterfaceMeshId *string = enableInterfaceCmd.String("m", "mesh", &argparse.Options{Required: true})
@ -298,7 +292,6 @@ func main() {
 	if newMeshCmd.Happened() {
 		fmt.Println(createMesh(&CreateMeshParams{
 			Client:   client,
-			IfName:   *newMeshIfName,
 			WgPort:   *newMeshPort,
 			Endpoint: *newMeshEndpoint,
 		}))
@ -311,7 +304,6 @@ func main() {
 	if joinMeshCmd.Happened() {
 		fmt.Println(joinMesh(&JoinMeshParams{
 			Client:    client,
-			IfName:    *joinMeshIfName,
 			WgPort:    *joinMeshPort,
 			IpAddress: *joinMeshIpAddress,
 			MeshId:    *joinMeshId,
--- a/pkg/api/apiserver.go
+++ b/pkg/api/apiserver.go
@ -10,6 +10,7 @@ import (
 	"github.com/tim-beatham/wgmesh/pkg/ctrlserver"
 	"github.com/tim-beatham/wgmesh/pkg/ipc"
 	logging "github.com/tim-beatham/wgmesh/pkg/log"
+	"github.com/tim-beatham/wgmesh/pkg/what8words"
 )

 const SockAddr = "/tmp/wgmesh_ipc.sock"
@ -22,33 +23,59 @@ type ApiServer interface {
 type SmegServer struct {
 	router *gin.Engine
 	client *ipcRpc.Client
+	words  *what8words.What8Words
 }

-func meshNodeToAPIMeshNode(meshNode ctrlserver.MeshNode) *SmegNode {
+func (s *SmegServer) routeToApiRoute(meshNode ctrlserver.MeshNode) []Route {
+	routes := make([]Route, len(meshNode.Routes))
+
+	for index, route := range meshNode.Routes {
+		word, err := s.words.Convert(route)
+
+		if err != nil {
+			fmt.Println(err.Error())
+		}
+
+		routes[index] = Route{
+			Prefix:  route,
+			RouteId: word,
+		}
+	}
+
+	return routes
+}
+
+func (s *SmegServer) meshNodeToAPIMeshNode(meshNode ctrlserver.MeshNode) *SmegNode {
 	if meshNode.Routes == nil {
 		meshNode.Routes = make([]string, 0)
 	}

+	alias := meshNode.Alias
+
+	if alias == "" {
+		alias, _ = s.words.ConvertIdentifier(meshNode.WgHost)
+	}
+
 	return &SmegNode{
 		WgHost:      meshNode.WgHost,
 		WgEndpoint:  meshNode.WgEndpoint,
 		Endpoint:    meshNode.HostEndpoint,
 		Timestamp:   int(meshNode.Timestamp),
 		Description: meshNode.Description,
-		Routes:      meshNode.Routes,
+		Routes:      s.routeToApiRoute(meshNode),
 		PublicKey:   meshNode.PublicKey,
-		Alias:       meshNode.Alias,
+		Alias:       alias,
 		Services:    meshNode.Services,
 	}
 }

-func meshToAPIMesh(meshId string, nodes []ctrlserver.MeshNode) SmegMesh {
+func (s *SmegServer) meshToAPIMesh(meshId string, nodes []ctrlserver.MeshNode) SmegMesh {
 	var smegMesh SmegMesh
 	smegMesh.MeshId = meshId
 	smegMesh.Nodes = make(map[string]SmegNode)

 	for _, node := range nodes {
-		smegMesh.Nodes[node.WgHost] = *meshNodeToAPIMeshNode(node)
+		smegMesh.Nodes[node.WgHost] = *s.meshNodeToAPIMeshNode(node)
 	}

 	return smegMesh
@ -62,11 +89,11 @@ func (s *SmegServer) CreateMesh(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, &gin.H{
 			"error": err.Error(),
 		})
+
 		return
 	}

 	ipcRequest := ipc.NewMeshArgs{
-		IfName: createMesh.IfName,
 		WgPort: createMesh.WgPort,
 	}

@ -100,7 +127,6 @@ func (s *SmegServer) JoinMesh(c *gin.Context) {
 	ipcRequest := ipc.JoinMeshArgs{
 		MeshId:   joinMesh.MeshId,
 		IpAdress: joinMesh.Bootstrap,
-		IfName:   joinMesh.IfName,
 		Port:     joinMesh.WgPort,
 	}

@ -139,7 +165,7 @@ func (s *SmegServer) GetMesh(c *gin.Context) {
 		return
 	}

-	mesh := meshToAPIMesh(meshidParam, getMeshReply.Nodes)
+	mesh := s.meshToAPIMesh(meshidParam, getMeshReply.Nodes)

 	c.JSON(http.StatusOK, mesh)
 }
@ -168,7 +194,7 @@ func (s *SmegServer) GetMeshes(c *gin.Context) {
 			return
 		}

-		meshes = append(meshes, meshToAPIMesh(mesh, getMeshReply.Nodes))
+		meshes = append(meshes, s.meshToAPIMesh(mesh, getMeshReply.Nodes))
 	}

 	c.JSON(http.StatusOK, meshes)
@ -179,13 +205,19 @@ func (s *SmegServer) Run(addr string) error {
 	return s.router.Run(addr)
 }

-func NewSmegServer() (ApiServer, error) {
+func NewSmegServer(conf ApiServerConf) (ApiServer, error) {
 	client, err := ipcRpc.DialHTTP("unix", SockAddr)

 	if err != nil {
 		return nil, err
 	}

+	words, err := what8words.NewWhat8Words(conf.WordsFile)
+
+	if err != nil {
+		return nil, err
+	}
+
 	router := gin.Default()

 	router.Use(gin.LoggerWithConfig(gin.LoggerConfig{
@ -195,6 +227,7 @@ func NewSmegServer() (ApiServer, error) {
 	smegServer := &SmegServer{
 		router: router,
 		client: client,
+		words:  words,
 	}

 	router.GET("/meshes", smegServer.GetMeshes)
--- a/pkg/api/types.go
+++ b/pkg/api/types.go
@ -1,5 +1,10 @@
 package api

+type Route struct {
+	RouteId string `json:"routeId"`
+	Prefix  string `json:"prefix"`
+}
+
 type SmegNode struct {
 	Alias       string            `json:"alias"`
 	WgHost      string            `json:"wgHost"`
@ -8,7 +13,7 @@ type SmegNode struct {
 	Timestamp   int               `json:"timestamp"`
 	Description string            `json:"description"`
 	PublicKey   string            `json:"publicKey"`
-	Routes      []string          `json:"routes"`
+	Routes      []Route           `json:"routes"`
 	Services    map[string]string `json:"services"`
 }

@ -18,13 +23,15 @@ type SmegMesh struct {
 }

 type CreateMeshRequest struct {
-	IfName string `json:"ifName" binding:"required"`
-	WgPort int    `json:"port" binding:"required,gte=1024,lt=65535"`
+	WgPort int `json:"port" binding:"omitempty,gte=1024,lt=65535"`
 }

 type JoinMeshRequest struct {
-	IfName    string `json:"ifName" binding:"required"`
-	WgPort    int    `json:"port" binding:"required,gte=1024,lt=65535"`
+	WgPort    int    `json:"port" binding:"omitempty,gte=1024,lt=65535"`
 	Bootstrap string `json:"bootstrap" binding:"required"`
 	MeshId    string `json:"meshid" binding:"required"`
 }
+
+type ApiServerConf struct {
+	WordsFile string
+}
--- a/pkg/automerge/automerge.go
+++ b/pkg/automerge/automerge.go
@ -39,11 +39,32 @@ func (c *CrdtMeshManager) AddNode(node mesh.MeshNode) {
 	crdt.Services = make(map[string]string)
 	crdt.Timestamp = time.Now().Unix()

-	c.doc.Path("nodes").Map().Set(crdt.HostEndpoint, crdt)
+	c.doc.Path("nodes").Map().Set(crdt.PublicKey, crdt)
 }

-func (c *CrdtMeshManager) GetNodeIds() []string {
+func (c *CrdtMeshManager) isPeer(nodeId string) bool {
+	node, err := c.doc.Path("nodes").Map().Get(nodeId)
+
+	if err != nil || node.Kind() != automerge.KindMap {
+		return false
+	}
+
+	nodeType, err := node.Map().Get("type")
+
+	if err != nil || nodeType.Kind() != automerge.KindStr {
+		return false
+	}
+
+	return nodeType.Str() == string(conf.PEER_ROLE)
+}
+
+func (c *CrdtMeshManager) GetPeers() []string {
 	keys, _ := c.doc.Path("nodes").Map().Keys()
+
+	keys = lib.Filter(keys, func(s string) bool {
+		return c.isPeer(s)
+	})
+
 	return keys
 }

@ -55,7 +76,7 @@ func (c *CrdtMeshManager) GetMesh() (mesh.MeshSnapshot, error) {
 		return nil, err
 	}

-	if c.cache == nil || len(changes) > 3 {
+	if c.cache == nil || len(changes) > 0 {
 		c.lastCacheHash = c.LastHash
 		cache, err := automerge.As[*MeshCrdt](c.doc.Root())

@ -113,7 +134,7 @@ func NewCrdtNodeManager(params *NewCrdtNodeMangerParams) (*CrdtMeshManager, erro
 // NodeExists: returns true if the node exists. Returns false
 func (m *CrdtMeshManager) NodeExists(key string) bool {
 	node, err := m.doc.Path("nodes").Map().Get(key)
-	return node.Kind() == automerge.KindMap && err != nil
+	return node.Kind() == automerge.KindMap && err == nil
 }

 func (m *CrdtMeshManager) GetNode(endpoint string) (mesh.MeshNode, error) {
@ -450,6 +471,12 @@ func (m *MeshNodeCrdt) GetServices() map[string]string {
 	return services
 }

+// GetType refers to the type of the node. Peer means that the node is globally accessible
+// Client means the node is only accessible through another peer
+func (n *MeshNodeCrdt) GetType() conf.NodeType {
+	return conf.NodeType(n.Type)
+}
+
 func (m *MeshCrdt) GetNodes() map[string]mesh.MeshNode {
 	nodes := make(map[string]mesh.MeshNode)

@ -464,6 +491,7 @@ func (m *MeshCrdt) GetNodes() map[string]mesh.MeshNode {
 			Description:  node.Description,
 			Alias:        node.Alias,
 			Services:     node.GetServices(),
+			Type:         node.Type,
 		}
 	}

--- a/pkg/automerge/factory.go
+++ b/pkg/automerge/factory.go
@ -28,8 +28,14 @@ type MeshNodeFactory struct {
 func (f *MeshNodeFactory) Build(params *mesh.MeshNodeFactoryParams) mesh.MeshNode {
 	hostName := f.getAddress(params)

+	grpcEndpoint := fmt.Sprintf("%s:%s", hostName, f.Config.GrpcPort)
+
+	if f.Config.Role == conf.CLIENT_ROLE {
+		grpcEndpoint = "-"
+	}
+
 	return &MeshNodeCrdt{
-		HostEndpoint: fmt.Sprintf("%s:%s", hostName, f.Config.GrpcPort),
+		HostEndpoint: grpcEndpoint,
 		PublicKey:    params.PublicKey.String(),
 		WgEndpoint:   fmt.Sprintf("%s:%d", hostName, params.WgPort),
 		WgHost:       fmt.Sprintf("%s/128", params.NodeIP.String()),
@ -38,6 +44,7 @@ func (f *MeshNodeFactory) Build(params *mesh.MeshNodeFactoryParams) mesh.MeshNod
 		Routes:      map[string]interface{}{},
 		Description: "",
 		Alias:       "",
+		Type:        string(f.Config.Role),
 	}
 }

@ -50,7 +57,19 @@ func (f *MeshNodeFactory) getAddress(params *mesh.MeshNodeFactoryParams) string
 	} else if len(f.Config.Endpoint) != 0 {
 		hostName = f.Config.Endpoint
 	} else {
-		hostName = lib.GetOutboundIP().String()
+		ipFunc := lib.GetPublicIP
+
+		if f.Config.IPDiscovery == conf.DNS_IP_DISCOVERY {
+			ipFunc = lib.GetOutboundIP
+		}
+
+		ip, err := ipFunc()
+
+		if err != nil {
+			return ""
+		}
+
+		hostName = ip.String()
 	}

 	return hostName
--- a/pkg/automerge/types.go
+++ b/pkg/automerge/types.go
@ -11,6 +11,7 @@ type MeshNodeCrdt struct {
 	Alias        string                 `automerge:"alias"`
 	Description  string                 `automerge:"description"`
 	Services     map[string]string      `automerge:"services"`
+	Type         string                 `automerge:"type"`
 }

 // MeshCrdt: Represents the mesh network as a whole
--- a/pkg/conf/conf.go
+++ b/pkg/conf/conf.go
@ -16,6 +16,20 @@ func (m *WgMeshConfigurationError) Error() string {
 	return m.msg
 }

+type NodeType string
+
+const (
+	PEER_ROLE   NodeType = "peer"
+	CLIENT_ROLE NodeType = "client"
+)
+
+type IPDiscovery string
+
+const (
+	PUBLIC_IP_DISCOVERY = "public"
+	DNS_IP_DISCOVERY    = "dns"
+)
+
 type WgMeshConfiguration struct {
 	// CertificatePath is the path to the certificate to use in mTLS
 	CertificatePath string `yaml:"certificatePath"`
@ -28,6 +42,9 @@ type WgMeshConfiguration struct {
 	SkipCertVerification bool `yaml:"skipCertVerification"`
 	// Port to run the GrpcServer on
 	GrpcPort string `yaml:"gRPCPort"`
+	// IPDIscovery: how to discover your IP if not specified. Use DNS server 8.8.8.8 or
+	// use public IP discovery library
+	IPDiscovery IPDiscovery `yaml:"ipDiscovery"`
 	// AdvertiseRoutes advertises other meshes if the node is in multiple meshes
 	AdvertiseRoutes bool `yaml:"advertiseRoutes"`
 	// Endpoint is the IP in which this computer is publicly reachable.
@ -53,6 +70,12 @@ type WgMeshConfiguration struct {
 	Profile bool `yaml:"profile"`
 	// StubWg whether or not to stub the WireGuard types
 	StubWg bool `yaml:"stubWg"`
+	// Role specifies whether or not the user is globally accessible.
+	// If the user is globaly accessible they specify themselves as a client.
+	Role NodeType `yaml:"role"`
+	// KeepAliveWg configures the implementation so that we send keep alive packets to peers.
+	// KeepAlive can only be set if role is type client
+	KeepAliveWg int `yaml:"keepAliveWg"`
 }

 func ValidateConfiguration(c *WgMeshConfiguration) error {
@ -134,6 +157,14 @@ func ValidateConfiguration(c *WgMeshConfiguration) error {
 		}
 	}

+	if c.Role == "" {
+		c.Role = PEER_ROLE
+	}
+
+	if c.IPDiscovery == "" {
+		c.IPDiscovery = PUBLIC_IP_DISCOVERY
+	}
+
 	return nil
 }

--- a/pkg/ctrlserver/ctrlserver.go
+++ b/pkg/ctrlserver/ctrlserver.go
@ -35,7 +35,7 @@ func NewCtrlServer(params *NewCtrlServerParams) (*MeshCtrlServer, error) {
 	ipAllocator := &ip.ULABuilder{}
 	interfaceManipulator := wg.NewWgInterfaceManipulator(params.Client)

-	configApplyer := mesh.NewWgMeshConfigApplyer()
+	configApplyer := mesh.NewWgMeshConfigApplyer(params.Conf)

 	meshManagerParams := &mesh.NewMeshManagerParams{
 		Conf:                 *params.Conf,
--- a/pkg/grpc/ctrlserver/ctrlserver.proto
+++ b/pkg/grpc/ctrlserver/ctrlserver.proto
@ -4,13 +4,13 @@ package rpctypes;
 option go_package = "pkg/rpc";

 service MeshCtrlServer {
-    rpc JoinMesh(JoinMeshRequest) returns (JoinMeshReply) {}
+    rpc GetMesh(GetMeshRequest) returns (GetMeshReply) {} 
 }

-message JoinMeshRequest {
-    string meshId = 2;
+message GetMeshRequest {
+    string meshId = 1;
 }

-message JoinMeshReply {
-    bool success = 1;
+message GetMeshReply {
+    bytes mesh = 1;
 }
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@ -11,8 +11,6 @@ import (
 )

 type NewMeshArgs struct {
-	// IfName is the interface that the mesh instance will run on
-	IfName string
 	// WgPort is the WireGuard port to expose
 	WgPort int
 	// Endpoint is the routable alias of the machine. Can be an IP
@ -25,13 +23,14 @@ type JoinMeshArgs struct {
 	MeshId string
 	// IpAddress is a routable IP in another mesh
 	IpAdress string
-	// IfName is the interface name of the mesh
-	IfName string
 	// Port is the WireGuard port to expose
 	Port int
 	// Endpoint is the routable address of this machine. If not provided
 	// defaults to the default address
 	Endpoint string
+	// Client specifies whether we should join as a client of the peer
+	// we are connecting to
+	Client bool
 }

 type PutServiceArgs struct {
--- a/pkg/lib/hashing.go
+++ b/pkg/lib/hashing.go
@ -0,0 +1,46 @@
+package lib
+
+import (
+	"hash/fnv"
+	"sort"
+)
+
+type consistentHashRecord[V any] struct {
+	record V
+	value  int
+}
+
+func HashString(value string) int {
+	f := fnv.New32a()
+	f.Write([]byte(value))
+	return int(f.Sum32())
+}
+
+// ConsistentHash implementation. Traverse the values until we find a key
+// less than ours.
+func ConsistentHash[V any](values []V, client V, keyFunc func(V) int) V {
+	if len(values) == 0 {
+		panic("values is empty")
+	}
+
+	vs := Map(values, func(v V) consistentHashRecord[V] {
+		return consistentHashRecord[V]{
+			v,
+			keyFunc(v),
+		}
+	})
+
+	sort.SliceStable(vs, func(i, j int) bool {
+		return vs[i].value < vs[j].value
+	})
+
+	ourKey := keyFunc(client)
+
+	for _, record := range vs {
+		if ourKey < record.value {
+			return record.record
+		}
+	}
+
+	return vs[0].record
+}
--- a/pkg/lib/ip.go
+++ b/pkg/lib/ip.go
@ -1,17 +1,61 @@
 package lib

 import (
+	"encoding/json"
+	"io"
 	"log"
 	"net"
+	"net/http"
 )

 // GetOutboundIP: gets the oubound IP of this packet
-func GetOutboundIP() net.IP {
+func GetOutboundIP() (net.IP, error) {
 	conn, err := net.Dial("udp", "8.8.8.8:80")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer conn.Close()
 	localAddr := conn.LocalAddr().(*net.UDPAddr)
-	return localAddr.IP
+	return localAddr.IP, nil
+}
+
+const IP_SERVICE = "https://api.ipify.org?format=json"
+
+type IpResponse struct {
+	Ip string `json:"ip"`
+}
+
+func (i *IpResponse) GetIP() net.IP {
+	return net.ParseIP(i.Ip)
+}
+
+// GetPublicIP: get the nodes public IP address. For when a node is behind NAT
+func GetPublicIP() (net.IP, error) {
+	req, err := http.NewRequest(http.MethodGet, IP_SERVICE, nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := http.DefaultClient.Do(req)
+
+	if err != nil {
+		return nil, err
+	}
+
+	resBody, err := io.ReadAll(res.Body)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var jsonResponse IpResponse
+
+	err = json.Unmarshal([]byte(resBody), &jsonResponse)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return jsonResponse.GetIP(), nil
 }
--- a/pkg/mesh/config.go
+++ b/pkg/mesh/config.go
@ -3,7 +3,12 @@ package mesh
 import (
 	"fmt"
 	"net"
+	"slices"
+	"time"

+	"github.com/tim-beatham/wgmesh/pkg/conf"
+	"github.com/tim-beatham/wgmesh/pkg/lib"
+	"github.com/tim-beatham/wgmesh/pkg/route"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

@ -16,10 +21,12 @@ type MeshConfigApplyer interface {

 // WgMeshConfigApplyer applies WireGuard configuration
 type WgMeshConfigApplyer struct {
-	meshManager MeshManager
+	meshManager    MeshManager
+	config         *conf.WgMeshConfiguration
+	routeInstaller route.RouteInstaller
 }

-func convertMeshNode(node MeshNode) (*wgtypes.PeerConfig, error) {
+func (m *WgMeshConfigApplyer) convertMeshNode(node MeshNode, device *wgtypes.Device, peerToClients map[string][]net.IPNet) (*wgtypes.PeerConfig, error) {
 	endpoint, err := net.ResolveUDPAddr("udp", node.GetWgEndpoint())

 	if err != nil {
@ -40,10 +47,28 @@ func convertMeshNode(node MeshNode) (*wgtypes.PeerConfig, error) {
 		allowedips = append(allowedips, *ipnet)
 	}

+	clients, ok := peerToClients[node.GetWgHost().String()]
+
+	if ok {
+		allowedips = append(allowedips, clients...)
+	}
+
+	keepAlive := time.Duration(m.config.KeepAliveWg) * time.Second
+
+	existing := slices.IndexFunc(device.Peers, func(p wgtypes.Peer) bool {
+		pubKey, _ := node.GetPublicKey()
+		return p.PublicKey.String() == pubKey.String()
+	})
+
+	if existing != -1 {
+		endpoint = device.Peers[existing].Endpoint
+	}
+
 	peerConfig := wgtypes.PeerConfig{
-		PublicKey:  pubKey,
-		Endpoint:   endpoint,
-		AllowedIPs: allowedips,
+		PublicKey:                   pubKey,
+		Endpoint:                    endpoint,
+		AllowedIPs:                  allowedips,
+		PersistentKeepaliveInterval: &keepAlive,
 	}

 	return &peerConfig, nil
@ -56,13 +81,68 @@ func (m *WgMeshConfigApplyer) updateWgConf(mesh MeshProvider) error {
 		return err
 	}

-	nodes := snap.GetNodes()
+	nodes := lib.MapValues(snap.GetNodes())
 	peerConfigs := make([]wgtypes.PeerConfig, len(nodes))

+	peers := lib.Filter(nodes, func(mn MeshNode) bool {
+		return mn.GetType() == conf.PEER_ROLE
+	})
+
 	var count int = 0

+	self, err := m.meshManager.GetSelf(mesh.GetMeshId())
+
+	if err != nil {
+		return err
+	}
+
+	rtnl, err := lib.NewRtNetlinkConfig()
+
+	if err != nil {
+		return err
+	}
+
+	peerToClients := make(map[string][]net.IPNet)
+
 	for _, n := range nodes {
-		peer, err := convertMeshNode(n)
+		if NodeEquals(n, self) {
+			continue
+		}
+
+		if n.GetType() == conf.CLIENT_ROLE && len(peers) > 0 && self.GetType() == conf.CLIENT_ROLE {
+			peer := lib.ConsistentHash(peers, n, func(mn MeshNode) int {
+				return lib.HashString(mn.GetWgHost().String())
+			})
+
+			dev, err := mesh.GetDevice()
+
+			if err != nil {
+				return err
+			}
+
+			rtnl.AddRoute(dev.Name, lib.Route{
+				Gateway:     peer.GetWgHost().IP,
+				Destination: *n.GetWgHost(),
+			})
+
+			if err != nil {
+				return err
+			}
+
+			clients, ok := peerToClients[peer.GetWgHost().String()]
+
+			if !ok {
+				clients = make([]net.IPNet, 0)
+				peerToClients[peer.GetWgHost().String()] = clients
+			}
+
+			peerToClients[peer.GetWgHost().String()] = append(clients, *n.GetWgHost())
+			continue
+		}
+
+		dev, _ := mesh.GetDevice()
+
+		peer, err := m.convertMeshNode(n, dev, peerToClients)

 		if err != nil {
 			return err
@ -112,7 +192,7 @@ func (m *WgMeshConfigApplyer) RemovePeers(meshId string) error {

 	m.meshManager.GetClient().ConfigureDevice(dev.Name, wgtypes.Config{
 		ReplacePeers: true,
-		Peers:        make([]wgtypes.PeerConfig, 1),
+		Peers:        make([]wgtypes.PeerConfig, 0),
 	})

 	return nil
@ -122,6 +202,9 @@ func (m *WgMeshConfigApplyer) SetMeshManager(manager MeshManager) {
 	m.meshManager = manager
 }

-func NewWgMeshConfigApplyer() MeshConfigApplyer {
-	return &WgMeshConfigApplyer{}
+func NewWgMeshConfigApplyer(config *conf.WgMeshConfiguration) MeshConfigApplyer {
+	return &WgMeshConfigApplyer{
+		config:         config,
+		routeInstaller: route.NewRouteInstaller(),
+	}
 }
--- a/pkg/mesh/manager.go
+++ b/pkg/mesh/manager.go
@ -14,7 +14,7 @@ import (
 )

 type MeshManager interface {
-	CreateMesh(devName string, port int) (string, error)
+	CreateMesh(port int) (string, error)
 	AddMesh(params *AddMeshParams) error
 	HasChanges(meshid string) bool
 	GetMesh(meshId string) MeshProvider
@ -57,7 +57,7 @@ type MeshManagerImpl struct {
 // RemoveService implements MeshManager.
 func (m *MeshManagerImpl) RemoveService(service string) error {
 	for _, mesh := range m.Meshes {
-		err := mesh.RemoveService(m.HostParameters.HostEndpoint, service)
+		err := mesh.RemoveService(m.HostParameters.GetPublicKey(), service)

 		if err != nil {
 			return err
@ -70,7 +70,7 @@ func (m *MeshManagerImpl) RemoveService(service string) error {
 // SetService implements MeshManager.
 func (m *MeshManagerImpl) SetService(service string, value string) error {
 	for _, mesh := range m.Meshes {
-		err := mesh.AddService(m.HostParameters.HostEndpoint, service, value)
+		err := mesh.AddService(m.HostParameters.GetPublicKey(), service, value)

 		if err != nil {
 			return err
@ -115,15 +115,25 @@ func (m *MeshManagerImpl) Prune() error {
 }

 // CreateMesh: Creates a new mesh, stores it and returns the mesh id
-func (m *MeshManagerImpl) CreateMesh(devName string, port int) (string, error) {
+func (m *MeshManagerImpl) CreateMesh(port int) (string, error) {
 	meshId, err := m.idGenerator.GetId()

+	var ifName string = ""
+
 	if err != nil {
 		return "", err
 	}

+	if !m.conf.StubWg {
+		ifName, err = m.interfaceManipulator.CreateInterface(port, m.HostParameters.PrivateKey)
+
+		if err != nil {
+			return "", fmt.Errorf("error creating mesh: %w", err)
+		}
+	}
+
 	nodeManager, err := m.meshProviderFactory.CreateMesh(&MeshProviderFactoryParams{
-		DevName: devName,
+		DevName: ifName,
 		Port:    port,
 		Conf:    m.conf,
 		Client:  m.Client,
@ -134,32 +144,31 @@ func (m *MeshManagerImpl) CreateMesh(devName string, port int) (string, error) {
 		return "", fmt.Errorf("error creating mesh: %w", err)
 	}

-	if !m.conf.StubWg {
-		err = m.interfaceManipulator.CreateInterface(&wg.CreateInterfaceParams{
-			IfName: devName,
-			Port:   port,
-		})
-
-		if err != nil {
-			return "", fmt.Errorf("error creating mesh: %w", err)
-		}
-	}
-
 	m.Meshes[meshId] = nodeManager
 	return meshId, nil
 }

 type AddMeshParams struct {
 	MeshId    string
-	DevName   string
 	WgPort    int
 	MeshBytes []byte
 }

 // AddMesh: Add the mesh to the list of meshes
 func (m *MeshManagerImpl) AddMesh(params *AddMeshParams) error {
+	var ifName string
+	var err error
+
+	if !m.conf.StubWg {
+		ifName, err = m.interfaceManipulator.CreateInterface(params.WgPort, m.HostParameters.PrivateKey)
+
+		if err != nil {
+			return err
+		}
+	}
+
 	meshProvider, err := m.meshProviderFactory.CreateMesh(&MeshProviderFactoryParams{
-		DevName: params.DevName,
+		DevName: ifName,
 		Port:    params.WgPort,
 		Conf:    m.conf,
 		Client:  m.Client,
@ -177,14 +186,6 @@ func (m *MeshManagerImpl) AddMesh(params *AddMeshParams) error {
 	}

 	m.Meshes[params.MeshId] = meshProvider
-
-	if !m.conf.StubWg {
-		return m.interfaceManipulator.CreateInterface(&wg.CreateInterfaceParams{
-			IfName: params.DevName,
-			Port:   params.WgPort,
-		})
-	}
-
 	return nil
 }

@ -255,6 +256,16 @@ func (s *MeshManagerImpl) AddSelf(params *AddSelfParams) error {
 		return fmt.Errorf("addself: mesh %s does not exist", params.MeshId)
 	}

+	if params.WgPort == 0 && !s.conf.StubWg {
+		device, err := mesh.GetDevice()
+
+		if err != nil {
+			return err
+		}
+
+		params.WgPort = device.ListenPort
+	}
+
 	pubKey, err := s.GetPublicKey(params.MeshId)

 	if err != nil {
@ -327,7 +338,8 @@ func (s *MeshManagerImpl) GetSelf(meshId string) (MeshNode, error) {
 		return nil, fmt.Errorf("mesh %s does not exist", meshId)
 	}

-	node, err := meshInstance.GetNode(s.HostParameters.HostEndpoint)
+	logging.Log.WriteInfof(s.HostParameters.GetPublicKey())
+	node, err := meshInstance.GetNode(s.HostParameters.GetPublicKey())

 	if err != nil {
 		return nil, errors.New("the node doesn't exist in the mesh")
@ -337,6 +349,10 @@ func (s *MeshManagerImpl) GetSelf(meshId string) (MeshNode, error) {
 }

 func (s *MeshManagerImpl) ApplyConfig() error {
+	if s.conf.StubWg {
+		return nil
+	}
+
 	err := s.configApplyer.ApplyConfig()

 	if err != nil {
@ -348,8 +364,8 @@ func (s *MeshManagerImpl) ApplyConfig() error {

 func (s *MeshManagerImpl) SetDescription(description string) error {
 	for _, mesh := range s.Meshes {
-		if mesh.NodeExists(s.HostParameters.HostEndpoint) {
-			err := mesh.SetDescription(s.HostParameters.HostEndpoint, description)
+		if mesh.NodeExists(s.HostParameters.GetPublicKey()) {
+			err := mesh.SetDescription(s.HostParameters.GetPublicKey(), description)

 			if err != nil {
 				return err
@ -363,8 +379,8 @@ func (s *MeshManagerImpl) SetDescription(description string) error {
 // SetAlias implements MeshManager.
 func (s *MeshManagerImpl) SetAlias(alias string) error {
 	for _, mesh := range s.Meshes {
-		if mesh.NodeExists(s.HostParameters.HostEndpoint) {
-			err := mesh.SetAlias(s.HostParameters.HostEndpoint, alias)
+		if mesh.NodeExists(s.HostParameters.GetPublicKey()) {
+			err := mesh.SetAlias(s.HostParameters.GetPublicKey(), alias)

 			if err != nil {
 				return err
@ -377,8 +393,8 @@ func (s *MeshManagerImpl) SetAlias(alias string) error {
 // UpdateTimeStamp updates the timestamp of this node in all meshes
 func (s *MeshManagerImpl) UpdateTimeStamp() error {
 	for _, mesh := range s.Meshes {
-		if mesh.NodeExists(s.HostParameters.HostEndpoint) {
-			err := mesh.UpdateTimeStamp(s.HostParameters.HostEndpoint)
+		if mesh.NodeExists(s.HostParameters.GetPublicKey()) {
+			err := mesh.UpdateTimeStamp(s.HostParameters.GetPublicKey())

 			if err != nil {
 				return err
@ -435,17 +451,11 @@ type NewMeshManagerParams struct {

 // Creates a new instance of a mesh manager with the given parameters
 func NewMeshManager(params *NewMeshManagerParams) MeshManager {
-	hostParams := HostParameters{}
-
-	switch params.Conf.Endpoint {
-	case "":
-		hostParams.HostEndpoint = fmt.Sprintf("%s:%s", lib.GetOutboundIP().String(), params.Conf.GrpcPort)
-	default:
-		hostParams.HostEndpoint = fmt.Sprintf("%s:%s", params.Conf.Endpoint, params.Conf.GrpcPort)
+	privateKey, _ := wgtypes.GeneratePrivateKey()
+	hostParams := HostParameters{
+		PrivateKey: &privateKey,
 	}

-	logging.Log.WriteInfof("Endpoint %s", hostParams.HostEndpoint)
-
 	m := &MeshManagerImpl{
 		Meshes:              make(map[string]MeshProvider),
 		HostParameters:      &hostParams,
--- a/pkg/mesh/manager_test.go
+++ b/pkg/mesh/manager_test.go
@ -201,8 +201,8 @@ func TestSetDescription(t *testing.T) {
 	manager := getMeshManager()
 	description := "wooooo"

-	meshId1, _ := manager.CreateMesh("wg0", 5000)
-	meshId2, _ := manager.CreateMesh("wg0", 5001)
+	meshId1, _ := manager.CreateMesh(5000)
+	meshId2, _ := manager.CreateMesh(5001)

 	manager.AddSelf(&AddSelfParams{
 		MeshId:   meshId1,
@ -225,8 +225,8 @@ func TestSetDescription(t *testing.T) {
 func TestUpdateTimeStampUpdatesAllMeshes(t *testing.T) {
 	manager := getMeshManager()

-	meshId1, _ := manager.CreateMesh("wg0", 5000)
-	meshId2, _ := manager.CreateMesh("wg0", 5001)
+	meshId1, _ := manager.CreateMesh(5000)
+	meshId2, _ := manager.CreateMesh(5001)

 	manager.AddSelf(&AddSelfParams{
 		MeshId:   meshId1,
--- a/pkg/mesh/stub_types.go
+++ b/pkg/mesh/stub_types.go
@ -21,6 +21,11 @@ type MeshNodeStub struct {
 	description  string
 }

+// GetType implements MeshNode.
+func (*MeshNodeStub) GetType() conf.NodeType {
+	return PEER
+}
+
 // GetServices implements MeshNode.
 func (*MeshNodeStub) GetServices() map[string]string {
 	return make(map[string]string)
@ -77,28 +82,28 @@ type MeshProviderStub struct {
 }

 // GetNodeIds implements MeshProvider.
-func (*MeshProviderStub) GetNodeIds() []string {
-	panic("unimplemented")
+func (*MeshProviderStub) GetPeers() []string {
+	return make([]string, 0)
 }

 // GetNode implements MeshProvider.
 func (*MeshProviderStub) GetNode(string) (MeshNode, error) {
-	panic("unimplemented")
+	return nil, nil
 }

 // NodeExists implements MeshProvider.
 func (*MeshProviderStub) NodeExists(string) bool {
-	panic("unimplemented")
+	return false
 }

 // AddService implements MeshProvider.
 func (*MeshProviderStub) AddService(nodeId string, key string, value string) error {
-	panic("unimplemented")
+	return nil
 }

 // RemoveService implements MeshProvider.
 func (*MeshProviderStub) RemoveService(nodeId string, key string) error {
-	panic("unimplemented")
+	return nil
 }

 // SetAlias implements MeshProvider.
@ -108,7 +113,7 @@ func (*MeshProviderStub) SetAlias(nodeId string, alias string) error {

 // RemoveRoutes implements MeshProvider.
 func (*MeshProviderStub) RemoveRoutes(nodeId string, route ...string) error {
-	panic("unimplemented")
+	return nil
 }

 // Prune implements MeshProvider.
@ -250,7 +255,7 @@ func NewMeshManagerStub() MeshManager {
 	return &MeshManagerStub{meshes: make(map[string]MeshProvider)}
 }

-func (m *MeshManagerStub) CreateMesh(devName string, port int) (string, error) {
+func (m *MeshManagerStub) CreateMesh(port int) (string, error) {
 	return "tim123", nil
 }

--- a/pkg/mesh/types.go
+++ b/pkg/mesh/types.go
@ -4,13 +4,19 @@ package mesh

 import (
 	"net"
-	"slices"

 	"github.com/tim-beatham/wgmesh/pkg/conf"
 	"golang.zx2c4.com/wireguard/wgctrl"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )

+const (
+	// Data Exchanged Between Peers
+	PEER conf.NodeType = "peer"
+	// Data Exchanged Between Clients
+	CLIENT conf.NodeType = "client"
+)
+
 // MeshNode represents an implementation of a node in a mesh
 type MeshNode interface {
 	// GetHostEndpoint: gets the gRPC endpoint of the node
@ -34,46 +40,12 @@ type MeshNode interface {
 	GetAlias() string
 	// GetServices: returns a list of services offered by the node
 	GetServices() map[string]string
+	GetType() conf.NodeType
 }

 // NodeEquals: determines if two mesh nodes are equivalent to one another
 func NodeEquals(node1, node2 MeshNode) bool {
-	if node1.GetHostEndpoint() != node2.GetHostEndpoint() {
-		return false
-	}
-
-	node1Pub, _ := node1.GetPublicKey()
-	node2Pub, _ := node2.GetPublicKey()
-
-	if node1Pub != node2Pub {
-		return false
-	}
-
-	if node1.GetWgEndpoint() != node2.GetWgEndpoint() {
-		return false
-	}
-
-	if node1.GetWgHost() != node2.GetWgHost() {
-		return false
-	}
-
-	if !slices.Equal(node1.GetRoutes(), node2.GetRoutes()) {
-		return false
-	}
-
-	if node1.GetIdentifier() != node2.GetIdentifier() {
-		return false
-	}
-
-	if node1.GetDescription() != node2.GetDescription() {
-		return false
-	}
-
-	if node1.GetAlias() != node2.GetAlias() {
-		return false
-	}
-
-	return true
+	return node1.GetHostEndpoint() == node2.GetHostEndpoint()
 }

 type MeshSnapshot interface {
@ -129,12 +101,17 @@ type MeshProvider interface {
 	// Prune: prunes all nodes that have not updated their timestamp in
 	// pruneAmount seconds
 	Prune(pruneAmount int) error
-	GetNodeIds() []string
+	GetPeers() []string
 }

 // HostParameters contains the IDs of a node
 type HostParameters struct {
-	HostEndpoint string
+	PrivateKey *wgtypes.Key
+}
+
+// GetPublicKey: gets the public key of the node
+func (h *HostParameters) GetPublicKey() string {
+	return h.PrivateKey.PublicKey().String()
 }

 // MeshProviderFactoryParams parameters required to build a mesh provider
--- a/pkg/query/query.go
+++ b/pkg/query/query.go
@ -5,6 +5,7 @@ import (
 	"fmt"

 	"github.com/jmespath/go-jmespath"
+	"github.com/tim-beatham/wgmesh/pkg/conf"
 	"github.com/tim-beatham/wgmesh/pkg/lib"
 	"github.com/tim-beatham/wgmesh/pkg/mesh"
 )
@ -28,11 +29,12 @@ type QueryNode struct {
 	PublicKey    string            `json:"publicKey"`
 	WgEndpoint   string            `json:"wgEndpoint"`
 	WgHost       string            `json:"wgHost"`
-	Timestamp    int64             `json:"timestmap"`
+	Timestamp    int64             `json:"timestamp"`
 	Description  string            `json:"description"`
 	Routes       []string          `json:"routes"`
 	Alias        string            `json:"alias"`
 	Services     map[string]string `json:"services"`
+	Type         conf.NodeType     `json:"type"`
 }

 func (m *QueryError) Error() string {
@ -80,6 +82,7 @@ func MeshNodeToQueryNode(node mesh.MeshNode) *QueryNode {
 	queryNode.Description = node.GetDescription()
 	queryNode.Alias = node.GetAlias()
 	queryNode.Services = node.GetServices()
+	queryNode.Type = node.GetType()

 	return queryNode
 }
--- a/pkg/robin/requester.go
+++ b/pkg/robin/requester.go
@ -20,7 +20,7 @@ type IpcHandler struct {
 }

 func (n *IpcHandler) CreateMesh(args *ipc.NewMeshArgs, reply *string) error {
-	meshId, err := n.Server.GetMeshManager().CreateMesh(args.IfName, args.WgPort)
+	meshId, err := n.Server.GetMeshManager().CreateMesh(args.WgPort)

 	if err != nil {
 		return err
@ -72,7 +72,9 @@ func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {
 		return err
 	}

-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	configuration := n.Server.GetConfiguration()
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(configuration.Timeout))
 	defer cancel()

 	meshReply, err := c.GetMesh(ctx, &rpc.GetMeshRequest{MeshId: args.MeshId})
@ -83,7 +85,6 @@ func (n *IpcHandler) JoinMesh(args ipc.JoinMeshArgs, reply *string) error {

 	err = n.Server.GetMeshManager().AddMesh(&mesh.AddMeshParams{
 		MeshId:    args.MeshId,
-		DevName:   args.IfName,
 		WgPort:    args.Port,
 		MeshBytes: meshReply.Mesh,
 	})
--- a/pkg/robin/responder.go
+++ b/pkg/robin/responder.go
@ -28,7 +28,3 @@ func (m *WgRpc) GetMesh(ctx context.Context, request *rpc.GetMeshRequest) (*rpc.

 	return &reply, nil
 }
-
-func (m *WgRpc) JoinMesh(ctx context.Context, request *rpc.JoinMeshRequest) (*rpc.JoinMeshReply, error) {
-	return &rpc.JoinMeshReply{Success: true}, nil
-}
--- a/pkg/rpc/ctrlserver.pb.go
+++ b/pkg/rpc/ctrlserver.pb.go
@ -20,77 +20,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )

-type MeshNode struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	PublicKey  string `protobuf:"bytes,1,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
-	WgEndpoint string `protobuf:"bytes,2,opt,name=wgEndpoint,proto3" json:"wgEndpoint,omitempty"`
-	Endpoint   string `protobuf:"bytes,3,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
-	WgHost     string `protobuf:"bytes,4,opt,name=wgHost,proto3" json:"wgHost,omitempty"`
-}
-
-func (x *MeshNode) Reset() {
-	*x = MeshNode{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *MeshNode) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*MeshNode) ProtoMessage() {}
-
-func (x *MeshNode) ProtoReflect() protoreflect.Message {
-	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use MeshNode.ProtoReflect.Descriptor instead.
-func (*MeshNode) Descriptor() ([]byte, []int) {
-	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *MeshNode) GetPublicKey() string {
-	if x != nil {
-		return x.PublicKey
-	}
-	return ""
-}
-
-func (x *MeshNode) GetWgEndpoint() string {
-	if x != nil {
-		return x.WgEndpoint
-	}
-	return ""
-}
-
-func (x *MeshNode) GetEndpoint() string {
-	if x != nil {
-		return x.Endpoint
-	}
-	return ""
-}
-
-func (x *MeshNode) GetWgHost() string {
-	if x != nil {
-		return x.WgHost
-	}
-	return ""
-}
-
 type GetMeshRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@ -102,7 +31,7 @@ type GetMeshRequest struct {
 func (x *GetMeshRequest) Reset() {
 	*x = GetMeshRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1]
+		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[0]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@ -115,7 +44,7 @@ func (x *GetMeshRequest) String() string {
 func (*GetMeshRequest) ProtoMessage() {}

 func (x *GetMeshRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1]
+	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[0]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@ -128,7 +57,7 @@ func (x *GetMeshRequest) ProtoReflect() protoreflect.Message {

 // Deprecated: Use GetMeshRequest.ProtoReflect.Descriptor instead.
 func (*GetMeshRequest) Descriptor() ([]byte, []int) {
-	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{1}
+	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{0}
 }

 func (x *GetMeshRequest) GetMeshId() string {
@ -149,7 +78,7 @@ type GetMeshReply struct {
 func (x *GetMeshReply) Reset() {
 	*x = GetMeshReply{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[2]
+		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@ -162,7 +91,7 @@ func (x *GetMeshReply) String() string {
 func (*GetMeshReply) ProtoMessage() {}

 func (x *GetMeshReply) ProtoReflect() protoreflect.Message {
-	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[2]
+	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@ -175,7 +104,7 @@ func (x *GetMeshReply) ProtoReflect() protoreflect.Message {

 // Deprecated: Use GetMeshReply.ProtoReflect.Descriptor instead.
 func (*GetMeshReply) Descriptor() ([]byte, []int) {
-	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{2}
+	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{1}
 }

 func (x *GetMeshReply) GetMesh() []byte {
@ -185,145 +114,24 @@ func (x *GetMeshReply) GetMesh() []byte {
 	return nil
 }

-type JoinMeshRequest struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Changes []byte `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"`
-	MeshId  string `protobuf:"bytes,2,opt,name=meshId,proto3" json:"meshId,omitempty"`
-}
-
-func (x *JoinMeshRequest) Reset() {
-	*x = JoinMeshRequest{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *JoinMeshRequest) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*JoinMeshRequest) ProtoMessage() {}
-
-func (x *JoinMeshRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use JoinMeshRequest.ProtoReflect.Descriptor instead.
-func (*JoinMeshRequest) Descriptor() ([]byte, []int) {
-	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *JoinMeshRequest) GetChanges() []byte {
-	if x != nil {
-		return x.Changes
-	}
-	return nil
-}
-
-func (x *JoinMeshRequest) GetMeshId() string {
-	if x != nil {
-		return x.MeshId
-	}
-	return ""
-}
-
-type JoinMeshReply struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
-}
-
-func (x *JoinMeshReply) Reset() {
-	*x = JoinMeshReply{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *JoinMeshReply) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*JoinMeshReply) ProtoMessage() {}
-
-func (x *JoinMeshReply) ProtoReflect() protoreflect.Message {
-	mi := &file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use JoinMeshReply.ProtoReflect.Descriptor instead.
-func (*JoinMeshReply) Descriptor() ([]byte, []int) {
-	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *JoinMeshReply) GetSuccess() bool {
-	if x != nil {
-		return x.Success
-	}
-	return false
-}
-
 var File_pkg_grpc_ctrlserver_ctrlserver_proto protoreflect.FileDescriptor

 var file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDesc = []byte{
 	0x0a, 0x24, 0x70, 0x6b, 0x67, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x63, 0x74, 0x72, 0x6c, 0x73,
 	0x65, 0x72, 0x76, 0x65, 0x72, 0x2f, 0x63, 0x74, 0x72, 0x6c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
 	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x08, 0x72, 0x70, 0x63, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x22, 0x7c, 0x0a, 0x08, 0x4d, 0x65, 0x73, 0x68, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1c, 0x0a, 0x09,
-	0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x77, 0x67,
-	0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a,
-	0x77, 0x67, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e,
-	0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e,
-	0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x67, 0x48, 0x6f, 0x73, 0x74,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x77, 0x67, 0x48, 0x6f, 0x73, 0x74, 0x22, 0x28,
-	0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x73, 0x68, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x06, 0x6d, 0x65, 0x73, 0x68, 0x49, 0x64, 0x22, 0x22, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x4d,
-	0x65, 0x73, 0x68, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x65, 0x73, 0x68,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6d, 0x65, 0x73, 0x68, 0x22, 0x43, 0x0a, 0x0f,
-	0x4a, 0x6f, 0x69, 0x6e, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x73,
-	0x68, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x73, 0x68, 0x49,
-	0x64, 0x22, 0x29, 0x0a, 0x0d, 0x4a, 0x6f, 0x69, 0x6e, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x70,
-	0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x32, 0x91, 0x01, 0x0a,
-	0x0e, 0x4d, 0x65, 0x73, 0x68, 0x43, 0x74, 0x72, 0x6c, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12,
-	0x3d, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x12, 0x18, 0x2e, 0x72, 0x70, 0x63,
-	0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x72, 0x70, 0x63, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e,
-	0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x12, 0x40,
-	0x0a, 0x08, 0x4a, 0x6f, 0x69, 0x6e, 0x4d, 0x65, 0x73, 0x68, 0x12, 0x19, 0x2e, 0x72, 0x70, 0x63,
-	0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x72, 0x70, 0x63, 0x74, 0x79, 0x70, 0x65, 0x73,
-	0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00,
-	0x42, 0x09, 0x5a, 0x07, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x22, 0x28, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x73, 0x68, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x73, 0x68, 0x49, 0x64, 0x22, 0x22, 0x0a, 0x0c, 0x47, 0x65,
+	0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x65,
+	0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6d, 0x65, 0x73, 0x68, 0x32, 0x4f,
+	0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x68, 0x43, 0x74, 0x72, 0x6c, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
+	0x12, 0x3d, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x12, 0x18, 0x2e, 0x72, 0x70,
+	0x63, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x72, 0x70, 0x63, 0x74, 0x79, 0x70, 0x65, 0x73,
+	0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x68, 0x52, 0x65, 0x70, 0x6c, 0x79, 0x22, 0x00, 0x42,
+	0x09, 0x5a, 0x07, 0x70, 0x6b, 0x67, 0x2f, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 }

 var (
@ -338,21 +146,16 @@ func file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescGZIP() []byte {
 	return file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDescData
 }

-var file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
+var file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_pkg_grpc_ctrlserver_ctrlserver_proto_goTypes = []interface{}{
-	(*MeshNode)(nil),        // 0: rpctypes.MeshNode
-	(*GetMeshRequest)(nil),  // 1: rpctypes.GetMeshRequest
-	(*GetMeshReply)(nil),    // 2: rpctypes.GetMeshReply
-	(*JoinMeshRequest)(nil), // 3: rpctypes.JoinMeshRequest
-	(*JoinMeshReply)(nil),   // 4: rpctypes.JoinMeshReply
+	(*GetMeshRequest)(nil), // 0: rpctypes.GetMeshRequest
+	(*GetMeshReply)(nil),   // 1: rpctypes.GetMeshReply
 }
 var file_pkg_grpc_ctrlserver_ctrlserver_proto_depIdxs = []int32{
-	1, // 0: rpctypes.MeshCtrlServer.GetMesh:input_type -> rpctypes.GetMeshRequest
-	3, // 1: rpctypes.MeshCtrlServer.JoinMesh:input_type -> rpctypes.JoinMeshRequest
-	2, // 2: rpctypes.MeshCtrlServer.GetMesh:output_type -> rpctypes.GetMeshReply
-	4, // 3: rpctypes.MeshCtrlServer.JoinMesh:output_type -> rpctypes.JoinMeshReply
-	2, // [2:4] is the sub-list for method output_type
-	0, // [0:2] is the sub-list for method input_type
+	0, // 0: rpctypes.MeshCtrlServer.GetMesh:input_type -> rpctypes.GetMeshRequest
+	1, // 1: rpctypes.MeshCtrlServer.GetMesh:output_type -> rpctypes.GetMeshReply
+	1, // [1:2] is the sub-list for method output_type
+	0, // [0:1] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
@ -365,18 +168,6 @@ func file_pkg_grpc_ctrlserver_ctrlserver_proto_init() {
 	}
 	if !protoimpl.UnsafeEnabled {
 		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MeshNode); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetMeshRequest); i {
 			case 0:
 				return &v.state
@ -388,7 +179,7 @@ func file_pkg_grpc_ctrlserver_ctrlserver_proto_init() {
 				return nil
 			}
 		}
-		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*GetMeshReply); i {
 			case 0:
 				return &v.state
@ -400,30 +191,6 @@ func file_pkg_grpc_ctrlserver_ctrlserver_proto_init() {
 				return nil
 			}
 		}
-		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*JoinMeshRequest); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_pkg_grpc_ctrlserver_ctrlserver_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*JoinMeshReply); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@ -431,7 +198,7 @@ func file_pkg_grpc_ctrlserver_ctrlserver_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_pkg_grpc_ctrlserver_ctrlserver_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   5,
+			NumMessages:   2,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
--- a/pkg/rpc/ctrlserver_grpc.pb.go
+++ b/pkg/rpc/ctrlserver_grpc.pb.go
@ -23,7 +23,6 @@ const _ = grpc.SupportPackageIsVersion7
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type MeshCtrlServerClient interface {
 	GetMesh(ctx context.Context, in *GetMeshRequest, opts ...grpc.CallOption) (*GetMeshReply, error)
-	JoinMesh(ctx context.Context, in *JoinMeshRequest, opts ...grpc.CallOption) (*JoinMeshReply, error)
 }

 type meshCtrlServerClient struct {
@ -43,21 +42,11 @@ func (c *meshCtrlServerClient) GetMesh(ctx context.Context, in *GetMeshRequest,
 	return out, nil
 }

-func (c *meshCtrlServerClient) JoinMesh(ctx context.Context, in *JoinMeshRequest, opts ...grpc.CallOption) (*JoinMeshReply, error) {
-	out := new(JoinMeshReply)
-	err := c.cc.Invoke(ctx, "/rpctypes.MeshCtrlServer/JoinMesh", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 // MeshCtrlServerServer is the server API for MeshCtrlServer service.
 // All implementations must embed UnimplementedMeshCtrlServerServer
 // for forward compatibility
 type MeshCtrlServerServer interface {
 	GetMesh(context.Context, *GetMeshRequest) (*GetMeshReply, error)
-	JoinMesh(context.Context, *JoinMeshRequest) (*JoinMeshReply, error)
 	mustEmbedUnimplementedMeshCtrlServerServer()
 }

@ -68,9 +57,6 @@ type UnimplementedMeshCtrlServerServer struct {
 func (UnimplementedMeshCtrlServerServer) GetMesh(context.Context, *GetMeshRequest) (*GetMeshReply, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetMesh not implemented")
 }
-func (UnimplementedMeshCtrlServerServer) JoinMesh(context.Context, *JoinMeshRequest) (*JoinMeshReply, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method JoinMesh not implemented")
-}
 func (UnimplementedMeshCtrlServerServer) mustEmbedUnimplementedMeshCtrlServerServer() {}

 // UnsafeMeshCtrlServerServer may be embedded to opt out of forward compatibility for this service.
@ -102,24 +88,6 @@ func _MeshCtrlServer_GetMesh_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }

-func _MeshCtrlServer_JoinMesh_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(JoinMeshRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(MeshCtrlServerServer).JoinMesh(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/rpctypes.MeshCtrlServer/JoinMesh",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MeshCtrlServerServer).JoinMesh(ctx, req.(*JoinMeshRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 // MeshCtrlServer_ServiceDesc is the grpc.ServiceDesc for MeshCtrlServer service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@ -131,10 +99,6 @@ var MeshCtrlServer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "GetMesh",
 			Handler:    _MeshCtrlServer_GetMesh_Handler,
 		},
-		{
-			MethodName: "JoinMesh",
-			Handler:    _MeshCtrlServer_JoinMesh_Handler,
-		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "pkg/grpc/ctrlserver/ctrlserver.proto",
--- a/pkg/sync/syncer.go
+++ b/pkg/sync/syncer.go
@ -44,15 +44,20 @@ func (s *SyncerImpl) Sync(meshId string) error {
 		}
 	}

-	nodeNames := s.manager.GetMesh(meshId).GetNodeIds()
-
+	nodeNames := s.manager.GetMesh(meshId).GetPeers()
 	self, err := s.manager.GetSelf(meshId)

 	if err != nil {
 		return err
 	}

-	neighbours := s.cluster.GetNeighbours(nodeNames, self.GetHostEndpoint())
+	selfPublickey, err := self.GetPublicKey()
+
+	if err != nil {
+		return err
+	}
+
+	neighbours := s.cluster.GetNeighbours(nodeNames, selfPublickey.String())
 	randomSubset := lib.RandomSubsetOfLength(neighbours, s.conf.BranchRate)

 	for _, node := range randomSubset {
@ -63,7 +68,7 @@ func (s *SyncerImpl) Sync(meshId string) error {

 	if len(nodeNames) > s.conf.ClusterSize && rand.Float64() < s.conf.InterClusterChance {
 		logging.Log.WriteInfof("Sending to random cluster")
-		interCluster := s.cluster.GetInterCluster(nodeNames, self.GetHostEndpoint())
+		interCluster := s.cluster.GetInterCluster(nodeNames, selfPublickey.String())
 		randomSubset = append(randomSubset, interCluster)
 	}

@ -74,7 +79,14 @@ func (s *SyncerImpl) Sync(meshId string) error {

 		go func(i int) error {
 			defer waitGroup.Done()
-			err := s.requester.SyncMesh(meshId, randomSubset[i])
+
+			correspondingPeer := s.manager.GetNode(meshId, randomSubset[i])
+
+			if correspondingPeer == nil {
+				logging.Log.WriteErrorf("node %s does not exist", randomSubset[i])
+			}
+
+			err := s.requester.SyncMesh(meshId, correspondingPeer.GetHostEndpoint())
 			return err
 		}(index)
 	}
--- a/pkg/sync/syncrequester.go
+++ b/pkg/sync/syncrequester.go
@ -50,7 +50,6 @@ func (s *SyncRequesterImpl) GetMesh(meshId string, ifName string, port int, endP

 	err = s.server.MeshManager.AddMesh(&mesh.AddMeshParams{
 		MeshId:    meshId,
-		DevName:   ifName,
 		WgPort:    port,
 		MeshBytes: reply.Mesh,
 	})
--- a/pkg/sync/syncscheduler.go
+++ b/pkg/sync/syncscheduler.go
@ -5,20 +5,6 @@ import (
 	"github.com/tim-beatham/wgmesh/pkg/lib"
 )

-// SyncScheduler: Loops through all nodes in the mesh and runs a schedule to
-// sync each event
-type SyncScheduler interface {
-	Run() error
-	Stop() error
-}
-
-// SyncSchedulerImpl scheduler for sync scheduling
-type SyncSchedulerImpl struct {
-	quit   chan struct{}
-	server *ctrlserver.MeshCtrlServer
-	syncer Syncer
-}
-
 // Run implements SyncScheduler.
 func syncFunction(syncer Syncer) lib.TimerFunc {
 	return func() error {
--- a/pkg/sync/syncservice.go
+++ b/pkg/sync/syncservice.go
@ -64,11 +64,11 @@ func (s *SyncServiceImpl) SyncMesh(stream rpc.SyncService_SyncMeshServer) error

 			syncer = mesh.GetSyncer()
 		} else if meshId != in.MeshId {
-			return errors.New("Differing MeshIDs")
+			return errors.New("differing meshids")
 		}

 		if syncer == nil {
-			return errors.New("Syncer should not be nil")
+			return errors.New("syncer should not be nil")
 		}

 		msg, moreMessages := syncer.GenerateMessage()
--- a/pkg/wg/stubs.go
+++ b/pkg/wg/stubs.go
@ -2,8 +2,8 @@ package wg

 type WgInterfaceManipulatorStub struct{}

-func (i *WgInterfaceManipulatorStub) CreateInterface(params *CreateInterfaceParams) error {
-	return nil
+func (i *WgInterfaceManipulatorStub) CreateInterface(port int) (string, error) {
+	return "", nil
 }

 func (i *WgInterfaceManipulatorStub) AddAddress(ifName string, addr string) error {
--- a/pkg/wg/types.go
+++ b/pkg/wg/types.go
@ -1,5 +1,7 @@
 package wg

+import "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+
 type WgError struct {
 	msg string
 }
@ -8,14 +10,9 @@ func (m *WgError) Error() string {
 	return m.msg
 }

-type CreateInterfaceParams struct {
-	IfName string
-	Port   int
-}
-
 type WgInterfaceManipulator interface {
 	// CreateInterface creates a WireGuard interface
-	CreateInterface(params *CreateInterfaceParams) error
+	CreateInterface(port int, privateKey *wgtypes.Key) (string, error)
 	// AddAddress adds an address to the given interface name
 	AddAddress(ifName string, addr string) error
 	// RemoveInterface removes the specified interface
--- a/pkg/wg/wg.go
+++ b/pkg/wg/wg.go
@ -1,6 +1,9 @@
 package wg

 import (
+	"crypto"
+	"crypto/rand"
+	"encoding/base64"
 	"fmt"

 	"github.com/tim-beatham/wgmesh/pkg/lib"
@ -13,40 +16,48 @@ type WgInterfaceManipulatorImpl struct {
 	client *wgctrl.Client
 }

+const hashLength = 6
+
 // CreateInterface creates a WireGuard interface
-func (m *WgInterfaceManipulatorImpl) CreateInterface(params *CreateInterfaceParams) error {
+func (m *WgInterfaceManipulatorImpl) CreateInterface(port int, privKey *wgtypes.Key) (string, error) {
 	rtnl, err := lib.NewRtNetlinkConfig()

 	if err != nil {
-		return fmt.Errorf("failed to access link: %w", err)
+		return "", fmt.Errorf("failed to access link: %w", err)
 	}
 	defer rtnl.Close()

-	err = rtnl.CreateLink(params.IfName)
+	randomBuf := make([]byte, 32)
+	_, err = rand.Read(randomBuf)

 	if err != nil {
-		return fmt.Errorf("failed to create link: %w", err)
+		return "", err
 	}

-	privateKey, err := wgtypes.GeneratePrivateKey()
+	md5 := crypto.MD5.New().Sum(randomBuf)
+
+	md5Str := fmt.Sprintf("wg%s", base64.StdEncoding.EncodeToString(md5)[:hashLength])
+
+	err = rtnl.CreateLink(md5Str)

 	if err != nil {
-		return fmt.Errorf("failed to create private key: %w", err)
+		return "", fmt.Errorf("failed to create link: %w", err)
 	}

 	var cfg wgtypes.Config = wgtypes.Config{
-		PrivateKey: &privateKey,
-		ListenPort: &params.Port,
+		PrivateKey: privKey,
+		ListenPort: &port,
 	}

-	err = m.client.ConfigureDevice(params.IfName, cfg)
+	err = m.client.ConfigureDevice(md5Str, cfg)

 	if err != nil {
-		return fmt.Errorf("failed to configure dev: %w", err)
+		m.RemoveInterface(md5Str)
+		return "", fmt.Errorf("failed to configure dev: %w", err)
 	}

-	logging.Log.WriteInfof("ip link set up dev %s type wireguard", params.IfName)
-	return nil
+	logging.Log.WriteInfof("ip link set up dev %s type wireguard", md5Str)
+	return md5Str, nil
 }

 // Add an address to the given interface
--- a/pkg/what8words/what8words.go
+++ b/pkg/what8words/what8words.go
@ -0,0 +1,92 @@
+// Package to convert an IPV6 addres into 8 words
+package what8words
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+)
+
+type What8Words struct {
+	words []string
+}
+
+// Convert implements What8Words.
+func (w *What8Words) Convert(ipStr string) (string, error) {
+	ip, ipNet, err := net.ParseCIDR(ipStr)
+
+	if err != nil {
+		return "", err
+	}
+
+	ip16 := ip.To16()
+
+	if ip16 == nil {
+		return "", fmt.Errorf("cannot convert ip to 16 representation")
+	}
+
+	representation := make([]string, 7)
+
+	for i := 2; i <= net.IPv6len-2; i += 2 {
+		word1 := w.words[ip16[i]]
+		word2 := w.words[ip16[i+1]]
+
+		representation[i/2-1] = fmt.Sprintf("%s-%s", word1, word2)
+	}
+
+	prefixSize, _ := ipNet.Mask.Size()
+	return strings.Join(representation[:prefixSize/16-1], "."), nil
+}
+
+// Convert implements What8Words.
+func (w *What8Words) ConvertIdentifier(ipStr string) (string, error) {
+	ip, err := w.Convert(ipStr)
+
+	if err != nil {
+		return "", err
+	}
+
+	constituents := strings.Split(ip, ".")
+
+	return strings.Join(constituents[3:], "."), nil
+}
+func NewWhat8Words(pathToWords string) (*What8Words, error) {
+	words, err := ReadWords(pathToWords)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &What8Words{words: words}, nil
+}
+
+// ReadWords reads the what 8 words txt file
+func ReadWords(wordFile string) ([]string, error) {
+	f, err := os.ReadFile(wordFile)
+
+	if err != nil {
+		return nil, err
+	}
+
+	words := make([]string, 257)
+
+	reader := bufio.NewScanner(bytes.NewReader(f))
+
+	counter := 0
+
+	for reader.Scan() && counter <= len(words) {
+		text := reader.Text()
+
+		words[counter] = text
+		counter++
+
+		if reader.Err() != nil {
+			return nil, reader.Err()
+		}
+	}
+
+	return words, nil
+}
Author	SHA1	Message	Date
Tim Beatham	7be11dbaa3	27-remove-client-grpc-endpoint Removed a client's grpc endpoint value. Client's aren't publicly available so there is no need for a client's gRPC endpoint. Also changed a node ID's to their public key. A node id's public address is an issue for mobility of clients as their endpoint is subject to change	2023-11-24 12:07:03 +00:00
Tim Beatham	e7ac8c5542	Only updating WireGuard config if node exists	2023-11-22 13:08:02 +00:00
Ubuntu	09c64c4628	Fixed container file	2023-11-22 12:45:01 +00:00
Tim Beatham	2c4f18f52b	Merge pull request #26 from tim-beatham/25-modify-code-to-use-public-api 25-modify-code-to-use-public-api	2023-11-22 10:42:48 +00:00
Tim Beatham	4c54022f63	25-modify-code-to-use-public-api Modify the code to use a public IP address by default if none is specified	2023-11-22 10:41:54 +00:00
Tim Beatham	bf0724f6e5	Merge pull request #24 from tim-beatham/24-keepalive-holepunch 24 keepalive holepunch	2023-11-21 21:28:16 +00:00
Tim Beatham	624bd6e921	24-keepalive Persistent keep alive working	2023-11-21 21:26:31 +00:00
Tim Beatham	7b939e0468	24-keepalive-holepunch Added the ability to hole punch NAT	2023-11-21 20:42:43 +00:00
Tim Beatham	6e201ebaf5	24-keepalive-holepunch Nodes acting as peers and nodes acting as clients	2023-11-21 16:42:49 +00:00
Tim Beatham	06542da03c	main Fixed problems with timestamp not updating	2023-11-21 13:31:34 +00:00
Tim Beatham	0d63cd6624	main Adding words.txt for what words	2023-11-20 18:12:58 +00:00
Tim Beatham	f13319cfc1	Merge pull request #22 from tim-beatham/21-phonetic-words-ipv6 21 phonetic words ipv6	2023-11-20 18:08:49 +00:00
Tim Beatham	95f4495b0b	21-phonetic-words-ipv6 Simple what 8 words implementation	2023-11-20 18:07:52 +00:00
Tim Beatham	330fa74ef4	IPv6 What 8 Words what 8 words for ipv6 started	2023-11-20 15:22:32 +00:00
Tim Beatham	3e5b57e41f	Merge pull request #20 from tim-beatham/19-hash-wg-interface Hashing the WireGuard interface	2023-11-20 13:04:19 +00:00
Tim Beatham	b179cd3cf4	Hashing the WireGuard interface Hashing the interface and using ephmeral ports so that the admin doesn't choose an interface and port combination. An administrator can alteranatively decide to provide port but this isn't critical.	2023-11-20 13:03:42 +00:00
Tim Beatham	8f211aa116	Merge pull request #18 from tim-beatham/26-performance-testing Stubbing out WireGuard components	2023-11-20 11:29:37 +00:00