initial commit

internal/tunnel/client.go

@@ -0,0 +1,172 @@
+package tunnel
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"time"
+
+	"os"
+
+	"golang.org/x/crypto/ssh"
+)
+
+func logToFile(msg string) {
+	f, _ := os.OpenFile("client_debug.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	defer f.Close()
+	f.WriteString(time.Now().Format(time.RFC3339) + " " + msg + "\n")
+}
+
+// Client handles the SSH connection and forwarding
+type Client struct {
+	ServerAddr string
+	LocalPort  string
+	AuthToken  string
+	SSHClient  *ssh.Client
+	Listener   net.Listener
+	Events     chan string // Channel to send logs/events to TUI
+	Metrics    chan int64  // Channel to send bytes transferred
+	PublicURL  string      // PublicURL is the URL accessible from the internet
+}
+
+func NewClient(serverAddr, localPort, authToken string) *Client {
+	return &Client{
+		ServerAddr: serverAddr,
+		LocalPort:  localPort,
+		AuthToken:  authToken,
+		Events:     make(chan string, 10),
+		Metrics:    make(chan int64, 10),
+	}
+}
+
+func (c *Client) Start() error {
+	config := &ssh.ClientConfig{
+		User: "grokway",
+		Auth: []ssh.AuthMethod{
+			ssh.Password(c.AuthToken),
+		},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(), // Dev only
+		Timeout:         5 * time.Second,
+	}
+
+	c.Events <- fmt.Sprintf("Connecting to %s...", c.ServerAddr)
+	client, err := ssh.Dial("tcp", c.ServerAddr, config)
+	if err != nil {
+		return err
+	}
+	c.SSHClient = client
+	c.Events <- "SSH Connected!"
+
+	// Request remote listening (Reverse Forwarding)
+	// Bind to 0.0.0.0 on server, random port (0)
+	listener, err := client.Listen("tcp", "0.0.0.0:0")
+	if err != nil {
+		return fmt.Errorf("failed to request port forwarding: %w", err)
+	}
+	c.Listener = listener
+
+	// Query server for assigned slug
+	ok, slugBytes, err := client.SendRequest("grokway-whoami", true, nil)
+	slug := "test-slug" // Fallback
+	if err == nil && ok {
+		slug = string(slugBytes)
+		c.Events <- fmt.Sprintf("Server assigned domain: %s", slug)
+	} else {
+		c.Events <- "Failed to query domain from server, using fallback"
+	}
+
+	hostname := "localhost" // This should match what the server is running on actually
+
+	// Assuming HTTP proxy is on port 8080 of the same host as SSH server (but different port)
+	// We extract host from c.ServerAddr
+	host, _, _ := net.SplitHostPort(c.ServerAddr)
+	if host == "" {
+		host = hostname
+	}
+
+	c.PublicURL = fmt.Sprintf("https://%s.%s", slug, host)
+	c.Events <- fmt.Sprintf("Tunnel established! Public URL: %s", c.PublicURL)
+
+	go c.acceptLoop()
+
+	return nil
+}
+
+func (c *Client) acceptLoop() {
+	for {
+		remoteConn, err := c.Listener.Accept()
+		if err != nil {
+			c.Events <- fmt.Sprintf("Accept error: %s", err)
+			break
+		}
+
+		c.Events <- "New Request received"
+		go c.handleConnection(remoteConn)
+	}
+}
+
+func (c *Client) handleConnection(remoteConn net.Conn) {
+	defer remoteConn.Close()
+
+	// Dial local service
+	localConn, err := net.Dial("tcp", "localhost:"+c.LocalPort)
+	if err != nil {
+		errMsg := fmt.Sprintf("Failed to dial local: %s", err)
+		c.Events <- errMsg
+		logToFile(errMsg)
+		return
+	}
+	defer localConn.Close()
+	logToFile("Dialed local service successfully")
+
+	// We need to peek at the connection to see if it's HTTP
+	// Wrap the connection to peek without consuming
+	logToFile("Handling new connection")
+
+	// Check if we can peek
+	// Since net.Conn doesn't support Peek, we read specific bytes and reconstruct
+	// or use a bufio reader if we weren't doing a raw Copy.
+	// But io.Copy needs a reader.
+
+	// Create a buffer to read the first few bytes
+	buf := make([]byte, 1024)
+	n, err := remoteConn.Read(buf)
+	if err != nil {
+		logToFile(fmt.Sprintf("Error reading from remote: %v", err))
+		return
+	}
+
+	payload := string(buf[:n])
+
+	// Try to parse rudimentary HTTP
+	// Format: METHOD PATH PROTOCOL
+	lines := strings.Split(payload, "\n")
+	if len(lines) > 0 {
+		firstLine := lines[0]
+		parts := strings.Fields(firstLine)
+		if len(parts) >= 3 {
+			method := parts[0]
+			path := parts[1]
+			// Send structured log
+			c.Events <- fmt.Sprintf("HTTP|%s|%s|%d", method, path, 200) // Status is fake for now, acts as connection open
+		} else {
+			c.Events <- "TCP|||Connection"
+		}
+	}
+
+	// We need to write the bytes we read to the local connection first
+	localConn.Write(buf[:n])
+
+	// Bidirectional copy
+	// Calculate bytes?
+
+	// We can use a custom copy to track metrics
+	go func() {
+		n, _ := io.Copy(remoteConn, localConn)
+		c.Metrics <- n
+	}()
+
+	n2, _ := io.Copy(localConn, remoteConn)
+	c.Metrics <- n2
+}