5
0
mirror of https://github.com/cwinfo/yggdrasil-go.git synced 2024-12-23 23:55:40 +00:00
yggdrasil-go/src/tuntap/tun.go

296 lines
9.0 KiB
Go
Raw Normal View History

package tuntap
2017-12-29 04:16:20 +00:00
// This manages the tun driver to send/recv packets to/from applications
2019-04-22 23:04:22 +00:00
// TODO: Crypto-key routing support
2019-04-22 22:12:13 +00:00
// TODO: Set MTU of session properly
2019-04-22 23:04:22 +00:00
// TODO: Reject packets that exceed session MTU with ICMPv6 for PMTU Discovery
// TODO: Connection timeouts (call Conn.Close() when we want to time out)
// TODO: Don't block in reader on writes that are pending searches
2019-04-22 22:12:13 +00:00
2018-06-12 22:50:08 +00:00
import (
"encoding/hex"
"errors"
"fmt"
2019-01-14 14:25:52 +00:00
"net"
2019-08-28 18:31:04 +00:00
2019-08-25 23:53:11 +00:00
//"sync"
"github.com/Arceliar/phony"
"github.com/gologme/log"
2018-06-12 22:50:08 +00:00
"github.com/yggdrasil-network/water"
2018-12-08 01:56:04 +00:00
"github.com/yggdrasil-network/yggdrasil-go/src/address"
"github.com/yggdrasil-network/yggdrasil-go/src/config"
"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
2018-12-08 01:56:04 +00:00
"github.com/yggdrasil-network/yggdrasil-go/src/defaults"
"github.com/yggdrasil-network/yggdrasil-go/src/yggdrasil"
2018-06-12 22:50:08 +00:00
)
2017-12-29 04:16:20 +00:00
2018-05-27 22:31:34 +00:00
const tun_IPv6_HEADER_LENGTH = 40
const tun_ETHER_HEADER_LENGTH = 14
2017-12-29 04:16:20 +00:00
2019-03-29 18:18:31 +00:00
// TunAdapter represents a running TUN/TAP interface and extends the
// yggdrasil.Adapter type. In order to use the TUN/TAP adapter with Yggdrasil,
// you should pass this object to the yggdrasil.SetRouterAdapter() function
// before calling yggdrasil.Start().
type TunAdapter struct {
core *yggdrasil.Core
2019-08-25 23:53:11 +00:00
writer tunWriter
reader tunReader
config *config.NodeState
log *log.Logger
reconfigure chan chan error
listener *yggdrasil.Listener
dialer *yggdrasil.Dialer
addr address.Address
subnet address.Subnet
ckr cryptokey
icmpv6 ICMPv6
mtu int
iface *water.Interface
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
addrToConn map[address.Address]*tunConn
subnetToConn map[address.Subnet]*tunConn
dials map[string][][]byte // Buffer of packets to send after dialing finishes
isOpen bool
2017-12-29 04:16:20 +00:00
}
type TunOptions struct {
Listener *yggdrasil.Listener
Dialer *yggdrasil.Dialer
}
2018-06-12 21:45:53 +00:00
// Gets the maximum supported MTU for the platform based on the defaults in
// defaults.GetDefaults().
func getSupportedMTU(mtu int, istapmode bool) int {
if mtu < 1280 {
return 1280
}
if mtu > MaximumMTU(istapmode) {
return MaximumMTU(istapmode)
}
return mtu
}
2019-03-29 18:18:31 +00:00
// Name returns the name of the adapter, e.g. "tun0". On Windows, this may
// return a canonical adapter name instead.
func (tun *TunAdapter) Name() string {
return tun.iface.Name()
}
2019-03-29 18:18:31 +00:00
// MTU gets the adapter's MTU. This can range between 1280 and 65535, although
// the maximum value is determined by your platform. The returned value will
// never exceed that of MaximumMTU().
func (tun *TunAdapter) MTU() int {
return getSupportedMTU(tun.mtu, tun.IsTAP())
}
2019-03-29 18:18:31 +00:00
// IsTAP returns true if the adapter is a TAP adapter (Layer 2) or false if it
// is a TUN adapter (Layer 3).
func (tun *TunAdapter) IsTAP() bool {
return tun.iface.IsTAP()
}
2019-03-29 18:18:31 +00:00
// DefaultName gets the default TUN/TAP interface name for your platform.
func DefaultName() string {
return defaults.GetDefaults().DefaultIfName
}
2019-03-29 18:18:31 +00:00
// DefaultMTU gets the default TUN/TAP interface MTU for your platform. This can
// be as high as MaximumMTU(), depending on platform, but is never lower than 1280.
func DefaultMTU() int {
ehbytes := 0
if DefaultIsTAP() {
2019-11-20 22:40:48 +00:00
ehbytes = tun_ETHER_HEADER_LENGTH
}
return defaults.GetDefaults().DefaultIfMTU - ehbytes
}
2019-03-29 18:18:31 +00:00
// DefaultIsTAP returns true if the default adapter mode for the current
// platform is TAP (Layer 2) and returns false for TUN (Layer 3).
func DefaultIsTAP() bool {
return defaults.GetDefaults().DefaultIfTAPMode
}
2019-03-29 18:18:31 +00:00
// MaximumMTU returns the maximum supported TUN/TAP interface MTU for your
// platform. This can be as high as 65535, depending on platform, but is never
// lower than 1280.
func MaximumMTU(iftapmode bool) int {
ehbytes := 0
if iftapmode {
2019-11-20 22:40:48 +00:00
ehbytes = tun_ETHER_HEADER_LENGTH
}
return defaults.GetDefaults().MaximumIfMTU - ehbytes
}
// Init initialises the TUN/TAP module. You must have acquired a Listener from
// the Yggdrasil core before this point and it must not be in use elsewhere.
func (tun *TunAdapter) Init(core *yggdrasil.Core, config *config.NodeState, log *log.Logger, options interface{}) error {
tunoptions, ok := options.(TunOptions)
if !ok {
return fmt.Errorf("invalid options supplied to TunAdapter module")
}
tun.core = core
tun.config = config
tun.log = log
tun.listener = tunoptions.Listener
tun.dialer = tunoptions.Dialer
tun.addrToConn = make(map[address.Address]*tunConn)
tun.subnetToConn = make(map[address.Subnet]*tunConn)
tun.dials = make(map[string][][]byte)
tun.writer.tun = tun
tun.reader.tun = tun
return nil
2017-12-29 04:16:20 +00:00
}
2019-03-29 18:18:31 +00:00
// Start the setup process for the TUN/TAP adapter. If successful, starts the
2019-08-25 23:53:11 +00:00
// reader actor to handle packets on that interface.
func (tun *TunAdapter) Start() error {
2019-08-25 23:53:11 +00:00
var err error
phony.Block(tun, func() {
2019-08-25 23:53:11 +00:00
err = tun._start()
})
return err
}
func (tun *TunAdapter) _start() error {
2019-10-24 22:37:39 +00:00
if tun.isOpen {
return errors.New("TUN/TAP module is already started")
}
current := tun.config.GetCurrent()
if tun.config == nil || tun.listener == nil || tun.dialer == nil {
2019-10-24 22:37:39 +00:00
return errors.New("no configuration available to TUN/TAP")
}
var boxPub crypto.BoxPubKey
boxPubHex, err := hex.DecodeString(current.EncryptionPublicKey)
if err != nil {
return err
}
copy(boxPub[:], boxPubHex)
nodeID := crypto.GetNodeID(&boxPub)
tun.addr = *address.AddrForNodeID(nodeID)
tun.subnet = *address.SubnetForNodeID(nodeID)
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/TAP as ifname is none or dummy")
2019-01-02 18:05:54 +00:00
return nil
2018-05-27 21:35:30 +00:00
}
if err := tun.setup(current.IfName, current.IfTAPMode, addr, current.IfMTU); err != nil {
return err
}
if tun.MTU() != current.IfMTU {
tun.log.Warnf("Warning: Interface MTU %d automatically adjusted to %d (supported range is 1280-%d)", current.IfMTU, tun.MTU(), MaximumMTU(tun.IsTAP()))
}
tun.core.SetMaximumSessionMTU(uint16(tun.MTU()))
tun.isOpen = true
go tun.handler()
tun.reader.Act(nil, tun.reader._read) // Start the reader
2019-04-23 10:37:32 +00:00
tun.icmpv6.Init(tun)
if tun.IsTAP() {
2019-07-06 14:08:17 +00:00
go tun.icmpv6.Solicit(tun.addr)
}
2019-05-17 21:09:20 +00:00
tun.ckr.init(tun)
2018-05-27 21:35:30 +00:00
return nil
}
// IsStarted returns true if the module has been started.
func (tun *TunAdapter) IsStarted() bool {
2019-10-24 22:37:39 +00:00
var isOpen bool
phony.Block(tun, func() {
isOpen = tun.isOpen
})
return isOpen
}
// Start the setup process for the TUN/TAP adapter. If successful, starts the
// read/write goroutines to handle packets on that interface.
func (tun *TunAdapter) Stop() error {
2019-08-25 23:53:11 +00:00
var err error
phony.Block(tun, func() {
2019-08-25 23:53:11 +00:00
err = tun._stop()
})
return err
}
func (tun *TunAdapter) _stop() error {
tun.isOpen = false
// by TUN/TAP, e.g. readers/writers, sessions
if tun.iface != nil {
// Just in case we failed to start up the iface for some reason, this can apparently happen on Windows
tun.iface.Close()
}
return nil
}
2019-05-17 21:29:52 +00:00
// UpdateConfig updates the TUN/TAP module with the provided config.NodeConfig
// and then signals the various module goroutines to reconfigure themselves if
// needed.
func (tun *TunAdapter) UpdateConfig(config *config.NodeConfig) {
tun.log.Debugln("Reloading TUN/TAP configuration...")
2019-08-28 18:31:04 +00:00
// Replace the active configuration with the supplied one
2019-05-17 21:29:52 +00:00
tun.config.Replace(*config)
2019-08-28 18:31:04 +00:00
// Notify children about the configuration change
tun.Act(nil, tun.ckr.configure)
2019-05-17 21:29:52 +00:00
}
func (tun *TunAdapter) handler() error {
for {
// Accept the incoming connection
conn, err := tun.listener.Accept()
if err != nil {
2019-04-21 11:28:46 +00:00
tun.log.Errorln("TUN/TAP connection accept error:", err)
return err
}
phony.Block(tun, func() {
if _, err := tun._wrap(conn.(*yggdrasil.Conn)); err != nil {
2019-08-25 23:53:11 +00:00
// Something went wrong when storing the connection, typically that
// something already exists for this address or subnet
tun.log.Debugln("TUN/TAP handler wrap:", err)
}
})
}
}
2019-08-25 23:53:11 +00:00
func (tun *TunAdapter) _wrap(conn *yggdrasil.Conn) (c *tunConn, err error) {
// Prepare a session wrapper for the given connection
s := tunConn{
tun: tun,
conn: conn,
stop: make(chan struct{}),
}
c = &s
// Get the remote address and subnet of the other side
remoteNodeID := conn.RemoteAddr().(*crypto.NodeID)
s.addr = *address.AddrForNodeID(remoteNodeID)
s.snet = *address.SubnetForNodeID(remoteNodeID)
// Work out if this is already a destination we already know about
atc, aok := tun.addrToConn[s.addr]
stc, sok := tun.subnetToConn[s.snet]
// If we know about a connection for this destination already then assume it
// is no longer valid and close it
if aok {
2019-08-25 23:53:11 +00:00
atc._close_from_tun()
err = errors.New("replaced connection for address")
} else if sok {
2019-08-25 23:53:11 +00:00
stc._close_from_tun()
err = errors.New("replaced connection for subnet")
}
// Save the session wrapper so that we can look it up quickly next time
// we receive a packet through the interface for this address
tun.addrToConn[s.addr] = &s
tun.subnetToConn[s.snet] = &s
// Set the read callback and start the timeout
conn.SetReadCallback(func(bs []byte) {
s.Act(conn, func() {
s._read(bs)
})
})
s.Act(nil, s.stillAlive)
// Return
return c, err
2017-12-29 04:16:20 +00:00
}