init v0.1.0
This commit is contained in:
Sudo-Ivan
459
pkg/transport/transport.go
Normal file
459
pkg/transport/transport.go
Normal file
@@ -0,0 +1,459 @@
|
||||
package transport
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"net"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/Sudo-Ivan/reticulum-go/pkg/common"
|
||||
)
|
||||
|
||||
var (
|
||||
transportInstance *Transport
|
||||
transportMutex sync.Mutex
|
||||
)
|
||||
|
||||
const (
|
||||
PathfinderM = 128 // Maximum number of hops
|
||||
PathRequestTTL = 300 // Time to live for path requests in seconds
|
||||
AnnounceTimeout = 15 // Timeout for announce responses in seconds
|
||||
|
||||
// Link constants
|
||||
EstablishmentTimeoutPerHop = 6 // Timeout for link establishment in seconds per hop
|
||||
KeepaliveTimeoutFactor = 4 // RTT timeout factor for link timeout calculation
|
||||
StaleGrace = 2 // Grace period in seconds for link timeout
|
||||
Keepalive = 360 // Interval for sending keep-alive packets in seconds
|
||||
StaleTime = 720 // Time after which link is considered stale
|
||||
|
||||
// Direction constants
|
||||
OUT = 0x02
|
||||
IN = 0x01
|
||||
|
||||
// Destination type constants
|
||||
SINGLE = 0x00
|
||||
GROUP = 0x01
|
||||
PLAIN = 0x02
|
||||
)
|
||||
|
||||
type PathInfo struct {
|
||||
NextHop []byte
|
||||
Interface string
|
||||
Hops uint8
|
||||
LastUpdated time.Time
|
||||
}
|
||||
|
||||
type Transport struct {
|
||||
config *common.ReticulumConfig
|
||||
interfaces map[string]common.NetworkInterface
|
||||
paths map[string]*common.Path
|
||||
announceHandlers []AnnounceHandler
|
||||
mutex sync.RWMutex
|
||||
handlerLock sync.RWMutex
|
||||
pathLock sync.RWMutex
|
||||
}
|
||||
|
||||
func NewTransport(config *common.ReticulumConfig) (*Transport, error) {
|
||||
t := &Transport{
|
||||
config: config,
|
||||
interfaces: make(map[string]common.NetworkInterface),
|
||||
paths: make(map[string]*common.Path),
|
||||
}
|
||||
|
||||
transportMutex.Lock()
|
||||
transportInstance = t
|
||||
transportMutex.Unlock()
|
||||
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// Add GetTransportInstance function
|
||||
func GetTransportInstance() *Transport {
|
||||
transportMutex.Lock()
|
||||
defer transportMutex.Unlock()
|
||||
return transportInstance
|
||||
}
|
||||
|
||||
// Update the interface methods
|
||||
func (t *Transport) RegisterInterface(name string, iface common.NetworkInterface) error {
|
||||
t.mutex.Lock()
|
||||
defer t.mutex.Unlock()
|
||||
|
||||
if _, exists := t.interfaces[name]; exists {
|
||||
return errors.New("interface already registered")
|
||||
}
|
||||
|
||||
t.interfaces[name] = iface
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *Transport) GetInterface(name string) (common.NetworkInterface, error) {
|
||||
t.mutex.RLock()
|
||||
defer t.mutex.RUnlock()
|
||||
|
||||
iface, exists := t.interfaces[name]
|
||||
if !exists {
|
||||
return nil, errors.New("interface not found")
|
||||
}
|
||||
|
||||
return iface, nil
|
||||
}
|
||||
|
||||
// Update the Close method
|
||||
func (t *Transport) Close() error {
|
||||
t.mutex.Lock()
|
||||
defer t.mutex.Unlock()
|
||||
|
||||
for _, iface := range t.interfaces {
|
||||
iface.Detach()
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type Link struct {
|
||||
destination []byte
|
||||
establishedAt time.Time
|
||||
lastInbound time.Time
|
||||
lastOutbound time.Time
|
||||
lastData time.Time
|
||||
rtt time.Duration
|
||||
establishedCb func()
|
||||
closedCb func()
|
||||
packetCb func([]byte)
|
||||
resourceCb func(interface{}) bool
|
||||
resourceStrategy int
|
||||
}
|
||||
|
||||
type Destination struct {
|
||||
Identity interface{}
|
||||
Direction int
|
||||
Type int
|
||||
AppName string
|
||||
Aspects []string
|
||||
}
|
||||
|
||||
func NewLink(dest []byte, establishedCallback func(), closedCallback func()) *Link {
|
||||
return &Link{
|
||||
destination: dest,
|
||||
establishedAt: time.Now(),
|
||||
lastInbound: time.Now(),
|
||||
lastOutbound: time.Now(),
|
||||
lastData: time.Now(),
|
||||
establishedCb: establishedCallback,
|
||||
closedCb: closedCallback,
|
||||
}
|
||||
}
|
||||
|
||||
// Link methods
|
||||
func (l *Link) GetAge() time.Duration {
|
||||
return time.Since(l.establishedAt)
|
||||
}
|
||||
|
||||
func (l *Link) NoInboundFor() time.Duration {
|
||||
return time.Since(l.lastInbound)
|
||||
}
|
||||
|
||||
func (l *Link) NoOutboundFor() time.Duration {
|
||||
return time.Since(l.lastOutbound)
|
||||
}
|
||||
|
||||
func (l *Link) NoDataFor() time.Duration {
|
||||
return time.Since(l.lastData)
|
||||
}
|
||||
|
||||
func (l *Link) InactiveFor() time.Duration {
|
||||
inbound := l.NoInboundFor()
|
||||
outbound := l.NoOutboundFor()
|
||||
if inbound < outbound {
|
||||
return inbound
|
||||
}
|
||||
return outbound
|
||||
}
|
||||
|
||||
func (l *Link) SetPacketCallback(cb func([]byte)) {
|
||||
l.packetCb = cb
|
||||
}
|
||||
|
||||
func (l *Link) SetResourceCallback(cb func(interface{}) bool) {
|
||||
l.resourceCb = cb
|
||||
}
|
||||
|
||||
func (l *Link) Teardown() {
|
||||
if l.closedCb != nil {
|
||||
l.closedCb()
|
||||
}
|
||||
}
|
||||
|
||||
func (l *Link) Send(data []byte) error {
|
||||
l.lastOutbound = time.Now()
|
||||
l.lastData = time.Now()
|
||||
|
||||
packet := &LinkPacket{
|
||||
Destination: l.destination,
|
||||
Data: data,
|
||||
Timestamp: time.Now(),
|
||||
}
|
||||
|
||||
if l.rtt == 0 {
|
||||
l.rtt = l.InactiveFor()
|
||||
}
|
||||
|
||||
return packet.send()
|
||||
}
|
||||
|
||||
type AnnounceHandler interface {
|
||||
ReceivedAnnounce(destinationHash []byte, identity interface{}, appData []byte)
|
||||
}
|
||||
|
||||
func (t *Transport) RegisterAnnounceHandler(handler AnnounceHandler) {
|
||||
t.handlerLock.Lock()
|
||||
defer t.handlerLock.Unlock()
|
||||
t.announceHandlers = append(t.announceHandlers, handler)
|
||||
}
|
||||
|
||||
func (t *Transport) DeregisterAnnounceHandler(handler AnnounceHandler) {
|
||||
t.handlerLock.Lock()
|
||||
defer t.handlerLock.Unlock()
|
||||
for i, h := range t.announceHandlers {
|
||||
if h == handler {
|
||||
t.announceHandlers = append(t.announceHandlers[:i], t.announceHandlers[i+1:]...)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Transport) HasPath(destinationHash []byte) bool {
|
||||
t.pathLock.RLock()
|
||||
defer t.pathLock.RUnlock()
|
||||
|
||||
path, exists := t.paths[string(destinationHash)]
|
||||
if !exists {
|
||||
return false
|
||||
}
|
||||
|
||||
// Check if path is still valid (not expired)
|
||||
if time.Since(path.LastUpdated) > time.Duration(PathRequestTTL)*time.Second {
|
||||
delete(t.paths, string(destinationHash))
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
func (t *Transport) HopsTo(destinationHash []byte) uint8 {
|
||||
t.pathLock.RLock()
|
||||
defer t.pathLock.RUnlock()
|
||||
|
||||
path, exists := t.paths[string(destinationHash)]
|
||||
if !exists {
|
||||
return PathfinderM
|
||||
}
|
||||
|
||||
return path.Hops
|
||||
}
|
||||
|
||||
func (t *Transport) NextHop(destinationHash []byte) []byte {
|
||||
t.pathLock.RLock()
|
||||
defer t.pathLock.RUnlock()
|
||||
|
||||
path, exists := t.paths[string(destinationHash)]
|
||||
if !exists {
|
||||
return nil
|
||||
}
|
||||
|
||||
return path.NextHop
|
||||
}
|
||||
|
||||
func (t *Transport) NextHopInterface(destinationHash []byte) string {
|
||||
t.pathLock.RLock()
|
||||
defer t.pathLock.RUnlock()
|
||||
|
||||
path, exists := t.paths[string(destinationHash)]
|
||||
if !exists {
|
||||
return ""
|
||||
}
|
||||
|
||||
return path.Interface.GetName()
|
||||
}
|
||||
|
||||
func (t *Transport) RequestPath(destinationHash []byte, onInterface string, tag []byte, recursive bool) error {
|
||||
packet := &PathRequest{
|
||||
DestinationHash: destinationHash,
|
||||
Tag: tag,
|
||||
TTL: PathRequestTTL,
|
||||
Recursive: recursive,
|
||||
}
|
||||
|
||||
if onInterface != "" {
|
||||
return t.sendPathRequest(packet, onInterface)
|
||||
}
|
||||
|
||||
return t.broadcastPathRequest(packet)
|
||||
}
|
||||
|
||||
func (t *Transport) UpdatePath(destinationHash []byte, nextHop []byte, interfaceName string, hops uint8) {
|
||||
t.pathLock.Lock()
|
||||
defer t.pathLock.Unlock()
|
||||
|
||||
iface, err := t.GetInterface(interfaceName)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
t.paths[string(destinationHash)] = &common.Path{
|
||||
Interface: iface,
|
||||
NextHop: nextHop,
|
||||
Hops: hops,
|
||||
LastUpdated: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Transport) HandleAnnounce(destinationHash []byte, identity []byte, appData []byte) {
|
||||
t.handlerLock.RLock()
|
||||
defer t.handlerLock.RUnlock()
|
||||
|
||||
for _, handler := range t.announceHandlers {
|
||||
handler.ReceivedAnnounce(destinationHash, identity, appData)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Transport) NewDestination(identity interface{}, direction int, destType int, appName string, aspects ...string) *Destination {
|
||||
return &Destination{
|
||||
Identity: identity,
|
||||
Direction: direction,
|
||||
Type: destType,
|
||||
AppName: appName,
|
||||
Aspects: aspects,
|
||||
}
|
||||
}
|
||||
|
||||
func (t *Transport) NewLink(dest []byte, establishedCallback func(), closedCallback func()) *Link {
|
||||
return NewLink(dest, establishedCallback, closedCallback)
|
||||
}
|
||||
|
||||
type PathRequest struct {
|
||||
DestinationHash []byte
|
||||
Tag []byte
|
||||
TTL int
|
||||
Recursive bool
|
||||
}
|
||||
|
||||
type LinkPacket struct {
|
||||
Destination []byte
|
||||
Data []byte
|
||||
Timestamp time.Time
|
||||
}
|
||||
|
||||
func (p *LinkPacket) send() error {
|
||||
// Get transport instance
|
||||
t := GetTransportInstance()
|
||||
|
||||
// Create packet header
|
||||
header := make([]byte, 0, 64)
|
||||
header = append(header, 0x02) // Link packet type
|
||||
header = append(header, p.Destination...)
|
||||
|
||||
// Add timestamp
|
||||
ts := make([]byte, 8)
|
||||
binary.BigEndian.PutUint64(ts, uint64(p.Timestamp.Unix()))
|
||||
header = append(header, ts...)
|
||||
|
||||
// Combine header and data
|
||||
packet := append(header, p.Data...)
|
||||
|
||||
// Get next hop info
|
||||
nextHop := t.NextHop(p.Destination)
|
||||
if nextHop == nil {
|
||||
return errors.New("no path to destination")
|
||||
}
|
||||
|
||||
// Get interface for next hop
|
||||
ifaceName := t.NextHopInterface(p.Destination)
|
||||
iface, ok := t.interfaces[ifaceName]
|
||||
if !ok {
|
||||
return errors.New("interface not found")
|
||||
}
|
||||
|
||||
// Send packet using interface's Send method
|
||||
return iface.Send(packet, "")
|
||||
}
|
||||
|
||||
func (t *Transport) sendPathRequest(req *PathRequest, interfaceName string) error {
|
||||
// Create path request packet
|
||||
packet := &PathRequestPacket{
|
||||
Type: 0x01,
|
||||
DestinationHash: req.DestinationHash,
|
||||
Tag: req.Tag,
|
||||
TTL: byte(req.TTL),
|
||||
Recursive: req.Recursive,
|
||||
}
|
||||
|
||||
// Serialize packet
|
||||
buf := make([]byte, 0, 128)
|
||||
buf = append(buf, packet.Type)
|
||||
buf = append(buf, packet.DestinationHash...)
|
||||
buf = append(buf, packet.Tag...)
|
||||
buf = append(buf, packet.TTL)
|
||||
if packet.Recursive {
|
||||
buf = append(buf, 0x01)
|
||||
} else {
|
||||
buf = append(buf, 0x00)
|
||||
}
|
||||
|
||||
// Get interface
|
||||
iface, ok := t.interfaces[interfaceName]
|
||||
if !ok {
|
||||
return errors.New("interface not found")
|
||||
}
|
||||
|
||||
return iface.Send(buf, "")
|
||||
}
|
||||
|
||||
func (t *Transport) broadcastPathRequest(req *PathRequest) error {
|
||||
var lastErr error
|
||||
for _, iface := range t.interfaces {
|
||||
if !iface.IsEnabled() {
|
||||
continue
|
||||
}
|
||||
|
||||
if err := t.sendPathRequest(req, iface.GetName()); err != nil {
|
||||
lastErr = err
|
||||
}
|
||||
}
|
||||
return lastErr
|
||||
}
|
||||
|
||||
type PathRequestPacket struct {
|
||||
Type byte // 0x01 for path request
|
||||
DestinationHash []byte // 32 bytes
|
||||
Tag []byte // Variable length
|
||||
TTL byte
|
||||
Recursive bool
|
||||
}
|
||||
|
||||
type NetworkInterface struct {
|
||||
Name string
|
||||
Addr *net.UDPAddr
|
||||
Conn *net.UDPConn
|
||||
MTU int
|
||||
Enabled bool
|
||||
}
|
||||
|
||||
func SendAnnounce(packet []byte) error {
|
||||
t := GetTransportInstance()
|
||||
if t == nil {
|
||||
return errors.New("transport not initialized")
|
||||
}
|
||||
|
||||
// Send announce packet to all interfaces
|
||||
var lastErr error
|
||||
for _, iface := range t.interfaces {
|
||||
if err := iface.Send(packet, ""); err != nil {
|
||||
lastErr = err
|
||||
}
|
||||
}
|
||||
|
||||
return lastErr
|
||||
}
|
||||
Reference in New Issue
Block a user