# Copyright (c) 2000-2006 ActiveState Software Inc.
# See the file LICENSE.txt for licensing information.

# An implementation of a secure ftp file object for Komodo
#
# This uses "paramiko", a pure python implementation of the 
# SSH2 protocol, of which, we are using the SFTP component.
# http://www.lag.net/paramiko/
#
# Contributors:
# * Todd Whiteman

import os
import socket
import logging

from xpcom import components, ServerException, nsError

# remote file library
import remotefilelib
# needed for SFTP
import paramiko


log = logging.getLogger('koSFTPConnection')
#log.setLevel(logging.DEBUG)


# URI handler
class SFTPURI:
    _com_interfaces_ = components.interfaces.nsIProtocolHandler
    _reg_contractid_ = '@mozilla.org/network/protocol;1?name=sftp'
    _reg_clsid_ = '{b7b16573-c158-4546-91be-f4324de9dcfb}'
    _reg_desc_ = "SFTP handler"

    scheme = "sftp"
    defaultPort = 22
    protocolFlags = components.interfaces.nsIProtocolHandler.URI_STD

    def __init__(self):
        pass

    def newURI(self, aSpec, aOriginCharset, aBaseURI):
        url = components.classes["@mozilla.org/network/standard-url;1"].\
                 createInstance(components.interfaces.nsIStandardURL)
        url.init(components.interfaces.nsIStandardURL.URLTYPE_AUTHORITY,
                 self.defaultPort, aSpec, aOriginCharset, aBaseURI)
        return url.QueryInterface(components.interfaces.nsIURI)

    def newChannel(self, aURI):
        raise ServerException(nsError.NS_ERROR_NOT_IMPLEMENTED)

    def allowPort(self, port, scheme):
        return True


# Connection handler
class koSFTPConnection(remotefilelib.koRemoteSSH):
    _com_interfaces_ = [components.interfaces.koISSHConnection]
    _reg_desc_ = "Komodo SFTP Connection"
    _reg_contractid_ = "@activestate.com/koSFTPConnection;1"
    _reg_clsid_ = "{0a29b026-b0cb-4316-a0ea-23f890c7e8be}"

    # SFTP Exceptions caught and handled
    _SFTPExceptions = (paramiko.SFTPError, IOError, socket.timeout)

    def __init__(self):
        remotefilelib.koRemoteSSH.__init__(self)
        self.log = log
        self.log.debug('__init__()')
        self.protocol = 'sftp'
        self.port = remotefilelib.koRFProtocolDefaultPort[self.protocol]
        self._sftp = None
        # Private, set to the first directory where we log into
        # This is because sftp does not support "~" names.
        self._homedirectory = None

    def __del__(self):
        # Ensure we are closed properly
        self.do_close()
        if self._sftp:
            del self._sftp
        if self._connection:
            del self._connection
        self.log.debug("__del__: koSFTP object deleted")
        del self.log

    def _fixPath(self, path):
        """Hack for SFTP because
        1 - sftp does not understand tilde directory names
        2 - sometimes the tilde pathname is preceeded with a /
        3 - need to remove any trailing forward slashes
        """
        newPath = None
        if not path or path == "~":
            newPath = "./"
        elif path[:2] == "/~":
            newPath = "." + path[2:]
        elif path[0] == "~":
            if path[:2] == '~/':
                newPath = "." + path[1:]
            else:
                newPath = "./" + path[1:]
        if newPath:
            # Remove any trailing forward slash
            if len(newPath) > 1 and newPath[-1] == "/":
                newPath = newPath[:-1]
            self.log.debug("_fixPath: '%s' -> '%s'", path, newPath)
            return newPath
        elif len(path) > 1 and path[-1] == "/":
            # Remove any trailing forward slash
            newPath = path[:-1]
            self.log.debug("_fixPath: %s -> %s", path, newPath)
            return newPath
        return path

    def _setupClientSFTP(self):
        """Get the client SFTP object for access to the remote site."""
        try:
            self._sftp = paramiko.SFTP.from_transport(self._connection)
            # _sftp.sock in this case is actually a paramiko.Channel object
            self._sftp.sock.settimeout(self._socket_timeout)
            self._homedirectory = self.do_currentDirectory()
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    # Authenicate to the remote SSH server using the supplied username/password
    # Return 1 on successful authentication
    # Return 0 when agent fails to authorize
    # Raise exception on error
    def do_authenticateWithAgent(self):
        if remotefilelib.koRemoteSSH.do_authenticateWithAgent(self) == 1:
            self._setupClientSFTP()
            return 1
        return 0

    # Authenicate to the remote SSH server using the supplied private key file.
    # Return 1 on successful authentication
    # Return 0 when agent fails to authorize
    # Raise exception on error
    def do_authenticateWithPrivateKey(self):
        if remotefilelib.koRemoteSSH.do_authenticateWithPrivateKey(self) == 1:
            self._setupClientSFTP()
            return 1
        return 0

    # Return 1 on successful authentication
    # Return 0 when username/password is incorrect
    # Raise exception on error
    def do_authenticateWithPassword(self):
        if remotefilelib.koRemoteSSH.do_authenticateWithPassword(self) == 1:
            self._setupClientSFTP()
            return 1
        return 0

    # remotefilelib.koRemoteSSH handles these methods.
    #def do_openSocket(self):
    #def do_close(self):
    #def do_verifyConnected(self):

    def _createRFInfoFromStat(self, dirname, filename, fileinfo):
        """Create a koRemoteFileInfo class object given the path and paramiko stats"""
        rf = components.classes['@activestate.com/koRemoteFileInfo;1'].\
                    createInstance(components.interfaces.koIRemoteFileInfo)
        try:
            rf.initFromStats(dirname, filename, str(fileinfo.st_size),
                             str(fileinfo.st_uid), str(fileinfo.st_gid),
                             fileinfo.st_mode, fileinfo.st_mtime)
        except UnicodeDecodeError:
            # Need to encode the filename then
            try:
                filename, rf.encoding, bom = self._encodingSvc.getUnicodeEncodedString(filename)
                self.log.debug("Had to decode filename(%s): %s" % (rf.encoding, filename))
                rf.initFromStats(dirname, filename, str(fileinfo.st_size),
                                 str(fileinfo.st_uid), str(fileinfo.st_gid),
                                 fileinfo.st_mode, fileinfo.st_mtime)
            except Exception, e:
                # No go, we assume it was not found in this string
                self.log.debug("Error '%s' decoding filename: '%s'" % (e, filename))
                del rf
                return None
        if rf.isSymlink():
            # Find out the link target and populate the target info
            # into this file
            link_target = self._sftp.normalize(self._fixPath(rf.getFilepath()))
            self.log.debug("_createRFInfoFromStat: Symlink info for '%s' -> '%s'", rf.getFilepath(), link_target)
            ## We now know where the link goes, but not what the link is,
            ## we need to find out what it is
            linkstat = self._sftp.lstat(link_target)
            # Copy the target information into our current rf object
            # Do not change the name, we want to keep the original symlink path
            rf.initFromStats(rf.getDirname(), rf.getFilename(), str(linkstat.st_size),
                            str(linkstat.st_uid), str(linkstat.st_gid),
                            linkstat.st_mode, linkstat.st_mtime)
            self.log.debug("_createRFInfoFromStat: File now: %s", rf)
        return rf

    def do_getPathInfo(self, path):
        """Get information about the file/directory for the given path"""
        try:
            self.log.debug("do_getPathInfo: Getting path info for: %s", path)
            info = self._sftp.lstat(self._fixPath(path))
            parentPath = self.do_getParentPath(path)
            #if path == '~': 
            #    parentPath = path
            #else:
            #    parentPath = os.path.dirname(path)
            if path == "/":
                return self._createRFInfoFromStat(parentPath, path, info)
            return self._createRFInfoFromStat(parentPath, os.path.basename(path), info)
        except IOError, e:
            # Likely this path does not exist then, else it needs to be encoded
            self.log.debug("do_getPathInfo: error: %s on path '%s'", e.args[-1], path)
            return None
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_getDirectoryList(self, path, dir_rfinfo):
        """Retrieve directory entries for the given path"""
        dirinfo = []
        try:
            orig_path = path
            # Fix up path for home directory
            path = self._fixPath(path)
            info = self._sftp.listdir_attr(path)
            for fileinfo in info:
                try:
                    rf_fileinfo = self._createRFInfoFromStat(orig_path, fileinfo.filename, fileinfo)
                    if rf_fileinfo is not None:
                        dirinfo.append(rf_fileinfo)
                except Exception, e:
                    self.log.error("Unable to create a listing element for: %s", fileinfo.filename)
                    self.log.debug("Error: %s: %s", e, e.args)
        except self._SFTPExceptions, e:
            self._raiseWithException(e)
        return dirinfo

    def do_rename(self, oldName, newName):
        try:
            self._sftp.rename(self._fixPath(oldName), self._fixPath(newName))
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_changeDirectory(self, path):
        try:
            self._sftp.chdir(self._fixPath(path))
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_currentDirectory(self):
        try:
            return self._sftp.normalize(".")
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_getHomeDirectory(self):
        # Home directory is set when we initially log in
        return self._homedirectory

    def do_getParentPath(self, path):
        try:
            parent_path = os.path.dirname(self._fixPath(path))
            norm_path = self._sftp.normalize(parent_path)
            if not parent_path:
                parent_path = "/"
            self.log.debug("do_getParentPath: '%s' -> '%s'", path, parent_path)
            return parent_path
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_removeFile(self, name):
        try:
            self._sftp.remove(self._fixPath(name))
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_removeDirectory(self, name):
        try:
            return self._sftp.rmdir(self._fixPath(name))
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_createDirectory(self, name, permissions):
        try:
            # Treat permissions as an octet value, we need to convert to integer
            # I.e. 755 as octet, the integer value of this is 493
            # permissions = int(str(permissions), 8)
            return self._sftp.mkdir(self._fixPath(name), permissions)
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_createFile(self, name, permissions):
        try:
            # Treat permissions as an octet value, we need to convert to integer
            # I.e. 755 as octet, the integer value of this is 493
            # permissions = int(str(permissions), 8)
            filename = self._fixPath(name)
            self.log.debug("do_createFile: Creating file though sftp: '%s'", filename)
            # Open and then close the file to create it
            self._sftp.open(filename, 'wb').close()
            self._sftp.chmod(filename, permissions)
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_chmod(self, filepath, permissions):
        try:
            self._sftp.chmod(self._fixPath(filepath), permissions)
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_readFile(self, filename):
        try:
            # Fix up path for home directory
            filename = self._fixPath(filename)
            self.log.debug("do_readFile: Reading sftp file: %s", filename)
            data = self._sftp.open(filename, 'rb').read()
            self.log.debug("do_readFile: Read in %d characters", len(data))
            return data
        except self._SFTPExceptions, e:
            self._raiseWithException(e)

    def do_writeFile(self, filename, data):
        try:
            # Fix up path for home directory
            filename = self._fixPath(filename)
            self.log.debug("do_writeFile: Writing sftp file: %s", filename)
            self._sftp.open(filename, 'wb').write(data)
            self.log.debug("do_writeFile: Wrote %s characters", len(data))
        except self._SFTPExceptions, e:
            self._raiseWithException(e)


# Test function
def _test():
    pass

# When run from command line
if __name__ == '__main__':
    _test()

