Expect(globalRequestHandler.HandleRequestCallCount()).To(Equal(1))
_, request := globalRequestHandler.HandleRequestArgsForCall(0)
Expect(request.Type).To(Equal("test-global-request"))
Expect(request.WantReply).To(BeTrue())
Expect(request.Payload).To(Equal([]byte("request-payload")))
})
})
Context("when the client requests a new channel", func() {
var newChannelHandler *fake_handlers.FakeNewChannelHandler
BeforeEach(func() {
newChannelHandler = &fake_handlers.FakeNewChannelHandler{}
newChannelHandler.HandleNewChannelStub = func(logger lager.Logger, newChannel ssh.NewChannel) {
newChannel.Reject(ssh.Prohibited, "not now")
}
daemonNewChannelHandlers["test"] = newChannelHandler
})
It("gets forwarded to the daemon", func() {
_, _, err := client.OpenChannel("test", nil)
Expect(err).To(Equal(&ssh.OpenChannelError{Reason: ssh.Prohibited, Message: "not now"}))
})
})
})
Describe("target requests to client", func() {
var (
connectionHandler *server_fakes.FakeConnectionHandler
echoServer = server.NewServer(logger.Session("echo"), "", echoHandler)
echoServer.SetListener(echoListener)
go echoServer.Serve()
serverSSHConfig = &ssh.ServerConfig{
NoClientAuth: true,
}
serverSSHConfig.AddHostKey(TestHostKey)
testDialer = &fakes.FakeDialer{}
testDialer.DialStub = net.Dial
testHandler = handlers.NewDirectTcpipChannelHandler(testDialer)
handler = &fake_handlers.FakeNewChannelHandler{}
handler.HandleNewChannelStub = testHandler.HandleNewChannel
newChannelHandlers := map[string]handlers.NewChannelHandler{
"direct-tcpip": handler,
}
serverNetConn, clientNetConn := test_helpers.Pipe()
sshd = daemon.New(logger, serverSSHConfig, nil, newChannelHandlers)
go sshd.HandleConnection(serverNetConn)
client = test_helpers.NewClient(clientNetConn, nil)
})
AfterEach(func() {
client.Close()
sshChannel ssh.Channel
requestChan <-chan *ssh.Request
openError error
)
JustBeforeEach(func() {
sshChannel, requestChan, openError = client.OpenChannel(channelType, []byte("extra-data"))
})
Context("and there is an associated handler", func() {
BeforeEach(func() {
channelType = "known-channel-type"
fakeHandler.HandleNewChannelStub = func(logger lager.Logger, newChannel ssh.NewChannel) {
ch, _, err := newChannel.Accept()
Expect(err).NotTo(HaveOccurred())
ch.Close()
}
})
It("calls the handler to process the new channel request", func() {
Expect(fakeHandler.HandleNewChannelCallCount()).To(Equal(1))
logger, actualChannel := fakeHandler.HandleNewChannelArgsForCall(0)
Expect(logger).NotTo(BeNil())
Expect(actualChannel.ChannelType()).To(Equal("known-channel-type"))
Expect(actualChannel.ExtraData()).To(Equal([]byte("extra-data")))
})
})
