nebula/udp_generic.go

96 lines
2.1 KiB
Go
Raw Normal View History

// +build !linux android
2021-03-26 15:46:30 +01:00
// +build !e2e_testing
2019-11-19 18:00:20 +01:00
// udp_generic implements the nebula UDP interface in pure Go stdlib. This
// means it can be used on platforms like Darwin and Windows.
package nebula
import (
"context"
"fmt"
"net"
2021-03-26 15:46:30 +01:00
"github.com/sirupsen/logrus"
2019-11-19 18:00:20 +01:00
)
type udpConn struct {
*net.UDPConn
2021-03-26 15:46:30 +01:00
l *logrus.Logger
2019-11-19 18:00:20 +01:00
}
2021-03-26 15:46:30 +01:00
func NewListener(l *logrus.Logger, ip string, port int, multi bool) (*udpConn, error) {
2019-11-19 18:00:20 +01:00
lc := NewListenConfig(multi)
2021-03-19 02:37:24 +01:00
pc, err := lc.ListenPacket(context.TODO(), "udp", fmt.Sprintf("%s:%d", ip, port))
2019-11-19 18:00:20 +01:00
if err != nil {
return nil, err
}
if uc, ok := pc.(*net.UDPConn); ok {
2021-03-26 15:46:30 +01:00
return &udpConn{UDPConn: uc, l: l}, nil
2019-11-19 18:00:20 +01:00
}
return nil, fmt.Errorf("Unexpected PacketConn: %T %#v", pc, pc)
}
func (uc *udpConn) WriteTo(b []byte, addr *udpAddr) error {
2021-03-19 02:37:24 +01:00
_, err := uc.UDPConn.WriteToUDP(b, &net.UDPAddr{IP: addr.IP, Port: int(addr.Port)})
2019-11-19 18:00:20 +01:00
return err
}
func (uc *udpConn) LocalAddr() (*udpAddr, error) {
a := uc.UDPConn.LocalAddr()
switch v := a.(type) {
case *net.UDPAddr:
2021-03-19 02:37:24 +01:00
addr := &udpAddr{IP: make([]byte, len(v.IP))}
copy(addr.IP, v.IP)
addr.Port = uint16(v.Port)
return addr, nil
2019-11-19 18:00:20 +01:00
default:
return nil, fmt.Errorf("LocalAddr returned: %#v", a)
}
}
func (u *udpConn) reloadConfig(c *Config) {
// TODO
}
func NewUDPStatsEmitter(udpConns []*udpConn) func() {
// No UDP stats for non-linux
return func() {}
}
2019-11-19 18:00:20 +01:00
type rawMessage struct {
Len uint32
}
func (u *udpConn) ListenOut(f *Interface, q int) {
2019-11-19 18:00:20 +01:00
plaintext := make([]byte, mtu)
buffer := make([]byte, mtu)
header := &Header{}
fwPacket := &FirewallPacket{}
2021-03-19 02:37:24 +01:00
udpAddr := &udpAddr{IP: make([]byte, 16)}
2019-11-19 18:00:20 +01:00
nb := make([]byte, 12, 12)
lhh := f.lightHouse.NewRequestHandler()
conntrackCache := NewConntrackCacheTicker(f.conntrackCacheTimeout)
2019-11-19 18:00:20 +01:00
for {
// Just read one packet at a time
n, rua, err := u.ReadFromUDP(buffer)
if err != nil {
2021-03-26 15:46:30 +01:00
f.l.WithError(err).Error("Failed to read packets")
2019-11-19 18:00:20 +01:00
continue
}
2021-03-19 02:37:24 +01:00
udpAddr.IP = rua.IP
udpAddr.Port = uint16(rua.Port)
2021-03-26 15:46:30 +01:00
f.readOutsidePackets(udpAddr, plaintext[:0], buffer[:n], header, fwPacket, lhh, nb, q, conntrackCache.Get(f.l))
2019-11-19 18:00:20 +01:00
}
}
func hostDidRoam(addr *udpAddr, newaddr *udpAddr) bool {
return !addr.Equals(newaddr)
}