func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
flag.Parse()
logger, reconfigurableSink := cf_lager.New("sshd")
serverConfig, err := configure(logger)
if err != nil {
logger.Error("configure-failed", err)
os.Exit(1)
}
runner := handlers.NewCommandRunner()
shellLocator := handlers.NewShellLocator()
dialer := &net.Dialer{}
sshDaemon := daemon.New(
logger,
serverConfig,
nil,
map[string]handlers.NewChannelHandler{
"session": handlers.NewSessionChannelHandler(runner, shellLocator, getDaemonEnvironment(), 15*time.Second),
"direct-tcpip": handlers.NewDirectTcpipChannelHandler(dialer),
},
)
server := server.NewServer(logger, *address, sshDaemon)
members := grouper.Members{
{"sshd", server},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
os.Exit(0)
}
func main() {
cf_debug_server.AddFlags(flag.CommandLine)
cf_lager.AddFlags(flag.CommandLine)
flag.Parse()
logger, reconfigurableSink := cf_lager.New("sshd")
serverConfig, err := configure(logger)
if err != nil {
logger.Error("configure-failed", err)
os.Exit(1)
}
sshDaemon := daemon.New(logger, serverConfig, nil, newChannelHandlers())
server := server.NewServer(logger, *address, sshDaemon)
members := grouper.Members{
{"sshd", server},
}
if dbgAddr := cf_debug_server.DebugAddress(flag.CommandLine); dbgAddr != "" {
members = append(grouper.Members{
{"debug-server", cf_debug_server.Runner(dbgAddr, reconfigurableSink)},
}, members...)
}
group := grouper.NewOrdered(os.Interrupt, members)
monitor := ifrit.Invoke(sigmon.New(group))
logger.Info("started")
err = <-monitor.Wait()
if err != nil {
logger.Error("exited-with-failure", err)
os.Exit(1)
}
logger.Info("exited")
os.Exit(0)
}
shellLocator = &fakes.FakeShellLocator{}
shellLocator.ShellPathReturns("/bin/sh")
defaultEnv = map[string]string{}
defaultEnv["TEST"] = "FOO"
sessionChannelHandler = handlers.NewSessionChannelHandler(runner, shellLocator, defaultEnv, time.Second)
newChannelHandlers = map[string]handlers.NewChannelHandler{
"session": sessionChannelHandler,
}
serverNetConn, clientNetConn := test_helpers.Pipe()
sshd = daemon.New(logger, serverSSHConfig, nil, newChannelHandlers)
connectionFinished = make(chan struct{})
go func() {
sshd.HandleConnection(serverNetConn)
close(connectionFinished)
}()
client = test_helpers.NewClient(clientNetConn, nil)
})
AfterEach(func() {
if client != nil {
err := client.Close()
Expect(err).NotTo(HaveOccurred())
}
Eventually(connectionFinished).Should(BeClosed())
permissions := &ssh.Permissions{
CriticalOptions: map[string]string{
"proxy-target-config": string(targetConfigJson),
"log-message": string(logMessageJson),
},
}
proxyAuthenticator.AuthenticateReturns(permissions, nil)
})
JustBeforeEach(func() {
sshProxy = proxy.New(logger.Session("proxy"), proxySSHConfig)
proxyServer = server.NewServer(logger, "127.0.0.1:0", sshProxy)
proxyServer.SetListener(proxyListener)
go proxyServer.Serve()
sshDaemon = daemon.New(logger.Session("sshd"), daemonSSHConfig, daemonGlobalRequestHandlers, daemonNewChannelHandlers)
sshdServer = server.NewServer(logger, "127.0.0.1:0", sshDaemon)
sshdServer.SetListener(sshdListener)
go sshdServer.Serve()
})
AfterEach(func() {
proxyServer.Shutdown()
sshdServer.Shutdown()
})
Context("when a new connection arrives", func() {
var clientConfig *ssh.ClientConfig
BeforeEach(func() {
clientConfig = &ssh.ClientConfig{
logger = lagertest.NewTestLogger("test")
serverSSHConfig = &ssh.ServerConfig{
NoClientAuth: true,
}
serverSSHConfig.AddHostKey(TestHostKey)
})
Describe("HandleConnection", func() {
var fakeConn *fake_net.FakeConn
Context("when the function returns", func() {
BeforeEach(func() {
fakeConn = &fake_net.FakeConn{}
fakeConn.ReadReturns(0, errors.New("oops"))
sshd = daemon.New(logger, serverSSHConfig, nil, nil)
})
It("closes the connection", func() {
sshd.HandleConnection(fakeConn)
Expect(fakeConn.CloseCallCount()).To(BeNumerically(">=", 1))
})
})
Context("when an ssh client connects", func() {
var (
serverNetConn net.Conn
clientNetConn net.Conn
clientConn ssh.Conn
clientChannels <-chan ssh.NewChannel
