remote

type Ask interface {
	// Passphrase unlocks a private key file. A passphrase that does not
	// open the key is asked for again, so a typo is a second try rather
	// than a connection that quietly signs in some other way -- or does
	// not sign in at all. Cancelling is what stops the asking.
	Passphrase(ctx context.Context, key LockedKey) (string, error)

	// Password is the account password, asked only after key
	// authentication has been tried.
	Password(ctx context.Context, user, host string) (string, error)

	// Question is keyboard-interactive authentication: whatever the
	// server decided to ask, which is usually a one-time code.
	Question(ctx context.Context, q Question) ([]string, error)

	// TrustHostKey asks whether to connect to a host that is not in
	// known_hosts. Answering yes records the key.
	TrustHostKey(ctx context.Context, key HostKey) (bool, error)

	// Notice is something a server said rather than asked: a link to
	// open, most often, which is how a server that signs people in
	// through a browser tells them where to go. The handshake goes on
	// waiting while they do it, and finishes on its own once they have.
	//
	// It must return as soon as the message is on its way to the user.
	// Nothing is waiting for an answer, and a client that sat on this
	// would hold up the very handshake the user is being asked to
	// unblock.
	//
	// The message stops being worth showing when ctx is done, which is
	// when the connection has been made, has failed, or was given up
	// on.
	Notice(ctx context.Context, n Notice)
}

type Book struct {
	// contains filtered or unexported fields
}

type Config struct {
	// Host is the name or address to connect to. Port defaults to 22.
	Host string
	Port int

	// User defaults to the local username.
	User string

	// KnownHosts lists the files to verify the host key against. Empty
	// means the usual ~/.ssh/known_hosts.
	KnownHosts []string

	// Identities lists private key files to try. Empty means the usual
	// ~/.ssh/id_ed25519, id_ecdsa and id_rsa. A file named here that
	// cannot be read or decrypted fails the connection; one of the
	// defaults is skipped.
	Identities []string

	// NoAgent skips the SSH agent even when one is running, and
	// NoIdentities skips key files entirely, for a connection that
	// should only ever offer a password.
	NoAgent      bool
	NoIdentities bool

	// ForwardAgent carries this machine's SSH agent to the far end, so a
	// second hop from there signs with the keys held here.
	//
	// It is for the whole connection, not one pane: while it is on,
	// anyone who is root on that machine can sign with these keys.
	ForwardAgent bool

	// KeysOnly offers keys and nothing else, which is what taking over
	// another kakel window does: that end accepts no password and no
	// keyboard-interactive.
	KeysOnly bool

	// NoRing leaves out the keys already unlocked, for a connection that
	// must offer only the key files it was named.
	NoRing bool

	// Ask reaches the user for a passphrase, a password, a one-time code
	// or a decision about an unknown host key. A nil one refuses
	// anything that would need asking: encrypted keys are skipped, no
	// password is offered, and an unknown host is a hard failure.
	Ask Ask

	// Saying is told each step of connecting as it is tried, for showing
	// somebody what a connection is doing. A nil one is not called.
	//
	// It is called from whichever goroutine is connecting, which is not
	// the one that draws, so an implementation that touches a window has
	// to hand the work to whatever does.
	Saying func(what string)

	// Wrong is told the steps that did not go well: a passphrase that
	// did not unlock a key, an SSH agent that stopped answering. A
	// window draws these differently from the steps that went well, so
	// an account of a connection that had trouble does not read like one
	// that had none. A nil one sends them to Saying instead.
	Wrong func(what string)

	// Ring holds keys already unlocked, so a passphrase is asked for
	// once and then used for every connection. A nil one holds nothing
	// and keeps nothing.
	Ring *Ring

	// HostKeyCallback replaces known-hosts checking entirely.
	//
	// This exists so tests can pin a generated host key. Setting it in a
	// real client — to ssh.InsecureIgnoreHostKey, say — removes the only
	// defence against a man-in-the-middle, and nothing else here will
	// notice.
	HostKeyCallback ssh.HostKeyCallback
	// contains filtered or unexported fields
}

type Conn struct {
	// contains filtered or unexported fields
}

type Counter interface {
	// Wrap returns a writer that counts what is written through it. out
	// says the bytes are leaving this machine.
	Wrap(w io.Writer, out bool) io.Writer
}

type FileRelay struct {
	// contains filtered or unexported fields
}

type Files struct {
	// contains filtered or unexported fields
}

type Forwarder struct {
	// contains filtered or unexported fields
}

type Host struct {
	// Name is what the user calls this machine. It is what the panel
	// shows and what Via names, so it has to be unique in a Book.
	Name string `json:"name"`

	// ID is what the window knows this machine by, and never changes.
	//
	// Not the name: a name can be given up in a rename and given to
	// another machine, and something that remembered only the name
	// would follow it there. The Book gives one out and keeps it; the
	// user never sees it.
	ID string `json:"id,omitempty"`

	// Address and Port are the machine itself. A zero port means 22.
	Address string `json:"address"`
	Port    int    `json:"port,omitempty"`

	// User is the account to log in as. Empty means the local username.
	User string `json:"user,omitempty"`

	// Via is the ID of another saved host to reach this one through,
	// with no local port opened for it.
	//
	// The id and not the name, so a jump host renamed is still the one
	// this goes through, and a server saved since under the name it
	// gave up is not. A Book given a name here, in a list saved before
	// servers had ids or in one edited by hand, turns it into the id of
	// the server with that name.
	Via string `json:"via,omitempty"`

	// Identities lists private key files to prefer. Empty means the
	// usual three under ~/.ssh.
	Identities []string `json:"identities,omitempty"`

	// Term is the TERM value sent to the machine. Empty means
	// xterm-256color.
	Term string `json:"term,omitempty"`

	// Folders are directories on this machine that were worth opening
	// a file browser at, before there were favourites. They are moved to
	// favourites once, and read for nothing else.
	Folders []string `json:"folders,omitempty"`

	// Setup says the shell on this machine is taught to say where it
	// is and where each command starts, by kakel typing one line in
	// as the shell starts.
	//
	// Off unless the user asks for it: the line goes into whatever
	// login shell the account has, and an unusual one would answer
	// with an error rather than doing it.
	Setup bool `json:"shellSetup,omitempty"`

	// ForwardAgent carries this machine's SSH agent to the server, so a
	// second hop from there signs with the keys held here.
	//
	// Off unless the user asks for it: while it is on, anyone who is
	// root on that server can sign with these keys.
	ForwardAgent bool `json:"forwardAgent,omitempty"`

	// Window says this is another kakel serving, taken over rather
	// than logged in to.
	//
	// Address and Port are where it serves, and the first of Identities
	// is the key to offer it. User and Term mean nothing to one: there
	// is no account to log in to. Via is the saved server the window,
	// or its relay, is reached through.
	Window bool `json:"window,omitempty"`

	// Code is the code of a window served through a relay, which is
	// reached by the relay and the code rather than an address and a
	// port: Address is then the relay's URL, with its secret.
	Code string `json:"code,omitempty"`
}

type HostKey struct {
	// Addr is the host:port being connected to.
	Addr string

	// Shown is what to call the machine when Addr is not it, as for a
	// window reached through a relay; empty when Addr is.
	Shown string

	// Key is what the server presented.
	Key ssh.PublicKey
}

type Kind struct {
	// Name is the book's own spelling of the name, which can differ in
	// case from the name asked about.
	Name string

	// Window says the machine is another kakel, and Serve is where
	// that one serves.
	Window bool
	Serve  string
}

type LockedKey struct {
	// Path is the key file being unlocked.
	Path string

	// Wrong counts the passphrases already refused for this file, and is
	// zero the first time it is asked. Anything above zero means the
	// last answer did not open the key, which the dialog has to say: a
	// question asked twice with no word of why reads as a question that
	// was not heard.
	Wrong int
}

type NewKey struct {
	// Path is the private half, and Pub the public half beside it.
	Path string
	Pub  string

	// Line is the public half as one line, which is what goes into an
	// authorized_keys file.
	Line string
}

type Notice struct {
	// User and Host name the connection the message came from.
	User, Host string

	// Name and Instruction are the server's own wording, and may be
	// empty. Text is the message of a banner, which has neither.
	Name, Instruction, Text string
}

type OwnedShell struct {
	*Shell
	// contains filtered or unexported fields
}

type Question struct {
	// User and Host name the connection the question came from.
	User, Host string

	// Name and Instruction are the server's own wording, and may be
	// empty.
	Name, Instruction string

	// Prompts is what to ask, and Echo says which answers may be shown
	// as they are typed. The two are the same length.
	Prompts []string
	Echo    []bool
}

type Reach struct {
	// Addr is where the window serves, which its host key is kept
	// under, and KeyFile the key to offer it.
	Addr, KeyFile string
	// Through makes the connection the window is reached over, in place
	// of a TCP connection to Addr: a stream through a relay, or through
	// a jump server. A nil one dials Addr from this machine.
	Through func(ctx context.Context) (net.Conn, error)
	// Shown is what to call the window, when Addr is not it.
	Shown string
	Ring  *Ring
	Ask   Ask

	// Known says where the windows already reached are recorded. Given
	// rather than looked up, so a test can hand over a file of its own.
	Known func() (string, error)

	// Agent is where the keys an SSH agent holds come from: the socket to
	// hold until signing is done, and the agent speaking over it. A nil
	// one asks the agent running on this machine.
	//
	// Listing is left to the ladder to call, so the same bound and the
	// same "it did not answer" applies here as anywhere else.
	Agent func() (io.Closer, agent.Agent, error)

	// Saying is told what is being done now, for the row to show. It is
	// called from the goroutine doing it, so it hands the work to
	// whatever draws. A nil one is not called.
	Saying func(what string)

	// Wrong is told the steps that did not go well, which a window draws
	// differently from the ones that did. A nil one sends them to
	// Saying instead.
	Wrong func(what string)

	// Patience is how long the other end has to get through the
	// handshake. Zero asks the serve package for its own.
	Patience time.Duration
}

type Ring struct {
	// contains filtered or unexported fields
}

type SSHConfigHost struct {
	Alias, HostName, User string
	Port                  int
	Identity, Jump        string
}

type Shell struct {
	// contains filtered or unexported fields
}

type ShellConfig struct {
	// Command is what to run. Empty asks for the user's login shell.
	Command []string

	// Dir is the directory to run Command in. Empty runs wherever the
	// login lands. It is ignored without a Command: a shell to type into
	// is started where the far end starts it.
	Dir string

	// Cols and Rows are the initial window size.
	Cols, Rows int

	// Term is the TERM value sent to the remote. Defaults to
	// xterm-256color.
	Term string
}

type Tunnel struct {
	// Kind is which machine listens.
	Kind TunnelKind

	// Listen is where connections are accepted, as host:port, read on
	// whichever machine is doing the listening. An empty host means that
	// machine only, which is what ssh does and what keeps a tunnel from
	// being a hole for everything on the network. Port 0 asks for any
	// free port.
	//
	// For a remote forward this is what the far machine is asked for.
	// Where it really binds is its own decision: a server set to share
	// forwarded ports binds them for its whole network whatever the
	// client asked.
	Listen string

	// Target is where they are sent, as host:port, read on whichever
	// machine is doing the connecting. A dynamic tunnel has none: every
	// stream says where it wants to go.
	Target string
}

type TunnelConfig struct {
	// Tunnel is the forward itself.
	Tunnel Tunnel

	// Count records what moves, for the panel. It may be nil.
	Count Counter

	// OnError is told about a failure on one stream, which leaves the
	// tunnel open: the next stream may work. It is called from the
	// goroutines carrying the streams, so it must be safe to call from
	// any of them.
	OnError func(error)

	// OnStopped is told when the tunnel has ended on its own, because
	// the listener failed. It is called once, from the goroutine that
	// was accepting, and never for a tunnel that was closed on purpose.
	OnStopped func(error)
}

type TunnelKind uint8