137 lines
3.7 KiB
Go
Raw Normal View History

2017-12-28 22:16:20 -06:00
package yggdrasil
// This manages the tun driver to send/recv packets to/from applications
import "github.com/songgao/packets/ethernet"
import "github.com/yggdrasil-network/water"
2017-12-28 22:16:20 -06:00
2018-05-27 23:31:34 +01:00
const tun_IPv6_HEADER_LENGTH = 40
const tun_ETHER_HEADER_LENGTH = 14
2017-12-28 22:16:20 -06:00
2018-06-12 22:45:53 +01:00
// Represents a running TUN/TAP interface.
2017-12-28 22:16:20 -06:00
type tunDevice struct {
2018-02-12 18:19:31 +00:00
core *Core
icmpv6 icmpv6
send chan<- []byte
recv <-chan []byte
mtu int
iface *water.Interface
2017-12-28 22:16:20 -06:00
}
2018-06-12 22:45:53 +01:00
// Defines which parameters are expected by default for a TUN/TAP adapter on a
// specific platform. These values are populated in the relevant tun_*.go for
// the platform being targeted. They must be set.
type tunDefaultParameters struct {
2018-03-03 11:49:24 -06:00
maximumIfMTU int
2018-03-03 12:30:54 +00:00
defaultIfMTU int
2018-03-03 11:49:24 -06:00
defaultIfName string
2018-03-03 12:30:54 +00:00
defaultIfTAPMode bool
}
2018-06-12 22:45:53 +01:00
// Gets the maximum supported MTU for the platform based on the defaults in
// getDefaults().
2018-03-03 12:30:54 +00:00
func getSupportedMTU(mtu int) int {
if mtu > getDefaults().maximumIfMTU {
return getDefaults().maximumIfMTU
}
return mtu
}
2018-06-12 22:45:53 +01:00
// Initialises the TUN/TAP adapter.
2017-12-28 22:16:20 -06:00
func (tun *tunDevice) init(core *Core) {
2018-01-04 22:37:51 +00:00
tun.core = core
2018-02-12 18:19:31 +00:00
tun.icmpv6.init(tun)
2017-12-28 22:16:20 -06:00
}
2018-06-12 22:45:53 +01:00
// Starts the setup process for the TUN/TAP adapter, and if successful, starts
// the read/write goroutines to handle packets on that interface.
2018-05-27 22:35:30 +01:00
func (tun *tunDevice) start(ifname string, iftapmode bool, addr string, mtu int) error {
2018-06-02 23:29:06 +01:00
if ifname == "none" {
return nil
}
2018-05-27 22:35:30 +01:00
if err := tun.setup(ifname, iftapmode, addr, mtu); err != nil {
return err
}
go func() { panic(tun.read()) }()
go func() { panic(tun.write()) }()
return nil
}
2018-06-12 22:45:53 +01:00
// Writes a packet to the TUN/TAP adapter. If the adapter is running in TAP
// mode then additional ethernet encapsulation is added for the benefit of the
// host operating system.
2017-12-28 22:16:20 -06:00
func (tun *tunDevice) write() error {
2018-01-04 22:37:51 +00:00
for {
data := <-tun.recv
if tun.iface == nil {
continue
}
if tun.iface.IsTAP() {
var frame ethernet.Frame
frame.Prepare(
2018-02-12 18:19:31 +00:00
tun.icmpv6.peermac[:6], // Destination MAC address
tun.icmpv6.mymac[:6], // Source MAC address
ethernet.NotTagged, // VLAN tagging
ethernet.IPv6, // Ethertype
len(data)) // Payload length
2018-05-27 23:31:34 +01:00
copy(frame[tun_ETHER_HEADER_LENGTH:], data[:])
if _, err := tun.iface.Write(frame); err != nil {
2018-01-25 17:44:56 +00:00
panic(err)
}
} else {
if _, err := tun.iface.Write(data); err != nil {
2018-01-25 17:44:56 +00:00
panic(err)
}
2018-01-04 22:37:51 +00:00
}
util_putBytes(data)
}
2017-12-28 22:16:20 -06:00
}
2018-06-12 22:45:53 +01:00
// Reads any packets that are waiting on the TUN/TAP adapter. If the adapter
// is running in TAP mode then the ethernet headers will automatically be
// processed and stripped if necessary. If an ICMPv6 packet is found, then
// the relevant helper functions in icmpv6.go are called.
2017-12-28 22:16:20 -06:00
func (tun *tunDevice) read() error {
2018-01-25 17:44:56 +00:00
mtu := tun.mtu
if tun.iface.IsTAP() {
2018-05-27 23:31:34 +01:00
mtu += tun_ETHER_HEADER_LENGTH
2018-01-25 17:44:56 +00:00
}
buf := make([]byte, mtu)
2018-01-04 22:37:51 +00:00
for {
n, err := tun.iface.Read(buf)
if err != nil {
2018-02-28 15:15:57 +00:00
// panic(err)
return err
2018-01-04 22:37:51 +00:00
}
o := 0
if tun.iface.IsTAP() {
2018-05-27 23:31:34 +01:00
o = tun_ETHER_HEADER_LENGTH
}
if buf[o]&0xf0 != 0x60 ||
2018-05-27 23:31:34 +01:00
n != 256*int(buf[o+4])+int(buf[o+5])+tun_IPv6_HEADER_LENGTH+o {
2018-01-04 22:37:51 +00:00
// Either not an IPv6 packet or not the complete packet for some reason
//panic("Should not happen in testing")
continue
}
2018-02-12 18:19:31 +00:00
if buf[o+6] == 58 {
// Found an ICMPv6 packet
b := make([]byte, n)
copy(b, buf)
2018-02-12 20:00:55 +00:00
// tun.icmpv6.recv <- b
go tun.icmpv6.parse_packet(b)
2018-02-12 18:19:31 +00:00
}
packet := append(util_getBytes(), buf[o:n]...)
2018-01-04 22:37:51 +00:00
tun.send <- packet
}
2017-12-28 22:16:20 -06:00
}
2018-06-12 22:45:53 +01:00
// Closes the TUN/TAP adapter. This is only usually called when the Yggdrasil
// process stops. Typically this operation will happen quickly, but on macOS
// it can block until a read operation is completed.
2017-12-28 22:16:20 -06:00
func (tun *tunDevice) close() error {
if tun.iface == nil {
return nil
}
2018-01-04 22:37:51 +00:00
return tun.iface.Close()
2017-12-28 22:16:20 -06:00
}