Merge pull request 'fix: prevent subdomain change to already-in-use subdomains' (#54) from staging into main

Reviewed-on: #54

.gitea/workflows/build.yml

@@ -5,8 +5,6 @@ on:
     branches:
       - main
       - staging
-    tags:
-      - 'v*'
     paths:
       - '**.go'
       - 'go.mod'
@@ -17,9 +15,8 @@ on:
       - '.gitea/workflows/build.yml'
 
 jobs:
-  build-and-push-branches:
+  build-and-push:
     runs-on: ubuntu-latest
-    if: github.ref_type == 'branch'
 
     steps:
       - name: Checkout repository
@@ -35,17 +32,6 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
-      - name: Set version variables
-        id: vars
-        run: |
-          if [ "${{ github.ref }}" == "refs/heads/main" ]; then
-            echo "VERSION=dev-main" >> $GITHUB_OUTPUT
-          else
-            echo "VERSION=dev-staging" >> $GITHUB_OUTPUT
-          fi
-          echo "BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')" >> $GITHUB_OUTPUT
-          echo "COMMIT=${{ github.sha }}" >> $GITHUB_OUTPUT
-
       - name: Build and push Docker image for main
         uses: docker/build-push-action@v6
         with:
@@ -54,10 +40,6 @@ jobs:
           tags: |
             git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:latest
           platforms: linux/amd64,linux/arm64
-          build-args: |
-            VERSION=${{ steps.vars.outputs.VERSION }}
-            BUILD_DATE=${{ steps.vars.outputs.BUILD_DATE }}
-            COMMIT=${{ steps.vars.outputs.COMMIT }}
         if: github.ref == 'refs/heads/main'
 
       - name: Build and push Docker image for staging
@@ -68,85 +50,4 @@ jobs:
           tags: |
             git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:staging
           platforms: linux/amd64,linux/arm64
-          build-args: |
+        if: github.ref == 'refs/heads/staging'
-            VERSION=${{ steps.vars.outputs.VERSION }}
-            BUILD_DATE=${{ steps.vars.outputs.BUILD_DATE }}
-            COMMIT=${{ steps.vars.outputs.COMMIT }}
-        if: github.ref == 'refs/heads/staging'
-
-  build-and-push-tags:
-    runs-on: ubuntu-latest
-    if: github.ref_type == 'tag' && startsWith(github.ref, 'refs/tags/v')
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          registry: git.fossy.my.id
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Extract version and determine release type
-        id: version
-        run: |
-          VERSION=${GITHUB_REF#refs/tags/v}
-          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
-          echo "BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')" >> $GITHUB_OUTPUT
-          echo "COMMIT=${{ github.sha }}" >> $GITHUB_OUTPUT
-          
-          if echo "$VERSION" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?$'; then
-            MAJOR=$(echo "$VERSION" | cut -d. -f1)
-            MINOR=$(echo "$VERSION" | cut -d. -f2)
-            
-            echo "MAJOR=$MAJOR" >> $GITHUB_OUTPUT
-            echo "MINOR=$MINOR" >> $GITHUB_OUTPUT
-            
-            if echo "$VERSION" | grep -q '-'; then
-              echo "IS_PRERELEASE=true" >> $GITHUB_OUTPUT
-              echo "ADDITIONAL_TAG=staging" >> $GITHUB_OUTPUT
-            else
-              echo "IS_PRERELEASE=false" >> $GITHUB_OUTPUT
-              echo "ADDITIONAL_TAG=latest" >> $GITHUB_OUTPUT
-            fi
-          else
-            echo "Invalid version format: $VERSION"
-            exit 1
-          fi
-
-      - name: Build and push Docker image for release
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          tags: |
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:v${{ steps.version.outputs.VERSION }}
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:v${{ steps.version.outputs.MAJOR }}.${{ steps.version.outputs.MINOR }}
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:v${{ steps.version.outputs.MAJOR }}
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:${{ steps.version.outputs.ADDITIONAL_TAG }}
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            VERSION=${{ steps.version.outputs.VERSION }}
-            BUILD_DATE=${{ steps.version.outputs.BUILD_DATE }}
-            COMMIT=${{ steps.version.outputs.COMMIT }}
-        if: steps.version.outputs.IS_PRERELEASE == 'false'
-
-      - name: Build and push Docker image for pre-release
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          tags: |
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:v${{ steps.version.outputs.VERSION }}
-            git.fossy.my.id/${{ secrets.DOCKER_USERNAME }}/tunnel-please:${{ steps.version.outputs.ADDITIONAL_TAG }}
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            VERSION=${{ steps.version.outputs.VERSION }}
-            BUILD_DATE=${{ steps.version.outputs.BUILD_DATE }}
-            COMMIT=${{ steps.version.outputs.COMMIT }}
-        if: steps.version.outputs.IS_PRERELEASE == 'true'

Dockerfile

@@ -1,9 +1,5 @@
 FROM golang:1.25.5-alpine AS go_builder
 
-ARG VERSION=dev
-ARG BUILD_DATE=unknown
-ARG COMMIT=unknown
-
 RUN apk update && apk upgrade && \
     apk add --no-cache ca-certificates tzdata git && \
     update-ca-certificates
@@ -22,7 +18,7 @@ RUN --mount=type=cache,target=/go/pkg/mod \
     --mount=type=cache,target=/root/.cache/go-build \
     CGO_ENABLED=0 GOOS=linux \
     go build -trimpath \
-    -ldflags="-w -s -X tunnel_pls/version.Version=${VERSION} -X tunnel_pls/version.BuildDate=${BUILD_DATE} -X tunnel_pls/version.Commit=${COMMIT}" \
+    -ldflags="-w -s" \
     -o /app/tunnel_pls \
     .
 
@@ -32,10 +28,6 @@ RUN adduser -D -u 10001 -g '' appuser && \
 
 FROM scratch
 
-ARG VERSION=dev
-ARG BUILD_DATE=unknown
-ARG COMMIT=unknown
-
 COPY --from=go_builder /usr/share/zoneinfo /usr/share/zoneinfo
 COPY --from=go_builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 COPY --from=go_builder /etc/passwd /etc/passwd
@@ -51,9 +43,6 @@ ENV TZ=Asia/Jakarta
 EXPOSE 2200 8080 8443
 
 LABEL org.opencontainers.image.title="Tunnel Please" \
-      org.opencontainers.image.description="SSH-based tunnel server" \
+      org.opencontainers.image.description="SSH-based tunnel server"
-      org.opencontainers.image.version="${VERSION}" \
-      org.opencontainers.image.revision="${COMMIT}" \
-      org.opencontainers.image.created="${BUILD_DATE}"
 
 ENTRYPOINT ["/app/tunnel_pls"]

go.mod

@@ -3,21 +3,20 @@ module tunnel_pls
 go 1.24.4
 
 require (
-	github.com/caddyserver/certmagic v0.25.1
+	github.com/caddyserver/certmagic v0.25.0
 	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10
-	github.com/charmbracelet/lipgloss v1.1.0
 	github.com/joho/godotenv v1.5.1
 	github.com/libdns/cloudflare v0.2.2
-	github.com/muesli/termenv v0.16.0
 	golang.org/x/crypto v0.46.0
 )
 
 require (
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/caddyserver/zerossl v0.1.4 // indirect
+	github.com/caddyserver/zerossl v0.1.3 // indirect
 	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/lipgloss v1.1.0 // indirect
 	github.com/charmbracelet/x/ansi v0.10.1 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
@@ -28,19 +27,20 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-localereader v0.0.1 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
-	github.com/mholt/acmez/v3 v3.1.4 // indirect
+	github.com/mholt/acmez/v3 v3.1.3 // indirect
-	github.com/miekg/dns v1.1.69 // indirect
+	github.com/miekg/dns v1.1.68 // indirect
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/sahilm/fuzzy v0.1.1 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/zeebo/blake3 v0.2.4 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	go.uber.org/zap v1.27.1 // indirect
+	go.uber.org/zap v1.27.0 // indirect
 	go.uber.org/zap/exp v0.3.0 // indirect
 	golang.org/x/mod v0.30.0 // indirect
-	golang.org/x/net v0.48.0 // indirect
+	golang.org/x/net v0.47.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.39.0 // indirect
 	golang.org/x/text v0.32.0 // indirect

go.sum

@@ -6,12 +6,8 @@ github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWp
 github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/caddyserver/certmagic v0.25.0 h1:VMleO/XA48gEWes5l+Fh6tRWo9bHkhwAEhx63i+F5ic=
 github.com/caddyserver/certmagic v0.25.0/go.mod h1:m9yB7Mud24OQbPHOiipAoyKPn9pKHhpSJxXR1jydBxA=
-github.com/caddyserver/certmagic v0.25.1 h1:4sIKKbOt5pg6+sL7tEwymE1x2bj6CHr80da1CRRIPbY=
-github.com/caddyserver/certmagic v0.25.1/go.mod h1:VhyvndxtVton/Fo/wKhRoC46Rbw1fmjvQ3GjHYSQTEY=
 github.com/caddyserver/zerossl v0.1.3 h1:onS+pxp3M8HnHpN5MMbOMyNjmTheJyWRaZYwn+YTAyA=
 github.com/caddyserver/zerossl v0.1.3/go.mod h1:CxA0acn7oEGO6//4rtrRjYgEoa4MFw/XofZnrYwGqG4=
-github.com/caddyserver/zerossl v0.1.4 h1:CVJOE3MZeFisCERZjkxIcsqIH4fnFdlYWnPYeFtBHRw=
-github.com/caddyserver/zerossl v0.1.4/go.mod h1:CxA0acn7oEGO6//4rtrRjYgEoa4MFw/XofZnrYwGqG4=
 github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
 github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
@@ -54,12 +50,8 @@ github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6T
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mholt/acmez/v3 v3.1.3 h1:gUl789rjbJSuM5hYzOFnNaGgWPV1xVfnOs59o0dZEcc=
 github.com/mholt/acmez/v3 v3.1.3/go.mod h1:L1wOU06KKvq7tswuMDwKdcHeKpFFgkppZy/y0DFxagQ=
-github.com/mholt/acmez/v3 v3.1.4 h1:DyzZe/RnAzT3rpZj/2Ii5xZpiEvvYk3cQEN/RmqxwFQ=
-github.com/mholt/acmez/v3 v3.1.4/go.mod h1:L1wOU06KKvq7tswuMDwKdcHeKpFFgkppZy/y0DFxagQ=
 github.com/miekg/dns v1.1.68 h1:jsSRkNozw7G/mnmXULynzMNIsgY2dHC8LO6U6Ij2JEA=
 github.com/miekg/dns v1.1.68/go.mod h1:fujopn7TB3Pu3JM69XaawiU0wqjpL9/8xGop5UrTPps=
-github.com/miekg/dns v1.1.69 h1:Kb7Y/1Jo+SG+a2GtfoFUfDkG//csdRPwRLkCsxDG9Sc=
-github.com/miekg/dns v1.1.69/go.mod h1:7OyjD9nEba5OkqQ/hB4fy3PIoxafSZJtducccIelz3g=
 github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
 github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
@@ -89,8 +81,6 @@ go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
 go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
-go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc=
-go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 go.uber.org/zap/exp v0.3.0 h1:6JYzdifzYkGmTdRR59oYH+Ng7k49H9qVpWwNSsGJj3U=
 go.uber.org/zap/exp v0.3.0/go.mod h1:5I384qq7XGxYyByIhHm6jg5CHkGY0nsTfbDLgDDlgJQ=
 golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
@@ -101,8 +91,6 @@ golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
 golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
 golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
 golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
-golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
-golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

internal/config/config.go

@@ -1,35 +0,0 @@
-package config
-
-import (
-	"log"
-	"os"
-	"strconv"
-
-	"github.com/joho/godotenv"
-)
-
-func init() {
-	if _, err := os.Stat(".env"); err == nil {
-		if err := godotenv.Load(".env"); err != nil {
-			log.Printf("Warning: Failed to load .env file: %s", err)
-		}
-	}
-}
-
-func Getenv(key, defaultValue string) string {
-	val := os.Getenv(key)
-	if val == "" {
-		val = defaultValue
-	}
-
-	return val
-}
-
-func GetBufferSize() int {
-	sizeStr := Getenv("BUFFER_SIZE", "32768")
-	size, err := strconv.Atoi(sizeStr)
-	if err != nil || size < 4096 || size > 1048576 {
-		return 32768
-	}
-	return size
-}

internal/port/port.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-	"tunnel_pls/internal/config"
+	"tunnel_pls/utils"
 )
 
 type Manager interface {
@@ -28,7 +28,7 @@ var Default Manager = &manager{
 }
 
 func init() {
-	rawRange := config.Getenv("ALLOWED_PORTS", "")
+	rawRange := utils.Getenv("ALLOWED_PORTS", "")
 	if rawRange == "" {
 		return
 	}

internal/random/random.go

@@ -1,18 +0,0 @@
-package random
-
-import (
-	mathrand "math/rand"
-	"strings"
-	"time"
-)
-
-func GenerateRandomString(length int) string {
-	const charset = "abcdefghijklmnopqrstuvwxyz"
-	seededRand := mathrand.New(mathrand.NewSource(time.Now().UnixNano() + int64(mathrand.Intn(9999))))
-	var result strings.Builder
-	for i := 0; i < length; i++ {
-		randomIndex := seededRand.Intn(len(charset))
-		result.WriteString(string(charset[randomIndex]))
-	}
-	return result.String()
-}

main.go

@@ -6,29 +6,19 @@ import (
 	"net/http"
 	_ "net/http/pprof"
 	"os"
-	"tunnel_pls/internal/config"
-	"tunnel_pls/internal/key"
 	"tunnel_pls/server"
-	"tunnel_pls/session"
+	"tunnel_pls/utils"
-	"tunnel_pls/version"
 
 	"golang.org/x/crypto/ssh"
 )
 
 func main() {
-	if len(os.Args) > 1 && (os.Args[1] == "--version" || os.Args[1] == "-v") {
-		fmt.Println(version.GetVersion())
-		os.Exit(0)
-	}
-
 	log.SetOutput(os.Stdout)
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
 
-	log.Printf("Starting %s", version.GetVersion())
+	pprofEnabled := utils.Getenv("PPROF_ENABLED", "false")
-
-	pprofEnabled := config.Getenv("PPROF_ENABLED", "false")
 	if pprofEnabled == "true" {
-		pprofPort := config.Getenv("PPROF_PORT", "6060")
+		pprofPort := utils.Getenv("PPROF_PORT", "6060")
 		go func() {
 			pprofAddr := fmt.Sprintf("localhost:%s", pprofPort)
 			log.Printf("Starting pprof server on http://%s/debug/pprof/", pprofAddr)
@@ -40,11 +30,11 @@ func main() {
 
 	sshConfig := &ssh.ServerConfig{
 		NoClientAuth:  true,
-		ServerVersion: fmt.Sprintf("SSH-2.0-TunnlPls-%s", version.GetShortVersion()),
+		ServerVersion: "SSH-2.0-TunnlPls-1.0",
 	}
 
 	sshKeyPath := "certs/ssh/id_rsa"
-	if err := key.GenerateSSHKeyIfNotExist(sshKeyPath); err != nil {
+	if err := utils.GenerateSSHKeyIfNotExist(sshKeyPath); err != nil {
 		log.Fatalf("Failed to generate SSH key: %s", err)
 	}
 
@@ -59,11 +49,6 @@ func main() {
 	}
 
 	sshConfig.AddHostKey(private)
-	sessionRegistry := session.NewRegistry()
+	app := server.NewServer(sshConfig)
-
-	app, err := server.NewServer(sshConfig, sessionRegistry)
-	if err != nil {
-		log.Fatalf("Failed to start server: %s", err)
-	}
 	app.Start()
 }

server/handler.go

@@ -0,0 +1,28 @@
+package server
+
+import (
+	"log"
+	"net"
+	"tunnel_pls/session"
+
+	"golang.org/x/crypto/ssh"
+)
+
+func (s *Server) handleConnection(conn net.Conn) {
+	sshConn, chans, forwardingReqs, err := ssh.NewServerConn(conn, s.config)
+	if err != nil {
+		log.Printf("failed to establish SSH connection: %v", err)
+		err := conn.Close()
+		if err != nil {
+			log.Printf("failed to close SSH connection: %v", err)
+			return
+		}
+		return
+	}
+
+	log.Println("SSH connection established:", sshConn.User())
+
+	session.New(sshConn, forwardingReqs, chans)
+
+	return
+}

server/header.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
+	"strings"
 )
 
 type HeaderManager interface {
@@ -43,132 +44,43 @@ type requestHeaderFactory struct {
 	headers   map[string]string
 }
 
-func NewRequestHeaderFactory(r interface{}) (RequestHeaderManager, error) {
+func NewRequestHeaderFactory(br *bufio.Reader) (RequestHeaderManager, error) {
-	switch v := r.(type) {
-	case []byte:
-		return parseHeadersFromBytes(v)
-	case *bufio.Reader:
-		return parseHeadersFromReader(v)
-	default:
-		return nil, fmt.Errorf("unsupported type: %T", r)
-	}
-}
-
-func parseHeadersFromBytes(headerData []byte) (RequestHeaderManager, error) {
 	header := &requestHeaderFactory{
-		headers: make(map[string]string, 16),
+		headers: make(map[string]string),
 	}
 
-	lineEnd := bytes.IndexByte(headerData, '\n')
+	startLine, err := br.ReadString('\n')
-	if lineEnd == -1 {
-		return nil, fmt.Errorf("invalid request: no newline found")
-	}
-
-	startLine := bytes.TrimRight(headerData[:lineEnd], "\r\n")
-	header.startLine = make([]byte, len(startLine))
-	copy(header.startLine, startLine)
-
-	parts := bytes.Split(startLine, []byte{' '})
-	if len(parts) < 3 {
-		return nil, fmt.Errorf("invalid request line")
-	}
-
-	header.method = string(parts[0])
-	header.path = string(parts[1])
-	header.version = string(parts[2])
-
-	remaining := headerData[lineEnd+1:]
-
-	for len(remaining) > 0 {
-		lineEnd = bytes.IndexByte(remaining, '\n')
-		if lineEnd == -1 {
-			lineEnd = len(remaining)
-		}
-
-		line := bytes.TrimRight(remaining[:lineEnd], "\r\n")
-
-		if len(line) == 0 {
-			break
-		}
-
-		colonIdx := bytes.IndexByte(line, ':')
-		if colonIdx != -1 {
-			key := bytes.TrimSpace(line[:colonIdx])
-			value := bytes.TrimSpace(line[colonIdx+1:])
-			header.headers[string(key)] = string(value)
-		}
-
-		if lineEnd == len(remaining) {
-			break
-		}
-		remaining = remaining[lineEnd+1:]
-	}
-
-	return header, nil
-}
-
-func parseHeadersFromReader(br *bufio.Reader) (RequestHeaderManager, error) {
-	header := &requestHeaderFactory{
-		headers: make(map[string]string, 16),
-	}
-
-	startLineBytes, err := br.ReadSlice('\n')
 	if err != nil {
-		if err == bufio.ErrBufferFull {
+		return nil, err
-			var startLine string
-			startLine, err = br.ReadString('\n')
-			if err != nil {
-				return nil, err
-			}
-			startLineBytes = []byte(startLine)
-		} else {
-			return nil, err
-		}
 	}
+	startLine = strings.TrimRight(startLine, "\r\n")
+	header.startLine = []byte(startLine)
 
-	startLineBytes = bytes.TrimRight(startLineBytes, "\r\n")
+	parts := strings.Split(startLine, " ")
-	header.startLine = make([]byte, len(startLineBytes))
-	copy(header.startLine, startLineBytes)
-
-	parts := bytes.Split(startLineBytes, []byte{' '})
 	if len(parts) < 3 {
 		return nil, fmt.Errorf("invalid request line")
 	}
 
-	header.method = string(parts[0])
+	header.method = parts[0]
-	header.path = string(parts[1])
+	header.path = parts[1]
-	header.version = string(parts[2])
+	header.version = parts[2]
 
 	for {
-		lineBytes, err := br.ReadSlice('\n')
+		line, err := br.ReadString('\n')
 		if err != nil {
-			if err == bufio.ErrBufferFull {
+			return nil, err
-				var line string
-				line, err = br.ReadString('\n')
-				if err != nil {
-					return nil, err
-				}
-				lineBytes = []byte(line)
-			} else {
-				return nil, err
-			}
 		}
+		line = strings.TrimRight(line, "\r\n")
 
-		lineBytes = bytes.TrimRight(lineBytes, "\r\n")
+		if line == "" {
-
-		if len(lineBytes) == 0 {
 			break
 		}
 
-		colonIdx := bytes.IndexByte(lineBytes, ':')
+		kv := strings.SplitN(line, ":", 2)
-		if colonIdx == -1 {
+		if len(kv) != 2 {
 			continue
 		}
-
+		header.headers[strings.TrimSpace(kv[0])] = strings.TrimSpace(kv[1])
-		key := bytes.TrimSpace(lineBytes[:colonIdx])
-		value := bytes.TrimSpace(lineBytes[colonIdx+1:])
-
-		header.headers[string(key)] = string(value)
 	}
 
 	return header, nil

server/http.go

@@ -11,15 +11,21 @@ import (
 	"regexp"
 	"strings"
 	"time"
-	"tunnel_pls/internal/config"
 	"tunnel_pls/session"
+	"tunnel_pls/utils"
 
 	"golang.org/x/crypto/ssh"
 )
 
+type Interaction interface {
+	SendMessage(message string)
+}
+
 type HTTPWriter interface {
 	io.Reader
 	io.Writer
+	SetInteraction(interaction Interaction)
+	AddInteraction(interaction Interaction)
 	GetRemoteAddr() net.Addr
 	GetWriter() io.Writer
 	AddResponseMiddleware(mw ResponseMiddleware)
@@ -29,16 +35,21 @@ type HTTPWriter interface {
 }
 
 type customWriter struct {
-	remoteAddr net.Addr
+	remoteAddr  net.Addr
-	writer     io.Writer
+	writer      io.Writer
-	reader     io.Reader
+	reader      io.Reader
-	headerBuf  []byte
+	headerBuf   []byte
-	buf        []byte
+	buf         []byte
-	respHeader ResponseHeaderManager
+	respHeader  ResponseHeaderManager
-	reqHeader  RequestHeaderManager
+	reqHeader   RequestHeaderManager
-	respMW     []ResponseMiddleware
+	interaction Interaction
-	reqStartMW []RequestMiddleware
+	respMW      []ResponseMiddleware
-	reqEndMW   []RequestMiddleware
+	reqStartMW  []RequestMiddleware
+	reqEndMW    []RequestMiddleware
+}
+
+func (cw *customWriter) SetInteraction(interaction Interaction) {
+	cw.interaction = interaction
 }
 
 func (cw *customWriter) GetRemoteAddr() net.Addr {
@@ -99,7 +110,8 @@ func (cw *customWriter) Read(p []byte) (int, error) {
 		}
 	}
 
-	reqhf, err := NewRequestHeaderFactory(header)
+	headerReader := bufio.NewReader(bytes.NewReader(header))
+	reqhf, err := NewRequestHeaderFactory(headerReader)
 	if err != nil {
 		return 0, err
 	}
@@ -123,10 +135,11 @@ func (cw *customWriter) Read(p []byte) (int, error) {
 
 func NewCustomWriter(writer io.Writer, reader io.Reader, remoteAddr net.Addr) HTTPWriter {
 	return &customWriter{
-		remoteAddr: remoteAddr,
+		remoteAddr:  remoteAddr,
-		writer:     writer,
+		writer:      writer,
-		reader:     reader,
+		reader:      reader,
-		buf:        make([]byte, 0, 4096),
+		buf:         make([]byte, 0, 4096),
+		interaction: nil,
 	}
 }
 
@@ -211,29 +224,19 @@ func (cw *customWriter) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
+func (cw *customWriter) AddInteraction(interaction Interaction) {
+	cw.interaction = interaction
+}
+
 var redirectTLS = false
 
-type HTTPServer interface {
+func NewHTTPServer() error {
-	ListenAndServe() error
+	httpPort := utils.Getenv("HTTP_PORT", "8080")
-	ListenAndServeTLS() error
-	handler(conn net.Conn)
-	handlerTLS(conn net.Conn)
-}
-type httpServer struct {
-	sessionRegistry session.Registry
-}
-
-func NewHTTPServer(sessionRegistry session.Registry) HTTPServer {
-	return &httpServer{sessionRegistry: sessionRegistry}
-}
-
-func (hs *httpServer) ListenAndServe() error {
-	httpPort := config.Getenv("HTTP_PORT", "8080")
 	listener, err := net.Listen("tcp", ":"+httpPort)
 	if err != nil {
 		return errors.New("Error listening: " + err.Error())
 	}
-	if config.Getenv("TLS_ENABLED", "false") == "true" && config.Getenv("TLS_REDIRECT", "false") == "true" {
+	if utils.Getenv("TLS_ENABLED", "false") == "true" && utils.Getenv("TLS_REDIRECT", "false") == "true" {
 		redirectTLS = true
 	}
 	go func() {
@@ -248,13 +251,13 @@ func (hs *httpServer) ListenAndServe() error {
 				continue
 			}
 
-			go hs.handler(conn)
+			go Handler(conn)
 		}
 	}()
 	return nil
 }
 
-func (hs *httpServer) handler(conn net.Conn) {
+func Handler(conn net.Conn) {
 	defer func() {
 		err := conn.Close()
 		if err != nil && !errors.Is(err, net.ErrClosed) {
@@ -285,7 +288,7 @@ func (hs *httpServer) handler(conn net.Conn) {
 
 	if redirectTLS {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
-			fmt.Sprintf("Location: https://%s.%s/\r\n", slug, config.Getenv("DOMAIN", "localhost")) +
+			fmt.Sprintf("Location: https://%s.%s/\r\n", slug, utils.Getenv("DOMAIN", "localhost")) +
 			"Content-Length: 0\r\n" +
 			"Connection: close\r\n" +
 			"\r\n"))
@@ -313,8 +316,8 @@ func (hs *httpServer) handler(conn net.Conn) {
 		return
 	}
 
-	sshSession, exist := hs.sessionRegistry.Get(slug)
+	sshSession, ok := session.Clients[slug]
-	if !exist {
+	if !ok {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +
 			"Content-Length: 0\r\n" +

server/https.go

@@ -8,12 +8,13 @@ import (
 	"log"
 	"net"
 	"strings"
-	"tunnel_pls/internal/config"
+	"tunnel_pls/session"
+	"tunnel_pls/utils"
 )
 
-func (hs *httpServer) ListenAndServeTLS() error {
+func NewHTTPSServer() error {
-	domain := config.Getenv("DOMAIN", "localhost")
+	domain := utils.Getenv("DOMAIN", "localhost")
-	httpsPort := config.Getenv("HTTPS_PORT", "8443")
+	httpsPort := utils.Getenv("HTTPS_PORT", "8443")
 
 	tlsConfig, err := NewTLSConfig(domain)
 	if err != nil {
@@ -37,13 +38,13 @@ func (hs *httpServer) ListenAndServeTLS() error {
 				continue
 			}
 
-			go hs.handlerTLS(conn)
+			go HandlerTLS(conn)
 		}
 	}()
 	return nil
 }
 
-func (hs *httpServer) handlerTLS(conn net.Conn) {
+func HandlerTLS(conn net.Conn) {
 	defer func() {
 		err := conn.Close()
 		if err != nil {
@@ -89,8 +90,8 @@ func (hs *httpServer) handlerTLS(conn net.Conn) {
 		return
 	}
 
-	sshSession, exist := hs.sessionRegistry.Get(slug)
+	sshSession, ok := session.Clients[slug]
-	if !exist {
+	if !ok {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +
 			"Content-Length: 0\r\n" +

server/server.go

@@ -4,45 +4,50 @@ import (
 	"fmt"
 	"log"
 	"net"
-	"tunnel_pls/internal/config"
+	"net/http"
-	"tunnel_pls/session"
+	"tunnel_pls/utils"
 
 	"golang.org/x/crypto/ssh"
 )
 
 type Server struct {
-	conn            *net.Listener
+	conn       *net.Listener
-	config          *ssh.ServerConfig
+	config     *ssh.ServerConfig
-	sessionRegistry session.Registry
+	httpServer *http.Server
 }
 
-func NewServer(sshConfig *ssh.ServerConfig, sessionRegistry session.Registry) (*Server, error) {
+func (s *Server) GetConn() *net.Listener {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%s", config.Getenv("PORT", "2200")))
+	return s.conn
+}
+
+func (s *Server) GetConfig() *ssh.ServerConfig {
+	return s.config
+}
+
+func (s *Server) GetHttpServer() *http.Server {
+	return s.httpServer
+}
+
+func NewServer(config *ssh.ServerConfig) *Server {
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%s", utils.Getenv("PORT", "2200")))
 	if err != nil {
 		log.Fatalf("failed to listen on port 2200: %v", err)
-		return nil, err
+		return nil
 	}
-
+	if utils.Getenv("TLS_ENABLED", "false") == "true" {
-	HttpServer := NewHTTPServer(sessionRegistry)
+		err = NewHTTPSServer()
-	err = HttpServer.ListenAndServe()
-	if err != nil {
-		log.Fatalf("failed to start http server: %v", err)
-		return nil, err
-	}
-
-	if config.Getenv("TLS_ENABLED", "false") == "true" {
-		err = HttpServer.ListenAndServeTLS()
 		if err != nil {
 			log.Fatalf("failed to start https server: %v", err)
-			return nil, err
 		}
 	}
-
+	err = NewHTTPServer()
+	if err != nil {
+		log.Fatalf("failed to start http server: %v", err)
+	}
 	return &Server{
-		conn:            &listener,
+		conn:   &listener,
-		config:          sshConfig,
+		config: config,
-		sessionRegistry: sessionRegistry,
+	}
-	}, nil
 }
 
 func (s *Server) Start() {
@@ -57,26 +62,3 @@ func (s *Server) Start() {
 		go s.handleConnection(conn)
 	}
 }
-
-func (s *Server) handleConnection(conn net.Conn) {
-	sshConn, chans, forwardingReqs, err := ssh.NewServerConn(conn, s.config)
-	if err != nil {
-		log.Printf("failed to establish SSH connection: %v", err)
-		err := conn.Close()
-		if err != nil {
-			log.Printf("failed to close SSH connection: %v", err)
-			return
-		}
-		return
-	}
-
-	log.Println("SSH connection established:", sshConn.User())
-
-	sshSession := session.New(sshConn, forwardingReqs, chans, s.sessionRegistry)
-	err = sshSession.Start()
-	if err != nil {
-		log.Printf("SSH session ended with error: %v", err)
-		return
-	}
-	return
-}

server/tls.go

@@ -10,7 +10,7 @@ import (
 	"os"
 	"sync"
 	"time"
-	"tunnel_pls/internal/config"
+	"tunnel_pls/utils"
 
 	"github.com/caddyserver/certmagic"
 	"github.com/libdns/cloudflare"
@@ -92,7 +92,7 @@ func NewTLSConfig(domain string) (*tls.Config, error) {
 }
 
 func isACMEConfigComplete() bool {
-	cfAPIToken := config.Getenv("CF_API_TOKEN", "")
+	cfAPIToken := utils.Getenv("CF_API_TOKEN", "")
 	return cfAPIToken != ""
 }
 
@@ -241,9 +241,9 @@ func (tm *tlsManager) initCertMagic() error {
 		return fmt.Errorf("failed to create cert storage directory: %w", err)
 	}
 
-	acmeEmail := config.Getenv("ACME_EMAIL", "admin@"+tm.domain)
+	acmeEmail := utils.Getenv("ACME_EMAIL", "admin@"+tm.domain)
-	cfAPIToken := config.Getenv("CF_API_TOKEN", "")
+	cfAPIToken := utils.Getenv("CF_API_TOKEN", "")
-	acmeStaging := config.Getenv("ACME_STAGING", "false") == "true"
+	acmeStaging := utils.Getenv("ACME_STAGING", "false") == "true"
 
 	if cfAPIToken == "" {
 		return fmt.Errorf("CF_API_TOKEN environment variable is required for automatic certificate generation")
@@ -301,22 +301,7 @@ func (tm *tlsManager) initCertMagic() error {
 func (tm *tlsManager) getTLSConfig() *tls.Config {
 	return &tls.Config{
 		GetCertificate: tm.getCertificate,
-		MinVersion:     tls.VersionTLS13,
+		MinVersion:     tls.VersionTLS12,
-		MaxVersion:     tls.VersionTLS13,
-
-		SessionTicketsDisabled: false,
-
-		CipherSuites: []uint16{
-			tls.TLS_AES_128_GCM_SHA256,
-			tls.TLS_CHACHA20_POLY1305_SHA256,
-		},
-
-		CurvePreferences: []tls.CurveID{
-			tls.X25519,
-		},
-
-		ClientAuth: tls.NoClientCert,
-		NextProtos: nil,
 	}
 }
 

session/forwarder/forwarder.go

@@ -10,16 +10,16 @@ import (
 	"strconv"
 	"sync"
 	"time"
-	"tunnel_pls/internal/config"
 	"tunnel_pls/session/slug"
 	"tunnel_pls/types"
+	"tunnel_pls/utils"
 
 	"golang.org/x/crypto/ssh"
 )
 
 var bufferPool = sync.Pool{
 	New: func() interface{} {
-		bufSize := config.GetBufferSize()
+		bufSize := utils.GetBufferSize()
 		return make([]byte, bufSize)
 	},
 }
@@ -152,26 +152,25 @@ func (f *Forwarder) HandleConnection(dst io.ReadWriter, src ssh.Channel, remoteA
 
 	log.Printf("Handling new forwarded connection from %s", remoteAddr)
 
-	var wg sync.WaitGroup
+	done := make(chan struct{}, 2)
-	wg.Add(2)
 
 	go func() {
-		defer wg.Done()
-		_, err := copyWithBuffer(dst, src)
-		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, net.ErrClosed) {
-			log.Printf("Error copying src→dst: %v", err)
-		}
-	}()
-
-	go func() {
-		defer wg.Done()
 		_, err := copyWithBuffer(src, dst)
 		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, net.ErrClosed) {
-			log.Printf("Error copying dst→src: %v", err)
+			log.Printf("Error copying from conn.Reader to channel: %v", err)
 		}
+		done <- struct{}{}
 	}()
 
-	wg.Wait()
+	go func() {
+		_, err := copyWithBuffer(dst, src)
+		if err != nil && !errors.Is(err, io.EOF) && !errors.Is(err, net.ErrClosed) {
+			log.Printf("Error copying from channel to conn.Writer: %v", err)
+		}
+		done <- struct{}{}
+	}()
+
+	<-done
 }
 
 func (f *Forwarder) SetType(tunnelType types.TunnelType) {

session/handler.go

@@ -7,9 +7,10 @@ import (
 	"log"
 	"net"
 	portUtil "tunnel_pls/internal/port"
-	"tunnel_pls/internal/random"
 	"tunnel_pls/types"
 
+	"tunnel_pls/utils"
+
 	"golang.org/x/crypto/ssh"
 )
 
@@ -106,6 +107,7 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
 	}
 
 	portToBind := uint16(rawPortToBind)
+
 	if isBlockedPort(portToBind) {
 		log.Printf("Port %d is blocked or restricted", portToBind)
 		err := req.Reply(false, nil)
@@ -163,9 +165,16 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
 }
 
 func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
-	slug := random.GenerateRandomString(20)
+	slug := generateUniqueSlug()
+	if slug == "" {
+		err := req.Reply(false, nil)
+		if err != nil {
+			log.Println("Failed to reply to request:", err)
+		}
+		return
+	}
 
-	if !s.registry.Register(slug, s) {
+	if !registerClient(slug, s) {
 		log.Printf("Failed to register client with slug: %s", slug)
 		err := req.Reply(false, nil)
 		if err != nil {
@@ -178,7 +187,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err := binary.Write(buf, binary.BigEndian, uint32(portToBind))
 	if err != nil {
 		log.Println("Failed to write port to buffer:", err)
-		s.registry.Remove(slug)
+		unregisterClient(slug)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -190,7 +199,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err = req.Reply(true, buf.Bytes())
 	if err != nil {
 		log.Println("Failed to reply to request:", err)
-		s.registry.Remove(slug)
+		unregisterClient(slug)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -263,6 +272,25 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 	s.interaction.Start()
 }
 
+func generateUniqueSlug() string {
+	maxAttempts := 5
+
+	for i := 0; i < maxAttempts; i++ {
+		slug := utils.GenerateRandomString(20)
+
+		clientsMutex.RLock()
+		_, exists := Clients[slug]
+		clientsMutex.RUnlock()
+
+		if !exists {
+			return slug
+		}
+	}
+
+	log.Println("Failed to generate unique slug after multiple attempts")
+	return ""
+}
+
 func readSSHString(reader *bytes.Reader) (string, error) {
 	var length uint32
 	if err := binary.Read(reader, binary.BigEndian, &length); err != nil {

session/interaction/interaction.go

@@ -6,10 +6,9 @@ import (
 	"log"
 	"strings"
 	"time"
-	"tunnel_pls/internal/config"
-	"tunnel_pls/internal/random"
 	"tunnel_pls/session/slug"
 	"tunnel_pls/types"
+	"tunnel_pls/utils"
 
 	"github.com/charmbracelet/bubbles/help"
 	"github.com/charmbracelet/bubbles/key"
@@ -114,7 +113,7 @@ func (i *Interaction) SetChannel(channel ssh.Channel) {
 	i.channel = channel
 }
 
-func (i *Interaction) SetSlugModificator(modificator func(oldSlug, newSlug string) (success bool)) {
+func (i *Interaction) SetSlugModificator(modificator func(oldSlug, newSlug string) bool) {
 	i.updateClientSlug = modificator
 }
 
@@ -199,11 +198,6 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 
 		if m.editingSlug {
-			if m.tunnelType != types.HTTP {
-				m.editingSlug = false
-				m.slugError = ""
-				return m, tea.Batch(tea.ClearScreen, textinput.Blink)
-			}
 			switch msg.String() {
 			case "esc":
 				m.editingSlug = false
@@ -728,9 +722,9 @@ func (m model) View() string {
 func (i *Interaction) Start() {
 	lipgloss.SetColorProfile(termenv.TrueColor)
 
-	domain := config.Getenv("DOMAIN", "localhost")
+	domain := utils.Getenv("DOMAIN", "localhost")
 	protocol := "http"
-	if config.Getenv("TLS_ENABLED", "false") == "true" {
+	if utils.Getenv("TLS_ENABLED", "false") == "true" {
 		protocol = "https"
 	}
 
@@ -817,7 +811,7 @@ func buildURL(protocol, subdomain, domain string) string {
 }
 
 func generateRandomSubdomain() string {
-	return random.GenerateRandomString(20)
+	return utils.GenerateRandomString(20)
 }
 
 func isValidSlug(slug string) bool {

session/registry.go

@@ -1,66 +0,0 @@
-package session
-
-import "sync"
-
-type Registry interface {
-	Get(slug string) (session *SSHSession, exist bool)
-	Update(oldSlug, newSlug string) (success bool)
-	Register(slug string, session *SSHSession) (success bool)
-	Remove(slug string)
-}
-type registry struct {
-	mu      sync.RWMutex
-	clients map[string]*SSHSession
-}
-
-func NewRegistry() Registry {
-	return &registry{
-		clients: make(map[string]*SSHSession),
-	}
-}
-
-func (r *registry) Get(slug string) (session *SSHSession, exist bool) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	session, exist = r.clients[slug]
-	return
-}
-
-func (r *registry) Update(oldSlug, newSlug string) (success bool) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	if _, exists := r.clients[newSlug]; exists && newSlug != oldSlug {
-		return false
-	}
-
-	client, ok := r.clients[oldSlug]
-	if !ok {
-		return false
-	}
-
-	delete(r.clients, oldSlug)
-	client.slugManager.Set(newSlug)
-	r.clients[newSlug] = client
-	return true
-}
-
-func (r *registry) Register(slug string, session *SSHSession) (success bool) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	if _, exists := r.clients[slug]; exists {
-		return false
-	}
-
-	r.clients[slug] = session
-	return true
-}
-
-func (r *registry) Remove(slug string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	delete(r.clients, slug)
-}

session/session.go

@@ -1,18 +1,23 @@
 package session
 
 import (
-	"fmt"
 	"log"
+	"sync"
 	"time"
-	"tunnel_pls/internal/config"
 	"tunnel_pls/session/forwarder"
 	"tunnel_pls/session/interaction"
 	"tunnel_pls/session/lifecycle"
 	"tunnel_pls/session/slug"
+	"tunnel_pls/utils"
 
 	"golang.org/x/crypto/ssh"
 )
 
+var (
+	clientsMutex sync.RWMutex
+	Clients      = make(map[string]*SSHSession)
+)
+
 type Session interface {
 	HandleGlobalRequest(ch <-chan *ssh.Request)
 	HandleTCPIPForward(req *ssh.Request)
@@ -21,13 +26,10 @@ type Session interface {
 }
 
 type SSHSession struct {
-	initialReq    <-chan *ssh.Request
+	lifecycle   lifecycle.SessionLifecycle
-	sshReqChannel <-chan ssh.NewChannel
+	interaction interaction.Controller
-	lifecycle     lifecycle.SessionLifecycle
+	forwarder   forwarder.ForwardingController
-	interaction   interaction.Controller
+	slugManager slug.Manager
-	forwarder     forwarder.ForwardingController
-	slugManager   slug.Manager
-	registry      Registry
 }
 
 func (s *SSHSession) GetLifecycle() lifecycle.SessionLifecycle {
@@ -46,64 +48,55 @@ func (s *SSHSession) GetSlugManager() slug.Manager {
 	return s.slugManager
 }
 
-func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan ssh.NewChannel, sessionRegistry Registry) *SSHSession {
+func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan ssh.NewChannel) {
 	slugManager := slug.NewManager()
 	forwarderManager := forwarder.NewForwarder(slugManager)
 	interactionManager := interaction.NewInteraction(slugManager, forwarderManager)
 	lifecycleManager := lifecycle.NewLifecycle(conn, forwarderManager, slugManager)
 
 	interactionManager.SetLifecycle(lifecycleManager)
-	interactionManager.SetSlugModificator(sessionRegistry.Update)
+	interactionManager.SetSlugModificator(updateClientSlug)
 	forwarderManager.SetLifecycle(lifecycleManager)
-	lifecycleManager.SetUnregisterClient(sessionRegistry.Remove)
+	lifecycleManager.SetUnregisterClient(unregisterClient)
 
-	return &SSHSession{
+	session := &SSHSession{
-		initialReq:    forwardingReq,
+		lifecycle:   lifecycleManager,
-		sshReqChannel: sshChan,
+		interaction: interactionManager,
-		lifecycle:     lifecycleManager,
+		forwarder:   forwarderManager,
-		interaction:   interactionManager,
+		slugManager: slugManager,
-		forwarder:     forwarderManager,
-		slugManager:   slugManager,
-		registry:      sessionRegistry,
 	}
-}
 
-func (s *SSHSession) Start() error {
+	var once sync.Once
-	channel := <-s.sshReqChannel
+	for channel := range sshChan {
-	ch, reqs, err := channel.Accept()
+		ch, reqs, err := channel.Accept()
-	if err != nil {
-		log.Printf("failed to accept channel: %v", err)
-		return err
-	}
-	go s.HandleGlobalRequest(reqs)
-
-	tcpipReq := s.waitForTCPIPForward()
-	if tcpipReq == nil {
-		_, err := ch.Write([]byte(fmt.Sprintf("Port forwarding request not received. Ensure you ran the correct command with -R flag. Example: ssh %s -p %s -R 80:localhost:3000", config.Getenv("DOMAIN", "localhost"), config.Getenv("PORT", "2200"))))
 		if err != nil {
-			return err
+			log.Printf("failed to accept channel: %v", err)
+			continue
 		}
-		if err := s.lifecycle.Close(); err != nil {
+		once.Do(func() {
-			log.Printf("failed to close session: %v", err)
+			session.lifecycle.SetChannel(ch)
-		}
+			session.interaction.SetChannel(ch)
-		return fmt.Errorf("No forwarding Request")
+
+			tcpipReq := session.waitForTCPIPForward(forwardingReq)
+			if tcpipReq == nil {
+				log.Printf("Port forwarding request not received. Ensure you ran the correct command with -R flag. Example: ssh %s -p %s -R 80:localhost:3000", utils.Getenv("DOMAIN", "localhost"), utils.Getenv("PORT", "2200"))
+				if err := session.lifecycle.Close(); err != nil {
+					log.Printf("failed to close session: %v", err)
+				}
+				return
+			}
+			go session.HandleTCPIPForward(tcpipReq)
+		})
+		session.HandleGlobalRequest(reqs)
 	}
-
+	if err := session.lifecycle.Close(); err != nil {
-	s.lifecycle.SetChannel(ch)
-	s.interaction.SetChannel(ch)
-
-	s.HandleTCPIPForward(tcpipReq)
-
-	if err := s.lifecycle.Close(); err != nil {
 		log.Printf("failed to close session: %v", err)
-		return err
 	}
-	return nil
 }
 
-func (s *SSHSession) waitForTCPIPForward() *ssh.Request {
+func (s *SSHSession) waitForTCPIPForward(forwardingReq <-chan *ssh.Request) *ssh.Request {
 	select {
-	case req, ok := <-s.initialReq:
+	case req, ok := <-forwardingReq:
 		if !ok {
 			log.Println("Forwarding request channel closed")
 			return nil
@@ -121,3 +114,41 @@ func (s *SSHSession) waitForTCPIPForward() *ssh.Request {
 		return nil
 	}
 }
+
+func updateClientSlug(oldSlug, newSlug string) bool {
+	clientsMutex.Lock()
+	defer clientsMutex.Unlock()
+
+	if _, exists := Clients[newSlug]; exists && newSlug != oldSlug {
+		return false
+	}
+
+	client, ok := Clients[oldSlug]
+	if !ok {
+		return false
+	}
+
+	delete(Clients, oldSlug)
+	client.slugManager.Set(newSlug)
+	Clients[newSlug] = client
+	return true
+}
+
+func registerClient(slug string, session *SSHSession) bool {
+	clientsMutex.Lock()
+	defer clientsMutex.Unlock()
+
+	if _, exists := Clients[slug]; exists {
+		return false
+	}
+
+	Clients[slug] = session
+	return true
+}
+
+func unregisterClient(slug string) {
+	clientsMutex.Lock()
+	defer clientsMutex.Unlock()
+
+	delete(Clients, slug)
+}

session/slug/slug.go

@@ -1,24 +1,32 @@
 package slug
 
+import "sync"
+
 type Manager interface {
 	Get() string
 	Set(slug string)
 }
 
 type manager struct {
-	slug string
+	slug   string
+	slugMu sync.RWMutex
 }
 
 func NewManager() Manager {
 	return &manager{
-		slug: "",
+		slug:   "",
+		slugMu: sync.RWMutex{},
 	}
 }
 
 func (s *manager) Get() string {
+	s.slugMu.RLock()
+	defer s.slugMu.RUnlock()
 	return s.slug
 }
 
 func (s *manager) Set(slug string) {
+	s.slugMu.Lock()
 	s.slug = slug
+	s.slugMu.Unlock()
 }

utils/utils.go

@@ -1,4 +1,4 @@
-package key
+package utils
 
 import (
 	"crypto/rand"
@@ -6,12 +6,54 @@ import (
 	"crypto/x509"
 	"encoding/pem"
 	"log"
+	mathrand "math/rand"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 
+	"github.com/joho/godotenv"
 	"golang.org/x/crypto/ssh"
 )
 
+func init() {
+	if _, err := os.Stat(".env"); err == nil {
+		if err := godotenv.Load(".env"); err != nil {
+			log.Printf("Warning: Failed to load .env file: %s", err)
+		}
+	}
+}
+
+func GenerateRandomString(length int) string {
+	const charset = "abcdefghijklmnopqrstuvwxyz"
+	seededRand := mathrand.New(mathrand.NewSource(time.Now().UnixNano() + int64(mathrand.Intn(9999))))
+	var result strings.Builder
+	for i := 0; i < length; i++ {
+		randomIndex := seededRand.Intn(len(charset))
+		result.WriteString(string(charset[randomIndex]))
+	}
+	return result.String()
+}
+
+func Getenv(key, defaultValue string) string {
+	val := os.Getenv(key)
+	if val == "" {
+		val = defaultValue
+	}
+
+	return val
+}
+
+func GetBufferSize() int {
+	sizeStr := Getenv("BUFFER_SIZE", "32768")
+	size, err := strconv.Atoi(sizeStr)
+	if err != nil || size < 4096 || size > 1048576 {
+		return 32768
+	}
+	return size
+}
+
 func GenerateSSHKeyIfNotExist(keyPath string) error {
 	if _, err := os.Stat(keyPath); err == nil {
 		log.Printf("SSH key already exists at %s", keyPath)

version/version.go

@@ -1,17 +0,0 @@
-package version
-
-import "fmt"
-
-var (
-	Version   = "dev"
-	BuildDate = "unknown"
-	Commit    = "unknown"
-)
-
-func GetVersion() string {
-	return fmt.Sprintf("tunnel_pls %s (commit: %s, built: %s)", Version, Commit, BuildDate)
-}
-
-func GetShortVersion() string {
-	return Version
-}