← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: John Arbash Meinel
  • Date: 2007-01-25 15:54:29 UTC
  • mto: This revision was merged to the branch mainline in revision 2245.
  • Revision ID: john@arbash-meinel.com-20070125155429-x53892xqx4r17l8h
Clean up the documentation and imports for decorators (per Martin's suggestions)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ssh.py
1
 
# Copyright (C) 2006-2010 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
 
2
# Copyright (C) 2005, 2006 Canonical Ltd
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
"""Foundation SSH support for SFTP and smart server."""
19
19
 
20
20
import errno
21
21
import getpass
22
 
import logging
23
22
import os
24
23
import socket
25
24
import subprocess
26
25
import sys
27
26
 
28
 
from bzrlib import (
29
 
    config,
30
 
    errors,
31
 
    osutils,
32
 
    trace,
33
 
    ui,
34
 
    )
 
27
from bzrlib.config import config_dir, ensure_config_dir_exists
 
28
from bzrlib.errors import (ConnectionError,
 
29
                           ParamikoNotPresent,
 
30
                           SocketConnectionError,
 
31
                           TransportError,
 
32
                           UnknownSSH,
 
33
                           )
 
34
 
 
35
from bzrlib.osutils import pathjoin
 
36
from bzrlib.trace import mutter, warning
 
37
import bzrlib.ui
35
38
 
36
39
try:
37
40
    import paramiko
55
58
# connect to an agent if we are on win32 and using Paramiko older than 1.6
56
59
_use_ssh_agent = (sys.platform != 'win32' or _paramiko_version >= (1, 6, 0))
57
60
 
58
 
 
59
 
class SSHVendorManager(object):
60
 
    """Manager for manage SSH vendors."""
61
 
 
62
 
    # Note, although at first sign the class interface seems similar to
63
 
    # bzrlib.registry.Registry it is not possible/convenient to directly use
64
 
    # the Registry because the class just has "get()" interface instead of the
65
 
    # Registry's "get(key)".
66
 
 
67
 
    def __init__(self):
68
 
        self._ssh_vendors = {}
69
 
        self._cached_ssh_vendor = None
70
 
        self._default_ssh_vendor = None
71
 
 
72
 
    def register_default_vendor(self, vendor):
73
 
        """Register default SSH vendor."""
74
 
        self._default_ssh_vendor = vendor
75
 
 
76
 
    def register_vendor(self, name, vendor):
77
 
        """Register new SSH vendor by name."""
78
 
        self._ssh_vendors[name] = vendor
79
 
 
80
 
    def clear_cache(self):
81
 
        """Clear previously cached lookup result."""
82
 
        self._cached_ssh_vendor = None
83
 
 
84
 
    def _get_vendor_by_environment(self, environment=None):
85
 
        """Return the vendor or None based on BZR_SSH environment variable.
86
 
 
87
 
        :raises UnknownSSH: if the BZR_SSH environment variable contains
88
 
                            unknown vendor name
89
 
        """
90
 
        if environment is None:
91
 
            environment = os.environ
92
 
        if 'BZR_SSH' in environment:
93
 
            vendor_name = environment['BZR_SSH']
94
 
            try:
95
 
                vendor = self._ssh_vendors[vendor_name]
96
 
            except KeyError:
97
 
                vendor = self._get_vendor_from_path(vendor_name)
98
 
                if vendor is None:
99
 
                    raise errors.UnknownSSH(vendor_name)
100
 
                vendor.executable_path = vendor_name
101
 
            return vendor
102
 
        return None
103
 
 
104
 
    def _get_ssh_version_string(self, args):
105
 
        """Return SSH version string from the subprocess."""
 
61
_ssh_vendors = {}
 
62
 
 
63
def register_ssh_vendor(name, vendor):
 
64
    """Register SSH vendor."""
 
65
    _ssh_vendors[name] = vendor
 
66
 
 
67
    
 
68
_ssh_vendor = None
 
69
def _get_ssh_vendor():
 
70
    """Find out what version of SSH is on the system."""
 
71
    global _ssh_vendor
 
72
    if _ssh_vendor is not None:
 
73
        return _ssh_vendor
 
74
 
 
75
    if 'BZR_SSH' in os.environ:
 
76
        vendor_name = os.environ['BZR_SSH']
106
77
        try:
107
 
            p = subprocess.Popen(args,
108
 
                                 stdout=subprocess.PIPE,
109
 
                                 stderr=subprocess.PIPE,
110
 
                                 **os_specific_subprocess_params())
111
 
            stdout, stderr = p.communicate()
112
 
        except OSError:
113
 
            stdout = stderr = ''
114
 
        return stdout + stderr
115
 
 
116
 
    def _get_vendor_by_version_string(self, version, progname):
117
 
        """Return the vendor or None based on output from the subprocess.
118
 
 
119
 
        :param version: The output of 'ssh -V' like command.
120
 
        :param args: Command line that was run.
121
 
        """
122
 
        vendor = None
123
 
        if 'OpenSSH' in version:
124
 
            trace.mutter('ssh implementation is OpenSSH')
125
 
            vendor = OpenSSHSubprocessVendor()
126
 
        elif 'SSH Secure Shell' in version:
127
 
            trace.mutter('ssh implementation is SSH Corp.')
128
 
            vendor = SSHCorpSubprocessVendor()
129
 
        # As plink user prompts are not handled currently, don't auto-detect
130
 
        # it by inspection below, but keep this vendor detection for if a path
131
 
        # is given in BZR_SSH. See https://bugs.launchpad.net/bugs/414743
132
 
        elif 'plink' in version and progname == 'plink':
133
 
            # Checking if "plink" was the executed argument as Windows
134
 
            # sometimes reports 'ssh -V' incorrectly with 'plink' in it's
135
 
            # version.  See https://bugs.launchpad.net/bzr/+bug/107155
136
 
            trace.mutter("ssh implementation is Putty's plink.")
137
 
            vendor = PLinkSubprocessVendor()
138
 
        return vendor
139
 
 
140
 
    def _get_vendor_by_inspection(self):
141
 
        """Return the vendor or None by checking for known SSH implementations."""
142
 
        version = self._get_ssh_version_string(['ssh', '-V'])
143
 
        return self._get_vendor_by_version_string(version, "ssh")
144
 
 
145
 
    def _get_vendor_from_path(self, path):
146
 
        """Return the vendor or None using the program at the given path"""
147
 
        version = self._get_ssh_version_string([path, '-V'])
148
 
        return self._get_vendor_by_version_string(version, 
149
 
            os.path.splitext(os.path.basename(path))[0])
150
 
 
151
 
    def get_vendor(self, environment=None):
152
 
        """Find out what version of SSH is on the system.
153
 
 
154
 
        :raises SSHVendorNotFound: if no any SSH vendor is found
155
 
        :raises UnknownSSH: if the BZR_SSH environment variable contains
156
 
                            unknown vendor name
157
 
        """
158
 
        if self._cached_ssh_vendor is None:
159
 
            vendor = self._get_vendor_by_environment(environment)
160
 
            if vendor is None:
161
 
                vendor = self._get_vendor_by_inspection()
162
 
                if vendor is None:
163
 
                    trace.mutter('falling back to default implementation')
164
 
                    vendor = self._default_ssh_vendor
165
 
                    if vendor is None:
166
 
                        raise errors.SSHVendorNotFound()
167
 
            self._cached_ssh_vendor = vendor
168
 
        return self._cached_ssh_vendor
169
 
 
170
 
_ssh_vendor_manager = SSHVendorManager()
171
 
_get_ssh_vendor = _ssh_vendor_manager.get_vendor
172
 
register_default_ssh_vendor = _ssh_vendor_manager.register_default_vendor
173
 
register_ssh_vendor = _ssh_vendor_manager.register_vendor
174
 
 
175
 
 
176
 
def _ignore_signals():
 
78
            _ssh_vendor = _ssh_vendors[vendor_name]
 
79
        except KeyError:
 
80
            raise UnknownSSH(vendor_name)
 
81
        return _ssh_vendor
 
82
 
 
83
    try:
 
84
        p = subprocess.Popen(['ssh', '-V'],
 
85
                             stdin=subprocess.PIPE,
 
86
                             stdout=subprocess.PIPE,
 
87
                             stderr=subprocess.PIPE,
 
88
                             **os_specific_subprocess_params())
 
89
        returncode = p.returncode
 
90
        stdout, stderr = p.communicate()
 
91
    except OSError:
 
92
        returncode = -1
 
93
        stdout = stderr = ''
 
94
    if 'OpenSSH' in stderr:
 
95
        mutter('ssh implementation is OpenSSH')
 
96
        _ssh_vendor = OpenSSHSubprocessVendor()
 
97
    elif 'SSH Secure Shell' in stderr:
 
98
        mutter('ssh implementation is SSH Corp.')
 
99
        _ssh_vendor = SSHCorpSubprocessVendor()
 
100
 
 
101
    if _ssh_vendor is not None:
 
102
        return _ssh_vendor
 
103
 
 
104
    # XXX: 20051123 jamesh
 
105
    # A check for putty's plink or lsh would go here.
 
106
 
 
107
    mutter('falling back to paramiko implementation')
 
108
    _ssh_vendor = ParamikoVendor()
 
109
    return _ssh_vendor
 
110
 
 
111
 
 
112
def _ignore_sigint():
177
113
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
178
114
    # doesn't handle it itself.
179
115
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
180
116
    import signal
181
117
    signal.signal(signal.SIGINT, signal.SIG_IGN)
182
 
    # GZ 2010-02-19: Perhaps make this check if breakin is installed instead
183
 
    if signal.getsignal(signal.SIGQUIT) != signal.SIG_DFL:
184
 
        signal.signal(signal.SIGQUIT, signal.SIG_IGN)
185
 
 
186
 
 
187
 
class SocketAsChannelAdapter(object):
 
118
    
 
119
 
 
120
 
 
121
class LoopbackSFTP(object):
188
122
    """Simple wrapper for a socket that pretends to be a paramiko Channel."""
189
123
 
190
124
    def __init__(self, sock):
191
125
        self.__socket = sock
192
 
 
193
 
    def get_name(self):
194
 
        return "bzr SocketAsChannelAdapter"
195
 
 
 
126
 
196
127
    def send(self, data):
197
128
        return self.__socket.send(data)
198
129
 
199
130
    def recv(self, n):
200
 
        try:
201
 
            return self.__socket.recv(n)
202
 
        except socket.error, e:
203
 
            if e.args[0] in (errno.EPIPE, errno.ECONNRESET, errno.ECONNABORTED,
204
 
                             errno.EBADF):
205
 
                # Connection has closed.  Paramiko expects an empty string in
206
 
                # this case, not an exception.
207
 
                return ''
208
 
            raise
 
131
        return self.__socket.recv(n)
209
132
 
210
133
    def recv_ready(self):
211
 
        # TODO: jam 20051215 this function is necessary to support the
212
 
        # pipelined() function. In reality, it probably should use
213
 
        # poll() or select() to actually return if there is data
214
 
        # available, otherwise we probably don't get any benefit
215
134
        return True
216
135
 
217
136
    def close(self):
220
139
 
221
140
class SSHVendor(object):
222
141
    """Abstract base class for SSH vendor implementations."""
223
 
 
 
142
    
224
143
    def connect_sftp(self, username, password, host, port):
225
144
        """Make an SSH connection, and return an SFTPClient.
226
 
 
 
145
        
227
146
        :param username: an ascii string
228
147
        :param password: an ascii string
229
148
        :param host: a host name as an ascii string
238
157
 
239
158
    def connect_ssh(self, username, password, host, port, command):
240
159
        """Make an SSH connection.
241
 
 
 
160
        
242
161
        :returns: something with a `close` method, and a `get_filelike_channels`
243
162
            method that returns a pair of (read, write) filelike objects.
244
163
        """
245
164
        raise NotImplementedError(self.connect_ssh)
246
 
 
 
165
        
247
166
    def _raise_connection_error(self, host, port=None, orig_error=None,
248
167
                                msg='Unable to connect to SSH host'):
249
168
        """Raise a SocketConnectionError with properly formatted host.
251
170
        This just unifies all the locations that try to raise ConnectionError,
252
171
        so that they format things properly.
253
172
        """
254
 
        raise errors.SocketConnectionError(host=host, port=port, msg=msg,
255
 
                                           orig_error=orig_error)
 
173
        raise SocketConnectionError(host=host, port=port, msg=msg,
 
174
                                    orig_error=orig_error)
256
175
 
257
176
 
258
177
class LoopbackVendor(SSHVendor):
259
178
    """SSH "vendor" that connects over a plain TCP socket, not SSH."""
260
 
 
 
179
    
261
180
    def connect_sftp(self, username, password, host, port):
262
181
        sock = socket.socket()
263
182
        try:
264
183
            sock.connect((host, port))
265
184
        except socket.error, e:
266
185
            self._raise_connection_error(host, port=port, orig_error=e)
267
 
        return SFTPClient(SocketAsChannelAdapter(sock))
 
186
        return SFTPClient(LoopbackSFTP(sock))
268
187
 
269
188
register_ssh_vendor('loopback', LoopbackVendor())
270
189
 
285
204
 
286
205
    def _connect(self, username, password, host, port):
287
206
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
288
 
 
 
207
        
289
208
        load_host_keys()
290
209
 
291
210
        try:
294
213
            t.start_client()
295
214
        except (paramiko.SSHException, socket.error), e:
296
215
            self._raise_connection_error(host, port=port, orig_error=e)
297
 
 
 
216
            
298
217
        server_key = t.get_remote_server_key()
299
218
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
300
219
        keytype = server_key.get_name()
301
220
        if host in SYSTEM_HOSTKEYS and keytype in SYSTEM_HOSTKEYS[host]:
302
221
            our_server_key = SYSTEM_HOSTKEYS[host][keytype]
303
 
            our_server_key_hex = paramiko.util.hexify(
304
 
                our_server_key.get_fingerprint())
 
222
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
305
223
        elif host in BZR_HOSTKEYS and keytype in BZR_HOSTKEYS[host]:
306
224
            our_server_key = BZR_HOSTKEYS[host][keytype]
307
 
            our_server_key_hex = paramiko.util.hexify(
308
 
                our_server_key.get_fingerprint())
 
225
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
309
226
        else:
310
 
            trace.warning('Adding %s host key for %s: %s'
311
 
                          % (keytype, host, server_key_hex))
 
227
            warning('Adding %s host key for %s: %s' % (keytype, host, server_key_hex))
312
228
            add = getattr(BZR_HOSTKEYS, 'add', None)
313
229
            if add is not None: # paramiko >= 1.X.X
314
230
                BZR_HOSTKEYS.add(host, keytype, server_key)
315
231
            else:
316
232
                BZR_HOSTKEYS.setdefault(host, {})[keytype] = server_key
317
233
            our_server_key = server_key
318
 
            our_server_key_hex = paramiko.util.hexify(
319
 
                our_server_key.get_fingerprint())
 
234
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
320
235
            save_host_keys()
321
236
        if server_key != our_server_key:
322
237
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
323
 
            filename2 = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
324
 
            raise errors.TransportError(
325
 
                'Host keys for %s do not match!  %s != %s' %
 
238
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
239
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
326
240
                (host, our_server_key_hex, server_key_hex),
327
241
                ['Try editing %s or %s' % (filename1, filename2)])
328
242
 
329
 
        _paramiko_auth(username, password, host, port, t)
 
243
        _paramiko_auth(username, password, host, t)
330
244
        return t
331
 
 
 
245
        
332
246
    def connect_sftp(self, username, password, host, port):
333
247
        t = self._connect(username, password, host, port)
334
248
        try:
349
263
                                         msg='Unable to invoke remote bzr')
350
264
 
351
265
if paramiko is not None:
352
 
    vendor = ParamikoVendor()
353
 
    register_ssh_vendor('paramiko', vendor)
354
 
    register_ssh_vendor('none', vendor)
355
 
    register_default_ssh_vendor(vendor)
356
 
    _sftp_connection_errors = (EOFError, paramiko.SSHException)
357
 
    del vendor
358
 
else:
359
 
    _sftp_connection_errors = (EOFError,)
 
266
    register_ssh_vendor('paramiko', ParamikoVendor())
360
267
 
361
268
 
362
269
class SubprocessVendor(SSHVendor):
363
270
    """Abstract base class for vendors that use pipes to a subprocess."""
364
 
 
 
271
    
365
272
    def _connect(self, argv):
366
273
        proc = subprocess.Popen(argv,
367
274
                                stdin=subprocess.PIPE,
374
281
            argv = self._get_vendor_specific_argv(username, host, port,
375
282
                                                  subsystem='sftp')
376
283
            sock = self._connect(argv)
377
 
            return SFTPClient(SocketAsChannelAdapter(sock))
378
 
        except _sftp_connection_errors, e:
 
284
            return SFTPClient(sock)
 
285
        except (EOFError, paramiko.SSHException), e:
379
286
            self._raise_connection_error(host, port=port, orig_error=e)
380
287
        except (OSError, IOError), e:
381
288
            # If the machine is fast enough, ssh can actually exit
403
310
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
404
311
                                  command=None):
405
312
        """Returns the argument list to run the subprocess with.
406
 
 
 
313
        
407
314
        Exactly one of 'subsystem' and 'command' must be specified.
408
315
        """
409
316
        raise NotImplementedError(self._get_vendor_specific_argv)
410
317
 
 
318
register_ssh_vendor('none', ParamikoVendor())
 
319
 
411
320
 
412
321
class OpenSSHSubprocessVendor(SubprocessVendor):
413
322
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
414
 
 
415
 
    executable_path = 'ssh'
416
 
 
 
323
    
417
324
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
418
325
                                  command=None):
419
 
        args = [self.executable_path,
 
326
        assert subsystem is not None or command is not None, (
 
327
            'Must specify a command or subsystem')
 
328
        if subsystem is not None:
 
329
            assert command is None, (
 
330
                'subsystem and command are mutually exclusive')
 
331
        args = ['ssh',
420
332
                '-oForwardX11=no', '-oForwardAgent=no',
421
333
                '-oClearAllForwardings=yes', '-oProtocol=2',
422
334
                '-oNoHostAuthenticationForLocalhost=yes']
436
348
class SSHCorpSubprocessVendor(SubprocessVendor):
437
349
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
438
350
 
439
 
    executable_path = 'ssh'
440
 
 
441
351
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
442
352
                                  command=None):
443
 
        args = [self.executable_path, '-x']
 
353
        assert subsystem is not None or command is not None, (
 
354
            'Must specify a command or subsystem')
 
355
        if subsystem is not None:
 
356
            assert command is None, (
 
357
                'subsystem and command are mutually exclusive')
 
358
        args = ['ssh', '-x']
444
359
        if port is not None:
445
360
            args.extend(['-p', str(port)])
446
361
        if username is not None:
450
365
        else:
451
366
            args.extend([host] + command)
452
367
        return args
453
 
 
454
 
register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())
455
 
 
456
 
 
457
 
class PLinkSubprocessVendor(SubprocessVendor):
458
 
    """SSH vendor that uses the 'plink' executable from Putty."""
459
 
 
460
 
    executable_path = 'plink'
461
 
 
462
 
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
463
 
                                  command=None):
464
 
        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']
465
 
        if port is not None:
466
 
            args.extend(['-P', str(port)])
467
 
        if username is not None:
468
 
            args.extend(['-l', username])
469
 
        if subsystem is not None:
470
 
            args.extend(['-s', host, subsystem])
471
 
        else:
472
 
            args.extend([host] + command)
473
 
        return args
474
 
 
475
 
register_ssh_vendor('plink', PLinkSubprocessVendor())
476
 
 
477
 
 
478
 
def _paramiko_auth(username, password, host, port, paramiko_transport):
479
 
    auth = config.AuthenticationConfig()
480
 
    # paramiko requires a username, but it might be none if nothing was
481
 
    # supplied.  If so, use the local username.
482
 
    if username is None:
483
 
        username = auth.get_user('ssh', host, port=port,
484
 
                                 default=getpass.getuser())
 
368
    
 
369
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
 
370
 
 
371
 
 
372
def _paramiko_auth(username, password, host, paramiko_transport):
 
373
    # paramiko requires a username, but it might be none if nothing was supplied
 
374
    # use the local username, just in case.
 
375
    # We don't override username, because if we aren't using paramiko,
 
376
    # the username might be specified in ~/.ssh/config and we don't want to
 
377
    # force it to something else
 
378
    # Also, it would mess up the self.relpath() functionality
 
379
    username = username or getpass.getuser()
 
380
 
485
381
    if _use_ssh_agent:
486
382
        agent = paramiko.Agent()
487
383
        for key in agent.get_keys():
488
 
            trace.mutter('Trying SSH agent key %s'
489
 
                         % paramiko.util.hexify(key.get_fingerprint()))
 
384
            mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
490
385
            try:
491
386
                paramiko_transport.auth_publickey(username, key)
492
387
                return
493
388
            except paramiko.SSHException, e:
494
389
                pass
495
 
 
 
390
    
496
391
    # okay, try finding id_rsa or id_dss?  (posix only)
497
392
    if _try_pkey_auth(paramiko_transport, paramiko.RSAKey, username, 'id_rsa'):
498
393
        return
499
394
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
500
395
        return
501
396
 
502
 
    # If we have gotten this far, we are about to try for passwords, do an
503
 
    # auth_none check to see if it is even supported.
504
 
    supported_auth_types = []
505
 
    try:
506
 
        # Note that with paramiko <1.7.5 this logs an INFO message:
507
 
        #    Authentication type (none) not permitted.
508
 
        # So we explicitly disable the logging level for this action
509
 
        old_level = paramiko_transport.logger.level
510
 
        paramiko_transport.logger.setLevel(logging.WARNING)
511
 
        try:
512
 
            paramiko_transport.auth_none(username)
513
 
        finally:
514
 
            paramiko_transport.logger.setLevel(old_level)
515
 
    except paramiko.BadAuthenticationType, e:
516
 
        # Supported methods are in the exception
517
 
        supported_auth_types = e.allowed_types
518
 
    except paramiko.SSHException, e:
519
 
        # Don't know what happened, but just ignore it
520
 
        pass
521
 
    # We treat 'keyboard-interactive' and 'password' auth methods identically,
522
 
    # because Paramiko's auth_password method will automatically try
523
 
    # 'keyboard-interactive' auth (using the password as the response) if
524
 
    # 'password' auth is not available.  Apparently some Debian and Gentoo
525
 
    # OpenSSH servers require this.
526
 
    # XXX: It's possible for a server to require keyboard-interactive auth that
527
 
    # requires something other than a single password, but we currently don't
528
 
    # support that.
529
 
    if ('password' not in supported_auth_types and
530
 
        'keyboard-interactive' not in supported_auth_types):
531
 
        raise errors.ConnectionError('Unable to authenticate to SSH host as'
532
 
            '\n  %s@%s\nsupported auth types: %s'
533
 
            % (username, host, supported_auth_types))
534
 
 
535
397
    if password:
536
398
        try:
537
399
            paramiko_transport.auth_password(username, password)
540
402
            pass
541
403
 
542
404
    # give up and ask for a password
543
 
    password = auth.get_password('ssh', host, username, port=port)
544
 
    # get_password can still return None, which means we should not prompt
545
 
    if password is not None:
546
 
        try:
547
 
            paramiko_transport.auth_password(username, password)
548
 
        except paramiko.SSHException, e:
549
 
            raise errors.ConnectionError(
550
 
                'Unable to authenticate to SSH host as'
551
 
                '\n  %s@%s\n' % (username, host), e)
552
 
    else:
553
 
        raise errors.ConnectionError('Unable to authenticate to SSH host as'
554
 
                                     '  %s@%s' % (username, host))
 
405
    password = bzrlib.ui.ui_factory.get_password(
 
406
            prompt='SSH %(user)s@%(host)s password',
 
407
            user=username, host=host)
 
408
    try:
 
409
        paramiko_transport.auth_password(username, password)
 
410
    except paramiko.SSHException, e:
 
411
        raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
412
                              (username, host), e)
555
413
 
556
414
 
557
415
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
561
419
        paramiko_transport.auth_publickey(username, key)
562
420
        return True
563
421
    except paramiko.PasswordRequiredException:
564
 
        password = ui.ui_factory.get_password(
565
 
            prompt='SSH %(filename)s password', filename=filename)
 
422
        password = bzrlib.ui.ui_factory.get_password(
 
423
                prompt='SSH %(filename)s password',
 
424
                filename=filename)
566
425
        try:
567
426
            key = pkey_class.from_private_key_file(filename, password)
568
427
            paramiko_transport.auth_publickey(username, key)
569
428
            return True
570
429
        except paramiko.SSHException:
571
 
            trace.mutter('SSH authentication via %s key failed.'
572
 
                         % (os.path.basename(filename),))
 
430
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
573
431
    except paramiko.SSHException:
574
 
        trace.mutter('SSH authentication via %s key failed.'
575
 
                     % (os.path.basename(filename),))
 
432
        mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
576
433
    except IOError:
577
434
        pass
578
435
    return False
585
442
    """
586
443
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
587
444
    try:
588
 
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(
589
 
            os.path.expanduser('~/.ssh/known_hosts'))
590
 
    except IOError, e:
591
 
        trace.mutter('failed to load system host keys: ' + str(e))
592
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
 
445
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
446
    except Exception, e:
 
447
        mutter('failed to load system host keys: ' + str(e))
 
448
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
593
449
    try:
594
450
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
595
 
    except IOError, e:
596
 
        trace.mutter('failed to load bzr host keys: ' + str(e))
 
451
    except Exception, e:
 
452
        mutter('failed to load bzr host keys: ' + str(e))
597
453
        save_host_keys()
598
454
 
599
455
 
602
458
    Save "discovered" host keys in $(config)/ssh_host_keys/.
603
459
    """
604
460
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
605
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
606
 
    config.ensure_config_dir_exists()
 
461
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
462
    ensure_config_dir_exists()
607
463
 
608
464
    try:
609
465
        f = open(bzr_hostkey_path, 'w')
613
469
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
614
470
        f.close()
615
471
    except IOError, e:
616
 
        trace.mutter('failed to save bzr host keys: ' + str(e))
 
472
        mutter('failed to save bzr host keys: ' + str(e))
617
473
 
618
474
 
619
475
def os_specific_subprocess_params():
620
476
    """Get O/S specific subprocess parameters."""
621
477
    if sys.platform == 'win32':
622
 
        # setting the process group and closing fds is not supported on
 
478
        # setting the process group and closing fds is not supported on 
623
479
        # win32
624
480
        return {}
625
481
    else:
626
 
        # We close fds other than the pipes as the child process does not need
 
482
        # We close fds other than the pipes as the child process does not need 
627
483
        # them to be open.
628
484
        #
629
485
        # We also set the child process to ignore SIGINT.  Normally the signal
631
487
        # this causes it to be seen only by bzr and not by ssh.  Python will
632
488
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
633
489
        # to release locks or do other cleanup over ssh before the connection
634
 
        # goes away.
 
490
        # goes away.  
635
491
        # <https://launchpad.net/products/bzr/+bug/5987>
636
492
        #
637
493
        # Running it in a separate process group is not good because then it
638
494
        # can't get non-echoed input of a password or passphrase.
639
495
        # <https://launchpad.net/products/bzr/+bug/40508>
640
 
        return {'preexec_fn': _ignore_signals,
 
496
        return {'preexec_fn': _ignore_sigint,
641
497
                'close_fds': True,
642
498
                }
643
499
 
644
 
import weakref
645
 
_subproc_weakrefs = set()
646
 
 
647
 
def _close_ssh_proc(proc):
648
 
    for func in [proc.stdin.close, proc.stdout.close, proc.wait]:
649
 
        try:
650
 
            func()
651
 
        except OSError:
652
 
            pass
653
 
 
654
500
 
655
501
class SSHSubprocess(object):
656
502
    """A socket-like object that talks to an ssh subprocess via pipes."""
657
503
 
658
504
    def __init__(self, proc):
659
505
        self.proc = proc
660
 
        # Add a weakref to proc that will attempt to do the same as self.close
661
 
        # to avoid leaving processes lingering indefinitely.
662
 
        def terminate(ref):
663
 
            _subproc_weakrefs.remove(ref)
664
 
            _close_ssh_proc(proc)
665
 
        _subproc_weakrefs.add(weakref.ref(self, terminate))
666
506
 
667
507
    def send(self, data):
668
508
        return os.write(self.proc.stdin.fileno(), data)
669
509
 
 
510
    def recv_ready(self):
 
511
        # TODO: jam 20051215 this function is necessary to support the
 
512
        # pipelined() function. In reality, it probably should use
 
513
        # poll() or select() to actually return if there is data
 
514
        # available, otherwise we probably don't get any benefit
 
515
        return True
 
516
 
670
517
    def recv(self, count):
671
518
        return os.read(self.proc.stdout.fileno(), count)
672
519
 
673
520
    def close(self):
674
 
        _close_ssh_proc(self.proc)
 
521
        self.proc.stdin.close()
 
522
        self.proc.stdout.close()
 
523
        self.proc.wait()
675
524
 
676
525
    def get_filelike_channels(self):
677
526
        return (self.proc.stdout, self.proc.stdin)