// sendSshKeepAlive is a helper which sends a [email protected] request // on the specified SSH connections and returns true of the request succeeds // within a specified timeout. func sendSshKeepAlive( sshClient *ssh.Client, conn net.Conn, timeout time.Duration) error { errChannel := make(chan error, 2) if timeout > 0 { time.AfterFunc(timeout, func() { errChannel <- TimeoutError{} }) } go func() { // Random padding to frustrate fingerprinting _, _, err := sshClient.SendRequest( "*****@*****.**", true, MakeSecureRandomPadding(0, TUNNEL_SSH_KEEP_ALIVE_PAYLOAD_MAX_BYTES)) errChannel <- err }() err := <-errChannel if err != nil { sshClient.Close() conn.Close() } return ContextError(err) }
// sendSshKeepAlive is a helper which sends a [email protected] request // on the specified SSH connections and returns true of the request succeeds // within a specified timeout. func sendSshKeepAlive(sshClient *ssh.Client) error { errChannel := make(chan error, 2) time.AfterFunc(TUNNEL_SSH_KEEP_ALIVE_TIMEOUT, func() { errChannel <- TimeoutError{} }) go func() { // Random padding to frustrate fingerprinting _, _, err := sshClient.SendRequest( "*****@*****.**", true, MakeSecureRandomPadding(0, TUNNEL_SSH_KEEP_ALIVE_PAYLOAD_MAX_BYTES)) errChannel <- err }() return ContextError(<-errChannel) }
func SSHls(client *ssh.Client) ([]string, error) {
defer trace.End(trace.Begin(""))
ok, reply, err := client.SendRequest(msgs.ContainersReq, true, nil)
if !ok || err != nil {
return nil, fmt.Errorf("failed to get container IDs from remote: %s", err)
}
ids := msgs.ContainersMsg{}
if err = ids.Unmarshal(reply); err != nil {
log.Debugf("raw IDs response: %+v", reply)
return nil, fmt.Errorf("failed to unmarshal ids from remote: %s", err)
}
return ids.IDs, nil
}
client.Close()
})
Context("when the client sends a global request", func() {
var globalRequestHandler *fake_handlers.FakeGlobalRequestHandler
BeforeEach(func() {
globalRequestHandler = &fake_handlers.FakeGlobalRequestHandler{}
globalRequestHandler.HandleRequestStub = func(logger lager.Logger, request *ssh.Request) {
request.Reply(true, []byte("response-payload"))
}
daemonGlobalRequestHandlers["test-global-request"] = globalRequestHandler
})
It("gets forwarded to the daemon and the response comes back", func() {
accepted, response, err := client.SendRequest("test-global-request", true, []byte("request-payload"))
Expect(err).NotTo(HaveOccurred())
Expect(accepted).To(BeTrue())
Expect(response).To(Equal([]byte("response-payload")))
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
AfterEach(func() {
client.Close()
})
Context("when a global request is recevied", func() {
var (
accepted bool
requestErr error
name string
wantReply bool
)
JustBeforeEach(func() {
accepted, _, requestErr = client.SendRequest(name, wantReply, []byte("payload"))
})
Context("and there is an associated handler", func() {
BeforeEach(func() {
name = "known-handler"
wantReply = true
fakeHandler.HandleRequestStub = func(logger lager.Logger, request *ssh.Request) {
request.Reply(true, []byte("response"))
}
})
It("calls the handler to handle the request", func() {
Eventually(fakeHandler.HandleRequestCallCount).Should(Equal(1))
})
