+.tox/

+docs/

+ channels: "irc.freenode.org#paramiko"

+docs: paramiko/*

+v1.10.0 (DD MM YYYY)

+--------------------

+

+* #110: Honor SSH config `AddressFamily` setting when looking up local

+ host's FQDN. Thanks to John Hensley for the patch.

+* #128: Defer FQDN resolution until needed, when parsing SSH config files.

+ Thanks to Parantapa Bhattacharya for catch & patch.

+* #102: Forego random padding for packets when running under `*-ctr` ciphers.

+ This corrects some slowdowns on platforms where random byte generation is

+ inefficient (e.g. Windows). Thanks to `@warthog618` for catch & patch, and

+ Michael van der Kolff for code/technique review.

+* #127: Turn `SFTPFile` into a context manager. Thanks to Michael Williamson

+* for the patch.

+* #116: Limit `Message.get_bytes` to an upper bound of 1MB to protect against

+ potential DoS vectors. Thanks to `@mvschaik` for catch & patch.

+* #115: Add convenience `get_pty` kwarg to `Client.exec_command` so users not

+ manually controlling a channel object can still toggle PTY creation. Thanks

+ to Michael van der Kolff for the patch.

+* #71: Add `SFTPClient.putfo` and `.getfo` methods to allow direct

+ uploading/downloading of file-like objects. Thanks to Eric Buehl for the

+ patch.

+* #113: Add `timeout` parameter to `SSHClient.exec_command` for easier setting

+ of the command's internal channel object's timeout. Thanks to Cernov Vladimir

+ for the patch.

+* #94: Remove duplication of SSH port constant. Thanks to Olle Lundberg for the

+ catch.

+* #80: Expose the internal "is closed" property of the file transfer class

+ `BufferedFile` as `.closed`, better conforming to Python's file interface.

+ Thanks to `@smunaut` and James Hiscock for catch & patch.

+

+v1.9.0 (6th Nov 2012)

+---------------------

+

+* #97 (with a little #93): Improve config parsing of `ProxyCommand` directives

+ and provide a wrapper class to allow subprocess-driven proxy commands to be

+ used as `sock=` arguments for `SSHClient.connect`.

+* #77: Allow `SSHClient.connect()` to take an explicit `sock` parameter

+ overriding creation of an internal, implicit socket object.

+* Thanks in no particular order to Erwin Bolwidt, Oskari Saarenmaa, Steven

+ Noonan, Vladimir Lazarenko, Lincoln de Sousa, Valentino Volonghi, Olle

+ Lundberg, and Github user `@acrish` for the various and sundry patches

+ leading to the above changes.

+

+v1.8.1 (6th Nov 2012)

+---------------------

+

+* #90: Ensure that callbacks handed to `SFTPClient.get()` always fire at least

+ once, even for zero-length files downloaded. Thanks to Github user `@enB` for

+ the catch.

+* #85: Paramiko's test suite overrides

+ `unittest.TestCase.assertTrue/assertFalse` to provide these modern assertions

+ to Python 2.2/2.3, which lacked them. However on newer Pythons such as 2.7,

+ this now causes deprecation warnings. The overrides have been patched to only

+ execute when necessary. Thanks to `@Arfrever` for catch & patch.

+

+

+v1.8.0 (3rd Oct 2012)

+---------------------

+* #17 ('ssh' 28): Fix spurious `NoneType has no attribute 'error'` and similar

+ exceptions that crop up on interpreter exit.

+:Copyright: Copyright (c) 2013 Jeff Forcier <jeff@bitprophet.org>

+"friend". it's a module for python 2.5+ that implements the SSH2 protocol

+ - python 2.5 or better <http://www.python.org/>

+from fabric.api import task, sudo, env

+from fabric.contrib.project import rsync_project

+

+

+@task

+def upload_docs():

+ target = "/var/www/paramiko.org"

+ staging = "/tmp/paramiko_docs"

+ sudo("mkdir -p %s" % staging)

+ sudo("chown -R %s %s" % (env.user, staging))

+ sudo("rm -rf %s/*" % target)

+ rsync_project(local_dir='docs/', remote_dir=staging, delete=True)

+ sudo("cp -R %s/* %s/" % (staging, target))

+is a module for python 2.5 or greater that implements the SSH2 protocol for

+if sys.version_info < (2, 5):

+ raise RuntimeError('You need python 2.5+ for this module.')

+__version__ = "1.10.0"

+ AuthenticationException, ProxyCommandFailure

+from proxy import ProxyCommand

+ 'ProxyCommand',

+ 'ProxyCommandFailure',

+from paramiko.config import SSH_PORT

+ compress=False, sock=None):

+ @param sock: an open socket or socket-like object (such as a

+ L{Channel}) to use for communication to the target host

+ @type sock: socket

+ if not sock:

+ for (family, socktype, proto, canonname, sockaddr) in socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM):

+ if socktype == socket.SOCK_STREAM:

+ af = family

+ addr = sockaddr

+ break

+ else:

+ # some OS like AIX don't indicate SOCK_STREAM support, so just guess. :(

+ af, _, _, _, addr = socket.getaddrinfo(hostname, port, socket.AF_UNSPEC, socket.SOCK_STREAM)

+ sock = socket.socket(af, socket.SOCK_STREAM)

+ if timeout is not None:

+ try:

+ sock.settimeout(timeout)

+ except:

+ pass

+ retry_on_signal(lambda: sock.connect(addr))

+

+ def exec_command(self, command, bufsize=-1, timeout=None, get_pty=False):

+ @param timeout: set command's channel timeout. See L{Channel.settimeout}.settimeout

+ @type timeout: int

+ if(get_pty):

+ chan.get_pty()

+ chan.settimeout(timeout)

+proxy_re = re.compile(r"^(proxycommand)\s*=*\s*(.*)", re.I)

+class LazyFqdn(object):

+ """

+ Returns the host's fqdn on request as string.

+ """

+

+ def __init__(self, config):

+ self.fqdn = None

+ self.config = config

+

+ def __str__(self):

+ if self.fqdn is None:

+ #

+ # If the SSH config contains AddressFamily, use that when

+ # determining the local host's FQDN. Using socket.getfqdn() from

+ # the standard library is the most general solution, but can

+ # result in noticeable delays on some platforms when IPv6 is

+ # misconfigured or not available, as it calls getaddrinfo with no

+ # address family specified, so both IPv4 and IPv6 are checked.

+ #

+

+ # Handle specific option

+ fqdn = None

+ address_family = self.config.get('addressfamily', 'any').lower()

+ if address_family != 'any':

+ family = socket.AF_INET if address_family == 'inet' \

+ else socket.AF_INET6

+ results = socket.getaddrinfo(host,

+ None,

+ family,

+ socket.SOCK_DGRAM,

+ socket.IPPROTO_IP,

+ socket.AI_CANONNAME)

+ for res in results:

+ af, socktype, proto, canonname, sa = res

+ if canonname and '.' in canonname:

+ fqdn = canonname

+ break

+ # Handle 'any' / unspecified

+ if fqdn is None:

+ fqdn = socket.getfqdn()

+ # Cache

+ self.fqdn = fqdn

+ return self.fqdn

+

+ # Ensure ProxyCommand gets properly split

+ if line.lower().strip().startswith('proxycommand'):

+ match = proxy_re.match(line)

+ key, value = match.group(1).lower(), match.group(2)

+ else:

+ fqdn = LazyFqdn(config)

+

+ @property

+ def closed(self):

+ return self._closed

+

+ max_pad_size = 1<<20 # Limit padding to 1 MB

+ if len(b) < n and n < max_pad_size:

+from paramiko.ssh_exception import SSHException, ProxyCommandFailure

+ self.__sdctr_out = False

+ def set_outbound_cipher(self, block_engine, block_size, mac_engine, mac_size, mac_key, sdctr=False):

+ self.__sdctr_out = sdctr

+ except ProxyCommandFailure:

+ raise # so it doesn't get swallowed by the below catchall

+ if self.__sdctr_out or self.__block_engine_out is None:

+ # cute trick i caught openssh doing: if we're not encrypting or SDCTR mode (RFC4344),

+ else:

+ packet += rng.read(padding)

+# Copyright (C) 2012 Yipit, Inc <coders@yipit.com>

+#

+# This file is part of paramiko.

+#

+# Paramiko is free software; you can redistribute it and/or modify it under the

+# terms of the GNU Lesser General Public License as published by the Free

+# Software Foundation; either version 2.1 of the License, or (at your option)

+# any later version.

+#

+# Paramiko is distrubuted in the hope that it will be useful, but WITHOUT ANY

+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

+# A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more

+# details.

+#

+# You should have received a copy of the GNU Lesser General Public License

+# along with Paramiko; if not, write to the Free Software Foundation, Inc.,

+# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

+

+"""

+L{ProxyCommand}.

+"""

+

+import os

+from shlex import split as shlsplit

+import signal

+from subprocess import Popen, PIPE

+

+from paramiko.ssh_exception import ProxyCommandFailure

+

+

+class ProxyCommand(object):

+ """

+ Wraps a subprocess running ProxyCommand-driven programs.

+

+ This class implements a the socket-like interface needed by the

+ L{Transport} and L{Packetizer} classes. Using this class instead of a

+ regular socket makes it possible to talk with a Popen'd command that will

+ proxy traffic between the client and a server hosted in another machine.

+ """

+ def __init__(self, command_line):

+ """

+ Create a new CommandProxy instance. The instance created by this

+ class can be passed as an argument to the L{Transport} class.

+

+ @param command_line: the command that should be executed and

+ used as the proxy.

+ @type command_line: str

+ """

+ self.cmd = shlsplit(command_line)

+ self.process = Popen(self.cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)

+

+ def send(self, content):

+ """

+ Write the content received from the SSH client to the standard

+ input of the forked command.

+

+ @param content: string to be sent to the forked command

+ @type content: str

+ """

+ try:

+ self.process.stdin.write(content)

+ except IOError, e:

+ # There was a problem with the child process. It probably

+ # died and we can't proceed. The best option here is to

+ # raise an exception informing the user that the informed

+ # ProxyCommand is not working.

+ raise BadProxyCommand(' '.join(self.cmd), e.strerror)

+ return len(content)

+

+ def recv(self, size):

+ """

+ Read from the standard output of the forked program.

+

+ @param size: how many chars should be read

+ @type size: int

+

+ @return: the length of the read content

+ @rtype: int

+ """

+ try:

+ return os.read(self.process.stdout.fileno(), size)

+ except IOError, e:

+ raise BadProxyCommand(' '.join(self.cmd), e.strerror)

+

+ def close(self):

+ os.kill(self.process.pid, signal.SIGTERM)

+

+ def settimeout(self, timeout):

+ # Timeouts are meaningless for this implementation, but are part of the

+ # spec, so must be present.

+ pass

+ object, including the ability to be used as a context manager.

+ def putfo(self, fl, remotepath, file_size=0, callback=None, confirm=True):

+ """

+ Copy the contents of an open file object (C{fl}) to the SFTP server as

+ C{remotepath}. Any exception raised by operations will be passed through.

+

+ The SFTP operations use pipelining for speed.

+

+ @param fl: opened file or file-like object to copy

+ @type localpath: object

+ @param remotepath: the destination path on the SFTP server

+ @type remotepath: str

+ @param file_size: optional size parameter passed to callback. If none is

+ specified, size defaults to 0

+ @type file_size: int

+ @param callback: optional callback function that accepts the bytes

+ transferred so far and the total bytes to be transferred

+ (since 1.7.4)

+ @type callback: function(int, int)

+ @param confirm: whether to do a stat() on the file afterwards to

+ confirm the file size (since 1.7.7)

+ @type confirm: bool

+

+ @return: an object containing attributes about the given file

+ (since 1.7.4)

+ @rtype: SFTPAttributes

+

+ @since: 1.4

+ """

+ fr = self.file(remotepath, 'wb')

+ fr.set_pipelined(True)

+ size = 0

+ try:

+ while True:

+ data = fl.read(32768)

+ fr.write(data)

+ size += len(data)

+ if callback is not None:

+ callback(size, file_size)

+ if len(data) == 0:

+ break

+ finally:

+ fr.close()

+ if confirm and file_size:

+ s = self.stat(remotepath)

+ if s.st_size != size:

+ raise IOError('size mismatch in put! %d != %d' % (s.st_size, size))

+ else:

+ s = SFTPAttributes()

+ return s

+

+ return self.putfo(fl, remotepath, os.stat(localpath).st_size, callback, confirm)

+

+ def getfo(self, remotepath, fl, callback=None):

+ """

+ Copy a remote file (C{remotepath}) from the SFTP server and write to

+ an open file or file-like object, C{fl}. Any exception raised by

+ operations will be passed through. This method is primarily provided

+ as a convenience.

+

+ @param remotepath: opened file or file-like object to copy to

+ @type remotepath: object

+ @param fl: the destination path on the local host or open file

+ object

+ @type localpath: str

+ @param callback: optional callback function that accepts the bytes

+ transferred so far and the total bytes to be transferred

+ (since 1.7.4)

+ @type callback: function(int, int)

+ @return: the number of bytes written to the opened file object

+

+ @since: 1.4

+ """

+ fr = self.file(remotepath, 'rb')

+ file_size = self.stat(remotepath).st_size

+ fr.prefetch()

+ try:

+ size = 0

+ while True:

+ data = fr.read(32768)

+ fl.write(data)

+ size += len(data)

+ if callback is not None:

+ callback(size, file_size)

+ if len(data) == 0:

+ break

+ finally:

+ fr.close()

+ return size

+ fl = file(localpath, 'wb')

+ size = self.getfo(remotepath, fl, callback)

+ fl.close()

+

+ Instances of this class may be used as context managers in the same way

+ that built-in Python file objects are.

+

+ def __enter__(self):

+ return self

+

+ def __exit__(self, type, value, traceback):

+ self.close()

+

+class ProxyCommandFailure (SSHException):

+ """

+ The "ProxyCommand" found in the .ssh/config file returned an error.

+

+ @ivar command: The command line that is generating this exception.

+ @type command: str

+ @ivar error: The error captured from the proxy command output.

+ @type error: str

+ """

+ def __init__(self, command, error):

+ SSHException.__init__(self,

+ '"ProxyCommand (%s)" returned non-zero exit status: %s' % (

+ command, error

+ )

+ )

+ self.error = error

+from paramiko.ssh_exception import (SSHException, BadAuthenticationType,

+ ChannelException, ProxyCommandFailure)

+ except ProxyCommandFailure:

+ raise

+ sdctr = self.local_cipher.endswith('-ctr')

+ self.packetizer.set_outbound_cipher(engine, block_size, mac_engine, mac_size, mac_key, sdctr)

+pycrypto

+tox

+ version = "1.10.0",

+from util import ParamikoTest

+

+class BufferedPipeTest(ParamikoTest):

+from __future__ import with_statement

+

+ def test_3_sftp_file_can_be_used_as_context_manager(self):

+ """

+ verify that an opened file can be used as a context manager

+ """

+ try:

+ with sftp.open(FOLDER + '/duck.txt', 'w') as f:

+ f.write(ARTICLE)

+ self.assertEqual(sftp.stat(FOLDER + '/duck.txt').st_size, 1483)

+ finally:

+ sftp.remove(FOLDER + '/duck.txt')

+

+from util import ParamikoTest

+class TransportTest(ParamikoTest):

+from paramiko.util import lookup_ssh_host_config as host_config

+from util import ParamikoTest

+class UtilTest(ParamikoTest):

+ def test_9_proxycommand_config_equals_parsing(self):

+ """

+ ProxyCommand should not split on equals signs within the value.

+ """

+ conf = """

+Host space-delimited

+ ProxyCommand foo bar=biz baz

+

+Host equals-delimited

+ ProxyCommand=foo bar=biz baz

+"""

+ f = cStringIO.StringIO(conf)

+ config = paramiko.util.parse_ssh_config(f)

+ for host in ('space-delimited', 'equals-delimited'):

+ self.assertEquals(

+ host_config(host, config)['proxycommand'],

+ 'foo bar=biz baz'

+ )

+

+ def test_10_proxycommand_interpolation(self):

+ """

+ ProxyCommand should perform interpolation on the value

+ """

+ config = paramiko.util.parse_ssh_config(cStringIO.StringIO("""

+Host specific

+ Port 37

+ ProxyCommand host %h port %p lol

+

+Host portonly

+ Port 155

+

+Host *

+ Port 25

+ ProxyCommand host %h port %p

+"""))

+ for host, val in (

+ ('foo.com', "host foo.com port 25"),

+ ('specific', "host specific port 37 lol"),

+ ('portonly', "host portonly port 155"),

+ ):

+ self.assertEquals(

+ host_config(host, config)['proxycommand'],

+ val

+ )

+

+ def test_11_host_config_test_negation(self):

+ def test_12_host_config_test_proxycommand(self):

+import unittest

+

+

+class ParamikoTest(unittest.TestCase):

+ # for Python 2.3 and below

+ if not hasattr(unittest.TestCase, 'assertTrue'):

+ assertTrue = unittest.TestCase.failUnless

+ if not hasattr(unittest.TestCase, 'assertFalse'):

+ assertFalse = unittest.TestCase.failIf

+

+[tox]

+envlist = py25,py26,py27

+

+[testenv]

+commands = pip install --use-mirrors -q -r requirements.txt

+ python test.py