No calls to debug.go from yggdrasil.go

src/yggdrasil/admin.go

@@ -215,8 +215,9 @@ func (a *admin) init(c *Core, listenaddr string) {
 	})
 }
 
-func (a *admin) start() {
+func (a *admin) start() error {
 	go a.listen()
+	return nil
 }
 
 func (a *admin) listen() {

src/yggdrasil/core.go

@@ -1,6 +1,6 @@
 package yggdrasil
 
-import "io/ioutil"
+// import "io/ioutil"
 import "log"
 import "regexp"
 import "net"
@@ -35,29 +35,6 @@ func (c *Core) Init() {
 	c.init(bpub, bpriv, spub, spriv)
 }
 
-func (c *Core) Run(nc *config.NodeConfig) {
-	var boxPub boxPubKey
-   	var boxPriv boxPrivKey
-   	var sigPub sigPubKey
-   	var sigPriv sigPrivKey
-   	copy(boxPub[:], nc.EncryptionPublicKey)
-   	copy(boxPriv[:], nc.EncryptionPrivateKey)
-   	copy(sigPub[:], nc.SigningPublicKey)
-   	copy(sigPriv[:], nc.SigningPrivateKey)
-
-   	c.init(&boxPub, &boxPriv, &sigPub, &sigPriv)
-
-	c.udp.init(c, nc.Listen)
-	c.tcp.init(c, nc.Listen)
-	c.admin.init(c, nc.AdminListen)
-
-	c.multicast.start()
-	c.router.start()
-	c.switchTable.start()
-	c.tun.setup(nc.IfName, nc.IfTAPMode, net.IP(c.router.addr[:]).String(), nc.IfMTU)
-	c.admin.start()
-}
-
 func (c *Core) init(bpub *boxPubKey,
 	bpriv *boxPrivKey,
 	spub *sigPubKey,
@@ -67,7 +44,7 @@ func (c *Core) init(bpub *boxPubKey,
 	//  Start launches goroutines that depend on structs being set up
 	// This is pretty much required to completely avoid race conditions
 	util_initByteStore()
-	c.log = log.New(ioutil.Discard, "", 0)
+	// c.log = log.New(ioutil.Discard, "", 0)
 	c.boxPub, c.boxPriv = *bpub, *bpriv
 	c.sigPub, c.sigPriv = *spub, *spriv
 	c.admin.core = c
@@ -82,6 +59,79 @@ func (c *Core) init(bpub *boxPubKey,
 	c.tun.init(c)
 }
 
+func (c *Core) Start(nc *config.NodeConfig, log *log.Logger) error {
+	c.log = log
+	c.log.Println("Starting up...")
+
+	udp := udpInterface{}
+	if err := udp.init(c, nc.Listen); err != nil {
+		c.log.Println("Failed to start UDP interface")
+		return err
+	}
+	c.udp = &udp
+
+	tcp := tcpInterface{}
+	if err := tcp.init(c, nc.Listen); err != nil {
+		c.log.Println("Failed to start TCP interface")
+		return err
+	}
+	c.tcp = &tcp
+
+	var boxPub boxPubKey
+	var boxPriv boxPrivKey
+	var sigPub sigPubKey
+	var sigPriv sigPrivKey
+	copy(boxPub[:], nc.EncryptionPublicKey)
+	copy(boxPriv[:], nc.EncryptionPrivateKey)
+	copy(sigPub[:], nc.SigningPublicKey)
+	copy(sigPriv[:], nc.SigningPrivateKey)
+
+	c.init(&boxPub, &boxPriv, &sigPub, &sigPriv)
+	c.admin.init(c, nc.AdminListen)
+
+	if err := c.router.start(); err != nil {
+		c.log.Println("Failed to start router")
+		return err
+	}
+
+	if err := c.switchTable.start(); err != nil {
+		c.log.Println("Failed to start switch table ticker")
+		return err
+	}
+
+	if err := c.tun.setup(nc.IfName, nc.IfTAPMode, net.IP(c.router.addr[:]).String(), nc.IfMTU); err != nil {
+		c.log.Println("Failed to start TUN/TAP")
+		return err
+	}
+
+	if err := c.admin.start(); err != nil {
+		c.log.Println("Failed to start admin socket")
+		return err
+	}
+
+	if err := c.multicast.start(); err != nil {
+		c.log.Println("Failed to start multicast interface")
+		return err
+	}
+
+	c.log.Println("Startup complete")
+	return nil
+}
+
+func (c *Core) Stop() {
+	c.log.Println("Stopping...")
+	c.tun.close()
+	c.log.Println("Goodbye!")
+}
+
+func (c *Core) NewEncryptionKeys() (*boxPubKey, *boxPrivKey) {
+	return newBoxKeys()
+}
+
+func (c *Core) NewSigningKeys() (*sigPubKey, *sigPrivKey) {
+	return newSigKeys()
+}
+
 func (c *Core) GetNodeID() *NodeID {
 	return getNodeID(&c.boxPub)
 }
@@ -97,3 +147,43 @@ func (c *Core) GetAddress() *address {
 func (c *Core) GetSubnet() *subnet {
 	return address_subnetForNodeID(c.GetNodeID())
 }
+
+func (c *Core) SetLogger(log *log.Logger) {
+	c.log = log
+}
+
+func (c *Core) AddPeer(addr string) error {
+	return c.admin.addPeer(addr)
+}
+
+func (c *Core) AddMulticastInterfaceExpr(expr *regexp.Regexp) {
+	c.ifceExpr = append(c.ifceExpr, expr)
+}
+
+func (c *Core) AddAllowedEncryptionPublicKey(boxStr string) error {
+	return c.admin.addAllowedEncryptionPublicKey(boxStr)
+}
+
+func (c *Core) GetTUNDefaultIfName() string {
+	return getDefaults().defaultIfName
+}
+
+func (c *Core) GetTUNDefaultIfMTU() int {
+	return getDefaults().defaultIfMTU
+}
+
+func (c *Core) GetTUNMaximumIfMTU() int {
+	return getDefaults().maximumIfMTU
+}
+
+func (c *Core) GetTUNDefaultIfTAPMode() bool {
+	return getDefaults().defaultIfTAPMode
+}
+
+func (c *Core) GetTUNIfName() string {
+	return c.tun.iface.Name()
+}
+
+func (c *Core) GetTUNIfMTU() int {
+	return c.tun.mtu
+}

src/yggdrasil/multicast.go

@@ -44,19 +44,19 @@ func (m *multicast) init(core *Core) {
 	m.core.log.Println("Found", len(m.interfaces), "multicast interface(s)")
 }
 
-func (m *multicast) start() {
+func (m *multicast) start() error {
 	if len(m.core.ifceExpr) == 0 {
 		m.core.log.Println("Multicast discovery is disabled")
 	} else {
 		m.core.log.Println("Multicast discovery is enabled")
 		addr, err := net.ResolveUDPAddr("udp", m.groupAddr)
 		if err != nil {
-			panic(err)
+			return err
 		}
 		listenString := fmt.Sprintf("[::]:%v", addr.Port)
 		conn, err := net.ListenPacket("udp6", listenString)
 		if err != nil {
-			panic(err)
+			return err
 		}
 		//defer conn.Close() // Let it close on its own when the application exits
 		m.sock = ipv6.NewPacketConn(conn)
@@ -68,6 +68,7 @@ func (m *multicast) start() {
 		go m.listen()
 		go m.announce()
 	}
+	return nil
 }
 
 func (m *multicast) announce() {
@@ -76,7 +77,7 @@ func (m *multicast) announce() {
 		panic(err)
 	}
 	var anAddr net.TCPAddr
-	myAddr := m.core.DEBUG_getGlobalTCPAddr()
+	myAddr := m.core.tcp.getAddr()
 	anAddr.Port = myAddr.Port
 	destAddr, err := net.ResolveUDPAddr("udp6", m.groupAddr)
 	if err != nil {

src/yggdrasil/router.go

@@ -67,8 +67,10 @@ func (r *router) init(core *Core) {
 	// go r.mainLoop()
 }
 
-func (r *router) start() {
+func (r *router) start() error {
+	r.core.log.Println("Starting router")
 	go r.mainLoop()
+	return nil
 }
 
 func (r *router) mainLoop() {

src/yggdrasil/switch.go

@@ -169,7 +169,7 @@ func (t *switchTable) init(core *Core, key sigPubKey) {
 	t.drop = make(map[sigPubKey]int64)
 }
 
-func (t *switchTable) start() {
+func (t *switchTable) start() error {
 	doTicker := func() {
 		ticker := time.NewTicker(time.Second)
 		defer ticker.Stop()
@@ -179,6 +179,7 @@ func (t *switchTable) start() {
 		}
 	}
 	go doTicker()
+	return nil
 }
 
 func (t *switchTable) getLocator() switchLocator {

src/yggdrasil/tcp.go

@@ -42,6 +42,10 @@ type tcpInfo struct {
 	remoteAddr string
 }
 
+func (iface *tcpInterface) getAddr() *net.TCPAddr {
+	return iface.serv.Addr().(*net.TCPAddr)
+}
+
 func (iface *tcpInterface) init(core *Core, addr string) (err error) {
 	iface.core = core
 
@@ -51,7 +55,8 @@ func (iface *tcpInterface) init(core *Core, addr string) (err error) {
 		iface.conns = make(map[tcpInfo](chan struct{}))
 		go iface.listener()
 	}
-	return
+
+	return err
 }
 
 func (iface *tcpInterface) listener() {

src/yggdrasil/udp.go

@@ -65,18 +65,25 @@ type udpKeys struct {
 	sig sigPubKey
 }
 
-func (iface *udpInterface) init(core *Core, addr string) {
+func (iface *udpInterface) getAddr() *net.UDPAddr {
+	return iface.sock.LocalAddr().(*net.UDPAddr)
+}
+
+func (iface *udpInterface) init(core *Core, addr string) error {
 	iface.core = core
 	udpAddr, err := net.ResolveUDPAddr("udp", addr)
 	if err != nil {
-		panic(err)
+		return err
+		//panic(err)
 	}
 	iface.sock, err = net.ListenUDP("udp", udpAddr)
 	if err != nil {
-		panic(err)
+		return err
+		//	panic(err)
 	}
 	iface.conns = make(map[connAddr]*connInfo)
 	go iface.reader()
+	return nil
 }
 
 func (iface *udpInterface) sendKeys(addr connAddr) {