Enable IPv6 address discovery (#578)

Agents will use IPv6 when available for ICE negotiation

client/internal/config.go

@@ -33,13 +33,14 @@ func init() {
 // Config Configuration type
 type Config struct {
 	// Wireguard private key of local peer
-	PrivateKey     string
+	PrivateKey           string
-	PreSharedKey   string
+	PreSharedKey         string
-	ManagementURL  *url.URL
+	ManagementURL        *url.URL
-	AdminURL       *url.URL
+	AdminURL             *url.URL
-	WgIface        string
+	WgIface              string
-	WgPort         int
+	WgPort               int
-	IFaceBlackList []string
+	IFaceBlackList       []string
+	DisableIPv6Discovery bool
 	// SSHKey is a private SSH key in a PEM format
 	SSHKey         string
 
@@ -69,11 +70,12 @@ func createNewConfig(managementURL, adminURL, configPath, preSharedKey string) (
 		return nil, err
 	}
 	config := &Config{
-		SSHKey:         string(pem),
+		SSHKey:               string(pem),
-		PrivateKey:     wgKey,
+		PrivateKey:           wgKey,
-		WgIface:        iface.WgInterfaceDefault,
+		WgIface:              iface.WgInterfaceDefault,
-		WgPort:         iface.DefaultWgPort,
+		WgPort:               iface.DefaultWgPort,
-		IFaceBlackList: []string{},
+		IFaceBlackList:       []string{},
+		DisableIPv6Discovery: false,
 	}
 	if managementURL != "" {
 		URL, err := ParseURL("Management URL", managementURL)

client/internal/connect.go

@@ -185,12 +185,13 @@ func RunClient(ctx context.Context, config *Config, statusRecorder *nbStatus.Sta
 func createEngineConfig(key wgtypes.Key, config *Config, peerConfig *mgmProto.PeerConfig) (*EngineConfig, error) {
 
 	engineConf := &EngineConfig{
-		WgIfaceName:    config.WgIface,
+		WgIfaceName:          config.WgIface,
-		WgAddr:         peerConfig.Address,
+		WgAddr:               peerConfig.Address,
-		IFaceBlackList: config.IFaceBlackList,
+		IFaceBlackList:       config.IFaceBlackList,
-		WgPrivateKey:   key,
+		DisableIPv6Discovery: config.DisableIPv6Discovery,
-		WgPort:         config.WgPort,
+		WgPrivateKey:         key,
-		SSHKey:         []byte(config.SSHKey),
+		WgPort:               config.WgPort,
+		SSHKey:               []byte(config.SSHKey),
 		NATExternalIPs:	config.NATExternalIPs,
 	}
 

client/internal/engine.go

@@ -55,7 +55,8 @@ type EngineConfig struct {
 	WgPrivateKey wgtypes.Key
 
 	// IFaceBlackList is a list of network interfaces to ignore when discovering connection candidates (ICE related)
-	IFaceBlackList []string
+	IFaceBlackList       []string
+	DisableIPv6Discovery bool
 
 	PreSharedKey *wgtypes.Key
 
@@ -226,13 +227,18 @@ func (e *Engine) Start() error {
 		return err
 	}
 
-	e.udpMuxConn, err = net.ListenUDP("udp4", &net.UDPAddr{Port: e.config.UDPMuxPort})
+	networkName := "udp"
+	if e.config.DisableIPv6Discovery {
+		networkName = "udp4"
+	}
+
+	e.udpMuxConn, err = net.ListenUDP(networkName, &net.UDPAddr{Port: e.config.UDPMuxPort})
 	if err != nil {
 		log.Errorf("failed listening on UDP port %d: [%s]", e.config.UDPMuxPort, err.Error())
 		return err
 	}
 
-	e.udpMuxConnSrflx, err = net.ListenUDP("udp4", &net.UDPAddr{Port: e.config.UDPMuxSrflxPort})
+	e.udpMuxConnSrflx, err = net.ListenUDP(networkName, &net.UDPAddr{Port: e.config.UDPMuxSrflxPort})
 	if err != nil {
 		log.Errorf("failed listening on UDP port %d: [%s]", e.config.UDPMuxSrflxPort, err.Error())
 		return err
@@ -819,15 +825,16 @@ func (e Engine) createPeerConn(pubKey string, allowedIPs string) (*peer.Conn, er
 	// randomize connection timeout
 	timeout := time.Duration(rand.Intn(PeerConnectionTimeoutMax-PeerConnectionTimeoutMin)+PeerConnectionTimeoutMin) * time.Millisecond
 	config := peer.ConnConfig{
-		Key:                pubKey,
+		Key:                  pubKey,
-		LocalKey:           e.config.WgPrivateKey.PublicKey().String(),
+		LocalKey:             e.config.WgPrivateKey.PublicKey().String(),
-		StunTurn:           stunTurn,
+		StunTurn:             stunTurn,
-		InterfaceBlackList: e.config.IFaceBlackList,
+		InterfaceBlackList:   e.config.IFaceBlackList,
-		Timeout:            timeout,
+		DisableIPv6Discovery: e.config.DisableIPv6Discovery,
-		UDPMux:             e.udpMux,
+		Timeout:              timeout,
-		UDPMuxSrflx:        e.udpMuxSrflx,
+		UDPMux:               e.udpMux,
-		ProxyConfig:        proxyConfig,
+		UDPMuxSrflx:          e.udpMuxSrflx,
-		LocalWgPort:        e.config.WgPort,
+		ProxyConfig:          proxyConfig,
+		LocalWgPort:          e.config.WgPort,
 		NATExternalIPs:		e.parseNATExternalIPMappings(),
 	}
 

client/internal/peer/conn.go

@@ -29,7 +29,8 @@ type ConnConfig struct {
 
 	// InterfaceBlackList is a list of machine interfaces that should be filtered out by ICE Candidate gathering
 	// (e.g. if eth0 is in the list, host candidate of this interface won't be used)
-	InterfaceBlackList []string
+	InterfaceBlackList   []string
+	DisableIPv6Discovery bool
 
 	Timeout time.Duration
 
@@ -145,9 +146,9 @@ func (conn *Conn) reCreateAgent() error {
 
 	failedTimeout := 6 * time.Second
 	var err error
-	conn.agent, err = ice.NewAgent(&ice.AgentConfig{
+	agentConfig := &ice.AgentConfig{
 		MulticastDNSMode: ice.MulticastDNSModeDisabled,
-		NetworkTypes:     []ice.NetworkType{ice.NetworkTypeUDP4},
+		NetworkTypes:     []ice.NetworkType{ice.NetworkTypeUDP4, ice.NetworkTypeUDP6},
 		Urls:             conn.config.StunTurn,
 		CandidateTypes:   []ice.CandidateType{ice.CandidateTypeHost, ice.CandidateTypeServerReflexive, ice.CandidateTypeRelay},
 		FailedTimeout:    &failedTimeout,
@@ -155,7 +156,14 @@ func (conn *Conn) reCreateAgent() error {
 		UDPMux:           conn.config.UDPMux,
 		UDPMuxSrflx:      conn.config.UDPMuxSrflx,
 		NAT1To1IPs:       conn.config.NATExternalIPs,
-	})
+	}
+
+	if conn.config.DisableIPv6Discovery {
+		agentConfig.NetworkTypes = []ice.NetworkType{ice.NetworkTypeUDP4}
+	}
+
+	conn.agent, err = ice.NewAgent(agentConfig)
+
 	if err != nil {
 		return err
 	}