← Back to branch summary

~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: 2007-04-13 05:06:23 UTC
  • mfrom: (2279.7.13 bzr.dev.hpss.api.changes)
  • Revision ID: pqm@pqm.ubuntu.com-20070413050623-10v4wozs1tu04kcu
(Andrew Bennetts, Robert Collins) Add a 'token' argument to lock_write.

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>
 
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
2
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
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
                           SSHVendorNotFound,
 
32
                           TransportError,
 
33
                           UnknownSSH,
 
34
                           )
 
35
 
 
36
from bzrlib.osutils import pathjoin
 
37
from bzrlib.trace import mutter, warning
 
38
import bzrlib.ui
35
39
 
36
40
try:
37
41
    import paramiko
94
98
            try:
95
99
                vendor = self._ssh_vendors[vendor_name]
96
100
            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
                raise UnknownSSH(vendor_name)
101
102
            return vendor
102
103
        return None
103
104
 
113
114
            stdout = stderr = ''
114
115
        return stdout + stderr
115
116
 
116
 
    def _get_vendor_by_version_string(self, version, progname):
 
117
    def _get_vendor_by_version_string(self, version):
117
118
        """Return the vendor or None based on output from the subprocess.
118
119
 
119
120
        :param version: The output of 'ssh -V' like command.
120
 
        :param args: Command line that was run.
121
121
        """
122
122
        vendor = None
123
123
        if 'OpenSSH' in version:
124
 
            trace.mutter('ssh implementation is OpenSSH')
 
124
            mutter('ssh implementation is OpenSSH')
125
125
            vendor = OpenSSHSubprocessVendor()
126
126
        elif 'SSH Secure Shell' in version:
127
 
            trace.mutter('ssh implementation is SSH Corp.')
 
127
            mutter('ssh implementation is SSH Corp.')
128
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.")
 
129
        elif 'plink' in version:
 
130
            mutter("ssh implementation is Putty's plink.")
137
131
            vendor = PLinkSubprocessVendor()
138
132
        return vendor
139
133
 
140
134
    def _get_vendor_by_inspection(self):
141
135
        """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])
 
136
        for args in [['ssh', '-V'], ['plink', '-V']]:
 
137
            version = self._get_ssh_version_string(args)
 
138
            vendor = self._get_vendor_by_version_string(version)
 
139
            if vendor is not None:
 
140
                return vendor
 
141
        return None
150
142
 
151
143
    def get_vendor(self, environment=None):
152
144
        """Find out what version of SSH is on the system.
160
152
            if vendor is None:
161
153
                vendor = self._get_vendor_by_inspection()
162
154
                if vendor is None:
163
 
                    trace.mutter('falling back to default implementation')
 
155
                    mutter('falling back to default implementation')
164
156
                    vendor = self._default_ssh_vendor
165
157
                    if vendor is None:
166
 
                        raise errors.SSHVendorNotFound()
 
158
                        raise SSHVendorNotFound()
167
159
            self._cached_ssh_vendor = vendor
168
160
        return self._cached_ssh_vendor
169
161
 
173
165
register_ssh_vendor = _ssh_vendor_manager.register_vendor
174
166
 
175
167
 
176
 
def _ignore_signals():
 
168
def _ignore_sigint():
177
169
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
178
170
    # doesn't handle it itself.
179
171
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
180
172
    import signal
181
173
    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):
 
174
 
 
175
 
 
176
class LoopbackSFTP(object):
188
177
    """Simple wrapper for a socket that pretends to be a paramiko Channel."""
189
178
 
190
179
    def __init__(self, sock):
191
180
        self.__socket = sock
192
 
 
193
 
    def get_name(self):
194
 
        return "bzr SocketAsChannelAdapter"
195
 
 
 
181
 
196
182
    def send(self, data):
197
183
        return self.__socket.send(data)
198
184
 
199
185
    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
 
186
        return self.__socket.recv(n)
209
187
 
210
188
    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
189
        return True
216
190
 
217
191
    def close(self):
220
194
 
221
195
class SSHVendor(object):
222
196
    """Abstract base class for SSH vendor implementations."""
223
 
 
 
197
    
224
198
    def connect_sftp(self, username, password, host, port):
225
199
        """Make an SSH connection, and return an SFTPClient.
226
 
 
 
200
        
227
201
        :param username: an ascii string
228
202
        :param password: an ascii string
229
203
        :param host: a host name as an ascii string
238
212
 
239
213
    def connect_ssh(self, username, password, host, port, command):
240
214
        """Make an SSH connection.
241
 
 
 
215
        
242
216
        :returns: something with a `close` method, and a `get_filelike_channels`
243
217
            method that returns a pair of (read, write) filelike objects.
244
218
        """
245
219
        raise NotImplementedError(self.connect_ssh)
246
 
 
 
220
        
247
221
    def _raise_connection_error(self, host, port=None, orig_error=None,
248
222
                                msg='Unable to connect to SSH host'):
249
223
        """Raise a SocketConnectionError with properly formatted host.
251
225
        This just unifies all the locations that try to raise ConnectionError,
252
226
        so that they format things properly.
253
227
        """
254
 
        raise errors.SocketConnectionError(host=host, port=port, msg=msg,
255
 
                                           orig_error=orig_error)
 
228
        raise SocketConnectionError(host=host, port=port, msg=msg,
 
229
                                    orig_error=orig_error)
256
230
 
257
231
 
258
232
class LoopbackVendor(SSHVendor):
259
233
    """SSH "vendor" that connects over a plain TCP socket, not SSH."""
260
 
 
 
234
    
261
235
    def connect_sftp(self, username, password, host, port):
262
236
        sock = socket.socket()
263
237
        try:
264
238
            sock.connect((host, port))
265
239
        except socket.error, e:
266
240
            self._raise_connection_error(host, port=port, orig_error=e)
267
 
        return SFTPClient(SocketAsChannelAdapter(sock))
 
241
        return SFTPClient(LoopbackSFTP(sock))
268
242
 
269
243
register_ssh_vendor('loopback', LoopbackVendor())
270
244
 
285
259
 
286
260
    def _connect(self, username, password, host, port):
287
261
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
288
 
 
 
262
        
289
263
        load_host_keys()
290
264
 
291
265
        try:
294
268
            t.start_client()
295
269
        except (paramiko.SSHException, socket.error), e:
296
270
            self._raise_connection_error(host, port=port, orig_error=e)
297
 
 
 
271
            
298
272
        server_key = t.get_remote_server_key()
299
273
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
300
274
        keytype = server_key.get_name()
301
275
        if host in SYSTEM_HOSTKEYS and keytype in SYSTEM_HOSTKEYS[host]:
302
276
            our_server_key = SYSTEM_HOSTKEYS[host][keytype]
303
 
            our_server_key_hex = paramiko.util.hexify(
304
 
                our_server_key.get_fingerprint())
 
277
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
305
278
        elif host in BZR_HOSTKEYS and keytype in BZR_HOSTKEYS[host]:
306
279
            our_server_key = BZR_HOSTKEYS[host][keytype]
307
 
            our_server_key_hex = paramiko.util.hexify(
308
 
                our_server_key.get_fingerprint())
 
280
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
309
281
        else:
310
 
            trace.warning('Adding %s host key for %s: %s'
311
 
                          % (keytype, host, server_key_hex))
 
282
            warning('Adding %s host key for %s: %s' % (keytype, host, server_key_hex))
312
283
            add = getattr(BZR_HOSTKEYS, 'add', None)
313
284
            if add is not None: # paramiko >= 1.X.X
314
285
                BZR_HOSTKEYS.add(host, keytype, server_key)
315
286
            else:
316
287
                BZR_HOSTKEYS.setdefault(host, {})[keytype] = server_key
317
288
            our_server_key = server_key
318
 
            our_server_key_hex = paramiko.util.hexify(
319
 
                our_server_key.get_fingerprint())
 
289
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
320
290
            save_host_keys()
321
291
        if server_key != our_server_key:
322
292
            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' %
 
293
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
294
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
326
295
                (host, our_server_key_hex, server_key_hex),
327
296
                ['Try editing %s or %s' % (filename1, filename2)])
328
297
 
329
 
        _paramiko_auth(username, password, host, port, t)
 
298
        _paramiko_auth(username, password, host, t)
330
299
        return t
331
 
 
 
300
        
332
301
    def connect_sftp(self, username, password, host, port):
333
302
        t = self._connect(username, password, host, port)
334
303
        try:
353
322
    register_ssh_vendor('paramiko', vendor)
354
323
    register_ssh_vendor('none', vendor)
355
324
    register_default_ssh_vendor(vendor)
356
 
    _sftp_connection_errors = (EOFError, paramiko.SSHException)
357
325
    del vendor
358
 
else:
359
 
    _sftp_connection_errors = (EOFError,)
360
326
 
361
327
 
362
328
class SubprocessVendor(SSHVendor):
363
329
    """Abstract base class for vendors that use pipes to a subprocess."""
364
 
 
 
330
    
365
331
    def _connect(self, argv):
366
332
        proc = subprocess.Popen(argv,
367
333
                                stdin=subprocess.PIPE,
374
340
            argv = self._get_vendor_specific_argv(username, host, port,
375
341
                                                  subsystem='sftp')
376
342
            sock = self._connect(argv)
377
 
            return SFTPClient(SocketAsChannelAdapter(sock))
378
 
        except _sftp_connection_errors, e:
 
343
            return SFTPClient(sock)
 
344
        except (EOFError, paramiko.SSHException), e:
379
345
            self._raise_connection_error(host, port=port, orig_error=e)
380
346
        except (OSError, IOError), e:
381
347
            # If the machine is fast enough, ssh can actually exit
403
369
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
404
370
                                  command=None):
405
371
        """Returns the argument list to run the subprocess with.
406
 
 
 
372
        
407
373
        Exactly one of 'subsystem' and 'command' must be specified.
408
374
        """
409
375
        raise NotImplementedError(self._get_vendor_specific_argv)
411
377
 
412
378
class OpenSSHSubprocessVendor(SubprocessVendor):
413
379
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
414
 
 
415
 
    executable_path = 'ssh'
416
 
 
 
380
    
417
381
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
418
382
                                  command=None):
419
 
        args = [self.executable_path,
 
383
        assert subsystem is not None or command is not None, (
 
384
            'Must specify a command or subsystem')
 
385
        if subsystem is not None:
 
386
            assert command is None, (
 
387
                'subsystem and command are mutually exclusive')
 
388
        args = ['ssh',
420
389
                '-oForwardX11=no', '-oForwardAgent=no',
421
390
                '-oClearAllForwardings=yes', '-oProtocol=2',
422
391
                '-oNoHostAuthenticationForLocalhost=yes']
436
405
class SSHCorpSubprocessVendor(SubprocessVendor):
437
406
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
438
407
 
439
 
    executable_path = 'ssh'
440
 
 
441
408
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
442
409
                                  command=None):
443
 
        args = [self.executable_path, '-x']
 
410
        assert subsystem is not None or command is not None, (
 
411
            'Must specify a command or subsystem')
 
412
        if subsystem is not None:
 
413
            assert command is None, (
 
414
                'subsystem and command are mutually exclusive')
 
415
        args = ['ssh', '-x']
444
416
        if port is not None:
445
417
            args.extend(['-p', str(port)])
446
418
        if username is not None:
450
422
        else:
451
423
            args.extend([host] + command)
452
424
        return args
453
 
 
454
 
register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())
 
425
    
 
426
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
455
427
 
456
428
 
457
429
class PLinkSubprocessVendor(SubprocessVendor):
458
430
    """SSH vendor that uses the 'plink' executable from Putty."""
459
431
 
460
 
    executable_path = 'plink'
461
 
 
462
432
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
463
433
                                  command=None):
464
 
        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']
 
434
        assert subsystem is not None or command is not None, (
 
435
            'Must specify a command or subsystem')
 
436
        if subsystem is not None:
 
437
            assert command is None, (
 
438
                'subsystem and command are mutually exclusive')
 
439
        args = ['plink', '-x', '-a', '-ssh', '-2']
465
440
        if port is not None:
466
441
            args.extend(['-P', str(port)])
467
442
        if username is not None:
475
450
register_ssh_vendor('plink', PLinkSubprocessVendor())
476
451
 
477
452
 
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())
 
453
def _paramiko_auth(username, password, host, paramiko_transport):
 
454
    # paramiko requires a username, but it might be none if nothing was supplied
 
455
    # use the local username, just in case.
 
456
    # We don't override username, because if we aren't using paramiko,
 
457
    # the username might be specified in ~/.ssh/config and we don't want to
 
458
    # force it to something else
 
459
    # Also, it would mess up the self.relpath() functionality
 
460
    username = username or getpass.getuser()
 
461
 
485
462
    if _use_ssh_agent:
486
463
        agent = paramiko.Agent()
487
464
        for key in agent.get_keys():
488
 
            trace.mutter('Trying SSH agent key %s'
489
 
                         % paramiko.util.hexify(key.get_fingerprint()))
 
465
            mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
490
466
            try:
491
467
                paramiko_transport.auth_publickey(username, key)
492
468
                return
493
469
            except paramiko.SSHException, e:
494
470
                pass
495
 
 
 
471
    
496
472
    # okay, try finding id_rsa or id_dss?  (posix only)
497
473
    if _try_pkey_auth(paramiko_transport, paramiko.RSAKey, username, 'id_rsa'):
498
474
        return
499
475
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
500
476
        return
501
477
 
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
478
    if password:
536
479
        try:
537
480
            paramiko_transport.auth_password(username, password)
540
483
            pass
541
484
 
542
485
    # 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))
 
486
    password = bzrlib.ui.ui_factory.get_password(
 
487
            prompt='SSH %(user)s@%(host)s password',
 
488
            user=username, host=host)
 
489
    try:
 
490
        paramiko_transport.auth_password(username, password)
 
491
    except paramiko.SSHException, e:
 
492
        raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
493
                              (username, host), e)
555
494
 
556
495
 
557
496
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
561
500
        paramiko_transport.auth_publickey(username, key)
562
501
        return True
563
502
    except paramiko.PasswordRequiredException:
564
 
        password = ui.ui_factory.get_password(
565
 
            prompt='SSH %(filename)s password', filename=filename)
 
503
        password = bzrlib.ui.ui_factory.get_password(
 
504
                prompt='SSH %(filename)s password',
 
505
                filename=filename)
566
506
        try:
567
507
            key = pkey_class.from_private_key_file(filename, password)
568
508
            paramiko_transport.auth_publickey(username, key)
569
509
            return True
570
510
        except paramiko.SSHException:
571
 
            trace.mutter('SSH authentication via %s key failed.'
572
 
                         % (os.path.basename(filename),))
 
511
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
573
512
    except paramiko.SSHException:
574
 
        trace.mutter('SSH authentication via %s key failed.'
575
 
                     % (os.path.basename(filename),))
 
513
        mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
576
514
    except IOError:
577
515
        pass
578
516
    return False
585
523
    """
586
524
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
587
525
    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')
 
526
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
527
    except Exception, e:
 
528
        mutter('failed to load system host keys: ' + str(e))
 
529
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
593
530
    try:
594
531
        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))
 
532
    except Exception, e:
 
533
        mutter('failed to load bzr host keys: ' + str(e))
597
534
        save_host_keys()
598
535
 
599
536
 
602
539
    Save "discovered" host keys in $(config)/ssh_host_keys/.
603
540
    """
604
541
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
605
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
606
 
    config.ensure_config_dir_exists()
 
542
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
543
    ensure_config_dir_exists()
607
544
 
608
545
    try:
609
546
        f = open(bzr_hostkey_path, 'w')
613
550
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
614
551
        f.close()
615
552
    except IOError, e:
616
 
        trace.mutter('failed to save bzr host keys: ' + str(e))
 
553
        mutter('failed to save bzr host keys: ' + str(e))
617
554
 
618
555
 
619
556
def os_specific_subprocess_params():
620
557
    """Get O/S specific subprocess parameters."""
621
558
    if sys.platform == 'win32':
622
 
        # setting the process group and closing fds is not supported on
 
559
        # setting the process group and closing fds is not supported on 
623
560
        # win32
624
561
        return {}
625
562
    else:
626
 
        # We close fds other than the pipes as the child process does not need
 
563
        # We close fds other than the pipes as the child process does not need 
627
564
        # them to be open.
628
565
        #
629
566
        # We also set the child process to ignore SIGINT.  Normally the signal
631
568
        # this causes it to be seen only by bzr and not by ssh.  Python will
632
569
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
633
570
        # to release locks or do other cleanup over ssh before the connection
634
 
        # goes away.
 
571
        # goes away.  
635
572
        # <https://launchpad.net/products/bzr/+bug/5987>
636
573
        #
637
574
        # Running it in a separate process group is not good because then it
638
575
        # can't get non-echoed input of a password or passphrase.
639
576
        # <https://launchpad.net/products/bzr/+bug/40508>
640
 
        return {'preexec_fn': _ignore_signals,
 
577
        return {'preexec_fn': _ignore_sigint,
641
578
                'close_fds': True,
642
579
                }
643
580
 
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
581
 
655
582
class SSHSubprocess(object):
656
583
    """A socket-like object that talks to an ssh subprocess via pipes."""
657
584
 
658
585
    def __init__(self, proc):
659
586
        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
587
 
667
588
    def send(self, data):
668
589
        return os.write(self.proc.stdin.fileno(), data)
669
590
 
 
591
    def recv_ready(self):
 
592
        # TODO: jam 20051215 this function is necessary to support the
 
593
        # pipelined() function. In reality, it probably should use
 
594
        # poll() or select() to actually return if there is data
 
595
        # available, otherwise we probably don't get any benefit
 
596
        return True
 
597
 
670
598
    def recv(self, count):
671
599
        return os.read(self.proc.stdout.fileno(), count)
672
600
 
673
601
    def close(self):
674
 
        _close_ssh_proc(self.proc)
 
602
        self.proc.stdin.close()
 
603
        self.proc.stdout.close()
 
604
        self.proc.wait()
675
605
 
676
606
    def get_filelike_channels(self):
677
607
        return (self.proc.stdout, self.proc.stdin)