# -*- coding: UTF-8 -*-

# Copyright (c) 2007 - 2010, Pascal Volk

# See COPYING for distribution information.

"""

   VirtualMailManager.Handler

   A wrapper class. It wraps round all other classes and does some

   dependencies checks.

   Additionally it communicates with the PostgreSQL database, creates

   or deletes directories of domains or users.

"""

import os

import re

from shutil import rmtree

from subprocess import Popen, PIPE

from pyPgSQL import PgSQL # python-pgsql - http://pypgsql.sourceforge.net

import VirtualMailManager.constants.ERROR as ERR

from VirtualMailManager import ENCODING, ace2idna, exec_ok, read_pass

from VirtualMailManager.Account import Account

from VirtualMailManager.Alias import Alias

from VirtualMailManager.AliasDomain import AliasDomain

from VirtualMailManager.Config import Config as Cfg

from VirtualMailManager.Domain import Domain

from VirtualMailManager.EmailAddress import EmailAddress

from VirtualMailManager.Exceptions import *

from VirtualMailManager.Relocated import Relocated

from VirtualMailManager.ext.Postconf import Postconf

SALTCHARS = './0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

RE_DOMAIN_SRCH = """^[a-z0-9-\.]+$"""

RE_LOCALPART = """[^\w!#$%&'\*\+-\.\/=?^_`{\|}~]"""

RE_MBOX_NAMES = """^[\x20-\x25\x27-\x7E]*$"""

class Handler(object):

    """Wrapper class to simplify the access on all the stuff from

    VirtualMailManager"""

    # TODO: accept a LazyConfig object as argument

    __slots__ = ('__Cfg', '__cfgFileName', '__dbh', '__scheme', '__warnings',

                 '_postconf')

    def __init__(self):

        """Creates a new Handler instance.

        Throws a VMMNotRootException if your uid is greater 0.

        """

        self.__cfgFileName = ''

        self.__warnings = []

        self.__Cfg = None

        self.__dbh = None

        if os.geteuid():

            raise VMMNotRootException(_(u"You are not root.\n\tGood bye!\n"),

                ERR.CONF_NOPERM)

        if self.__chkCfgFile():

            self.__Cfg = Cfg(self.__cfgFileName)

            self.__Cfg.load()

        if not os.sys.argv[1] in ('cf','configure','h','help','v','version'):

            self.__Cfg.check()

            self.__chkenv()

            self.__scheme = self.__Cfg.dget('misc.password_scheme')

            self._postconf = Postconf(self.__Cfg.dget('bin.postconf'))

    def __findCfgFile(self):

        for path in ['/root', '/usr/local/etc', '/etc']:

            tmp = os.path.join(path, 'vmm.cfg')

            if os.path.isfile(tmp):

                self.__cfgFileName = tmp

                break

        if not len(self.__cfgFileName):

            raise VMMException(

                _(u"No “vmm.cfg” found in: /root:/usr/local/etc:/etc"),

                ERR.CONF_NOFILE)

    def __chkCfgFile(self):

        """Checks the configuration file, returns bool"""

        self.__findCfgFile()

        fstat = os.stat(self.__cfgFileName)

        fmode = int(oct(fstat.st_mode & 0777))

`chmod 0600 %(file)s` would be great.') % {'file':

        else:

            return True

    def __chkenv(self):

        """"""

        basedir = self.__Cfg.dget('misc.base_directory')

        if not os.path.exists(basedir):

            old_umask = os.umask(0006)

            os.makedirs(basedir, 0771)

            os.chown(basedir, 0, self.__Cfg.dget('misc.gid_mail'))

            os.umask(old_umask)

        elif not os.path.isdir(basedir):

            raise VMMException(_(u'“%s” is not a directory.\n\

(vmm.cfg: section "misc", option "base_directory")') %

                                 basedir, ERR.NO_SUCH_DIRECTORY)

        for opt, val in self.__Cfg.items('bin'):

            try:

                exec_ok(val)

            except VMMException, e:

                code = e.code()

                if code is ERR.NO_SUCH_BINARY:

                    raise VMMException(_(u'“%(binary)s” doesn\'t exist.\n\

(vmm.cfg: section "bin", option "%(option)s")') %{'binary': val,'option': opt},

                                       ERR.NO_SUCH_BINARY)

                elif code is ERR.NOT_EXECUTABLE:

                    raise VMMException(_(u'“%(binary)s” is not executable.\n\

(vmm.cfg: section "bin", option "%(option)s")') %{'binary': val,'option': opt},

                                       ERR.NOT_EXECUTABLE)

                else:

                    raise

    def __dbConnect(self):

        """Creates a pyPgSQL.PgSQL.connection instance."""

        if self.__dbh is None or (isinstance(self.__dbh, PgSQL.Connection) and

                                  not self.__dbh._isOpen):

            try:

                self.__dbh = PgSQL.connect(

                        database=self.__Cfg.dget('database.name'),

                        user=self.__Cfg.pget('database.user'),

                        host=self.__Cfg.dget('database.host'),

                        password=self.__Cfg.pget('database.pass'),

                        client_encoding='utf8', unicode_results=True)

                dbc = self.__dbh.cursor()

                dbc.execute("SET NAMES 'UTF8'")

                dbc.close()

            except PgSQL.libpq.DatabaseError, e:

                raise VMMException(str(e), ERR.DATABASE_ERROR)

    def _exists(dbh, query):

        dbc = dbh.cursor()

        dbc.execute(query)

        gid = dbc.fetchone()

        dbc.close()

        if gid is None:

            return False

        else:

            return True

    _exists = staticmethod(_exists)

    def accountExists(dbh, address):

        sql = "SELECT gid FROM users WHERE gid = (SELECT gid FROM domain_name\

 WHERE domainname = '%s') AND local_part = '%s'" % (address._domainname,

            address._localpart)

        return Handler._exists(dbh, sql)

    accountExists = staticmethod(accountExists)

    def aliasExists(dbh, address):

        sql = "SELECT DISTINCT gid FROM alias WHERE gid = (SELECT gid FROM\

            (address._domainname, address._localpart)

        return Handler._exists(dbh, sql)

    aliasExists = staticmethod(aliasExists)

    def relocatedExists(dbh, address):

        sql = "SELECT gid FROM relocated WHERE gid = (SELECT gid FROM\

            (address._domainname, address._localpart)

        return Handler._exists(dbh, sql)

    relocatedExists = staticmethod(relocatedExists)

    def __getAccount(self, address, password=None):

        self.__dbConnect()

        address = EmailAddress(address)

        if not password is None:

            password = self.__pwhash(password)

        return Account(self.__dbh, address, password)

    def __getAlias(self, address, destination=None):

        self.__dbConnect()

        address = EmailAddress(address)

        if destination is not None:

            destination = EmailAddress(destination)

        return Alias(self.__dbh, address, destination)

    def __getRelocated(self,address, destination=None):

        self.__dbConnect()

        address = EmailAddress(address)

        if destination is not None:

            destination = EmailAddress(destination)

        return Relocated(self.__dbh, address, destination)

    def __getDomain(self, domainname, transport=None):

        if transport is None:

            transport = self.__Cfg.dget('misc.transport')

        self.__dbConnect()

        return Domain(self.__dbh, domainname,

                self.__Cfg.dget('misc.base_directory'), transport)

    def __getDiskUsage(self, directory):

        """Estimate file space usage for the given directory.

        Keyword arguments:

        directory -- the directory to summarize recursively disk usage for

        """

        if self.__isdir(directory):

            return Popen([self.__Cfg.dget('bin.du'), "-hs", directory],

                stdout=PIPE).communicate()[0].split('\t')[0]

        else:

            return 0

    def __isdir(self, directory):

        isdir = os.path.isdir(directory)

        if not isdir:

            self.__warnings.append(_('No such directory: %s') % directory)

        return isdir

    def __makedir(self, directory, mode=None, uid=None, gid=None):

        if mode is None:

            mode = self.__Cfg.dget('account.directory_mode')

        if uid is None:

            uid = 0

        if gid is None:

            gid = 0

        os.makedirs(directory, mode)

        os.chown(directory, uid, gid)

    def __domDirMake(self, domdir, gid):

        os.umask(0006)

        oldpwd = os.getcwd()

        basedir = self.__Cfg.dget('misc.base_directory')

        domdirdirs = domdir.replace(basedir+'/', '').split('/')

        os.chdir(basedir)

        if not os.path.isdir(domdirdirs[0]):

            self.__makedir(domdirdirs[0], 489, 0,

                           self.__Cfg.dget('misc.gid_mail'))

        os.chdir(domdirdirs[0])

        os.umask(0007)

        self.__makedir(domdirdirs[1], self.__Cfg.dget('domain.directory_mode'),

                       0, gid)

        os.chdir(oldpwd)

    def __subscribeFL(self, folderlist, uid, gid):

        fname = os.path.join(self.__Cfg.dget('maildir.name'), 'subscriptions')

        sf = file(fname, 'w')

        for f in folderlist:

            sf.write(f+'\n')

        sf.flush()

        sf.close()

        os.chown(fname, uid, gid)

        os.chmod(fname, 384)

    def __mailDirMake(self, domdir, uid, gid):

        """Creates maildirs and maildir subfolders.

        Keyword arguments:

        domdir -- the path to the domain directory

        uid -- user id from the account

        gid -- group id from the account

        """

        os.umask(0007)

        oldpwd = os.getcwd()

        os.chdir(domdir)

        maildir = self.__Cfg.dget('maildir.name')

        folders = [maildir]

        for folder in self.__Cfg.dget('maildir.folders').split(':'):

            folder = folder.strip()

            if len(folder) and not folder.count('..')\

            and re.match(RE_MBOX_NAMES, folder):

                folders.append('%s/.%s' % (maildir, folder))

        subdirs = ['cur', 'new', 'tmp']

        mode = self.__Cfg.dget('account.directory_mode')

        self.__makedir('%s' % uid, mode, uid, gid)

        os.chdir('%s' % uid)

        for folder in folders:

            self.__makedir(folder, mode, uid, gid)

            for subdir in subdirs:

                self.__makedir(os.path.join(folder, subdir), mode, uid, gid)

        self.__subscribeFL([f.replace(maildir+'/.', '') for f in folders[1:]],

                uid, gid)

        os.chdir(oldpwd)

    def __userDirDelete(self, domdir, uid, gid):

        if uid > 0 and gid > 0:

            userdir = '%s' % uid

            if userdir.count('..') or domdir.count('..'):

                raise VMMException(_(u'Found ".." in home directory path.'),

                    ERR.FOUND_DOTS_IN_PATH)

            if os.path.isdir(domdir):

                os.chdir(domdir)

                if os.path.isdir(userdir):

                    mdstat = os.stat(userdir)

                    if (mdstat.st_uid, mdstat.st_gid) != (uid, gid):

                        raise VMMException(

                         _(u'Detected owner/group mismatch in home directory.'),

                         ERR.MAILDIR_PERM_MISMATCH)

                    rmtree(userdir, ignore_errors=True)

                else:

                    raise VMMException(_(u"No such directory: %s") %

                        os.path.join(domdir, userdir), ERR.NO_SUCH_DIRECTORY)

    def __domDirDelete(self, domdir, gid):

        if gid > 0:

            if not self.__isdir(domdir):

                return

            basedir = self.__Cfg.dget('misc.base_directory')

            domdirdirs = domdir.replace(basedir+'/', '').split('/')

            domdirparent = os.path.join(basedir, domdirdirs[0])

            if basedir.count('..') or domdir.count('..'):

                raise VMMException(_(u'Found ".." in domain directory path.'),

                        ERR.FOUND_DOTS_IN_PATH)

            if os.path.isdir(domdirparent):

                os.chdir(domdirparent)

                if os.lstat(domdirdirs[1]).st_gid != gid:

                    raise VMMException(_(

                        u'Detected group mismatch in domain directory.'),

                        ERR.DOMAINDIR_GROUP_MISMATCH)

                rmtree(domdirdirs[1], ignore_errors=True)

    def __getSalt(self):

        from random import choice

        salt = None

        if self.__scheme == 'CRYPT':

            salt = '%s%s' % (choice(SALTCHARS), choice(SALTCHARS))

        elif self.__scheme in ['MD5', 'MD5-CRYPT']:

            salt = '$1$%s$' % ''.join([choice(SALTCHARS) for x in xrange(8)])

        return salt

    def __pwCrypt(self, password):

        # for: CRYPT, MD5 and MD5-CRYPT

        from crypt import crypt

        return crypt(password, self.__getSalt())

    def __pwSHA1(self, password):

        # for: SHA/SHA1

        import sha

        from base64 import standard_b64encode

        sha1 = sha.new(password)

        return standard_b64encode(sha1.digest())

    def __pwMD5(self, password, emailaddress=None):

        import md5

        _md5 = md5.new(password)

        if self.__scheme == 'LDAP-MD5':

            from base64 import standard_b64encode

            return standard_b64encode(_md5.digest())

        elif self.__scheme == 'PLAIN-MD5':

            return _md5.hexdigest()

        elif self.__scheme == 'DIGEST-MD5' and emailaddress is not None:

            # use an empty realm - works better with usenames like user@dom

            _md5 = md5.new('%s::%s' % (emailaddress, password))

            return _md5.hexdigest()

    def __pwMD4(self, password):