Merge branch 'future' into cleanup

src/tuntap/iface.go

@@ -50,6 +50,8 @@ func (tun *TunAdapter) read() {
 		if srcAddr != tun.addr && srcSubnet != tun.subnet {
 			continue // Wrong soruce address
 		}
+		bs = buf[begin-1 : end]
+		bs[0] = typeSessionTraffic
 		if dstAddr.IsValid() {
 			tun.store.sendToAddress(dstAddr, bs)
 		} else if dstSubnet.IsValid() {
@@ -61,12 +63,38 @@ func (tun *TunAdapter) read() {
 func (tun *TunAdapter) write() {
 	var buf [TUN_OFFSET_BYTES + 65535]byte
 	for {
-		bs := buf[TUN_OFFSET_BYTES:]
+		bs := buf[TUN_OFFSET_BYTES-1:]
 		n, from, err := tun.core.ReadFrom(bs)
 		if err != nil {
 			return
 		}
-		bs = bs[:n]
+		if n == 0 {
+			continue
+		}
+		switch bs[0] {
+		case typeSessionTraffic:
+			// This is what we want to handle here
+			if !tun.isEnabled {
+				continue // Drop traffic if the tun is disabled
+			}
+		case typeSessionNodeInfoRequest:
+			var key keyArray
+			copy(key[:], from.(iwt.Addr))
+			tun.nodeinfo.handleReq(nil, key)
+			continue
+		case typeSessionNodeInfoResponse:
+			var key keyArray
+			copy(key[:], from.(iwt.Addr))
+			res := append([]byte(nil), bs[1:n]...)
+			tun.nodeinfo.handleRes(nil, key, res)
+			continue
+		default:
+			continue
+		}
+		bs = bs[1:n]
+		if len(bs) == 0 {
+			continue
+		}
 		if bs[0]&0xf0 != 0x60 {
 			continue // not IPv6
 		}
@@ -99,7 +127,7 @@ func (tun *TunAdapter) write() {
 		if srcAddr != info.address && srcSubnet != info.subnet {
 			continue // bad remote address/subnet
 		}
-		bs = buf[:TUN_OFFSET_BYTES+n]
+		bs = buf[:TUN_OFFSET_BYTES+len(bs)]
 		n, err = tun.iface.Write(bs, TUN_OFFSET_BYTES)
 		if err != nil {
 			tun.Act(nil, func() {

src/tuntap/nodeinfo.go

@@ -0,0 +1,200 @@
+package tuntap
+
+import (
+	"encoding/json"
+	"errors"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/Arceliar/phony"
+	//"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
+	"github.com/yggdrasil-network/yggdrasil-go/src/version"
+
+	iwt "github.com/Arceliar/ironwood/types"
+)
+
+// NodeInfoPayload represents a RequestNodeInfo response, in bytes.
+type NodeInfoPayload []byte
+
+type nodeinfo struct {
+	phony.Inbox
+	tun        *TunAdapter
+	myNodeInfo NodeInfoPayload
+	callbacks  map[keyArray]nodeinfoCallback
+	cache      map[keyArray]nodeinfoCached
+	//table      *lookupTable
+}
+
+type nodeinfoCached struct {
+	payload NodeInfoPayload
+	created time.Time
+}
+
+type nodeinfoCallback struct {
+	call    func(nodeinfo *NodeInfoPayload)
+	created time.Time
+}
+
+// Represents a session nodeinfo packet.
+type nodeinfoReqRes struct {
+	Key        keyArray // Sender's permanent key
+	IsResponse bool
+	NodeInfo   NodeInfoPayload
+}
+
+// Initialises the nodeinfo cache/callback maps, and starts a goroutine to keep
+// the cache/callback maps clean of stale entries
+func (m *nodeinfo) init(tun *TunAdapter) {
+	m.Act(nil, func() {
+		m._init(tun)
+	})
+}
+
+func (m *nodeinfo) _init(tun *TunAdapter) {
+	m.tun = tun
+	m.callbacks = make(map[keyArray]nodeinfoCallback)
+	m.cache = make(map[keyArray]nodeinfoCached)
+
+	m._cleanup()
+}
+
+func (m *nodeinfo) _cleanup() {
+	for boxPubKey, callback := range m.callbacks {
+		if time.Since(callback.created) > time.Minute {
+			delete(m.callbacks, boxPubKey)
+		}
+	}
+	for boxPubKey, cache := range m.cache {
+		if time.Since(cache.created) > time.Hour {
+			delete(m.cache, boxPubKey)
+		}
+	}
+	time.AfterFunc(time.Second*30, func() {
+		m.Act(nil, m._cleanup)
+	})
+}
+
+// Add a callback for a nodeinfo lookup
+func (m *nodeinfo) addCallback(sender keyArray, call func(nodeinfo *NodeInfoPayload)) {
+	m.Act(nil, func() {
+		m._addCallback(sender, call)
+	})
+}
+
+func (m *nodeinfo) _addCallback(sender keyArray, call func(nodeinfo *NodeInfoPayload)) {
+	m.callbacks[sender] = nodeinfoCallback{
+		created: time.Now(),
+		call:    call,
+	}
+}
+
+// Handles the callback, if there is one
+func (m *nodeinfo) _callback(sender keyArray, nodeinfo NodeInfoPayload) {
+	if callback, ok := m.callbacks[sender]; ok {
+		callback.call(&nodeinfo)
+		delete(m.callbacks, sender)
+	}
+}
+
+// Get the current node's nodeinfo
+func (m *nodeinfo) getNodeInfo() (p NodeInfoPayload) {
+	phony.Block(m, func() {
+		p = m._getNodeInfo()
+	})
+	return
+}
+
+func (m *nodeinfo) _getNodeInfo() NodeInfoPayload {
+	return m.myNodeInfo
+}
+
+// Set the current node's nodeinfo
+func (m *nodeinfo) setNodeInfo(given interface{}, privacy bool) (err error) {
+	phony.Block(m, func() {
+		err = m._setNodeInfo(given, privacy)
+	})
+	return
+}
+
+func (m *nodeinfo) _setNodeInfo(given interface{}, privacy bool) error {
+	defaults := map[string]interface{}{
+		"buildname":     version.BuildName(),
+		"buildversion":  version.BuildVersion(),
+		"buildplatform": runtime.GOOS,
+		"buildarch":     runtime.GOARCH,
+	}
+	newnodeinfo := make(map[string]interface{})
+	if !privacy {
+		for k, v := range defaults {
+			newnodeinfo[k] = v
+		}
+	}
+	if nodeinfomap, ok := given.(map[string]interface{}); ok {
+		for key, value := range nodeinfomap {
+			if _, ok := defaults[key]; ok {
+				if strvalue, strok := value.(string); strok && strings.EqualFold(strvalue, "null") || value == nil {
+					delete(newnodeinfo, key)
+				}
+				continue
+			}
+			newnodeinfo[key] = value
+		}
+	}
+	newjson, err := json.Marshal(newnodeinfo)
+	if err == nil {
+		if len(newjson) > 16384 {
+			return errors.New("NodeInfo exceeds max length of 16384 bytes")
+		}
+		m.myNodeInfo = newjson
+		return nil
+	}
+	return err
+}
+
+// Add nodeinfo into the cache for a node
+func (m *nodeinfo) _addCachedNodeInfo(key keyArray, payload NodeInfoPayload) {
+	m.cache[key] = nodeinfoCached{
+		created: time.Now(),
+		payload: payload,
+	}
+}
+
+// Get a nodeinfo entry from the cache
+func (m *nodeinfo) _getCachedNodeInfo(key keyArray) (NodeInfoPayload, error) {
+	if nodeinfo, ok := m.cache[key]; ok {
+		return nodeinfo.payload, nil
+	}
+	return NodeInfoPayload{}, errors.New("No cache entry found")
+}
+
+func (m *nodeinfo) sendReq(from phony.Actor, key keyArray, callback func(nodeinfo *NodeInfoPayload)) {
+	m.Act(from, func() {
+		m._sendReq(key, callback)
+	})
+}
+
+func (m *nodeinfo) _sendReq(key keyArray, callback func(nodeinfo *NodeInfoPayload)) {
+	if callback != nil {
+		m._addCallback(key, callback)
+	}
+	m.tun.core.WriteTo([]byte{typeSessionNodeInfoRequest}, iwt.Addr(key[:]))
+}
+
+func (m *nodeinfo) handleReq(from phony.Actor, key keyArray) {
+	m.Act(from, func() {
+		m._sendRes(key)
+	})
+}
+
+func (m *nodeinfo) handleRes(from phony.Actor, key keyArray, info NodeInfoPayload) {
+	m.Act(from, func() {
+		m._callback(key, info)
+		m._addCachedNodeInfo(key, info)
+	})
+}
+
+func (m *nodeinfo) _sendRes(key keyArray) {
+	bs := append([]byte{typeSessionNodeInfoResponse}, m._getNodeInfo()...)
+	m.tun.core.WriteTo(bs, iwt.Addr(key[:]))
+}

src/tuntap/tun.go

@@ -44,7 +44,9 @@ type TunAdapter struct {
 	phony.Inbox // Currently only used for _handlePacket from the reader, TODO: all the stuff that currently needs a mutex below
 	//mutex        sync.RWMutex // Protects the below
 	isOpen     bool
+	isEnabled  bool // Used by the writer to drop sessionTraffic if not enabled
 	gatekeeper func(pubkey ed25519.PublicKey, initiator bool) bool
+	nodeinfo   nodeinfo
 }
 
 func (tun *TunAdapter) SetSessionGatekeeper(gatekeeper func(pubkey ed25519.PublicKey, initiator bool) bool) {
@@ -106,6 +108,7 @@ func (tun *TunAdapter) Init(core *yggdrasil.Core, config *config.NodeState, log
 	tun.store.init(tun)
 	tun.config = config
 	tun.log = log
+	tun.nodeinfo.init(tun)
 	if err := tun.core.SetOutOfBandHandler(tun.oobHandler); err != nil {
 		return fmt.Errorf("tun.core.SetOutOfBandHander: %w", err)
 	}
@@ -137,20 +140,13 @@ func (tun *TunAdapter) _start() error {
 	addr := fmt.Sprintf("%s/%d", net.IP(tun.addr[:]).String(), 8*len(address.GetPrefix())-1)
 	if current.IfName == "none" || current.IfName == "dummy" {
 		tun.log.Debugln("Not starting TUN as ifname is none or dummy")
-		go func() {
+		tun.isEnabled = false
-			bs := make([]byte, tun.core.PacketConn.MTU())
+		go tun.write()
-			for {
-				// Dump traffic to nowhere
-				if _, _, err := tun.core.PacketConn.ReadFrom(bs); err != nil {
-					return
-				}
-			}
-		}()
 		return nil
 	}
 	mtu := current.IfMTU
-	if tun.core.MTU() < uint64(mtu) {
+	if tun.maxSessionMTU() < mtu {
-		mtu = tun.core.MTU()
+		mtu = tun.maxSessionMTU()
 	}
 	if err := tun.setup(current.IfName, addr, mtu); err != nil {
 		return err
@@ -159,6 +155,7 @@ func (tun *TunAdapter) _start() error {
 		tun.log.Warnf("Warning: Interface MTU %d automatically adjusted to %d (supported range is 1280-%d)", current.IfMTU, tun.MTU(), MaximumMTU())
 	}
 	tun.isOpen = true
+	tun.isEnabled = true
 	go tun.read()
 	go tun.write()
 	return nil
@@ -215,11 +212,6 @@ func (tun *TunAdapter) oobHandler(fromKey, toKey ed25519.PublicKey, data []byte)
 	}
 }
 
-const (
-	typeKeyLookup   = 1
-	typeKeyResponse = 2
-)
-
 func (tun *TunAdapter) sendKeyLookup(partial ed25519.PublicKey) {
 	sig := ed25519.Sign(tun.core.PrivateKey(), partial[:])
 	bs := append([]byte{typeKeyLookup}, sig...)
@@ -231,3 +223,8 @@ func (tun *TunAdapter) sendKeyResponse(dest ed25519.PublicKey) {
 	bs := append([]byte{typeKeyResponse}, sig...)
 	tun.core.SendOutOfBand(dest, bs)
 }
+
+func (tun *TunAdapter) maxSessionMTU() MTU {
+	const sessionTypeOverhead = 1
+	return MTU(tun.core.MTU() - sessionTypeOverhead)
+}

src/tuntap/types.go

@@ -0,0 +1,16 @@
+package tuntap
+
+// Out-of-band packet types
+const (
+	typeKeyDummy = iota
+	typeKeyLookup
+	typeKeyResponse
+)
+
+// In-band packet types
+const (
+	typeSessionDummy = iota
+	typeSessionTraffic
+	typeSessionNodeInfoRequest
+	typeSessionNodeInfoResponse
+)