p2p

type Address struct {
	Data []byte `size:"32"` // address data of size "(ADDRESS_BITS+7)/8"
}

type Bucket struct {
	// contains filtered or unexported fields
}

type BucketList struct {
	// contains filtered or unexported fields
}

type BucketListTask struct {
	// contains filtered or unexported fields
}

type Connector interface {
	// Send packet to endpoint (low-level transport)
	Send(context.Context, net.Addr, *Packet) error

	// Listen to messages from transport
	Listen(context.Context, chan Message)

	// Learn network address of node address
	Learn(*Address, net.Addr) error

	// Resolve the network address of a node address
	Resolve(*Address) net.Addr

	// NewAddress to instaniate a new endpoint address
	NewAddress(string) (net.Addr, error)

	// Sample given number of nodes with network addresses
	// stored in cache.
	Sample(int, *Address) []*Address

	// Epoch step: perform periodic tasks
	Epoch(int)
}

type Endpoint struct {
	Addr *Address // address of node
	Endp *String  // listen address
}

type FindNodeMsg struct {
	MsgHeader

	Addr *Address // address of node we are looking for
}

type FindNodeRespMsg struct {
	MsgHeader

	// List of response entries
	List []*Endpoint `size:"*"`
}

type HandlerList struct {
	// contains filtered or unexported fields
}

type LocalAddress struct {
	Name string
}

type LocalConnector struct {
	// contains filtered or unexported fields
}

type LocalTransport struct {
	// contains filtered or unexported fields
}

type LookupService struct {
	ServiceImpl
}

type Message interface {
	// Header of message (common data)
	Header() *MsgHeader

	// Data returns the binary representation of the message
	Data() []byte

	// String returns a human-readable message
	String() string
}

type MessageFactory func([]byte) (Message, error)

type MessageHandler func(context.Context, Message) (bool, error)

type MsgHeader struct {
	Size     uint16 `order:"big"` // Size of message (including size)
	Type     uint16 `order:"big"` // Message type (see constants)
	Flags    uint32 `order:"big"` // Message flags (see constants)
	TxID     uint64 `order:"big"` // transaction identifier
	Sender   *Address
	Receiver *Address
}

type NewMessage func() Message

type Node struct {
	// contains filtered or unexported fields
}

type Packet struct {
	Size uint16 `order:"big"` // size of packet (including this field)
	KXT  []byte `size:"32"`   // Key Exchange Token
	Body []byte `size:"*"`    // encrypted body
}

type PingMsg struct {
	MsgHeader
}

type PingService struct {
	ServiceImpl
}

type PongMsg struct {
	MsgHeader
}

type Query func(ctx context.Context, peer, addr *Address) interface{}

type RelayMsg struct {
	MsgHeader

	NextHop *Endpoint // next hop address
	Pkt     *Packet   // packet to deliver to next hop
}

type RelayService struct {
	ServiceImpl
}

type Service interface {
	// Name is a human-readble and short service description like "PING"
	Name() string

	// Node the service is running on
	Node() *Node

	// Respond to a service request from peer.
	// The bool return value indicates whether the message has been processed
	// or not and if there was an error message with it.
	Respond(context.Context, Message) (bool, error)

	// Listen to service responses from peer.
	// The bool return value indicates whether the message has been processed
	// or not and if there was an error message with it.
	Listen(context.Context, Message) (bool, error)

	// Send a message to network
	Send(context.Context, Message) error

	// NewMessage creates an empty service message of given type.
	// The type must be known to the service.
	NewMessage(mt int) Message
	// contains filtered or unexported methods
}

type ServiceImpl struct {
	// contains filtered or unexported fields
}

type ServiceList struct {
	// contains filtered or unexported fields
}

type String struct {
	Len  uint16 `order:"big"` // length of string
	Data []byte `size:"Len"`  // string data
}

type TaskHandler struct {
	// contains filtered or unexported fields
}

type TorAddress struct {
	// contains filtered or unexported fields
}

type TorConnection struct {
	// contains filtered or unexported fields
}

type TorConnector struct {
	// contains filtered or unexported fields
}

type TorTransport struct {
	// contains filtered or unexported fields
}

type TorTransportConfig struct {
	// Ctrl specifies the Tor control interface. It is formatted like
	// "network:endp", where 'network' is either "tcp" (for TCP/IP) or
	// "unix" (for a local Unix socket). 'endp' specifies the endpoint
	// depending on the network; it is "host:port" for "tcp" and a file
	// path in case of a local Unix socket.
	// The same host (either "host" as deined or localhos) must have the
	// defined SOCKS ports open for access to Tor cuircuits.
	Ctrl string `json:"ctrl"`
	// Auth is the authentication password/cookie. If a cookie is used
	// (only applicable for local Tor service instances), the value is
	// set dynamically (and not in a persistent configuration file).
	Auth string `json:"auth"`
	// HSHost refers to the host running hidden service endpoints
	HSHost string `json:"hshost"`
	// PeerTTL defines (in seconds) how long connections are kept-alive
	// after a message has been send.
	PeerTTL int `json:"peerTTL"`
}

type Transport interface {
	// Open transport based on configuration
	Open(TransportConfig) error
	// Register a node for participation in this transport
	Register(context.Context, *Node, string) error
	// Close transport
	Close() error
}

type TransportConfig interface {
	TransportType() string // return type of associated transport
}

type UDPConnector struct {
	// contains filtered or unexported fields
}

type UDPTransport struct {
	// contains filtered or unexported fields
}