Merge branch 'develop'

cmd/boring/config.go

@@ -25,7 +25,7 @@ const defaultConfig = `# An example tunnel is defined below.
 
 `
 
-func openConfig() {
+func editConfig() {
 	if err := ensureConfig(); err != nil {
 		log.Fatalf("could not create config file: %v", err)
 	}

cmd/boring/main.go

@@ -48,11 +48,11 @@ func main() {
 	case "list", "l":
 		listTunnels()
 	case "edit", "e":
-		openConfig()
+		editConfig()
 	case "version", "v":
 		printVersion()
 	default:
-		log.Printf("Unknown command: %v\n", os.Args[1])
+		log.Printf("Unknown command: %v\n\n", os.Args[1])
 		printUsage()
 		os.Exit(1)
 	}
@@ -93,7 +93,7 @@ func printVersion() {
 }
 
 func printUsage() {
-	log.Printf("The `boring` SSH tunnel manager.\n\n")
+	log.Printf("The `boring` SSH tunnel manager\n\n")
 	log.Printf("Usage:\n")
 	log.Printf("  boring list, l                List all tunnels\n")
 	log.Printf(`  boring open, o (-a | <patterns>...)

cmd/boring/status.go

@@ -8,7 +8,7 @@ import (
 	"github.com/alebeck/boring/internal/tunnel"
 )
 
-func status(t *tunnel.Tunnel) string {
+func status(t *tunnel.TunnelDesc) string {
 	switch t.Status {
 	case tunnel.Closed:
 		return log.Red + "closed" + log.Reset

cmd/boring/tunnels.go

@@ -68,7 +68,7 @@ func controlTunnels(args []string, kind daemon.CmdKind) {
 
 	conf, err := prepare()
 	if err != nil {
-		log.Fatalf(err.Error())
+		log.Fatalf("%s", err.Error())
 	}
 
 	// Get available tunnels for requested command
@@ -103,7 +103,7 @@ func controlTunnels(args []string, kind daemon.CmdKind) {
 		if len(args) > 1 {
 			msg = fmt.Sprintf("No %stunnels match any provided pattern.", m)
 		}
-		log.Fatalf(msg)
+		log.Fatalf("%s", msg)
 	}
 
 	// If tunnels were matched, do print a warning for unmatched patterns
@@ -127,7 +127,7 @@ func controlTunnels(args []string, kind daemon.CmdKind) {
 	wg.Wait()
 }
 
-func openTunnel(t *tunnel.Tunnel) {
+func openTunnel(t *tunnel.TunnelDesc) {
 	var resp daemon.Resp
 	cmd := daemon.Cmd{Kind: daemon.Open, Tunnel: *t}
 	if err := transmitCmd(cmd, &resp); err != nil {
@@ -147,9 +147,9 @@ func openTunnel(t *tunnel.Tunnel) {
 	}
 }
 
-func closeTunnel(t *tunnel.Tunnel) {
-	// The daemon only needs the name for closing, so simplify
-	t = &tunnel.Tunnel{Name: t.Name}
+func closeTunnel(t *tunnel.TunnelDesc) {
+	// Daemon only needs the name, so simplify
+	t = &tunnel.TunnelDesc{Name: t.Name}
 
 	var resp daemon.Resp
 	cmd := daemon.Cmd{Kind: daemon.Close, Tunnel: *t}
@@ -164,16 +164,16 @@ func closeTunnel(t *tunnel.Tunnel) {
 	}
 }
 
-func getRunningTunnels() (map[string]*tunnel.Tunnel, error) {
+func getRunningTunnels() (map[string]*tunnel.TunnelDesc, error) {
 	var resp daemon.Resp
 	cmd := daemon.Cmd{Kind: daemon.List}
 	if err := transmitCmd(cmd, &resp); err != nil {
 		return nil, err
 	}
 	if !resp.Success {
-		return nil, fmt.Errorf(resp.Error)
+		return nil, fmt.Errorf("%s", resp.Error)
 	}
-	m := make(map[string]*tunnel.Tunnel, len(resp.Tunnels))
+	m := make(map[string]*tunnel.TunnelDesc, len(resp.Tunnels))
 	for _, t := range resp.Tunnels {
 		m[t.Name] = &t
 	}
@@ -183,7 +183,7 @@ func getRunningTunnels() (map[string]*tunnel.Tunnel, error) {
 func listTunnels() {
 	conf, err := prepare()
 	if err != nil {
-		log.Fatalf(err.Error())
+		log.Fatalf("%s", err.Error())
 	}
 
 	ts, err := getRunningTunnels()
@@ -238,7 +238,7 @@ func transmitCmd(cmd daemon.Cmd, resp any) error {
 }
 
 func filterGlob(
-	ts map[string]*tunnel.Tunnel, keep map[string]bool, pat string) (
+	ts map[string]*tunnel.TunnelDesc, keep map[string]bool, pat string) (
 	n int, err error) {
 	// Fail early if pattern is malformed; if this passes we can
 	// ignore the error return value of the following matches

internal/agent/agent.go

@@ -0,0 +1,53 @@
+package agent
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"sync"
+
+	"golang.org/x/crypto/ssh"
+	"golang.org/x/crypto/ssh/agent"
+)
+
+var (
+	// Keep a single agent instance for all connection attempts
+	inst agent.ExtendedAgent
+	mu   sync.Mutex
+)
+
+func getAgent() (agent.ExtendedAgent, error) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	if inst != nil {
+		return inst, nil
+	}
+
+	sock := os.Getenv("SSH_AUTH_SOCK")
+	if sock == "" {
+		return nil, fmt.Errorf("SSH_AUTH_SOCK is not set")
+	}
+
+	conn, err := net.Dial("unix", sock)
+	if err != nil {
+		return nil, fmt.Errorf("could not dial agent: %v", err)
+	}
+
+	inst = agent.NewClient(conn)
+	return inst, nil
+}
+
+func GetSigners() ([]ssh.Signer, error) {
+	agent, err := getAgent()
+	if err != nil {
+		return nil, err
+	}
+
+	signers, err := agent.Signers()
+	if err != nil {
+		return nil, fmt.Errorf("could not retrieve signers from agent: %v", err)
+	}
+
+	return signers, nil
+}

internal/config/config.go

@@ -21,8 +21,8 @@ var Path string
 
 // Config represents the application configuration as parsed from ./boring.toml
 type Config struct {
-	Tunnels    []tunnel.Tunnel           `toml:"tunnels"`
-	TunnelsMap map[string]*tunnel.Tunnel `toml:"-"`
+	Tunnels    []tunnel.TunnelDesc           `toml:"tunnels"`
+	TunnelsMap map[string]*tunnel.TunnelDesc `toml:"-"`
 }
 
 func init() {
@@ -53,7 +53,7 @@ func Load() (*Config, error) {
 	}
 
 	// Create a map of tunnel names to tunnel pointers for easy lookup
-	m := make(map[string]*tunnel.Tunnel)
+	m := make(map[string]*tunnel.TunnelDesc)
 	for i := range config.Tunnels {
 		t := &config.Tunnels[i]
 		if _, exists := m[t.Name]; exists {

internal/daemon/control.go

@@ -54,14 +54,14 @@ func (k CmdKind) String() string {
 }
 
 type Cmd struct {
-	Kind   CmdKind       `json:"kind"`
-	Tunnel tunnel.Tunnel `json:"tunnel,omitempty"`
+	Kind   CmdKind           `json:"kind"`
+	Tunnel tunnel.TunnelDesc `json:"tunnel,omitempty"`
 }
 
 type Resp struct {
-	Success bool                     `json:"success"`
-	Error   string                   `json:"error"`
-	Tunnels map[string]tunnel.Tunnel `json:"tunnels"`
+	Success bool                         `json:"success"`
+	Error   string                       `json:"error"`
+	Tunnels map[string]tunnel.TunnelDesc `json:"tunnels"`
 }
 
 // Ensure starts the daemon if it is not already running.

internal/daemon/daemon.go

@@ -123,9 +123,9 @@ func handleConnection(s *state, conn net.Conn) {
 	// Execute command
 	switch cmd.Kind {
 	case Open:
-		openTunnel(s, conn, cmd.Tunnel)
+		openTunnel(s, conn, &cmd.Tunnel)
 	case Close:
-		closeTunnel(s, conn, cmd.Tunnel)
+		closeTunnel(s, conn, &cmd.Tunnel)
 	case List:
 		listTunnels(s, conn)
 	default:
@@ -143,26 +143,27 @@ func respond(conn net.Conn, err *error) {
 	}
 }
 
-func openTunnel(s *state, conn net.Conn, t tunnel.Tunnel) {
+func openTunnel(s *state, conn net.Conn, d *tunnel.TunnelDesc) {
 	var err error
 	defer respond(conn, &err)
 
 	s.mutex.RLock()
-	_, exists := s.tunnels[t.Name]
+	_, exists := s.tunnels[d.Name]
 	s.mutex.RUnlock()
 	if exists {
 		err = AlreadyRunning
-		log.Errorf("%v: could not open: %v", t.Name, err)
+		log.Errorf("%v: could not open: %v", d.Name, err)
 		return
 	}
 
+	t := tunnel.FromDesc(d)
 	if err = t.Open(); err != nil {
 		log.Errorf("%v: could not open: %v", t.Name, err)
 		return
 	}
 
 	s.mutex.Lock()
-	s.tunnels[t.Name] = &t
+	s.tunnels[t.Name] = t
 	s.mutex.Unlock()
 
 	// Register closing logic
@@ -175,7 +176,7 @@ func openTunnel(s *state, conn net.Conn, t tunnel.Tunnel) {
 	}()
 }
 
-func closeTunnel(s *state, conn net.Conn, q tunnel.Tunnel) {
+func closeTunnel(s *state, conn net.Conn, q *tunnel.TunnelDesc) {
 	var err error
 	defer respond(conn, &err)
 
@@ -196,10 +197,10 @@ func closeTunnel(s *state, conn net.Conn, q tunnel.Tunnel) {
 }
 
 func listTunnels(s *state, conn net.Conn) {
-	m := make(map[string]tunnel.Tunnel)
+	m := make(map[string]tunnel.TunnelDesc)
 	s.mutex.RLock()
 	for n, t := range s.tunnels {
-		m[n] = *t
+		m[n] = *t.TunnelDesc
 	}
 	s.mutex.RUnlock()