/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: Daniel Silverstone
  • Date: 2006-11-11 16:27:08 UTC
  • mto: This revision was merged to the branch mainline in revision 2135.
  • Revision ID: dsilvers@digital-scurf.org-20061111162708-fb545d8a5b913f04
Oops, fix the message up

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))
312
 
            add = getattr(BZR_HOSTKEYS, 'add', None)
313
 
            if add is not None: # paramiko >= 1.X.X
314
 
                BZR_HOSTKEYS.add(host, keytype, server_key)
315
 
            else:
316
 
                BZR_HOSTKEYS.setdefault(host, {})[keytype] = server_key
 
227
            warning('Adding %s host key for %s: %s' % (keytype, host, server_key_hex))
 
228
            if host not in BZR_HOSTKEYS:
 
229
                BZR_HOSTKEYS[host] = {}
 
230
            BZR_HOSTKEYS[host][keytype] = server_key
317
231
            our_server_key = server_key
318
 
            our_server_key_hex = paramiko.util.hexify(
319
 
                our_server_key.get_fingerprint())
 
232
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
320
233
            save_host_keys()
321
234
        if server_key != our_server_key:
322
235
            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' %
 
236
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
237
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
326
238
                (host, our_server_key_hex, server_key_hex),
327
239
                ['Try editing %s or %s' % (filename1, filename2)])
328
240
 
329
 
        _paramiko_auth(username, password, host, port, t)
 
241
        _paramiko_auth(username, password, host, t)
330
242
        return t
331
 
 
 
243
        
332
244
    def connect_sftp(self, username, password, host, port):
333
245
        t = self._connect(username, password, host, port)
334
246
        try:
349
261
                                         msg='Unable to invoke remote bzr')
350
262
 
351
263
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,)
 
264
    register_ssh_vendor('paramiko', ParamikoVendor())
360
265
 
361
266
 
362
267
class SubprocessVendor(SSHVendor):
363
268
    """Abstract base class for vendors that use pipes to a subprocess."""
364
 
 
 
269
    
365
270
    def _connect(self, argv):
366
271
        proc = subprocess.Popen(argv,
367
272
                                stdin=subprocess.PIPE,
374
279
            argv = self._get_vendor_specific_argv(username, host, port,
375
280
                                                  subsystem='sftp')
376
281
            sock = self._connect(argv)
377
 
            return SFTPClient(SocketAsChannelAdapter(sock))
378
 
        except _sftp_connection_errors, e:
 
282
            return SFTPClient(sock)
 
283
        except (EOFError, paramiko.SSHException), e:
379
284
            self._raise_connection_error(host, port=port, orig_error=e)
380
285
        except (OSError, IOError), e:
381
286
            # If the machine is fast enough, ssh can actually exit
403
308
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
404
309
                                  command=None):
405
310
        """Returns the argument list to run the subprocess with.
406
 
 
 
311
        
407
312
        Exactly one of 'subsystem' and 'command' must be specified.
408
313
        """
409
314
        raise NotImplementedError(self._get_vendor_specific_argv)
410
315
 
 
316
register_ssh_vendor('none', ParamikoVendor())
 
317
 
411
318
 
412
319
class OpenSSHSubprocessVendor(SubprocessVendor):
413
320
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
414
 
 
415
 
    executable_path = 'ssh'
416
 
 
 
321
    
417
322
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
418
323
                                  command=None):
419
 
        args = [self.executable_path,
 
324
        assert subsystem is not None or command is not None, (
 
325
            'Must specify a command or subsystem')
 
326
        if subsystem is not None:
 
327
            assert command is None, (
 
328
                'subsystem and command are mutually exclusive')
 
329
        args = ['ssh',
420
330
                '-oForwardX11=no', '-oForwardAgent=no',
421
331
                '-oClearAllForwardings=yes', '-oProtocol=2',
422
332
                '-oNoHostAuthenticationForLocalhost=yes']
436
346
class SSHCorpSubprocessVendor(SubprocessVendor):
437
347
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
438
348
 
439
 
    executable_path = 'ssh'
440
 
 
441
349
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
442
350
                                  command=None):
443
 
        args = [self.executable_path, '-x']
 
351
        assert subsystem is not None or command is not None, (
 
352
            'Must specify a command or subsystem')
 
353
        if subsystem is not None:
 
354
            assert command is None, (
 
355
                'subsystem and command are mutually exclusive')
 
356
        args = ['ssh', '-x']
444
357
        if port is not None:
445
358
            args.extend(['-p', str(port)])
446
359
        if username is not None:
450
363
        else:
451
364
            args.extend([host] + command)
452
365
        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())
 
366
    
 
367
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
 
368
 
 
369
 
 
370
def _paramiko_auth(username, password, host, paramiko_transport):
 
371
    # paramiko requires a username, but it might be none if nothing was supplied
 
372
    # use the local username, just in case.
 
373
    # We don't override username, because if we aren't using paramiko,
 
374
    # the username might be specified in ~/.ssh/config and we don't want to
 
375
    # force it to something else
 
376
    # Also, it would mess up the self.relpath() functionality
 
377
    username = username or getpass.getuser()
 
378
 
485
379
    if _use_ssh_agent:
486
380
        agent = paramiko.Agent()
487
381
        for key in agent.get_keys():
488
 
            trace.mutter('Trying SSH agent key %s'
489
 
                         % paramiko.util.hexify(key.get_fingerprint()))
 
382
            mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
490
383
            try:
491
384
                paramiko_transport.auth_publickey(username, key)
492
385
                return
493
386
            except paramiko.SSHException, e:
494
387
                pass
495
 
 
 
388
    
496
389
    # okay, try finding id_rsa or id_dss?  (posix only)
497
390
    if _try_pkey_auth(paramiko_transport, paramiko.RSAKey, username, 'id_rsa'):
498
391
        return
499
392
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
500
393
        return
501
394
 
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
395
    if password:
536
396
        try:
537
397
            paramiko_transport.auth_password(username, password)
540
400
            pass
541
401
 
542
402
    # 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))
 
403
    password = bzrlib.ui.ui_factory.get_password(
 
404
            prompt='SSH %(user)s@%(host)s password',
 
405
            user=username, host=host)
 
406
    try:
 
407
        paramiko_transport.auth_password(username, password)
 
408
    except paramiko.SSHException, e:
 
409
        raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
410
                              (username, host), e)
555
411
 
556
412
 
557
413
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
561
417
        paramiko_transport.auth_publickey(username, key)
562
418
        return True
563
419
    except paramiko.PasswordRequiredException:
564
 
        password = ui.ui_factory.get_password(
565
 
            prompt='SSH %(filename)s password', filename=filename)
 
420
        password = bzrlib.ui.ui_factory.get_password(
 
421
                prompt='SSH %(filename)s password',
 
422
                filename=filename)
566
423
        try:
567
424
            key = pkey_class.from_private_key_file(filename, password)
568
425
            paramiko_transport.auth_publickey(username, key)
569
426
            return True
570
427
        except paramiko.SSHException:
571
 
            trace.mutter('SSH authentication via %s key failed.'
572
 
                         % (os.path.basename(filename),))
 
428
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
573
429
    except paramiko.SSHException:
574
 
        trace.mutter('SSH authentication via %s key failed.'
575
 
                     % (os.path.basename(filename),))
 
430
        mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
576
431
    except IOError:
577
432
        pass
578
433
    return False
585
440
    """
586
441
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
587
442
    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')
 
443
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
444
    except Exception, e:
 
445
        mutter('failed to load system host keys: ' + str(e))
 
446
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
593
447
    try:
594
448
        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))
 
449
    except Exception, e:
 
450
        mutter('failed to load bzr host keys: ' + str(e))
597
451
        save_host_keys()
598
452
 
599
453
 
602
456
    Save "discovered" host keys in $(config)/ssh_host_keys/.
603
457
    """
604
458
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
605
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
606
 
    config.ensure_config_dir_exists()
 
459
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
460
    ensure_config_dir_exists()
607
461
 
608
462
    try:
609
463
        f = open(bzr_hostkey_path, 'w')
613
467
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
614
468
        f.close()
615
469
    except IOError, e:
616
 
        trace.mutter('failed to save bzr host keys: ' + str(e))
 
470
        mutter('failed to save bzr host keys: ' + str(e))
617
471
 
618
472
 
619
473
def os_specific_subprocess_params():
620
474
    """Get O/S specific subprocess parameters."""
621
475
    if sys.platform == 'win32':
622
 
        # setting the process group and closing fds is not supported on
 
476
        # setting the process group and closing fds is not supported on 
623
477
        # win32
624
478
        return {}
625
479
    else:
626
 
        # We close fds other than the pipes as the child process does not need
 
480
        # We close fds other than the pipes as the child process does not need 
627
481
        # them to be open.
628
482
        #
629
483
        # We also set the child process to ignore SIGINT.  Normally the signal
631
485
        # this causes it to be seen only by bzr and not by ssh.  Python will
632
486
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
633
487
        # to release locks or do other cleanup over ssh before the connection
634
 
        # goes away.
 
488
        # goes away.  
635
489
        # <https://launchpad.net/products/bzr/+bug/5987>
636
490
        #
637
491
        # Running it in a separate process group is not good because then it
638
492
        # can't get non-echoed input of a password or passphrase.
639
493
        # <https://launchpad.net/products/bzr/+bug/40508>
640
 
        return {'preexec_fn': _ignore_signals,
 
494
        return {'preexec_fn': _ignore_sigint,
641
495
                'close_fds': True,
642
496
                }
643
497
 
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
498
 
655
499
class SSHSubprocess(object):
656
500
    """A socket-like object that talks to an ssh subprocess via pipes."""
657
501
 
658
502
    def __init__(self, proc):
659
503
        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
504
 
667
505
    def send(self, data):
668
506
        return os.write(self.proc.stdin.fileno(), data)
669
507
 
 
508
    def recv_ready(self):
 
509
        # TODO: jam 20051215 this function is necessary to support the
 
510
        # pipelined() function. In reality, it probably should use
 
511
        # poll() or select() to actually return if there is data
 
512
        # available, otherwise we probably don't get any benefit
 
513
        return True
 
514
 
670
515
    def recv(self, count):
671
516
        return os.read(self.proc.stdout.fileno(), count)
672
517
 
673
518
    def close(self):
674
 
        _close_ssh_proc(self.proc)
 
519
        self.proc.stdin.close()
 
520
        self.proc.stdout.close()
 
521
        self.proc.wait()
675
522
 
676
523
    def get_filelike_channels(self):
677
524
        return (self.proc.stdout, self.proc.stdin)