Clean up

cmd/yggstack/main.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io"
 	"net"
 	"os"
 	"os/signal"
@@ -22,6 +23,7 @@ import (
 
 	"github.com/yggdrasil-network/yggdrasil-go/src/version"
 
+	"net/http"
 	_ "net/http/pprof"
 )
 
@@ -141,21 +143,20 @@ func main() {
 	logger.Infof("Your IPv6 address is %s", address.String())
 	logger.Infof("Your IPv6 subnet is %s", subnet.String())
 
-	_, err = netstack.CreateYggdrasilNetstack(&n.Core, false)
+	s, err := netstack.CreateYggdrasilNetstack(&n.Core)
 	if err != nil {
 		logger.Fatalln(err)
 	}
-	/*
+
-		listener, err := s.ListenTCP(&net.TCPAddr{Port: 80})
+	listener, err := s.ListenTCP(&net.TCPAddr{Port: 80})
-		if err != nil {
+	if err != nil {
-			log.Panicln(err)
+		log.Panicln(err)
-		}
+	}
-		http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
+	http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
-			_, _ = io.WriteString(writer, "Hello from userspace TCP "+request.RemoteAddr)
+		_, _ = io.WriteString(writer, "Hello from userspace TCP "+request.RemoteAddr)
-		})
+	})
-		httpServer := &http.Server{}
+	httpServer := &http.Server{}
-		go httpServer.Serve(listener) // nolint:errcheck
+	go httpServer.Serve(listener) // nolint:errcheck
-	*/
 
 	term := make(chan os.Signal, 1)
 	signal.Notify(term, os.Interrupt, syscall.SIGTERM)

contrib/netstack/netstack.go

@@ -1,10 +1,8 @@
 package netstack
 
 import (
-	"encoding/base64"
 	"fmt"
 	"net"
-	"time"
 
 	"github.com/yggdrasil-network/yggdrasil-go/src/core"
 
@@ -21,12 +19,12 @@ type YggdrasilNetstack struct {
 	stack *stack.Stack
 }
 
-func CreateYggdrasilNetstack(ygg *core.Core, handlelocal bool) (*YggdrasilNetstack, error) {
+func CreateYggdrasilNetstack(ygg *core.Core) (*YggdrasilNetstack, error) {
 	s := &YggdrasilNetstack{
 		stack: stack.New(stack.Options{
 			NetworkProtocols:   []stack.NetworkProtocolFactory{ipv6.NewProtocol},
 			TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol, icmp.NewProtocol6},
-			HandleLocal:        handlelocal,
+			HandleLocal:        true,
 		}),
 	}
 	if s.stack.HandleLocal() {
@@ -37,22 +35,6 @@ func CreateYggdrasilNetstack(ygg *core.Core, handlelocal bool) (*YggdrasilNetsta
 	if err := s.NewYggdrasilNIC(ygg); err != nil {
 		return nil, fmt.Errorf("s.NewYggdrasilNIC: %s", err.String())
 	}
-	pk, err := base64.RawStdEncoding.WithPadding('=').DecodeString("T6wTiFBhFj1evcApUyQDuDNADGePrheqx0A6vW9rFEw=")
-	if err != nil {
-		panic(err)
-	}
-	if err := s.NewWireguardNIC(ygg, pk[:]); err != nil {
-		return nil, fmt.Errorf("s.NewWireguardNIC: %s", err.String())
-	}
-
-	var f func()
-	f = func() {
-		fmt.Printf("\nRouting table: %+v\n", s.stack.GetRouteTable())
-		fmt.Printf("Forwarding: %+v\n", s.stack.Stats().IP.Forwarding)
-		time.AfterFunc(time.Second, f)
-	}
-	f()
-
 	return s, nil
 }
 
@@ -65,33 +47,21 @@ func convertToFullAddr(ip net.IP, port int) (tcpip.FullAddress, tcpip.NetworkPro
 }
 
 func (s *YggdrasilNetstack) DialTCP(addr *net.TCPAddr) (net.Conn, error) {
-	if !s.stack.HandleLocal() {
-		return nil, fmt.Errorf("only available when handling local traffic is enabled")
-	}
 	fa, pn := convertToFullAddr(addr.IP, addr.Port)
 	return gonet.DialTCP(s.stack, fa, pn)
 }
 
 func (s *YggdrasilNetstack) DialUDP(addr *net.UDPAddr) (net.PacketConn, error) {
-	if !s.stack.HandleLocal() {
-		return nil, fmt.Errorf("only available when handling local traffic is enabled")
-	}
 	fa, pn := convertToFullAddr(addr.IP, addr.Port)
 	return gonet.DialUDP(s.stack, nil, &fa, pn)
 }
 
 func (s *YggdrasilNetstack) ListenTCP(addr *net.TCPAddr) (net.Listener, error) {
-	if !s.stack.HandleLocal() {
-		return nil, fmt.Errorf("only available when handling local traffic is enabled")
-	}
 	fa, pn := convertToFullAddr(addr.IP, addr.Port)
 	return gonet.ListenTCP(s.stack, fa, pn)
 }
 
 func (s *YggdrasilNetstack) ListenUDP(addr *net.UDPAddr) (net.PacketConn, error) {
-	if !s.stack.HandleLocal() {
-		return nil, fmt.Errorf("only available when handling local traffic is enabled")
-	}
 	fa, pn := convertToFullAddr(addr.IP, addr.Port)
 	return gonet.DialUDP(s.stack, &fa, nil, pn)
 }

contrib/netstack/wireguard.go

@@ -1,218 +0,0 @@
-package netstack
-
-import (
-	"crypto/ed25519"
-	"encoding/hex"
-	"fmt"
-	"os"
-
-	"github.com/yggdrasil-network/yggdrasil-go/src/core"
-	"golang.org/x/crypto/curve25519"
-
-	"golang.zx2c4.com/wireguard/conn"
-	"golang.zx2c4.com/wireguard/device"
-	"golang.zx2c4.com/wireguard/tun"
-
-	"inet.af/netstack/tcpip"
-	"inet.af/netstack/tcpip/buffer"
-	"inet.af/netstack/tcpip/header"
-	"inet.af/netstack/tcpip/network/ipv4"
-	"inet.af/netstack/tcpip/network/ipv6"
-	"inet.af/netstack/tcpip/stack"
-)
-
-type YggdrasilWireguard struct {
-	stack          *YggdrasilNetstack
-	device         *device.Device
-	dispatcher     stack.NetworkDispatcher
-	events         chan tun.Event
-	incomingPacket chan buffer.VectorisedView
-}
-
-type YggdrasilWireguardEndpoint YggdrasilWireguard
-
-func (s *YggdrasilNetstack) NewWireguardNIC(ygg *core.Core, public ed25519.PublicKey) tcpip.Error {
-	wg := &YggdrasilWireguard{
-		stack: s,
-	}
-
-	var nsk device.NoisePrivateKey
-	var npk device.NoisePublicKey
-	apk := (*[device.NoisePublicKeySize]byte)(&npk)
-	ask := (*[device.NoisePrivateKeySize]byte)(&nsk)
-
-	ysk := hex.EncodeToString(ygg.PrivateKey()[:ed25519.PrivateKeySize-ed25519.PublicKeySize])
-	if err := nsk.FromMaybeZeroHex(ysk); err != nil {
-		panic(err)
-	}
-	curve25519.ScalarBaseMult(apk, ask)
-
-	wg.device = device.NewDevice(wg, conn.NewDefaultBind(), device.NewLogger(device.LogLevelError, ""))
-	if err := wg.device.IpcSet(fmt.Sprintf(""+
-		"listen_port=12346\n"+
-		"private_key=%s\n"+
-		"public_key=%s\n"+
-		"allowed_ip=%s/128\n"+
-		"allowed_ip=%s/64",
-		hex.EncodeToString(ask[:]),
-		hex.EncodeToString(public[:]),
-		ygg.Address().String(),
-		ygg.Subnet().IP.String(),
-	)); err != nil {
-		panic(err)
-	}
-	wg.device.Up()
-
-	/*
-		fmt.Println("WIREGUARD CONFIG:")
-		fmt.Println()
-		fmt.Println("[Interface]")
-		fmt.Println("Address =", ygg.Address().String())
-		fmt.Println()
-		fmt.Println("[Peer]")
-		fmt.Println("Endpoint = localhost:12346")
-		fmt.Println("AllowedIPs = 200::/7")
-		fmt.Println("PublicKey =", base64.RawStdEncoding.WithPadding('=').EncodeToString(apk[:]))
-		fmt.Println()
-	*/
-
-	if err := s.stack.CreateNIC(2, (*YggdrasilWireguardEndpoint)(wg)); err != nil {
-		return err
-	}
-
-	addr := ygg.Address()
-	snet := ygg.Subnet()
-	m := []byte{
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-	}
-
-	routeAddr, err := tcpip.NewSubnet(
-		tcpip.Address(addr),
-		tcpip.AddressMask(m[:]),
-	)
-	if err != nil {
-		panic(err)
-	}
-	routeSnet, err := tcpip.NewSubnet(
-		tcpip.Address(string(snet.IP)),
-		tcpip.AddressMask(string(snet.Mask)),
-	)
-	if err != nil {
-		panic(err)
-	}
-	s.stack.AddRoute(tcpip.Route{
-		Destination: routeAddr,
-		NIC:         2,
-	})
-	s.stack.AddRoute(tcpip.Route{
-		Destination: routeSnet,
-		NIC:         2,
-	})
-	return nil
-}
-
-//////////// BELOW IMPLEMENTS tcpip.Endpoint ////////////
-
-func (e *YggdrasilWireguardEndpoint) Attach(dispatcher stack.NetworkDispatcher) {
-	e.dispatcher = dispatcher
-}
-
-func (e *YggdrasilWireguardEndpoint) IsAttached() bool {
-	return e.dispatcher != nil
-}
-
-func (e *YggdrasilWireguardEndpoint) MTU() uint32 {
-	return 1420
-}
-
-func (*YggdrasilWireguardEndpoint) Capabilities() stack.LinkEndpointCapabilities {
-	return stack.CapabilityNone
-}
-
-func (*YggdrasilWireguardEndpoint) MaxHeaderLength() uint16 {
-	return 0
-}
-
-func (*YggdrasilWireguardEndpoint) LinkAddress() tcpip.LinkAddress {
-	return ""
-}
-
-func (*YggdrasilWireguardEndpoint) Wait() {}
-
-func (e *YggdrasilWireguardEndpoint) WritePacket(_ stack.RouteInfo, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
-	e.incomingPacket <- buffer.NewVectorisedView(pkt.Size(), pkt.Views())
-	return nil
-}
-
-func (e *YggdrasilWireguardEndpoint) WritePackets(stack.RouteInfo, stack.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
-	panic("not implemented")
-}
-
-func (e *YggdrasilWireguardEndpoint) WriteRawPacket(*stack.PacketBuffer) tcpip.Error {
-	panic("not implemented")
-}
-
-func (*YggdrasilWireguardEndpoint) ARPHardwareType() header.ARPHardwareType {
-	return header.ARPHardwareNone
-}
-
-func (e *YggdrasilWireguardEndpoint) AddHeader(tcpip.LinkAddress, tcpip.LinkAddress, tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
-}
-
-//////////// BELOW IMPLEMENTS tun.Device ////////////
-
-func (tun *YggdrasilWireguard) Name() (string, error) {
-	return "go", nil
-}
-
-func (tun *YggdrasilWireguard) File() *os.File {
-	return nil
-}
-
-func (tun *YggdrasilWireguard) Events() chan tun.Event {
-	return tun.events
-}
-
-func (tun *YggdrasilWireguard) Read(buf []byte, offset int) (int, error) {
-	view, ok := <-tun.incomingPacket
-	if !ok {
-		return 0, os.ErrClosed
-	}
-	return view.Read(buf[offset:])
-}
-
-func (tun *YggdrasilWireguard) Write(buf []byte, offset int) (int, error) {
-	packet := buf[offset:]
-	if len(packet) == 0 {
-		return 0, nil
-	}
-
-	pkb := stack.NewPacketBuffer(stack.PacketBufferOptions{Data: buffer.NewVectorisedView(len(packet), []buffer.View{buffer.NewViewFromBytes(packet)})})
-	switch packet[0] >> 4 {
-	case 4:
-		tun.dispatcher.DeliverNetworkPacket("", "", ipv4.ProtocolNumber, pkb)
-	case 6:
-		tun.dispatcher.DeliverNetworkPacket("", "", ipv6.ProtocolNumber, pkb)
-	}
-
-	return len(buf), nil
-}
-
-func (tun *YggdrasilWireguard) Flush() error {
-	return nil
-}
-
-func (tun *YggdrasilWireguard) Close() error {
-	if tun.events != nil {
-		close(tun.events)
-	}
-	if tun.incomingPacket != nil {
-		close(tun.incomingPacket)
-	}
-	return nil
-}
-
-func (tun *YggdrasilWireguard) MTU() (int, error) {
-	return 1420, nil
-}