nsm.patch

diff --git a/environment/docker/stats.go b/environment/docker/stats.go
index 7a984399c4f0587e63b41f9bd23e11e67b97cce2..1f6642753d695dd5ecc0c456ac5d5434527ccd88 100644
--- a/environment/docker/stats.go
+++ b/environment/docker/stats.go
@@ -88,6 +88,12 @@ func (e *Environment) pollResources(ctx context.Context) error {
 			for _, nw := range v.Networks {
 				st.Network.RxBytes += nw.RxBytes
 				st.Network.TxBytes += nw.TxBytes
+				st.Network.RxPackets += nw.RxPackets
+				st.Network.TxPackets += nw.TxPackets
+				st.Network.RxErrors += nw.RxErrors
+				st.Network.TxErrors += nw.TxErrors
+				st.Network.RxDropped += nw.RxDropped
+				st.Network.TxDropped += nw.TxDropped
 			}
 
 			e.Events().Publish(environment.ResourceEvent, st)
diff --git a/environment/stats.go b/environment/stats.go
index 5d5c8720307f3d0c717d159eb9be6f851ac25925..9d3084232d9118845e666b201f330ac56291a37c 100644
--- a/environment/stats.go
+++ b/environment/stats.go
@@ -25,6 +25,12 @@ type Stats struct {
 }
 
 type NetworkStats struct {
-	RxBytes uint64 `json:"rx_bytes"`
-	TxBytes uint64 `json:"tx_bytes"`
+	RxBytes   uint64 `json:"rx_bytes"`
+	TxBytes   uint64 `json:"tx_bytes"`
+	RxPackets uint64 `json:"rx_packets"`
+	TxPackets uint64 `json:"tx_packets"`
+	RxErrors  uint64 `json:"rx_errors"`
+	TxErrors  uint64 `json:"tx_errors"`
+	RxDropped uint64 `json:"rx_dropped"`
+	TxDropped uint64 `json:"tx_dropped"`
 }
diff --git a/router/nsm_router.go b/router/nsm_router.go
new file mode 100644
index 0000000000000000000000000000000000000000..fea5c8df7254725837f5c262047d4c8e62970dfc
--- /dev/null
+++ b/router/nsm_router.go
@@ -0,0 +1,23 @@
+package router
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/pterodactyl/wings/router/middleware"
+)
+
+func getServerProtocolStats(c *gin.Context) {
+	s := ExtractServer(c)
+
+	stats, err := s.GetProtocolStats(c.Request.Context())
+	if err != nil {
+		middleware.CaptureAndAbort(c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"data": stats,
+	})
+}
diff --git a/router/router.go b/router/router.go
index bdac76065242c834f37f74a68fdba2211df96125..411eee4bd6ed7b5eddf9d92f677297fb7ff46bb3 100644
--- a/router/router.go
+++ b/router/router.go
@@ -77,6 +77,7 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 		server.DELETE("", deleteServer)
 
 		server.GET("/logs", getServerLogs)
+		server.GET("/stats/protocols", getServerProtocolStats)
 		server.POST("/power", postServerPower)
 		server.POST("/commands", postServerCommands)
 		server.POST("/install", postServerInstall)
diff --git a/server/protocol_monitor.go b/server/protocol_monitor.go
new file mode 100644
index 0000000000000000000000000000000000000000..acea374a068b0e4b103bddd3af10b4aeb36f71ce
--- /dev/null
+++ b/server/protocol_monitor.go
@@ -0,0 +1,85 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"sync"
+	"time"
+)
+
+type ProtocolMonitor struct {
+	mu       sync.RWMutex
+	server   *Server
+	stats    *ProtocolStats
+	enabled  bool
+	stopChan chan struct{}
+}
+
+func NewProtocolMonitor(s *Server) *ProtocolMonitor {
+	return &ProtocolMonitor{
+		server:   s,
+		stats:    &ProtocolStats{},
+		enabled:  false,
+		stopChan: make(chan struct{}),
+	}
+}
+
+func (pm *ProtocolMonitor) Start() error {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if pm.enabled {
+		return nil
+	}
+
+	pm.enabled = true
+	go pm.run()
+
+	return nil
+}
+
+func (pm *ProtocolMonitor) Stop() {
+	pm.mu.Lock()
+	defer pm.mu.Unlock()
+
+	if !pm.enabled {
+		return
+	}
+
+	pm.enabled = false
+	close(pm.stopChan)
+	pm.stopChan = make(chan struct{})
+}
+
+func (pm *ProtocolMonitor) run() {
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-pm.stopChan:
+			return
+		case <-ticker.C:
+			stats, err := pm.server.GetProtocolStats(context.Background())
+			if err != nil {
+				pm.server.Log().WithError(err).Warn("failed to get protocol stats")
+				continue
+			}
+
+			pm.mu.Lock()
+			pm.stats = stats
+			pm.mu.Unlock()
+
+			if b, err := json.Marshal(stats); err == nil {
+				pm.server.Events().Publish(ProtocolStatsEvent, string(b))
+			}
+		}
+	}
+}
+
+func (pm *ProtocolMonitor) Stats() *ProtocolStats {
+	pm.mu.RLock()
+	defer pm.mu.RUnlock()
+
+	return pm.stats
+}
diff --git a/server/protocol_stats.go b/server/protocol_stats.go
new file mode 100644
index 0000000000000000000000000000000000000000..1fcc0a6b9a82d0fdcae7fe28ab07a7bf17ebf9ca
--- /dev/null
+++ b/server/protocol_stats.go
@@ -0,0 +1,135 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/pterodactyl/wings/environment/docker"
+)
+
+const ProtocolStatsEvent = "protocol stats"
+
+type ProtocolStats struct {
+	Total struct {
+		InPackets  uint64 `json:"in_packets"`
+		OutPackets uint64 `json:"out_packets"`
+	} `json:"total"`
+	TCP struct {
+		InPackets  uint64 `json:"in_packets"`
+		OutPackets uint64 `json:"out_packets"`
+		InErrors   uint64 `json:"in_errors"`
+		OutErrors  uint64 `json:"out_errors"`
+	} `json:"tcp"`
+	UDP struct {
+		InDatagrams  uint64 `json:"in_datagrams"`
+		OutDatagrams uint64 `json:"out_datagrams"`
+		InErrors     uint64 `json:"in_errors"`
+		NoPorts      uint64 `json:"no_ports"`
+	} `json:"udp"`
+	ICMP struct {
+		InMsgs    uint64 `json:"in_msgs"`
+		OutMsgs   uint64 `json:"out_msgs"`
+		InErrors  uint64 `json:"in_errors"`
+		OutErrors uint64 `json:"out_errors"`
+	} `json:"icmp"`
+	Other struct {
+		InPackets  uint64 `json:"in_packets"`
+		OutPackets uint64 `json:"out_packets"`
+	} `json:"other"`
+}
+
+func (s *Server) GetProtocolStats(ctx context.Context) (*ProtocolStats, error) {
+	stats := &ProtocolStats{}
+	env, ok := s.Environment.(*docker.Environment)
+	if !ok {
+		return stats, nil
+	}
+	cmd := exec.Command("docker", "exec", env.Id, "cat", "/proc/net/dev")
+	output, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get network device stats: %v", err)
+	}
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		if strings.Contains(line, "eth0:") {
+			fields := strings.Fields(line)
+			if len(fields) >= 11 {
+				fmt.Sscanf(fields[2], "%d", &stats.Total.InPackets)
+				fmt.Sscanf(fields[10], "%d", &stats.Total.OutPackets)
+			}
+			break
+		}
+	}
+	cmd = exec.Command("docker", "exec", env.Id, "cat", "/proc/net/snmp")
+	output, err = cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get protocol stats: %v", err)
+	}
+	lines = strings.Split(string(output), "\n")
+	for i := 0; i < len(lines)-1; i += 2 {
+		header := strings.Fields(lines[i])
+		values := strings.Fields(lines[i+1])
+
+		if len(header) == 0 || len(values) == 0 {
+			continue
+		}
+
+		switch header[0] {
+		case "Tcp:":
+			for j, field := range header[1:] {
+				switch field {
+				case "InSegs":
+					fmt.Sscanf(values[j+1], "%d", &stats.TCP.InPackets)
+				case "OutSegs":
+					fmt.Sscanf(values[j+1], "%d", &stats.TCP.OutPackets)
+				case "InErrs":
+					fmt.Sscanf(values[j+1], "%d", &stats.TCP.InErrors)
+				case "OutRsts":
+					fmt.Sscanf(values[j+1], "%d", &stats.TCP.OutErrors)
+				}
+			}
+
+		case "Udp:":
+			for j, field := range header[1:] {
+				switch field {
+				case "InDatagrams":
+					fmt.Sscanf(values[j+1], "%d", &stats.UDP.InDatagrams)
+				case "OutDatagrams":
+					fmt.Sscanf(values[j+1], "%d", &stats.UDP.OutDatagrams)
+				case "InErrors":
+					fmt.Sscanf(values[j+1], "%d", &stats.UDP.InErrors)
+				case "NoPorts":
+					fmt.Sscanf(values[j+1], "%d", &stats.UDP.NoPorts)
+				}
+			}
+
+		case "Icmp:":
+			for j, field := range header[1:] {
+				switch field {
+				case "InMsgs":
+					fmt.Sscanf(values[j+1], "%d", &stats.ICMP.InMsgs)
+				case "OutMsgs":
+					fmt.Sscanf(values[j+1], "%d", &stats.ICMP.OutMsgs)
+				case "InErrors":
+					fmt.Sscanf(values[j+1], "%d", &stats.ICMP.InErrors)
+				case "OutErrors":
+					fmt.Sscanf(values[j+1], "%d", &stats.ICMP.OutErrors)
+				}
+			}
+		}
+	}
+
+	protocolInSum := stats.TCP.InPackets + stats.UDP.InDatagrams + stats.ICMP.InMsgs
+	if protocolInSum <= stats.Total.InPackets {
+		stats.Other.InPackets = stats.Total.InPackets - protocolInSum
+	}
+
+	protocolOutSum := stats.TCP.OutPackets + stats.UDP.OutDatagrams + stats.ICMP.OutMsgs
+	if protocolOutSum <= stats.Total.OutPackets {
+		stats.Other.OutPackets = stats.Total.OutPackets - protocolOutSum
+	}
+
+	return stats, nil
+}
diff --git a/server/resources.go b/server/resources.go
index e11adf59a791aa1c34507cf0ab2e56e87bf8ddb4..d0ef20173835e88178ea4072829d9f6bc4710466 100644
--- a/server/resources.go
+++ b/server/resources.go
@@ -56,4 +56,6 @@ func (ru *ResourceUsage) Reset() {
 	ru.Uptime = 0
 	ru.Network.TxBytes = 0
 	ru.Network.RxBytes = 0
+	ru.Network.TxPackets = 0
+	ru.Network.RxPackets = 0
 }