mirror of
https://github.com/slackhq/nebula.git
synced 2024-09-20 14:56:12 +08:00
27d9a67dda
This change is for Linux only. Previously, when running with multiple tun.routines, we would only have one file descriptor. This change instead sets IFF_MULTI_QUEUE and opens a file descriptor for each routine. This allows us to process with multiple threads while preventing out of order packet reception issues. To attempt to distribute the flows across the queues, we try to write to the tun/UDP queue that corresponds with the one we read from. So if we read a packet from tun queue "2", we will write the outgoing encrypted packet to UDP queue "2". Because of the nature of how multi queue works with flows, a given host tunnel will be sticky to a given routine (so if you try to performance benchmark by only using one tunnel between two hosts, you are only going to be using a max of one thread for each direction). Because this system works much better when we can correlate flows between the tun and udp routines, we are deprecating the undocumented "tun.routines" and "listen.routines" parameters and introducing a new "routines" parameter that sets the value for both. If you use the old undocumented parameters, the max of the values will be used and a warning logged. Co-authored-by: Nate Brown <nbrown.us@gmail.com>
88 lines
2.3 KiB
Go
88 lines
2.3 KiB
Go
// +build !ios
|
|
|
|
package nebula
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"os/exec"
|
|
"strconv"
|
|
|
|
"github.com/songgao/water"
|
|
)
|
|
|
|
type Tun struct {
|
|
Device string
|
|
Cidr *net.IPNet
|
|
MTU int
|
|
UnsafeRoutes []route
|
|
|
|
*water.Interface
|
|
}
|
|
|
|
func newTun(deviceName string, cidr *net.IPNet, defaultMTU int, routes []route, unsafeRoutes []route, txQueueLen int, multiqueue bool) (ifce *Tun, err error) {
|
|
if len(routes) > 0 {
|
|
return nil, fmt.Errorf("route MTU not supported in Darwin")
|
|
}
|
|
|
|
// NOTE: You cannot set the deviceName under Darwin, so you must check tun.Device after calling .Activate()
|
|
return &Tun{
|
|
Cidr: cidr,
|
|
MTU: defaultMTU,
|
|
UnsafeRoutes: unsafeRoutes,
|
|
}, nil
|
|
}
|
|
|
|
func newTunFromFd(deviceFd int, cidr *net.IPNet, defaultMTU int, routes []route, unsafeRoutes []route, txQueueLen int) (ifce *Tun, err error) {
|
|
return nil, fmt.Errorf("newTunFromFd not supported in Darwin")
|
|
}
|
|
|
|
func (c *Tun) Activate() error {
|
|
var err error
|
|
c.Interface, err = water.New(water.Config{
|
|
DeviceType: water.TUN,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("activate failed: %v", err)
|
|
}
|
|
|
|
c.Device = c.Interface.Name()
|
|
|
|
// TODO use syscalls instead of exec.Command
|
|
if err = exec.Command("/sbin/ifconfig", c.Device, c.Cidr.String(), c.Cidr.IP.String()).Run(); err != nil {
|
|
return fmt.Errorf("failed to run 'ifconfig': %s", err)
|
|
}
|
|
if err = exec.Command("/sbin/route", "-n", "add", "-net", c.Cidr.String(), "-interface", c.Device).Run(); err != nil {
|
|
return fmt.Errorf("failed to run 'route add': %s", err)
|
|
}
|
|
if err = exec.Command("/sbin/ifconfig", c.Device, "mtu", strconv.Itoa(c.MTU)).Run(); err != nil {
|
|
return fmt.Errorf("failed to run 'ifconfig': %s", err)
|
|
}
|
|
// Unsafe path routes
|
|
for _, r := range c.UnsafeRoutes {
|
|
if err = exec.Command("/sbin/route", "-n", "add", "-net", r.route.String(), "-interface", c.Device).Run(); err != nil {
|
|
return fmt.Errorf("failed to run 'route add' for unsafe_route %s: %s", r.route.String(), err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Tun) CidrNet() *net.IPNet {
|
|
return c.Cidr
|
|
}
|
|
|
|
func (c *Tun) DeviceName() string {
|
|
return c.Device
|
|
}
|
|
|
|
func (c *Tun) WriteRaw(b []byte) error {
|
|
_, err := c.Write(b)
|
|
return err
|
|
}
|
|
|
|
func (t *Tun) NewMultiQueueReader() (io.ReadWriteCloser, error) {
|
|
return nil, fmt.Errorf("TODO: multiqueue not implemented for darwin")
|
|
}
|