main.go

package main

import (
	"embed"
	"flag"
	"fmt"
	"net"
	"os"
	"os/exec"
	"path/filepath"
	"syscall"
)

// Embedding necessary files
//go:embed sshd.exe
//go:embed sshd_config
//go:embed ssh_host_rsa_key
//go:embed authorized_keys
var embeddedFiles embed.FS

func main() {
	// Parse command-line flags
	port := flag.Int("p", 2222, "Port")
	verbose := flag.Bool("v", false, "Verbose")
	foreground := flag.Bool("D", false, "Foreground")
	flag.Parse()

	// Determine executable directory
	exePath, err := os.Executable()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to get executable path: %v\n", err)
		os.Exit(1)
	}
	exeDir := filepath.Dir(exePath)

	// Create necessary directories
	binDir := filepath.Join(exeDir, "bin")
	cfgDir := filepath.Join(exeDir, "config")
	if err := os.MkdirAll(binDir, 0755); err != nil {
		fmt.Fprintf(os.Stderr, "Failed to create bin directory: %v\n", err)
		os.Exit(1)
	}
	if err := os.MkdirAll(cfgDir, 0755); err != nil {
		fmt.Fprintf(os.Stderr, "Failed to create config directory: %v\n", err)
		os.Exit(1)
	}

	// Write embedded files only if they do not exist
	writeEmbedIfNotExists("sshd.exe", binDir)
	writeEmbedIfNotExists("sshd_config", cfgDir)
	writeEmbedIfNotExists("ssh_host_rsa_key", cfgDir)
	writeEmbedIfNotExists("authorized_keys", cfgDir)

	// Verify port availability
	addr := fmt.Sprintf(":%d", *port)
	ln, err := net.Listen("tcp", addr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Port %d is already in use: %v\n", *port, err)
		os.Exit(1)
	}
	ln.Close()

	// Prepare sshd execution
	sshdPath := filepath.Join(binDir, "sshd.exe")
	sshdArgs := []string{
		"-f", filepath.Join(cfgDir, "sshd_config"),
		"-o", fmt.Sprintf("AuthorizedKeysFile %s", filepath.Join(cfgDir, "authorized_keys")),
		"-h", filepath.Join(cfgDir, "ssh_host_rsa_key"),
		"-p", fmt.Sprintf("%d", *port),
	}
	// Add debug flag if verbose
	if *verbose {
		sshdArgs = append(sshdArgs, "-d")
	}

	cmd := exec.Command(sshdPath, sshdArgs...)

	// Attach output only in foreground
	if *foreground {
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		// Run in foreground, blocking
		if err := cmd.Run(); err != nil {
			fmt.Fprintf(os.Stderr, "sshd exited with error: %v\n", err)
			os.Exit(1)
		}
	} else {
		// Daemonize: start and exit
		cmd.SysProcAttr = &syscall.SysProcAttr{
			CreationFlags: syscall.CREATE_NEW_PROCESS_GROUP,
		}
		if err := cmd.Start(); err != nil {
			fmt.Fprintf(os.Stderr, "Failed to start sshd: %v\n", err)
			os.Exit(1)
		}
		fmt.Printf("Running sshd in background (PID: %d)\n", cmd.Process.Pid)
	}
}

// Utility to write a file only if it doesn't already exist
func writeEmbedIfNotExists(name, destDir string) {
	outPath := filepath.Join(destDir, name)
	if _, err := os.Stat(outPath); os.IsNotExist(err) {
		data, err := embeddedFiles.ReadFile(name)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Failed to read embedded file %s: %v\n", name, err)
			os.Exit(1)
		}
		if err := os.WriteFile(outPath, data, 0644); err != nil {
			fmt.Fprintf(os.Stderr, "Failed to write file %s: %v\n", outPath, err)
			os.Exit(1)
		}
	}
}