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

# Copyright (c) 2007 - 2009, VEB IT

# See COPYING for distribution information.

"""The main class for vmm."""

from encodings.idna import ToASCII, ToUnicode

from getpass import getpass

from shutil import rmtree

from subprocess import Popen, PIPE

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

from __main__ import os, re, ENCODING, ERR, w_std

from ext.Postconf import Postconf

from Account import Account

from Alias import Alias

from AliasDomain import AliasDomain

from Config import Config as Cfg

from Domain import Domain

from EmailAddress import EmailAddress

from Exceptions import *

from Relocated import Relocated

SALTCHARS = './0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

RE_ASCII_CHARS = """^[\x20-\x7E]*$"""

RE_DOMAIN = """^(?:[a-z0-9-]{1,63}\.){1,}[a-z]{2,6}$"""

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

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

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

class VirtualMailManager(object):

    """The main class for vmm"""

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

            '__warnings', '_postconf')

    def __init__(self):

        """Creates a new VirtualMailManager 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()

            self.__Cfg.check()

            self.__cfgSections = self.__Cfg.getsections()

            self.__scheme = self.__Cfg.get('misc', 'passwdscheme')

            self._postconf = Postconf(self.__Cfg.get('bin', 'postconf'))

        if not os.sys.argv[1] in ['cf', 'configure']:

            self.__chkenv()

    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))

        if fmode % 100 and fstat.st_uid != fstat.st_gid \

        or fmode % 10 and fstat.st_uid == fstat.st_gid:

            raise VMMPermException(_(

                u'fix permissions (%(perms)s) for “%(file)s”\n\

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

                self.__cfgFileName, 'perms': fmode}, ERR.CONF_WRONGPERM)

        else:

            return True

    def __chkenv(self):

        """"""

        if not os.path.exists(self.__Cfg.get('domdir', 'base')):

            old_umask = os.umask(0006)

            os.makedirs(self.__Cfg.get('domdir', 'base'), 0771)

            os.chown(self.__Cfg.get('domdir', 'base'), 0,

                    self.__Cfg.getint('misc', 'gid_mail'))

            os.umask(old_umask)

        elif not os.path.isdir(self.__Cfg.get('domdir', 'base')):

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

(vmm.cfg: section "domdir", option "base")') %

                self.__Cfg.get('domdir', 'base'), ERR.NO_SUCH_DIRECTORY)

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

            if not os.path.exists(val):

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

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

                    ERR.NO_SUCH_BINARY)

            elif not os.access(val, os.X_OK):

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

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

                    ERR.NOT_EXECUTABLE)

    def __dbConnect(self):

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

        if self.__dbh is None or not self.__dbh._isOpen:

            try:

                self.__dbh = PgSQL.connect(

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

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

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

                        password=self.__Cfg.get('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 idn2ascii(domainname):

        """Converts an idn domainname in punycode.

        Arguments:

        domainname -- the domainname to convert (unicode)

        """

        return '.'.join([ToASCII(lbl) for lbl in domainname.split('.') if lbl])

    idn2ascii = staticmethod(idn2ascii)

    def ace2idna(domainname):

        """Convertis a domainname from ACE according to IDNA

        Arguments:

        domainname -- the domainname to convert (str)

        """

        return u'.'.join([ToUnicode(lbl) for lbl in domainname.split('.')\

                if lbl])

    ace2idna = staticmethod(ace2idna)

    def chkDomainname(domainname):

        """Validates the domain name of an e-mail address.

        Keyword arguments:

        domainname -- the domain name that should be validated

        """

        if not re.match(RE_ASCII_CHARS, domainname):

            domainname = VirtualMailManager.idn2ascii(domainname)

        if len(domainname) > 255:

            raise VMMException(_(u'The domain name is too long.'),

                ERR.DOMAIN_TOO_LONG)

        if not re.match(RE_DOMAIN, domainname):

            raise VMMException(_(u'The domain name “%s” is invalid.') %\

                    domainname, ERR.DOMAIN_INVALID)

        return domainname

    chkDomainname = staticmethod(chkDomainname)

    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 VirtualMailManager._exists(dbh, sql)

    accountExists = staticmethod(accountExists)

    def aliasExists(dbh, address):

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

 domain_name WHERE domainname = '%s') AND address = '%s'" %\

            (address._domainname, address._localpart)

        return VirtualMailManager._exists(dbh, sql)

    aliasExists = staticmethod(aliasExists)

    def relocatedExists(dbh, address):

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

 domain_name WHERE domainname = '%s') AND address = '%s'" %\

            (address._domainname, address._localpart)

        return VirtualMailManager._exists(dbh, sql)

    relocatedExists = staticmethod(relocatedExists)

    def _readpass(self):

        readp_msg0 = _(u'Enter new password: ').encode(ENCODING, 'replace')

        readp_msg1 = _(u'Retype new password: ').encode(ENCODING, 'replace')

        mismatched = True

        while mismatched:

            clear0 = getpass(prompt=readp_msg0)

            clear1 = getpass(prompt=readp_msg1)

            if clear0 != clear1:

                w_std(_(u'Sorry, passwords do not match'))

                continue

            if len(clear0) < 1 or len(clear1) < 1:

                w_std(_(u'Sorry, empty passwords are not permitted'))

                continue

            mismatched = False

        return clear0

    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.get('misc', 'transport')

        self.__dbConnect()

        return Domain(self.__dbh, domainname,

                self.__Cfg.get('domdir', 'base'), 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.get('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.getint('maildir', '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.get('domdir', 'base')

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

        os.chdir(basedir)

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

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

                    self.__Cfg.getint('misc', 'gid_mail'))

        os.chdir(domdirdirs[0])

        os.umask(0007)

        self.__makedir(domdirdirs[1], self.__Cfg.getint('domdir', 'mode'), 0,

                gid)

        os.chdir(oldpwd)

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

        fname = os.path.join(self.__Cfg.get('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.get('maildir', 'name')

        folders = [maildir]

        for folder in self.__Cfg.get('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.getint('maildir', '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'Owner/group mismatch in home directory detected.'),

                         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.get('domdir', 'base')

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

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

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

                raise VMMException(

                        _(u'FATAL: ".." in domain directory path detected.'),

                            ERR.FOUND_DOTS_IN_PATH)

            if os.path.isdir(domdirparent):

                os.chdir(domdirparent)

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