~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

  • Committer: Martin Pool
  • Date: 2009-01-13 03:11:04 UTC
  • mto: This revision was merged to the branch mainline in revision 3937.
  • Revision ID: mbp@sourcefrog.net-20090113031104-03my054s02i9l2pe
Bump version to 1.12 and add news template

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
94
93
            try:
95
94
                vendor = self._ssh_vendors[vendor_name]
96
95
            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
 
96
                raise errors.UnknownSSH(vendor_name)
101
97
            return vendor
102
98
        return None
103
99
 
113
109
            stdout = stderr = ''
114
110
        return stdout + stderr
115
111
 
116
 
    def _get_vendor_by_version_string(self, version, progname):
 
112
    def _get_vendor_by_version_string(self, version, args):
117
113
        """Return the vendor or None based on output from the subprocess.
118
114
 
119
115
        :param version: The output of 'ssh -V' like command.
126
122
        elif 'SSH Secure Shell' in version:
127
123
            trace.mutter('ssh implementation is SSH Corp.')
128
124
            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':
 
125
        elif 'plink' in version and args[0] == 'plink':
133
126
            # Checking if "plink" was the executed argument as Windows
134
127
            # sometimes reports 'ssh -V' incorrectly with 'plink' in it's
135
128
            # version.  See https://bugs.launchpad.net/bzr/+bug/107155
139
132
 
140
133
    def _get_vendor_by_inspection(self):
141
134
        """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])
 
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
150
141
 
151
142
    def get_vendor(self, environment=None):
152
143
        """Find out what version of SSH is on the system.
173
164
register_ssh_vendor = _ssh_vendor_manager.register_vendor
174
165
 
175
166
 
176
 
def _ignore_signals():
 
167
def _ignore_sigint():
177
168
    # TODO: This should possibly ignore SIGHUP as well, but bzr currently
178
169
    # doesn't handle it itself.
179
170
    # <https://launchpad.net/products/bzr/+bug/41433/+index>
180
171
    import signal
181
172
    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
173
 
186
174
 
187
175
class SocketAsChannelAdapter(object):
192
180
 
193
181
    def get_name(self):
194
182
        return "bzr SocketAsChannelAdapter"
195
 
 
 
183
    
196
184
    def send(self, data):
197
185
        return self.__socket.send(data)
198
186
 
223
211
 
224
212
    def connect_sftp(self, username, password, host, port):
225
213
        """Make an SSH connection, and return an SFTPClient.
226
 
 
 
214
        
227
215
        :param username: an ascii string
228
216
        :param password: an ascii string
229
217
        :param host: a host name as an ascii string
238
226
 
239
227
    def connect_ssh(self, username, password, host, port, command):
240
228
        """Make an SSH connection.
241
 
 
 
229
        
242
230
        :returns: something with a `close` method, and a `get_filelike_channels`
243
231
            method that returns a pair of (read, write) filelike objects.
244
232
        """
403
391
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
404
392
                                  command=None):
405
393
        """Returns the argument list to run the subprocess with.
406
 
 
 
394
        
407
395
        Exactly one of 'subsystem' and 'command' must be specified.
408
396
        """
409
397
        raise NotImplementedError(self._get_vendor_specific_argv)
412
400
class OpenSSHSubprocessVendor(SubprocessVendor):
413
401
    """SSH vendor that uses the 'ssh' executable from OpenSSH."""
414
402
 
415
 
    executable_path = 'ssh'
416
 
 
417
403
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
418
404
                                  command=None):
419
 
        args = [self.executable_path,
 
405
        args = ['ssh',
420
406
                '-oForwardX11=no', '-oForwardAgent=no',
421
407
                '-oClearAllForwardings=yes', '-oProtocol=2',
422
408
                '-oNoHostAuthenticationForLocalhost=yes']
436
422
class SSHCorpSubprocessVendor(SubprocessVendor):
437
423
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
438
424
 
439
 
    executable_path = 'ssh'
440
 
 
441
425
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
442
426
                                  command=None):
443
 
        args = [self.executable_path, '-x']
 
427
        args = ['ssh', '-x']
444
428
        if port is not None:
445
429
            args.extend(['-p', str(port)])
446
430
        if username is not None:
451
435
            args.extend([host] + command)
452
436
        return args
453
437
 
454
 
register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())
 
438
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
455
439
 
456
440
 
457
441
class PLinkSubprocessVendor(SubprocessVendor):
458
442
    """SSH vendor that uses the 'plink' executable from Putty."""
459
443
 
460
 
    executable_path = 'plink'
461
 
 
462
444
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
463
445
                                  command=None):
464
 
        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']
 
446
        args = ['plink', '-x', '-a', '-ssh', '-2', '-batch']
465
447
        if port is not None:
466
448
            args.extend(['-P', str(port)])
467
449
        if username is not None:
476
458
 
477
459
 
478
460
def _paramiko_auth(username, password, host, port, paramiko_transport):
479
 
    auth = config.AuthenticationConfig()
480
461
    # paramiko requires a username, but it might be none if nothing was
481
462
    # supplied.  If so, use the local username.
482
463
    if username is None:
483
 
        username = auth.get_user('ssh', host, port=port,
484
 
                                 default=getpass.getuser())
 
464
        username = getpass.getuser()
 
465
 
485
466
    if _use_ssh_agent:
486
467
        agent = paramiko.Agent()
487
468
        for key in agent.get_keys():
499
480
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
500
481
        return
501
482
 
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
483
    if password:
536
484
        try:
537
485
            paramiko_transport.auth_password(username, password)
540
488
            pass
541
489
 
542
490
    # give up and ask for a password
 
491
    auth = config.AuthenticationConfig()
543
492
    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))
 
493
    try:
 
494
        paramiko_transport.auth_password(username, password)
 
495
    except paramiko.SSHException, e:
 
496
        raise errors.ConnectionError(
 
497
            'Unable to authenticate to SSH host as %s@%s' % (username, host), e)
555
498
 
556
499
 
557
500
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
619
562
def os_specific_subprocess_params():
620
563
    """Get O/S specific subprocess parameters."""
621
564
    if sys.platform == 'win32':
622
 
        # setting the process group and closing fds is not supported on
 
565
        # setting the process group and closing fds is not supported on 
623
566
        # win32
624
567
        return {}
625
568
    else:
626
 
        # We close fds other than the pipes as the child process does not need
 
569
        # We close fds other than the pipes as the child process does not need 
627
570
        # them to be open.
628
571
        #
629
572
        # We also set the child process to ignore SIGINT.  Normally the signal
631
574
        # this causes it to be seen only by bzr and not by ssh.  Python will
632
575
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
633
576
        # to release locks or do other cleanup over ssh before the connection
634
 
        # goes away.
 
577
        # goes away.  
635
578
        # <https://launchpad.net/products/bzr/+bug/5987>
636
579
        #
637
580
        # Running it in a separate process group is not good because then it
638
581
        # can't get non-echoed input of a password or passphrase.
639
582
        # <https://launchpad.net/products/bzr/+bug/40508>
640
 
        return {'preexec_fn': _ignore_signals,
 
583
        return {'preexec_fn': _ignore_sigint,
641
584
                'close_fds': True,
642
585
                }
643
586
 
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
587
 
655
588
class SSHSubprocess(object):
656
589
    """A socket-like object that talks to an ssh subprocess via pipes."""
657
590
 
658
591
    def __init__(self, proc):
659
592
        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
593
 
667
594
    def send(self, data):
668
595
        return os.write(self.proc.stdin.fileno(), data)
671
598
        return os.read(self.proc.stdout.fileno(), count)
672
599
 
673
600
    def close(self):
674
 
        _close_ssh_proc(self.proc)
 
601
        self.proc.stdin.close()
 
602
        self.proc.stdout.close()
 
603
        self.proc.wait()
675
604
 
676
605
    def get_filelike_channels(self):
677
606
        return (self.proc.stdout, self.proc.stdin)