~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/ssh.py

• browse files at revision 4634.146.4
• compare with another revision
• download diff
• download tarball
• view history from revision 4634.146.4

• reverse the comparison (4634.146.4 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

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

94

94

            try:

95

95

                vendor = self._ssh_vendors[vendor_name]

96

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

 

97

                raise errors.UnknownSSH(vendor_name)

101

98

            return vendor

102

99

        return None

103

100

 

113

110

            stdout = stderr = ''

114

111

        return stdout + stderr

115

112

 

116

 

    def _get_vendor_by_version_string(self, version, progname):

 

113

    def _get_vendor_by_version_string(self, version, args):

117

114

        """Return the vendor or None based on output from the subprocess.

118

115

 

119

116

        :param version: The output of 'ssh -V' like command.

126

123

        elif 'SSH Secure Shell' in version:

127

124

            trace.mutter('ssh implementation is SSH Corp.')

128

125

            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()

 

126

        # Auto-detect of plink vendor disabled, on Windows recommended

 

127

        # default ssh-client is paramiko

 

128

        # see https://bugs.launchpad.net/bugs/414743

 

129

        #~elif 'plink' in version and args[0] == 'plink':

 

130

        #~    # Checking if "plink" was the executed argument as Windows

 

131

        #~    # sometimes reports 'ssh -V' incorrectly with 'plink' in it's

 

132

        #~    # version.  See https://bugs.launchpad.net/bzr/+bug/107155

 

133

        #~    trace.mutter("ssh implementation is Putty's plink.")

 

134

        #~    vendor = PLinkSubprocessVendor()

138

135

        return vendor

139

136

 

140

137

    def _get_vendor_by_inspection(self):

141

138

        """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])

 

139

        for args in (['ssh', '-V'], ['plink', '-V']):

 

140

            version = self._get_ssh_version_string(args)

 

141

            vendor = self._get_vendor_by_version_string(version, args)

 

142

            if vendor is not None:

 

143

                return vendor

 

144

        return None

150

145

 

151

146

    def get_vendor(self, environment=None):

152

147

        """Find out what version of SSH is on the system.

173

168

register_ssh_vendor = _ssh_vendor_manager.register_vendor

174

169

 

175

170

 

176

 

def _ignore_signals():

 

171

def _ignore_sigint():

177

172

    # TODO: This should possibly ignore SIGHUP as well, but bzr currently

178

173

    # doesn't handle it itself.

179

174

    # <https://launchpad.net/products/bzr/+bug/41433/+index>

180

175

    import signal

181

176

    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

177

 

186

178

 

187

179

class SocketAsChannelAdapter(object):

239

231

    def connect_ssh(self, username, password, host, port, command):

240

232

        """Make an SSH connection.

241

233

 

242

 

        :returns: an SSHConnection.

 

234

        :returns: something with a `close` method, and a `get_filelike_channels`

 

235

            method that returns a pair of (read, write) filelike objects.

243

236

        """

244

237

        raise NotImplementedError(self.connect_ssh)

245

238

 

268

261

register_ssh_vendor('loopback', LoopbackVendor())

269

262

 

270

263

 

 

264

class _ParamikoSSHConnection(object):

 

265

    def __init__(self, channel):

 

266

        self.channel = channel

 

267

 

 

268

    def get_filelike_channels(self):

 

269

        return self.channel.makefile('rb'), self.channel.makefile('wb')

 

270

 

 

271

    def close(self):

 

272

        return self.channel.close()

 

273

 

 

274

 

271

275

class ParamikoVendor(SSHVendor):

272

276

    """Vendor that uses paramiko."""

273

277

 

351

355

    """Abstract base class for vendors that use pipes to a subprocess."""

352

356

 

353

357

    def _connect(self, argv):

354

 

        # Attempt to make a socketpair to use as stdin/stdout for the SSH

355

 

        # subprocess.  We prefer sockets to pipes because they support

356

 

        # non-blocking short reads, allowing us to optimistically read 64k (or

357

 

        # whatever) chunks.

358

 

        try:

359

 

            my_sock, subproc_sock = socket.socketpair()

360

 

        except (AttributeError, socket.error):

361

 

            # This platform doesn't support socketpair(), so just use ordinary

362

 

            # pipes instead.

363

 

            stdin = stdout = subprocess.PIPE

364

 

            sock = None

365

 

        else:

366

 

            stdin = stdout = subproc_sock

367

 

            sock = my_sock

368

 

        proc = subprocess.Popen(argv, stdin=stdin, stdout=stdout,

 

358

        proc = subprocess.Popen(argv,

 

359

                                stdin=subprocess.PIPE,

 

360

                                stdout=subprocess.PIPE,

369

361

                                **os_specific_subprocess_params())

370

 

        return SSHSubprocessConnection(proc, sock=sock)

 

362

        return SSHSubprocess(proc)

371

363

 

372

364

    def connect_sftp(self, username, password, host, port):

373

365

        try:

412

404

class OpenSSHSubprocessVendor(SubprocessVendor):

413

405

    """SSH vendor that uses the 'ssh' executable from OpenSSH."""

414

406

 

415

 

    executable_path = 'ssh'

416

 

 

417

407

    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,

418

408

                                  command=None):

419

 

        args = [self.executable_path,

 

409

        args = ['ssh',

420

410

                '-oForwardX11=no', '-oForwardAgent=no',

421

411

                '-oClearAllForwardings=yes', '-oProtocol=2',

422

412

                '-oNoHostAuthenticationForLocalhost=yes']

436

426

class SSHCorpSubprocessVendor(SubprocessVendor):

437

427

    """SSH vendor that uses the 'ssh' executable from SSH Corporation."""

438

428

 

439

 

    executable_path = 'ssh'

440

 

 

441

429

    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,

442

430

                                  command=None):

443

 

        args = [self.executable_path, '-x']

 

431

        args = ['ssh', '-x']

444

432

        if port is not None:

445

433

            args.extend(['-p', str(port)])

446

434

        if username is not None:

451

439

            args.extend([host] + command)

452

440

        return args

453

441

 

454

 

register_ssh_vendor('sshcorp', SSHCorpSubprocessVendor())

 

442

register_ssh_vendor('ssh', SSHCorpSubprocessVendor())

455

443

 

456

444

 

457

445

class PLinkSubprocessVendor(SubprocessVendor):

458

446

    """SSH vendor that uses the 'plink' executable from Putty."""

459

447

 

460

 

    executable_path = 'plink'

461

 

 

462

448

    def _get_vendor_specific_argv(self, username, host, port, subsystem=None,

463

449

                                  command=None):

464

 

        args = [self.executable_path, '-x', '-a', '-ssh', '-2', '-batch']

 

450

        args = ['plink', '-x', '-a', '-ssh', '-2', '-batch']

465

451

        if port is not None:

466

452

            args.extend(['-P', str(port)])

467

453

        if username is not None:

637

623

        # Running it in a separate process group is not good because then it

638

624

        # can't get non-echoed input of a password or passphrase.

639

625

        # <https://launchpad.net/products/bzr/+bug/40508>

640

 

        return {'preexec_fn': _ignore_signals,

 

626

        return {'preexec_fn': _ignore_sigint,

641

627

                'close_fds': True,

642

628

                }

643

629

 

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

 

 

655

 

class SSHConnection(object):

656

 

    """Abstract base class for SSH connections."""

657

 

 

658

 

    def get_sock_or_pipes(self):

659

 

        """Returns a (kind, io_object) pair.

660

 

 

661

 

        If kind == 'socket', then io_object is a socket.

662

 

 

663

 

        If kind == 'pipes', then io_object is a pair of file-like objects

664

 

        (read_from, write_to).

665

 

        """

666

 

        raise NotImplementedError(self.get_sock_or_pipes)

667

 

 

668

 

    def close(self):

669

 

        raise NotImplementedError(self.close)

670

 

 

671

 

 

672

 

class SSHSubprocessConnection(SSHConnection):

673

 

    """A connection to an ssh subprocess via pipes or a socket.

674

 

 

675

 

    This class is also socket-like enough to be used with

676

 

    SocketAsChannelAdapter (it has 'send' and 'recv' methods).

677

 

    """

678

 

 

679

 

    def __init__(self, proc, sock=None):

680

 

        """Constructor.

681

 

 

682

 

        :param proc: a subprocess.Popen

683

 

        :param sock: if proc.stdin/out is a socket from a socketpair, then sock

684

 

            should bzrlib's half of that socketpair.  If not passed, proc's

685

 

            stdin/out is assumed to be ordinary pipes.

686

 

        """

 

630

 

 

631

class SSHSubprocess(object):

 

632

    """A socket-like object that talks to an ssh subprocess via pipes."""

 

633

 

 

634

    def __init__(self, proc):

687

635

        self.proc = proc

688

 

        self._sock = sock

689

 

        # Add a weakref to proc that will attempt to do the same as self.close

690

 

        # to avoid leaving processes lingering indefinitely.

691

 

        def terminate(ref):

692

 

            _subproc_weakrefs.remove(ref)

693

 

            _close_ssh_proc(proc)

694

 

        _subproc_weakrefs.add(weakref.ref(self, terminate))

695

636

 

696

637

    def send(self, data):

697

 

        if self._sock is not None:

698

 

            return self._sock.send(data)

699

 

        else:

700

 

            return os.write(self.proc.stdin.fileno(), data)

 

638

        return os.write(self.proc.stdin.fileno(), data)

701

639

 

702

640

    def recv(self, count):

703

 

        if self._sock is not None:

704

 

            return self._sock.recv(count)

705

 

        else:

706

 

            return os.read(self.proc.stdout.fileno(), count)

707

 

 

708

 

    def close(self):

709

 

        _close_ssh_proc(self.proc)

710

 

 

711

 

    def get_sock_or_pipes(self):

712

 

        if self._sock is not None:

713

 

            return 'socket', self._sock

714

 

        else:

715

 

            return 'pipes', (self.proc.stdout, self.proc.stdin)

716

 

 

717

 

 

718

 

class _ParamikoSSHConnection(SSHConnection):

719

 

    """An SSH connection via paramiko."""

720

 

 

721

 

    def __init__(self, channel):

722

 

        self.channel = channel

723

 

 

724

 

    def get_sock_or_pipes(self):

725

 

        return ('socket', self.channel)

726

 

 

727

 

    def close(self):

728

 

        return self.channel.close()

729

 

 

 

641

        return os.read(self.proc.stdout.fileno(), count)

 

642

 

 

643

    def close(self):

 

644

        self.proc.stdin.close()

 

645

        self.proc.stdout.close()

 

646

        self.proc.wait()

 

647

 

 

648

    def get_filelike_channels(self):

 

649

        return (self.proc.stdout, self.proc.stdin)

730

650

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1