fix relay updatesa

auth/host_session.go

@@ -237,7 +237,7 @@ func CheckNetRegAndHostUpdate(networks []string, h *models.Host) {
 				Host:   *h,
 				Node:   *newNode,
 			})
-			mq.BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *h, Node: *newNode}, false)
+			mq.BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *h, Node: *newNode}, false)
 		}
 	}
 	mq.HostUpdate(&models.HostUpdate{

controllers/ext_client.go

@@ -502,7 +502,7 @@ func updateExtClient(w http.ResponseWriter, r *http.Request) {
 		if ingressNode, err := logic.GetNodeByID(newclient.IngressGatewayID); err == nil {
 			if ingressHost, err := logic.GetHost(ingressNode.HostID.String()); err == nil {
 				if replaceOldClient || !update.Enabled {
-					mq.BroadcastDelExtClient(&models.Client{Host: *ingressHost, Node: ingressNode}, []models.ExtClient{currentClient})
+					mq.BroadcastDelExtClient(models.Client{Host: *ingressHost, Node: ingressNode}, []models.ExtClient{currentClient})
 				}
 				if replaceOldClient || changedEnabled {
 					// broadcast update
@@ -588,7 +588,7 @@ func deleteExtClient(w http.ResponseWriter, r *http.Request) {
 	go func() {
 		ingressHost, err := logic.GetHost(ingressnode.HostID.String())
 		if err == nil {
-			mq.BroadcastDelExtClient(&models.Client{Host: *ingressHost, Node: ingressnode}, []models.ExtClient{extclient})
+			mq.BroadcastDelExtClient(models.Client{Host: *ingressHost, Node: ingressnode}, []models.ExtClient{extclient})
 			f, err := logic.GetFwUpdate(ingressHost)
 			if err == nil {
 				mq.PublishFwUpdate(ingressHost, &f)

controllers/hosts.go

@@ -291,7 +291,7 @@ func addHostToNetwork(w http.ResponseWriter, r *http.Request) {
 		Action: models.RequestAck,
 		Host:   *currHost,
 	})
-	go mq.BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *currHost, Node: *newNode}, false)
+	go mq.BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *currHost, Node: *newNode}, false)
 
 	logger.Log(2, r.Header.Get("user"), fmt.Sprintf("added host %s to network %s", currHost.Name, network))
 	w.WriteHeader(http.StatusOK)

controllers/node.go

@@ -465,7 +465,7 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
 			logger.Log(0, "failed to get egress host: ", err.Error())
 			return
 		}
-		mq.BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *host, Node: node}, true)
+		mq.BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *host, Node: node}, true)
 		f, err := logic.GetFwUpdate(host)
 		if err != nil {
 			logger.Log(0, "failed to get egreess host: ", err.Error())
@@ -514,7 +514,7 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
 			logger.Log(0, "failed to get egress host: ", err.Error())
 			return
 		}
-		mq.BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *host, Node: node}, true)
+		mq.BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *host, Node: node}, true)
 		f, err := logic.GetFwUpdate(host)
 		if err != nil {
 			logger.Log(0, "failed to get egreess host: ", err.Error())
@@ -609,7 +609,7 @@ func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
 	if len(removedClients) > 0 {
 		host, err := logic.GetHost(node.HostID.String())
 		if err == nil {
-			mq.BroadcastDelExtClient(&models.Client{Host: *host, Node: node}, removedClients)
+			mq.BroadcastDelExtClient(models.Client{Host: *host, Node: node}, removedClients)
 			f, err := logic.GetFwUpdate(host)
 			if err == nil {
 				mq.PublishFwUpdate(host, &f)
@@ -708,7 +708,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 	runUpdates(newNode, ifaceDelta)
 	go func(aclUpdate, relayupdate bool, newNode *models.Node) {
 		if aclUpdate || relayupdate {
-			mq.BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *host, Node: *newNode}, true)
+			mq.BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *host, Node: *newNode}, true)
 		}
 		if err := mq.PublishReplaceDNS(&currentNode, newNode, host); err != nil {
 			logger.Log(1, "failed to publish dns update", err.Error())

logic/peers.go

@@ -63,24 +63,8 @@ func NodePeersInfo(client *models.Client) (models.NodePeersInfo, error) {
 			peerConfig.Endpoint.IP = peer.LocalAddress.IP
 			peerConfig.Endpoint.Port = peerHost.ListenPort
 		}
-		allowedips := GetNetworkAllowedIPs(&models.Client{Host: *peerHost, Node: peer})
-		if peer.IsIngressGateway {
-			for _, entry := range peer.IngressGatewayRange {
-				_, cidr, err := net.ParseCIDR(string(entry))
-				if err == nil {
-					allowedips = append(allowedips, *cidr)
-				}
-			}
-		}
-		if peer.IsEgressGateway {
+		allowedips := GetNetworkAllowedIPs(*client, models.Client{Host: *peerHost, Node: peer})
 
-			allowedips = append(allowedips, getEgressIPs(
-				&models.Client{
-					Host: *peerHost,
-					Node: peer,
-				})...)
-
-		}
 		peerConfig.AllowedIPs = allowedips
 		nodePeersInfo.Peers = append(nodePeersInfo.Peers, peerConfig)
 		nodePeersInfo.PeerIDs[peerHost.PublicKey.String()] = models.IDandAddr{
@@ -158,7 +142,7 @@ func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
 				PersistentKeepaliveInterval: &peer.PersistentKeepalive,
 				ReplaceAllowedIPs:           true,
 			}
-			if (node.IsRelayed && node.RelayedBy != peer.ID.String()) || ShouldRemovePeer(node, peer) {
+			if (node.IsRelayed && node.RelayedBy != peer.ID.String()) || (peer.IsRelayed && peer.RelayedBy != node.ID.String()) || ShouldRemovePeer(node, peer) {
 				// if node is relayed and peer is not the relay, set remove to true
 				peerConfig.Remove = true
 				hostPeerUpdate.Peers = append(hostPeerUpdate.Peers, peerConfig)
@@ -187,7 +171,7 @@ func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
 				peerConfig.Endpoint.IP = peer.LocalAddress.IP
 				peerConfig.Endpoint.Port = peerHost.ListenPort
 			}
-			peerConfig.AllowedIPs = GetNetworkAllowedIPs(&models.Client{Host: *peerHost, Node: peer})
+			peerConfig.AllowedIPs = GetNetworkAllowedIPs(models.Client{Host: *host, Node: node}, models.Client{Host: *peerHost, Node: peer})
 
 			if _, ok := peerIndexMap[peerHost.PublicKey.String()]; !ok {
 				hostPeerUpdate.Peers = append(hostPeerUpdate.Peers, peerConfig)
@@ -219,8 +203,7 @@ func GetPeerUpdateForHost(host *models.Host) (models.HostPeerUpdate, error) {
 
 func ShouldRemovePeer(node, peer models.Node) (remove bool) {
 	if peer.Action == models.NODE_DELETE || peer.PendingDelete || !peer.Connected ||
-		!nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID.String()), nodeacls.NodeID(peer.ID.String())) ||
-		(node.IsRelayed && node.RelayedBy != peer.ID.String()) {
+		!nodeacls.AreNodesAllowed(nodeacls.NetworkID(node.Network), nodeacls.NodeID(node.ID.String()), nodeacls.NodeID(peer.ID.String())) {
 		remove = true
 	}
 	return
@@ -449,7 +432,7 @@ func getNodeByNetworkFromHost(h *models.Host, network string) *models.Node {
 }
 
 // GetAllowedIPs - calculates the wireguard allowedip field for a peer of a node based on the peer and node settings
-func GetAllowedIPs(client, peer *models.Client) []net.IPNet {
+func GetAllowedIPs(client, peer models.Client) []net.IPNet {
 	var allowedips []net.IPNet
 	for _, nodeID := range peer.Host.Nodes {
 		node, err := GetNodeByID(nodeID)
@@ -484,7 +467,7 @@ func GetAllowedIPs(client, peer *models.Client) []net.IPNet {
 			allowedips = append(allowedips, getEgressIPs(peer)...)
 		}
 		if peer.Node.IsRelay {
-			allowedips = append(allowedips, getRelayAllowedIPs(peer)...)
+			allowedips = append(allowedips, getRelayAllowedIPs(client, peer)...)
 		}
 		// handle ingress gateway peers
 		if peer.Node.IsIngressGateway {
@@ -496,7 +479,7 @@ func GetAllowedIPs(client, peer *models.Client) []net.IPNet {
 }
 
 // GetNetworkAllowedIPs - calculates the wireguard allowedip field for a peer of a node based on the peer and node settings
-func GetNetworkAllowedIPs(peer *models.Client) []net.IPNet {
+func GetNetworkAllowedIPs(client, peer models.Client) []net.IPNet {
 	var allowedips []net.IPNet
 	if peer.Node.Address.IP != nil {
 		allowed := net.IPNet{
@@ -514,16 +497,12 @@ func GetNetworkAllowedIPs(peer *models.Client) []net.IPNet {
 	}
 	// handle egress gateway peers
 	if peer.Node.IsEgressGateway {
-		egressIPs := getEgressIPs(
-			&models.Client{
-				Host: peer.Host,
-				Node: peer.Node,
-			})
+		egressIPs := getEgressIPs(peer)
 		allowedips = append(allowedips, egressIPs...)
 
 	}
 	if peer.Node.IsRelay {
-		allowedips = append(allowedips, getRelayAllowedIPs(&models.Client{Node: peer.Node, Host: peer.Host})...)
+		allowedips = append(allowedips, getRelayAllowedIPs(client, peer)...)
 	}
 	// handle ingress gateway peers
 	if peer.Node.IsIngressGateway {
@@ -533,7 +512,7 @@ func GetNetworkAllowedIPs(peer *models.Client) []net.IPNet {
 }
 
 // getEgressIPs - gets the egress IPs for a client
-func getEgressIPs(client *models.Client) []net.IPNet {
+func getEgressIPs(client models.Client) []net.IPNet {
 
 	//check for internet gateway
 	internetGateway := false
@@ -606,22 +585,22 @@ func filterNodeMapForClientACLs(publicKey, network string, nodePeerMap map[strin
 }
 
 // getRelayAllowedIPs returns the list of allowedips for a peer that is a relay
-func getRelayAllowedIPs(peer *models.Client) []net.IPNet {
+func getRelayAllowedIPs(client, relayPeer models.Client) []net.IPNet {
 	var relayIPs []net.IPNet
-	if !peer.Node.IsRelay {
-		logger.Log(0, "getRelayAllowedIPs called for a non-relay node", peer.Host.Name)
+	if !relayPeer.Node.IsRelay {
+		logger.Log(0, "getRelayAllowedIPs called for a non-relay node", relayPeer.Host.Name)
 		return relayIPs
 	}
-	//if !client.Node.IsRelayed || client.Node.RelayedBy != peer.Node.ID.String() {
-	//logger.Log(0, "getRelayAllowedIPs called for non-relayed node", client.Host.Name, peer.Host.Name)
-	//return relayIPs
-	//}
-	for _, relayed := range peer.Node.RelayedNodes {
+	for _, relayed := range relayPeer.Node.RelayedNodes {
 		relayedNode, err := GetNodeByID(relayed)
 		if err != nil {
 			logger.Log(0, "retrieve relayed node", err.Error())
 			continue
 		}
+		if relayedNode.ID == client.Node.ID {
+			relayIPs = append(relayIPs, getAllowedIpsForRelayed(client, relayPeer)...)
+			continue
+		}
 		if relayedNode.Address.IP != nil {
 			relayedNode.Address.Mask = net.CIDRMask(32, 32)
 			relayIPs = append(relayIPs, relayedNode.Address)
@@ -630,38 +609,47 @@ func getRelayAllowedIPs(peer *models.Client) []net.IPNet {
 			relayedNode.Address.Mask = net.CIDRMask(128, 128)
 			relayIPs = append(relayIPs, relayedNode.Address6)
 		}
-		host, err := GetHost(relayedNode.HostID.String())
-		if err == nil {
-			if relayedNode.IsRelay {
-				relayIPs = append(relayIPs, getRelayAllowedIPs(
-					&models.Client{
-						Host: *host,
-						Node: relayedNode,
-					})...)
-			}
-			if relayedNode.IsEgressGateway {
-				relayIPs = append(relayIPs, getEgressIPs(
-					&models.Client{
-						Host: *host,
-						Node: relayedNode,
-					})...)
-			}
-			if relayedNode.IsIngressGateway {
-				relayIPs = append(relayIPs, getIngressIPs(
-					&models.Client{
-						Host: *host,
-						Node: relayedNode,
-					})...)
+		if relayedNode.IsEgressGateway {
+			relayedHost, err := GetHost(relayedNode.HostID.String())
+			if err == nil {
+				relayIPs = append(relayIPs, getEgressIPs(models.Client{
+					Host: *relayedHost,
+					Node: relayedNode,
+				})...)
 			}
+
 		}
+
 	}
 	return relayIPs
 }
 
+// getAllowedIpsForRelayed - returns the peerConfig for a node relayed by relay
+func getAllowedIpsForRelayed(relayed, relay models.Client) (allowedIPs []net.IPNet) {
+	if relayed.Node.RelayedBy != relay.Node.ID.String() {
+		logger.Log(0, "RelayedByRelay called with invalid parameters")
+		return
+	}
+	peers, err := GetNetworkClients(relay.Node.Network)
+	if err != nil {
+		logger.Log(0, "error getting network clients", err.Error())
+		return
+	}
+	for _, peer := range peers {
+		if peer.Node.ID == relayed.Node.ID || peer.Node.ID == relay.Node.ID {
+			continue
+		}
+		if nodeacls.AreNodesAllowed(nodeacls.NetworkID(relayed.Node.Network), nodeacls.NodeID(relayed.Node.ID.String()), nodeacls.NodeID(peer.Node.ID.String())) {
+			allowedIPs = append(allowedIPs, GetAllowedIPs(relayed, peer)...)
+		}
+	}
+	return
+}
+
 // getIngressIPs returns the additional allowedips (ext client addresses) that need
 // to be included for an ingress gateway peer
 // TODO:  add ExtraAllowedIPs
-func getIngressIPs(peer *models.Client) []net.IPNet {
+func getIngressIPs(peer models.Client) []net.IPNet {
 	var ingressIPs []net.IPNet
 	extclients, err := GetNetworkExtClients(peer.Node.Network)
 	if err != nil {

logic/relay.go

@@ -163,7 +163,7 @@ func DeleteRelay(network, nodeid string) ([]models.Client, models.Node, error) {
 }
 
 // GetPeerConfForRelayed - returns the peerConfig for a node relayed by relay
-func GetPeerConfForRelayed(relayed, relay *models.Client) wgtypes.PeerConfig {
+func GetPeerConfForRelayed(relayed, relay models.Client) wgtypes.PeerConfig {
 	if relayed.Node.RelayedBy != relay.Node.ID.String() {
 		logger.Log(0, "peerUpdateForRelayedByRelay called with invalid parameters")
 		return wgtypes.PeerConfig{}
@@ -175,19 +175,22 @@ func GetPeerConfForRelayed(relayed, relay *models.Client) wgtypes.PeerConfig {
 			IP:   relay.Host.EndpointIP,
 			Port: relay.Host.ListenPort,
 		},
+		AllowedIPs:                  getAllowedIpsForRelayed(relayed, relay),
 		PersistentKeepaliveInterval: &relay.Node.PersistentKeepalive,
 	}
-
-	peers, err := GetNetworkClients(relay.Node.Network)
-	if err != nil {
-		logger.Log(0, "error getting network clients", err.Error())
-		return update
+	if relay.Node.Address.IP != nil {
+		allowed := net.IPNet{
+			IP:   relay.Node.Address.IP,
+			Mask: net.CIDRMask(32, 32),
+		}
+		update.AllowedIPs = append(update.AllowedIPs, allowed)
 	}
-	for _, peer := range peers {
-		if peer.Host.ID == relayed.Host.ID {
-			continue
+	if relay.Node.Address6.IP != nil {
+		allowed := net.IPNet{
+			IP:   relay.Node.Address6.IP,
+			Mask: net.CIDRMask(128, 128),
 		}
-		update.AllowedIPs = append(update.AllowedIPs, GetAllowedIPs(relayed, &peer)...)
+		update.AllowedIPs = append(update.AllowedIPs, allowed)
 	}
 	return update
 }

mq/handlers.go

@@ -63,11 +63,11 @@ func UpdateNode(client mqtt.Client, msg mqtt.Message) {
 		if err != nil {
 			return
 		}
-		if err = BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *h, Node: newNode}, true); err != nil {
+		if err = BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *h, Node: newNode}, true); err != nil {
 			logger.Log(0, "error updating peers when node", currentNode.ID.String(), "informed the server of an interface change", err.Error())
 		}
 		if clients, err := logic.GetNetworkClients(newNode.Network); err == nil {
-			FlushNetworkPeersToHost(&models.Client{Host: *h, Node: newNode}, clients)
+			FlushNetworkPeersToHost(models.Client{Host: *h, Node: newNode}, clients)
 		}
 
 	}
@@ -121,7 +121,7 @@ func UpdateHost(client mqtt.Client, msg mqtt.Message) {
 				if err != nil {
 					return
 				}
-				err = FlushNetworkPeersToHost(&models.Client{Host: hu.Host, Node: hu.Node}, clients)
+				err = FlushNetworkPeersToHost(models.Client{Host: hu.Host, Node: hu.Node}, clients)
 				if err != nil {
 					logger.Log(0, "failed to flush peers to host: ", err.Error())
 				}

mq/publishers.go

@@ -32,7 +32,7 @@ func PublishSingleHostPeerUpdate(host *models.Host) error {
 }
 
 // FlushNetworkPeersToHost - sends all the peers in the network to the host.
-func FlushNetworkPeersToHost(client *models.Client, networkClients []models.Client) error {
+func FlushNetworkPeersToHost(client models.Client, networkClients []models.Client) error {
 	logger.Log(0, "flushing network peers to host: ", client.Host.ID.String(), client.Node.Network)
 	addPeerAction := models.PeerAction{
 		Action: models.AddPeer,
@@ -48,7 +48,7 @@ func FlushNetworkPeersToHost(client *models.Client, networkClients []models.Clie
 			// skip self
 			continue
 		}
-		allowedIPs := logic.GetAllowedIPs(client, &clientI)
+		allowedIPs := logic.GetAllowedIPs(client, clientI)
 		peerCfg := wgtypes.PeerConfig{
 			PublicKey: clientI.Host.PublicKey,
 			Endpoint: &net.UDPAddr{
@@ -71,24 +71,6 @@ func FlushNetworkPeersToHost(client *models.Client, networkClients []models.Clie
 
 		addPeerAction.Peers = append(addPeerAction.Peers, peerCfg)
 	}
-	if client.Node.IsRelayed {
-		// update the relay peer on this node
-		relayNode, err := logic.GetNodeByID(client.Node.RelayedBy)
-		if err != nil {
-			return err
-		}
-		relayHost, err := logic.GetHost(relayNode.HostID.String())
-		if err != nil {
-			return err
-		}
-		relayedClient := client
-		relayClient := &models.Client{
-			Host: *relayHost,
-			Node: relayNode,
-		}
-		relayPeerCfg := logic.GetPeerConfForRelayed(relayedClient, relayClient)
-		addPeerAction.Peers = append(addPeerAction.Peers, relayPeerCfg)
-	}
 	if len(rmPeerAction.Peers) > 0 {
 		data, err := json.Marshal(rmPeerAction)
 		if err != nil {
@@ -141,7 +123,7 @@ func BroadcastDelPeer(host *models.Host, networkClients []models.Client) error {
 			// skip self...
 			continue
 		}
-		allowedIPs := logic.GetAllowedIPs(&clientI, &models.Client{Host: *host})
+		allowedIPs := logic.GetAllowedIPs(clientI, models.Client{Host: *host})
 		if len(allowedIPs) != 0 {
 			p.Peers[0].Remove = false
 			p.Peers[0].AllowedIPs = allowedIPs
@@ -169,7 +151,7 @@ func BroadcastAclUpdate(network string) error {
 	}
 	for _, client := range clients {
 		client := client
-		go FlushNetworkPeersToHost(&client, clients)
+		go FlushNetworkPeersToHost(client, clients)
 	}
 	return err
 }
@@ -207,7 +189,7 @@ func BroadcastHostUpdate(host *models.Host, remove bool) error {
 }
 
 // BroadcastAddOrUpdateNetworkPeer - notifys the hosts in the network to add or update peer.
-func BroadcastAddOrUpdateNetworkPeer(client *models.Client, update bool) error {
+func BroadcastAddOrUpdateNetworkPeer(client models.Client, update bool) error {
 	clients, err := logic.GetNetworkClients(client.Node.Network)
 	if err != nil {
 		return err
@@ -237,7 +219,7 @@ func BroadcastAddOrUpdateNetworkPeer(client *models.Client, update bool) error {
 			continue
 		}
 		// update allowed ips, according to the peer node
-		p.Peers[0].AllowedIPs = logic.GetAllowedIPs(&clientI, &models.Client{Host: client.Host, Node: client.Node})
+		p.Peers[0].AllowedIPs = logic.GetAllowedIPs(clientI, models.Client{Host: client.Host, Node: client.Node})
 		if update && len(p.Peers[0].AllowedIPs) == 0 {
 			// remove peer
 			p.Action = models.RemovePeer
@@ -261,11 +243,11 @@ func BroadcastAddOrUpdateNetworkPeer(client *models.Client, update bool) error {
 			if err != nil {
 				continue
 			}
-			relayedClient := &models.Client{
+			relayedClient := models.Client{
 				Host: *peerHost,
 				Node: clientI.Node,
 			}
-			relayClient := &models.Client{
+			relayClient := models.Client{
 				Host: *relayHost,
 				Node: relayNode,
 			}
@@ -308,14 +290,14 @@ func BroadcastExtClient(ingressHost *models.Host, ingressNode *models.Node) erro
 		return err
 	}
 	//flush peers to ingress host
-	go FlushNetworkPeersToHost(&models.Client{Host: *ingressHost, Node: *ingressNode}, clients)
+	go FlushNetworkPeersToHost(models.Client{Host: *ingressHost, Node: *ingressNode}, clients)
 	// broadcast to update ingress peer to other hosts
-	go BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *ingressHost, Node: *ingressNode}, true)
+	go BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *ingressHost, Node: *ingressNode}, true)
 	return nil
 }
 
 // BroadcastDelExtClient - published msg to remove ext client from network
-func BroadcastDelExtClient(ingressClient *models.Client, extclients []models.ExtClient) error {
+func BroadcastDelExtClient(ingressClient models.Client, extclients []models.ExtClient) error {
 	go BroadcastAddOrUpdateNetworkPeer(ingressClient, true)
 	peers := []wgtypes.PeerConfig{}
 	for _, extclient := range extclients {

mq/relay.go

@@ -29,7 +29,7 @@ func BroadCastRelayUpdate(relayReq models.RelayRequest) error {
 			continue
 		}
 		BroadcastDelPeer(h, filteredClients)
-		FlushNetworkPeersToHost(&models.Client{Host: *h, Node: relayedNode}, clients)
+		FlushNetworkPeersToHost(models.Client{Host: *h, Node: relayedNode}, clients)
 	}
 	relayNode, err := logic.GetNodeByID(relayReq.NodeID)
 	if err != nil {
@@ -40,7 +40,7 @@ func BroadCastRelayUpdate(relayReq models.RelayRequest) error {
 		return err
 	}
 
-	return BroadcastAddOrUpdateNetworkPeer(&models.Client{Host: *relayHost, Node: relayNode}, true)
+	return BroadcastAddOrUpdateNetworkPeer(models.Client{Host: *relayHost, Node: relayNode}, true)
 }
 
 func BroadCastRelayRemoval(network string) error {
@@ -50,7 +50,7 @@ func BroadCastRelayRemoval(network string) error {
 	}
 	for _, client := range clients {
 		client := client
-		go FlushNetworkPeersToHost(&client, clients)
+		go FlushNetworkPeersToHost(client, clients)
 	}
 	return err
 }