Try to convert TUN/TAP to use new yggdrasil.Conn, search masks are still broken

src/yggdrasil/adapter.go

@@ -1,47 +0,0 @@
-package yggdrasil
-
-import (
-	"github.com/gologme/log"
-	"github.com/yggdrasil-network/yggdrasil-go/src/address"
-	"github.com/yggdrasil-network/yggdrasil-go/src/config"
-)
-
-// Adapter defines the minimum required struct members for an adapter type. This
-// is now the base type for adapters like tun.go. When implementing a new
-// adapter type, you should extend the adapter struct with this one and should
-// call the Adapter.Init() function when initialising.
-type Adapter struct {
-	adapterImplementation
-	Core        *Core
-	Config      *config.NodeState
-	Log         *log.Logger
-	Send        chan<- []byte
-	Recv        <-chan []byte
-	Reject      <-chan RejectedPacket
-	Reconfigure chan chan error
-}
-
-// Defines the minimum required functions for an adapter type. Note that the
-// implementation of Init() should call Adapter.Init(). This is not exported
-// because doing so breaks the gomobile bindings for iOS/Android.
-type adapterImplementation interface {
-	Init(*config.NodeState, *log.Logger, chan<- []byte, <-chan []byte, <-chan RejectedPacket)
-	Name() string
-	MTU() int
-	IsTAP() bool
-	Start(address.Address, address.Subnet) error
-	Close() error
-}
-
-// Init initialises the adapter with the necessary channels to operate from the
-// router. When defining a new Adapter type, the Adapter should call this
-// function from within it's own Init function to set up the channels. It is
-// otherwise not expected for you to call this function directly.
-func (adapter *Adapter) Init(config *config.NodeState, log *log.Logger, send chan<- []byte, recv <-chan []byte, reject <-chan RejectedPacket) {
-	adapter.Config = config
-	adapter.Log = log
-	adapter.Send = send
-	adapter.Recv = recv
-	adapter.Reject = reject
-	adapter.Reconfigure = make(chan chan error, 1)
-}

src/yggdrasil/conn.go

@@ -16,7 +16,7 @@ type Conn struct {
 	nodeID        *crypto.NodeID
 	nodeMask      *crypto.NodeID
 	session       *sessionInfo
-	sessionMutex  *sync.RWMutex
+	mutex         *sync.RWMutex
 	readDeadline  time.Time
 	writeDeadline time.Time
 	expired       bool
@@ -30,9 +30,10 @@ func (c *Conn) startSearch() {
 			return
 		}
 		if sinfo != nil {
-			c.sessionMutex.Lock()
+			c.mutex.Lock()
 			c.session = sinfo
-			c.sessionMutex.Unlock()
+			c.nodeID, c.nodeMask = sinfo.theirAddr.GetNodeIDandMask()
+			c.mutex.Unlock()
 		}
 	}
 	doSearch := func() {
@@ -65,8 +66,8 @@ func (c *Conn) startSearch() {
 }
 
 func (c *Conn) Read(b []byte) (int, error) {
-	c.sessionMutex.RLock()
-	defer c.sessionMutex.RUnlock()
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
 	if c.expired {
 		return 0, errors.New("session is closed")
 	}
@@ -119,8 +120,8 @@ func (c *Conn) Read(b []byte) (int, error) {
 }
 
 func (c *Conn) Write(b []byte) (bytesWritten int, err error) {
-	c.sessionMutex.RLock()
-	defer c.sessionMutex.RUnlock()
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
 	if c.expired {
 		return 0, errors.New("session is closed")
 	}
@@ -175,7 +176,9 @@ func (c *Conn) LocalAddr() crypto.NodeID {
 }
 
 func (c *Conn) RemoteAddr() crypto.NodeID {
-	return *crypto.GetNodeID(&c.session.theirPermPub)
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	return *c.nodeID
 }
 
 func (c *Conn) SetDeadline(t time.Time) error {

src/yggdrasil/core.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"io/ioutil"
 	"net"
-	"sync"
 	"time"
 
 	"github.com/gologme/log"
@@ -77,7 +76,6 @@ func (c *Core) init() error {
 	c.searches.init(c)
 	c.dht.init(c)
 	c.sessions.init(c)
-	//c.multicast.init(c)
 	c.peers.init(c)
 	c.router.init(c)
 	c.switchTable.init(c) // TODO move before peers? before router?
@@ -168,21 +166,6 @@ func BuildVersion() string {
 	return buildVersion
 }
 
-// SetRouterAdapter instructs Yggdrasil to use the given adapter when starting
-// the router. The adapter must implement the standard
-// adapter.adapterImplementation interface and should extend the adapter.Adapter
-// struct.
-func (c *Core) SetRouterAdapter(adapter interface{}) error {
-	// We do this because adapterImplementation is not a valid type for the
-	// gomobile bindings so we just ask for a generic interface and try to cast it
-	// to adapterImplementation instead
-	if a, ok := adapter.(adapterImplementation); ok {
-		c.router.adapter = a
-		return nil
-	}
-	return errors.New("unsuitable adapter")
-}
-
 // Start starts up Yggdrasil using the provided config.NodeConfig, and outputs
 // debug logging through the provided log.Logger. The started stack will include
 // TCP and UDP sockets, a multicast discovery socket, an admin socket, router,
@@ -233,13 +216,6 @@ func (c *Core) Start(nc *config.NodeConfig, log *log.Logger) (*config.NodeState,
 		return nil, err
 	}
 
-	if c.router.adapter != nil {
-		if err := c.router.adapter.Start(c.router.addr, c.router.subnet); err != nil {
-			c.log.Errorln("Failed to start TUN/TAP")
-			return nil, err
-		}
-	}
-
 	go c.addPeerLoop()
 
 	c.log.Infoln("Startup complete")
@@ -249,14 +225,11 @@ func (c *Core) Start(nc *config.NodeConfig, log *log.Logger) (*config.NodeState,
 // Stop shuts down the Yggdrasil node.
 func (c *Core) Stop() {
 	c.log.Infoln("Stopping...")
-	if c.router.adapter != nil {
-		c.router.adapter.Close()
-	}
 	c.admin.close()
 }
 
 // ListenConn returns a listener for Yggdrasil session connections.
-func (c *Core) ListenConn() (*Listener, error) {
+func (c *Core) ConnListen() (*Listener, error) {
 	c.sessions.listenerMutex.Lock()
 	defer c.sessions.listenerMutex.Unlock()
 	if c.sessions.listener != nil {
@@ -270,40 +243,11 @@ func (c *Core) ListenConn() (*Listener, error) {
 	return c.sessions.listener, nil
 }
 
-// Dial opens a session to the given node. The first paramter should be "nodeid"
-// and the second parameter should contain a hexadecimal representation of the
-// target node ID.
-func (c *Core) Dial(network, address string) (Conn, error) {
-	conn := Conn{
-		sessionMutex: &sync.RWMutex{},
-	}
-	nodeID := crypto.NodeID{}
-	nodeMask := crypto.NodeID{}
-	// Process
-	switch network {
-	case "nodeid":
-		// A node ID was provided - we don't need to do anything special with it
-		dest, err := hex.DecodeString(address)
-		if err != nil {
-			return Conn{}, err
-		}
-		copy(nodeID[:], dest)
-		for i := range nodeMask {
-			nodeMask[i] = 0xFF
-		}
-	default:
-		// An unexpected address type was given, so give up
-		return Conn{}, errors.New("unexpected address type")
-	}
-	conn.core = c
-	conn.nodeID = &nodeID
-	conn.nodeMask = &nodeMask
-	conn.core.router.doAdmin(func() {
-		conn.startSearch()
-	})
-	conn.sessionMutex.Lock()
-	defer conn.sessionMutex.Unlock()
-	return conn, nil
+// ConnDialer returns a dialer for Yggdrasil session connections.
+func (c *Core) ConnDialer() (*Dialer, error) {
+	return &Dialer{
+		core: c,
+	}, nil
 }
 
 // ListenTCP starts a new TCP listener. The input URI should match that of the

src/yggdrasil/dialer.go

@@ -0,0 +1,70 @@
+package yggdrasil
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
+)
+
+// Dialer represents an Yggdrasil connection dialer.
+type Dialer struct {
+	core *Core
+}
+
+// Dial opens a session to the given node. The first paramter should be "nodeid"
+// and the second parameter should contain a hexadecimal representation of the
+// target node ID.
+func (d *Dialer) Dial(network, address string) (Conn, error) {
+	conn := Conn{
+		mutex: &sync.RWMutex{},
+	}
+	nodeID := crypto.NodeID{}
+	nodeMask := crypto.NodeID{}
+	// Process
+	switch network {
+	case "nodeid":
+		// A node ID was provided - we don't need to do anything special with it
+		if tokens := strings.Split(address, "/"); len(tokens) == 2 {
+			len, err := strconv.Atoi(tokens[1])
+			if err != nil {
+				return Conn{}, err
+			}
+			dest, err := hex.DecodeString(tokens[0])
+			if err != nil {
+				return Conn{}, err
+			}
+			copy(nodeID[:], dest)
+			for idx := 0; idx < len; idx++ {
+				nodeMask[idx/8] |= 0x80 >> byte(idx%8)
+			}
+			fmt.Println(nodeID)
+			fmt.Println(nodeMask)
+		} else {
+			dest, err := hex.DecodeString(tokens[0])
+			if err != nil {
+				return Conn{}, err
+			}
+			copy(nodeID[:], dest)
+			for i := range nodeMask {
+				nodeMask[i] = 0xFF
+			}
+		}
+	default:
+		// An unexpected address type was given, so give up
+		return Conn{}, errors.New("unexpected address type")
+	}
+	conn.core = d.core
+	conn.nodeID = &nodeID
+	conn.nodeMask = &nodeMask
+	conn.core.router.doAdmin(func() {
+		conn.startSearch()
+	})
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
+	return conn, nil
+}

src/yggdrasil/router.go

@@ -41,7 +41,6 @@ type router struct {
 	in          <-chan []byte          // packets we received from the network, link to peer's "out"
 	out         func([]byte)           // packets we're sending to the network, link to peer's "in"
 	toRecv      chan router_recvPacket // packets to handle via recvPacket()
-	adapter     adapterImplementation  // TUN/TAP adapter
 	recv        chan<- []byte          // place where the adapter pulls received packets from
 	send        <-chan []byte          // place where the adapter puts outgoing packets
 	reject      chan<- RejectedPacket  // place where we send error packets back to adapter
@@ -136,9 +135,6 @@ func (r *router) init(core *Core) {
 	r.nodeinfo.setNodeInfo(r.core.config.Current.NodeInfo, r.core.config.Current.NodeInfoPrivacy)
 	r.core.config.Mutex.RUnlock()
 	r.cryptokey.init(r.core)
-	if r.adapter != nil {
-		r.adapter.Init(&r.core.config, r.core.log, send, recv, reject)
-	}
 }
 
 // Starts the mainLoop goroutine.

src/yggdrasil/session.go

@@ -289,9 +289,7 @@ func (ss *sessions) createSession(theirPermKey *crypto.BoxPubKey) *sessionInfo {
 	sinfo.mySesPriv = *priv
 	sinfo.myNonce = *crypto.NewBoxNonce()
 	sinfo.theirMTU = 1280
-	if ss.core.router.adapter != nil {
-		sinfo.myMTU = uint16(ss.core.router.adapter.MTU())
-	}
+	sinfo.myMTU = 1280
 	now := time.Now()
 	sinfo.timeMutex.Lock()
 	sinfo.time = now
@@ -480,11 +478,11 @@ func (ss *sessions) handlePing(ping *sessionPing) {
 		ss.listenerMutex.Lock()
 		if ss.listener != nil {
 			conn := &Conn{
-				core:         ss.core,
-				session:      sinfo,
-				sessionMutex: &sync.RWMutex{},
-				nodeID:       crypto.GetNodeID(&sinfo.theirPermPub),
-				nodeMask:     &crypto.NodeID{},
+				core:     ss.core,
+				session:  sinfo,
+				mutex:    &sync.RWMutex{},
+				nodeID:   crypto.GetNodeID(&sinfo.theirPermPub),
+				nodeMask: &crypto.NodeID{},
 			}
 			for i := range conn.nodeMask {
 				conn.nodeMask[i] = 0xFF