2017-12-28 22:16:20 -06:00
package yggdrasil
// This thing manages search packets
// The basic idea is as follows:
// We may know a NodeID (with a mask) and want to connect
2018-06-02 16:45:45 -05:00
// We begin a search by initializing a list of all nodes in our DHT, sorted by closest to the destination
// We then iteratively ping nodes from the search, marking each pinged node as visited
// We add any unvisited nodes from ping responses to the search, truncating to some maximum search size
// This stops when we either run out of nodes to ping (we hit a dead end where we can't make progress without going back), or we reach the destination
// A new search packet is sent immediately after receiving a response
// A new search packet is sent periodically, once per second, in case a packet was dropped (this slowly causes the search to become parallel if the search doesn't timeout but also doesn't finish within 1 second for whatever reason)
2017-12-28 22:16:20 -06:00
2018-10-29 22:24:18 -05:00
// TODO?
// Some kind of max search steps, in case the node is offline, so we don't crawl through too much of the network looking for a destination that isn't there?
2018-06-12 17:50:08 -05:00
import (
2019-04-18 23:38:23 +01:00
"errors"
2018-06-12 17:50:08 -05:00
"sort"
"time"
2018-12-14 20:49:18 -06:00
"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
2018-06-12 17:50:08 -05:00
)
2017-12-28 22:16:20 -06:00
2018-06-10 18:03:28 -05:00
// This defines the maximum number of dhtInfo that we keep track of for nodes to query in an ongoing search.
2018-06-02 14:57:06 -05:00
const search_MAX_SEARCH_SIZE = 16
2018-06-10 18:03:28 -05:00
// This defines the time after which we send a new search packet.
// Search packets are sent automatically immediately after a response is received.
// So this allows for timeouts and for long searches to become increasingly parallel.
2018-06-02 14:57:06 -05:00
const search_RETRY_TIME = time . Second
2018-06-10 18:03:28 -05:00
// Information about an ongoing search.
2019-01-09 11:44:45 +02:00
// Includes the target NodeID, the bitmask to match it to an IP, and the list of nodes to visit / already visited.
2017-12-28 22:16:20 -06:00
type searchInfo struct {
2019-04-18 23:38:23 +01:00
dest crypto . NodeID
mask crypto . NodeID
time time . Time
packet [ ] byte
toVisit [ ] * dhtInfo
visited map [ crypto . NodeID ] bool
callback func ( * sessionInfo , error )
2017-12-28 22:16:20 -06:00
}
2018-06-10 18:03:28 -05:00
// This stores a map of active searches.
2017-12-28 22:16:20 -06:00
type searches struct {
2018-12-29 18:51:51 +00:00
core * Core
2018-12-30 12:04:42 +00:00
reconfigure chan chan error
2018-12-29 18:51:51 +00:00
searches map [ crypto . NodeID ] * searchInfo
2017-12-28 22:16:20 -06:00
}
2018-06-10 18:03:28 -05:00
// Intializes the searches struct.
2017-12-28 22:16:20 -06:00
func ( s * searches ) init ( core * Core ) {
2018-01-04 22:37:51 +00:00
s . core = core
2018-12-30 12:04:42 +00:00
s . reconfigure = make ( chan chan error , 1 )
2018-12-29 18:51:51 +00:00
go func ( ) {
for {
2019-01-15 08:51:19 +00:00
e := <- s . reconfigure
e <- nil
2018-12-29 18:51:51 +00:00
}
} ( )
2018-12-14 20:49:18 -06:00
s . searches = make ( map [ crypto . NodeID ] * searchInfo )
2017-12-28 22:16:20 -06:00
}
2018-06-10 18:03:28 -05:00
// Creates a new search info, adds it to the searches struct, and returns a pointer to the info.
2019-04-18 23:38:23 +01:00
func ( s * searches ) createSearch ( dest * crypto . NodeID , mask * crypto . NodeID , callback func ( * sessionInfo , error ) ) * searchInfo {
2018-01-04 22:37:51 +00:00
now := time . Now ( )
for dest , sinfo := range s . searches {
if now . Sub ( sinfo . time ) > time . Minute {
delete ( s . searches , dest )
}
}
info := searchInfo {
2019-04-18 23:38:23 +01:00
dest : * dest ,
mask : * mask ,
time : now . Add ( - time . Second ) ,
callback : callback ,
2018-01-04 22:37:51 +00:00
}
s . searches [ * dest ] = & info
return & info
2017-12-28 22:16:20 -06:00
}
////////////////////////////////////////////////////////////////////////////////
2018-06-10 18:03:28 -05:00
// Checks if there's an ongoing search relaed to a dhtRes.
// If there is, it adds the response info to the search and triggers a new search step.
// If there's no ongoing search, or we if the dhtRes finished the search (it was from the target node), then don't do anything more.
2018-06-01 23:34:21 -05:00
func ( s * searches ) handleDHTRes ( res * dhtRes ) {
2018-06-02 16:30:05 -05:00
sinfo , isIn := s . searches [ res . Dest ]
2018-06-02 00:16:47 -05:00
if ! isIn || s . checkDHTRes ( sinfo , res ) {
// Either we don't recognize this search, or we just finished it
2018-06-01 23:34:21 -05:00
return
2018-06-02 00:16:47 -05:00
} else {
// Add to the search and continue
s . addToSearch ( sinfo , res )
s . doSearchStep ( sinfo )
2018-06-01 23:34:21 -05:00
}
}
2018-06-10 18:03:28 -05:00
// Adds the information from a dhtRes to an ongoing search.
// Info about a node that has already been visited is not re-added to the search.
// Duplicate information about nodes toVisit is deduplicated (the newest information is kept).
// The toVisit list is sorted in ascending order of keyspace distance from the destination.
2018-06-02 00:16:47 -05:00
func ( s * searches ) addToSearch ( sinfo * searchInfo , res * dhtRes ) {
2018-06-02 00:29:36 -05:00
// Add responses to toVisit if closer to dest than the res node
2018-06-02 16:30:05 -05:00
from := dhtInfo { key : res . Key , coords : res . Coords }
2018-10-29 22:24:18 -05:00
sinfo . visited [ * from . getNodeID ( ) ] = true
2018-06-02 16:30:05 -05:00
for _ , info := range res . Infos {
2018-10-20 15:21:40 -05:00
if * info . getNodeID ( ) == s . core . dht . nodeID || sinfo . visited [ * info . getNodeID ( ) ] {
2018-06-02 14:57:06 -05:00
continue
}
2018-10-24 22:03:27 -05:00
if dht_ordered ( & sinfo . dest , info . getNodeID ( ) , from . getNodeID ( ) ) {
// Response is closer to the destination
2018-06-01 23:34:21 -05:00
sinfo . toVisit = append ( sinfo . toVisit , info )
}
}
2018-06-02 00:29:36 -05:00
// Deduplicate
2018-12-14 20:49:18 -06:00
vMap := make ( map [ crypto . NodeID ] * dhtInfo )
2018-06-02 00:29:36 -05:00
for _ , info := range sinfo . toVisit {
vMap [ * info . getNodeID ( ) ] = info
}
sinfo . toVisit = sinfo . toVisit [ : 0 ]
for _ , info := range vMap {
sinfo . toVisit = append ( sinfo . toVisit , info )
}
// Sort
2018-06-01 23:34:21 -05:00
sort . SliceStable ( sinfo . toVisit , func ( i , j int ) bool {
2018-10-21 17:40:43 -05:00
// Should return true if i is closer to the destination than j
2018-10-21 18:15:04 -05:00
return dht_ordered ( & res . Dest , sinfo . toVisit [ i ] . getNodeID ( ) , sinfo . toVisit [ j ] . getNodeID ( ) )
2018-06-01 23:34:21 -05:00
} )
2018-06-02 00:29:36 -05:00
// Truncate to some maximum size
2018-06-02 14:57:06 -05:00
if len ( sinfo . toVisit ) > search_MAX_SEARCH_SIZE {
2018-11-09 23:02:38 -06:00
sinfo . toVisit = sinfo . toVisit [ : search_MAX_SEARCH_SIZE ]
2018-06-02 00:29:36 -05:00
}
2018-06-01 23:34:21 -05:00
}
2018-06-10 18:03:28 -05:00
// If there are no nodes left toVisit, then this cleans up the search.
// Otherwise, it pops the closest node to the destination (in keyspace) off of the toVisit list and sends a dht ping.
2018-06-01 23:34:21 -05:00
func ( s * searches ) doSearchStep ( sinfo * searchInfo ) {
2018-06-02 14:57:06 -05:00
if len ( sinfo . toVisit ) == 0 {
// Dead end, do cleanup
2018-06-02 16:33:58 -05:00
delete ( s . searches , sinfo . dest )
2019-04-21 22:31:56 -05:00
go sinfo . callback ( nil , errors . New ( "search reached dead end" ) )
2018-06-01 23:34:21 -05:00
return
}
2019-04-18 23:38:23 +01:00
// Send to the next search target
var next * dhtInfo
next , sinfo . toVisit = sinfo . toVisit [ 0 ] , sinfo . toVisit [ 1 : ]
rq := dhtReqKey { next . key , sinfo . dest }
s . core . dht . addCallback ( & rq , s . handleDHTRes )
s . core . dht . ping ( next , & sinfo . dest )
2018-06-01 23:34:21 -05:00
}
2018-06-10 18:03:28 -05:00
// If we've recenty sent a ping for this search, do nothing.
// Otherwise, doSearchStep and schedule another continueSearch to happen after search_RETRY_TIME.
2018-06-01 23:34:21 -05:00
func ( s * searches ) continueSearch ( sinfo * searchInfo ) {
2018-06-02 14:57:06 -05:00
if time . Since ( sinfo . time ) < search_RETRY_TIME {
2018-06-01 23:34:21 -05:00
return
}
sinfo . time = time . Now ( )
s . doSearchStep ( sinfo )
2018-06-02 14:57:06 -05:00
// In case the search dies, try to spawn another thread later
// Note that this will spawn multiple parallel searches as time passes
// Any that die aren't restarted, but a new one will start later
retryLater := func ( ) {
2018-06-02 16:33:58 -05:00
newSearchInfo := s . searches [ sinfo . dest ]
2018-06-02 14:57:06 -05:00
if newSearchInfo != sinfo {
return
}
s . continueSearch ( sinfo )
}
go func ( ) {
time . Sleep ( search_RETRY_TIME )
s . core . router . admin <- retryLater
} ( )
2018-06-01 23:34:21 -05:00
}
2018-06-10 18:03:28 -05:00
// Calls create search, and initializes the iterative search parts of the struct before returning it.
2019-04-18 23:38:23 +01:00
func ( s * searches ) newIterSearch ( dest * crypto . NodeID , mask * crypto . NodeID , callback func ( * sessionInfo , error ) ) * searchInfo {
sinfo := s . createSearch ( dest , mask , callback )
2018-06-02 16:39:34 -05:00
sinfo . toVisit = s . core . dht . lookup ( dest , true )
2018-12-14 20:49:18 -06:00
sinfo . visited = make ( map [ crypto . NodeID ] bool )
2018-06-01 23:34:21 -05:00
return sinfo
}
2018-06-10 18:03:28 -05:00
// Checks if a dhtRes is good (called by handleDHTRes).
// If the response is from the target, get/create a session, trigger a session ping, and return true.
// Otherwise return false.
2018-06-02 00:16:47 -05:00
func ( s * searches ) checkDHTRes ( info * searchInfo , res * dhtRes ) bool {
2018-12-14 20:49:18 -06:00
them := crypto . GetNodeID ( & res . Key )
var destMasked crypto . NodeID
var themMasked crypto . NodeID
for idx := 0 ; idx < crypto . NodeIDLen ; idx ++ {
2018-06-01 23:34:21 -05:00
destMasked [ idx ] = info . dest [ idx ] & info . mask [ idx ]
themMasked [ idx ] = them [ idx ] & info . mask [ idx ]
}
if themMasked != destMasked {
return false
}
// They match, so create a session and send a sessionRequest
2018-06-02 16:30:05 -05:00
sinfo , isIn := s . core . sessions . getByTheirPerm ( & res . Key )
2018-06-01 23:34:21 -05:00
if ! isIn {
2018-06-02 16:30:05 -05:00
sinfo = s . core . sessions . createSession ( & res . Key )
2018-10-08 19:51:51 +01:00
if sinfo == nil {
// nil if the DHT search finished but the session wasn't allowed
2019-04-21 22:31:56 -05:00
go info . callback ( nil , errors . New ( "session not allowed" ) )
2018-10-08 19:51:51 +01:00
return true
}
2018-06-02 16:30:05 -05:00
_ , isIn := s . core . sessions . getByTheirPerm ( & res . Key )
2018-06-01 23:34:21 -05:00
if ! isIn {
panic ( "This should never happen" )
}
}
// FIXME (!) replay attacks could mess with coords? Give it a handle (tstamp)?
2018-06-02 16:30:05 -05:00
sinfo . coords = res . Coords
2018-06-01 23:34:21 -05:00
sinfo . packet = info . packet
s . core . sessions . ping ( sinfo )
2019-04-21 22:31:56 -05:00
go info . callback ( sinfo , nil )
2018-06-01 23:34:21 -05:00
// Cleanup
2018-06-02 16:30:05 -05:00
delete ( s . searches , res . Dest )
2018-06-01 23:34:21 -05:00
return true
}