cmd/slicewriter/dummy_test.go

@@ -1,21 +1,5 @@
 package slicewriter
 
-/*
-   Copyright 2025 Suyono <suyono3484@gmail.com>
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
 import (
 	"sync"
 	"testing"

cmd/slicewriter/slicewriter.go

@@ -0,0 +1,36 @@
+package slicewriter
+
+import "io"
+
+type SliceWriter struct {
+	off int
+	buf []byte
+}
+
+func (w *SliceWriter) Write(p []byte) (int, error) {
+	if len(p)+w.off <= len(w.buf) {
+		copy(w.buf[w.off:], p)
+		w.off += len(p)
+		return len(p), nil
+	}
+
+	space := len(w.buf) - w.off
+	copy(w.buf[:w.off], p[:space])
+	w.off += space
+	return space, io.ErrShortWrite
+}
+
+func (w *SliceWriter) Reset() {
+	w.off = 0
+}
+
+func (w *SliceWriter) Bytes() []byte {
+	return w.buf[:w.off]
+}
+
+func NewSliceWriter(b []byte) *SliceWriter {
+	return &SliceWriter{
+		off: 0,
+		buf: b,
+	}
+}

cmd/test-client/main.go

@@ -18,64 +18,185 @@ package main
 
 import (
 	"context"
+	"fmt"
+	"net"
 	"os/signal"
 	"time"
 
 	"golang.org/x/sys/unix"
 
-	"gitea.suyono.dev/suyono/netbounce/testlib/client"
+	"gitea.suyono.dev/suyono/netbounce/cmd/slicewriter"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
 )
 
+var gLimit *counter
+
 func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), unix.SIGINT, unix.SIGTERM)
 	defer cancel()
 	parseFlags()
 
-	log.Debug().Caller().Msgf("Sending messages to %s server: %s", viper.GetString(client.PROTOCOL), viper.GetString(client.SERVER))
+	log.Debug().Caller().Msgf("Sending messages to %s server: %s", viper.GetString(PROTOCOL), viper.GetString(SERVER))
-	// sendMessages(ctx)
+	sendMessages(ctx)
-	client.SendMessages(ctx)
+}
+
+const (
+	SERVER      = "server"
+	PROTOCOL    = "protocol"
+	UDP         = "udp"
+	TCP         = "tcp"
+	NAME        = "name"
+	MESSAGE     = "message"
+	SLEEP       = "sleep"
+	READTIMEOUT = "read-timeout"
+)
+
+func sendMessages(ctx context.Context) {
+	switch viper.GetString(PROTOCOL) {
+	case "udp":
+		sendUDP(ctx)
+	case "tcp":
+		sendTCP(ctx)
+	default:
+		log.Fatal().Caller().Str(PROTOCOL, viper.GetString(PROTOCOL)).Msg("Unknown protocol")
+	}
+}
+
+func sendTCP(ctx context.Context) {
+	var (
+		conn   net.Conn
+		err    error
+		buf, b []byte
+		n      int
+	)
+
+	if conn, err = net.Dial(TCP, viper.GetString(SERVER)); err != nil {
+		log.Fatal().Caller().Err(err).Msg("Failed to connect to server")
+	}
+	defer func() {
+		_ = conn.Close()
+	}()
+	go func() {
+		<-ctx.Done()
+		_ = conn.Close()
+	}()
+
+	buf = make([]byte, 4096)
+	for gLimit.isContinue(ctx) {
+		sb := slicewriter.NewSliceWriter(buf)
+		if _, err = fmt.Fprintf(sb, "client %s | %v | %s", viper.GetString(NAME), time.Now(), viper.GetString(MESSAGE)); err != nil {
+			log.Fatal().Caller().Err(err).Msg("Failed to build client message")
+		}
+		b = sb.Bytes()
+		if _, err = conn.Write(b); err != nil {
+			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
+		}
+
+		if err = conn.SetReadDeadline(time.Now().Add(viper.GetDuration(READTIMEOUT))); err != nil {
+			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
+		}
+		if n, err = conn.Read(buf); err != nil {
+			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("read from the server")
+		}
+
+		log.Info().Caller().Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msgf("%s", buf[:n])
+
+		time.Sleep(viper.GetDuration(SLEEP))
+	}
+}
+
+func sendUDP(ctx context.Context) {
+	var (
+		addr, laddr *net.UDPAddr
+		conn        *net.UDPConn
+		rAddr       net.Addr
+		err         error
+		buf, b      []byte
+		n           int
+	)
+
+	if addr, err = net.ResolveUDPAddr(UDP, viper.GetString(SERVER)); err != nil {
+		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("udp resolve server address")
+	}
+
+	if laddr, err = net.ResolveUDPAddr(UDP, ""); err != nil {
+		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("udp resolve local/self address")
+	}
+	log.Info().Str(SERVER, viper.GetString(SERVER)).Msgf("bound address %v", laddr)
+
+	// In Go, binding address and port for UDP use ListenUDP. Confusing!!
+	if conn, err = net.ListenUDP(UDP, laddr); err != nil {
+		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("fail to bind local/self address")
+	}
+
+	defer func() {
+		_ = conn.Close()
+	}()
+	go func() {
+		<-ctx.Done()
+		_ = conn.Close()
+	}()
+
+	buf = make([]byte, 4096)
+	for gLimit.isContinue(ctx) {
+		sb := slicewriter.NewSliceWriter(buf)
+		if _, err = fmt.Fprintf(sb, "client %s | %v | %s", viper.GetString(NAME), time.Now(), viper.GetString(MESSAGE)); err != nil {
+			log.Fatal().Caller().Err(err).Msg("Failed to build client message")
+		}
+		b = sb.Bytes()
+		if _, err = conn.WriteTo(b, addr); err != nil {
+			log.Fatal().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
+		}
+
+		if err = conn.SetReadDeadline(time.Now().Add(viper.GetDuration(READTIMEOUT))); err != nil {
+			log.Error().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("set read timeout on the socket")
+		}
+		if n, rAddr, err = conn.ReadFrom(b); err != nil {
+			log.Fatal().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("read from server")
+		}
+
+		log.Info().Caller().Str(PROTOCOL, UDP).Str(SERVER, rAddr.String()).Msgf("%s", buf[:n])
+	}
 }
 
 func parseFlags() {
-	pflag.String(client.NAME, "", "client name")
+	pflag.String(NAME, "", "client name")
 	pflag.IntP("number", "n", 5, "number of messages to send; default 5; set to 0 for infinite")
-	pflag.Duration(client.READTIMEOUT, 5*time.Second, "read timeout; default 5 seconds")
+	pflag.Duration(READTIMEOUT, 5*time.Second, "read timeout; default 5 seconds")
-	pflag.DurationP(client.SLEEP, "s", 10*time.Millisecond, "sleep time between requests; default 10ms")
+	pflag.DurationP(SLEEP, "s", 10*time.Millisecond, "sleep time between requests; default 10ms")
-	pflag.StringP(client.MESSAGE, "m", "message from client", "message to send")
+	pflag.StringP(MESSAGE, "m", "message from client", "message to send")
 	pflag.Bool("debug", false, "run in debug mode")
-	pflag.String(client.TCP, "", "tcp server address")
+	pflag.String(TCP, "", "tcp server address")
-	pflag.String(client.UDP, "", "udp server address")
+	pflag.String(UDP, "", "udp server address")
 	pflag.Parse()
 
 	_ = viper.BindPFlags(pflag.CommandLine)
 
-	// gLimit = makeCounter(viper.GetInt("number"))
+	gLimit = makeCounter(viper.GetInt("number"))
-	client.InitLimit()
 
-	if !viper.IsSet(client.NAME) {
+	if !viper.IsSet(NAME) {
 		log.Fatal().Caller().Msg("server name is required")
 	}
 
-	if viper.IsSet(client.TCP) && viper.IsSet(client.UDP) {
+	if viper.IsSet(TCP) && viper.IsSet(UDP) {
 		log.Fatal().Caller().Msg("cannot use tcp and udp at once")
 	}
 
-	if !viper.IsSet(client.TCP) && !viper.IsSet(client.UDP) {
+	if !viper.IsSet(TCP) && !viper.IsSet(UDP) {
 		log.Fatal().Caller().Msg("--tcp or --udp is required, use one of them not both.")
 	}
 
-	if viper.IsSet(client.TCP) {
+	if viper.IsSet(TCP) {
-		viper.Set(client.PROTOCOL, client.TCP)
+		viper.Set(PROTOCOL, TCP)
-		viper.Set(client.SERVER, viper.GetString(client.TCP))
+		viper.Set(SERVER, viper.GetString(TCP))
 	}
 
-	if viper.IsSet(client.UDP) {
+	if viper.IsSet(UDP) {
-		viper.Set(client.PROTOCOL, client.UDP)
+		viper.Set(PROTOCOL, UDP)
-		viper.Set(client.SERVER, viper.GetString(client.UDP))
+		viper.Set(SERVER, viper.GetString(UDP))
 	}
 
 	zerolog.SetGlobalLevel(zerolog.InfoLevel)
@@ -83,3 +204,30 @@ func parseFlags() {
 		zerolog.SetGlobalLevel(zerolog.DebugLevel)
 	}
 }
+
+type counter struct {
+	limit, tick int
+}
+
+func makeCounter(limit int) *counter {
+	if limit <= 0 {
+		log.Fatal().Msg("number must be > 0")
+	}
+
+	return &counter{limit: limit, tick: -1}
+}
+
+func (c *counter) isContinue(ctx context.Context) bool {
+	select {
+	case <-ctx.Done():
+		return false
+	default:
+	}
+
+	if c.limit == 0 {
+		return true
+	}
+
+	c.tick++
+	return c.tick < c.limit
+}

cmd/test-server/main.go

@@ -18,10 +18,13 @@ package main
 
 import (
 	"context"
+	"fmt"
+	"net"
 	"os/signal"
 	"sync"
+	"time"
 
-	"gitea.suyono.dev/suyono/netbounce/testlib/server"
+	"gitea.suyono.dev/suyono/netbounce/cmd/slicewriter"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/pflag"
@@ -38,7 +41,7 @@ func main() {
 	defer cancel()
 
 	wg := &sync.WaitGroup{}
-	server.OpenPorts(wg, ctx)
+	openPorts(wg, ctx)
 
 	wg.Wait()
 
@@ -68,3 +71,167 @@ func parseFlags() {
 		zerolog.SetGlobalLevel(zerolog.DebugLevel)
 	}
 }
+
+func openPorts(wg *sync.WaitGroup, ctx context.Context) {
+	tcpPorts := viper.GetStringSlice("tcp")
+	for _, tcpPort := range tcpPorts {
+		wg.Add(1)
+		go listen(ctx, wg, tcpPort)
+	}
+
+	udpPorts := viper.GetStringSlice("udp")
+	for _, udpPort := range udpPorts {
+		wg.Add(1)
+		go bindUDP(ctx, wg, udpPort)
+	}
+}
+
+func ClosePacket(ctx context.Context, conn net.PacketConn) {
+	<-ctx.Done()
+	_ = conn.Close()
+}
+
+func bindUDP(ctx context.Context, wg *sync.WaitGroup, address string) {
+	defer wg.Done()
+
+	var (
+		conn   net.PacketConn
+		err    error
+		buf, b []byte
+		n      int
+		addr   net.Addr
+	)
+
+	log.Debug().Caller().Msgf("binding socket for UDP on %v", address)
+	if conn, err = net.ListenPacket("udp", address); err != nil {
+		panic(fmt.Errorf("failed to bind udp address: %v", err))
+	}
+	go ClosePacket(ctx, conn)
+
+	buf = make([]byte, 4096)
+udpLoop:
+	for {
+		if n, addr, err = conn.ReadFrom(buf); err != nil && n == 0 {
+			select {
+			case <-ctx.Done():
+				break udpLoop
+			default:
+			}
+			log.Error().Err(err).Msg("failed to read packet")
+			continue udpLoop
+		}
+
+		log.Info().Str("client", addr.String()).Msgf("received message: %s", buf[:n])
+		select {
+		case <-ctx.Done():
+			break udpLoop
+		default:
+		}
+
+		sb := slicewriter.NewSliceWriter(buf)
+		if _, err = fmt.Fprintf(sb, "server: %s | UDP | %v", viper.GetString("name"), time.Now()); err != nil {
+			log.Error().Err(err).Msg("build server message")
+		}
+		b = sb.Bytes()
+
+		if n, err = conn.WriteTo(b, addr); err != nil {
+			select {
+			case <-ctx.Done():
+				break udpLoop
+			default:
+			}
+			log.Error().Err(err).Str("client", addr.String()).Msg("failed to write packet")
+			continue udpLoop
+		}
+
+		if n != len(b) {
+			log.Debug().Str("client", addr.String()).Msg("incomplete packet sent")
+		}
+
+		log.Info().Str("client", addr.String()).Msg("packet received and replied")
+	}
+}
+
+func CloseListener(ctx context.Context, listener net.Listener) {
+	<-ctx.Done()
+	_ = listener.Close()
+}
+
+func listen(ctx context.Context, wg *sync.WaitGroup, address string) {
+	defer wg.Done()
+
+	var (
+		listener net.Listener
+		err      error
+		conn     net.Conn
+	)
+
+	log.Debug().Caller().Msgf("listeng for TCP on %v", address)
+	if listener, err = net.Listen("tcp", address); err != nil {
+		log.Error().Err(err).Str("address", address).Msg("failed to listen")
+		return
+	}
+	go CloseListener(ctx, listener)
+
+tcpIncoming:
+	for {
+		if conn, err = listener.Accept(); err != nil {
+			select {
+			case <-ctx.Done():
+				break tcpIncoming
+			default:
+			}
+
+			log.Error().Err(err).Str("address", address).Msg("failed to accept connection")
+			continue tcpIncoming
+		}
+
+		wg.Add(1)
+		go handleTCP(ctx, wg, conn)
+	}
+}
+
+func CloseConnection(ctx context.Context, conn net.Conn) {
+	<-ctx.Done()
+	_ = conn.Close()
+}
+
+func handleTCP(ctx context.Context, wg *sync.WaitGroup, conn net.Conn) {
+	defer wg.Done()
+	defer func() {
+		_ = conn.Close()
+	}()
+
+	var (
+		buf, b []byte
+		err    error
+		n      int
+	)
+
+	buf = make([]byte, 4096)
+	addr := conn.RemoteAddr()
+
+	cctx, cancel := context.WithCancel(ctx)
+	go CloseConnection(cctx, conn)
+	defer cancel()
+
+	for {
+		if n, err = conn.Read(buf); err != nil {
+			log.Error().Err(err).Str("client", addr.String()).Msg("failed to read data from TCP connection")
+			return
+		}
+
+		log.Info().Str("client", addr.String()).Msgf("received message: %s", buf[:n])
+
+		sb := slicewriter.NewSliceWriter(buf)
+		if _, err = fmt.Fprintf(sb, "server: %s | TCP | %v", viper.GetString("name"), time.Now()); err != nil {
+			log.Error().Err(err).Msg("build server message")
+		}
+		b = sb.Bytes()
+
+		if _, err = conn.Write(b); err != nil {
+			log.Error().Err(err).Str("client", addr.String()).Msg("failed to write data to TCP connection")
+			return
+		}
+	}
+}

go.mod

@@ -6,7 +6,7 @@ require (
 	github.com/rs/zerolog v1.34.0
 	github.com/spf13/pflag v1.0.6
 	github.com/spf13/viper v1.20.1
-	golang.org/x/sys v0.33.0
+	golang.org/x/sys v0.32.0
 )
 
 require (
@@ -22,7 +22,6 @@ require (
 	github.com/subosito/gotenv v1.6.0 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/multierr v1.9.0 // indirect
-	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
-	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -54,19 +54,13 @@ go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
 go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
-golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
 golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
 golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

slicewriter/slicewriter.go

@@ -1,52 +0,0 @@
-package slicewriter
-
-/*
-   Copyright 2025 Suyono <suyono3484@gmail.com>
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import "io"
-
-type SliceWriter struct {
-	off int
-	buf []byte
-}
-
-func (w *SliceWriter) Write(p []byte) (int, error) {
-	if len(p)+w.off <= len(w.buf) {
-		copy(w.buf[w.off:], p)
-		w.off += len(p)
-		return len(p), nil
-	}
-
-	space := len(w.buf) - w.off
-	copy(w.buf[:w.off], p[:space])
-	w.off += space
-	return space, io.ErrShortWrite
-}
-
-func (w *SliceWriter) Reset() {
-	w.off = 0
-}
-
-func (w *SliceWriter) Bytes() []byte {
-	return w.buf[:w.off]
-}
-
-func NewSliceWriter(b []byte) *SliceWriter {
-	return &SliceWriter{
-		off: 0,
-		buf: b,
-	}
-}

testlib/client/client.go

@@ -1,184 +0,0 @@
-package client
-
-/*
-   Copyright 2025 Suyono <suyono3484@gmail.com>
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"time"
-
-	"gitea.suyono.dev/suyono/netbounce/slicewriter"
-	"github.com/rs/zerolog/log"
-	"github.com/spf13/viper"
-)
-
-const (
-	SERVER      = "server"
-	PROTOCOL    = "protocol"
-	UDP         = "udp"
-	TCP         = "tcp"
-	NAME        = "name"
-	MESSAGE     = "message"
-	SLEEP       = "sleep"
-	READTIMEOUT = "read-timeout"
-)
-
-var gLimit *counter
-
-func SendMessages(ctx context.Context) {
-	sendMessages(ctx)
-}
-
-func InitLimit() {
-	gLimit = makeCounter(viper.GetInt("number"))
-}
-
-func sendMessages(ctx context.Context) {
-	switch viper.GetString(PROTOCOL) {
-	case "udp":
-		sendUDP(ctx)
-	case "tcp":
-		sendTCP(ctx)
-	default:
-		log.Fatal().Caller().Str(PROTOCOL, viper.GetString(PROTOCOL)).Msg("Unknown protocol")
-	}
-}
-
-func sendTCP(ctx context.Context) {
-	var (
-		conn   net.Conn
-		err    error
-		buf, b []byte
-		n      int
-	)
-
-	if conn, err = net.Dial(TCP, viper.GetString(SERVER)); err != nil {
-		log.Fatal().Caller().Err(err).Msg("Failed to connect to server")
-	}
-	defer func() {
-		_ = conn.Close()
-	}()
-	go func() {
-		<-ctx.Done()
-		_ = conn.Close()
-	}()
-
-	buf = make([]byte, 4096)
-	for gLimit.isContinue(ctx) {
-		sb := slicewriter.NewSliceWriter(buf)
-		if _, err = fmt.Fprintf(sb, "client %s | %v | %s", viper.GetString(NAME), time.Now(), viper.GetString(MESSAGE)); err != nil {
-			log.Fatal().Caller().Err(err).Msg("Failed to build client message")
-		}
-		b = sb.Bytes()
-		if _, err = conn.Write(b); err != nil {
-			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
-		}
-
-		if err = conn.SetReadDeadline(time.Now().Add(viper.GetDuration(READTIMEOUT))); err != nil {
-			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
-		}
-		if n, err = conn.Read(buf); err != nil {
-			log.Fatal().Caller().Err(err).Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msg("read from the server")
-		}
-
-		log.Info().Caller().Str(PROTOCOL, TCP).Str(SERVER, viper.GetString(SERVER)).Msgf("%s", buf[:n])
-
-		time.Sleep(viper.GetDuration(SLEEP))
-	}
-}
-
-func sendUDP(ctx context.Context) {
-	var (
-		addr, laddr *net.UDPAddr
-		conn        *net.UDPConn
-		rAddr       net.Addr
-		err         error
-		buf, b      []byte
-		n           int
-	)
-
-	if addr, err = net.ResolveUDPAddr(UDP, viper.GetString(SERVER)); err != nil {
-		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("udp resolve server address")
-	}
-
-	if laddr, err = net.ResolveUDPAddr(UDP, ""); err != nil {
-		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("udp resolve local/self address")
-	}
-	log.Info().Str(SERVER, viper.GetString(SERVER)).Msgf("bound address %v", laddr)
-
-	// In Go, binding address and port for UDP use ListenUDP. Confusing!!
-	if conn, err = net.ListenUDP(UDP, laddr); err != nil {
-		log.Fatal().Caller().Err(err).Str(SERVER, viper.GetString(SERVER)).Msg("fail to bind local/self address")
-	}
-
-	defer func() {
-		_ = conn.Close()
-	}()
-	go func() {
-		<-ctx.Done()
-		_ = conn.Close()
-	}()
-
-	buf = make([]byte, 4096)
-	for gLimit.isContinue(ctx) {
-		sb := slicewriter.NewSliceWriter(buf)
-		if _, err = fmt.Fprintf(sb, "client %s | %v | %s", viper.GetString(NAME), time.Now(), viper.GetString(MESSAGE)); err != nil {
-			log.Fatal().Caller().Err(err).Msg("Failed to build client message")
-		}
-		b = sb.Bytes()
-		if _, err = conn.WriteTo(b, addr); err != nil {
-			log.Fatal().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("Failed to send client message")
-		}
-
-		if err = conn.SetReadDeadline(time.Now().Add(viper.GetDuration(READTIMEOUT))); err != nil {
-			log.Error().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("set read timeout on the socket")
-		}
-		if n, rAddr, err = conn.ReadFrom(b); err != nil {
-			log.Fatal().Caller().Err(err).Str(PROTOCOL, UDP).Str(SERVER, viper.GetString(SERVER)).Msg("read from server")
-		}
-
-		log.Info().Caller().Str(PROTOCOL, UDP).Str(SERVER, rAddr.String()).Msgf("%s", buf[:n])
-	}
-}
-
-type counter struct {
-	limit, tick int
-}
-
-func makeCounter(limit int) *counter {
-	if limit <= 0 {
-		log.Fatal().Msg("number must be > 0")
-	}
-
-	return &counter{limit: limit, tick: -1}
-}
-
-func (c *counter) isContinue(ctx context.Context) bool {
-	select {
-	case <-ctx.Done():
-		return false
-	default:
-	}
-
-	if c.limit == 0 {
-		return true
-	}
-
-	c.tick++
-	return c.tick < c.limit
-}

testlib/randommessage/randommessage.go

@@ -1,100 +0,0 @@
-package randommessage
-
-/*
-   Copyright 2025 Suyono <suyono3484@gmail.com>
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import (
-	"crypto/rand"
-	"encoding/binary"
-	"errors"
-	"hash"
-	"io"
-
-	"golang.org/x/crypto/blake2s"
-)
-
-type StreamReader struct {
-	pos        int64
-	size       int64
-	hashEngine hash.Hash
-}
-
-var (
-	ErrInvalidBufSize = errors.New("invalid buffer size")
-)
-
-func NewStreamReader(size int64) (*StreamReader, error) {
-	var (
-		h   hash.Hash
-		err error
-	)
-
-	if h, err = blake2s.New256(nil); err != nil {
-		return nil, err
-	}
-	return &StreamReader{
-		pos:        0,
-		size:       size,
-		hashEngine: h,
-	}, nil
-}
-
-func (s *StreamReader) Read(buf []byte) (int, error) {
-	var (
-		n   int
-		err error
-	)
-
-	if s.pos == 0 {
-		if len(buf) < 4 {
-			return 0, ErrInvalidBufSize
-		}
-		binary.BigEndian.PutUint32(buf, uint32(s.size))
-
-		n, err = s.read(buf[4:])
-		n += 4
-	} else {
-		n, err = s.read(buf)
-	}
-
-	return n, err
-}
-
-func (s *StreamReader) read(buf []byte) (int, error) {
-	var (
-		n     int
-		limit int
-		err   error
-	)
-
-	limit = len(buf)
-	err = nil
-	if s.size-s.pos < int64(len(buf)) {
-		err = io.EOF
-		limit = int(s.size - s.pos)
-		if limit < 0 {
-			panic("unexpected limit")
-		}
-	}
-
-	if limit > 0 {
-		n, _ = rand.Read(buf[:limit])
-		s.pos += int64(limit)
-		s.hashEngine.Write(buf[:limit])
-	}
-
-	return n, err
-}

testlib/server/server.go

@@ -1,197 +0,0 @@
-package server
-
-/*
-   Copyright 2025 Suyono <suyono3484@gmail.com>
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"sync"
-	"time"
-
-	"gitea.suyono.dev/suyono/netbounce/slicewriter"
-	"github.com/rs/zerolog/log"
-	"github.com/spf13/viper"
-)
-
-func OpenPorts(wg *sync.WaitGroup, ctx context.Context) {
-	openPorts(wg, ctx)
-}
-
-func openPorts(wg *sync.WaitGroup, ctx context.Context) {
-	tcpPorts := viper.GetStringSlice("tcp")
-	for _, tcpPort := range tcpPorts {
-		wg.Add(1)
-		go listen(ctx, wg, tcpPort)
-	}
-
-	udpPorts := viper.GetStringSlice("udp")
-	for _, udpPort := range udpPorts {
-		wg.Add(1)
-		go bindUDP(ctx, wg, udpPort)
-	}
-}
-
-func ClosePacket(ctx context.Context, conn net.PacketConn) {
-	<-ctx.Done()
-	_ = conn.Close()
-}
-
-func bindUDP(ctx context.Context, wg *sync.WaitGroup, address string) {
-	defer wg.Done()
-
-	var (
-		conn   net.PacketConn
-		err    error
-		buf, b []byte
-		n      int
-		addr   net.Addr
-	)
-
-	log.Debug().Caller().Msgf("binding socket for UDP on %v", address)
-	if conn, err = net.ListenPacket("udp", address); err != nil {
-		panic(fmt.Errorf("failed to bind udp address: %v", err))
-	}
-	go ClosePacket(ctx, conn)
-
-	buf = make([]byte, 4096)
-udpLoop:
-	for {
-		if n, addr, err = conn.ReadFrom(buf); err != nil && n == 0 {
-			select {
-			case <-ctx.Done():
-				break udpLoop
-			default:
-			}
-			log.Error().Err(err).Msg("failed to read packet")
-			continue udpLoop
-		}
-
-		log.Info().Str("client", addr.String()).Msgf("received message: %s", buf[:n])
-		select {
-		case <-ctx.Done():
-			break udpLoop
-		default:
-		}
-
-		sb := slicewriter.NewSliceWriter(buf)
-		if _, err = fmt.Fprintf(sb, "server: %s | UDP | %v", viper.GetString("name"), time.Now()); err != nil {
-			log.Error().Err(err).Msg("build server message")
-		}
-		b = sb.Bytes()
-
-		if n, err = conn.WriteTo(b, addr); err != nil {
-			select {
-			case <-ctx.Done():
-				break udpLoop
-			default:
-			}
-			log.Error().Err(err).Str("client", addr.String()).Msg("failed to write packet")
-			continue udpLoop
-		}
-
-		if n != len(b) {
-			log.Debug().Str("client", addr.String()).Msg("incomplete packet sent")
-		}
-
-		log.Info().Str("client", addr.String()).Msg("packet received and replied")
-	}
-}
-
-func CloseListener(ctx context.Context, listener net.Listener) {
-	<-ctx.Done()
-	_ = listener.Close()
-}
-
-func listen(ctx context.Context, wg *sync.WaitGroup, address string) {
-	defer wg.Done()
-
-	var (
-		listener net.Listener
-		err      error
-		conn     net.Conn
-	)
-
-	log.Debug().Caller().Msgf("listeng for TCP on %v", address)
-	if listener, err = net.Listen("tcp", address); err != nil {
-		log.Error().Err(err).Str("address", address).Msg("failed to listen")
-		return
-	}
-	go CloseListener(ctx, listener)
-
-tcpIncoming:
-	for {
-		if conn, err = listener.Accept(); err != nil {
-			select {
-			case <-ctx.Done():
-				break tcpIncoming
-			default:
-			}
-
-			log.Error().Err(err).Str("address", address).Msg("failed to accept connection")
-			continue tcpIncoming
-		}
-
-		wg.Add(1)
-		go handleTCP(ctx, wg, conn)
-	}
-}
-
-func CloseConnection(ctx context.Context, conn net.Conn) {
-	<-ctx.Done()
-	_ = conn.Close()
-}
-
-func handleTCP(ctx context.Context, wg *sync.WaitGroup, conn net.Conn) {
-	defer wg.Done()
-	defer func() {
-		_ = conn.Close()
-	}()
-
-	var (
-		buf, b []byte
-		err    error
-		n      int
-	)
-
-	buf = make([]byte, 4096)
-	addr := conn.RemoteAddr()
-
-	cctx, cancel := context.WithCancel(ctx)
-	go CloseConnection(cctx, conn)
-	defer cancel()
-
-	for {
-		if n, err = conn.Read(buf); err != nil {
-			log.Error().Err(err).Str("client", addr.String()).Msg("failed to read data from TCP connection")
-			return
-		}
-
-		log.Info().Str("client", addr.String()).Msgf("received message: %s", buf[:n])
-
-		sb := slicewriter.NewSliceWriter(buf)
-		if _, err = fmt.Fprintf(sb, "server: %s | TCP | %v", viper.GetString("name"), time.Now()); err != nil {
-			log.Error().Err(err).Msg("build server message")
-		}
-		b = sb.Bytes()
-
-		if _, err = conn.Write(b); err != nil {
-			log.Error().Err(err).Str("client", addr.String()).Msg("failed to write data to TCP connection")
-			return
-		}
-	}
-}