135 lines
3.7 KiB
Go
135 lines
3.7 KiB
Go
package dht
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net"
|
|
"sort"
|
|
"strconv"
|
|
|
|
"github.com/lbryio/lbry.go/v3/dht/bits"
|
|
|
|
"github.com/cockroachdb/errors"
|
|
"github.com/lyoshenka/bencode"
|
|
)
|
|
|
|
// TODO: if routing table is ever empty (aka the node is isolated), it should re-bootstrap
|
|
|
|
// Contact contains information for contacting another node on the network
|
|
type Contact struct {
|
|
ID bits.Bitmap
|
|
IP net.IP
|
|
Port int // the udp port used for the dht
|
|
PeerPort int // the tcp port a peer can be contacted on for blob requests
|
|
}
|
|
|
|
// Equals returns true if two contacts are the same.
|
|
func (c Contact) Equals(other Contact, checkID bool) bool {
|
|
return c.IP.Equal(other.IP) && c.Port == other.Port && (!checkID || c.ID == other.ID)
|
|
}
|
|
|
|
// Addr returns the address of the contact.
|
|
func (c Contact) Addr() *net.UDPAddr {
|
|
return &net.UDPAddr{IP: c.IP, Port: c.Port}
|
|
}
|
|
|
|
// String returns a short string representation of the contact
|
|
func (c Contact) String() string {
|
|
str := c.ID.HexShort() + "@" + c.Addr().String()
|
|
if c.PeerPort != 0 {
|
|
str += "(" + strconv.Itoa(c.PeerPort) + ")"
|
|
}
|
|
return str
|
|
}
|
|
|
|
func (c Contact) MarshalJSON() ([]byte, error) {
|
|
b, err := json.Marshal(&struct {
|
|
ID string
|
|
IP string
|
|
Port int
|
|
PeerPort int
|
|
}{
|
|
ID: c.ID.Hex(),
|
|
IP: c.IP.String(),
|
|
Port: c.Port,
|
|
PeerPort: c.PeerPort,
|
|
})
|
|
return b, errors.Wrap(err, "")
|
|
}
|
|
|
|
// MarshalCompact returns a compact byteslice representation of the contact
|
|
// NOTE: The compact representation always uses the tcp PeerPort, not the udp Port. This is dumb, but that's how the python daemon does it
|
|
func (c Contact) MarshalCompact() ([]byte, error) {
|
|
if c.IP.To4() == nil {
|
|
return nil, errors.Wrap(errors.New("ip not set"), "")
|
|
}
|
|
if c.PeerPort < 0 || c.PeerPort > 65535 {
|
|
return nil, errors.Wrap(errors.New("invalid port"), "")
|
|
}
|
|
|
|
var buf bytes.Buffer
|
|
buf.Write(c.IP.To4())
|
|
buf.WriteByte(byte(c.PeerPort >> 8))
|
|
buf.WriteByte(byte(c.PeerPort))
|
|
buf.Write(c.ID[:])
|
|
|
|
if buf.Len() != compactNodeInfoLength {
|
|
return nil, errors.Wrap(errors.New("i dont know how this happened"), "")
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalCompact unmarshals the compact byteslice representation of a contact.
|
|
// NOTE: The compact representation always uses the tcp PeerPort, not the udp Port. This is dumb, but that's how the python daemon does it
|
|
func (c *Contact) UnmarshalCompact(b []byte) error {
|
|
if len(b) != compactNodeInfoLength {
|
|
return errors.Wrap(errors.New("invalid compact length"), "")
|
|
}
|
|
c.IP = net.IPv4(b[0], b[1], b[2], b[3]).To4()
|
|
c.PeerPort = int(uint16(b[5]) | uint16(b[4])<<8)
|
|
c.ID = bits.FromBytesP(b[6:])
|
|
return nil
|
|
}
|
|
|
|
// MarshalBencode returns the serialized byte slice representation of a contact.
|
|
func (c Contact) MarshalBencode() ([]byte, error) {
|
|
b, err := bencode.EncodeBytes([]interface{}{c.ID, c.IP.String(), c.Port})
|
|
return b, errors.Wrap(err, "")
|
|
}
|
|
|
|
// UnmarshalBencode unmarshals the serialized byte slice into the appropriate fields of the contact.
|
|
func (c *Contact) UnmarshalBencode(b []byte) error {
|
|
var raw []bencode.RawMessage
|
|
err := bencode.DecodeBytes(b, &raw)
|
|
if err != nil {
|
|
return errors.Wrap(err, "")
|
|
}
|
|
|
|
if len(raw) != 3 {
|
|
return errors.Wrap(errors.Newf("contact must have 3 elements; got %d", len(raw)), "")
|
|
}
|
|
|
|
err = bencode.DecodeBytes(raw[0], &c.ID)
|
|
if err != nil {
|
|
return errors.Wrap(err, "")
|
|
}
|
|
|
|
var ipStr string
|
|
err = bencode.DecodeBytes(raw[1], &ipStr)
|
|
if err != nil {
|
|
return errors.Wrap(err, "")
|
|
}
|
|
c.IP = net.ParseIP(ipStr).To4()
|
|
if c.IP == nil {
|
|
return errors.Wrap(errors.New("invalid IP"), "")
|
|
}
|
|
|
|
return bencode.DecodeBytes(raw[2], &c.Port)
|
|
}
|
|
|
|
func sortByDistance(contacts []Contact, target bits.Bitmap) {
|
|
sort.Slice(contacts, func(i, j int) bool {
|
|
return contacts[i].ID.Xor(target).Cmp(contacts[j].ID.Xor(target)) < 0
|
|
})
|
|
}
|