package yggdrasil import ( "encoding/json" "errors" "runtime" "strings" "sync" "time" "github.com/yggdrasil-network/yggdrasil-go/src/crypto" ) type nodeinfo struct { core *Core myNodeInfo nodeinfoPayload myNodeInfoMutex sync.RWMutex callbacks map[crypto.BoxPubKey]nodeinfoCallback callbacksMutex sync.Mutex cache map[crypto.BoxPubKey]nodeinfoCached cacheMutex sync.RWMutex } type nodeinfoPayload []byte type nodeinfoCached struct { payload nodeinfoPayload created time.Time } type nodeinfoCallback struct { call func(nodeinfo *nodeinfoPayload) created time.Time } // Represents a session nodeinfo packet. type nodeinfoReqRes struct { SendPermPub crypto.BoxPubKey // Sender's permanent key SendCoords []byte // Sender's coords IsResponse bool NodeInfo nodeinfoPayload } // Initialises the nodeinfo cache/callback maps, and starts a goroutine to keep // the cache/callback maps clean of stale entries func (m *nodeinfo) init(core *Core) { m.core = core m.callbacks = make(map[crypto.BoxPubKey]nodeinfoCallback) m.cache = make(map[crypto.BoxPubKey]nodeinfoCached) go func() { for { m.callbacksMutex.Lock() for boxPubKey, callback := range m.callbacks { if time.Since(callback.created) > time.Minute { delete(m.callbacks, boxPubKey) } } m.callbacksMutex.Unlock() m.cacheMutex.Lock() for boxPubKey, cache := range m.cache { if time.Since(cache.created) > time.Hour { delete(m.cache, boxPubKey) } } m.cacheMutex.Unlock() time.Sleep(time.Second * 30) } }() } // Add a callback for a nodeinfo lookup func (m *nodeinfo) addCallback(sender crypto.BoxPubKey, call func(nodeinfo *nodeinfoPayload)) { m.callbacksMutex.Lock() defer m.callbacksMutex.Unlock() m.callbacks[sender] = nodeinfoCallback{ created: time.Now(), call: call, } } // Handles the callback, if there is one func (m *nodeinfo) callback(sender crypto.BoxPubKey, nodeinfo nodeinfoPayload) { m.callbacksMutex.Lock() defer m.callbacksMutex.Unlock() if callback, ok := m.callbacks[sender]; ok { callback.call(&nodeinfo) delete(m.callbacks, sender) } } // Get the current node's nodeinfo func (m *nodeinfo) getNodeInfo() nodeinfoPayload { m.myNodeInfoMutex.RLock() defer m.myNodeInfoMutex.RUnlock() return m.myNodeInfo } // Set the current node's nodeinfo func (m *nodeinfo) setNodeInfo(given interface{}, privacy bool) error { m.myNodeInfoMutex.Lock() defer m.myNodeInfoMutex.Unlock() defaults := map[string]interface{}{ "buildname": GetBuildName(), "buildversion": GetBuildVersion(), "buildplatform": runtime.GOOS, "buildarch": runtime.GOARCH, } newnodeinfo := make(map[string]interface{}) if !privacy { for k, v := range defaults { newnodeinfo[k] = v } } if nodeinfomap, ok := given.(map[string]interface{}); ok { for key, value := range nodeinfomap { if _, ok := defaults[key]; ok { if strvalue, strok := value.(string); strok && strings.EqualFold(strvalue, "null") || value == nil { delete(newnodeinfo, key) } continue } newnodeinfo[key] = value } } if newjson, err := json.Marshal(newnodeinfo); err == nil { if len(newjson) > 16384 { return errors.New("NodeInfo exceeds max length of 16384 bytes") } m.myNodeInfo = newjson return nil } else { return err } } // Add nodeinfo into the cache for a node func (m *nodeinfo) addCachedNodeInfo(key crypto.BoxPubKey, payload nodeinfoPayload) { m.cacheMutex.Lock() defer m.cacheMutex.Unlock() m.cache[key] = nodeinfoCached{ created: time.Now(), payload: payload, } } // Get a nodeinfo entry from the cache func (m *nodeinfo) getCachedNodeInfo(key crypto.BoxPubKey) (nodeinfoPayload, error) { m.cacheMutex.RLock() defer m.cacheMutex.RUnlock() if nodeinfo, ok := m.cache[key]; ok { return nodeinfo.payload, nil } return nodeinfoPayload{}, errors.New("No cache entry found") } // Handles a nodeinfo request/response - called from the router func (m *nodeinfo) handleNodeInfo(nodeinfo *nodeinfoReqRes) { if nodeinfo.IsResponse { m.callback(nodeinfo.SendPermPub, nodeinfo.NodeInfo) m.addCachedNodeInfo(nodeinfo.SendPermPub, nodeinfo.NodeInfo) } else { m.sendNodeInfo(nodeinfo.SendPermPub, nodeinfo.SendCoords, true) } } // Send nodeinfo request or response - called from the router func (m *nodeinfo) sendNodeInfo(key crypto.BoxPubKey, coords []byte, isResponse bool) { table := m.core.switchTable.table.Load().(lookupTable) nodeinfo := nodeinfoReqRes{ SendCoords: table.self.getCoords(), IsResponse: isResponse, NodeInfo: m.getNodeInfo(), } bs := nodeinfo.encode() shared := m.core.sessions.getSharedKey(&m.core.boxPriv, &key) payload, nonce := crypto.BoxSeal(shared, bs, nil) p := wire_protoTrafficPacket{ Coords: coords, ToKey: key, FromKey: m.core.boxPub, Nonce: *nonce, Payload: payload, } packet := p.encode() m.core.router.out(packet) }