netclient working for ingress controller

controllers/controller.go

@@ -32,7 +32,7 @@ func HandleRESTRequests(wg *sync.WaitGroup) {
     fileHandlers(r)
     serverHandlers(r)
     extClientHandlers(r)
-
+    intClientHandlers(r)
 
 		port := servercfg.GetAPIPort()
 

controllers/intClientHttpController.go

@@ -0,0 +1,142 @@
+package controller
+
+import (
+//	"fmt"
+	"errors"
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+	"github.com/gorilla/mux"
+	"github.com/gravitl/netmaker/functions"
+	"github.com/gravitl/netmaker/serverctl"
+	"github.com/gravitl/netmaker/servercfg"
+	"github.com/gravitl/netmaker/models"
+	"github.com/gravitl/netmaker/mongoconn"
+	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
+)
+
+func intClientHandlers(r *mux.Router) {
+
+	r.HandleFunc("/api/intclient/{clientid}", securityCheck(http.HandlerFunc(getIntClient))).Methods("GET")
+	r.HandleFunc("/api/intclients", securityCheck(http.HandlerFunc(getAllIntClients))).Methods("GET")
+        r.HandleFunc("/api/intclients/deleteall", securityCheck(http.HandlerFunc(deleteAllIntClients))).Methods("POST")
+	r.HandleFunc("/api/intclient/register", http.HandlerFunc(registerIntClient)).Methods("POST")
+}
+
+func getAllIntClients(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+        clients, err := functions.GetAllIntClients()
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+        //Return all the extclients in JSON format
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(clients)
+}
+
+func deleteAllIntClients(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+        err := functions.DeleteAllIntClients()
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+        //Return all the extclients in JSON format
+        w.WriteHeader(http.StatusOK)
+}
+
+func getIntClient(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+        clients, err := functions.GetAllIntClients()
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+        //Return all the extclients in JSON format
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(clients)
+}
+
+
+
+func RegisterIntClient(client models.IntClient) (models.IntClient, error) {
+	if client.PrivateKey == "" {
+		privateKey, err := wgtypes.GeneratePrivateKey()
+		if err != nil {
+			return client, err
+		}
+
+		client.PrivateKey = privateKey.String()
+		client.PublicKey = privateKey.PublicKey().String()
+	}
+
+	if client.Address == "" {
+		newAddress, err := functions.UniqueAddress6(client.Network)
+		if err != nil {
+			return client, err
+		}
+		if newAddress == "" {
+			return client, errors.New("Could not find an address.")
+		}
+		client.Address6 = newAddress
+	}
+        if client.Network == "" { client.Network = "comms" }
+	server, err := serverctl.GetServerWGConf()
+	if err != nil {
+		return client, err
+	}
+	client.ServerEndpoint = server.ServerEndpoint
+	client.ServerAddress = server.ServerAddress
+	client.ServerPort = server.ServerPort
+	client.ServerKey = server.ServerKey
+
+	collection := mongoconn.Client.Database("netmaker").Collection("intclients")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	// insert our network into the network table
+	_, err = collection.InsertOne(ctx, client)
+	defer cancel()
+
+	if err != nil {
+		return client, err
+	}
+
+	err = serverctl.ReconfigureServerWireGuard()
+
+	return client, err
+}
+func registerIntClient(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+
+        var errorResponse = models.ErrorResponse{
+                Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
+        }
+
+        var clientreq models.IntClient
+
+        //get node from body of request
+        err := json.NewDecoder(r.Body).Decode(&clientreq)
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+        if servercfg.IsRegisterKeyRequired() {
+                validKey := functions.IsKeyValidGlobal(clientreq.AccessKey)
+                if !validKey {
+                                errorResponse = models.ErrorResponse{
+                                        Code: http.StatusUnauthorized, Message: "W1R3: Key invalid, or none provided.",
+                                }
+                                returnErrorResponse(w, r, errorResponse)
+                                return
+                }
+        }
+        client, err := RegisterIntClient(clientreq)
+
+        if err != nil {
+                returnErrorResponse(w, r, formatError(err, "internal"))
+                return
+        }
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(client)
+}

controllers/nodeGrpcController.go

@@ -62,6 +62,7 @@ func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.ReadNodeRe
 			Dnsoff:          !servercfg.IsDNSMode(),
 			Ispending:       node.IsPending,
 			Isingressgateway:       node.IsIngressGateway,
+			Ingressgatewayrange:       node.IngressGatewayRange,
 			Publickey:       node.PublicKey,
 			Listenport:      node.ListenPort,
 			Keepalive:       node.PersistentKeepalive,
@@ -77,7 +78,7 @@ func (s *NodeServiceServer) GetConn(ctx context.Context, data *nodepb.Client) (*
         // Get the protobuf node type from the protobuf request type
         // Essentially doing req.Node to access the struct with a nil check
         // Now we have to convert this into a NodeItem type to convert into BSON
-        clientreq := models.ServerClient{
+        clientreq := models.IntClient{
                 // ID:       primitive.NilObjectID,
                 Address:             data.GetAddress(),
                 Address6:            data.GetAddress6(),
@@ -100,7 +101,7 @@ func (s *NodeServiceServer) GetConn(ctx context.Context, data *nodepb.Client) (*
                         )
 		}
 	}
-	client, err := RegisterClient(clientreq)
+	client, err := RegisterIntClient(clientreq)
 
         if err != nil {
                 // return internal gRPC error to be handled later

controllers/nodeHttpController.go

@@ -8,7 +8,7 @@ import (
 	"net/http"
 	"strings"
 	"time"
-
+	"log"
 	"github.com/gorilla/mux"
 	"github.com/gravitl/netmaker/functions"
 	"github.com/gravitl/netmaker/models"
@@ -244,7 +244,7 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 
-	var nodes []models.ReturnNode
+	var nodes []models.Node
 	var params = mux.Vars(r)
 	nodes, err := GetNetworkNodes(params["network"])
 	if err != nil {
@@ -257,34 +257,34 @@ func getNetworkNodes(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(nodes)
 }
 
-func GetNetworkNodes(network string) ([]models.ReturnNode, error) {
-	var nodes []models.ReturnNode
+func GetNetworkNodes(network string) ([]models.Node, error) {
+	var nodes []models.Node
 	collection := mongoconn.Client.Database("netmaker").Collection("nodes")
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	filter := bson.M{"network": network}
 	//Filtering out the ID field cuz Dillon doesn't like it. May want to filter out other fields in the future
 	cur, err := collection.Find(ctx, filter, options.Find().SetProjection(bson.M{"_id": 0}))
 	if err != nil {
-		return []models.ReturnNode{}, err
+		return []models.Node{}, err
 	}
 	defer cancel()
 	for cur.Next(context.TODO()) {
-		//Using a different model for the ReturnNode (other than regular node).
+		//Using a different model for the Node (other than regular node).
 		//Either we should do this for ALL structs (so Networks and Keys)
 		//OR we should just use the original struct
 		//My preference is to make some new return structs
 		//TODO: Think about this. Not an immediate concern. Just need to get some consistency eventually
-		var node models.ReturnNode
+		var node models.Node
 		err := cur.Decode(&node)
 		if err != nil {
-			return []models.ReturnNode{}, err
+			return []models.Node{}, err
 		}
 		// add item our array of nodes
 		nodes = append(nodes, node)
 	}
 	//TODO: Another fatal error we should take care of.
 	if err := cur.Err(); err != nil {
-		return []models.ReturnNode{}, err
+		return []models.Node{}, err
 	}
 	return nodes, nil
 }
@@ -581,7 +581,7 @@ func CreateEgressGateway(gateway models.EgressGatewayRequest) (models.Node, erro
 			{"postup", nodechange.PostUp},
 			{"postdown", nodechange.PostDown},
 			{"isegressgateway", nodechange.IsEgressGateway},
-			{"gatewayrange", nodechange.EgressGatewayRange},
+			{"egressgatewayrange", nodechange.EgressGatewayRange},
 			{"lastmodified", nodechange.LastModified},
 		}},
 	}
@@ -687,35 +687,60 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
 	json.NewEncoder(w).Encode(node)
 }
 
-func CreateIngressGateway(network string, macaddress string) (models.Node, error) {
-	node, err := functions.GetNodeByMacAddress(network, macaddress)
-	if err != nil {
-		return models.Node{}, err
-	}
-
-	collection := mongoconn.Client.Database("netmaker").Collection("nodes")
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	// Create filter
-	filter := bson.M{"macaddress": macaddress, "network": network}
-	// prepare update model.
-	update := bson.D{
-		{"$set", bson.D{
-			{"isingressgateway", true},
-			{"lastmodified", time.Now().Unix()},
-		}},
-	}
-	var nodeupdate models.Node
-	err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&nodeupdate)
-	defer cancel()
-	if err != nil {
-		return models.Node{}, err
-	}
-	//Get updated values to return
-	node, err = functions.GetNodeByMacAddress(network, macaddress)
-	if err != nil {
-		return models.Node{}, err
-	}
-	return node, nil
+func CreateIngressGateway(netid string, macaddress string) (models.Node, error) {
+
+	node, err := functions.GetNodeByMacAddress(netid, macaddress)
+        if err != nil {
+                return models.Node{}, err
+        }
+
+        network, err := functions.GetParentNetwork(netid)
+        if err != nil {
+		log.Println("Could not find network.")
+                return models.Node{}, err
+        }
+
+	if node.IsEgressGateway {
+		errors.New("Node cannot be both Ingress and Egress Gateway in same network.")
+                return models.Node{}, err
+	}
+
+	node.IngressGatewayRange = network.AddressRange
+        node.PostUp = "iptables -A FORWARD -i " + node.Interface + " -j ACCEPT; iptables -t nat -A POSTROUTING -o " + node.Interface + " -j MASQUERADE"
+        node.PostDown = "iptables -D FORWARD -i " + node.Interface + " -j ACCEPT; iptables -t nat -D POSTROUTING -o " + node.Interface + " -j MASQUERADE"
+        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+        // Create filter
+        filter := bson.M{"macaddress": macaddress, "network": netid}
+        node.SetLastModified()
+        // prepare update model.
+        update := bson.D{
+                {"$set", bson.D{
+                        {"postup", node.PostUp},
+                        {"postdown", node.PostDown},
+                        {"isingressgateway", true},
+                        {"ingressgatewayrange", node.IngressGatewayRange},
+                        {"lastmodified", node.LastModified},
+                }},
+        }
+        var nodeupdate models.Node
+        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&nodeupdate)
+        defer cancel()
+        if err != nil {
+		log.Println("error updating node to gateway")
+                return models.Node{}, err
+        }
+        err = SetNetworkNodesLastModified(netid)
+        if err != nil {
+                return node, err
+        }
+        //Get updated values to return
+        node, err = functions.GetNodeByMacAddress(netid, macaddress)
+        if err != nil {
+		log.Println("error finding node after update")
+                return node, err
+        }
+        return node, nil
 }
 
 func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/go-playground/validator/v10 v10.5.0
-	github.com/golang/protobuf v1.4.3 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/gorilla/handlers v1.5.1
 	github.com/gorilla/mux v1.8.0
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e // indirect
@@ -25,6 +25,7 @@ require (
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20200609130330-bd2cb7843e1b
 	google.golang.org/genproto v0.0.0-20210201151548-94839c025ad4 // indirect
 	google.golang.org/grpc v1.35.0
-	google.golang.org/protobuf v1.25.0
+	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0 // indirect
+	google.golang.org/protobuf v1.26.0
 	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
 )

go.sum

@@ -73,6 +73,9 @@ github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QD
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -82,6 +85,7 @@ github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4=
 github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q=
@@ -269,6 +273,8 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.35.0 h1:TwIQcH3es+MojMVojxxfQ3l3OF2KzlRxML2xZq0kRo8=
 google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0 h1:M1YKkFIboKNieVO5DLUEVzQfGwJD30Nv2jfUgzb5UcE=
+google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -280,6 +286,9 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

grpc/node.pb.go

@@ -140,6 +140,7 @@ type Node struct {
 	Allowedips           string   `protobuf:"bytes,22,opt,name=allowedips,proto3" json:"allowedips,omitempty"`
 	Islocal              bool     `protobuf:"varint,23,opt,name=islocal,proto3" json:"islocal,omitempty"`
 	Isingressgateway     bool     `protobuf:"varint,28,opt,name=isingressgateway,proto3" json:"isingressgateway,omitempty"`
+	Ingressgatewayrange  string   `protobuf:"bytes,29,opt,name=ingressgatewayrange,proto3" json:"ingressgatewayrange,omitempty"`
 	Isdualstack          bool     `protobuf:"varint,27,opt,name=isdualstack,proto3" json:"isdualstack,omitempty"`
 	Dnsoff               bool     `protobuf:"varint,24,opt,name=dnsoff,proto3" json:"dnsoff,omitempty"`
 	Localrange           string   `protobuf:"bytes,25,opt,name=localrange,proto3" json:"localrange,omitempty"`
@@ -348,6 +349,13 @@ func (m *Node) GetIsingressgateway() bool {
 	return false
 }
 
+func (m *Node) GetIngressgatewayrange() string {
+	if m != nil {
+		return m.Ingressgatewayrange
+	}
+	return ""
+}
+
 func (m *Node) GetIsdualstack() bool {
 	if m != nil {
 		return m.Isdualstack
@@ -459,6 +467,7 @@ func (m *CheckInResponse) GetNeeddelete() bool {
 type PeersResponse struct {
 	Isegressgateway      bool     `protobuf:"varint,1,opt,name=isegressgateway,proto3" json:"isegressgateway,omitempty"`
 	Egressgatewayrange   string   `protobuf:"bytes,2,opt,name=egressgatewayrange,proto3" json:"egressgatewayrange,omitempty"`
+	Ingressgatewayrange  string   `protobuf:"bytes,9,opt,name=ingressgatewayrange,proto3" json:"ingressgatewayrange,omitempty"`
 	Publickey            string   `protobuf:"bytes,5,opt,name=publickey,proto3" json:"publickey,omitempty"`
 	Endpoint             string   `protobuf:"bytes,6,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
 	Address              string   `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
@@ -510,6 +519,13 @@ func (m *PeersResponse) GetEgressgatewayrange() string {
 	return ""
 }
 
+func (m *PeersResponse) GetIngressgatewayrange() string {
+	if m != nil {
+		return m.Ingressgatewayrange
+	}
+	return ""
+}
+
 func (m *PeersResponse) GetPublickey() string {
 	if m != nil {
 		return m.Publickey
@@ -1346,74 +1362,75 @@ func init() {
 func init() { proto.RegisterFile("grpc/node.proto", fileDescriptor_d13bd996b67da4ef) }
 
 var fileDescriptor_d13bd996b67da4ef = []byte{
-	// 1093 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0x4d, 0x6f, 0x1b, 0x45,
-	0x18, 0x96, 0x9d, 0xd8, 0x71, 0x5f, 0xd7, 0x49, 0x3a, 0x6d, 0xc3, 0x60, 0xaa, 0x2a, 0x5a, 0xa1,
-	0x2a, 0x45, 0x24, 0x0e, 0x41, 0xaa, 0x90, 0x38, 0x20, 0x91, 0xa2, 0x08, 0x04, 0x15, 0x2c, 0xe2,
-	0xc2, 0x6d, 0xb2, 0xfb, 0x7a, 0x3b, 0xf2, 0x66, 0x66, 0xb3, 0x33, 0xb6, 0x9b, 0x1b, 0x17, 0x7e,
-	0x14, 0xe2, 0x9f, 0x70, 0xe6, 0x87, 0xa0, 0xf9, 0x58, 0xef, 0xec, 0xc6, 0x4d, 0x52, 0xe5, 0xc6,
-	0xcd, 0xf3, 0xcc, 0xfb, 0xf9, 0xbc, 0x1f, 0x3b, 0x86, 0x9d, 0xac, 0x2c, 0x92, 0x89, 0x90, 0x29,
-	0x1e, 0x15, 0xa5, 0xd4, 0x92, 0x6c, 0x9a, 0xdf, 0x51, 0x0a, 0x0f, 0x7f, 0x94, 0x19, 0x17, 0x31,
-	0x5e, 0xce, 0x51, 0x69, 0xf2, 0x1c, 0xe0, 0x82, 0x25, 0x2c, 0x4d, 0x4b, 0x54, 0x8a, 0x76, 0xf6,
-	0x3b, 0x07, 0x0f, 0xe2, 0x00, 0x21, 0x63, 0x18, 0x14, 0x4c, 0xa9, 0xa5, 0x2c, 0x53, 0xda, 0xb5,
-	0xb7, 0xab, 0x33, 0xa1, 0xb0, 0x25, 0x50, 0x2f, 0x65, 0x39, 0xa3, 0x1b, 0xf6, 0xaa, 0x3a, 0x46,
-	0x5f, 0xc0, 0xc8, 0x7b, 0x51, 0x85, 0x14, 0x0a, 0xc9, 0x3e, 0x0c, 0x59, 0x92, 0xa0, 0x52, 0x5a,
-	0xce, 0x50, 0x78, 0x3f, 0x21, 0x14, 0xfd, 0xd3, 0x87, 0xcd, 0x37, 0x32, 0x45, 0xb2, 0x0d, 0x5d,
-	0x9e, 0x7a, 0x89, 0x2e, 0x4f, 0x09, 0x81, 0x4d, 0xc1, 0x2e, 0xd0, 0x7b, 0xb7, 0xbf, 0x8d, 0xe7,
-	0x2a, 0x64, 0xef, 0x39, 0x88, 0xd7, 0xff, 0x7c, 0x45, 0xc7, 0x2e, 0xde, 0xea, 0x6c, 0x72, 0xcd,
-	0xb9, 0xd2, 0x28, 0x0a, 0x59, 0x6a, 0xba, 0xb9, 0xdf, 0x39, 0xe8, 0xc5, 0x01, 0x42, 0x9e, 0xc1,
-	0x83, 0x62, 0x7e, 0x9e, 0xf3, 0x64, 0x86, 0x57, 0xb4, 0x67, 0x95, 0x6b, 0xc0, 0x58, 0x46, 0x91,
-	0x16, 0x92, 0x0b, 0x4d, 0xfb, 0xce, 0x72, 0x75, 0x6e, 0xb1, 0xb8, 0x75, 0x23, 0x8b, 0x83, 0x16,
-	0x8b, 0xfb, 0x30, 0x34, 0x95, 0xa9, 0x98, 0x7c, 0xe0, 0xa8, 0x09, 0x20, 0x13, 0x17, 0x57, 0x05,
-	0x8a, 0x94, 0x8b, 0x8c, 0xc2, 0x7e, 0xe7, 0x60, 0x10, 0xd7, 0x00, 0xd9, 0x83, 0x7e, 0x21, 0x95,
-	0x9e, 0x17, 0x74, 0x68, 0x55, 0xfd, 0xc9, 0xfa, 0x94, 0x4a, 0xa7, 0x72, 0x29, 0xe8, 0x43, 0xef,
-	0xd3, 0x9f, 0x8d, 0xc5, 0x19, 0x62, 0xc1, 0x72, 0xbe, 0x40, 0x3a, 0xb2, 0x44, 0xd4, 0x80, 0xc9,
-	0x46, 0xb1, 0x05, 0x26, 0x52, 0x4c, 0x79, 0x46, 0xb7, 0xad, 0xc3, 0x00, 0x31, 0xda, 0xae, 0x72,
-	0x86, 0xa7, 0x1d, 0xc7, 0xd3, 0x0a, 0xb0, 0xd1, 0x0a, 0x8d, 0xe5, 0x94, 0x25, 0x48, 0x77, 0xdd,
-	0xed, 0x0a, 0x30, 0xd9, 0xe6, 0x4c, 0xe9, 0xe4, 0x2d, 0x26, 0x33, 0x2e, 0xe8, 0x23, 0x97, 0x6d,
-	0x00, 0x91, 0x08, 0x1e, 0x9a, 0xe3, 0x85, 0x4c, 0xf9, 0x94, 0x63, 0x4a, 0x89, 0x15, 0x69, 0x60,
-	0xe4, 0x00, 0x76, 0xbc, 0xb8, 0xb5, 0xbc, 0x60, 0x39, 0x7d, 0x6c, 0xb3, 0x68, 0xc3, 0xd6, 0x9a,
-	0x4c, 0x58, 0x5e, 0xd5, 0xe6, 0x89, 0xb7, 0x16, 0x60, 0x26, 0x26, 0xc3, 0x4c, 0xf2, 0x96, 0x89,
-	0x0c, 0x15, 0x7d, 0xea, 0x62, 0x0a, 0x20, 0xc3, 0x08, 0xcb, 0x73, 0xb9, 0xc4, 0x94, 0x17, 0x8a,
-	0xee, 0xb9, 0xfa, 0xd6, 0x88, 0xe9, 0x47, 0xae, 0xac, 0x4d, 0xfa, 0x91, 0xa5, 0xab, 0x3a, 0x92,
-	0xcf, 0x60, 0x97, 0x2b, 0x2e, 0x32, 0xe3, 0x28, 0x63, 0x1a, 0x97, 0xec, 0x8a, 0x3e, 0xb3, 0x22,
-	0xd7, 0x70, 0x13, 0x07, 0x57, 0xe9, 0x9c, 0xe5, 0x4a, 0xb3, 0x64, 0x46, 0x3f, 0xb1, 0x62, 0x21,
-	0x64, 0x6a, 0x9d, 0x0a, 0x25, 0xa7, 0x53, 0x4a, 0xed, 0xa5, 0x3f, 0xd9, 0xce, 0x36, 0xee, 0x4a,
-	0x13, 0x2e, 0xfd, 0xd8, 0xc5, 0x57, 0x23, 0xd1, 0x9f, 0x5d, 0xd8, 0x39, 0x35, 0xcc, 0x7c, 0x5f,
-	0x8f, 0x24, 0x85, 0x2d, 0x35, 0xb7, 0x55, 0xb3, 0xc3, 0x36, 0x88, 0xab, 0x23, 0x79, 0x01, 0xdb,
-	0x02, 0x31, 0x2d, 0x10, 0xcb, 0x79, 0x91, 0x32, 0xed, 0x66, 0x6f, 0x10, 0xb7, 0x50, 0x93, 0x9b,
-	0x41, 0x5c, 0x57, 0x78, 0xc9, 0x0d, 0x97, 0x5b, 0x1b, 0xaf, 0xba, 0xfc, 0x02, 0x95, 0x62, 0x19,
-	0xda, 0xe1, 0xf3, 0x5d, 0xee, 0xa1, 0x66, 0x97, 0xf7, 0xda, 0x5d, 0xfe, 0x29, 0x8c, 0x8c, 0xcd,
-	0x19, 0x5e, 0x79, 0x47, 0x7d, 0x2b, 0xd1, 0x04, 0x0d, 0x0f, 0x06, 0x48, 0x31, 0x47, 0x8d, 0x76,
-	0x0e, 0x07, 0x71, 0x80, 0x44, 0x7f, 0x77, 0x61, 0xf4, 0x33, 0x62, 0xa9, 0x56, 0x2c, 0x1c, 0xc0,
-	0x0e, 0x57, 0xd8, 0x28, 0x8f, 0x63, 0xa3, 0x0d, 0x93, 0x23, 0x20, 0x0d, 0xc0, 0x71, 0xed, 0xb6,
-	0xd2, 0x9a, 0x9b, 0x7b, 0x6c, 0x93, 0xbb, 0x6d, 0xb7, 0xc1, 0x07, 0x6e, 0xb7, 0xf6, 0x24, 0x6c,
-	0xad, 0x99, 0x84, 0x1b, 0xf7, 0x42, 0xf4, 0x6f, 0x07, 0x76, 0xbf, 0x7b, 0xa7, 0x9b, 0x04, 0xfe,
-	0xff, 0xd2, 0xfc, 0xa3, 0x0b, 0xfd, 0xd3, 0x9c, 0xa3, 0xdb, 0xeb, 0x45, 0xc9, 0x17, 0x4c, 0xa3,
-	0xc9, 0xce, 0x7f, 0x1d, 0x6b, 0xa4, 0x99, 0x7c, 0xb7, 0x9d, 0x7c, 0x63, 0x4f, 0x6e, 0xb4, 0xf7,
-	0x64, 0x90, 0xfe, 0xe6, 0xfb, 0xd3, 0xef, 0xb5, 0xd2, 0x7f, 0x01, 0xdb, 0x0a, 0xcb, 0x05, 0x96,
-	0x2d, 0x5a, 0x5b, 0xa8, 0xdd, 0xe1, 0x16, 0xb1, 0x34, 0xf9, 0x2f, 0x52, 0x8d, 0x98, 0xd8, 0xdc,
-	0xc9, 0xc4, 0xe6, 0x38, 0xae, 0x81, 0x68, 0x02, 0xa3, 0xd3, 0x12, 0x99, 0x46, 0xf3, 0x45, 0x8e,
-	0xf1, 0x92, 0x3c, 0x07, 0xfb, 0x7c, 0xb0, 0x14, 0x0c, 0x4f, 0xe0, 0xc8, 0xbe, 0x2b, 0xec, 0xa5,
-	0x7b, 0x56, 0xb4, 0x14, 0xd4, 0x5d, 0x14, 0x7e, 0xb3, 0x33, 0xfb, 0x01, 0x1e, 0x42, 0x85, 0xdb,
-	0x3d, 0x9c, 0xc1, 0x30, 0x46, 0x96, 0xd6, 0xf6, 0x6f, 0x7e, 0xe8, 0x04, 0x8f, 0x99, 0x6e, 0xf3,
-	0x31, 0x73, 0x18, 0x1a, 0xba, 0xdd, 0xef, 0x2f, 0x30, 0x7a, 0x6d, 0xb7, 0xcd, 0x5d, 0x3d, 0x9b,
-	0xd5, 0xe8, 0x5c, 0xbd, 0xa9, 0xdf, 0x39, 0x21, 0x14, 0xbd, 0x6c, 0x9a, 0x54, 0xef, 0xdf, 0xdd,
-	0x26, 0xeb, 0x33, 0xac, 0x46, 0xf4, 0x3e, 0x59, 0xff, 0x00, 0xdb, 0x67, 0xa8, 0xeb, 0x71, 0xbf,
-	0x8f, 0xad, 0xaf, 0xc2, 0xa0, 0x14, 0x79, 0x09, 0x3d, 0xf3, 0x15, 0x51, 0x9e, 0xc2, 0xc7, 0x8e,
-	0xc2, 0xc6, 0x5a, 0x89, 0x9d, 0x44, 0xf4, 0xba, 0x15, 0x85, 0x22, 0x27, 0x30, 0xc0, 0x77, 0x3a,
-	0xd4, 0xdf, 0x73, 0xfa, 0xed, 0xcd, 0x14, 0xaf, 0xe4, 0xa2, 0xcf, 0x01, 0x56, 0x5f, 0xbf, 0xdb,
-	0x3b, 0xed, 0xa7, 0x40, 0x5a, 0x91, 0x6f, 0x56, 0x4f, 0x8d, 0xd2, 0x1b, 0xf6, 0x8a, 0x4f, 0x9d,
-	0x62, 0xeb, 0xb3, 0x1a, 0xb7, 0xa5, 0x4f, 0xfe, 0xda, 0x80, 0xa1, 0xb1, 0xfe, 0x2b, 0x96, 0x0b,
-	0x9e, 0x20, 0x39, 0x86, 0x9e, 0x7d, 0x1b, 0x13, 0xe2, 0x0c, 0x84, 0xcf, 0xf1, 0xf1, 0xe3, 0x06,
-	0xe6, 0x57, 0xec, 0x2b, 0x80, 0x7a, 0xb8, 0x88, 0x17, 0x69, 0xcc, 0xe7, 0x78, 0x0d, 0xa8, 0xc8,
-	0x31, 0x0c, 0xaa, 0xc6, 0x25, 0x8f, 0x9c, 0x40, 0x30, 0x11, 0xe3, 0x6b, 0x90, 0x32, 0x9e, 0xea,
-	0x21, 0xab, 0x3c, 0x35, 0xe6, 0x74, 0xbc, 0x06, 0xb4, 0x7a, 0x75, 0x83, 0x56, 0x7a, 0x8d, 0x29,
-	0x18, 0xaf, 0x01, 0x6d, 0x31, 0xab, 0xc6, 0xa8, 0x22, 0x0c, 0xba, 0x77, 0x7c, 0x0d, 0x52, 0xc7,
-	0x1d, 0xf2, 0xb5, 0x6d, 0xa6, 0xaa, 0xda, 0xe4, 0xc9, 0x4a, 0x26, 0xe8, 0xd5, 0xf1, 0x3a, 0xd4,
-	0x28, 0x1f, 0xc2, 0x96, 0x2f, 0x18, 0xd9, 0x6d, 0xd5, 0xef, 0x72, 0xdc, 0x46, 0xd4, 0xb7, 0x93,
-	0xdf, 0x0f, 0x33, 0x29, 0xb3, 0x1c, 0x8f, 0x32, 0x99, 0x33, 0x91, 0x1d, 0xc9, 0x32, 0x9b, 0xd8,
-	0xbf, 0x53, 0xe7, 0xf3, 0xe9, 0x44, 0x5f, 0x15, 0xa8, 0x26, 0x33, 0x21, 0x97, 0xc2, 0xfe, 0xd1,
-	0x2a, 0xce, 0xcf, 0xfb, 0xf6, 0xf2, 0xcb, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x11, 0xa6, 0x77,
-	0x7c, 0x7e, 0x0d, 0x00, 0x00,
+	// 1112 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0x4f, 0x6f, 0x23, 0x35,
+	0x14, 0x57, 0xd2, 0xa6, 0x49, 0x5f, 0x9a, 0xb6, 0xeb, 0xee, 0x16, 0x13, 0x96, 0x55, 0x15, 0xa1,
+	0x55, 0x17, 0xd1, 0xa6, 0x14, 0x69, 0x85, 0xc4, 0x01, 0x89, 0x2e, 0xaa, 0x40, 0xb0, 0x82, 0x41,
+	0x5c, 0xb8, 0xb9, 0x33, 0x2f, 0xb3, 0x56, 0xa6, 0xf6, 0x74, 0xec, 0x24, 0xdb, 0x1b, 0x17, 0x6e,
+	0x7c, 0x21, 0xbe, 0x0f, 0x57, 0xbe, 0x03, 0xf2, 0x9f, 0xc9, 0x78, 0xa6, 0xe9, 0x9f, 0x65, 0x6f,
+	0xdc, 0xc6, 0x3f, 0xbf, 0xbf, 0xbf, 0xe7, 0xf7, 0xec, 0x81, 0x9d, 0xb4, 0xc8, 0xe3, 0xb1, 0x90,
+	0x09, 0x1e, 0xe7, 0x85, 0xd4, 0x92, 0xac, 0x9b, 0xef, 0x51, 0x02, 0x5b, 0x3f, 0xc8, 0x94, 0x8b,
+	0x08, 0xaf, 0x66, 0xa8, 0x34, 0x79, 0x06, 0x70, 0xc9, 0x62, 0x96, 0x24, 0x05, 0x2a, 0x45, 0x5b,
+	0x07, 0xad, 0xc3, 0xcd, 0x28, 0x40, 0xc8, 0x10, 0x7a, 0x39, 0x53, 0x6a, 0x21, 0x8b, 0x84, 0xb6,
+	0xed, 0xee, 0x72, 0x4d, 0x28, 0x74, 0x05, 0xea, 0x85, 0x2c, 0xa6, 0x74, 0xcd, 0x6e, 0x95, 0xcb,
+	0xd1, 0xe7, 0x30, 0xf0, 0x5e, 0x54, 0x2e, 0x85, 0x42, 0x72, 0x00, 0x7d, 0x16, 0xc7, 0xa8, 0x94,
+	0x96, 0x53, 0x14, 0xde, 0x4f, 0x08, 0x8d, 0xfe, 0xec, 0xc2, 0xfa, 0x6b, 0x99, 0x20, 0xd9, 0x86,
+	0x36, 0x4f, 0xbc, 0x44, 0x9b, 0x27, 0x84, 0xc0, 0xba, 0x60, 0x97, 0xe8, 0xbd, 0xdb, 0x6f, 0xe3,
+	0xb9, 0x0c, 0xd9, 0x7b, 0x0e, 0xe2, 0xf5, 0x9f, 0x2f, 0xe9, 0xd0, 0xc5, 0x5b, 0xae, 0x4d, 0xae,
+	0x19, 0x57, 0x1a, 0x45, 0x2e, 0x0b, 0x4d, 0xd7, 0x0f, 0x5a, 0x87, 0x9d, 0x28, 0x40, 0xc8, 0x53,
+	0xd8, 0xcc, 0x67, 0x17, 0x19, 0x8f, 0xa7, 0x78, 0x4d, 0x3b, 0x56, 0xb9, 0x02, 0x8c, 0x65, 0x14,
+	0x49, 0x2e, 0xb9, 0xd0, 0x74, 0xc3, 0x59, 0x2e, 0xd7, 0x0d, 0x16, 0xbb, 0x77, 0xb2, 0xd8, 0x6b,
+	0xb0, 0x78, 0x00, 0x7d, 0x53, 0x99, 0x92, 0xc9, 0x4d, 0x47, 0x4d, 0x00, 0x99, 0xb8, 0xb8, 0xca,
+	0x51, 0x24, 0x5c, 0xa4, 0x14, 0x0e, 0x5a, 0x87, 0xbd, 0xa8, 0x02, 0xc8, 0x3e, 0x6c, 0xe4, 0x52,
+	0xe9, 0x59, 0x4e, 0xfb, 0x56, 0xd5, 0xaf, 0xac, 0x4f, 0xa9, 0x74, 0x22, 0x17, 0x82, 0x6e, 0x79,
+	0x9f, 0x7e, 0x6d, 0x2c, 0x4e, 0x11, 0x73, 0x96, 0xf1, 0x39, 0xd2, 0x81, 0x25, 0xa2, 0x02, 0x4c,
+	0x36, 0x8a, 0xcd, 0x31, 0x96, 0x62, 0xc2, 0x53, 0xba, 0x6d, 0x1d, 0x06, 0x88, 0xd1, 0x76, 0x95,
+	0x33, 0x3c, 0xed, 0x38, 0x9e, 0x96, 0x80, 0x8d, 0x56, 0x68, 0x2c, 0x26, 0x2c, 0x46, 0xba, 0xeb,
+	0x76, 0x97, 0x80, 0xc9, 0x36, 0x63, 0x4a, 0xc7, 0x6f, 0x30, 0x9e, 0x72, 0x41, 0x1f, 0xb9, 0x6c,
+	0x03, 0x88, 0x8c, 0x60, 0xcb, 0x2c, 0x2f, 0x65, 0xc2, 0x27, 0x1c, 0x13, 0x4a, 0xac, 0x48, 0x0d,
+	0x23, 0x87, 0xb0, 0xe3, 0xc5, 0xad, 0xe5, 0x39, 0xcb, 0xe8, 0x9e, 0xcd, 0xa2, 0x09, 0x5b, 0x6b,
+	0x32, 0x66, 0x59, 0x59, 0x9b, 0xc7, 0xde, 0x5a, 0x80, 0x99, 0x98, 0x0c, 0x33, 0xf1, 0x1b, 0x26,
+	0x52, 0x54, 0xf4, 0x89, 0x8b, 0x29, 0x80, 0x0c, 0x23, 0x2c, 0xcb, 0xe4, 0x02, 0x13, 0x9e, 0x2b,
+	0xba, 0xef, 0xea, 0x5b, 0x21, 0xe6, 0x3c, 0x72, 0x65, 0x6d, 0xd2, 0x0f, 0x2c, 0x5d, 0xe5, 0x92,
+	0x7c, 0x0a, 0xbb, 0x5c, 0x71, 0x91, 0x1a, 0x47, 0x29, 0xd3, 0xb8, 0x60, 0xd7, 0xf4, 0xa9, 0x15,
+	0xb9, 0x81, 0x93, 0x13, 0xd8, 0xab, 0x23, 0x85, 0xf1, 0x4e, 0x3f, 0xb6, 0xee, 0x56, 0x6d, 0x99,
+	0xc8, 0xb9, 0x4a, 0x66, 0x2c, 0x53, 0x9a, 0xc5, 0x53, 0xfa, 0x91, 0x35, 0x1c, 0x42, 0xe6, 0x74,
+	0x24, 0x42, 0xc9, 0xc9, 0x84, 0x52, 0xbb, 0xe9, 0x57, 0xb6, 0x17, 0x4c, 0x80, 0xce, 0xc5, 0x87,
+	0x2e, 0xa3, 0x0a, 0x19, 0xfd, 0xd1, 0x86, 0x9d, 0x33, 0xc3, 0xe5, 0x77, 0x55, 0x13, 0x53, 0xe8,
+	0xaa, 0x99, 0xad, 0xb3, 0x6d, 0xcf, 0x5e, 0x54, 0x2e, 0xc9, 0x73, 0xd8, 0x16, 0x88, 0x49, 0x8e,
+	0x58, 0xcc, 0xf2, 0x84, 0x69, 0xd7, 0xad, 0xbd, 0xa8, 0x81, 0x1a, 0x36, 0x0c, 0xe2, 0xce, 0x91,
+	0x97, 0x5c, 0x73, 0x6c, 0x34, 0xf1, 0xb2, 0x2f, 0x2e, 0x51, 0x29, 0x96, 0xa2, 0x6d, 0x57, 0xdf,
+	0x17, 0x1e, 0xaa, 0xf7, 0x45, 0xa7, 0xd9, 0x17, 0x9f, 0xc0, 0xc0, 0xd8, 0x9c, 0xe2, 0xb5, 0x77,
+	0xb4, 0x61, 0x25, 0xea, 0xa0, 0xe1, 0xc1, 0x00, 0x09, 0x66, 0xa8, 0xd1, 0x76, 0x6e, 0x2f, 0x0a,
+	0x90, 0xd1, 0x3f, 0x6d, 0x18, 0xfc, 0x84, 0x58, 0xa8, 0x25, 0x0b, 0x87, 0xb0, 0xc3, 0x15, 0xd6,
+	0x0a, 0xea, 0xd8, 0x68, 0xc2, 0xe4, 0x18, 0x08, 0xde, 0x2c, 0xa7, 0x9b, 0x63, 0x2b, 0x76, 0x6e,
+	0xab, 0xff, 0xe6, 0xed, 0xf5, 0xff, 0xef, 0x13, 0xeb, 0x61, 0x13, 0xb4, 0xf7, 0x8e, 0x13, 0xb4,
+	0xd9, 0x6d, 0xdd, 0x15, 0xdd, 0x76, 0xe7, 0xec, 0x19, 0xfd, 0xdd, 0x82, 0xdd, 0x6f, 0xdf, 0xea,
+	0x3a, 0xe5, 0xff, 0xbf, 0x34, 0x7f, 0x6f, 0xc3, 0xc6, 0x59, 0xc6, 0xd1, 0xdd, 0x1d, 0x79, 0xc1,
+	0xe7, 0x4c, 0xa3, 0xc9, 0xce, 0xdf, 0xc0, 0x15, 0x52, 0x4f, 0xbe, 0xdd, 0x4c, 0xbe, 0x36, 0x8b,
+	0xd7, 0x9a, 0xb3, 0x38, 0x48, 0x7f, 0xfd, 0xf6, 0xf4, 0x3b, 0x8d, 0xf4, 0x9f, 0xc3, 0xb6, 0xc2,
+	0x62, 0x8e, 0x45, 0x83, 0xd6, 0x06, 0x6a, 0xef, 0x09, 0x8b, 0x58, 0x9a, 0xfc, 0xad, 0x57, 0x21,
+	0x26, 0x36, 0xb7, 0x32, 0xb1, 0x39, 0x8e, 0x2b, 0x60, 0x34, 0x86, 0xc1, 0x59, 0x81, 0x4c, 0xa3,
+	0xb9, 0xf5, 0x23, 0xbc, 0x22, 0xcf, 0xc0, 0x3e, 0x51, 0x2c, 0x05, 0xfd, 0x53, 0x38, 0xb6, 0x6f,
+	0x17, 0xbb, 0xe9, 0x9e, 0x2e, 0x0d, 0x05, 0xf5, 0x10, 0x85, 0x5f, 0x6d, 0x97, 0xbf, 0x83, 0x87,
+	0x50, 0xe1, 0x7e, 0x0f, 0xe7, 0xd0, 0x8f, 0x90, 0x25, 0x95, 0xfd, 0xbb, 0x1f, 0x53, 0xc1, 0x83,
+	0xa9, 0x5d, 0x7f, 0x30, 0x1d, 0x85, 0x86, 0xee, 0xf7, 0xfb, 0x33, 0x0c, 0x5e, 0xd9, 0xf9, 0xf4,
+	0x50, 0xcf, 0x66, 0x98, 0x3a, 0x57, 0xaf, 0xab, 0xb7, 0x54, 0x08, 0x8d, 0x5e, 0xd4, 0x4d, 0xaa,
+	0xdb, 0xa7, 0xbd, 0xc9, 0xfa, 0x1c, 0xcb, 0x16, 0x7d, 0x9f, 0xac, 0xbf, 0x87, 0xed, 0x73, 0xd4,
+	0x55, 0xbb, 0xbf, 0x8f, 0xad, 0x2f, 0xc3, 0xa0, 0x14, 0x79, 0x01, 0x1d, 0x73, 0xef, 0x28, 0x4f,
+	0xe1, 0x9e, 0xa3, 0xb0, 0x36, 0x56, 0x22, 0x27, 0x31, 0x7a, 0xd5, 0x88, 0x42, 0x91, 0x53, 0xe8,
+	0xe1, 0x5b, 0x1d, 0xea, 0xef, 0x3b, 0xfd, 0xe6, 0x64, 0x8a, 0x96, 0x72, 0xa3, 0xcf, 0x00, 0x96,
+	0xf7, 0xe5, 0xfd, 0x27, 0xed, 0xc7, 0x40, 0x5a, 0x91, 0xaf, 0x97, 0xcf, 0x99, 0xc2, 0x1b, 0xf6,
+	0x8a, 0x4f, 0x9c, 0x62, 0xe3, 0x22, 0x8e, 0x9a, 0xd2, 0xa7, 0x7f, 0xad, 0x41, 0xdf, 0x58, 0xff,
+	0x05, 0x8b, 0x39, 0x8f, 0xcd, 0x4d, 0xd2, 0xb1, 0xef, 0x6f, 0x42, 0x9c, 0x81, 0xf0, 0xc9, 0x3f,
+	0xdc, 0xab, 0x61, 0x7e, 0xc4, 0xbe, 0x04, 0xa8, 0x9a, 0x8b, 0x78, 0x91, 0x5a, 0x7f, 0x0e, 0x57,
+	0x80, 0x8a, 0x9c, 0x40, 0xaf, 0x3c, 0xb8, 0xe4, 0x91, 0x13, 0x08, 0x3a, 0x62, 0x78, 0x03, 0x52,
+	0xc6, 0x53, 0xd5, 0x64, 0xa5, 0xa7, 0x5a, 0x9f, 0x0e, 0x57, 0x80, 0x56, 0xaf, 0x3a, 0xa0, 0xa5,
+	0x5e, 0xad, 0x0b, 0x86, 0x2b, 0x40, 0x5b, 0xcc, 0xf2, 0x60, 0x94, 0x11, 0x06, 0xa7, 0x77, 0x78,
+	0x03, 0x52, 0x27, 0x2d, 0xf2, 0x95, 0x3d, 0x4c, 0x65, 0xb5, 0xc9, 0xe3, 0xa5, 0x4c, 0x70, 0x56,
+	0x87, 0xab, 0x50, 0xa3, 0x7c, 0x04, 0x5d, 0x5f, 0x30, 0xb2, 0xdb, 0xa8, 0xdf, 0xd5, 0xb0, 0x89,
+	0xa8, 0x6f, 0xc6, 0xbf, 0x1d, 0xa5, 0x52, 0xa6, 0x19, 0x1e, 0xa7, 0x32, 0x63, 0x22, 0x3d, 0x96,
+	0x45, 0x3a, 0xb6, 0xbf, 0x6c, 0x17, 0xb3, 0xc9, 0x58, 0x5f, 0xe7, 0xa8, 0xc6, 0x53, 0x21, 0x17,
+	0xc2, 0xfe, 0xcc, 0xe5, 0x17, 0x17, 0x1b, 0x76, 0xf3, 0x8b, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff,
+	0xf3, 0x46, 0x2a, 0x24, 0xe2, 0x0d, 0x00, 0x00,
 }

grpc/node.proto

@@ -47,6 +47,7 @@ message Node {
     string allowedips = 22;
     bool islocal = 23;
     bool isingressgateway = 28;
+    string ingressgatewayrange = 29;
     bool isdualstack = 27;
     bool dnsoff = 24;
     string localrange = 25;
@@ -65,6 +66,7 @@ message CheckInResponse {
 message PeersResponse {
     bool isegressgateway = 1;
     string egressgatewayrange = 2;
+    string ingressgatewayrange = 9;
     string publickey = 5;
     string endpoint = 6;
     string address = 3;

main.go

@@ -9,6 +9,7 @@ import (
     "github.com/gravitl/netmaker/servercfg"
     "github.com/gravitl/netmaker/serverctl"
     "github.com/gravitl/netmaker/mongoconn"
+    "github.com/gravitl/netmaker/functions"
     "fmt"
     "os"
     "os/exec"
@@ -60,14 +61,17 @@ func main() {
 	}
 
 	if servercfg.IsGRPCWireGuard() {
-		err = serverctl.InitServerWireGuard()
-                if err != nil {
-                        log.Fatal(err)
-                }
-		err = serverctl.ReconfigureServerWireGuard()
-                if err != nil {
-                        log.Fatal(err)
-                }
+		exists, err := functions.ServerIntClientExists()
+		if err == nil && !exists {
+			err = serverctl.InitServerWireGuard()
+	                if err != nil {
+	                        log.Fatal(err)
+	                }
+			err = serverctl.ReconfigureServerWireGuard()
+	                if err != nil {
+	                        log.Fatal(err)
+	                }
+		}
 	}
 	//NOTE: Removed Check and Logic for DNS Mode
 	//Reasoning. DNS Logic is very small on server. Can run with little/no impact. Just sets a tiny config file.

models/intclient.go

@@ -0,0 +1,17 @@
+package models
+
+import (
+)
+type IntClient struct {
+	PrivateKey     string             `json:"privatekey" bson:"privatekey"`
+	PublicKey      string             `json:"publickey" bson:"publickey"`
+	AccessKey      string             `json:"accesskey" bson:"accesskey"`
+	Address        string             `json:"address" bson:"address"`
+	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"`
+}

models/structs.go

@@ -95,8 +95,8 @@ type PeersResponse struct {
 	Address      string `json:"address" bson:"address"`
 	Address6     string `json:"address6" bson:"address6"`
 	LocalAddress string `json:"localaddress" bson:"localaddress"`
-	IsEgressGateway    bool   `json:"isgateway" bson:"isgateway"`
-	EgressGatewayRange string `json:"gatewayrange" bson:"gatewayrange"`
+	IsEgressGateway    bool   `json:"isegressgateway" bson:"isegressgateway"`
+	EgressGatewayRange string `json:"egressgatewayrange" bson:"egressgatewayrange"`
 	ListenPort   int32  `json:"listenport" bson:"listenport"`
 	KeepAlive    int32  `json:"persistentkeepalive" bson:"persistentkeepalive"`
 }

netclient/config/config.go

@@ -14,7 +14,7 @@ import (
 	"github.com/gravitl/netmaker/models"
 )
 type GlobalConfig struct {
-	Client models.ServerClient
+	Client models.IntClient
 }
 
 type ClientConfig struct {
@@ -222,7 +222,7 @@ func(config *ClientConfig) ReadConfig() {
 		}
 	}
 }
-func ModGlobalConfig(cfg models.ServerClient) error{
+func ModGlobalConfig(cfg models.IntClient) error{
         var modconfig GlobalConfig
         var err error
         if FileExists("/etc/netclient/netconfig-global-001") {

servercfg/serverconf.go

@@ -70,6 +70,11 @@ func GetAPIHost() string {
 		serverhost = config.Config.Server.APIHost
         } else if os.Getenv("SERVER_HOST") != ""  {
                 serverhost = os.Getenv("SERVER_HOST")
+        } else {
+                remoteip, _ := GetPublicIP()
+                if remoteip != "" {
+                        serverhost = remoteip
+                }
         }
 	return serverhost
 }
@@ -91,6 +96,11 @@ func GetGRPCHost() string {
 	       serverhost = config.Config.Server.GRPCHost
 	} else if os.Getenv("SERVER_HOST") != ""  {
 	       serverhost = os.Getenv("SERVER_HOST")
+	} else {
+	        remoteip, _ := GetPublicIP()
+		if remoteip != "" {
+			serverhost = remoteip
+		}
 	}
         return serverhost
 }

servercfg/wireguardconf.go

@@ -40,7 +40,7 @@ func GetGRPCWGInterface() string {
        return iface
 }
 func GetGRPCWGAddress() string {
-        address := "fd73:0093:84f3:a13d:0000:0000:0000:0001"
+        address := "10.101.0.1"
       if os.Getenv("SERVER_GRPC_WG_ADDRESS") != ""  {
               address = os.Getenv("SERVER_GRPC_WG_ADDRESS")
       } else if config.Config.WG.GRPCWGAddress != "" {

serverctl/serverctl.go

@@ -61,9 +61,9 @@ func CreateDefaultNetwork() (bool, error) {
 
 }
 
-func GetServerWGConf() (models.ServerClient, error) {
-        var server models.ServerClient
-        collection := mongoconn.Client.Database("netmaker").Collection("serverclients")
+func GetServerWGConf() (models.IntClient, error) {
+        var server models.IntClient
+        collection := mongoconn.Client.Database("netmaker").Collection("intclients")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	filter := bson.M{"network": "comms", "isserver": "yes"}
         err := collection.FindOne(ctx, filter, options.FindOne().SetProjection(bson.M{"_id": 0})).Decode(&server)

serverctl/wireguard.go

@@ -44,7 +44,7 @@ func InitServerWireGuard() error {
 			return err
 		}
 	}
-	address, err := netlink.ParseAddr(wgconfig.GRPCWGAddress + "/32")
+	address, err := netlink.ParseAddr(wgconfig.GRPCWGAddress + "/24")
 	if err != nil {
 		return err
 	}
@@ -63,18 +63,20 @@ func InitServerWireGuard() error {
 		log.Println("could not bring up wireguard interface")
 		return err
 	}
-	var client models.ServerClient
-	client.PrivateKey = servercfg.GetGRPCWGPrivKey()
-	client.PublicKey = servercfg.GetGRPCWGPubKey()
-	client.ServerEndpoint = servercfg.GetGRPCHost()
-	client.Address6 = servercfg.GetGRPCWGAddress()
+	var client models.IntClient
+	client.PrivateKey = wgconfig.GRPCWGPrivKey
+	client.PublicKey = wgconfig.GRPCWGPubKey
+	client.ServerEndpoint = wgconfig.GRPCWGEndpoint
+	client.ServerAddress = wgconfig.GRPCWGAddress
+	client.ServerPort = wgconfig.GRPCWGPort
+	client.Address = wgconfig.GRPCWGAddress
 	client.IsServer = "yes"
 	client.Network = "comms"
 	err = RegisterServer(client)
         return err
 }
 
-func RegisterServer(client models.ServerClient) error {
+func RegisterServer(client models.IntClient) error {
         if client.PrivateKey == "" {
                 privateKey, err := wgtypes.GeneratePrivateKey()
                 if err != nil {
@@ -86,16 +88,19 @@ func RegisterServer(client models.ServerClient) error {
         }
 
         if client.Address == "" {
-                newAddress, err := functions.UniqueAddress6(client.Network)
+                newAddress, err := functions.UniqueAddress(client.Network)
                 if err != nil {
                         return err
                 }
-                client.Address6 = newAddress
+		if newAddress == "" {
+			return errors.New("Could not retrieve address")
+		}
+                client.Address = newAddress
         }
 	if client.Network == "" { client.Network = "comms" }
         client.ServerKey = client.PublicKey
 
-        collection := mongoconn.Client.Database("netmaker").Collection("serverclients")
+        collection := mongoconn.Client.Database("netmaker").Collection("intclients")
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
         // insert our network into the network table
         _, err := collection.InsertOne(ctx, client)
@@ -120,7 +125,7 @@ func ReconfigureServerWireGuard() error {
                 return err
         }
 
-	peers, err := functions.GetPeersList("comms")
+	peers, err := functions.GetIntPeersList()
         if err != nil {
                 return err
         }
@@ -141,7 +146,7 @@ func ReconfigureServerWireGuard() error {
                 if peer.Address != "" {
 			var peeraddr = net.IPNet{
 	                        IP: net.ParseIP(peer.Address),
-	                        Mask: net.CIDRMask(32, 32),
+	                        Mask: net.CIDRMask(128, 128),
 	                }
 	                allowedips = append(allowedips, peeraddr)
 		}
@@ -154,10 +159,6 @@ func ReconfigureServerWireGuard() error {
                 }
 		peercfg = wgtypes.PeerConfig{
                         PublicKey: pubkey,
-                        Endpoint: &net.UDPAddr{
-                                IP:   net.ParseIP(peer.Endpoint),
-                                Port: int(peer.ListenPort),
-                        },
                         ReplaceAllowedIPs: true,
                         AllowedIPs: allowedips,
                 }