254 lines
7.5 KiB
Go
Raw Normal View History

2017-12-28 22:16:20 -06:00
package yggdrasil
// This part does most of the work to handle packets to/from yourself
// It also manages crypto and dht info
// TODO clean up old/unused code, maybe improve comments on whatever is left
2017-12-28 22:16:20 -06:00
// Send:
2019-03-28 19:09:19 +00:00
// Receive a packet from the adapter
2017-12-28 22:16:20 -06:00
// Look up session (if none exists, trigger a search)
// Hand off to session (which encrypts, etc)
// Session will pass it back to router.out, which hands it off to the self peer
// The self peer triggers a lookup to find which peer to send to next
// And then passes it to that's peer's peer.out function
// The peer.out function sends it over the wire to the matching peer
// Recv:
// A packet comes in off the wire, and goes to a peer.handlePacket
// The peer does a lookup, sees no better peer than the self
// Hands it to the self peer.out, which passes it to router.in
// If it's dht/seach/etc. traffic, the router passes it to that part
// If it's an encapsulated IPv6 packet, the router looks up the session for it
// The packet is passed to the session, which decrypts it, router.recvPacket
2019-03-28 19:09:19 +00:00
// The router then runs some sanity checks before passing it to the adapter
2017-12-28 22:16:20 -06:00
2018-06-12 17:50:08 -05:00
import (
//"bytes"
2019-04-22 23:12:13 +01:00
2018-06-12 17:50:08 -05:00
"time"
2018-01-04 22:37:51 +00:00
"github.com/yggdrasil-network/yggdrasil-go/src/address"
"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
"github.com/yggdrasil-network/yggdrasil-go/src/util"
2019-08-23 18:47:15 -05:00
"github.com/Arceliar/phony"
2018-06-12 17:50:08 -05:00
)
2017-12-28 22:16:20 -06:00
2019-03-28 19:09:19 +00:00
// The router struct has channels to/from the adapter device and a self peer (0), which is how messages are passed between this node and the peers/switch layer.
// The router's phony.Inbox goroutine is responsible for managing all information related to the dht, searches, and crypto sessions.
2017-12-28 22:16:20 -06:00
type router struct {
phony.Inbox
core *Core
addr address.Address
subnet address.Subnet
out func([]byte) // packets we're sending to the network, link to peer's "in"
dht dht
nodeinfo nodeinfo
searches searches
sessions sessions
}
2019-03-28 19:09:19 +00:00
// Initializes the router struct, which includes setting up channels to/from the adapter.
2017-12-28 22:16:20 -06:00
func (r *router) init(core *Core) {
2018-01-04 22:37:51 +00:00
r.core = core
r.addr = *address.AddrForNodeID(&r.dht.nodeID)
r.subnet = *address.SubnetForNodeID(&r.dht.nodeID)
self := linkInterface{
name: "(self)",
info: linkInfo{
local: "(self)",
remote: "(self)",
linkType: "self",
},
}
p := r.core.peers.newPeer(&r.core.boxPub, &r.core.sigPub, &crypto.BoxSharedKey{}, &self, nil)
2019-08-24 12:55:49 -05:00
p.out = func(packets [][]byte) { r.handlePackets(p, packets) }
r.out = func(bs []byte) { p.handlePacketFrom(r, bs) }
2019-01-16 13:23:26 +00:00
r.nodeinfo.init(r.core)
r.core.config.Mutex.RLock()
r.nodeinfo.setNodeInfo(r.core.config.Current.NodeInfo, r.core.config.Current.NodeInfoPrivacy)
r.core.config.Mutex.RUnlock()
r.dht.init(r)
r.searches.init(r)
r.sessions.init(r)
2018-05-27 22:13:37 +01:00
}
2019-08-28 19:31:04 +01:00
// Reconfigures the router and any child modules. This should only ever be run
// by the router actor.
func (r *router) reconfigure() {
// Reconfigure the router
current := r.core.config.GetCurrent()
2019-08-28 19:31:04 +01:00
if err := r.nodeinfo.setNodeInfo(current.NodeInfo, current.NodeInfoPrivacy); err != nil {
r.core.log.Errorln("Error reloading NodeInfo:", err)
} else {
r.core.log.Infoln("NodeInfo updated")
}
2019-08-28 19:31:04 +01:00
// Reconfigure children
r.dht.reconfigure()
r.searches.reconfigure()
r.sessions.reconfigure()
}
// Starts the tickerLoop goroutine.
2018-05-27 22:13:37 +01:00
func (r *router) start() error {
r.core.log.Infoln("Starting router")
go r.doMaintenance()
2018-05-27 22:13:37 +01:00
return nil
2017-12-28 22:16:20 -06:00
}
2019-08-23 18:47:15 -05:00
// In practice, the switch will call this with 1 packet
func (r *router) handlePackets(from phony.Actor, packets [][]byte) {
r.Act(from, func() {
2019-08-23 18:47:15 -05:00
for _, packet := range packets {
r._handlePacket(packet)
2019-08-23 18:47:15 -05:00
}
})
}
// Insert a peer info into the dht, TODO? make the dht a separate actor
func (r *router) insertPeer(from phony.Actor, info *dhtInfo) {
r.Act(from, func() {
r.dht.insertPeer(info)
2019-08-23 18:47:15 -05:00
})
}
// Reset sessions and DHT after the switch sees our coords change
func (r *router) reset(from phony.Actor) {
r.Act(from, func() {
r.sessions.reset()
r.dht.reset()
2019-08-23 18:47:15 -05:00
})
}
// TODO remove reconfigure so this is just a ticker loop
// and then find something better than a ticker loop to schedule things...
func (r *router) doMaintenance() {
phony.Block(r, func() {
// Any periodic maintenance stuff goes here
r.core.switchTable.doMaintenance()
r.dht.doMaintenance()
r.sessions.cleanup()
})
time.AfterFunc(time.Second, r.doMaintenance)
2017-12-28 22:16:20 -06:00
}
// Checks incoming traffic type and passes it to the appropriate handler.
func (r *router) _handlePacket(packet []byte) {
2018-01-04 22:37:51 +00:00
pType, pTypeLen := wire_decode_uint64(packet)
if pTypeLen == 0 {
return
}
switch pType {
case wire_Traffic:
r._handleTraffic(packet)
2018-01-04 22:37:51 +00:00
case wire_ProtocolTraffic:
r._handleProto(packet)
2018-06-12 17:50:08 -05:00
default:
2018-01-04 22:37:51 +00:00
}
2017-12-28 22:16:20 -06:00
}
// Handles incoming traffic, i.e. encapuslated ordinary IPv6 packets.
2019-03-28 19:09:19 +00:00
// Passes them to the crypto session worker to be decrypted and sent to the adapter.
func (r *router) _handleTraffic(packet []byte) {
defer util.PutBytes(packet)
2018-01-04 22:37:51 +00:00
p := wire_trafficPacket{}
if !p.decode(packet) {
return
}
sinfo, isIn := r.sessions.getSessionForHandle(&p.Handle)
if !isIn {
util.PutBytes(p.Payload)
2018-01-04 22:37:51 +00:00
return
}
sinfo.recv(r, &p)
2017-12-28 22:16:20 -06:00
}
// Handles protocol traffic by decrypting it, checking its type, and passing it to the appropriate handler for that traffic type.
func (r *router) _handleProto(packet []byte) {
2018-01-04 22:37:51 +00:00
// First parse the packet
p := wire_protoTrafficPacket{}
if !p.decode(packet) {
return
}
// Now try to open the payload
var sharedKey *crypto.BoxSharedKey
2018-06-02 21:21:05 +01:00
if p.ToKey == r.core.boxPub {
2018-01-04 22:37:51 +00:00
// Try to open using our permanent key
sharedKey = r.sessions.getSharedKey(&r.core.boxPriv, &p.FromKey)
2018-01-04 22:37:51 +00:00
} else {
return
}
bs, isOK := crypto.BoxOpen(sharedKey, p.Payload, &p.Nonce)
2018-01-04 22:37:51 +00:00
if !isOK {
return
}
// Now do something with the bytes in bs...
2019-03-28 19:09:19 +00:00
// send dht messages to dht, sessionRefresh to sessions, data to adapter...
2018-01-04 22:37:51 +00:00
// For data, should check that key and IP match...
bsType, bsTypeLen := wire_decode_uint64(bs)
if bsTypeLen == 0 {
return
}
switch bsType {
case wire_SessionPing:
r._handlePing(bs, &p.FromKey)
2018-01-04 22:37:51 +00:00
case wire_SessionPong:
r._handlePong(bs, &p.FromKey)
2018-12-15 22:37:11 +00:00
case wire_NodeInfoRequest:
fallthrough
2018-12-15 22:37:11 +00:00
case wire_NodeInfoResponse:
r._handleNodeInfo(bs, &p.FromKey)
2018-01-04 22:37:51 +00:00
case wire_DHTLookupRequest:
r._handleDHTReq(bs, &p.FromKey)
2018-01-04 22:37:51 +00:00
case wire_DHTLookupResponse:
r._handleDHTRes(bs, &p.FromKey)
default:
util.PutBytes(packet)
2018-01-04 22:37:51 +00:00
}
2017-12-28 22:16:20 -06:00
}
// Decodes session pings from wire format and passes them to sessions.handlePing where they either create or update a session.
func (r *router) _handlePing(bs []byte, fromKey *crypto.BoxPubKey) {
2018-01-04 22:37:51 +00:00
ping := sessionPing{}
if !ping.decode(bs) {
return
}
ping.SendPermPub = *fromKey
r.sessions.handlePing(&ping)
2017-12-28 22:16:20 -06:00
}
// Handles session pongs (which are really pings with an extra flag to prevent acknowledgement).
func (r *router) _handlePong(bs []byte, fromKey *crypto.BoxPubKey) {
r._handlePing(bs, fromKey)
2017-12-28 22:16:20 -06:00
}
// Decodes dht requests and passes them to dht.handleReq to trigger a lookup/response.
func (r *router) _handleDHTReq(bs []byte, fromKey *crypto.BoxPubKey) {
2018-01-04 22:37:51 +00:00
req := dhtReq{}
if !req.decode(bs) {
return
}
req.Key = *fromKey
r.dht.handleReq(&req)
2017-12-28 22:16:20 -06:00
}
// Decodes dht responses and passes them to dht.handleRes to update the DHT table and further pass them to the search code (if applicable).
func (r *router) _handleDHTRes(bs []byte, fromKey *crypto.BoxPubKey) {
2018-01-04 22:37:51 +00:00
res := dhtRes{}
if !res.decode(bs) {
return
}
res.Key = *fromKey
r.dht.handleRes(&res)
2017-12-28 22:16:20 -06:00
}
2018-12-15 22:37:11 +00:00
// Decodes nodeinfo request
func (r *router) _handleNodeInfo(bs []byte, fromKey *crypto.BoxPubKey) {
2018-12-15 22:37:11 +00:00
req := nodeinfoReqRes{}
if !req.decode(bs) {
return
}
req.SendPermPub = *fromKey
2019-01-14 19:05:16 +00:00
r.nodeinfo.handleNodeInfo(&req)
}