← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: Alexander Belchenko
  • Date: 2006-10-14 08:51:07 UTC
  • mto: (2080.1.1 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 2081.
  • Revision ID: bialix@ukr.net-20061014085107-8dff865674eed30a
win32 installer: make short info page instead of full GPL license text

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transport/ssh.py
1
1
# Copyright (C) 2005 Robey Pointer <robey@lag.net>
2
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
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
24
24
import subprocess
25
25
import sys
26
26
 
27
 
from bzrlib import (
28
 
    config,
29
 
    errors,
30
 
    osutils,
31
 
    trace,
32
 
    ui,
33
 
    )
 
27
from bzrlib.config import config_dir, ensure_config_dir_exists
 
28
from bzrlib.errors import (ConnectionError,
 
29
                           ParamikoNotPresent,
 
30
                           TransportError,
 
31
                           UnknownSSH,
 
32
                           )
 
33
 
 
34
from bzrlib.osutils import pathjoin
 
35
from bzrlib.trace import mutter, warning
 
36
import bzrlib.ui
34
37
 
35
38
try:
36
39
    import paramiko
37
40
except ImportError, e:
38
 
    # If we have an ssh subprocess, we don't strictly need paramiko for all ssh
39
 
    # access
40
 
    paramiko = None
 
41
    raise ParamikoNotPresent(e)
41
42
else:
42
43
    from paramiko.sftp_client import SFTPClient
43
44
 
54
55
# connect to an agent if we are on win32 and using Paramiko older than 1.6
55
56
_use_ssh_agent = (sys.platform != 'win32' or _paramiko_version >= (1, 6, 0))
56
57
 
57
 
 
58
 
class SSHVendorManager(object):
59
 
    """Manager for manage SSH vendors."""
60
 
 
61
 
    # Note, although at first sign the class interface seems similar to
62
 
    # bzrlib.registry.Registry it is not possible/convenient to directly use
63
 
    # the Registry because the class just has "get()" interface instead of the
64
 
    # Registry's "get(key)".
65
 
 
66
 
    def __init__(self):
67
 
        self._ssh_vendors = {}
68
 
        self._cached_ssh_vendor = None
69
 
        self._default_ssh_vendor = None
70
 
 
71
 
    def register_default_vendor(self, vendor):
72
 
        """Register default SSH vendor."""
73
 
        self._default_ssh_vendor = vendor
74
 
 
75
 
    def register_vendor(self, name, vendor):
76
 
        """Register new SSH vendor by name."""
77
 
        self._ssh_vendors[name] = vendor
78
 
 
79
 
    def clear_cache(self):
80
 
        """Clear previously cached lookup result."""
81
 
        self._cached_ssh_vendor = None
82
 
 
83
 
    def _get_vendor_by_environment(self, environment=None):
84
 
        """Return the vendor or None based on BZR_SSH environment variable.
85
 
 
86
 
        :raises UnknownSSH: if the BZR_SSH environment variable contains
87
 
                            unknown vendor name
88
 
        """
89
 
        if environment is None:
90
 
            environment = os.environ
91
 
        if 'BZR_SSH' in environment:
92
 
            vendor_name = environment['BZR_SSH']
93
 
            try:
94
 
                vendor = self._ssh_vendors[vendor_name]
95
 
            except KeyError:
96
 
                raise errors.UnknownSSH(vendor_name)
97
 
            return vendor
98
 
        return None
99
 
 
100
 
    def _get_ssh_version_string(self, args):
101
 
        """Return SSH version string from the subprocess."""
 
58
_ssh_vendors = {}
 
59
 
 
60
def register_ssh_vendor(name, vendor):
 
61
    """Register SSH vendor."""
 
62
    _ssh_vendors[name] = vendor
 
63
 
 
64
    
 
65
_ssh_vendor = None
 
66
def _get_ssh_vendor():
 
67
    """Find out what version of SSH is on the system."""
 
68
    global _ssh_vendor
 
69
    if _ssh_vendor is not None:
 
70
        return _ssh_vendor
 
71
 
 
72
    if 'BZR_SSH' in os.environ:
 
73
        vendor_name = os.environ['BZR_SSH']
102
74
        try:
103
 
            p = subprocess.Popen(args,
104
 
                                 stdout=subprocess.PIPE,
105
 
                                 stderr=subprocess.PIPE,
106
 
                                 **os_specific_subprocess_params())
107
 
            stdout, stderr = p.communicate()
108
 
        except OSError:
109
 
            stdout = stderr = ''
110
 
        return stdout + stderr
111
 
 
112
 
    def _get_vendor_by_version_string(self, version, args):
113
 
        """Return the vendor or None based on output from the subprocess.
114
 
 
115
 
        :param version: The output of 'ssh -V' like command.
116
 
        :param args: Command line that was run.
117
 
        """
118
 
        vendor = None
119
 
        if 'OpenSSH' in version:
120
 
            trace.mutter('ssh implementation is OpenSSH')
121
 
            vendor = OpenSSHSubprocessVendor()
122
 
        elif 'SSH Secure Shell' in version:
123
 
            trace.mutter('ssh implementation is SSH Corp.')
124
 
            vendor = SSHCorpSubprocessVendor()
125
 
        elif 'plink' in version and args[0] == 'plink':
126
 
            # Checking if "plink" was the executed argument as Windows
127
 
            # sometimes reports 'ssh -V' incorrectly with 'plink' in it's
128
 
            # version.  See https://bugs.launchpad.net/bzr/+bug/107155
129
 
            trace.mutter("ssh implementation is Putty's plink.")
130
 
            vendor = PLinkSubprocessVendor()
131
 
        return vendor
132
 
 
133
 
    def _get_vendor_by_inspection(self):
134
 
        """Return the vendor or None by checking for known SSH implementations."""
135
 
        for args in (['ssh', '-V'], ['plink', '-V']):
136
 
            version = self._get_ssh_version_string(args)
137
 
            vendor = self._get_vendor_by_version_string(version, args)
138
 
            if vendor is not None:
139
 
                return vendor
140
 
        return None
141
 
 
142
 
    def get_vendor(self, environment=None):
143
 
        """Find out what version of SSH is on the system.
144
 
 
145
 
        :raises SSHVendorNotFound: if no any SSH vendor is found
146
 
        :raises UnknownSSH: if the BZR_SSH environment variable contains
147
 
                            unknown vendor name
148
 
        """
149
 
        if self._cached_ssh_vendor is None:
150
 
            vendor = self._get_vendor_by_environment(environment)
151
 
            if vendor is None:
152
 
                vendor = self._get_vendor_by_inspection()
153
 
                if vendor is None:
154
 
                    trace.mutter('falling back to default implementation')
155
 
                    vendor = self._default_ssh_vendor
156
 
                    if vendor is None:
157
 
                        raise errors.SSHVendorNotFound()
158
 
            self._cached_ssh_vendor = vendor
159
 
        return self._cached_ssh_vendor
160
 
 
161
 
_ssh_vendor_manager = SSHVendorManager()
162
 
_get_ssh_vendor = _ssh_vendor_manager.get_vendor
163
 
register_default_ssh_vendor = _ssh_vendor_manager.register_default_vendor
164
 
register_ssh_vendor = _ssh_vendor_manager.register_vendor
 
75
            _ssh_vendor = _ssh_vendors[vendor_name]
 
76
        except KeyError:
 
77
            raise UnknownSSH(vendor_name)
 
78
        return _ssh_vendor
 
79
 
 
80
    try:
 
81
        p = subprocess.Popen(['ssh', '-V'],
 
82
                             stdin=subprocess.PIPE,
 
83
                             stdout=subprocess.PIPE,
 
84
                             stderr=subprocess.PIPE,
 
85
                             **os_specific_subprocess_params())
 
86
        returncode = p.returncode
 
87
        stdout, stderr = p.communicate()
 
88
    except OSError:
 
89
        returncode = -1
 
90
        stdout = stderr = ''
 
91
    if 'OpenSSH' in stderr:
 
92
        mutter('ssh implementation is OpenSSH')
 
93
        _ssh_vendor = OpenSSHSubprocessVendor()
 
94
    elif 'SSH Secure Shell' in stderr:
 
95
        mutter('ssh implementation is SSH Corp.')
 
96
        _ssh_vendor = SSHCorpSubprocessVendor()
 
97
 
 
98
    if _ssh_vendor is not None:
 
99
        return _ssh_vendor
 
100
 
 
101
    # XXX: 20051123 jamesh
 
102
    # A check for putty's plink or lsh would go here.
 
103
 
 
104
    mutter('falling back to paramiko implementation')
 
105
    _ssh_vendor = ParamikoVendor()
 
106
    return _ssh_vendor
 
107
 
165
108
 
166
109
 
167
110
def _ignore_sigint():
170
113
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
171
114
    import signal
172
115
    signal.signal(signal.SIGINT, signal.SIG_IGN)
 
116
    
173
117
 
174
118
 
175
119
class LoopbackSFTP(object):
177
121
 
178
122
    def __init__(self, sock):
179
123
        self.__socket = sock
180
 
 
 
124
 
181
125
    def send(self, data):
182
126
        return self.__socket.send(data)
183
127
 
193
137
 
194
138
class SSHVendor(object):
195
139
    """Abstract base class for SSH vendor implementations."""
196
 
 
 
140
    
197
141
    def connect_sftp(self, username, password, host, port):
198
142
        """Make an SSH connection, and return an SFTPClient.
199
143
        
216
160
            method that returns a pair of (read, write) filelike objects.
217
161
        """
218
162
        raise NotImplementedError(self.connect_ssh)
219
 
 
220
 
    def _raise_connection_error(self, host, port=None, orig_error=None,
221
 
                                msg='Unable to connect to SSH host'):
222
 
        """Raise a SocketConnectionError with properly formatted host.
223
 
 
224
 
        This just unifies all the locations that try to raise ConnectionError,
225
 
        so that they format things properly.
226
 
        """
227
 
        raise errors.SocketConnectionError(host=host, port=port, msg=msg,
228
 
                                           orig_error=orig_error)
229
 
 
 
163
        
230
164
 
231
165
class LoopbackVendor(SSHVendor):
232
166
    """SSH "vendor" that connects over a plain TCP socket, not SSH."""
233
 
 
 
167
    
234
168
    def connect_sftp(self, username, password, host, port):
235
169
        sock = socket.socket()
236
170
        try:
237
171
            sock.connect((host, port))
238
172
        except socket.error, e:
239
 
            self._raise_connection_error(host, port=port, orig_error=e)
 
173
            raise ConnectionError('Unable to connect to SSH host %s:%s: %s'
 
174
                                  % (host, port, e))
240
175
        return SFTPClient(LoopbackSFTP(sock))
241
176
 
242
177
register_ssh_vendor('loopback', LoopbackVendor())
258
193
 
259
194
    def _connect(self, username, password, host, port):
260
195
        global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
261
 
 
 
196
        
262
197
        load_host_keys()
263
198
 
264
199
        try:
266
201
            t.set_log_channel('bzr.paramiko')
267
202
            t.start_client()
268
203
        except (paramiko.SSHException, socket.error), e:
269
 
            self._raise_connection_error(host, port=port, orig_error=e)
270
 
 
 
204
            raise ConnectionError('Unable to reach SSH host %s:%s: %s' 
 
205
                                  % (host, port, e))
 
206
            
271
207
        server_key = t.get_remote_server_key()
272
208
        server_key_hex = paramiko.util.hexify(server_key.get_fingerprint())
273
209
        keytype = server_key.get_name()
274
210
        if host in SYSTEM_HOSTKEYS and keytype in SYSTEM_HOSTKEYS[host]:
275
211
            our_server_key = SYSTEM_HOSTKEYS[host][keytype]
276
 
            our_server_key_hex = paramiko.util.hexify(
277
 
                our_server_key.get_fingerprint())
 
212
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
278
213
        elif host in BZR_HOSTKEYS and keytype in BZR_HOSTKEYS[host]:
279
214
            our_server_key = BZR_HOSTKEYS[host][keytype]
280
 
            our_server_key_hex = paramiko.util.hexify(
281
 
                our_server_key.get_fingerprint())
 
215
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
282
216
        else:
283
 
            trace.warning('Adding %s host key for %s: %s'
284
 
                          % (keytype, host, server_key_hex))
285
 
            add = getattr(BZR_HOSTKEYS, 'add', None)
286
 
            if add is not None: # paramiko >= 1.X.X
287
 
                BZR_HOSTKEYS.add(host, keytype, server_key)
288
 
            else:
289
 
                BZR_HOSTKEYS.setdefault(host, {})[keytype] = server_key
 
217
            warning('Adding %s host key for %s: %s' % (keytype, host, server_key_hex))
 
218
            if host not in BZR_HOSTKEYS:
 
219
                BZR_HOSTKEYS[host] = {}
 
220
            BZR_HOSTKEYS[host][keytype] = server_key
290
221
            our_server_key = server_key
291
 
            our_server_key_hex = paramiko.util.hexify(
292
 
                our_server_key.get_fingerprint())
 
222
            our_server_key_hex = paramiko.util.hexify(our_server_key.get_fingerprint())
293
223
            save_host_keys()
294
224
        if server_key != our_server_key:
295
225
            filename1 = os.path.expanduser('~/.ssh/known_hosts')
296
 
            filename2 = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
297
 
            raise errors.TransportError(
298
 
                'Host keys for %s do not match!  %s != %s' %
 
226
            filename2 = pathjoin(config_dir(), 'ssh_host_keys')
 
227
            raise TransportError('Host keys for %s do not match!  %s != %s' % \
299
228
                (host, our_server_key_hex, server_key_hex),
300
229
                ['Try editing %s or %s' % (filename1, filename2)])
301
230
 
302
 
        _paramiko_auth(username, password, host, port, t)
 
231
        _paramiko_auth(username, password, host, t)
303
232
        return t
304
 
 
 
233
        
305
234
    def connect_sftp(self, username, password, host, port):
306
235
        t = self._connect(username, password, host, port)
307
236
        try:
308
237
            return t.open_sftp_client()
309
238
        except paramiko.SSHException, e:
310
 
            self._raise_connection_error(host, port=port, orig_error=e,
311
 
                                         msg='Unable to start sftp client')
 
239
            raise ConnectionError('Unable to start sftp client %s:%d' %
 
240
                                  (host, port), e)
312
241
 
313
242
    def connect_ssh(self, username, password, host, port, command):
314
243
        t = self._connect(username, password, host, port)
318
247
            channel.exec_command(cmdline)
319
248
            return _ParamikoSSHConnection(channel)
320
249
        except paramiko.SSHException, e:
321
 
            self._raise_connection_error(host, port=port, orig_error=e,
322
 
                                         msg='Unable to invoke remote bzr')
 
250
            raise ConnectionError('Unable to invoke remote bzr %s:%d' %
 
251
                                  (host, port), e)
323
252
 
324
 
if paramiko is not None:
325
 
    vendor = ParamikoVendor()
326
 
    register_ssh_vendor('paramiko', vendor)
327
 
    register_ssh_vendor('none', vendor)
328
 
    register_default_ssh_vendor(vendor)
329
 
    _sftp_connection_errors = (EOFError, paramiko.SSHException)
330
 
    del vendor
331
 
else:
332
 
    _sftp_connection_errors = (EOFError,)
 
253
register_ssh_vendor('paramiko', ParamikoVendor())
333
254
 
334
255
 
335
256
class SubprocessVendor(SSHVendor):
336
257
    """Abstract base class for vendors that use pipes to a subprocess."""
337
 
 
 
258
    
338
259
    def _connect(self, argv):
339
260
        proc = subprocess.Popen(argv,
340
261
                                stdin=subprocess.PIPE,
348
269
                                                  subsystem='sftp')
349
270
            sock = self._connect(argv)
350
271
            return SFTPClient(sock)
351
 
        except _sftp_connection_errors, e:
352
 
            self._raise_connection_error(host, port=port, orig_error=e)
 
272
        except (EOFError, paramiko.SSHException), e:
 
273
            raise ConnectionError('Unable to connect to SSH host %s:%s: %s'
 
274
                                  % (host, port, e))
353
275
        except (OSError, IOError), e:
354
276
            # If the machine is fast enough, ssh can actually exit
355
277
            # before we try and send it the sftp request, which
356
278
            # raises a Broken Pipe
357
279
            if e.errno not in (errno.EPIPE,):
358
280
                raise
359
 
            self._raise_connection_error(host, port=port, orig_error=e)
 
281
            raise ConnectionError('Unable to connect to SSH host %s:%s: %s'
 
282
                                  % (host, port, e))
360
283
 
361
284
    def connect_ssh(self, username, password, host, port, command):
362
285
        try:
364
287
                                                  command=command)
365
288
            return self._connect(argv)
366
289
        except (EOFError), e:
367
 
            self._raise_connection_error(host, port=port, orig_error=e)
 
290
            raise ConnectionError('Unable to connect to SSH host %s:%s: %s'
 
291
                                  % (host, port, e))
368
292
        except (OSError, IOError), e:
369
293
            # If the machine is fast enough, ssh can actually exit
370
294
            # before we try and send it the sftp request, which
371
295
            # raises a Broken Pipe
372
296
            if e.errno not in (errno.EPIPE,):
373
297
                raise
374
 
            self._raise_connection_error(host, port=port, orig_error=e)
 
298
            raise ConnectionError('Unable to connect to SSH host %s:%s: %s'
 
299
                                  % (host, port, e))
375
300
 
376
301
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
377
302
                                  command=None):
381
306
        """
382
307
        raise NotImplementedError(self._get_vendor_specific_argv)
383
308
 
 
309
register_ssh_vendor('none', ParamikoVendor())
 
310
 
384
311
 
385
312
class OpenSSHSubprocessVendor(SubprocessVendor):
386
313
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
387
 
 
 
314
    
388
315
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
389
316
                                  command=None):
390
317
        assert subsystem is not None or command is not None, (
429
356
        else:
430
357
            args.extend([host] + command)
431
358
        return args
432
 
 
 
359
    
433
360
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
434
361
 
435
362
 
436
 
class PLinkSubprocessVendor(SubprocessVendor):
437
 
    """SSH vendor that uses the 'plink' executable from Putty."""
438
 
 
439
 
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
440
 
                                  command=None):
441
 
        assert subsystem is not None or command is not None, (
442
 
            'Must specify a command or subsystem')
443
 
        if subsystem is not None:
444
 
            assert command is None, (
445
 
                'subsystem and command are mutually exclusive')
446
 
        args = ['plink', '-x', '-a', '-ssh', '-2', '-batch']
447
 
        if port is not None:
448
 
            args.extend(['-P', str(port)])
449
 
        if username is not None:
450
 
            args.extend(['-l', username])
451
 
        if subsystem is not None:
452
 
            args.extend(['-s', host, subsystem])
453
 
        else:
454
 
            args.extend([host] + command)
455
 
        return args
456
 
 
457
 
register_ssh_vendor('plink', PLinkSubprocessVendor())
458
 
 
459
 
 
460
 
def _paramiko_auth(username, password, host, port, paramiko_transport):
 
363
def _paramiko_auth(username, password, host, paramiko_transport):
461
364
    # paramiko requires a username, but it might be none if nothing was supplied
462
365
    # use the local username, just in case.
463
366
    # We don't override username, because if we aren't using paramiko,
464
367
    # the username might be specified in ~/.ssh/config and we don't want to
465
368
    # force it to something else
466
369
    # Also, it would mess up the self.relpath() functionality
467
 
    auth = config.AuthenticationConfig()
468
 
    if username is None:
469
 
        username = auth.get_user('ssh', host, port=port)
470
 
        if username is None:
471
 
            # Default to local user
472
 
            username = getpass.getuser()
 
370
    username = username or getpass.getuser()
473
371
 
474
372
    if _use_ssh_agent:
475
373
        agent = paramiko.Agent()
476
374
        for key in agent.get_keys():
477
 
            trace.mutter('Trying SSH agent key %s'
478
 
                         % paramiko.util.hexify(key.get_fingerprint()))
 
375
            mutter('Trying SSH agent key %s' % paramiko.util.hexify(key.get_fingerprint()))
479
376
            try:
480
377
                paramiko_transport.auth_publickey(username, key)
481
378
                return
482
379
            except paramiko.SSHException, e:
483
380
                pass
484
 
 
 
381
    
485
382
    # okay, try finding id_rsa or id_dss?  (posix only)
486
383
    if _try_pkey_auth(paramiko_transport, paramiko.RSAKey, username, 'id_rsa'):
487
384
        return
496
393
            pass
497
394
 
498
395
    # give up and ask for a password
499
 
    password = auth.get_password('ssh', host, username, port=port)
 
396
    password = bzrlib.ui.ui_factory.get_password(
 
397
            prompt='SSH %(user)s@%(host)s password',
 
398
            user=username, host=host)
500
399
    try:
501
400
        paramiko_transport.auth_password(username, password)
502
401
    except paramiko.SSHException, e:
503
 
        raise errors.ConnectionError(
504
 
            'Unable to authenticate to SSH host as %s@%s' % (username, host), e)
 
402
        raise ConnectionError('Unable to authenticate to SSH host as %s@%s' %
 
403
                              (username, host), e)
505
404
 
506
405
 
507
406
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
511
410
        paramiko_transport.auth_publickey(username, key)
512
411
        return True
513
412
    except paramiko.PasswordRequiredException:
514
 
        password = ui.ui_factory.get_password(
515
 
            prompt='SSH %(filename)s password', filename=filename)
 
413
        password = bzrlib.ui.ui_factory.get_password(
 
414
                prompt='SSH %(filename)s password',
 
415
                filename=filename)
516
416
        try:
517
417
            key = pkey_class.from_private_key_file(filename, password)
518
418
            paramiko_transport.auth_publickey(username, key)
519
419
            return True
520
420
        except paramiko.SSHException:
521
 
            trace.mutter('SSH authentication via %s key failed.'
522
 
                         % (os.path.basename(filename),))
 
421
            mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
523
422
    except paramiko.SSHException:
524
 
        trace.mutter('SSH authentication via %s key failed.'
525
 
                     % (os.path.basename(filename),))
 
423
        mutter('SSH authentication via %s key failed.' % (os.path.basename(filename),))
526
424
    except IOError:
527
425
        pass
528
426
    return False
535
433
    """
536
434
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
537
435
    try:
538
 
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(
539
 
            os.path.expanduser('~/.ssh/known_hosts'))
540
 
    except IOError, e:
541
 
        trace.mutter('failed to load system host keys: ' + str(e))
542
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
 
436
        SYSTEM_HOSTKEYS = paramiko.util.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))
 
437
    except Exception, e:
 
438
        mutter('failed to load system host keys: ' + str(e))
 
439
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
543
440
    try:
544
441
        BZR_HOSTKEYS = paramiko.util.load_host_keys(bzr_hostkey_path)
545
 
    except IOError, e:
546
 
        trace.mutter('failed to load bzr host keys: ' + str(e))
 
442
    except Exception, e:
 
443
        mutter('failed to load bzr host keys: ' + str(e))
547
444
        save_host_keys()
548
445
 
549
446
 
552
449
    Save "discovered" host keys in $(config)/ssh_host_keys/.
553
450
    """
554
451
    global SYSTEM_HOSTKEYS, BZR_HOSTKEYS
555
 
    bzr_hostkey_path = osutils.pathjoin(config.config_dir(), 'ssh_host_keys')
556
 
    config.ensure_config_dir_exists()
 
452
    bzr_hostkey_path = pathjoin(config_dir(), 'ssh_host_keys')
 
453
    ensure_config_dir_exists()
557
454
 
558
455
    try:
559
456
        f = open(bzr_hostkey_path, 'w')
563
460
                f.write('%s %s %s\n' % (hostname, keytype, key.get_base64()))
564
461
        f.close()
565
462
    except IOError, e:
566
 
        trace.mutter('failed to save bzr host keys: ' + str(e))
 
463
        mutter('failed to save bzr host keys: ' + str(e))
567
464
 
568
465
 
569
466
def os_specific_subprocess_params():