From 81545fd9bfc2d05cd7144ede8e0d231c62c1668f Mon Sep 17 00:00:00 2001 From: Neil Alexander Date: Wed, 23 Jan 2019 15:16:22 +0000 Subject: [PATCH] Clean up --- src/yggdrasil/awdl.go | 3 +- src/yggdrasil/link.go | 106 ----------------------- src/yggdrasil/stream.go | 31 +------ src/yggdrasil/tcp.go | 187 +--------------------------------------- 4 files changed, 3 insertions(+), 324 deletions(-) diff --git a/src/yggdrasil/awdl.go b/src/yggdrasil/awdl.go index 8df98cc..ba3131f 100644 --- a/src/yggdrasil/awdl.go +++ b/src/yggdrasil/awdl.go @@ -54,7 +54,7 @@ func (l *awdl) create(fromAWDL chan []byte, toAWDL chan []byte, name, local, rem toAWDL: toAWDL, } s := stream{} - s.init(rwc, nil) + s.init(rwc) link, err := l.core.link.create(&s, name, "awdl", local, remote) if err != nil { return nil, err @@ -63,7 +63,6 @@ func (l *awdl) create(fromAWDL chan []byte, toAWDL chan []byte, name, local, rem link: link, rwc: rwc, } - intf.stream.init(intf.rwc, nil) l.mutex.Lock() l.interfaces[name] = &intf l.mutex.Unlock() diff --git a/src/yggdrasil/link.go b/src/yggdrasil/link.go index c056e6b..e763fb1 100644 --- a/src/yggdrasil/link.go +++ b/src/yggdrasil/link.go @@ -208,109 +208,3 @@ func (intf *linkInterface) handler() error { //////////////////////////////////////////////////////////////////////////////// return nil } - -/* -func (intf *linkInterface) start() { - myLinkPub, myLinkPriv := crypto.NewBoxKeys() - meta := version_getBaseMetadata() - meta.box = intf.link.core.boxPub - meta.sig = intf.link.core.sigPub - meta.link = *myLinkPub - metaBytes := meta.encode() - //intf.link.core.log.Println("start: intf.tolink <- metaBytes") - intf.tolink <- metaBytes - //intf.link.core.log.Println("finish: intf.tolink <- metaBytes") - //intf.link.core.log.Println("start: metaBytes = <-intf.fromlink") - metaBytes = <-intf.fromlink - //intf.link.core.log.Println("finish: metaBytes = <-intf.fromlink") - meta = version_metadata{} - if !meta.decode(metaBytes) || !meta.check() { - intf.link.core.log.Println("Metadata decode failure") - return - } - base := version_getBaseMetadata() - if meta.ver > base.ver || meta.ver == base.ver && meta.minorVer > base.minorVer { - intf.link.core.log.Println("Failed to connect to node: " + intf.name + " version: " + fmt.Sprintf("%d.%d", meta.ver, meta.minorVer)) - return - } - shared := crypto.GetSharedKey(myLinkPriv, &meta.link) - intf.peer = intf.link.core.peers.newPeer(&meta.box, &meta.sig, shared, intf.name) - if intf.peer == nil { - intf.link.mutex.Lock() - delete(intf.link.interfaces, intf.name) - intf.link.mutex.Unlock() - return - } - intf.peer.linkOut = make(chan []byte, 1) // protocol traffic - intf.peer.out = func(msg []byte) { - defer func() { recover() }() - intf.tolink <- msg - } // called by peer.sendPacket() - intf.link.core.switchTable.idleIn <- intf.peer.port // notify switch that we're idle - intf.peer.close = func() { - close(intf.fromlink) - close(intf.tolink) - } - go intf.handler() - go intf.peer.linkLoop() -} - -func (l *link) getInterface(identity string) *linkInterface { - l.mutex.RLock() - defer l.mutex.RUnlock() - if intf, ok := l.interfaces[identity]; ok { - return intf - } - return nil -} - -func (l *link) shutdown(identity string) error { - if intf, ok := l.interfaces[identity]; ok { - intf.shutdown <- true - l.core.peers.removePeer(intf.peer.port) - l.mutex.Lock() - delete(l.interfaces, identity) - l.mutex.Unlock() - return nil - } else { - return fmt.Errorf("interface '%s' doesn't exist or already shutdown", identity) - } -} - -func (ai *linkInterface) handler() { - send := func(msg []byte) { - ai.tolink <- msg - atomic.AddUint64(&ai.peer.bytesSent, uint64(len(msg))) - util.PutBytes(msg) - } - for { - timerInterval := tcp_ping_interval - timer := time.NewTimer(timerInterval) - defer timer.Stop() - select { - case p := <-ai.peer.linkOut: - send(p) - continue - default: - } - timer.Stop() - select { - case <-timer.C: - default: - } - timer.Reset(timerInterval) - select { - case _ = <-timer.C: - send([]byte{}) - case p := <-ai.peer.linkOut: - send(p) - continue - case r := <-ai.fromlink: - ai.peer.handlePacket(r) - ai.link.core.switchTable.idleIn <- ai.peer.port - case <-ai.shutdown: - return - } - } -} -*/ diff --git a/src/yggdrasil/stream.go b/src/yggdrasil/stream.go index 966319a..db2cdf7 100644 --- a/src/yggdrasil/stream.go +++ b/src/yggdrasil/stream.go @@ -14,8 +14,6 @@ var _ = linkInterfaceMsgIO(&stream{}) type stream struct { rwc io.ReadWriteCloser inputBuffer []byte // Incoming packet stream - // TODO remove the rest, it shouldn't matter in the long run - handlePacket func([]byte) } func (s *stream) close() error { @@ -26,11 +24,9 @@ const streamMsgSize = 2048 + 65535 var streamMsg = [...]byte{0xde, 0xad, 0xb1, 0x75} // "dead bits" -func (s *stream) init(rwc io.ReadWriteCloser, in func([]byte)) { +func (s *stream) init(rwc io.ReadWriteCloser) { // TODO have this also do the metadata handshake and create the peer struct s.rwc = rwc - s.handlePacket = in - // TODO call something to do the metadata exchange } @@ -112,31 +108,6 @@ func (s *stream) _recvMetaBytes() ([]byte, error) { return metaBytes, nil } -// This reads from the channel into a []byte buffer for incoming messages. It -// copies completed messages out of the cache into a new slice, and passes them -// to the peer struct via the provided `in func([]byte)` argument. Then it -// shifts the incomplete fragments of data forward so future reads won't -// overwrite it. -func (s *stream) handleInput(bs []byte) error { - if len(bs) > 0 { - s.inputBuffer = append(s.inputBuffer, bs...) - buf := s.inputBuffer - msg, ok, err2 := stream_chopMsg(&buf) - if err2 != nil { - return fmt.Errorf("message error: %v", err2) - } - if !ok { - // We didn't get the whole message yet - return nil - } - newMsg := append(util.GetBytes(), msg...) - s.inputBuffer = append(s.inputBuffer[:0], buf...) - s.handlePacket(newMsg) - util.Yield() // Make sure we give up control to the scheduler - } - return nil -} - // This takes a pointer to a slice as an argument. It checks if there's a // complete message and, if so, slices out those parts and returns the message, // true, and nil. If there's no error, but also no complete message, it returns diff --git a/src/yggdrasil/tcp.go b/src/yggdrasil/tcp.go index e1f490e..74c5ffe 100644 --- a/src/yggdrasil/tcp.go +++ b/src/yggdrasil/tcp.go @@ -20,14 +20,11 @@ import ( "math/rand" "net" "sync" - "sync/atomic" "time" "golang.org/x/net/proxy" - "github.com/yggdrasil-network/yggdrasil-go/src/address" "github.com/yggdrasil-network/yggdrasil-go/src/crypto" - "github.com/yggdrasil-network/yggdrasil-go/src/util" ) const default_timeout = 6 * time.Second @@ -284,7 +281,7 @@ func (iface *tcpInterface) handler(sock net.Conn, incoming bool) { defer sock.Close() iface.setExtraOptions(sock) stream := stream{} - stream.init(sock, nil) + stream.init(sock) local, _, _ := net.SplitHostPort(sock.LocalAddr().String()) remote, _, _ := net.SplitHostPort(sock.RemoteAddr().String()) name := "tcp://" + sock.RemoteAddr().String() @@ -297,185 +294,3 @@ func (iface *tcpInterface) handler(sock net.Conn, incoming bool) { err = link.handler() iface.core.log.Println("DEBUG: stopped handler for", name, err) } - -// This exchanges/checks connection metadata, sets up the peer struct, sets up the writer goroutine, and then runs the reader within the current goroutine. -// It defers a bunch of cleanup stuff to tear down all of these things when the reader exists (e.g. due to a closed connection or a timeout). -func (iface *tcpInterface) handler_old(sock net.Conn, incoming bool) { - defer sock.Close() - iface.setExtraOptions(sock) - // Get our keys - myLinkPub, myLinkPriv := crypto.NewBoxKeys() // ephemeral link keys - meta := version_getBaseMetadata() - meta.box = iface.core.boxPub - meta.sig = iface.core.sigPub - meta.link = *myLinkPub - metaBytes := meta.encode() - _, err := sock.Write(metaBytes) - if err != nil { - return - } - if iface.timeout > 0 { - sock.SetReadDeadline(time.Now().Add(iface.timeout)) - } - _, err = sock.Read(metaBytes) - if err != nil { - return - } - meta = version_metadata{} // Reset to zero value - if !meta.decode(metaBytes) || !meta.check() { - // Failed to decode and check the metadata - // If it's a version mismatch issue, then print an error message - base := version_getBaseMetadata() - if meta.meta == base.meta { - if meta.ver > base.ver { - iface.core.log.Println("Failed to connect to node:", sock.RemoteAddr().String(), "version:", meta.ver) - } else if meta.ver == base.ver && meta.minorVer > base.minorVer { - iface.core.log.Println("Failed to connect to node:", sock.RemoteAddr().String(), "version:", fmt.Sprintf("%d.%d", meta.ver, meta.minorVer)) - } - } - // TODO? Block forever to prevent future connection attempts? suppress future messages about the same node? - return - } - remoteAddr, _, e1 := net.SplitHostPort(sock.RemoteAddr().String()) - localAddr, _, e2 := net.SplitHostPort(sock.LocalAddr().String()) - if e1 != nil || e2 != nil { - return - } - info := tcpInfo{ // used as a map key, so don't include ephemeral link key - box: meta.box, - sig: meta.sig, - localAddr: localAddr, - remoteAddr: remoteAddr, - } - if iface.isAlreadyConnected(info) { - return - } - // Quit the parent call if this is a connection to ourself - equiv := func(k1, k2 []byte) bool { - for idx := range k1 { - if k1[idx] != k2[idx] { - return false - } - } - return true - } - if equiv(meta.box[:], iface.core.boxPub[:]) { - return - } - if equiv(meta.sig[:], iface.core.sigPub[:]) { - return - } - // Check if we're authorized to connect to this key / IP - if incoming && !iface.core.peers.isAllowedEncryptionPublicKey(&meta.box) { - // Allow unauthorized peers if they're link-local - raddrStr, _, _ := net.SplitHostPort(sock.RemoteAddr().String()) - raddr := net.ParseIP(raddrStr) - if !raddr.IsLinkLocalUnicast() { - return - } - } - // Check if we already have a connection to this node, close and block if yes - iface.mutex.Lock() - /*if blockChan, isIn := iface.conns[info]; isIn { - iface.mutex.Unlock() - sock.Close() - <-blockChan - return - }*/ - blockChan := make(chan struct{}) - iface.conns[info] = blockChan - iface.mutex.Unlock() - defer func() { - iface.mutex.Lock() - delete(iface.conns, info) - iface.mutex.Unlock() - close(blockChan) - }() - // Note that multiple connections to the same node are allowed - // E.g. over different interfaces - p := iface.core.peers.newPeer(&meta.box, &meta.sig, crypto.GetSharedKey(myLinkPriv, &meta.link), sock.RemoteAddr().String()) - p.linkOut = make(chan []byte, 1) - out := make(chan []byte, 1) - defer close(out) - go func() { - // This goroutine waits for outgoing packets, link protocol traffic, or sends idle keep-alive traffic - send := func(msg []byte) { - msgLen := wire_encode_uint64(uint64(len(msg))) - buf := net.Buffers{streamMsg[:], msgLen, msg} - buf.WriteTo(sock) - atomic.AddUint64(&p.bytesSent, uint64(len(streamMsg)+len(msgLen)+len(msg))) - util.PutBytes(msg) - } - timerInterval := tcp_ping_interval - timer := time.NewTimer(timerInterval) - defer timer.Stop() - for { - select { - case msg := <-p.linkOut: - // Always send outgoing link traffic first, if needed - send(msg) - continue - default: - } - // Otherwise wait reset the timer and wait for something to do - timer.Stop() - select { - case <-timer.C: - default: - } - timer.Reset(timerInterval) - select { - case _ = <-timer.C: - send(nil) // TCP keep-alive traffic - case msg := <-p.linkOut: - send(msg) - case msg, ok := <-out: - if !ok { - return - } - send(msg) // Block until the socket write has finished - // Now inform the switch that we're ready for more traffic - p.core.switchTable.idleIn <- p.port - } - } - }() - p.core.switchTable.idleIn <- p.port // Start in the idle state - p.out = func(msg []byte) { - defer func() { recover() }() - out <- msg - } - p.close = func() { sock.Close() } - go p.linkLoop() - defer func() { - // Put all of our cleanup here... - p.core.peers.removePeer(p.port) - }() - us, _, _ := net.SplitHostPort(sock.LocalAddr().String()) - them, _, _ := net.SplitHostPort(sock.RemoteAddr().String()) - themNodeID := crypto.GetNodeID(&meta.box) - themAddr := address.AddrForNodeID(themNodeID) - themAddrString := net.IP(themAddr[:]).String() - themString := fmt.Sprintf("%s@%s", themAddrString, them) - iface.core.log.Printf("Connected: %s, source: %s", themString, us) - //iface.stream.init(sock, p.handlePacket) - bs := make([]byte, 2*streamMsgSize) - var n int - for { - if iface.timeout > 0 { - sock.SetReadDeadline(time.Now().Add(iface.timeout)) - } - n, err = sock.Read(bs) - if err != nil { - break - } - if n > 0 { - //iface.stream.handleInput(bs[:n]) - } - } - if err == nil { - iface.core.log.Printf("Disconnected: %s, source: %s", themString, us) - } else { - iface.core.log.Printf("Disconnected: %s, source: %s, error: %s", themString, us, err) - } - return -}