From 8325666301939fc1910473deed78626dd443bed9 Mon Sep 17 00:00:00 2001
From: Sudo-Ivan <ivan@quad4.io>
Date: Fri, 2 Jan 2026 17:48:15 -0600
Subject: [PATCH] feat(interfaces): add transmission and reception metrics to
 BaseInterface

---
 pkg/common/interfaces.go    | 46 ++++++++++++++++++--
 pkg/interfaces/interface.go | 85 +++++++++++++++++++++++++------------
 2 files changed, 101 insertions(+), 30 deletions(-)

diff --git a/pkg/common/interfaces.go b/pkg/common/interfaces.go
index c505aee..30877e8 100644
--- a/pkg/common/interfaces.go
+++ b/pkg/common/interfaces.go
@@ -39,6 +39,10 @@ type NetworkInterface interface {
 	SendLinkPacket([]byte, []byte, time.Time) error
 	SetPacketCallback(PacketCallback)
 	GetPacketCallback() PacketCallback
+	GetTxBytes() uint64
+	GetRxBytes() uint64
+	GetTxPackets() uint64
+	GetRxPackets() uint64
 }
 
 // BaseInterface provides common implementation for network interfaces
@@ -56,9 +60,11 @@ type BaseInterface struct {
 	MTU     int
 	Bitrate int64
 
-	TxBytes uint64
-	RxBytes uint64
-	lastTx  time.Time
+	TxBytes   uint64
+	RxBytes   uint64
+	TxPackets uint64
+	RxPackets uint64
+	lastTx    time.Time
 
 	Mutex          sync.RWMutex
 	Owner          interface{}
@@ -125,6 +131,30 @@ func (i *BaseInterface) GetPacketCallback() PacketCallback {
 	return i.PacketCallback
 }
 
+func (i *BaseInterface) GetTxBytes() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.TxBytes
+}
+
+func (i *BaseInterface) GetRxBytes() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.RxBytes
+}
+
+func (i *BaseInterface) GetTxPackets() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.TxPackets
+}
+
+func (i *BaseInterface) GetRxPackets() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.RxPackets
+}
+
 func (i *BaseInterface) Detach() {
 	i.Mutex.Lock()
 	defer i.Mutex.Unlock()
@@ -160,10 +190,20 @@ func (i *BaseInterface) GetConn() net.Conn {
 }
 
 func (i *BaseInterface) Send(data []byte, address string) error {
+	i.Mutex.Lock()
+	i.TxBytes += uint64(len(data))
+	i.TxPackets++
+	i.lastTx = time.Now()
+	i.Mutex.Unlock()
 	return i.ProcessOutgoing(data)
 }
 
 func (i *BaseInterface) ProcessIncoming(data []byte) {
+	i.Mutex.Lock()
+	i.RxBytes += uint64(len(data))
+	i.RxPackets++
+	i.Mutex.Unlock()
+
 	if i.PacketCallback != nil {
 		i.PacketCallback(data, i)
 	}
diff --git a/pkg/interfaces/interface.go b/pkg/interfaces/interface.go
index 1af48a0..54ca857 100644
--- a/pkg/interfaces/interface.go
+++ b/pkg/interfaces/interface.go
@@ -56,20 +56,22 @@ type Interface interface {
 }
 
 type BaseInterface struct {
-	Name     string
-	Mode     common.InterfaceMode
-	Type     common.InterfaceType
-	Online   bool
-	Enabled  bool
-	Detached bool
-	IN       bool
-	OUT      bool
-	MTU      int
-	Bitrate  int64
-	TxBytes  uint64
-	RxBytes  uint64
-	lastTx   time.Time
-	lastRx   time.Time
+	Name      string
+	Mode      common.InterfaceMode
+	Type      common.InterfaceType
+	Online    bool
+	Enabled   bool
+	Detached  bool
+	IN        bool
+	OUT       bool
+	MTU       int
+	Bitrate   int64
+	TxBytes   uint64
+	RxBytes   uint64
+	TxPackets uint64
+	RxPackets uint64
+	lastTx    time.Time
+	lastRx    time.Time
 
 	Mutex          sync.RWMutex
 	packetCallback common.PacketCallback
@@ -77,18 +79,22 @@ type BaseInterface struct {
 
 func NewBaseInterface(name string, ifType common.InterfaceType, enabled bool) BaseInterface {
 	return BaseInterface{
-		Name:     name,
-		Mode:     common.IF_MODE_FULL,
-		Type:     ifType,
-		Online:   false,
-		Enabled:  enabled,
-		Detached: false,
-		IN:       false,
-		OUT:      false,
-		MTU:      common.DEFAULT_MTU,
-		Bitrate:  BITRATE_MINIMUM,
-		lastTx:   time.Now(),
-		lastRx:   time.Now(),
+		Name:      name,
+		Mode:      common.IF_MODE_FULL,
+		Type:      ifType,
+		Online:    false,
+		Enabled:   enabled,
+		Detached:  false,
+		IN:        false,
+		OUT:       false,
+		MTU:       common.DEFAULT_MTU,
+		Bitrate:   BITRATE_MINIMUM,
+		TxBytes:   0,
+		RxBytes:   0,
+		TxPackets: 0,
+		RxPackets: 0,
+		lastTx:    time.Now(),
+		lastRx:    time.Now(),
 	}
 }
 
@@ -107,6 +113,7 @@ func (i *BaseInterface) GetPacketCallback() common.PacketCallback {
 func (i *BaseInterface) ProcessIncoming(data []byte) {
 	i.Mutex.Lock()
 	i.RxBytes += uint64(len(data))
+	i.RxPackets++
 	i.Mutex.Unlock()
 
 	i.Mutex.RLock()
@@ -126,6 +133,7 @@ func (i *BaseInterface) ProcessOutgoing(data []byte) error {
 
 	i.Mutex.Lock()
 	i.TxBytes += uint64(len(data))
+	i.TxPackets++
 	i.Mutex.Unlock()
 
 	debug.Log(debug.DEBUG_VERBOSE, "Interface processed outgoing packet", "name", i.Name, "bytes", len(data), "total_tx", i.TxBytes)
@@ -221,6 +229,30 @@ func (i *BaseInterface) IsDetached() bool {
 	return i.Detached
 }
 
+func (i *BaseInterface) GetTxBytes() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.TxBytes
+}
+
+func (i *BaseInterface) GetRxBytes() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.RxBytes
+}
+
+func (i *BaseInterface) GetTxPackets() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.TxPackets
+}
+
+func (i *BaseInterface) GetRxPackets() uint64 {
+	i.Mutex.RLock()
+	defer i.Mutex.RUnlock()
+	return i.RxPackets
+}
+
 func (i *BaseInterface) Start() error {
 	return nil
 }
@@ -272,7 +304,6 @@ func (i *BaseInterface) updateBandwidthStats(bytes uint64) {
 	i.Mutex.Lock()
 	defer i.Mutex.Unlock()
 
-	i.TxBytes += bytes
 	i.lastTx = time.Now()
 
 	debug.Log(debug.DEBUG_VERBOSE, "Interface updated bandwidth stats", "name", i.Name, "tx_bytes", i.TxBytes, "last_tx", i.lastTx)