* add UDP RTT

Author: sg

client/auto.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"bufio"
+	"context"
 	"fmt"
 	"log"
 	"os"
@@ -62,6 +63,25 @@ func RunAutoMode() {
 func runAutoTests(target, transferType string, blocksize uint32) {
 	const conns = 3
 
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	go func() {
+		ticker := time.NewTicker(time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				if ms, ok := UDPLatencyProbe(target); ok {
+					fmt.Printf("  [UDP RTT] %s\n", formatUDPLatency(ms))
+				} else {
+					fmt.Printf("  [UDP RTT] ---\n")
+				}
+			}
+		}
+	}()
+
 	fmt.Println("Test 1: Download 10s (3 connections)...")
 	deadline1 := time.Now().Add(AutoTestDuration)
 	var wg sync.WaitGroup

client/client.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"net"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -53,6 +54,32 @@ func bytes2human(n int64, base int64) (str string) {
 	return fmt.Sprintf("%8.2f B", float64(n))
 }
 
+func UDPLatencyProbe(serverAddr string) (ms float64, ok bool) {
+	conn, err := net.DialTimeout("udp", serverAddr, 5*time.Second)
+	if err != nil {
+		return 0, false
+	}
+	defer conn.Close()
+	payload := []byte("ping")
+	start := time.Now()
+	if _, err := conn.Write(payload); err != nil {
+		return 0, false
+	}
+	buf := make([]byte, 64)
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+	if _, err := conn.Read(buf); err != nil {
+		return 0, false
+	}
+	return float64(time.Since(start).Nanoseconds()) / 1e6, true
+}
+
+func formatUDPLatency(ms float64) string {
+	if ms < 0.001 {
+		return "< 0.001 ms"
+	}
+	return fmt.Sprintf("%.3f ms", ms)
+}
+
 func connectServer(serverAddr string, localAddr string, transferType string) (transfer.Conn, error) {
 	var l transfer.Conn
 	var err error
@@ -152,7 +179,7 @@ exit:
 	wg.Done()
 }
 
-func DispalySpeed() {
+func DispalySpeed(serverAddr string) {
 	var last_up int64 = 0
 	var last_down int64 = 0
 
@@ -173,7 +200,13 @@ func DispalySpeed() {
 		}
 		now_up := atomic.LoadInt64(&total_write)
 		now_down := atomic.LoadInt64(&total_read)
-		log.Printf("down:%s/s     up:%s/s ...", bytes2human(now_down-last_down, 1000), bytes2human(now_up-last_up, 1000))
+		latencyStr := "---"
+		if serverAddr != "" {
+			if ms, ok := UDPLatencyProbe(serverAddr); ok {
+				latencyStr = formatUDPLatency(ms)
+			}
+		}
+		log.Printf("down:%s/s     up:%s/s     udp_rtt:%s", bytes2human(now_down-last_down, 1000), bytes2human(now_up-last_up, 1000), latencyStr)
 		last_up = now_up
 		last_down = now_down
 	}

netspeed.go

@@ -71,7 +71,7 @@ func main() {
 
 		}
 		if *onlyConnect != true {
-			go client.DispalySpeed()
+			go client.DispalySpeed(*caddress)
 		}
 
 	} else if *saddress != "" {

server/server.go

@@ -80,6 +80,31 @@ func parsePortFromAddress(address string) string {
 	return port
 }
 
+func ServeUDPEcho(port string) {
+	portNum, err := strconv.Atoi(port)
+	if err != nil || portNum <= 0 {
+		return
+	}
+	addr := &net.UDPAddr{IP: net.IPv4zero, Port: portNum}
+	conn, err := net.ListenUDP("udp4", addr)
+	if err != nil {
+		log.Printf("udp echo listen error: %v", err)
+		return
+	}
+	defer conn.Close()
+	log.Printf("udp echo listening on :%s (same port as TCP)", port)
+	buf := make([]byte, 256)
+	for {
+		n, remote, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			return
+		}
+		if n > 0 {
+			_, _ = conn.WriteToUDP(buf[:n], remote)
+		}
+	}
+}
+
 func ServerMain(address string, transferType string, wg *sync.WaitGroup) {
 	var l transfer.Listener
 	var err error
@@ -103,6 +128,7 @@ func ServerMain(address string, transferType string, wg *sync.WaitGroup) {
 	servicePort := parsePortFromAddress(address)
 	if servicePort != "" {
 		go ServeDiscovery(DiscoveryPort, servicePort)
+		go ServeUDPEcho(servicePort)
 	}
 	log.Printf("listen:%s %s", address, transferType)
 	for {