Implemented channel functions, added channel tests.

Added exceptions and error code handling functions.

Author: Pan

ssh/channel.pxd

@@ -0,0 +1,27 @@
+# This file is part of ssh-python.
+# Copyright (C) 2018 Panos Kittenis
+#
+# This library 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, version 2.1.
+#
+# This library is distributed 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 this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-130
+
+from session cimport Session
+
+cimport c_ssh
+
+
+cdef class Channel:
+    cdef c_ssh.ssh_channel _channel
+    cdef Session session
+
+    @staticmethod
+    cdef Channel from_ptr(c_ssh.ssh_channel _chan, Session session)

ssh/channel.pyx

@@ -0,0 +1,312 @@
+# This file is part of ssh-python.
+# Copyright (C) 2018 Panos Kittenis
+#
+# This library 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, version 2.1.
+#
+# This library is distributed 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 this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-130
+
+from libc.stdlib cimport malloc, free
+from libc.string cimport const_char
+
+from utils cimport to_bytes, to_str, handle_ssh_error_codes, \
+    handle_ok_error_codes
+
+cimport c_ssh
+
+
+cdef class Channel:
+
+    def __cinit__(self, Session session):
+        self.session = session
+        self._channel = NULL
+
+    def __dealloc__(self):
+        if self._channel is not NULL:
+            c_ssh.ssh_channel_free(self._channel)
+            self._channel = NULL
+
+    @property
+    def session(self):
+        """The originating session for this channel."""
+        return self.session
+
+    @staticmethod
+    cdef Channel from_ptr(c_ssh.ssh_channel _chan, Session session):
+        cdef Channel chan = Channel.__new__(Channel, session)
+        chan._channel = _chan
+        return chan
+
+    def close(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_close(self._channel)
+        return handle_ssh_error_codes(rc, self.session._session)
+
+    def get_exit_status(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_get_exit_status(self._channel)
+        return rc
+
+    def get_session(self):
+        return self.session
+
+    def is_closed(self):
+        cdef bint rc
+        with nogil:
+            rc = c_ssh.ssh_channel_is_closed(self._channel)
+        return rc != 0
+
+    def is_eof(self):
+        cdef bint rc
+        with nogil:
+            rc = c_ssh.ssh_channel_is_eof(self._channel)
+        return bool(rc)
+
+    def is_open(self):
+        cdef bint rc
+        with nogil:
+            rc = c_ssh.ssh_channel_is_open(self._channel)
+        return bool(rc)
+
+    def send_eof(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_send_eof(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def request_auth_agent(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_auth_agent(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def open_auth_agent(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_open_auth_agent(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def open_forward(self, remotehost, int remoteport, sourcehost, int sourceport):
+        cdef bytes b_remotehost = to_bytes(remotehost)
+        cdef const_char *c_remotehost = b_remotehost
+        cdef bytes b_sourcehost = to_bytes(sourcehost)
+        cdef const_char *c_sourcehost = b_sourcehost
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_open_forward(
+                self._channel, c_remotehost, remoteport, c_sourcehost, sourceport)
+        return handle_ok_error_codes(rc)
+
+    def open_session(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_open_session(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def open_x11(self, sourcehost, int sourceport):
+        cdef bytes b_sourcehost = to_bytes(sourcehost)
+        cdef const_char *c_sourcehost = b_sourcehost
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_open_x11(
+                self._channel, c_sourcehost, sourceport)
+        return handle_ok_error_codes(rc)
+
+    def accept_x11(self, int timeout_ms):
+        cdef Channel chan
+        cdef c_ssh.ssh_channel _chan = NULL
+        with nogil:
+            _chan = c_ssh.ssh_channel_accept_x11(self._channel, timeout_ms)
+        if _chan is NULL:
+            raise MemoryError
+        chan = Channel.from_ptr(_chan, self.session)
+        return chan
+
+    def poll(self, bint is_stderr=False):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_poll(self._channel, is_stderr)
+        return handle_ok_error_codes(rc)
+
+    def poll_timeout(self, int timeout, bint is_stderr=False):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_poll_timeout(
+                self._channel, timeout, is_stderr)
+        return handle_ok_error_codes(rc)
+
+    def read(self, c_ssh.uint32_t size=1024, bint is_stderr=False):
+        cdef int rc
+        cdef bytes buf = b''
+        cdef char* cbuf
+        with nogil:
+            cbuf = <char *>malloc(sizeof(char)*size)
+            if cbuf is NULL:
+                with gil:
+                    raise MemoryError
+            rc = c_ssh.ssh_channel_read(self._channel, cbuf, size, is_stderr)
+        try:
+            if rc > 0:
+                buf = cbuf[:rc]
+        finally:
+            free(cbuf)
+        return handle_ok_error_codes(rc), buf
+
+    def read_nonblocking(self, c_ssh.uint32_t size=1024, bint is_stderr=False):
+        cdef int rc
+        cdef bytes buf = b''
+        cdef char* cbuf
+        with nogil:
+            cbuf = <char *>malloc(sizeof(char)*size)
+            if cbuf is NULL:
+                with gil:
+                    raise MemoryError
+            rc = c_ssh.ssh_channel_read_nonblocking(
+                self._channel, cbuf, size, is_stderr)
+        try:
+            if rc > 0:
+                buf = cbuf[:rc]
+        finally:
+            free(cbuf)
+        return handle_ok_error_codes(rc), buf
+
+    def read_timeout(self, int timeout,
+                     c_ssh.uint32_t size=1024, bint is_stderr=False):
+        cdef int rc
+        cdef bytes buf = b''
+        cdef char* cbuf
+        with nogil:
+            cbuf = <char *>malloc(sizeof(char)*size)
+            if cbuf is NULL:
+                with gil:
+                    raise MemoryError
+            rc = c_ssh.ssh_channel_read_timeout(
+                self._channel, cbuf, size, is_stderr, timeout)
+        try:
+            if rc > 0:
+                buf = cbuf[:rc]
+        finally:
+            free(cbuf)
+        return handle_ok_error_codes(rc), buf
+
+    def request_env(self, name, value):
+        cdef bytes b_name = to_bytes(name)
+        cdef const_char *c_name = b_name
+        cdef bytes b_value = to_bytes(value)
+        cdef const_char *c_value = b_value
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_env(self._channel, c_name, c_value)
+        return handle_ok_error_codes(rc)
+
+    def request_exec(self, cmd):
+        cdef bytes b_cmd = to_bytes(cmd)
+        cdef const_char *c_cmd = b_cmd
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_exec(self._channel, c_cmd)
+        return handle_ok_error_codes(rc)
+
+    def request_pty(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_pty(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def change_pty_size(self, int cols, int rows):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_change_pty_size(self._channel, cols, rows)
+        return handle_ok_error_codes(rc)
+
+    def request_pty_size(self, terminal, int col, int row):
+        cdef bytes b_terminal = to_bytes(terminal)
+        cdef const_char *c_terminal = b_terminal
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_pty_size(
+                self._channel, c_terminal, col, row)
+        return handle_ok_error_codes(rc)
+
+    def request_send_signal(self, sig):
+        cdef bytes b_sig = to_bytes(sig)
+        cdef const_char *c_sig = b_sig
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_send_signal(
+                self._channel, c_sig)
+        return handle_ok_error_codes(rc)
+
+    def request_send_break(self, c_ssh.uint32_t length):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_send_break(
+                self._channel, length)
+        return handle_ok_error_codes(rc)
+
+    def request_shell(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_shell(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def request_sftp(self):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_sftp(self._channel)
+        return handle_ok_error_codes(rc)
+
+    def request_subsystem(self, subsystem):
+        cdef bytes b_sys = to_bytes(subsystem)
+        cdef const_char *c_sys = b_sys
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_subsystem(
+                self._channel, c_sys)
+        return handle_ok_error_codes(rc)
+
+    def request_x11(self, int screen_number, bint single_connection=True):
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_request_x11(
+                self._channel, single_connection, NULL, NULL, screen_number)
+        return handle_ok_error_codes(rc)
+
+    def set_blocking(self, bint blocking):
+        with nogil:
+            c_ssh.ssh_channel_set_blocking(self._channel, blocking)
+
+    def set_counter(self, counter):
+        raise NotImplementedError
+
+    def write(self, bytes data):
+        cdef c_ssh.uint32_t size = len(data)
+        cdef const_char *c_data = data
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_write(self._channel, c_data, size)
+        return handle_ok_error_codes(rc)
+
+    def write_stderr(self, bytes data):
+        cdef c_ssh.uint32_t size = len(data)
+        cdef const_char *c_data = data
+        cdef int rc
+        with nogil:
+            rc = c_ssh.ssh_channel_write_stderr(self._channel, c_data, size)
+        return handle_ok_error_codes(rc)
+
+    def window_size(self):
+        cdef c_ssh.uint32_t size
+        with nogil:
+            size = c_ssh.ssh_channel_window_size(self._channel)
+        return size

ssh/exceptions.pyx

@@ -57,3 +57,11 @@ class KeyImportError(BaseSSHError):
 
 class KeyGenerationError(BaseSSHError):
     """Raised on errors generating key"""
+
+
+class SSHError(BaseSSHError):
+    """Raised on SSH errors"""
+
+
+class EOF(BaseSSHError):
+    """Raised on EOF errors"""

ssh/session.pyx

@@ -18,6 +18,7 @@ from cpython cimport PyObject_AsFileDescriptor
 from libc.stdlib cimport malloc, free
 from libc.string cimport const_char
 
+from channel cimport Channel
 from utils cimport to_bytes, to_str, handle_ssh_error_codes, \
     handle_auth_error_codes
 from options cimport Option
@@ -47,10 +48,13 @@ cdef class Session:
             rc = c_ssh.ssh_blocking_flush(self._session, timeout)
         return handle_ssh_error_codes(rc, self._session)
 
-    def new_channel(self):
+    def channel_new(self):
         cdef c_ssh.ssh_channel _channel
+        cdef Channel channel
         with nogil:
             _channel = c_ssh.ssh_channel_new(self._session)
+        channel = Channel.from_ptr(_channel, self)
+        return channel
 
     def connect(self):
         cdef int rc

ssh/utils.pxd

@@ -17,5 +17,6 @@
 cdef bytes to_bytes(_str)
 cdef object to_str(char *c_str)
 cdef object to_str_len(char *c_str, int length)
+cdef int handle_ok_error_codes(int errcode) except -1
 cdef int handle_ssh_error_codes(int errcode, void *caller) except -1
 cdef int handle_auth_error_codes(int errcode, void *caller) except -1