~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-13 10:43:21 UTC
  • mfrom: (5856.1.4 no-inventory)
  • Revision ID: pqm@pqm.ubuntu.com-20110513104321-8j4cwyl49p3f2bwc
(jelmer) Remove use of inventory in a commit builder tests,
 remove broken and duplicate test_break_lock in per_foreign_vcs. (Jelmer
 Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006-2011 Robey Pointer <robey@lag.net>
 
2
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
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
 
17
 
 
18
"""Foundation SSH support for SFTP and smart server."""
 
19
 
 
20
import errno
 
21
import getpass
 
22
import logging
 
23
import os
 
24
import socket
 
25
import subprocess
 
26
import sys
 
27
 
 
28
from bzrlib import (
 
29
    config,
 
30
    errors,
 
31
    osutils,
 
32
    trace,
 
33
    ui,
 
34
    )
 
35
 
 
36
try:
 
37
    import paramiko
 
38
except ImportError, e:
 
39
    # If we have an ssh subprocess, we don't strictly need paramiko for all ssh
 
40
    # access
 
41
    paramiko = None
 
42
else:
 
43
    from paramiko.sftp_client import SFTPClient
 
44
 
 
45
 
 
46
SYSTEM_HOSTKEYS = {}
 
47
BZR_HOSTKEYS = {}
 
48
 
 
49
 
 
50
_paramiko_version = getattr(paramiko, '__version_info__', (0, 0, 0))
 
51
 
 
52
# Paramiko 1.5 tries to open a socket.AF_UNIX in order to connect
 
53
# to ssh-agent. That attribute doesn't exist on win32 (it does in cygwin)
 
54
# so we get an AttributeError exception. So we will not try to
 
55
# connect to an agent if we are on win32 and using Paramiko older than 1.6
 
56
_use_ssh_agent = (sys.platform != 'win32' or _paramiko_version >= (1, 6, 0))
 
57
 
 
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."""
 
106
        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
        elif 'lsh' in version:
 
130
            trace.mutter('ssh implementation is GNU lsh.')
 
131
            vendor = LSHSubprocessVendor()
 
132
        # As plink user prompts are not handled currently, don't auto-detect
 
133
        # it by inspection below, but keep this vendor detection for if a path
 
134
        # is given in BZR_SSH. See https://bugs.launchpad.net/bugs/414743
 
135
        elif 'plink' in version and progname == 'plink':
 
136
            # Checking if "plink" was the executed argument as Windows
 
137
            # sometimes reports 'ssh -V' incorrectly with 'plink' in its
 
138
            # version.  See https://bugs.launchpad.net/bzr/+bug/107155
 
139
            trace.mutter("ssh implementation is Putty's plink.")
 
140
            vendor = PLinkSubprocessVendor()
 
141
        return vendor
 
142
 
 
143
    def _get_vendor_by_inspection(self):
 
144
        """Return the vendor or None by checking for known SSH implementations."""
 
145
        version = self._get_ssh_version_string(['ssh', '-V'])
 
146
        return self._get_vendor_by_version_string(version, "ssh")
 
147
 
 
148
    def _get_vendor_from_path(self, path):
 
149
        """Return the vendor or None using the program at the given path"""
 
150
        version = self._get_ssh_version_string([path, '-V'])
 
151
        return self._get_vendor_by_version_string(version, 
 
152
            os.path.splitext(os.path.basename(path))[0])
 
153
 
 
154
    def get_vendor(self, environment=None):
 
155
        """Find out what version of SSH is on the system.
 
156
 
 
157
        :raises SSHVendorNotFound: if no any SSH vendor is found
 
158
        :raises UnknownSSH: if the BZR_SSH environment variable contains
 
159
                            unknown vendor name
 
160
        """
 
161
        if self._cached_ssh_vendor is None:
 
162
            vendor = self._get_vendor_by_environment(environment)
 
163
            if vendor is None:
 
164
                vendor = self._get_vendor_by_inspection()
 
165
                if vendor is None:
 
166
                    trace.mutter('falling back to default implementation')
 
167
                    vendor = self._default_ssh_vendor
 
168
                    if vendor is None:
 
169
                        raise errors.SSHVendorNotFound()
 
170
            self._cached_ssh_vendor = vendor
 
171
        return self._cached_ssh_vendor
 
172
 
 
173
_ssh_vendor_manager = SSHVendorManager()
 
174
_get_ssh_vendor = _ssh_vendor_manager.get_vendor
 
175
register_default_ssh_vendor = _ssh_vendor_manager.register_default_vendor
 
176
register_ssh_vendor = _ssh_vendor_manager.register_vendor
 
177
 
 
178
 
 
179
def _ignore_signals():
 
180
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
 
181
    # doesn't handle it itself.
 
182
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
 
183
    import signal
 
184
    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
185
    # GZ 2010-02-19: Perhaps make this check if breakin is installed instead
 
186
    if signal.getsignal(signal.SIGQUIT) != signal.SIG_DFL:
 
187
        signal.signal(signal.SIGQUIT, signal.SIG_IGN)
 
188
 
 
189
 
 
190
class SocketAsChannelAdapter(object):
 
191
    """Simple wrapper for a socket that pretends to be a paramiko Channel."""
 
192
 
 
193
    def __init__(self, sock):
 
194
        self.__socket = sock
 
195
 
 
196
    def get_name(self):
 
197
        return "bzr SocketAsChannelAdapter"
 
198
 
 
199
    def send(self, data):
 
200
        return self.__socket.send(data)
 
201
 
 
202
    def recv(self, n):
 
203
        try:
 
204
            return self.__socket.recv(n)
 
205
        except socket.error, e:
 
206
            if e.args[0] in (errno.EPIPE, errno.ECONNRESET, errno.ECONNABORTED,
 
207
                             errno.EBADF):
 
208
                # Connection has closed.  Paramiko expects an empty string in
 
209
                # this case, not an exception.
 
210
                return ''
 
211
            raise
 
212
 
 
213
    def recv_ready(self):
 
214
        # TODO: jam 20051215 this function is necessary to support the
 
215
        # pipelined() function. In reality, it probably should use
 
216
        # poll() or select() to actually return if there is data
 
217
        # available, otherwise we probably don't get any benefit
 
218
        return True
 
219
 
 
220
    def close(self):
 
221
        self.__socket.close()
 
222
 
 
223
 
 
224
class SSHVendor(object):
 
225
    """Abstract base class for SSH vendor implementations."""
 
226
 
 
227
    def connect_sftp(self, username, password, host, port):
 
228
        """Make an SSH connection, and return an SFTPClient.
 
229
 
 
230
        :param username: an ascii string
 
231
        :param password: an ascii string
 
232
        :param host: a host name as an ascii string
 
233
        :param port: a port number
 
234
        :type port: int
 
235
 
 
236
        :raises: ConnectionError if it cannot connect.
 
237
 
 
238
        :rtype: paramiko.sftp_client.SFTPClient
 
239
        """
 
240
        raise NotImplementedError(self.connect_sftp)
 
241
 
 
242
    def connect_ssh(self, username, password, host, port, command):
 
243
        """Make an SSH connection.
 
244
 
 
245
        :returns: an SSHConnection.
 
246
        """
 
247
        raise NotImplementedError(self.connect_ssh)
 
248
 
 
249
    def _raise_connection_error(self, host, port=None, orig_error=None,
 
250
                                msg='Unable to connect to SSH host'):
 
251
        """Raise a SocketConnectionError with properly formatted host.
 
252
 
 
253
        This just unifies all the locations that try to raise ConnectionError,
 
254
        so that they format things properly.
 
255
        """
 
256
        raise errors.SocketConnectionError(host=host, port=port, msg=msg,
 
257
                                           orig_error=orig_error)
 
258
 
 
259
 
 
260
class LoopbackVendor(SSHVendor):
 
261
    """SSH "vendor" that connects over a plain TCP socket, not SSH."""
 
262
 
 
263
    def connect_sftp(self, username, password, host, port):
 
264
        sock = socket.socket()
 
265
        try:
 
266
            sock.connect((host, port))
 
267
        except socket.error, e:
 
268
            self._raise_connection_error(host, port=port, orig_error=e)
 
269
        return SFTPClient(SocketAsChannelAdapter(sock))
 
270
 
 
271
register_ssh_vendor('loopback', LoopbackVendor())
 
272
 
 
273
 
 
274
class ParamikoVendor(SSHVendor):
 
275
    """Vendor that uses paramiko."""
 
276
 
 
277
    def _connect(self, username, password, host, port):
 
278
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
279
 
 
280
        load_host_keys()
 
281
 
 
282
        try:
 
283
            t = paramiko.Transport((host, port or 22))
 
284
            t.set_log_channel('bzr.paramiko')
 
285
            t.start_client()
 
286
        except (paramiko.SSHException, socket.error), e:
 
287
            self._raise_connection_error(host, port=port, orig_error=e)
 
288
 
 
289
        server_key = t.get_remote_server_key()
 
290
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
 
291
        keytype = server_key.get_name()
 
292
        if host in SYSTEM_HOSTKEYS and keytype in SYSTEM_HOSTKEYS[host]:
 
293
            our_server_key = SYSTEM_HOSTKEYS[host][keytype]
 
294
            our_server_key_hex = paramiko.util.hexify(
 
295
                our_server_key.get_fingerprint())
 
296
        elif host in BZR_HOSTKEYS and keytype in BZR_HOSTKEYS[host]:
 
297
            our_server_key = BZR_HOSTKEYS[host][keytype]
 
298
            our_server_key_hex = paramiko.util.hexify(
 
299
                our_server_key.get_fingerprint())
 
300
        else:
 
301
            trace.warning('Adding %s host key for %s: %s'
 
302
                          % (keytype, host, server_key_hex))
 
303
            add = getattr(BZR_HOSTKEYS, 'add', None)
 
304
            if add is not None: # paramiko >= 1.X.X
 
305
                BZR_HOSTKEYS.add(host, keytype, server_key)
 
306
            else:
 
307
                BZR_HOSTKEYS.setdefault(host, {})[keytype] = server_key
 
308
            our_server_key = server_key
 
309
            our_server_key_hex = paramiko.util.hexify(
 
310
                our_server_key.get_fingerprint())
 
311
            save_host_keys()
 
312
        if server_key != our_server_key:
 
313
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
 
314
            filename2 = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
 
315
            raise errors.TransportError(
 
316
                'Host keys for %s do not match!  %s != %s' %
 
317
                (host, our_server_key_hex, server_key_hex),
 
318
                ['Try editing %s or %s' % (filename1, filename2)])
 
319
 
 
320
        _paramiko_auth(username, password, host, port, t)
 
321
        return t
 
322
 
 
323
    def connect_sftp(self, username, password, host, port):
 
324
        t = self._connect(username, password, host, port)
 
325
        try:
 
326
            return t.open_sftp_client()
 
327
        except paramiko.SSHException, e:
 
328
            self._raise_connection_error(host, port=port, orig_error=e,
 
329
                                         msg='Unable to start sftp client')
 
330
 
 
331
    def connect_ssh(self, username, password, host, port, command):
 
332
        t = self._connect(username, password, host, port)
 
333
        try:
 
334
            channel = t.open_session()
 
335
            cmdline = ' '.join(command)
 
336
            channel.exec_command(cmdline)
 
337
            return _ParamikoSSHConnection(channel)
 
338
        except paramiko.SSHException, e:
 
339
            self._raise_connection_error(host, port=port, orig_error=e,
 
340
                                         msg='Unable to invoke remote bzr')
 
341
 
 
342
_ssh_connection_errors = (EOFError, OSError, IOError, socket.error)
 
343
if paramiko is not None:
 
344
    vendor = ParamikoVendor()
 
345
    register_ssh_vendor('paramiko', vendor)
 
346
    register_ssh_vendor('none', vendor)
 
347
    register_default_ssh_vendor(vendor)
 
348
    _ssh_connection_errors += (paramiko.SSHException,)
 
349
    del vendor
 
350
 
 
351
 
 
352
class SubprocessVendor(SSHVendor):
 
353
    """Abstract base class for vendors that use pipes to a subprocess."""
 
354
 
 
355
    def _connect(self, argv):
 
356
        # Attempt to make a socketpair to use as stdin/stdout for the SSH
 
357
        # subprocess.  We prefer sockets to pipes because they support
 
358
        # non-blocking short reads, allowing us to optimistically read 64k (or
 
359
        # whatever) chunks.
 
360
        try:
 
361
            my_sock, subproc_sock = socket.socketpair()
 
362
            osutils.set_fd_cloexec(my_sock)
 
363
        except (AttributeError, socket.error):
 
364
            # This platform doesn't support socketpair(), so just use ordinary
 
365
            # pipes instead.
 
366
            stdin = stdout = subprocess.PIPE
 
367
            my_sock, subproc_sock = None, None
 
368
        else:
 
369
            stdin = stdout = subproc_sock
 
370
        proc = subprocess.Popen(argv, stdin=stdin, stdout=stdout,
 
371
                                **os_specific_subprocess_params())
 
372
        if subproc_sock is not None:
 
373
            subproc_sock.close()
 
374
        return SSHSubprocessConnection(proc, sock=my_sock)
 
375
 
 
376
    def connect_sftp(self, username, password, host, port):
 
377
        try:
 
378
            argv = self._get_vendor_specific_argv(username, host, port,
 
379
                                                  subsystem='sftp')
 
380
            sock = self._connect(argv)
 
381
            return SFTPClient(SocketAsChannelAdapter(sock))
 
382
        except _ssh_connection_errors, e:
 
383
            self._raise_connection_error(host, port=port, orig_error=e)
 
384
 
 
385
    def connect_ssh(self, username, password, host, port, command):
 
386
        try:
 
387
            argv = self._get_vendor_specific_argv(username, host, port,
 
388
                                                  command=command)
 
389
            return self._connect(argv)
 
390
        except _ssh_connection_errors, e:
 
391
            self._raise_connection_error(host, port=port, orig_error=e)
 
392
 
 
393
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
 
394
                                  command=None):
 
395
        """Returns the argument list to run the subprocess with.
 
396
 
 
397
        Exactly one of 'subsystem' and 'command' must be specified.
 
398
        """
 
399
        raise NotImplementedError(self._get_vendor_specific_argv)
 
400
 
 
401
 
 
402
class OpenSSHSubprocessVendor(SubprocessVendor):
 
403
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
 
404
 
 
405
    executable_path = 'ssh'
 
406
 
 
407
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
 
408
                                  command=None):
 
409
        args = [self.executable_path,
 
410
                '-oForwardX11=no', '-oForwardAgent=no',
 
411
                '-oClearAllForwardings=yes',
 
412
                '-oNoHostAuthenticationForLocalhost=yes']
 
413
        if port is not None:
 
414
            args.extend(['-p', str(port)])
 
415
        if username is not None:
 
416
            args.extend(['-l', username])
 
417
        if subsystem is not None:
 
418
            args.extend(['-s', host, subsystem])
 
419
        else:
 
420
            args.extend([host] + command)
 
421
        return args
 
422
 
 
423
register_ssh_vendor('openssh', OpenSSHSubprocessVendor())
 
424
 
 
425
 
 
426
class SSHCorpSubprocessVendor(SubprocessVendor):
 
427
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
 
428
 
 
429
    executable_path = 'ssh'
 
430
 
 
431
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
 
432
                                  command=None):
 
433
        args = [self.executable_path, '-x']
 
434
        if port is not None:
 
435
            args.extend(['-p', str(port)])
 
436
        if username is not None:
 
437
            args.extend(['-l', username])
 
438
        if subsystem is not None:
 
439
            args.extend(['-s', subsystem, host])
 
440
        else:
 
441
            args.extend([host] + command)
 
442
        return args
 
443
 
 
444
register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())
 
445
 
 
446
 
 
447
class LSHSubprocessVendor(SubprocessVendor):
 
448
    """SSH vendor that uses the 'lsh' executable from GNU"""
 
449
 
 
450
    executable_path = 'lsh'
 
451
 
 
452
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
 
453
                                  command=None):
 
454
        args = [self.executable_path]
 
455
        if port is not None:
 
456
            args.extend(['-p', str(port)])
 
457
        if username is not None:
 
458
            args.extend(['-l', username])
 
459
        if subsystem is not None:
 
460
            args.extend(['--subsystem', subsystem, host])
 
461
        else:
 
462
            args.extend([host] + command)
 
463
        return args
 
464
 
 
465
register_ssh_vendor('lsh', LSHSubprocessVendor())
 
466
 
 
467
 
 
468
class PLinkSubprocessVendor(SubprocessVendor):
 
469
    """SSH vendor that uses the 'plink' executable from Putty."""
 
470
 
 
471
    executable_path = 'plink'
 
472
 
 
473
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
 
474
                                  command=None):
 
475
        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']
 
476
        if port is not None:
 
477
            args.extend(['-P', str(port)])
 
478
        if username is not None:
 
479
            args.extend(['-l', username])
 
480
        if subsystem is not None:
 
481
            args.extend(['-s', host, subsystem])
 
482
        else:
 
483
            args.extend([host] + command)
 
484
        return args
 
485
 
 
486
register_ssh_vendor('plink', PLinkSubprocessVendor())
 
487
 
 
488
 
 
489
def _paramiko_auth(username, password, host, port, paramiko_transport):
 
490
    auth = config.AuthenticationConfig()
 
491
    # paramiko requires a username, but it might be none if nothing was
 
492
    # supplied.  If so, use the local username.
 
493
    if username is None:
 
494
        username = auth.get_user('ssh', host, port=port,
 
495
                                 default=getpass.getuser())
 
496
    if _use_ssh_agent:
 
497
        agent = paramiko.Agent()
 
498
        for key in agent.get_keys():
 
499
            trace.mutter('Trying SSH agent key %s'
 
500
                         % paramiko.util.hexify(key.get_fingerprint()))
 
501
            try:
 
502
                paramiko_transport.auth_publickey(username, key)
 
503
                return
 
504
            except paramiko.SSHException, e:
 
505
                pass
 
506
 
 
507
    # okay, try finding id_rsa or id_dss?  (posix only)
 
508
    if _try_pkey_auth(paramiko_transport, paramiko.RSAKey, username, 'id_rsa'):
 
509
        return
 
510
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
 
511
        return
 
512
 
 
513
    # If we have gotten this far, we are about to try for passwords, do an
 
514
    # auth_none check to see if it is even supported.
 
515
    supported_auth_types = []
 
516
    try:
 
517
        # Note that with paramiko <1.7.5 this logs an INFO message:
 
518
        #    Authentication type (none) not permitted.
 
519
        # So we explicitly disable the logging level for this action
 
520
        old_level = paramiko_transport.logger.level
 
521
        paramiko_transport.logger.setLevel(logging.WARNING)
 
522
        try:
 
523
            paramiko_transport.auth_none(username)
 
524
        finally:
 
525
            paramiko_transport.logger.setLevel(old_level)
 
526
    except paramiko.BadAuthenticationType, e:
 
527
        # Supported methods are in the exception
 
528
        supported_auth_types = e.allowed_types
 
529
    except paramiko.SSHException, e:
 
530
        # Don't know what happened, but just ignore it
 
531
        pass
 
532
    # We treat 'keyboard-interactive' and 'password' auth methods identically,
 
533
    # because Paramiko's auth_password method will automatically try
 
534
    # 'keyboard-interactive' auth (using the password as the response) if
 
535
    # 'password' auth is not available.  Apparently some Debian and Gentoo
 
536
    # OpenSSH servers require this.
 
537
    # XXX: It's possible for a server to require keyboard-interactive auth that
 
538
    # requires something other than a single password, but we currently don't
 
539
    # support that.
 
540
    if ('password' not in supported_auth_types and
 
541
        'keyboard-interactive' not in supported_auth_types):
 
542
        raise errors.ConnectionError('Unable to authenticate to SSH host as'
 
543
            '\n  %s@%s\nsupported auth types: %s'
 
544
            % (username, host, supported_auth_types))
 
545
 
 
546
    if password:
 
547
        try:
 
548
            paramiko_transport.auth_password(username, password)
 
549
            return
 
550
        except paramiko.SSHException, e:
 
551
            pass
 
552
 
 
553
    # give up and ask for a password
 
554
    password = auth.get_password('ssh', host, username, port=port)
 
555
    # get_password can still return None, which means we should not prompt
 
556
    if password is not None:
 
557
        try:
 
558
            paramiko_transport.auth_password(username, password)
 
559
        except paramiko.SSHException, e:
 
560
            raise errors.ConnectionError(
 
561
                'Unable to authenticate to SSH host as'
 
562
                '\n  %s@%s\n' % (username, host), e)
 
563
    else:
 
564
        raise errors.ConnectionError('Unable to authenticate to SSH host as'
 
565
                                     '  %s@%s' % (username, host))
 
566
 
 
567
 
 
568
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
 
569
    filename = os.path.expanduser('~/.ssh/' + filename)
 
570
    try:
 
571
        key = pkey_class.from_private_key_file(filename)
 
572
        paramiko_transport.auth_publickey(username, key)
 
573
        return True
 
574
    except paramiko.PasswordRequiredException:
 
575
        password = ui.ui_factory.get_password(
 
576
            prompt='SSH %(filename)s password', filename=filename)
 
577
        try:
 
578
            key = pkey_class.from_private_key_file(filename, password)
 
579
            paramiko_transport.auth_publickey(username, key)
 
580
            return True
 
581
        except paramiko.SSHException:
 
582
            trace.mutter('SSH authentication via %s key failed.'
 
583
                         % (os.path.basename(filename),))
 
584
    except paramiko.SSHException:
 
585
        trace.mutter('SSH authentication via %s key failed.'
 
586
                     % (os.path.basename(filename),))
 
587
    except IOError:
 
588
        pass
 
589
    return False
 
590
 
 
591
 
 
592
def load_host_keys():
 
593
    """
 
594
    Load system host keys (probably doesn't work on windows) and any
 
595
    "discovered" keys from previous sessions.
 
596
    """
 
597
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
598
    try:
 
599
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(
 
600
            os.path.expanduser('~/.ssh/known_hosts'))
 
601
    except IOError, e:
 
602
        trace.mutter('failed to load system host keys: ' + str(e))
 
603
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
 
604
    try:
 
605
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
 
606
    except IOError, e:
 
607
        trace.mutter('failed to load bzr host keys: ' + str(e))
 
608
        save_host_keys()
 
609
 
 
610
 
 
611
def save_host_keys():
 
612
    """
 
613
    Save "discovered" host keys in $(config)/ssh_host_keys/.
 
614
    """
 
615
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
 
616
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
 
617
    config.ensure_config_dir_exists()
 
618
 
 
619
    try:
 
620
        f = open(bzr_hostkey_path, 'w')
 
621
        f.write('# SSH host keys collected by bzr\n')
 
622
        for hostname, keys in BZR_HOSTKEYS.iteritems():
 
623
            for keytype, key in keys.iteritems():
 
624
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
 
625
        f.close()
 
626
    except IOError, e:
 
627
        trace.mutter('failed to save bzr host keys: ' + str(e))
 
628
 
 
629
 
 
630
def os_specific_subprocess_params():
 
631
    """Get O/S specific subprocess parameters."""
 
632
    if sys.platform == 'win32':
 
633
        # setting the process group and closing fds is not supported on
 
634
        # win32
 
635
        return {}
 
636
    else:
 
637
        # We close fds other than the pipes as the child process does not need
 
638
        # them to be open.
 
639
        #
 
640
        # We also set the child process to ignore SIGINT.  Normally the signal
 
641
        # would be sent to every process in the foreground process group, but
 
642
        # this causes it to be seen only by bzr and not by ssh.  Python will
 
643
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
 
644
        # to release locks or do other cleanup over ssh before the connection
 
645
        # goes away.
 
646
        # <https://launchpad.net/products/bzr/+bug/5987>
 
647
        #
 
648
        # Running it in a separate process group is not good because then it
 
649
        # can't get non-echoed input of a password or passphrase.
 
650
        # <https://launchpad.net/products/bzr/+bug/40508>
 
651
        return {'preexec_fn': _ignore_signals,
 
652
                'close_fds': True,
 
653
                }
 
654
 
 
655
import weakref
 
656
_subproc_weakrefs = set()
 
657
 
 
658
def _close_ssh_proc(proc, sock):
 
659
    """Carefully close stdin/stdout and reap the SSH process.
 
660
 
 
661
    If the pipes are already closed and/or the process has already been
 
662
    wait()ed on, that's ok, and no error is raised.  The goal is to do our best
 
663
    to clean up (whether or not a clean up was already tried).
 
664
    """
 
665
    funcs = []
 
666
    for closeable in (proc.stdin, proc.stdout, sock):
 
667
        # We expect that either proc (a subprocess.Popen) will have stdin and
 
668
        # stdout streams to close, or that we will have been passed a socket to
 
669
        # close, with the option not in use being None.
 
670
        if closeable is not None:
 
671
            funcs.append(closeable.close)
 
672
    funcs.append(proc.wait)
 
673
    for func in funcs:
 
674
        try:
 
675
            func()
 
676
        except OSError:
 
677
            # It's ok for the pipe to already be closed, or the process to
 
678
            # already be finished.
 
679
            continue
 
680
 
 
681
 
 
682
class SSHConnection(object):
 
683
    """Abstract base class for SSH connections."""
 
684
 
 
685
    def get_sock_or_pipes(self):
 
686
        """Returns a (kind, io_object) pair.
 
687
 
 
688
        If kind == 'socket', then io_object is a socket.
 
689
 
 
690
        If kind == 'pipes', then io_object is a pair of file-like objects
 
691
        (read_from, write_to).
 
692
        """
 
693
        raise NotImplementedError(self.get_sock_or_pipes)
 
694
 
 
695
    def close(self):
 
696
        raise NotImplementedError(self.close)
 
697
 
 
698
 
 
699
class SSHSubprocessConnection(SSHConnection):
 
700
    """A connection to an ssh subprocess via pipes or a socket.
 
701
 
 
702
    This class is also socket-like enough to be used with
 
703
    SocketAsChannelAdapter (it has 'send' and 'recv' methods).
 
704
    """
 
705
 
 
706
    def __init__(self, proc, sock=None):
 
707
        """Constructor.
 
708
 
 
709
        :param proc: a subprocess.Popen
 
710
        :param sock: if proc.stdin/out is a socket from a socketpair, then sock
 
711
            should bzrlib's half of that socketpair.  If not passed, proc's
 
712
            stdin/out is assumed to be ordinary pipes.
 
713
        """
 
714
        self.proc = proc
 
715
        self._sock = sock
 
716
        # Add a weakref to proc that will attempt to do the same as self.close
 
717
        # to avoid leaving processes lingering indefinitely.
 
718
        def terminate(ref):
 
719
            _subproc_weakrefs.remove(ref)
 
720
            _close_ssh_proc(proc, sock)
 
721
        _subproc_weakrefs.add(weakref.ref(self, terminate))
 
722
 
 
723
    def send(self, data):
 
724
        if self._sock is not None:
 
725
            return self._sock.send(data)
 
726
        else:
 
727
            return os.write(self.proc.stdin.fileno(), data)
 
728
 
 
729
    def recv(self, count):
 
730
        if self._sock is not None:
 
731
            return self._sock.recv(count)
 
732
        else:
 
733
            return os.read(self.proc.stdout.fileno(), count)
 
734
 
 
735
    def close(self):
 
736
        _close_ssh_proc(self.proc, self._sock)
 
737
 
 
738
    def get_sock_or_pipes(self):
 
739
        if self._sock is not None:
 
740
            return 'socket', self._sock
 
741
        else:
 
742
            return 'pipes', (self.proc.stdout, self.proc.stdin)
 
743
 
 
744
 
 
745
class _ParamikoSSHConnection(SSHConnection):
 
746
    """An SSH connection via paramiko."""
 
747
 
 
748
    def __init__(self, channel):
 
749
        self.channel = channel
 
750
 
 
751
    def get_sock_or_pipes(self):
 
752
        return ('socket', self.channel)
 
753
 
 
754
    def close(self):
 
755
        return self.channel.close()
 
756
 
 
757