Added sftp write implementation and tests.

Added sftp attribute setting and tests. Added sftp exceptions.

Author: Pan

ssh/exceptions.pyx

@@ -155,5 +155,9 @@ class ResourceShortage(BaseSSHError):
     """Raised on resource shortage errors"""
 
 
-class SFTPHandleError(BaseSSHError):
-    """Raised on errors SFTP handle errors"""
+class SFTPError(BaseSSHError):
+    """Raised on SFTP errors"""
+
+
+class SFTPHandleError(SFTPError):
+    """Raised on SFTP handle errors"""

ssh/sftp_attributes.pxd

@@ -22,6 +22,7 @@ cimport c_sftp
 cdef class SFTPAttributes:
     cdef c_sftp.sftp_attributes _attrs
     cdef SFTP sftp
+    cdef bint self_made
 
     @staticmethod
     cdef SFTPAttributes from_ptr(c_sftp.sftp_attributes attrs, SFTP sftp)

ssh/sftp_attributes.pyx

@@ -20,18 +20,22 @@ from sftp cimport SFTP
 from utils cimport ssh_string_to_bytes
 
 cimport c_sftp
-from c_ssh cimport ssh_string
+from c_ssh cimport ssh_string, uint8_t, uint32_t, uint64_t
 
 
 cdef class SFTPAttributes:
 
     def __cinit__(self, SFTP sftp):
         self.sftp = sftp
+        self.self_made = False
 
     def __dealloc__(self):
-        if self._attrs is not NULL:
+        if self._attrs is not NULL and not self.self_made:
             c_sftp.sftp_attributes_free(self._attrs)
             self._attrs = NULL
+        elif self._attrs is not NULL and self.self_made:
+            free(self._attrs)
+            self._attrs = NULL
 
     @staticmethod
     cdef SFTPAttributes from_ptr(c_sftp.sftp_attributes attrs, SFTP sftp):
@@ -42,13 +46,38 @@ cdef class SFTPAttributes:
 
     @staticmethod
     def new_attrs(SFTP sftp):
+        cdef SFTPAttributes attrs
         cdef c_sftp.sftp_attributes _attrs
         with nogil:
             _attrs = <c_sftp.sftp_attributes>malloc(
                 sizeof(c_sftp.sftp_attributes_struct))
         if _attrs is NULL:
             raise MemoryError
-        return SFTPAttributes.from_ptr(_attrs, sftp)
+        _attrs.name = b''
+        _attrs.longname = b''
+        _attrs.flags = 0
+        _attrs.type = 0
+        _attrs.size = 0
+        _attrs.uid = 0
+        _attrs.gid = 0
+        _attrs.owner = b''
+        _attrs.group = b''
+        _attrs.permissions = 0
+        _attrs.atime64 = 0
+        _attrs.atime = 0
+        _attrs.atime_nseconds = 0
+        _attrs.createtime = 0
+        _attrs.createtime_nseconds = 0
+        _attrs.mtime64 = 0
+        _attrs.mtime = 0
+        _attrs.mtime_nseconds = 0
+        _attrs.acl = NULL
+        _attrs.extended_count = 0
+        _attrs.extended_type = NULL
+        _attrs.extended_data = NULL
+        attrs = SFTPAttributes.from_ptr(_attrs, sftp)
+        attrs.self_made = True
+        return attrs
 
     @property
     def name(self):
@@ -68,22 +97,42 @@ cdef class SFTPAttributes:
     def flags(self):
         return self._attrs.flags if self._attrs is not NULL else None
 
+    @flags.setter
+    def flags(self, uint32_t flags):
+        self._attrs.flags = flags
+
     @property
     def type(self):
         return self._attrs.type if self._attrs is not NULL else None
 
+    @type.setter
+    def type(self, uint8_t _type):
+        self._attrs.type = _type
+
     @property
     def size(self):
         return self._attrs.size if self._attrs is not NULL else None
 
+    @size.setter
+    def size(self, uint64_t size):
+        self._attrs.size = size
+
     @property
     def uid(self):
         return self._attrs.uid if self._attrs is not NULL else None
 
+    @uid.setter
+    def uid(self, uint32_t uid):
+        self._attrs.uid = uid
+
     @property
     def gid(self):
         return self._attrs.gid if self._attrs is not NULL else None
 
+    @gid.setter
+    def gid(self, uint32_t gid):
+        self._attrs.gid = gid
+
     @property
     def owner(self):
         if self._attrs is NULL:
@@ -104,38 +153,74 @@ cdef class SFTPAttributes:
     def permissions(self):
         return self._attrs.permissions if self._attrs is not NULL else None
 
+    @permissions.setter
+    def permissions(self, uint32_t permissions):
+        self._attrs.permissions = permissions
+
     @property
     def atime64(self):
         return self._attrs.atime64 if self._attrs is not NULL else None
 
+    @atime64.setter
+    def atime64(self, uint64_t atime):
+        self._attrs.atime64 = atime
+
     @property
     def atime(self):
         return self._attrs.atime if self._attrs is not NULL else None
 
+    @atime.setter
+    def atime(self, uint32_t atime):
+        self._attrs.atime = atime
+
     @property
     def atime_nseconds(self):
         return self._attrs.atime_nseconds if self._attrs is not NULL else None
 
+    @atime_nseconds.setter
+    def atime_nseconds(self, uint32_t nseconds):
+        self._attrs.atime_nseconds = nseconds
+
     @property
     def createtime(self):
         return self._attrs.createtime if self._attrs is not NULL else None
 
+    @createtime.setter
+    def createtime(self, uint64_t createtime):
+        self._attrs.createtime = createtime
+
     @property
     def createtime_nseconds(self):
         return self._attrs.createtime_nseconds if self._attrs is not NULL else None
 
+    @createtime_nseconds.setter
+    def createtime_nseconds(self, uint32_t nseconds):
+        self._attrs.createtime_nseconds = nseconds
+
     @property
     def mtime64(self):
         return self._attrs.mtime64 if self._attrs is not NULL else None
 
+    @mtime64.setter
+    def mtime64(self, uint64_t mtime):
+        self._attrs.mtime64 = mtime
+
     @property
     def mtime(self):
         return self._attrs.mtime if self._attrs is not NULL else None
 
+    @mtime.setter
+    def mtime(self, uint32_t mtime):
+        self._attrs.mtime = mtime
+
     @property
     def mtime_nseconds(self):
         return self._attrs.mtime_nseconds if self._attrs is not NULL else None
 
+    @mtime_nseconds.setter
+    def mtime_nseconds(self, uint32_t nseconds):
+        self._attrs.mtime_nseconds = nseconds
+
     @property
     def acl(self):
         if self._attrs is NULL:
@@ -146,6 +231,10 @@ cdef class SFTPAttributes:
     def extended_count(self):
         return self._attrs.extended_count if self._attrs is not NULL else None
 
+    @extended_count.setter
+    def extended_count(self, uint32_t count):
+        self._attrs.extended_count = count
+
     @property
     def extended_type(self):
         if self._attrs is NULL:

ssh/sftp_handles.pxd

@@ -23,7 +23,7 @@ cimport c_sftp
 cdef class SFTPFile:
     cdef c_sftp.sftp_file _file
     cdef SFTP sftp
-    cdef bint closed
+    cdef readonly bint closed
 
     @staticmethod
     cdef SFTPFile from_ptr(c_sftp.sftp_file _file, SFTP sftp)

ssh/sftp_handles.pyx

@@ -17,10 +17,11 @@
 from libc.stdlib cimport malloc, free
 
 from sftp_attributes cimport SFTPAttributes
+from sftp_statvfs cimport SFTPStatVFS
 
-from .exceptions import SFTPHandleError
+from .exceptions import SFTPError, SFTPHandleError
 
-from c_ssh cimport uint32_t, uint64_t, ssh_get_error
+from c_ssh cimport uint32_t, uint64_t, ssh_get_error, SSH_ERROR, SSH_AGAIN
 cimport c_sftp
 
 
@@ -87,52 +88,116 @@ cdef class SFTPFile:
         with nogil:
             c_sftp.sftp_file_set_blocking(self._file)
 
-    def read(self, size_t count=1024000):
-        cdef ssize_t size
+    def read(self, size_t size=1048576):
+        cdef ssize_t _size
         cdef bytes buf = b''
         cdef char *c_buf
         with nogil:
-            c_buf = <char *>malloc(sizeof(char) * count)
+            c_buf = <char *>malloc(sizeof(char) * size)
             if c_buf is NULL:
                 with gil:
                     raise MemoryError
-            size = c_sftp.sftp_read(self._file, c_buf, count)
+            _size = c_sftp.sftp_read(self._file, c_buf, size)
+        try:
+            if _size > 0:
+                buf = c_buf[:_size]
+        finally:
+            free(c_buf)
+        return _size, buf
+
+    def async_read_begin(self, uint32_t length=1048576):
+        cdef int rc
+        with nogil:
+            rc = c_sftp.sftp_async_read_begin(self._file, length)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
+
+    def async_read(self, uint32_t _id, uint32_t length=1048576):
+        cdef int size
+        cdef bytes buf = b''
+        cdef char *c_buf
+        with nogil:
+            c_buf = <char *>malloc(sizeof(char) * length)
+            if c_buf is NULL:
+                with gil:
+                    raise MemoryError
+            size = c_sftp.sftp_async_read(self._file, c_buf, length, _id)
         try:
             if size > 0:
                 buf = c_buf[:size]
+            elif size < 0:
+                if size == SSH_ERROR:
+                    raise SFTPError(ssh_get_error(self.sftp.session._session))
+                elif size == SSH_AGAIN:
+                    return SSH_AGAIN
         finally:
             free(c_buf)
         return size, buf
 
-    def async_read_begin(self, uint32_t length=1024000):
-        pass
-
-    def async_read(self, uint32_t length, uint32_t, _id):
-        pass
-
-    def write(self, size_t count=1024000):
-        pass
+    def write(self, bytes data):
+        cdef ssize_t rc
+        cdef const char *c_data = data
+        cdef size_t data_len = len(data)
+        with nogil:
+            rc = c_sftp.sftp_write(self._file, c_data, data_len)
+        if rc < 0:
+            raise SFTPError(ssh_get_error(self.sftp.session._session))
+        return rc
 
     def seek(self, uint32_t offset):
-        pass
+        cdef int rc
+        with nogil:
+            rc = c_sftp.sftp_seek(self._file, offset)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
 
     def seek64(self, uint64_t offset):
-        pass
+        cdef int rc
+        with nogil:
+            rc = c_sftp.sftp_seek64(self._file, offset)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
 
     def tell(self):
-        pass
+        cdef unsigned long rc
+        with nogil:
+            rc = c_sftp.sftp_tell(self._file)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
 
     def tell64(self):
-        pass
+        cdef uint64_t rc
+        with nogil:
+            rc = c_sftp.sftp_tell64(self._file)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
 
     def rewind(self):
-        pass
+        with nogil:
+            c_sftp.sftp_rewind(self._file)
 
     def fstatvfs(self):
-        pass
+        cdef SFTPStatVFS vfs
+        cdef c_sftp.sftp_statvfs_t c_vfs
+        with nogil:
+            c_vfs = c_sftp.sftp_fstatvfs(self._file)
+        if c_vfs is NULL:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        vfs = SFTPStatVFS.from_ptr(c_vfs, self.sftp)
+        return vfs
 
     def fsync(self):
-        pass
+        cdef int rc
+        with nogil:
+            rc = c_sftp.sftp_fsync(self._file)
+        if rc < 0:
+            raise SFTPHandleError(ssh_get_error(self.sftp.session._session))
+        return rc
 
 
 cdef class SFTPDir: