adding gateway functionality

controllers/common.go

@@ -141,8 +141,8 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
     if nodechange.ExpirationDateTime != 0 {
         node.ExpirationDateTime = nodechange.ExpirationDateTime
     }
-    if nodechange.PreUp != "" {
-        node.PreUp = nodechange.PreUp
+    if nodechange.PostDown != "" {
+        node.PostDown = nodechange.PostDown
     }
     if nodechange.Interface != "" {
         node.Interface = nodechange.Interface
@@ -204,7 +204,7 @@ func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
                         {"expdatetime", node.ExpirationDateTime},
                         {"endpoint", node.Endpoint},
                         {"postup", node.PostUp},
-                        {"preup", node.PreUp},
+                        {"preup", node.PostDown},
                         {"macaddress", node.MacAddress},
                         {"localaddress", node.LocalAddress},
                         {"persistentkeepalive", node.PersistentKeepalive},

controllers/networkHttpController.go

@@ -190,7 +190,6 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
         ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 
         filter := bson.M{"netid": params["networkname"]}
-
         // prepare update model.
         update := bson.D{
                 {"$set", bson.D{
@@ -198,7 +197,7 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
                         {"displayname", network.DisplayName},
                         {"defaultlistenport", network.DefaultListenPort},
                         {"defaultpostup", network.DefaultPostUp},
-                        {"defaultpreup", network.DefaultPreUp},
+                        {"defaultpreup", network.DefaultPostDown},
 			{"defaultkeepalive", network.DefaultKeepalive},
                         {"keyupdatetimestamp", network.KeyUpdateTimeStamp},
                         {"defaultsaveconfig", network.DefaultSaveConfig},
@@ -206,7 +205,7 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
                         {"nodeslastmodified", network.NodesLastModified},
                         {"networklastmodified", network.NetworkLastModified},
                         {"allowmanualsignup", network.AllowManualSignUp},
-                        {"defaultcheckininterval", network.DefaultCheckInInterval},
+			{"defaultcheckininterval", network.DefaultCheckInInterval},
                 }},
         }
 
@@ -223,6 +222,34 @@ func keyUpdate(w http.ResponseWriter, r *http.Request) {
         json.NewEncoder(w).Encode(network)
 }
 
+//Update a network
+func AlertNetwork(netid string) error{
+
+        collection := mongoconn.Client.Database("netmaker").Collection("networks")
+        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+        filter := bson.M{"netid": netid}
+
+
+        var network models.Network
+
+        network, err := functions.GetParentNetwork(netid)
+        if err != nil {
+                return err
+        }
+	updatetime := time.Now().Unix()
+        update := bson.D{
+                {"$set", bson.D{
+                        {"nodeslastmodified", updatetime},
+                        {"networklastmodified", updatetime},
+                }},
+        }
+
+        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&network)
+        defer cancel()
+
+        return err
+}
+
 //Update a network
 func updateNetwork(w http.ResponseWriter, r *http.Request) {
 
@@ -296,8 +323,8 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
 		network.DefaultListenPort = networkChange.DefaultListenPort
 		haschange = true
         }
-        if networkChange.DefaultPreUp != "" {
-		network.DefaultPreUp = networkChange.DefaultPreUp
+        if networkChange.DefaultPostDown != "" {
+		network.DefaultPostDown = networkChange.DefaultPostDown
 		haschange = true
         }
         if networkChange.DefaultInterface != "" {
@@ -340,7 +367,7 @@ func updateNetwork(w http.ResponseWriter, r *http.Request) {
                         {"displayname", network.DisplayName},
                         {"defaultlistenport", network.DefaultListenPort},
                         {"defaultpostup", network.DefaultPostUp},
-                        {"defaultpreup", network.DefaultPreUp},
+                        {"defaultpreup", network.DefaultPostDown},
                         {"defaultkeepalive", network.DefaultKeepalive},
                         {"defaultsaveconfig", network.DefaultSaveConfig},
                         {"defaultinterface", network.DefaultInterface},

controllers/nodeGrpcController.go

@@ -43,7 +43,7 @@ func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.ReadNodeRe
 			Nodenetwork:  node.Network,
 			Interface:  node.Interface,
 			Localaddress:  node.LocalAddress,
-			Preup:  node.PreUp,
+			Postdown:  node.PostDown,
 			Postup:  node.PostUp,
 			Checkininterval:  node.CheckInInterval,
 			Ispending:  node.IsPending,
@@ -197,7 +197,7 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
                         PersistentKeepalive:  data.GetKeepalive(),
                         Network:  data.GetNodenetwork(),
                         Interface:  data.GetInterface(),
-                        PreUp:  data.GetPreup(),
+                        PostDown:  data.GetPostdown(),
                         PostUp:  data.GetPostup(),
                         IsPending:  data.GetIspending(),
                         PublicKey:  data.GetPublickey(),
@@ -240,7 +240,7 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
                         Endpoint:  newnode.Endpoint,
                         Password:  newnode.Password,
                         Interface:  newnode.Interface,
-                        Preup:  newnode.PreUp,
+                        Postdown:  newnode.PostDown,
                         Postup:  newnode.PostUp,
                         Nodenetwork:  newnode.Network,
                         Ispending:  newnode.IsPending,

controllers/nodeHttpController.go

@@ -26,8 +26,8 @@ func nodeHandlers(r *mux.Router) {
     r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
     r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
     r.HandleFunc("/api/nodes/{network}/{macaddress}/checkin", authorize(true, "node", http.HandlerFunc(checkIn))).Methods("POST")
-//    r.HandleFunc("/api/nodes/{network}/{macaddress}/creategateway", authorize(true, "master", http.HandlerFunc(createGateway))).Methods("POST")
-//    r.HandleFunc("/api/nodes/{network}/{macaddress}/deletegateway", authorize(true, "master", http.HandlerFunc(deleteGateway))).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/creategateway", authorize(true, "master", http.HandlerFunc(createGateway))).Methods("POST")
+    r.HandleFunc("/api/nodes/{network}/{macaddress}/deletegateway", authorize(true, "master", http.HandlerFunc(deleteGateway))).Methods("POST")
     r.HandleFunc("/api/nodes/{network}/{macaddress}/uncordon", authorize(true, "master", http.HandlerFunc(uncordonNode))).Methods("POST")
     r.HandleFunc("/api/nodes/{network}/nodes", createNode).Methods("POST")
     r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
@@ -565,7 +565,15 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
 
         var params = mux.Vars(r)
 
-        var node models.Node
+        var gateway models.GatewayRequest
+
+	err := json.NewDecoder(r.Body).Decode(&gateway)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
+	gateway.NetID = params["network"]
+	gateway.NodeID = params["macaddress"]
 
         node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
         if err != nil {
@@ -573,42 +581,91 @@ func createGateway(w http.ResponseWriter, r *http.Request) {
                 return
         }
 
-        collection := mongoconn.Client.Database("netmaker").Collection("nodes")
+	err = validateGateway(gateway)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
-        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+        var nodechange models.Node
 
-        // Create filter
-        filter := bson.M{"macaddress": params["macaddress"], "network": params["network"]}
+	nodechange.IsGateway = true
+	nodechange.GatewayRange = gateway.RangeString
+	if gateway.PostUp == "" {
+		nodechange.PostUp = "iptables -A FORWARD -i %i -j ACCEPT; iptables -t nat -A POSTROUTING -o " + gateway.Interface + " -j MASQUERADE"
+	} else {
+		nodechange.PostUp = gateway.PostUp
+	}
+	if gateway.PostDown == "" {
+		nodechange.PostDown = "iptables -D FORWARD -i %i -j ACCEPT; iptables -t nat -D POSTROUTING -o " + gateway.Interface + " -j MASQUERADE"
+	} else {
+		nodechange.PostDown = gateway.PostDown
+	}
 
-        node.SetLastModified()
+        node, err = UpdateNode(nodechange, node)
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
-        err =  ValidateNode("create", params["network"], node)
+        err = AlertNetwork(params["networkname"])
         if err != nil {
                 returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
 
-        // prepare update model.
-        update := bson.D{
-                {"$set", bson.D{
-                        {"ispending", false},
-                }},
+
+
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(node)
+}
+
+func validateGateway(gateway models.GatewayRequest) error {
+		var err error
+                isIpv4 := functions.IsIpv4Net(gateway.RangeString)
+                empty := gateway.RangeString == ""
+                if empty || !isIpv4 {
+			err = errors.New("IP Range Not Valid")
+		}
+		return err
+}
+
+
+
+
+func deleteGateway(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+
+        var params = mux.Vars(r)
+
+        node, err := functions.GetNodeByMacAddress(params["network"], params["macaddress"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
         }
 
-        err = collection.FindOneAndUpdate(ctx, filter, update).Decode(&node)
+        var nodechange models.Node
 
-        defer cancel()
+        nodechange.IsGateway = false
+        nodechange.GatewayRange = ""
+        nodechange.PostUp = ""
+        nodechange.PostDown = ""
 
+        node, err = UpdateNode(nodechange, node)
         if err != nil {
                 returnErrorResponse(w,r,formatError(err, "internal"))
                 return
         }
-        fmt.Println("Node " + node.Name + " uncordoned.")
 
-	w.WriteHeader(http.StatusOK)
-        json.NewEncoder(w).Encode("SUCCESS")
-}
+        err = AlertNetwork(params["networkname"])
+        if err != nil {
+                returnErrorResponse(w,r,formatError(err, "internal"))
+                return
+        }
 
+        w.WriteHeader(http.StatusOK)
+        json.NewEncoder(w).Encode(node)
+}
 
 
 func updateNode(w http.ResponseWriter, r *http.Request) {

grpc/node.pb.go

@@ -126,7 +126,7 @@ type Node struct {
 	Nodenetwork          string   `protobuf:"bytes,9,opt,name=nodenetwork,proto3" json:"nodenetwork,omitempty"`
 	Ispending            bool     `protobuf:"varint,10,opt,name=ispending,proto3" json:"ispending,omitempty"`
 	Postup               string   `protobuf:"bytes,11,opt,name=postup,proto3" json:"postup,omitempty"`
-	Preup                string   `protobuf:"bytes,12,opt,name=preup,proto3" json:"preup,omitempty"`
+	Postdown             string   `protobuf:"bytes,12,opt,name=postdown,proto3" json:"postdown,omitempty"`
 	Keepalive            int32    `protobuf:"varint,13,opt,name=keepalive,proto3" json:"keepalive,omitempty"`
 	Saveconfig           bool     `protobuf:"varint,14,opt,name=saveconfig,proto3" json:"saveconfig,omitempty"`
 	Accesskey            string   `protobuf:"bytes,15,opt,name=accesskey,proto3" json:"accesskey,omitempty"`
@@ -136,6 +136,7 @@ type Node struct {
 	Checkininterval      int32    `protobuf:"varint,19,opt,name=checkininterval,proto3" json:"checkininterval,omitempty"`
 	Localaddress         string   `protobuf:"bytes,20,opt,name=localaddress,proto3" json:"localaddress,omitempty"`
 	Postchanges          string   `protobuf:"bytes,21,opt,name=postchanges,proto3" json:"postchanges,omitempty"`
+	Allowedips           string   `protobuf:"bytes,22,opt,name=allowedips,proto3" json:"allowedips,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -243,9 +244,9 @@ func (m *Node) GetPostup() string {
 	return ""
 }
 
-func (m *Node) GetPreup() string {
+func (m *Node) GetPostdown() string {
 	if m != nil {
-		return m.Preup
+		return m.Postdown
 	}
 	return ""
 }
@@ -313,6 +314,13 @@ func (m *Node) GetPostchanges() string {
 	return ""
 }
 
+func (m *Node) GetAllowedips() string {
+	if m != nil {
+		return m.Allowedips
+	}
+	return ""
+}
+
 type CheckInResponse struct {
 	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
 	Needpeerupdate       bool     `protobuf:"varint,2,opt,name=needpeerupdate,proto3" json:"needpeerupdate,omitempty"`
@@ -401,6 +409,8 @@ func (m *CheckInResponse) GetNeeddelete() bool {
 }
 
 type PeersResponse struct {
+	Isgateway            bool     `protobuf:"varint,1,opt,name=isgateway,proto3" json:"isgateway,omitempty"`
+	Gatewayrange         string   `protobuf:"bytes,2,opt,name=gatewayrange,proto3" json:"gatewayrange,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"`
@@ -437,6 +447,20 @@ func (m *PeersResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_PeersResponse proto.InternalMessageInfo
 
+func (m *PeersResponse) GetIsgateway() bool {
+	if m != nil {
+		return m.Isgateway
+	}
+	return false
+}
+
+func (m *PeersResponse) GetGatewayrange() string {
+	if m != nil {
+		return m.Gatewayrange
+	}
+	return ""
+}
+
 func (m *PeersResponse) GetPublickey() string {
 	if m != nil {
 		return m.Publickey
@@ -994,58 +1018,61 @@ func init() {
 func init() { proto.RegisterFile("grpc/node.proto", fileDescriptor_d13bd996b67da4ef) }
 
 var fileDescriptor_d13bd996b67da4ef = []byte{
-	// 847 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x96, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0xc7, 0x95, 0x6c, 0xd2, 0xb8, 0x27, 0x4d, 0xdb, 0x9d, 0xee, 0xa2, 0x91, 0x85, 0xaa, 0xc8,
-	0x42, 0xa8, 0x8b, 0x68, 0x53, 0x8a, 0x84, 0xb8, 0x43, 0x62, 0x91, 0x56, 0x48, 0xb0, 0x02, 0x23,
-	0x6e, 0xb8, 0x9b, 0x7a, 0x4e, 0xbd, 0x56, 0x9c, 0x99, 0xa9, 0xc7, 0x49, 0xd5, 0x07, 0xe0, 0xd1,
-	0x78, 0x27, 0x2e, 0xb8, 0x40, 0xf3, 0xe1, 0x78, 0xec, 0x86, 0x76, 0xd9, 0xbd, 0xcb, 0xfc, 0xe6,
-	0x7c, 0xcc, 0x39, 0xf3, 0x9f, 0x13, 0xc3, 0x51, 0x5e, 0xa9, 0x6c, 0x21, 0x24, 0xc7, 0x0b, 0x55,
-	0xc9, 0x5a, 0x92, 0x91, 0xf9, 0x9d, 0x70, 0x38, 0xf8, 0x49, 0xe6, 0x85, 0x48, 0xf1, 0x76, 0x8d,
-	0xba, 0x26, 0xa7, 0x00, 0x2b, 0x96, 0x31, 0xce, 0x2b, 0xd4, 0x9a, 0x0e, 0xe6, 0x83, 0xb3, 0xfd,
-	0x34, 0x20, 0x24, 0x86, 0x48, 0x31, 0xad, 0xef, 0x64, 0xc5, 0xe9, 0xd0, 0xee, 0x6e, 0xd7, 0x84,
-	0xc2, 0x44, 0x60, 0x7d, 0x27, 0xab, 0x25, 0x7d, 0x66, 0xb7, 0x9a, 0x65, 0xf2, 0x15, 0xcc, 0x7c,
-	0x16, 0xad, 0xa4, 0xd0, 0x48, 0xe6, 0x30, 0x65, 0x59, 0x86, 0x5a, 0xd7, 0x72, 0x89, 0xc2, 0xe7,
-	0x09, 0x51, 0xf2, 0xf7, 0x08, 0x46, 0x6f, 0x25, 0x47, 0x72, 0x08, 0xc3, 0x82, 0x7b, 0x8b, 0x61,
-	0xc1, 0x09, 0x81, 0x91, 0x60, 0x2b, 0xf4, 0xd9, 0xed, 0x6f, 0x93, 0xb9, 0x39, 0xb2, 0xcf, 0xdc,
-	0x9c, 0xf7, 0x14, 0xa0, 0x2c, 0x74, 0x8d, 0x42, 0xc9, 0xaa, 0xa6, 0xa3, 0xf9, 0xe0, 0x6c, 0x9c,
-	0x06, 0x84, 0x7c, 0x0a, 0xfb, 0x6a, 0x7d, 0x5d, 0x16, 0xd9, 0x12, 0xef, 0xe9, 0xd8, 0xfa, 0xb6,
-	0xc0, 0x54, 0x8b, 0x82, 0x2b, 0x59, 0x88, 0x9a, 0xee, 0xb9, 0x6a, 0x9b, 0x75, 0xaf, 0x53, 0x93,
-	0x47, 0x3b, 0x15, 0xf5, 0x3a, 0x35, 0x87, 0xa9, 0xe9, 0x7e, 0xd3, 0xad, 0x7d, 0x57, 0x7e, 0x80,
-	0xcc, 0xb9, 0x0a, 0xad, 0x50, 0xf0, 0x42, 0xe4, 0x14, 0xe6, 0x83, 0xb3, 0x28, 0x6d, 0x01, 0xf9,
-	0x04, 0xf6, 0x94, 0xd4, 0xf5, 0x5a, 0xd1, 0xa9, 0x75, 0xf5, 0x2b, 0xf2, 0x02, 0xc6, 0xaa, 0xc2,
-	0xb5, 0xa2, 0x07, 0x16, 0xbb, 0x85, 0x89, 0xb5, 0x44, 0x54, 0xac, 0x2c, 0x36, 0x48, 0x67, 0xb6,
-	0x05, 0x2d, 0x30, 0x75, 0x68, 0xb6, 0xc1, 0x4c, 0x8a, 0x9b, 0x22, 0xa7, 0x87, 0x36, 0x55, 0x40,
-	0x8c, 0xb7, 0xbb, 0x17, 0xd3, 0xa1, 0x23, 0xd7, 0xa1, 0x2d, 0xb0, 0xe7, 0x14, 0x35, 0x56, 0x37,
-	0x2c, 0x43, 0x7a, 0xec, 0x76, 0xb7, 0xc0, 0xd4, 0x59, 0x32, 0x5d, 0x67, 0xef, 0x30, 0x5b, 0x16,
-	0x82, 0x3e, 0x77, 0x75, 0x06, 0x88, 0x24, 0x70, 0x60, 0x96, 0x2b, 0xc9, 0x8b, 0x9b, 0x02, 0x39,
-	0x25, 0xd6, 0xa4, 0xc3, 0xc8, 0x19, 0x1c, 0x79, 0x73, 0x1b, 0x79, 0xc3, 0x4a, 0x7a, 0x62, 0xab,
-	0xe8, 0x63, 0x1b, 0x4d, 0x66, 0xac, 0x6c, 0x6e, 0xe5, 0x85, 0x8f, 0x16, 0x30, 0x73, 0x26, 0xd3,
-	0xad, 0xec, 0x1d, 0x13, 0x39, 0x6a, 0xfa, 0xd2, 0x9d, 0x29, 0x40, 0xc9, 0x9f, 0x43, 0x38, 0x7a,
-	0x6d, 0x22, 0xff, 0xd8, 0x0a, 0x96, 0xc2, 0x44, 0xaf, 0x6d, 0xd5, 0x56, 0x8a, 0x51, 0xda, 0x2c,
-	0xc9, 0xe7, 0x70, 0x28, 0x10, 0xb9, 0x42, 0xac, 0xd6, 0x8a, 0xb3, 0xda, 0x29, 0x33, 0x4a, 0x7b,
-	0x94, 0x7c, 0x01, 0xc7, 0x86, 0xb8, 0xae, 0x7a, 0xcb, 0x67, 0xd6, 0xf2, 0x01, 0x6f, 0xf4, 0xb1,
-	0x42, 0xad, 0x59, 0x8e, 0x56, 0xb6, 0x5e, 0x1f, 0x1e, 0x75, 0xf5, 0x31, 0xee, 0xeb, 0xe3, 0x33,
-	0x98, 0x99, 0x98, 0x4b, 0xbc, 0xf7, 0x89, 0xf6, 0xac, 0x45, 0x17, 0x9a, 0x9b, 0x37, 0x80, 0x63,
-	0x89, 0x35, 0x5a, 0x05, 0x47, 0x69, 0x40, 0x92, 0xbf, 0x06, 0x30, 0xfb, 0x05, 0xb1, 0xd2, 0xdb,
-	0x2e, 0x7c, 0xf8, 0x6b, 0xf9, 0xf0, 0x17, 0xda, 0xbf, 0xd3, 0xc9, 0x8e, 0x3b, 0x7d, 0x54, 0xe1,
-	0xc9, 0x02, 0x66, 0xaf, 0x2b, 0x64, 0x35, 0x9a, 0x79, 0x92, 0xe2, 0x2d, 0x39, 0x05, 0x3b, 0xfc,
-	0xec, 0x4d, 0x4e, 0xaf, 0xe0, 0xc2, 0x4e, 0x45, 0xbb, 0xe9, 0x86, 0x62, 0xcf, 0x41, 0xbf, 0x8f,
-	0xc3, 0xef, 0xb6, 0xa7, 0xff, 0x23, 0x43, 0xe8, 0xf0, 0x74, 0x86, 0x37, 0x30, 0x4d, 0x91, 0xf1,
-	0x36, 0xfe, 0xe3, 0x63, 0x3a, 0x18, 0xc5, 0xc3, 0xee, 0x28, 0x3e, 0x0f, 0x03, 0x3d, 0x9d, 0xf7,
-	0x57, 0x98, 0xfd, 0x60, 0xd5, 0xf0, 0xbe, 0x99, 0x8d, 0x74, 0x5d, 0xaa, 0xb7, 0xed, 0x94, 0x0e,
-	0x51, 0xf2, 0xaa, 0x1b, 0x52, 0xff, 0xf7, 0xdb, 0x32, 0x55, 0xbf, 0xc1, 0xda, 0x6b, 0xf0, 0x63,
-	0xaa, 0xfe, 0x36, 0x0c, 0xa4, 0xc9, 0x2b, 0x18, 0x9b, 0x97, 0xa9, 0x7d, 0xd9, 0x27, 0xae, 0xec,
-	0x8e, 0xd6, 0x53, 0x67, 0x91, 0x7c, 0x09, 0xb0, 0x9d, 0x05, 0x4f, 0xdf, 0xeb, 0xcf, 0x81, 0xb5,
-	0x26, 0xdf, 0x6d, 0x07, 0x57, 0xe5, 0xa3, 0x7a, 0xc7, 0x97, 0xce, 0xb1, 0x37, 0x64, 0xd2, 0xbe,
-	0xf5, 0xd5, 0x3f, 0x43, 0x98, 0x9a, 0xe8, 0xbf, 0x61, 0xb5, 0x29, 0x32, 0x24, 0x97, 0x30, 0xb6,
-	0xff, 0xa3, 0x84, 0xb8, 0x00, 0xe1, 0x5f, 0x77, 0x7c, 0xd2, 0x61, 0xfe, 0xc5, 0x7e, 0x03, 0xd0,
-	0x4a, 0x99, 0x78, 0x93, 0xce, 0x6b, 0x88, 0x77, 0x40, 0x4d, 0x2e, 0x21, 0x6a, 0x64, 0x42, 0x9e,
-	0x3b, 0x83, 0x40, 0x7f, 0xf1, 0x03, 0xa4, 0x4d, 0xa6, 0x56, 0xd2, 0x4d, 0xa6, 0xce, 0xab, 0x88,
-	0x77, 0x40, 0xeb, 0xd7, 0xca, 0xa1, 0xf1, 0xeb, 0x68, 0x2e, 0xde, 0x01, 0x35, 0xb9, 0x82, 0xa8,
-	0xb9, 0xd2, 0xe6, 0x84, 0x81, 0x56, 0xe2, 0x07, 0x48, 0x5f, 0x0e, 0xc8, 0x39, 0x4c, 0x7c, 0xcf,
-	0xc9, 0x71, 0xef, 0x0a, 0x6e, 0xe3, 0x3e, 0xd1, 0xdf, 0x2f, 0xfe, 0x38, 0xcf, 0xa5, 0xcc, 0x4b,
-	0xbc, 0xc8, 0x65, 0xc9, 0x44, 0x7e, 0x21, 0xab, 0x7c, 0x61, 0xbf, 0x9e, 0xae, 0xd7, 0x37, 0x8b,
-	0xfa, 0x5e, 0xa1, 0x5e, 0x2c, 0x85, 0xbc, 0x13, 0xf6, 0xbb, 0x4a, 0x5d, 0x5f, 0xef, 0xd9, 0xcd,
-	0xaf, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x18, 0x12, 0x66, 0x6d, 0x09, 0x00, 0x00,
+	// 882 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x5d, 0x6f, 0xe4, 0x34,
+	0x14, 0xd5, 0xcc, 0x76, 0x3a, 0xd3, 0x3b, 0x9d, 0xb6, 0xeb, 0xb2, 0x2b, 0x2b, 0x42, 0xd5, 0x28,
+	0x42, 0xa8, 0x8b, 0x68, 0xa7, 0x14, 0x09, 0xf1, 0x86, 0xc4, 0x22, 0xad, 0x90, 0x60, 0x05, 0x41,
+	0xbc, 0xf0, 0xe6, 0xc6, 0xb7, 0xd9, 0x68, 0x52, 0xdb, 0x8d, 0x3d, 0x1d, 0xf5, 0x07, 0x20, 0xfe,
+	0x05, 0xbf, 0x94, 0x07, 0xe4, 0x8f, 0x4c, 0x9c, 0x74, 0x68, 0x97, 0xdd, 0xb7, 0xf8, 0xe4, 0xde,
+	0x7b, 0x7c, 0x8f, 0x8f, 0x6f, 0x02, 0x87, 0x45, 0xad, 0xf2, 0x85, 0x90, 0x1c, 0xcf, 0x55, 0x2d,
+	0x8d, 0x24, 0x3b, 0xf6, 0x39, 0xe5, 0xb0, 0xff, 0x93, 0x2c, 0x4a, 0x91, 0xe1, 0xed, 0x0a, 0xb5,
+	0x21, 0x27, 0x00, 0x37, 0x2c, 0x67, 0x9c, 0xd7, 0xa8, 0x35, 0x1d, 0xcc, 0x07, 0xa7, 0x7b, 0x59,
+	0x84, 0x90, 0x04, 0x26, 0x8a, 0x69, 0xbd, 0x96, 0x35, 0xa7, 0x43, 0xf7, 0x76, 0xb3, 0x26, 0x14,
+	0xc6, 0x02, 0xcd, 0x5a, 0xd6, 0x4b, 0xfa, 0xcc, 0xbd, 0x6a, 0x96, 0xe9, 0x57, 0x30, 0x0b, 0x2c,
+	0x5a, 0x49, 0xa1, 0x91, 0xcc, 0x61, 0xca, 0xf2, 0x1c, 0xb5, 0x36, 0x72, 0x89, 0x22, 0xf0, 0xc4,
+	0x50, 0xfa, 0xf7, 0x08, 0x76, 0xde, 0x4a, 0x8e, 0xe4, 0x00, 0x86, 0x25, 0x0f, 0x11, 0xc3, 0x92,
+	0x13, 0x02, 0x3b, 0x82, 0xdd, 0x60, 0x60, 0x77, 0xcf, 0x96, 0xb9, 0xd9, 0x72, 0x60, 0x6e, 0xf6,
+	0x7b, 0x02, 0x50, 0x95, 0xda, 0xa0, 0x50, 0xb2, 0x36, 0x74, 0x67, 0x3e, 0x38, 0x1d, 0x65, 0x11,
+	0x42, 0x3e, 0x85, 0x3d, 0xb5, 0xba, 0xaa, 0xca, 0x7c, 0x89, 0xf7, 0x74, 0xe4, 0x72, 0x5b, 0xc0,
+	0x76, 0x8b, 0x82, 0x2b, 0x59, 0x0a, 0x43, 0x77, 0x7d, 0xb7, 0xcd, 0xba, 0xa7, 0xd4, 0xf8, 0x51,
+	0xa5, 0x26, 0x3d, 0xa5, 0xe6, 0x30, 0xb5, 0xea, 0x37, 0x6a, 0xed, 0xf9, 0xf6, 0x23, 0xc8, 0xee,
+	0xab, 0xd4, 0x0a, 0x05, 0x2f, 0x45, 0x41, 0x61, 0x3e, 0x38, 0x9d, 0x64, 0x2d, 0x40, 0x5e, 0xc2,
+	0xae, 0x92, 0xda, 0xac, 0x14, 0x9d, 0xba, 0xd4, 0xb0, 0x72, 0x9c, 0x52, 0x1b, 0x2e, 0xd7, 0x82,
+	0xee, 0x07, 0xce, 0xb0, 0xb6, 0x15, 0x97, 0x88, 0x8a, 0x55, 0xe5, 0x1d, 0xd2, 0x99, 0x13, 0xa2,
+	0x05, 0x6c, 0x37, 0x9a, 0xdd, 0x61, 0x2e, 0xc5, 0x75, 0x59, 0xd0, 0x03, 0x47, 0x18, 0x21, 0x36,
+	0xdb, 0x9f, 0x8e, 0xd5, 0xe9, 0xd0, 0xeb, 0xb4, 0x01, 0xdc, 0x6e, 0x85, 0xc1, 0xfa, 0x9a, 0xe5,
+	0x48, 0x8f, 0xfc, 0xdb, 0x0d, 0x60, 0xbb, 0xad, 0x98, 0x36, 0xf9, 0x3b, 0xcc, 0x97, 0xa5, 0xa0,
+	0xcf, 0x7d, 0xb7, 0x11, 0x44, 0x52, 0xd8, 0xb7, 0xcb, 0x1b, 0xc9, 0xcb, 0xeb, 0x12, 0x39, 0x25,
+	0x2e, 0xa4, 0x83, 0x91, 0x53, 0x38, 0x0c, 0xe1, 0xae, 0xf2, 0x1d, 0xab, 0xe8, 0xb1, 0xeb, 0xa2,
+	0x0f, 0xbb, 0x6a, 0x32, 0x67, 0x55, 0x73, 0x36, 0x9f, 0x84, 0x6a, 0x11, 0x66, 0xf7, 0x64, 0x95,
+	0xc9, 0xdf, 0x31, 0x51, 0xa0, 0xa6, 0x2f, 0xfc, 0x9e, 0x22, 0xc8, 0x2a, 0xc2, 0xaa, 0x4a, 0xae,
+	0x91, 0x97, 0x4a, 0xd3, 0x97, 0xfe, 0x7c, 0x5b, 0x24, 0xfd, 0x73, 0x08, 0x87, 0xaf, 0x2d, 0xf3,
+	0x8f, 0xad, 0xad, 0x29, 0x8c, 0xf5, 0xca, 0xa9, 0xe2, 0x0c, 0x3b, 0xc9, 0x9a, 0x25, 0xf9, 0x1c,
+	0x0e, 0x04, 0x22, 0x57, 0x88, 0xf5, 0x4a, 0x71, 0x66, 0xbc, 0x7f, 0x27, 0x59, 0x0f, 0x25, 0x5f,
+	0xc0, 0x91, 0x45, 0xbc, 0xea, 0x21, 0xf2, 0x99, 0x8b, 0x7c, 0x80, 0x37, 0x2e, 0xba, 0x41, 0xad,
+	0x59, 0x81, 0xce, 0xdc, 0xc1, 0x45, 0x01, 0xea, 0xba, 0x68, 0xd4, 0x77, 0xd1, 0x67, 0x30, 0xb3,
+	0x35, 0x97, 0x78, 0x1f, 0x88, 0x76, 0x5d, 0x44, 0x17, 0xb4, 0x3a, 0x58, 0x80, 0x63, 0x85, 0x06,
+	0x9d, 0xcf, 0x27, 0x59, 0x84, 0xa4, 0x7f, 0x0d, 0x61, 0xf6, 0x0b, 0x62, 0xad, 0x37, 0x2a, 0x38,
+	0xd6, 0x82, 0x19, 0x5c, 0xb3, 0xfb, 0xa0, 0x43, 0x0b, 0xd8, 0xd3, 0x09, 0x8f, 0xb5, 0x15, 0x3a,
+	0xdc, 0xe3, 0x0e, 0xf6, 0x11, 0xb7, 0xf2, 0xc3, 0x27, 0x41, 0xdf, 0x35, 0xe3, 0x2d, 0xae, 0x79,
+	0xf4, 0x0e, 0xa5, 0x0b, 0x98, 0xbd, 0xae, 0x91, 0x19, 0xb4, 0x73, 0x2b, 0xc3, 0x5b, 0x72, 0x02,
+	0x6e, 0xc8, 0x3a, 0x0d, 0xa6, 0x97, 0x70, 0xee, 0xa6, 0xaf, 0x7b, 0xe9, 0x87, 0x6f, 0x2f, 0x41,
+	0xbf, 0x4f, 0xc2, 0xef, 0xee, 0x54, 0xfe, 0x07, 0x43, 0x9c, 0xf0, 0x34, 0xc3, 0x1b, 0x98, 0x66,
+	0xc8, 0x78, 0x5b, 0xff, 0xf1, 0xcf, 0x41, 0x34, 0xf2, 0x87, 0xdd, 0x91, 0x7f, 0x16, 0x17, 0x7a,
+	0x9a, 0xf7, 0x57, 0x98, 0xfd, 0xe0, 0xfc, 0xf4, 0xbe, 0xcc, 0xd6, 0xfc, 0x9e, 0xea, 0x6d, 0xfb,
+	0x35, 0x88, 0xa1, 0xf4, 0x55, 0xb7, 0xa4, 0xfe, 0xef, 0xdb, 0x69, 0xbb, 0x7e, 0x83, 0x26, 0xb8,
+	0xf8, 0x63, 0xba, 0xfe, 0x36, 0x2e, 0xa4, 0xc9, 0x2b, 0x18, 0xd9, 0xbb, 0xad, 0x43, 0xdb, 0xc7,
+	0xbe, 0xed, 0xce, 0x6d, 0xc9, 0x7c, 0x44, 0xfa, 0x25, 0xc0, 0x66, 0x9a, 0x3c, 0x7d, 0xae, 0x3f,
+	0x47, 0xd1, 0x9a, 0x7c, 0xb7, 0x19, 0x8d, 0x75, 0xa8, 0x1a, 0x12, 0x5f, 0xf8, 0xc4, 0xde, 0x98,
+	0xca, 0xfa, 0xd1, 0x97, 0xff, 0x0c, 0x61, 0x6a, 0xab, 0xff, 0x86, 0xf5, 0x5d, 0x99, 0x23, 0xb9,
+	0x80, 0x91, 0xfb, 0x5e, 0x13, 0xe2, 0x0b, 0xc4, 0xbf, 0x08, 0xc9, 0x71, 0x07, 0x0b, 0x77, 0xfe,
+	0x1b, 0x80, 0xd6, 0xca, 0x24, 0x84, 0x74, 0x6e, 0x43, 0xb2, 0x05, 0xd4, 0xe4, 0x02, 0x26, 0x8d,
+	0x4d, 0xc8, 0x73, 0x1f, 0x10, 0xf9, 0x2f, 0x79, 0x00, 0x69, 0xcb, 0xd4, 0x5a, 0xba, 0x61, 0xea,
+	0xdc, 0x8a, 0x64, 0x0b, 0xe8, 0xf2, 0x5a, 0x3b, 0x34, 0x79, 0x1d, 0xcf, 0x25, 0x5b, 0x40, 0x4d,
+	0x2e, 0x61, 0xd2, 0x1c, 0x69, 0xb3, 0xc3, 0xc8, 0x2b, 0xc9, 0x03, 0x48, 0x5f, 0x0c, 0xc8, 0x19,
+	0x8c, 0x83, 0xe6, 0xe4, 0xa8, 0x77, 0x04, 0xb7, 0x49, 0x1f, 0xd1, 0xdf, 0x2f, 0xfe, 0x38, 0x2b,
+	0xa4, 0x2c, 0x2a, 0x3c, 0x2f, 0x64, 0xc5, 0x44, 0x71, 0x2e, 0xeb, 0x62, 0xe1, 0xfe, 0xd2, 0xae,
+	0x56, 0xd7, 0x0b, 0x73, 0xaf, 0x50, 0x2f, 0x96, 0x42, 0xae, 0x85, 0xfb, 0x7f, 0x53, 0x57, 0x57,
+	0xbb, 0xee, 0xe5, 0xd7, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x2e, 0x68, 0x98, 0xd5, 0x09,
+	0x00, 0x00,
 }

grpc/node.proto

@@ -32,7 +32,7 @@ message Node {
     string nodenetwork = 9;
     bool ispending = 10;
     string postup = 11;
-    string preup = 12;
+    string postdown = 12;
     int32 keepalive = 13;
     bool saveconfig = 14;
     string accesskey = 15;
@@ -42,6 +42,7 @@ message Node {
     int32 checkininterval = 19;
     string localaddress = 20;
     string postchanges = 21;
+    string allowedips = 22;
 }
 
 message CheckInResponse {
@@ -55,6 +56,8 @@ message CheckInResponse {
 }
 
 message PeersResponse {
+    bool isgateway = 1;
+    string gatewayrange = 2;
     string publickey = 5;
     string endpoint = 6;
     string address = 3;

models/network.go

@@ -18,7 +18,7 @@ type Network struct {
 	DefaultInterface	string `json:"defaulinterface" bson:"defaultinterface"`
         DefaultListenPort      int32 `json:"defaultlistenport,omitempty" bson:"defaultlistenport,omitempty" validate:"omitempty,numeric,min=1024,max=65535"`
         DefaultPostUp  string `json:"defaultpostup" bson:"defaultpostup"`
-        DefaultPreUp   string `json:"defaultpreup" bson:"defaultpreup"`
+        DefaultPostDown   string `json:"defaultpreup" bson:"defaultpreup"`
         KeyUpdateTimeStamp      int64 `json:"keyupdatetimestamp" bson:"keyupdatetimestamp"`
         DefaultKeepalive int32 `json:"defaultkeepalive" bson:"defaultkeepalive" validate: "omitempty,numeric,max=1000"`
         DefaultSaveConfig      *bool `json:"defaultsaveconfig" bson:"defaultsaveconfig"`
@@ -49,7 +49,7 @@ func(network *Network) SetDefaults(){
     if network.DefaultListenPort == 0 {
         network.DefaultListenPort = 51821
     }
-    if network.DefaultPreUp == "" {
+    if network.DefaultPostDown == "" {
 
     }
     if network.DefaultSaveConfig == nil {

models/node.go

@@ -25,7 +25,7 @@ type Node struct {
 	PublicKey	string `json:"publickey" bson:"publickey" validate:"pubkey_check"`
 	Endpoint	string `json:"endpoint" bson:"endpoint" validate:"endpoint_check"`
 	PostUp	string `json:"postup" bson:"postup"`
-	PreUp	string `json:"preup" bson:"preup"`
+	PostDown	string `json:"postdown" bson:"postdown"`
 	AllowedIPs	string `json:"allowedips" bson:"allowedips"`
 	PersistentKeepalive int32 `json:"persistentkeepalive" bson:"persistentkeepalive" validate: "omitempty,numeric,max=1000"`
 	SaveConfig	*bool `json:"saveconfig" bson:"saveconfig"`
@@ -111,7 +111,7 @@ func(node *Node) SetDefaults() {
     if node.ListenPort == 0 {
         node.ListenPort = parentNetwork.DefaultListenPort
     }
-    if node.PreUp == "" {
+    if node.PostDown == "" {
         //Empty because we dont set it
         //may want to set it to something in the future
     }

models/returnNode.go

@@ -12,7 +12,7 @@ type ReturnNode struct {
 	PublicKey	string `json:"publickey" bson:"publickey" validate:"base64"`
 	Endpoint	string `json:"endpoint" bson:"endpoint" validate:"required,ipv4"`
 	PostUp	string `json:"postup" bson:"postup"`
-	PreUp	string `json:"preup" bson:"preup"`
+	PostDown	string `json:"preup" bson:"preup"`
 	PersistentKeepalive int32 `json:"persistentkeepalive" bson:"persistentkeepalive"`
 	SaveConfig	*bool `json:"saveconfig" bson:"saveconfig"`
 	Interface	string `json:"interface" bson:"interface"`

models/structs.go

@@ -100,9 +100,13 @@ type PeersResponse struct {
 }
 
 type GatewayRequest struct {
+    NodeID string `json:"nodeid" bson:"nodeid"`
+    NetID string `json:"netid" bson:"netid"`
     RangeString string `json:"rangestring" bson:"rangestring"`
     Ranges []string `json:"ranges" bson:"ranges"`
     Interface string `json:"interface" bson:"interface"`
+    PostUp string `json:"postup" bson:"postup"`
+    PostDown string `json:"postdown" bson:"postdown"`
 }
 
 

netclient/config/config.go

@@ -32,8 +32,9 @@ type NodeConfig struct {
         LocalAddress string `yaml:"localaddress"`
         WGAddress string `yaml:"wgaddress"`
         RoamingOff bool `yaml:"roamingoff"`
+        AllowedIPs string `yaml:"allowedips"`
         PostUp string `yaml:"postup"`
-        PreUp string `yaml:"preup"`
+        PostDown string `yaml:"postdown"`
         Port int32 `yaml:"port"`
         KeepAlive int32 `yaml:"keepalive"`
         PublicKey string `yaml:"publickey"`

netclient/functions/common.go

@@ -1070,7 +1070,7 @@ func getNode(network string) nodepb.Node {
 	node.Listenport = nodecfg.Port
 	node.Keepalive = nodecfg.KeepAlive
 	node.Postup = nodecfg.PostUp
-	node.Preup = nodecfg.PreUp
+	node.Postdown = nodecfg.PostDown
 	node.Publickey = nodecfg.PublicKey
 	node.Macaddress = nodecfg.MacAddress
 	node.Endpoint = nodecfg.Endpoint
@@ -1271,6 +1271,23 @@ func getPeers(macaddress string, network string, server string) ([]wgtypes.PeerC
                         return peers, err
                 }
 		var peer wgtypes.PeerConfig
+		var peeraddr = net.IPNet{
+			IP: net.ParseIP(res.Peers.Address),
+                        Mask: net.CIDRMask(32, 32),
+		}
+		var allowedips []net.IPNet
+		allowedips = append(allowedips, peeraddr)
+
+		if res.Peers.Isgateway {
+			_, ipnet, err := net.ParseCIDR(res.Peers.Gatewayrange)
+			if err != nil {
+				fmt.Println("ERROR ENCOUNTERED SETTING GATEWAY")
+				fmt.Println("NOT SETTING GATEWAY")
+				fmt.Println(err)
+			} else {
+				allowedips = append(allowedips, *ipnet)
+			}
+		}
 		if keepalive != 0 {
 		peer = wgtypes.PeerConfig{
 			PublicKey: pubkey,
@@ -1280,11 +1297,8 @@ func getPeers(macaddress string, network string, server string) ([]wgtypes.PeerC
 				Port: int(res.Peers.Listenport),
 			},
 			ReplaceAllowedIPs: true,
-                        AllowedIPs: []net.IPNet{{
-                                IP: net.ParseIP(res.Peers.Address),
-				Mask: net.CIDRMask(32, 32),
-			}},
-		}
+                        AllowedIPs: allowedips,
+			}
 		} else {
                 peer = wgtypes.PeerConfig{
                         PublicKey: pubkey,
@@ -1293,11 +1307,8 @@ func getPeers(macaddress string, network string, server string) ([]wgtypes.PeerC
                                 Port: int(res.Peers.Listenport),
                         },
                         ReplaceAllowedIPs: true,
-                        AllowedIPs: []net.IPNet{{
-                                IP: net.ParseIP(res.Peers.Address),
-                                Mask: net.CIDRMask(32, 32),
-                        }},
-                }
+                        AllowedIPs: allowedips,
+			}
 		}
 		peers = append(peers, peer)