get wg listen interface addr from the interface

nm-proxy/common/common.go

@@ -22,8 +22,11 @@ import (
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
 
+var IsHostNetwork bool
+
 const (
 	NmProxyPort = 51722
+	DefaultCIDR = "127.0.0.1/8"
 )
 
 type Conn struct {

nm-proxy/manager/manager.go

@@ -47,7 +47,7 @@ func StartProxyManager(manageChan chan *ManagerAction) {
 			case UpdatePeer:
 				mI.UpdatePeerProxy()
 			case DeletePeer:
-
+				mI.DeletePeers()
 			}
 
 		}

nm-proxy/nm-proxy.go

@@ -3,7 +3,9 @@ package nmproxy
 import (
 	"log"
 	"net"
+	"os"
 
+	"github.com/gravitl/netmaker/nm-proxy/common"
 	"github.com/gravitl/netmaker/nm-proxy/manager"
 	"github.com/gravitl/netmaker/nm-proxy/server"
 	"github.com/gravitl/netmaker/nm-proxy/stun"
@@ -17,6 +19,7 @@ import (
 */
 func Start(mgmChan chan *manager.ManagerAction) {
 	log.Println("Starting Proxy...")
+	common.IsHostNetwork = (os.Getenv("HOST_NETWORK") == "" || os.Getenv("HOST_NETWORK") == "on")
 	go manager.StartProxyManager(mgmChan)
 	hInfo := stun.GetHostInfo()
 	stun.Host = hInfo

nm-proxy/packet/packet.go

@@ -10,12 +10,10 @@ import (
 
 var udpHeaderLen = 8
 
-func ProcessPacketBeforeSending(buf []byte, srckey string, n, dstPort int) ([]byte, int, error) {
+func ProcessPacketBeforeSending(buf []byte, srckey string, n, dstPort int) ([]byte, int, string, error) {
-	log.Println("@###### DST Port: ", dstPort)
 	portbuf := new(bytes.Buffer)
 	binary.Write(portbuf, binary.BigEndian, uint16(dstPort))
 	hmd5 := md5.Sum([]byte(srckey))
-	log.Printf("---> HASH: %x ", hmd5)
 	if n > len(buf)-18 {
 		buf = append(buf, portbuf.Bytes()[0])
 		buf = append(buf, portbuf.Bytes()[1])
@@ -29,7 +27,7 @@ func ProcessPacketBeforeSending(buf []byte, srckey string, n, dstPort int) ([]by
 	n += 2
 	n += len(hmd5)
 
-	return buf, n, nil
+	return buf, n, fmt.Sprintf("%x", hmd5), nil
 }
 
 func ExtractInfo(buffer []byte, n int) (int, int, string, error) {

nm-proxy/proxy/proxy.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net"
 
+	"github.com/gravitl/netmaker/nm-proxy/common"
 	"github.com/gravitl/netmaker/nm-proxy/wg"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 )
@@ -58,3 +59,46 @@ func GetInterfaceIpv4Addr(interfaceName string) (addr string, err error) {
 	}
 	return ipv4Addr.String(), nil
 }
+
+func GetInterfaceListenAddr(port int) (*net.UDPAddr, error) {
+	locallistenAddr := "127.0.0.1"
+	udpAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", locallistenAddr, port))
+	if err != nil {
+		return udpAddr, err
+	}
+	if !common.IsHostNetwork {
+		addrs, err := getBoardCastAddress()
+		if err != nil {
+			return udpAddr, err
+		}
+		for _, addr := range addrs {
+			if liAddr := addr.(*net.IPNet).IP; liAddr != nil {
+				udpAddr.IP = liAddr
+				break
+			}
+		}
+	}
+
+	return udpAddr, nil
+}
+
+func getBoardCastAddress() ([]net.Addr, error) {
+	localnets, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+	var (
+		ief   net.Interface
+		addrs []net.Addr
+	)
+	for _, ief = range localnets {
+		if ief.Flags&net.FlagBroadcast != 0 && ief.Flags&net.FlagUp != 0 {
+			addrs, err = ief.Addrs()
+			if err == nil {
+				return addrs, nil
+			}
+
+		}
+	}
+	return nil, errors.New("couldn't obtain the broadcast addr")
+}

nm-proxy/proxy/wireguard.go

@@ -58,17 +58,18 @@ func (p *Proxy) ProxyToRemote() {
 			}
 			peers := common.WgIFaceMap[p.Config.WgInterface.Name]
 			if peerI, ok := peers[p.Config.RemoteKey]; ok {
-				log.Println("PROCESSING PKT BEFORE SENDING")
+				var srcPeerHash string
-
+				buf, n, srcPeerHash, err = packet.ProcessPacketBeforeSending(buf, peerI.Config.LocalKey, n, peerI.Config.RemoteWgPort)
-				buf, n, err = packet.ProcessPacketBeforeSending(buf, peerI.Config.LocalKey, n, peerI.Config.RemoteWgPort)
 				if err != nil {
 					log.Println("failed to process pkt before sending: ", err)
 				}
+				log.Printf("PROXING TO REMOTE!!!---> %s >>>>> %s [[ DstPort: %d, SrcPeerHash: %x ]]\n",
+					server.NmProxyServer.Server.LocalAddr().String(), p.RemoteConn.String(), peerI.Config.RemoteWgPort, srcPeerHash)
 			} else {
 				log.Printf("Peer: %s not found in config\n", p.Config.RemoteKey)
+				continue
 			}
 			// test(n, buf)
-			log.Printf("PROXING TO REMOTE!!!---> %s >>>>> %s\n", server.NmProxyServer.Server.LocalAddr().String(), p.RemoteConn.String())
 
 			_, err = server.NmProxyServer.Server.WriteToUDP(buf[:n], p.RemoteConn)
 			if err != nil {
@@ -83,8 +84,8 @@ func (p *Proxy) updateEndpoint() error {
 	if err != nil {
 		return err
 	}
-	log.Println("--------> UDPADDR:  ", udpAddr)
 	// add local proxy connection as a Wireguard peer
+	log.Printf("---> ## Updating Peer:  %+v\n", p.Config)
 	err = p.Config.WgInterface.UpdatePeer(p.Config.RemoteKey, p.Config.AllowedIps, wg.DefaultWgKeepAlive,
 		udpAddr, p.Config.PreSharedKey)
 	if err != nil {
@@ -109,23 +110,24 @@ func (p *Proxy) Start(remoteConn *net.UDPAddr) error {
 	// 	return err
 	// }
 	log.Printf("----> WGIFACE: %+v\n", p.Config.WgInterface)
-	addr, err := GetFreeIp("127.0.0.1/8", p.Config.WgInterface.Port)
+	addr, err := GetFreeIp(common.DefaultCIDR, p.Config.WgInterface.Port)
 	if err != nil {
 		log.Println("Failed to get freeIp: ", err)
 		return err
 	}
-	wgAddr := "127.0.0.1"
+	wgListenAddr, err := GetInterfaceListenAddr(p.Config.WgInterface.Port)
-	if runtime.GOOS == "darwin" {
+	if err != nil {
-		wgAddr = addr
+		log.Println("failed to get wg listen addr: ", err)
+		return err
 	}
-
+	if runtime.GOOS == "darwin" {
+		wgListenAddr.IP = net.ParseIP(addr)
+	}
+	log.Println("--------->#### Wg Listen Addr: ", wgListenAddr.String())
 	p.LocalConn, err = net.DialUDP("udp", &net.UDPAddr{
 		IP:   net.ParseIP(addr),
 		Port: common.NmProxyPort,
-	}, &net.UDPAddr{
+	}, wgListenAddr)
-		IP:   net.ParseIP(wgAddr),
-		Port: p.Config.WgInterface.Port,
-	})
 	if err != nil {
 		log.Printf("failed dialing to local Wireguard port,Err: %v\n", err)
 		return err
@@ -172,7 +174,8 @@ func GetFreeIp(cidrAddr string, dstPort int) (string, error) {
 		})
 		if err != nil {
 			log.Println("----> GetFreeIP ERR: ", err)
-			if strings.Contains(err.Error(), "can't assign requested address") || strings.Contains(err.Error(), "address already in use") {
+			if strings.Contains(err.Error(), "can't assign requested address") ||
+				strings.Contains(err.Error(), "address already in use") || strings.Contains(err.Error(), "cannot assign requested address") {
 				var nErr error
 				newAddrs, nErr = net4.NextIP(newAddrs)
 				if nErr != nil {

nm-proxy/server/server.go

@@ -16,14 +16,13 @@ var (
 
 const (
 	defaultBodySize = 10000
-	defaultPort     = 51722
+	defaultPort     = common.NmProxyPort
 )
 
 type Config struct {
 	Port     int
 	BodySize int
 	Addr     net.Addr
-	LocalWgInterfaces []string
 }
 
 type ProxyServer struct {
@@ -50,13 +49,14 @@ func (p *ProxyServer) Listen() {
 			log.Println("failed to extract info: ", err)
 			continue
 		}
-		log.Printf("--------> RECV PKT [DSTPORT: %d], [SRCKEYHASH: %s], SourceIP: [%s] \n", localWgPort, srcPeerKeyHash, source.IP.String())
+		// log.Printf("--------> RECV PKT [DSTPORT: %d], [SRCKEYHASH: %s], SourceIP: [%s] \n", localWgPort, srcPeerKeyHash, source.IP.String())
 		if peerInfo, ok := common.PeerKeyHashMap[srcPeerKeyHash]; ok {
 			if peers, ok := common.WgIFaceMap[peerInfo.Interface]; ok {
 				if peerI, ok := peers[peerInfo.PeerKey]; ok {
 					// if peerI.Config.LocalWgPort == int(localWgPort) {
-					log.Printf("PROXING TO LOCAL!!!---> %s <<<< %s <<<<<<<< %s\n", peerI.Proxy.LocalConn.RemoteAddr(),
+					log.Printf("PROXING TO LOCAL!!!---> %s <<<< %s <<<<<<<< %s   [[ RECV PKT [DSTPORT: %d], [SRCKEYHASH: %s], SourceIP: [%s] ]]\n",
-						peerI.Proxy.LocalConn.LocalAddr(), fmt.Sprintf("%s:%d", source.IP.String(), source.Port))
+						peerI.Proxy.LocalConn.RemoteAddr(), peerI.Proxy.LocalConn.LocalAddr(),
+						fmt.Sprintf("%s:%d", source.IP.String(), source.Port), localWgPort, srcPeerKeyHash, source.IP.String())
 					_, err = peerI.Proxy.LocalConn.Write(buffer[:n])
 					if err != nil {
 						log.Println("Failed to proxy to Wg local interface: ", err)