← Back to branch summary

~certify-web-dev/twisted/certify-trunk

« back to all changes in this revision

Viewing changes to twisted/conch/client/direct.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-01-17 14:52:35 UTC
  • mfrom: (1.1.5 upstream) (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20070117145235-btmig6qfmqfen0om
Tags: 2.5.0-0ubuntu1
New upstream version, compatible with python2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
twisted/conch/client/direct.py
 
1
# Copyright (c) 2001-2004 Twisted Matrix Laboratories.
 
2
# See LICENSE for details.
 
3
 
 
4
#
 
5
from twisted.internet import defer, protocol, reactor
 
6
from twisted.conch import error
 
7
from twisted.conch.ssh import transport
 
8
from twisted.python import log
 
9
 
 
10
import unix
 
11
 
 
12
import os
 
13
 
 
14
class SSHClientFactory(protocol.ClientFactory):
 
15
#    noisy = 1
 
16
 
 
17
    def __init__(self, d, options, verifyHostKey, userAuthObject):
 
18
        self.d = d
 
19
        self.options = options
 
20
        self.verifyHostKey = verifyHostKey
 
21
        self.userAuthObject = userAuthObject
 
22
 
 
23
    def clientConnectionLost(self, connector, reason):
 
24
        if self.options['reconnect']:
 
25
            connector.connect()
 
26
 
 
27
    def clientConnectionFailed(self, connector, reason):
 
28
        if not self.d: return
 
29
        d = self.d
 
30
        self.d = None
 
31
        d.errback(reason)
 
32
 
 
33
    def buildProtocol(self, addr):
 
34
        trans = SSHClientTransport(self)
 
35
        if self.options['ciphers']:
 
36
            trans.supportedCiphers = self.options['ciphers']
 
37
        if self.options['macs']:
 
38
            trans.supportedMACs = self.options['macs']
 
39
        if self.options['compress']:
 
40
            trans.supportedCompressions[0:1] = ['zlib']
 
41
        if self.options['host-key-algorithms']:
 
42
            trans.supportedPublicKeys = self.options['host-key-algorithms']
 
43
        return trans
 
44
 
 
45
class SSHClientTransport(transport.SSHClientTransport):
 
46
 
 
47
    def __init__(self, factory):
 
48
        self.factory = factory
 
49
        self.unixServer = None
 
50
 
 
51
    def connectionLost(self, reason):
 
52
        transport.SSHClientTransport.connectionLost(self, reason)
 
53
        if self.unixServer:
 
54
            self.unixServer.stopListening()
 
55
            self.unixServer = None
 
56
 
 
57
    def receiveError(self, code, desc):
 
58
        if not self.factory.d: return
 
59
        d = self.factory.d
 
60
        self.factory.d = None
 
61
        d.errback(error.ConchError(desc, code))
 
62
 
 
63
    def sendDisconnect(self, code, reason):
 
64
        if not self.factory.d: return
 
65
        d = self.factory.d
 
66
        self.factory.d = None
 
67
        transport.SSHClientTransport.sendDisconnect(self, code, reason)
 
68
        d.errback(error.ConchError(reason, code))
 
69
 
 
70
    def receiveDebug(self, alwaysDisplay, message, lang):
 
71
        log.msg('Received Debug Message: %s' % message)
 
72
        if alwaysDisplay: # XXX what should happen here?
 
73
            print message
 
74
 
 
75
    def verifyHostKey(self, pubKey, fingerprint):
 
76
        return self.factory.verifyHostKey(self, self.transport.getPeer().host, pubKey,
 
77
                                          fingerprint)
 
78
 
 
79
    def setService(self, service):
 
80
        log.msg('setting client server to %s' % service)
 
81
        transport.SSHClientTransport.setService(self, service)
 
82
        if service.name != 'ssh-userauth' and self.factory.d:
 
83
            d = self.factory.d
 
84
            self.factory.d = None
 
85
            d.callback(None)
 
86
        if service.name == 'ssh-connection':
 
87
            # listen for UNIX
 
88
            if not self.factory.options['nocache']:
 
89
                user = self.factory.userAuthObject.user
 
90
                peer = self.transport.getPeer()
 
91
                filename = os.path.expanduser("~/.conch-%s-%s-%i" % (user, peer.host, peer.port))
 
92
                try:
 
93
                    u = unix.SSHUnixServerFactory(service)
 
94
                    try:
 
95
                        os.unlink(filename)
 
96
                    except OSError:
 
97
                        pass
 
98
                    self.unixServer = reactor.listenUNIX(filename, u, mode=0600, wantPID=1)
 
99
                except Exception, e:
 
100
                    log.msg('error trying to listen on %s' % filename)
 
101
                    log.err(e)
 
102
 
 
103
    def connectionSecure(self):
 
104
        self.requestService(self.factory.userAuthObject)
 
105
 
 
106
 
 
107
def connect(host, port, options, verifyHostKey, userAuthObject):
 
108
    d = defer.Deferred()
 
109
    factory = SSHClientFactory(d, options, verifyHostKey, userAuthObject)
 
110
    reactor.connectTCP(host, port, factory)
 
111
    return d