/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

Merge from bzr.dev

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
        assert subsystem is not None or command is not None, (
 
406
            'Must specify a command or subsystem')
 
407
        if subsystem is not None:
 
408
            assert command is None, (
 
409
                'subsystem and command are mutually exclusive')
 
410
        args = ['ssh',
420
411
                '-oForwardX11=no', '-oForwardAgent=no',
421
412
                '-oClearAllForwardings=yes', '-oProtocol=2',
422
413
                '-oNoHostAuthenticationForLocalhost=yes']
436
427
class SSHCorpSubprocessVendor(SubprocessVendor):
437
428
    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""
438
429
 
439
 
    executable_path = 'ssh'
440
 
 
441
430
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
442
431
                                  command=None):
443
 
        args = [self.executable_path, '-x']
 
432
        assert subsystem is not None or command is not None, (
 
433
            'Must specify a command or subsystem')
 
434
        if subsystem is not None:
 
435
            assert command is None, (
 
436
                'subsystem and command are mutually exclusive')
 
437
        args = ['ssh', '-x']
444
438
        if port is not None:
445
439
            args.extend(['-p', str(port)])
446
440
        if username is not None:
451
445
            args.extend([host] + command)
452
446
        return args
453
447
 
454
 
register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())
 
448
register_ssh_vendor('ssh', SSHCorpSubprocessVendor())
455
449
 
456
450
 
457
451
class PLinkSubprocessVendor(SubprocessVendor):
458
452
    """SSH vendor that uses the 'plink' executable from Putty."""
459
453
 
460
 
    executable_path = 'plink'
461
 
 
462
454
    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,
463
455
                                  command=None):
464
 
        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']
 
456
        assert subsystem is not None or command is not None, (
 
457
            'Must specify a command or subsystem')
 
458
        if subsystem is not None:
 
459
            assert command is None, (
 
460
                'subsystem and command are mutually exclusive')
 
461
        args = ['plink', '-x', '-a', '-ssh', '-2', '-batch']
465
462
        if port is not None:
466
463
            args.extend(['-P', str(port)])
467
464
        if username is not None:
476
473
 
477
474
 
478
475
def _paramiko_auth(username, password, host, port, paramiko_transport):
 
476
    # paramiko requires a username, but it might be none if nothing was supplied
 
477
    # use the local username, just in case.
 
478
    # We don't override username, because if we aren't using paramiko,
 
479
    # the username might be specified in ~/.ssh/config and we don't want to
 
480
    # force it to something else
 
481
    # Also, it would mess up the self.relpath() functionality
479
482
    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
483
    if username is None:
483
 
        username = auth.get_user('ssh', host, port=port,
484
 
                                 default=getpass.getuser())
 
484
        username = auth.get_user('ssh', host, port=port)
 
485
        if username is None:
 
486
            # Default to local user
 
487
            username = getpass.getuser()
 
488
 
485
489
    if _use_ssh_agent:
486
490
        agent = paramiko.Agent()
487
491
        for key in agent.get_keys():
499
503
    if _try_pkey_auth(paramiko_transport, paramiko.DSSKey, username, 'id_dsa'):
500
504
        return
501
505
 
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
506
    if password:
536
507
        try:
537
508
            paramiko_transport.auth_password(username, password)
541
512
 
542
513
    # give up and ask for a password
543
514
    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))
 
515
    try:
 
516
        paramiko_transport.auth_password(username, password)
 
517
    except paramiko.SSHException, e:
 
518
        raise errors.ConnectionError(
 
519
            'Unable to authenticate to SSH host as %s@%s' % (username, host), e)
555
520
 
556
521
 
557
522
def _try_pkey_auth(paramiko_transport, pkey_class, username, filename):
619
584
def os_specific_subprocess_params():
620
585
    """Get O/S specific subprocess parameters."""
621
586
    if sys.platform == 'win32':
622
 
        # setting the process group and closing fds is not supported on
 
587
        # setting the process group and closing fds is not supported on 
623
588
        # win32
624
589
        return {}
625
590
    else:
626
 
        # We close fds other than the pipes as the child process does not need
 
591
        # We close fds other than the pipes as the child process does not need 
627
592
        # them to be open.
628
593
        #
629
594
        # We also set the child process to ignore SIGINT.  Normally the signal
631
596
        # this causes it to be seen only by bzr and not by ssh.  Python will
632
597
        # generate a KeyboardInterrupt in bzr, and we will then have a chance
633
598
        # to release locks or do other cleanup over ssh before the connection
634
 
        # goes away.
 
599
        # goes away.  
635
600
        # <https://launchpad.net/products/bzr/+bug/5987>
636
601
        #
637
602
        # Running it in a separate process group is not good because then it
638
603
        # can't get non-echoed input of a password or passphrase.
639
604
        # <https://launchpad.net/products/bzr/+bug/40508>
640
 
        return {'preexec_fn': _ignore_signals,
 
605
        return {'preexec_fn': _ignore_sigint,
641
606
                'close_fds': True,
642
607
                }
643
608
 
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
609
 
655
610
class SSHSubprocess(object):
656
611
    """A socket-like object that talks to an ssh subprocess via pipes."""
657
612
 
658
613
    def __init__(self, proc):
659
614
        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
615
 
667
616
    def send(self, data):
668
617
        return os.write(self.proc.stdin.fileno(), data)
671
620
        return os.read(self.proc.stdout.fileno(), count)
672
621
 
673
622
    def close(self):
674
 
        _close_ssh_proc(self.proc)
 
623
        self.proc.stdin.close()
 
624
        self.proc.stdout.close()
 
625
        self.proc.wait()
675
626
 
676
627
    def get_filelike_channels(self):
677
628
        return (self.proc.stdout, self.proc.stdin)