update clients

cmd/reticulum-go/main.go

@@ -6,10 +6,14 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
 	"github.com/Sudo-Ivan/reticulum-go/internal/config"
+	"github.com/Sudo-Ivan/reticulum-go/pkg/buffer"
+	"github.com/Sudo-Ivan/reticulum-go/pkg/channel"
 	"github.com/Sudo-Ivan/reticulum-go/pkg/common"
 	"github.com/Sudo-Ivan/reticulum-go/pkg/interfaces"
+	"github.com/Sudo-Ivan/reticulum-go/pkg/packet"
 	"github.com/Sudo-Ivan/reticulum-go/pkg/transport"
 )
 
@@ -17,6 +21,8 @@ type Reticulum struct {
 	config     *common.ReticulumConfig
 	transport  *transport.Transport
 	interfaces []interfaces.Interface
+	channels   map[string]*channel.Channel
+	buffers    map[string]*buffer.Buffer
 }
 
 func NewReticulum(cfg *common.ReticulumConfig) (*Reticulum, error) {
@@ -33,9 +39,45 @@ func NewReticulum(cfg *common.ReticulumConfig) (*Reticulum, error) {
 		config:     cfg,
 		transport:  t,
 		interfaces: make([]interfaces.Interface, 0),
+		channels:   make(map[string]*channel.Channel),
+		buffers:    make(map[string]*buffer.Buffer),
 	}, nil
 }
 
+func (r *Reticulum) handleInterface(iface common.NetworkInterface) {
+	// Create channel using transport wrapper
+	ch := channel.NewChannel(&transportWrapper{r.transport})
+	r.channels[iface.GetName()] = ch
+
+	// Create bidirectional buffer
+	rw := buffer.CreateBidirectionalBuffer(
+		1, // Receive stream ID
+		2, // Send stream ID
+		ch,
+		func(size int) {
+			// Handle data ready callback
+			data := make([]byte, size)
+			iface.ProcessIncoming(data)
+			r.transport.HandlePacket(data, iface)
+		},
+	)
+
+	// Store the buffer
+	r.buffers[iface.GetName()] = &buffer.Buffer{
+		ReadWriter: rw,
+	}
+
+	// Set up packet callback
+	iface.SetPacketCallback(func(data []byte, ni common.NetworkInterface) {
+		if buf, ok := r.buffers[ni.GetName()]; ok {
+			if _, err := buf.Write(data); err != nil {
+				log.Printf("Error writing to buffer for interface %s: %v", ni.GetName(), err)
+			}
+		}
+		r.transport.HandlePacket(data, ni)
+	})
+}
+
 func (r *Reticulum) Start() error {
 	log.Printf("Starting Reticulum...")
 
@@ -146,12 +188,7 @@ func (r *Reticulum) Start() error {
 			}
 
 			netIface := iface.(common.NetworkInterface)
-
-			callback := func(data []byte, ni common.NetworkInterface) {
-				r.transport.HandlePacket(data, ni)
-			}
-
-			netIface.SetPacketCallback(callback)
+			r.handleInterface(netIface)
 			r.interfaces = append(r.interfaces, iface)
 			log.Printf("Created and started interface %s (type=%v, enabled=%v)",
 				iface.GetName(), iface.GetType(), iface.IsEnabled())
@@ -165,6 +202,21 @@ func (r *Reticulum) Start() error {
 }
 
 func (r *Reticulum) Stop() error {
+	// Close all buffers
+	for _, buf := range r.buffers {
+		if err := buf.Close(); err != nil {
+			log.Printf("Error closing buffer: %v", err)
+		}
+	}
+
+	// Close all channels
+	for _, ch := range r.channels {
+		if err := ch.Close(); err != nil {
+			log.Printf("Error closing channel: %v", err)
+		}
+	}
+
+	// Stop interfaces
 	for _, iface := range r.interfaces {
 		if err := iface.Stop(); err != nil {
 			log.Printf("Error stopping interface %s: %v", iface.GetName(), err)
@@ -204,3 +256,53 @@ func main() {
 	}
 	log.Printf("Goodbye!")
 }
+
+// Update transportWrapper to use packet.Packet
+type transportWrapper struct {
+	*transport.Transport
+}
+
+func (tw *transportWrapper) GetRTT() float64 {
+	return 0.1 // Default value for now
+}
+
+func (tw *transportWrapper) RTT() float64 {
+	return tw.GetRTT()
+}
+
+func (tw *transportWrapper) GetStatus() int {
+	return transport.STATUS_ACTIVE
+}
+
+func (tw *transportWrapper) Send(data []byte) interface{} {
+	p := &packet.Packet{
+		Header: [2]byte{
+			packet.PacketTypeData, // First byte
+			0,                     // Second byte (hops)
+		},
+		Data: data,
+	}
+
+	err := tw.Transport.SendPacket(p)
+	if err != nil {
+		return nil
+	}
+	return p
+}
+
+func (tw *transportWrapper) Resend(p interface{}) error {
+	if pkt, ok := p.(*packet.Packet); ok {
+		return tw.Transport.SendPacket(pkt)
+	}
+	return fmt.Errorf("invalid packet type")
+}
+
+func (tw *transportWrapper) SetPacketTimeout(packet interface{}, callback func(interface{}), timeout time.Duration) {
+	time.AfterFunc(timeout, func() {
+		callback(packet)
+	})
+}
+
+func (tw *transportWrapper) SetPacketDelivered(packet interface{}, callback func(interface{})) {
+	callback(packet)
+}