remove unused recursive search packets

build

@@ -5,7 +5,7 @@ go get -d -v
 go get -d -v yggdrasil
 for file in *.go ; do
   echo "Building: $file"
-  go build -v $file
+  go build $@ $file
   #go build -ldflags="-s -w" -v $file
   #upx --brute ${file/.go/}
 done

src/yggdrasil/router.go

@@ -310,10 +310,6 @@ func (r *router) handleProto(packet []byte) {
 		r.handleDHTReq(bs, &p.FromKey)
 	case wire_DHTLookupResponse:
 		r.handleDHTRes(bs, &p.FromKey)
-	case wire_SearchRequest:
-		r.handleSearchReq(bs)
-	case wire_SearchResponse:
-		r.handleSearchRes(bs)
 	default: /*panic("Should not happen in testing") ;*/
 		return
 	}
@@ -350,22 +346,6 @@ func (r *router) handleDHTRes(bs []byte, fromKey *boxPubKey) {
 	r.core.dht.handleRes(&res)
 }
 
-func (r *router) handleSearchReq(bs []byte) {
-	req := searchReq{}
-	if !req.decode(bs) {
-		return
-	}
-	r.core.searches.handleSearchReq(&req)
-}
-
-func (r *router) handleSearchRes(bs []byte) {
-	res := searchRes{}
-	if !res.decode(bs) {
-		return
-	}
-	r.core.searches.handleSearchRes(&res)
-}
-
 func (r *router) doAdmin(f func()) {
 	// Pass this a function that needs to be run by the router's main goroutine
 	// It will pass the function to the router and wait for the router to finish

src/yggdrasil/search.go

@@ -170,126 +170,3 @@ func (s *searches) checkDHTRes(info *searchInfo, res *dhtRes) bool {
 	return true
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-type searchReq struct {
-	key    boxPubKey // Who I am
-	coords []byte    // Where I am
-	dest   NodeID    // Who I'm trying to connect to
-}
-
-type searchRes struct {
-	key    boxPubKey // Who I am
-	coords []byte    // Where I am
-	dest   NodeID    // Who I was asked about
-}
-
-func (s *searches) sendSearch(info *searchInfo) {
-	now := time.Now()
-	if now.Sub(info.time) < time.Second {
-		return
-	}
-	loc := s.core.switchTable.getLocator()
-	coords := loc.getCoords()
-	req := searchReq{
-		key:    s.core.boxPub,
-		coords: coords,
-		dest:   info.dest,
-	}
-	info.time = time.Now()
-	s.handleSearchReq(&req)
-}
-
-func (s *searches) handleSearchReq(req *searchReq) {
-	lookup := s.core.dht.lookup(&req.dest, false)
-	sent := false
-	//fmt.Println("DEBUG len:", len(lookup))
-	for _, info := range lookup {
-		//fmt.Println("DEBUG lup:", info.getNodeID())
-		if dht_firstCloserThanThird(info.getNodeID(),
-			&req.dest,
-			&s.core.dht.nodeID) {
-			s.forwardSearch(req, info)
-			sent = true
-			break
-		}
-	}
-	if !sent {
-		s.sendSearchRes(req)
-	}
-}
-
-func (s *searches) forwardSearch(req *searchReq, next *dhtInfo) {
-	//fmt.Println("DEBUG fwd:", req.dest, next.getNodeID())
-	bs := req.encode()
-	shared := s.core.sessions.getSharedKey(&s.core.boxPriv, &next.key)
-	payload, nonce := boxSeal(shared, bs, nil)
-	p := wire_protoTrafficPacket{
-		TTL:     ^uint64(0),
-		Coords:  next.coords,
-		ToKey:   next.key,
-		FromKey: s.core.boxPub,
-		Nonce:   *nonce,
-		Payload: payload,
-	}
-	packet := p.encode()
-	s.core.router.out(packet)
-}
-
-func (s *searches) sendSearchRes(req *searchReq) {
-	//fmt.Println("DEBUG res:", req.dest, s.core.dht.nodeID)
-	loc := s.core.switchTable.getLocator()
-	coords := loc.getCoords()
-	res := searchRes{
-		key:    s.core.boxPub,
-		coords: coords,
-		dest:   req.dest,
-	}
-	bs := res.encode()
-	shared := s.core.sessions.getSharedKey(&s.core.boxPriv, &req.key)
-	payload, nonce := boxSeal(shared, bs, nil)
-	p := wire_protoTrafficPacket{
-		TTL:     ^uint64(0),
-		Coords:  req.coords,
-		ToKey:   req.key,
-		FromKey: s.core.boxPub,
-		Nonce:   *nonce,
-		Payload: payload,
-	}
-	packet := p.encode()
-	s.core.router.out(packet)
-}
-
-func (s *searches) handleSearchRes(res *searchRes) {
-	info, isIn := s.searches[res.dest]
-	if !isIn {
-		return
-	}
-	them := getNodeID(&res.key)
-	var destMasked NodeID
-	var themMasked NodeID
-	for idx := 0; idx < NodeIDLen; idx++ {
-		destMasked[idx] = info.dest[idx] & info.mask[idx]
-		themMasked[idx] = them[idx] & info.mask[idx]
-	}
-	//fmt.Println("DEBUG search res1:", themMasked, destMasked)
-	//fmt.Println("DEBUG search res2:", *them, *info.dest, *info.mask)
-	if themMasked != destMasked {
-		return
-	}
-	// They match, so create a session and send a sessionRequest
-	sinfo, isIn := s.core.sessions.getByTheirPerm(&res.key)
-	if !isIn {
-		sinfo = s.core.sessions.createSession(&res.key)
-		_, isIn := s.core.sessions.getByTheirPerm(&res.key)
-		if !isIn {
-			panic("This should never happen")
-		}
-	}
-	// FIXME (!) replay attacks could mess with coords? Give it a handle (tstamp)?
-	sinfo.coords = res.coords
-	sinfo.packet = info.packet
-	s.core.sessions.ping(sinfo)
-	// Cleanup
-	delete(s.searches, res.dest)
-}

src/yggdrasil/wire.go

@@ -19,8 +19,6 @@ const (
 	wire_SessionPong                // inside protocol traffic header
 	wire_DHTLookupRequest           // inside protocol traffic header
 	wire_DHTLookupResponse          // inside protocol traffic header
-	wire_SearchRequest              // inside protocol traffic header
-	wire_SearchResponse             // inside protocol traffic header
 )
 
 // Encode uint64 using a variable length scheme
@@ -514,58 +512,3 @@ func (r *dhtRes) decode(bs []byte) bool {
 	return true
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-func (r *searchReq) encode() []byte {
-	coords := wire_encode_coords(r.coords)
-	bs := wire_encode_uint64(wire_SearchRequest)
-	bs = append(bs, r.key[:]...)
-	bs = append(bs, coords...)
-	bs = append(bs, r.dest[:]...)
-	return bs
-}
-
-func (r *searchReq) decode(bs []byte) bool {
-	var pType uint64
-	switch {
-	case !wire_chop_uint64(&pType, &bs):
-		return false
-	case pType != wire_SearchRequest:
-		return false
-	case !wire_chop_slice(r.key[:], &bs):
-		return false
-	case !wire_chop_coords(&r.coords, &bs):
-		return false
-	case !wire_chop_slice(r.dest[:], &bs):
-		return false
-	default:
-		return true
-	}
-}
-
-func (r *searchRes) encode() []byte {
-	coords := wire_encode_coords(r.coords)
-	bs := wire_encode_uint64(wire_SearchResponse)
-	bs = append(bs, r.key[:]...)
-	bs = append(bs, coords...)
-	bs = append(bs, r.dest[:]...)
-	return bs
-}
-
-func (r *searchRes) decode(bs []byte) bool {
-	var pType uint64
-	switch {
-	case !wire_chop_uint64(&pType, &bs):
-		return false
-	case pType != wire_SearchResponse:
-		return false
-	case !wire_chop_slice(r.key[:], &bs):
-		return false
-	case !wire_chop_coords(&r.coords, &bs):
-		return false
-	case !wire_chop_slice(r.dest[:], &bs):
-		return false
-	default:
-		return true
-	}
-}