Minor optimization

cmd/passport/auth.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/yosebyte/passport/internal/auth"
+	"github.com/yosebyte/passport/internal"
 	"github.com/yosebyte/passport/pkg/log"
 )
 
@@ -20,7 +20,7 @@ func authSetups(parsedURL *url.URL, whiteList *sync.Map) {
 	log.Info("Auth mode enabled: %v", parsedAuthURL)
 	go func() {
 		for {
-			if err := auth.HandleHTTP(parsedAuthURL, whiteList); err != nil {
+			if err := internal.HandleHTTP(parsedAuthURL, whiteList); err != nil {
 				log.Error("Auth mode error: %v", err)
 				log.Info("Restarting in 1s...")
 				time.Sleep(1 * time.Second)

cmd/passport/main.go

@@ -9,7 +9,7 @@ import (
 )
 
 var (
-	version = "dev"
+	version   = "dev"
 	whiteList sync.Map
 )
 

internal/const.go

@@ -1,8 +1,8 @@
 package internal
 
 const (
-	MaxSemaphore   = 1024
-	MaxBufferSize  = 8192
-	MinBufferSize  = 1024
-	MaxUDPDeadline = 5
+	MaxSemaphoreLimit = 1024
+	MaxSignalBuffer   = 1024
+	MaxDataBuffer     = 8192
+	MaxUDPTimeout     = 5
 )

internal/forward/tcp.go

@@ -29,17 +29,17 @@ func HandleTCP(parsedURL *url.URL, whiteList *sync.Map) error {
 		return err
 	}
 	defer linkListen.Close()
-	semaphore := make(chan struct{}, internal.MaxSemaphore)
+	sem := make(chan struct{}, internal.MaxSemaphoreLimit)
 	for {
 		linkConn, err := linkListen.AcceptTCP()
 		if err != nil {
 			log.Error("Unable to connect link address: [%v] %v", linkAddr, err)
 			time.Sleep(1 * time.Second)
 			continue
 		}
-		semaphore <- struct{}{}
+		sem <- struct{}{}
 		go func(linkConn *net.TCPConn) {
-			defer func() { <-semaphore }()
+			defer func() { <-sem }()
 			clientAddr := linkConn.RemoteAddr().String()
 			log.Info("Client connection established: [%v]", clientAddr)
 			if parsedURL.Fragment != "" {

internal/forward/udp.go

@@ -28,9 +28,9 @@ func HandleUDP(parsedURL *url.URL, whiteList *sync.Map) error {
 		return err
 	}
 	defer linkConn.Close()
-	semaphore := make(chan struct{}, internal.MaxSemaphore)
+	sem := make(chan struct{}, internal.MaxSemaphoreLimit)
 	for {
-		buffer := make([]byte, internal.MaxBufferSize)
+		buffer := make([]byte, internal.MaxDataBuffer)
 		n, clientAddr, err := linkConn.ReadFromUDP(buffer)
 		if err != nil {
 			log.Error("Unable to read from client address: [%v] %v", clientAddr, err)
@@ -43,17 +43,17 @@ func HandleUDP(parsedURL *url.URL, whiteList *sync.Map) error {
 				continue
 			}
 		}
-		semaphore <- struct{}{}
+		sem <- struct{}{}
 		go func(buffer []byte, n int, clientAddr *net.UDPAddr) {
-			defer func() { <-semaphore }()
+			defer func() { <-sem }()
 			targetConn, err := net.DialUDP("udp", nil, targetAddr)
 			if err != nil {
 				log.Error("Unable to dial target address: [%v] %v", targetAddr, err)
 				return
 			}
 			defer targetConn.Close()
 			log.Info("Target connection established: [%v]", targetAddr)
-			err = targetConn.SetDeadline(time.Now().Add(internal.MaxUDPDeadline * time.Second))
+			err = targetConn.SetDeadline(time.Now().Add(internal.MaxUDPTimeout * time.Second))
 			if err != nil {
 				log.Error("Unable to set deadline: %v", err)
 				return

internal/auth/http.go → internal/http.go

@@ -1,4 +1,4 @@
-package auth
+package internal
 
 import (
 	"net"

internal/tunnel/client.go

@@ -32,7 +32,7 @@ func Client(parsedURL *url.URL) error {
 	}
 	defer linkConn.Close()
 	log.Info("Tunnel connection established to: [%v]", linkAddr)
-	buffer := make([]byte, internal.MinBufferSize)
+	buffer := make([]byte, internal.MaxSignalBuffer)
 	for {
 		n, err := linkConn.Read(buffer)
 		if err != nil {

internal/tunnel/tcp.go

@@ -18,7 +18,7 @@ func ServeTCP(parsedURL *url.URL, whiteList *sync.Map, linkAddr, targetAddr *net
 	}
 	defer targetListen.Close()
 	var mu sync.Mutex
-	semaphore := make(chan struct{}, internal.MaxSemaphore)
+	sem := make(chan struct{}, internal.MaxSemaphoreLimit)
 	for {
 		targetConn, err := targetListen.AcceptTCP()
 		if err != nil {
@@ -40,10 +40,10 @@ func ServeTCP(parsedURL *url.URL, whiteList *sync.Map, linkAddr, targetAddr *net
 				continue
 			}
 		}
-		semaphore <- struct{}{}
+		sem <- struct{}{}
 		go func(targetConn *net.TCPConn) {
 			defer func() {
-				<-semaphore
+				<-sem
 				targetConn.Close()
 			}()
 			mu.Lock()

internal/tunnel/udp.go

@@ -18,9 +18,9 @@ func ServeUDP(parsedURL *url.URL, whiteList *sync.Map, linkAddr *net.TCPAddr, ta
 	}
 	defer targetConn.Close()
 	var mu sync.Mutex
-	semaphore := make(chan struct{}, internal.MaxSemaphore)
+	sem := make(chan struct{}, internal.MaxSemaphoreLimit)
 	for {
-		buffer := make([]byte, internal.MaxBufferSize)
+		buffer := make([]byte, internal.MaxDataBuffer)
 		n, clientAddr, err := targetConn.ReadFromUDP(buffer)
 		if err != nil {
 			log.Error("Unable to read from client address: [%v] %v", clientAddr, err)
@@ -45,10 +45,10 @@ func ServeUDP(parsedURL *url.URL, whiteList *sync.Map, linkAddr *net.TCPAddr, ta
 			log.Error("Unable to accept connections from link address: [%v] %v", linkAddr, err)
 			continue
 		}
-		semaphore <- struct{}{}
+		sem <- struct{}{}
 		go func(buffer []byte, n int, remoteConn *net.TCPConn, clientAddr *net.UDPAddr) {
 			defer func() {
-				<-semaphore
+				<-sem
 				remoteConn.Close()
 			}()
 			log.Info("Starting data transfer: [%v] <-> [%v]", clientAddr, targetAddr)
@@ -81,7 +81,7 @@ func ClientUDP(linkAddr *net.TCPAddr, targetUDPAddr *net.UDPAddr) {
 	}
 	defer remoteConn.Close()
 	log.Info("Remote connection established: [%v]", linkAddr)
-	buffer := make([]byte, internal.MaxBufferSize)
+	buffer := make([]byte, internal.MaxDataBuffer)
 	n, err := remoteConn.Read(buffer)
 	if err != nil {
 		log.Error("Unable to read from remote address: [%v] %v", linkAddr, err)
@@ -94,7 +94,7 @@ func ClientUDP(linkAddr *net.TCPAddr, targetUDPAddr *net.UDPAddr) {
 	}
 	defer targetConn.Close()
 	log.Info("Target connection established: [%v]", targetUDPAddr)
-	err = targetConn.SetDeadline(time.Now().Add(internal.MaxUDPDeadline * time.Second))
+	err = targetConn.SetDeadline(time.Now().Add(internal.MaxUDPTimeout * time.Second))
 	if err != nil {
 		log.Error("Unable to set deadline: %v", err)
 		return