convert to go module

cmd/yggdrasil/main.go

@@ -0,0 +1,295 @@
+package main
+
+import (
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"math/rand"
+	"os"
+	"os/signal"
+	"regexp"
+	"syscall"
+	"time"
+
+	"golang.org/x/text/encoding/unicode"
+
+	"github.com/kardianos/minwinsvc"
+	"github.com/mitchellh/mapstructure"
+	"github.com/neilalexander/hjson-go"
+
+	"github.com/yggdrasil-network/yggdrasil-go/src/config"
+	"github.com/yggdrasil-network/yggdrasil-go/src/defaults"
+	"github.com/yggdrasil-network/yggdrasil-go/src/yggdrasil"
+)
+
+type nodeConfig = config.NodeConfig
+type Core = yggdrasil.Core
+
+type node struct {
+	core Core
+}
+
+// Generates default configuration. This is used when outputting the -genconf
+// parameter and also when using -autoconf. The isAutoconf flag is used to
+// determine whether the operating system should select a free port by itself
+// (which guarantees that there will not be a conflict with any other services)
+// or whether to generate a random port number. The only side effect of setting
+// isAutoconf is that the TCP and UDP ports will likely end up with different
+// port numbers.
+func generateConfig(isAutoconf bool) *nodeConfig {
+	// Create a new core.
+	core := Core{}
+	// Generate encryption keys.
+	bpub, bpriv := core.NewEncryptionKeys()
+	spub, spriv := core.NewSigningKeys()
+	// Create a node configuration and populate it.
+	cfg := nodeConfig{}
+	if isAutoconf {
+		cfg.Listen = "[::]:0"
+	} else {
+		r1 := rand.New(rand.NewSource(time.Now().UnixNano()))
+		cfg.Listen = fmt.Sprintf("[::]:%d", r1.Intn(65534-32768)+32768)
+	}
+	cfg.AdminListen = defaults.GetDefaults().DefaultAdminListen
+	cfg.EncryptionPublicKey = hex.EncodeToString(bpub[:])
+	cfg.EncryptionPrivateKey = hex.EncodeToString(bpriv[:])
+	cfg.SigningPublicKey = hex.EncodeToString(spub[:])
+	cfg.SigningPrivateKey = hex.EncodeToString(spriv[:])
+	cfg.Peers = []string{}
+	cfg.InterfacePeers = map[string][]string{}
+	cfg.AllowedEncryptionPublicKeys = []string{}
+	cfg.MulticastInterfaces = []string{".*"}
+	cfg.IfName = defaults.GetDefaults().DefaultIfName
+	cfg.IfMTU = defaults.GetDefaults().DefaultIfMTU
+	cfg.IfTAPMode = defaults.GetDefaults().DefaultIfTAPMode
+	cfg.SessionFirewall.Enable = false
+	cfg.SessionFirewall.AllowFromDirect = true
+	cfg.SessionFirewall.AllowFromRemote = true
+	cfg.SwitchOptions.MaxTotalQueueSize = yggdrasil.SwitchQueueTotalMinSize
+
+	return &cfg
+}
+
+// Generates a new configuration and returns it in HJSON format. This is used
+// with -genconf.
+func doGenconf(isjson bool) string {
+	cfg := generateConfig(false)
+	var bs []byte
+	var err error
+	if isjson {
+		bs, err = json.MarshalIndent(cfg, "", "  ")
+	} else {
+		bs, err = hjson.Marshal(cfg)
+	}
+	if err != nil {
+		panic(err)
+	}
+	return string(bs)
+}
+
+// The main function is responsible for configuring and starting Yggdrasil.
+func main() {
+	// Configure the command line parameters.
+	genconf := flag.Bool("genconf", false, "print a new config to stdout")
+	useconf := flag.Bool("useconf", false, "read HJSON/JSON config from stdin")
+	useconffile := flag.String("useconffile", "", "read HJSON/JSON config from specified file path")
+	normaliseconf := flag.Bool("normaliseconf", false, "use in combination with either -useconf or -useconffile, outputs your configuration normalised")
+	confjson := flag.Bool("json", false, "print configuration from -genconf or -normaliseconf as JSON instead of HJSON")
+	autoconf := flag.Bool("autoconf", false, "automatic mode (dynamic IP, peer with IPv6 neighbors)")
+	version := flag.Bool("version", false, "prints the version of this build")
+	flag.Parse()
+
+	var cfg *nodeConfig
+	switch {
+	case *version:
+		fmt.Println("Build name:", yggdrasil.GetBuildName())
+		fmt.Println("Build version:", yggdrasil.GetBuildVersion())
+		os.Exit(0)
+	case *autoconf:
+		// Use an autoconf-generated config, this will give us random keys and
+		// port numbers, and will use an automatically selected TUN/TAP interface.
+		cfg = generateConfig(true)
+	case *useconffile != "" || *useconf:
+		// Use a configuration file. If -useconf, the configuration will be read
+		// from stdin. If -useconffile, the configuration will be read from the
+		// filesystem.
+		var config []byte
+		var err error
+		if *useconffile != "" {
+			// Read the file from the filesystem
+			config, err = ioutil.ReadFile(*useconffile)
+		} else {
+			// Read the file from stdin.
+			config, err = ioutil.ReadAll(os.Stdin)
+		}
+		if err != nil {
+			panic(err)
+		}
+		// If there's a byte order mark - which Windows 10 is now incredibly fond of
+		// throwing everywhere when it's converting things into UTF-16 for the hell
+		// of it - remove it and decode back down into UTF-8. This is necessary
+		// because hjson doesn't know what to do with UTF-16 and will panic
+		if bytes.Compare(config[0:2], []byte{0xFF, 0xFE}) == 0 ||
+			bytes.Compare(config[0:2], []byte{0xFE, 0xFF}) == 0 {
+			utf := unicode.UTF16(unicode.BigEndian, unicode.UseBOM)
+			decoder := utf.NewDecoder()
+			config, err = decoder.Bytes(config)
+			if err != nil {
+				panic(err)
+			}
+		}
+		// Generate a new configuration - this gives us a set of sane defaults -
+		// then parse the configuration we loaded above on top of it. The effect
+		// of this is that any configuration item that is missing from the provided
+		// configuration will use a sane default.
+		cfg = generateConfig(false)
+		var dat map[string]interface{}
+		if err := hjson.Unmarshal(config, &dat); err != nil {
+			panic(err)
+		}
+		confJson, err := json.Marshal(dat)
+		if err != nil {
+			panic(err)
+		}
+		json.Unmarshal(confJson, &cfg)
+		// For now we will do a little bit to help the user adjust their
+		// configuration to match the new configuration format, as some of the key
+		// names have changed recently.
+		changes := map[string]string{
+			"Multicast":      "",
+			"LinkLocal":      "MulticastInterfaces",
+			"BoxPub":         "EncryptionPublicKey",
+			"BoxPriv":        "EncryptionPrivateKey",
+			"SigPub":         "SigningPublicKey",
+			"SigPriv":        "SigningPrivateKey",
+			"AllowedBoxPubs": "AllowedEncryptionPublicKeys",
+		}
+		// Loop over the mappings aove and see if we have anything to fix.
+		for from, to := range changes {
+			if _, ok := dat[from]; ok {
+				if to == "" {
+					if !*normaliseconf {
+						log.Println("Warning: Deprecated config option", from, "- please remove")
+					}
+				} else {
+					if !*normaliseconf {
+						log.Println("Warning: Deprecated config option", from, "- please rename to", to)
+					}
+					// If the configuration file doesn't already contain a line with the
+					// new name then set it to the old value. This makes sure that we
+					// don't overwrite something that was put there intentionally.
+					if _, ok := dat[to]; !ok {
+						dat[to] = dat[from]
+					}
+				}
+			}
+		}
+		// Overlay our newly mapped configuration onto the autoconf node config that
+		// we generated above.
+		if err = mapstructure.Decode(dat, &cfg); err != nil {
+			panic(err)
+		}
+		// If the -normaliseconf option was specified then remarshal the above
+		// configuration and print it back to stdout. This lets the user update
+		// their configuration file with newly mapped names (like above) or to
+		// convert from plain JSON to commented HJSON.
+		if *normaliseconf {
+			var bs []byte
+			if *confjson {
+				bs, err = json.MarshalIndent(cfg, "", "  ")
+			} else {
+				bs, err = hjson.Marshal(cfg)
+			}
+			if err != nil {
+				panic(err)
+			}
+			fmt.Println(string(bs))
+			return
+		}
+	case *genconf:
+		// Generate a new configuration and print it to stdout.
+		fmt.Println(doGenconf(*confjson))
+	default:
+		// No flags were provided, therefore print the list of flags to stdout.
+		flag.PrintDefaults()
+	}
+	// Have we got a working configuration? If we don't then it probably means
+	// that neither -autoconf, -useconf or -useconffile were set above. Stop
+	// if we don't.
+	if cfg == nil {
+		return
+	}
+	// Create a new logger that logs output to stdout.
+	logger := log.New(os.Stdout, "", log.Flags())
+	// Setup the Yggdrasil node itself. The node{} type includes a Core, so we
+	// don't need to create this manually.
+	n := node{}
+	// Check to see if any multicast interface expressions were provided in the
+	// config. If they were then set them now.
+	for _, ll := range cfg.MulticastInterfaces {
+		ifceExpr, err := regexp.Compile(ll)
+		if err != nil {
+			panic(err)
+		}
+		n.core.AddMulticastInterfaceExpr(ifceExpr)
+	}
+	// Now that we have a working configuration, we can now actually start
+	// Yggdrasil. This will start the router, switch, DHT node, TCP and UDP
+	// sockets, TUN/TAP adapter and multicast discovery port.
+	if err := n.core.Start(cfg, logger); err != nil {
+		logger.Println("An error occurred during startup")
+		panic(err)
+	}
+	// Check to see if any allowed encryption keys were provided in the config.
+	// If they were then set them now.
+	for _, pBoxStr := range cfg.AllowedEncryptionPublicKeys {
+		n.core.AddAllowedEncryptionPublicKey(pBoxStr)
+	}
+	// If any static peers were provided in the configuration above then we should
+	// configure them. The loop ensures that disconnected peers will eventually
+	// be reconnected with.
+	go func() {
+		if len(cfg.Peers) == 0 && len(cfg.InterfacePeers) == 0 {
+			return
+		}
+		for {
+			for _, peer := range cfg.Peers {
+				n.core.AddPeer(peer, "")
+				time.Sleep(time.Second)
+			}
+			for intf, intfpeers := range cfg.InterfacePeers {
+				for _, peer := range intfpeers {
+					n.core.AddPeer(peer, intf)
+					time.Sleep(time.Second)
+				}
+			}
+			time.Sleep(time.Minute)
+		}
+	}()
+	// The Stop function ensures that the TUN/TAP adapter is correctly shut down
+	// before the program exits.
+	defer func() {
+		n.core.Stop()
+	}()
+	// Make some nice output that tells us what our IPv6 address and subnet are.
+	// This is just logged to stdout for the user.
+	address := n.core.GetAddress()
+	subnet := n.core.GetSubnet()
+	logger.Printf("Your IPv6 address is %s", address.String())
+	logger.Printf("Your IPv6 subnet is %s", subnet.String())
+	// Catch interrupts from the operating system to exit gracefully.
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	// Create a function to capture the service being stopped on Windows.
+	winTerminate := func() {
+		c <- os.Interrupt
+	}
+	minwinsvc.SetOnExit(winTerminate)
+	// Wait for the terminate/interrupt signal. Once a signal is received, the
+	// deferred Stop function above will run which will shut down TUN/TAP.
+	<-c
+}

cmd/yggdrasilctl/main.go

@@ -0,0 +1,332 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"net"
+	"net/url"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/yggdrasil-network/yggdrasil-go/src/defaults"
+)
+
+type admin_info map[string]interface{}
+
+func main() {
+	server := flag.String("endpoint", defaults.GetDefaults().DefaultAdminListen, "Admin socket endpoint")
+	injson := flag.Bool("json", false, "Output in JSON format")
+	verbose := flag.Bool("v", false, "Verbose output (includes public keys)")
+	flag.Parse()
+	args := flag.Args()
+
+	if len(args) == 0 {
+		fmt.Println("usage:", os.Args[0], "[-endpoint=proto://server] [-v] [-json] command [key=value] [...]")
+		fmt.Println("example:", os.Args[0], "getPeers")
+		fmt.Println("example:", os.Args[0], "setTunTap name=auto mtu=1500 tap_mode=false")
+		fmt.Println("example:", os.Args[0], "-endpoint=tcp://localhost:9001 getDHT")
+		fmt.Println("example:", os.Args[0], "-endpoint=unix:///var/run/ygg.sock getDHT")
+		return
+	}
+
+	var conn net.Conn
+	u, err := url.Parse(*server)
+	if err == nil {
+		switch strings.ToLower(u.Scheme) {
+		case "unix":
+			conn, err = net.Dial("unix", (*server)[7:])
+		case "tcp":
+			conn, err = net.Dial("tcp", u.Host)
+		default:
+			err = errors.New("protocol not supported")
+		}
+	} else {
+		conn, err = net.Dial("tcp", *server)
+	}
+	if err != nil {
+		panic(err)
+	}
+	defer conn.Close()
+
+	decoder := json.NewDecoder(conn)
+	encoder := json.NewEncoder(conn)
+	send := make(admin_info)
+	recv := make(admin_info)
+
+	for c, a := range args {
+		if c == 0 {
+			send["request"] = a
+			continue
+		}
+		tokens := strings.Split(a, "=")
+		if i, err := strconv.Atoi(tokens[1]); err == nil {
+			send[tokens[0]] = i
+		} else {
+			switch strings.ToLower(tokens[1]) {
+			case "true":
+				send[tokens[0]] = true
+			case "false":
+				send[tokens[0]] = false
+			default:
+				send[tokens[0]] = tokens[1]
+			}
+		}
+	}
+
+	if err := encoder.Encode(&send); err != nil {
+		panic(err)
+	}
+	if err := decoder.Decode(&recv); err == nil {
+		if recv["status"] == "error" {
+			if err, ok := recv["error"]; ok {
+				fmt.Println("Error:", err)
+			} else {
+				fmt.Println("Unspecified error occured")
+			}
+			os.Exit(1)
+		}
+		if _, ok := recv["request"]; !ok {
+			fmt.Println("Missing request in response (malformed response?)")
+			return
+		}
+		if _, ok := recv["response"]; !ok {
+			fmt.Println("Missing response body (malformed response?)")
+			return
+		}
+		req := recv["request"].(map[string]interface{})
+		res := recv["response"].(map[string]interface{})
+
+		if *injson {
+			if json, err := json.MarshalIndent(res, "", "  "); err == nil {
+				fmt.Println(string(json))
+			}
+			os.Exit(0)
+		}
+
+		switch strings.ToLower(req["request"].(string)) {
+		case "dot":
+			fmt.Println(res["dot"])
+		case "list", "getpeers", "getswitchpeers", "getdht", "getsessions", "dhtping":
+			maxWidths := make(map[string]int)
+			var keyOrder []string
+			keysOrdered := false
+
+			for _, tlv := range res {
+				for slk, slv := range tlv.(map[string]interface{}) {
+					if !keysOrdered {
+						for k := range slv.(map[string]interface{}) {
+							if !*verbose {
+								if k == "box_pub_key" || k == "box_sig_key" {
+									continue
+								}
+							}
+							keyOrder = append(keyOrder, fmt.Sprint(k))
+						}
+						sort.Strings(keyOrder)
+						keysOrdered = true
+					}
+					for k, v := range slv.(map[string]interface{}) {
+						if len(fmt.Sprint(slk)) > maxWidths["key"] {
+							maxWidths["key"] = len(fmt.Sprint(slk))
+						}
+						if len(fmt.Sprint(v)) > maxWidths[k] {
+							maxWidths[k] = len(fmt.Sprint(v))
+							if maxWidths[k] < len(k) {
+								maxWidths[k] = len(k)
+							}
+						}
+					}
+				}
+
+				if len(keyOrder) > 0 {
+					fmt.Printf("%-"+fmt.Sprint(maxWidths["key"])+"s  ", "")
+					for _, v := range keyOrder {
+						fmt.Printf("%-"+fmt.Sprint(maxWidths[v])+"s  ", v)
+					}
+					fmt.Println()
+				}
+
+				for slk, slv := range tlv.(map[string]interface{}) {
+					fmt.Printf("%-"+fmt.Sprint(maxWidths["key"])+"s  ", slk)
+					for _, k := range keyOrder {
+						preformatted := slv.(map[string]interface{})[k]
+						var formatted string
+						switch k {
+						case "bytes_sent", "bytes_recvd":
+							formatted = fmt.Sprintf("%d", uint(preformatted.(float64)))
+						case "uptime", "last_seen":
+							seconds := uint(preformatted.(float64)) % 60
+							minutes := uint(preformatted.(float64)/60) % 60
+							hours := uint(preformatted.(float64) / 60 / 60)
+							formatted = fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
+						default:
+							formatted = fmt.Sprint(preformatted)
+						}
+						fmt.Printf("%-"+fmt.Sprint(maxWidths[k])+"s  ", formatted)
+					}
+					fmt.Println()
+				}
+			}
+		case "gettuntap", "settuntap":
+			for k, v := range res {
+				fmt.Println("Interface name:", k)
+				if mtu, ok := v.(map[string]interface{})["mtu"].(float64); ok {
+					fmt.Println("Interface MTU:", mtu)
+				}
+				if tap_mode, ok := v.(map[string]interface{})["tap_mode"].(bool); ok {
+					fmt.Println("TAP mode:", tap_mode)
+				}
+			}
+		case "getself":
+			for k, v := range res["self"].(map[string]interface{}) {
+				if buildname, ok := v.(map[string]interface{})["build_name"].(string); ok {
+					fmt.Println("Build name:", buildname)
+				}
+				if buildversion, ok := v.(map[string]interface{})["build_version"].(string); ok {
+					fmt.Println("Build version:", buildversion)
+				}
+				fmt.Println("IPv6 address:", k)
+				if subnet, ok := v.(map[string]interface{})["subnet"].(string); ok {
+					fmt.Println("IPv6 subnet:", subnet)
+				}
+				if coords, ok := v.(map[string]interface{})["coords"].(string); ok {
+					fmt.Println("Coords:", coords)
+				}
+				if *verbose {
+					if boxPubKey, ok := v.(map[string]interface{})["box_pub_key"].(string); ok {
+						fmt.Println("Public encryption key:", boxPubKey)
+					}
+					if boxSigKey, ok := v.(map[string]interface{})["box_sig_key"].(string); ok {
+						fmt.Println("Public signing key:", boxSigKey)
+					}
+				}
+			}
+		case "getswitchqueues":
+			maximumqueuesize := float64(4194304)
+			portqueues := make(map[float64]float64)
+			portqueuesize := make(map[float64]float64)
+			portqueuepackets := make(map[float64]float64)
+			v := res["switchqueues"].(map[string]interface{})
+			if queuecount, ok := v["queues_count"].(float64); ok {
+				fmt.Printf("Active queue count: %d queues\n", uint(queuecount))
+			}
+			if queuesize, ok := v["queues_size"].(float64); ok {
+				fmt.Printf("Active queue size: %d bytes\n", uint(queuesize))
+			}
+			if highestqueuecount, ok := v["highest_queues_count"].(float64); ok {
+				fmt.Printf("Highest queue count: %d queues\n", uint(highestqueuecount))
+			}
+			if highestqueuesize, ok := v["highest_queues_size"].(float64); ok {
+				fmt.Printf("Highest queue size: %d bytes\n", uint(highestqueuesize))
+			}
+			if m, ok := v["maximum_queues_size"].(float64); ok {
+				maximumqueuesize = m
+				fmt.Printf("Maximum queue size: %d bytes\n", uint(maximumqueuesize))
+			}
+			if queues, ok := v["queues"].([]interface{}); ok {
+				if len(queues) != 0 {
+					fmt.Println("Active queues:")
+					for _, v := range queues {
+						queueport := v.(map[string]interface{})["queue_port"].(float64)
+						queuesize := v.(map[string]interface{})["queue_size"].(float64)
+						queuepackets := v.(map[string]interface{})["queue_packets"].(float64)
+						queueid := v.(map[string]interface{})["queue_id"].(string)
+						portqueues[queueport] += 1
+						portqueuesize[queueport] += queuesize
+						portqueuepackets[queueport] += queuepackets
+						queuesizepercent := (100 / maximumqueuesize) * queuesize
+						fmt.Printf("- Switch port %d, Stream ID: %v, size: %d bytes (%d%% full), %d packets\n",
+							uint(queueport), []byte(queueid), uint(queuesize),
+							uint(queuesizepercent), uint(queuepackets))
+					}
+				}
+			}
+			if len(portqueuesize) > 0 && len(portqueuepackets) > 0 {
+				fmt.Println("Aggregated statistics by switchport:")
+				for k, v := range portqueuesize {
+					queuesizepercent := (100 / (portqueues[k] * maximumqueuesize)) * v
+					fmt.Printf("- Switch port %d, size: %d bytes (%d%% full), %d packets\n",
+						uint(k), uint(v), uint(queuesizepercent), uint(portqueuepackets[k]))
+				}
+			}
+		case "addpeer", "removepeer", "addallowedencryptionpublickey", "removeallowedencryptionpublickey", "addsourcesubnet", "addroute", "removesourcesubnet", "removeroute":
+			if _, ok := res["added"]; ok {
+				for _, v := range res["added"].([]interface{}) {
+					fmt.Println("Added:", fmt.Sprint(v))
+				}
+			}
+			if _, ok := res["not_added"]; ok {
+				for _, v := range res["not_added"].([]interface{}) {
+					fmt.Println("Not added:", fmt.Sprint(v))
+				}
+			}
+			if _, ok := res["removed"]; ok {
+				for _, v := range res["removed"].([]interface{}) {
+					fmt.Println("Removed:", fmt.Sprint(v))
+				}
+			}
+			if _, ok := res["not_removed"]; ok {
+				for _, v := range res["not_removed"].([]interface{}) {
+					fmt.Println("Not removed:", fmt.Sprint(v))
+				}
+			}
+		case "getallowedencryptionpublickeys":
+			if _, ok := res["allowed_box_pubs"]; !ok {
+				fmt.Println("All connections are allowed")
+			} else if res["allowed_box_pubs"] == nil {
+				fmt.Println("All connections are allowed")
+			} else {
+				fmt.Println("Connections are allowed only from the following public box keys:")
+				for _, v := range res["allowed_box_pubs"].([]interface{}) {
+					fmt.Println("-", v)
+				}
+			}
+		case "getmulticastinterfaces":
+			if _, ok := res["multicast_interfaces"]; !ok {
+				fmt.Println("No multicast interfaces found")
+			} else if res["multicast_interfaces"] == nil {
+				fmt.Println("No multicast interfaces found")
+			} else {
+				fmt.Println("Multicast peer discovery is active on:")
+				for _, v := range res["multicast_interfaces"].([]interface{}) {
+					fmt.Println("-", v)
+				}
+			}
+		case "getsourcesubnets":
+			if _, ok := res["source_subnets"]; !ok {
+				fmt.Println("No source subnets found")
+			} else if res["source_subnets"] == nil {
+				fmt.Println("No source subnets found")
+			} else {
+				fmt.Println("Source subnets:")
+				for _, v := range res["source_subnets"].([]interface{}) {
+					fmt.Println("-", v)
+				}
+			}
+		case "getroutes":
+			if _, ok := res["routes"]; !ok {
+				fmt.Println("No routes found")
+			} else if res["routes"] == nil {
+				fmt.Println("No routes found")
+			} else {
+				fmt.Println("Routes:")
+				for _, v := range res["routes"].([]interface{}) {
+					fmt.Println("-", v)
+				}
+			}
+		default:
+			if json, err := json.MarshalIndent(recv["response"], "", "  "); err == nil {
+				fmt.Println(string(json))
+			}
+		}
+	}
+
+	if v, ok := recv["status"]; ok && v == "error" {
+		os.Exit(1)
+	}
+	os.Exit(0)
+}