Added callbacks implementation and test.

Updated event implementation and tests.
Updated session.

Author: Pan

ssh/c_callbacks.pxd

@@ -102,6 +102,7 @@ cdef extern from "libssh/callbacks.h" nogil:
         ssh_gssapi_verify_mic_callback gssapi_verify_mic_function
     ctypedef ssh_server_callbacks_struct *ssh_server_callbacks
     int ssh_set_server_callbacks(ssh_session session, ssh_server_callbacks cb)
+    void ssh_callbacks_init(void *cb)
     struct ssh_socket_callbacks_struct:
         void *userdata
         ssh_callback_data data

ssh/callbacks.pxd

@@ -0,0 +1,21 @@
+# 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
+
+cimport c_callbacks
+
+
+cdef class Callbacks:
+    cdef c_callbacks.ssh_callbacks _cb

ssh/callbacks.pyx

@@ -0,0 +1,62 @@
+# 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 memset
+
+from session cimport Session
+from utils cimport handle_ssh_error_codes
+
+cimport c_callbacks
+# from c_ssh cimport ssh_auth_callback
+
+
+# cdef int auth_callback(const char *prompt, char *buf, size_t len,
+#                        int echo, int verify, void *userdata):
+#     # (void) verify;
+#     # (void) userdata;
+
+#     return 0
+#     # ssh_getpass(prompt, buf, len, echo, verify);
+
+
+cdef class Callbacks:
+
+    def __cinit__(self):
+        self._cb = <c_callbacks.ssh_callbacks>malloc(sizeof(c_callbacks.ssh_callbacks_struct))
+        if self._cb is NULL:
+            raise MemoryError
+        memset(self._cb, 0, sizeof(c_callbacks.ssh_callbacks_struct))
+        c_callbacks.ssh_callbacks_init(self._cb)
+        # self._cb.userdata = NULL
+        # self._cb.auth_function = NULL # <c_callbacks.ssh_auth_callback>auth_callback
+        # self._cb.log_function = NULL
+        # self._cb.connect_status_function = NULL
+        # self._cb.global_request_function = NULL
+        # self._cb.channel_open_request_x11_function = NULL
+        # self._cb.channel_open_request_auth_agent_function = NULL
+
+    def __dealloc__(self):
+        if self._cb is not NULL:
+            free(self._cb)
+            self._cb = NULL
+
+    def set_callbacks(self, Session session not None):
+        cdef int rc
+        with nogil:
+            rc = c_callbacks.ssh_set_callbacks(
+                session._session, self._cb)
+        return handle_ssh_error_codes(rc, session._session)

ssh/event.pxd

@@ -15,7 +15,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-130
 
 from session cimport Session
-from channel cimport Channel
+from connector cimport Connector
 
 cimport c_ssh
 
@@ -24,7 +24,7 @@ cdef class Event:
     cdef c_ssh.ssh_event _event
     cdef object _sock
     cdef Session session
-    cdef Channel channel
+    cdef Connector connector
 
     @staticmethod
     cdef Event from_ptr(c_ssh.ssh_event _event)

ssh/event.pyx

@@ -41,8 +41,12 @@ cdef class Event:
         return self.session
 
     @property
-    def channel(self):
-        return self.channel
+    def connector(self):
+        return self.connector
+
+    @property
+    def socket(self):
+        return self._sock
 
     @staticmethod
     cdef Event from_ptr(c_ssh.ssh_event _event):
@@ -58,16 +62,15 @@ cdef class Event:
         except Exception:
             return -1
 
-    def add_fd(self, socket, short events=0, callback=None):
-        cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(socket)
+    def add_fd(self, sock, short events, callback=None):
+        cdef c_ssh.socket_t _sock = PyObject_AsFileDescriptor(sock)
         cdef c_ssh.ssh_event_callback cb = <c_ssh.ssh_event_callback>&Event.event_callback
         cdef int rc
         cdef void *_cb = NULL if callback is None else <void *>callback
-        cb = NULL if callback is None else cb
         rc = c_ssh.ssh_event_add_fd(
             self._event, _sock, events, cb, _cb)
         if rc == 0:
-            self._sock = socket
+            self._sock = sock
         return rc
 
     def remove_fd(self, socket):
@@ -94,7 +97,7 @@ cdef class Event:
                 self._event, connector._connector)
         if rc == 0:
             self.connector = connector
-        return rc
+        return handle_ssh_error_codes(rc, connector.session._session)
 
     def dopoll(self, int timeout):
         cdef int rc
@@ -117,4 +120,4 @@ cdef class Event:
                 self._event, connector._connector)
         if rc == 0:
             self.connector = None
-        return rc
+        return handle_ssh_error_codes(rc, connector.session._session)

ssh/session.pyx

@@ -110,7 +110,7 @@ cdef class Session:
             return
         return Channel.from_ptr(_channel, self)
 
-    def cancel_forward(self, address, int port):
+    def cancel_forward(self, address not None, int port):
         cdef bytes b_address = to_bytes(address)
         cdef char *c_address = b_address
         cdef int rc
@@ -119,7 +119,7 @@ cdef class Session:
                 self._session, c_address, port)
         return handle_ssh_error_codes(rc, self._session)
 
-    def listen_forward(self, address, int port, int bound_port):
+    def listen_forward(self, address not None, int port, int bound_port):
         cdef bytes b_address = to_bytes(address)
         cdef char *c_address = b_address
         cdef int rc
@@ -338,23 +338,23 @@ cdef class Session:
             rc = c_ssh.ssh_userauth_list(self._session, NULL)
         return handle_ssh_error_codes(rc, self._session)
 
-    def userauth_try_publickey(self, SSHKey pubkey):
+    def userauth_try_publickey(self, SSHKey pubkey not None):
         cdef int rc
         with nogil:
             _check_connected(self._session)
             rc = c_ssh.ssh_userauth_try_publickey(
                 self._session, NULL, pubkey._key)
         return handle_auth_error_codes(rc, self._session)
 
-    def userauth_publickey(self, SSHKey privkey):
+    def userauth_publickey(self, SSHKey privkey not None):
         cdef int rc
         with nogil:
             _check_connected(self._session)
             rc = c_ssh.ssh_userauth_publickey(
                 self._session, NULL, privkey._key)
         return handle_auth_error_codes(rc, self._session)
 
-    def userauth_agent(self, username):
+    def userauth_agent(self, username not None):
         cdef bytes b_username = to_bytes(username)
         cdef char *c_username = b_username
         cdef int rc
@@ -363,7 +363,7 @@ cdef class Session:
             rc = c_ssh.ssh_userauth_agent(self._session, c_username)
         return handle_ssh_error_codes(rc, self._session)
 
-    def userauth_publickey_auto(self, passphrase):
+    def userauth_publickey_auto(self, passphrase not None):
         cdef bytes b_passphrase = to_bytes(passphrase)
         cdef char *c_passphrase = b_passphrase
         cdef int rc
@@ -373,7 +373,7 @@ cdef class Session:
                 self._session, NULL, c_passphrase)
         return handle_ssh_error_codes(rc, self._session)
 
-    def userauth_password(self, username, password):
+    def userauth_password(self, username not None, password not None):
         cdef bytes b_username = to_bytes(username)
         cdef bytes b_password = to_bytes(password)
         cdef char *c_username = b_username
@@ -385,7 +385,7 @@ cdef class Session:
                 self._session, c_username, c_password)
         return handle_ssh_error_codes(rc, self._session)
 
-    def userauth_kbdint(self, username, submethods):
+    def userauth_kbdint(self, username not None, submethods not None):
         cdef bytes b_username = to_bytes(username)
         cdef bytes b_submethods = to_bytes(submethods)
         cdef char *c_username = b_username

ssh/utils.pxd

@@ -14,9 +14,11 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
+from c_ssh cimport ssh_session
+
 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
+cdef int handle_ssh_error_codes(int errcode, ssh_session) except -1
+cdef int handle_auth_error_codes(int errcode, ssh_session) except -1

ssh/utils.pyx

@@ -17,7 +17,7 @@
 from cpython.version cimport PY_MAJOR_VERSION
 
 from c_ssh cimport ssh_error_types_e, ssh_get_error, ssh_auth_e, \
-    SSH_OK, SSH_ERROR, SSH_AGAIN, SSH_EOF
+    SSH_OK, SSH_ERROR, SSH_AGAIN, SSH_EOF, ssh_session
 
 from exceptions import RequestDenied, FatalError, OtherError, \
     AuthenticationPartial, AuthenticationDenied, AuthenticationError, \
@@ -63,31 +63,31 @@ cdef int handle_ok_error_codes(int errcode) except -1:
         return errcode
 
 
-cdef int handle_ssh_error_codes(int errcode, void *caller) except -1:
+cdef int handle_ssh_error_codes(int errcode, ssh_session session) except -1:
     if errcode == ssh_error_types_e.SSH_NO_ERROR:
         return 0
     elif errcode == ssh_error_types_e.SSH_REQUEST_DENIED:
-        raise RequestDenied(ssh_get_error(caller))
+        raise RequestDenied(ssh_get_error(session))
     elif errcode == ssh_error_types_e.SSH_FATAL:
-        raise FatalError(ssh_get_error(caller))
+        raise FatalError(ssh_get_error(session))
     else:
         if errcode < 0:
-            raise OtherError(ssh_get_error(caller))
+            raise OtherError(ssh_get_error(session))
         return errcode
 
 
-cdef int handle_auth_error_codes(int errcode, void *caller) except -1:
+cdef int handle_auth_error_codes(int errcode, ssh_session session) except -1:
     if errcode == ssh_auth_e.SSH_AUTH_SUCCESS:
         return ssh_auth_e.SSH_AUTH_SUCCESS
     elif errcode == ssh_auth_e.SSH_AUTH_DENIED:
-        raise AuthenticationDenied(ssh_get_error(caller))
+        raise AuthenticationDenied(ssh_get_error(session))
     elif errcode == ssh_auth_e.SSH_AUTH_ERROR:
-        raise AuthenticationError(ssh_get_error(caller))
+        raise AuthenticationError(ssh_get_error(session))
     elif errcode == ssh_auth_e.SSH_AUTH_PARTIAL:
-        raise AuthenticationPartial(ssh_get_error(caller))
+        raise AuthenticationPartial(ssh_get_error(session))
     elif errcode == ssh_auth_e.SSH_AUTH_AGAIN:
         return ssh_auth_e.SSH_AUTH_AGAIN
     else:
         if errcode < 0:
-            raise OtherError(ssh_get_error(caller))
+            raise OtherError(ssh_get_error(session))
         return errcode

tests/base_test.py

@@ -60,7 +60,7 @@ def setUp(self):
         self.session.options_set_port(self.port)
         self.session.options_set(options.USER, self.user)
         self.pkey = import_privkey_file(self.user_key)
-        self.session.options_set(options.LOG_VERBOSITY, '1')
+        # self.session.options_set(options.LOG_VERBOSITY, '1')
 
     def tearDown(self):
         del self.session

tests/test_event.py

@@ -22,8 +22,17 @@
 from ssh.session import Session
 from ssh import options
 from ssh.event import Event
+from ssh.callbacks import Callbacks
 from ssh.connector import CONNECTOR_STDOUT, CONNECTOR_STDERR, \
     CONNECTOR_BOTH
+from ssh.exceptions import OtherError
+
+
+class CallbacksTest(SSHTestCase):
+
+    def test_callbacks(self):
+        cb = Callbacks()
+        self.assertEqual(cb.set_callbacks(self.session), 0)
 
 
 class EventTest(SSHTestCase):
@@ -39,22 +48,15 @@ def test_event_session(self):
 
     def test_event_connector(self):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.connect((self.host, self.port))
-        session = Session()
-        session.options_set(options.USER, self.user)
-        session.options_set(options.HOST, self.host)
-        session.options_set_port(self.port)
-        self.assertEqual(session.set_socket(sock), 0)
-        self.assertEqual(session.connect(), 0)
-        self.assertEqual(
-            session.userauth_publickey(self.pkey), 0)
-        
         event = Event()
-        connector = session.connector_new()
-        chan = session.channel_new()
-        connector.set_in_channel(chan, CONNECTOR_STDOUT)
-        connector.set_out_fd(sock)
-        self.assertEqual(event.add_connector(connector), 0)
-        # self.assertEqual(connector, event.connector)
-        # self.assertEqual(event.remove_connector(connector), 0)
-        # self.assertIsNone(event.connector)
+        self.assertEqual(event.add_fd(sock, 1), 0)
+        self.assertEqual(sock, event.socket)
+        self.assertEqual(event.remove_fd(sock), 0)
+        self.assertIsNone(event.socket)
+        self.assertEqual(event.add_fd(sock, 1, callback=lambda: 1), 0)
+        connector = self.session.connector_new()
+        self.assertIsNone(event.connector)
+        self.assertRaises(OtherError, event.add_connector, connector)
+        self.assertIsNone(event.connector)
+        self.assertEqual(event.remove_connector(connector), 0)
+        self.assertIsNone(event.connector)