func proxy(sm *subnet.SubnetManager, tun *os.File, conn *net.UDPConn, tunMTU uint, port int) {
log.Info("Running slow proxy loop")
rtr := NewRouter(port)
go proxyTunToUdp(rtr, tun, conn, tunMTU)
go proxyUdpToTun(conn, tun, tunMTU)
log.Info("Watching for new subnet leases")
evts := make(chan subnet.EventBatch)
sm.Start(evts)
for evtBatch := range evts {
for _, evt := range evtBatch {
if evt.Type == subnet.SubnetAdded {
log.Info("Subnet added: ", evt.Lease.Network)
var attrs subnet.BaseAttrs
if err := json.Unmarshal([]byte(evt.Lease.Data), &attrs); err != nil {
log.Error("Error decoding subnet lease JSON: ", err)
continue
}
rtr.SetRoute(evt.Lease.Network, attrs.PublicIP)
} else if evt.Type == subnet.SubnetRemoved {
log.Info("Subnet removed: ", evt.Lease.Network)
rtr.DelRoute(evt.Lease.Network)
} else {
log.Error("Internal error: unknown event type: ", int(evt.Type))
}
}
}
}
func Run(sm *subnet.SubnetManager, tepIface *net.Interface, tepIP net.IP, port int, ipMasq bool, ready backend.ReadyFunc) {
sn, err := acquireLease(sm, tepIP)
if err != nil {
log.Error("Failed to acquire lease: ", err)
return
}
tun, tunName, err := ip.OpenTun("rudder%d")
if err != nil {
log.Error("Failed to open TUN device: ", err)
return
}
localAddr := net.UDPAddr{
Port: port,
}
conn, err := net.ListenUDP("udp4", &localAddr)
if err != nil {
log.Error("Failed to start listening on UDP socket: ", err)
return
}
// Interface's subnet is that of the whole overlay network (e.g. /16)
// and not that of the individual host (e.g. /24)
tunNet := ip.IP4Net{
IP: sn.IP,
PrefixLen: sm.GetConfig().Network.PrefixLen,
}
// TUN MTU will be smaller b/c of encap (IP+UDP hdrs)
var mtu int
if tepIface.MTU > 0 {
mtu = tepIface.MTU - encapOverhead
} else {
log.Errorf("Failed to determine MTU for %s interface", tepIP)
return
}
err = configureIface(tunName, tunNet, mtu)
if err != nil {
return
}
if ipMasq {
err = setupIpMasq(tunNet.Network(), tunName)
if err != nil {
return
}
}
// all initialized and ready for business
log.Info("UDP encapsulation initialized")
ready(sn, mtu)
fastProxy(sm, tun, conn, tunNet.IP, uint(mtu), port)
}
func acquireLease(sm *subnet.SubnetManager, pubIP net.IP) (ip.IP4Net, error) {
attrs := subnet.BaseAttrs{
PublicIP: ip.FromIP(pubIP),
}
data, err := json.Marshal(&attrs)
if err != nil {
return ip.IP4Net{}, err
}
var sn ip.IP4Net
for {
sn, err = sm.AcquireLease(attrs.PublicIP, string(data))
if err == nil {
log.Info("Subnet lease acquired: ", sn)
break
}
log.Error("Failed to acquire subnet: ", err)
time.Sleep(time.Second)
}
return sn, nil
}
func fastProxy(sm *subnet.SubnetManager, tun *os.File, conn *net.UDPConn, tunIP ip.IP4, tunMTU uint, port int) {
log.Info("Running fast proxy loop")
c, err := conn.File()
if err != nil {
log.Error("Converting UDPConn to File failed: ", err)
return
}
defer c.Close()
ctl, peerCtl, err := newCtlSockets()
if err != nil {
log.Error("Failed to create control socket: ", err)
return
}
defer ctl.Close()
defer peerCtl.Close()
go runCProxy(tun, c, peerCtl, tunIP, tunMTU)
log.Info("Watching for new subnet leases")
evts := make(chan subnet.EventBatch)
sm.Start(evts)
for evtBatch := range evts {
for _, evt := range evtBatch {
if evt.Type == subnet.SubnetAdded {
log.Info("Subnet added: ", evt.Lease.Network)
var attrs subnet.BaseAttrs
if err := json.Unmarshal([]byte(evt.Lease.Data), &attrs); err != nil {
log.Error("Error decoding subnet lease JSON: ", err)
continue
}
cmd := C.command{
cmd: C.CMD_SET_ROUTE,
dest_net: C.in_addr_t(evt.Lease.Network.IP.NetworkOrder()),
dest_net_len: C.int(evt.Lease.Network.PrefixLen),
next_hop_ip: C.in_addr_t(attrs.PublicIP.NetworkOrder()),
next_hop_port: C.short(port),
}
writeCommand(ctl, &cmd)
} else if evt.Type == subnet.SubnetRemoved {
log.Info("Subnet removed: ", evt.Lease.Network)
cmd := C.command{
cmd: C.CMD_DEL_ROUTE,
dest_net: C.in_addr_t(evt.Lease.Network.IP.NetworkOrder()),
dest_net_len: C.int(evt.Lease.Network.PrefixLen),
}
writeCommand(ctl, &cmd)
} else {
log.Error("Internal error: unknown event type: ", int(evt.Type))
}
}
}
}