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

     2 # Copyright (c) 2007 - 2010, Pascal Volk

     3 # See COPYING for distribution information.

     4 

     5 """

     6    VirtualMailManager.Handler

     7 

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

     9    dependencies checks.

    10 

    11    Additionally it communicates with the PostgreSQL database, creates

    12    or deletes directories of domains or users.

    13 """

    14 

    15 import os

    16 import re

    17 

    18 from shutil import rmtree

    19 from subprocess import Popen, PIPE

    20 

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

    22 

    23 import VirtualMailManager.constants.ERROR as ERR

    24 from VirtualMailManager import ENCODING, ace2idna, exec_ok, read_pass

    25 from VirtualMailManager.Account import Account

    26 from VirtualMailManager.Alias import Alias

    27 from VirtualMailManager.AliasDomain import AliasDomain

    28 from VirtualMailManager.Config import Config as Cfg

    29 from VirtualMailManager.Domain import Domain

    30 from VirtualMailManager.EmailAddress import EmailAddress

    31 from VirtualMailManager.Exceptions import *

    32 from VirtualMailManager.Relocated import Relocated

    33 from VirtualMailManager.ext.Postconf import Postconf

    34 

    35 SALTCHARS = './0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

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

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

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

    39 

    40 class Handler(object):

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

    42     VirtualMailManager"""

    43     # TODO: accept a LazyConfig object as argument

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

    45                  '_postconf')

    46     def __init__(self):

    47         """Creates a new Handler instance.

    48         Throws a VMMNotRootException if your uid is greater 0.

    49         """

    50         self.__cfgFileName = ''

    51         self.__warnings = []

    52         self.__Cfg = None

    53         self.__dbh = None

    54 

    55         if os.geteuid():

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

    57                 ERR.CONF_NOPERM)

    58         if self.__chkCfgFile():

    59             self.__Cfg = Cfg(self.__cfgFileName)

    60             self.__Cfg.load()

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

    62             self.__Cfg.check()

    63             self.__chkenv()

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

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

    66 

    67     def __findCfgFile(self):

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

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

    70             if os.path.isfile(tmp):

    71                 self.__cfgFileName = tmp

    72                 break

    73         if not len(self.__cfgFileName):

    74             raise VMMException(

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

    76                 ERR.CONF_NOFILE)

    77 

    78     def __chkCfgFile(self):

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

    80         self.__findCfgFile()

    81         fstat = os.stat(self.__cfgFileName)

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

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

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

    85             raise VMMPermException(_(

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

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

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

    89         else:

    90             return True

    91 

    92     def __chkenv(self):

    93         """"""

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

    95         if not os.path.exists(basedir):

    96             old_umask = os.umask(0006)

    97             os.makedirs(basedir, 0771)

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

    99             os.umask(old_umask)

   100         elif not os.path.isdir(basedir):

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

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

   103                                  basedir, ERR.NO_SUCH_DIRECTORY)

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

   105             try:

   106                 exec_ok(val)

   107             except VMMException, e:

   108                 code = e.code()

   109                 if code is ERR.NO_SUCH_BINARY:

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

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

   112                                        ERR.NO_SUCH_BINARY)

   113                 elif code is ERR.NOT_EXECUTABLE:

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

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

   116                                        ERR.NOT_EXECUTABLE)

   117                 else:

   118                     raise

   119 

   120     def __dbConnect(self):

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

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

   123                                   not self.__dbh._isOpen):

   124             try:

   125                 self.__dbh = PgSQL.connect(

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

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

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

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

   130                         client_encoding='utf8', unicode_results=True)

   131                 dbc = self.__dbh.cursor()

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

   133                 dbc.close()

   134             except PgSQL.libpq.DatabaseError, e:

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

   136 

   137     def _exists(dbh, query):

   138         dbc = dbh.cursor()

   139         dbc.execute(query)

   140         gid = dbc.fetchone()

   141         dbc.close()

   142         if gid is None:

   143             return False

   144         else:

   145             return True

   146     _exists = staticmethod(_exists)

   147 

   148     def accountExists(dbh, address):

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

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

   151             address._localpart)

   152         return Handler._exists(dbh, sql)

   153     accountExists = staticmethod(accountExists)

   154 

   155     def aliasExists(dbh, address):

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

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

   158             (address._domainname, address._localpart)

   159         return Handler._exists(dbh, sql)

   160     aliasExists = staticmethod(aliasExists)

   161 

   162     def relocatedExists(dbh, address):

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

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

   165             (address._domainname, address._localpart)

   166         return Handler._exists(dbh, sql)

   167     relocatedExists = staticmethod(relocatedExists)

   168 

   169 

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

   171         self.__dbConnect()

   172         address = EmailAddress(address)

   173         if not password is None:

   174             password = self.__pwhash(password)

   175         return Account(self.__dbh, address, password)

   176 

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

   178         self.__dbConnect()

   179         address = EmailAddress(address)

   180         if destination is not None:

   181             destination = EmailAddress(destination)

   182         return Alias(self.__dbh, address, destination)

   183 

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

   185         self.__dbConnect()

   186         address = EmailAddress(address)

   187         if destination is not None:

   188             destination = EmailAddress(destination)

   189         return Relocated(self.__dbh, address, destination)

   190 

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

   192         if transport is None:

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

   194         self.__dbConnect()

   195         return Domain(self.__dbh, domainname,

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

   197 

   198     def __getDiskUsage(self, directory):

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

   200 

   201         Keyword arguments:

   202         directory -- the directory to summarize recursively disk usage for

   203         """

   204         if self.__isdir(directory):

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

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

   207         else:

   208             return 0

   209 

   210     def __isdir(self, directory):

   211         isdir = os.path.isdir(directory)

   212         if not isdir:

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

   214         return isdir

   215 

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

   217         if mode is None:

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

   219         if uid is None:

   220             uid = 0

   221         if gid is None:

   222             gid = 0

   223         os.makedirs(directory, mode)

   224         os.chown(directory, uid, gid)

   225 

   226     def __domDirMake(self, domdir, gid):

   227         os.umask(0006)

   228         oldpwd = os.getcwd()

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

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

   231 

   232         os.chdir(basedir)

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

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

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

   236         os.chdir(domdirdirs[0])

   237         os.umask(0007)

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

   239                        0, gid)

   240         os.chdir(oldpwd)

   241 

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

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

   244         sf = file(fname, 'w')

   245         for f in folderlist:

   246             sf.write(f+'\n')

   247         sf.flush()

   248         sf.close()

   249         os.chown(fname, uid, gid)

   250         os.chmod(fname, 384)

   251 

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

   253         """Creates maildirs and maildir subfolders.

   254 

   255         Keyword arguments:

   256         domdir -- the path to the domain directory

   257         uid -- user id from the account

   258         gid -- group id from the account

   259         """

   260         os.umask(0007)

   261         oldpwd = os.getcwd()

   262         os.chdir(domdir)

   263 

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

   265         folders = [maildir]

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

   267             folder = folder.strip()

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

   269             and re.match(RE_MBOX_NAMES, folder):

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

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

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

   273 

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

   275         os.chdir('%s' % uid)

   276         for folder in folders:

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

   278             for subdir in subdirs:

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

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

   281                 uid, gid)

   282         os.chdir(oldpwd)

   283 

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

   285         if uid > 0 and gid > 0:

   286             userdir = '%s' % uid

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

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

   289                     ERR.FOUND_DOTS_IN_PATH)

   290             if os.path.isdir(domdir):

   291                 os.chdir(domdir)

   292                 if os.path.isdir(userdir):

   293                     mdstat = os.stat(userdir)

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

   295                         raise VMMException(

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

   297                          ERR.MAILDIR_PERM_MISMATCH)

   298                     rmtree(userdir, ignore_errors=True)

   299                 else:

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

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

   302 

   303     def __domDirDelete(self, domdir, gid):

   304         if gid > 0:

   305             if not self.__isdir(domdir):

   306                 return

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

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

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

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

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

   312                         ERR.FOUND_DOTS_IN_PATH)

   313             if os.path.isdir(domdirparent):

   314                 os.chdir(domdirparent)

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

   316                     raise VMMException(_(

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

   318                         ERR.DOMAINDIR_GROUP_MISMATCH)

   319                 rmtree(domdirdirs[1], ignore_errors=True)

   320 

   321     def __getSalt(self):

   322         from random import choice

   323         salt = None

   324         if self.__scheme == 'CRYPT':

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

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

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

   328         return salt

   329 

   330     def __pwCrypt(self, password):

   331         # for: CRYPT, MD5 and MD5-CRYPT

   332         from crypt import crypt

   333         return crypt(password, self.__getSalt())

   334 

   335     def __pwSHA1(self, password):

   336         # for: SHA/SHA1

   337         import sha

   338         from base64 import standard_b64encode

   339         sha1 = sha.new(password)

   340         return standard_b64encode(sha1.digest())

   341 

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

   343         import md5

   344         _md5 = md5.new(password)

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

   346             from base64 import standard_b64encode

   347             return standard_b64encode(_md5.digest())

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

   349             return _md5.hexdigest()

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

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

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

   353             return _md5.hexdigest()

   354 

   355     def __pwMD4(self, password):

   356         # for: PLAIN-MD4

   357         from Crypto.Hash import MD4

   358         _md4 = MD4.new(password)

   359         return _md4.hexdigest()

   360 

   361     def __pwhash(self, password, scheme=None, user=None):

   362         if scheme is not None:

   363             self.__scheme = scheme

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

   365             return '{%s}%s' % (self.__scheme, self.__pwCrypt(password))

   366         elif self.__scheme in ['SHA', 'SHA1']:

   367             return '{%s}%s' % (self.__scheme, self.__pwSHA1(password))

   368         elif self.__scheme in ['PLAIN-MD5', 'LDAP-MD5', 'DIGEST-MD5']:

   369             return '{%s}%s' % (self.__scheme, self.__pwMD5(password, user))

   370         elif self.__scheme == 'MD4':

   371             return '{%s}%s' % (self.__scheme, self.__pwMD4(password))

   372         elif self.__scheme in ['SMD5', 'SSHA', 'CRAM-MD5', 'HMAC-MD5',

   373                 'LANMAN', 'NTLM', 'RPA']:

   374             return Popen([self.__Cfg.dget('bin.dovecotpw'), '-s',

   375                 self.__scheme,'-p',password],stdout=PIPE).communicate()[0][:-1]

   376         else:

   377             return '{%s}%s' % (self.__scheme, password)

   378 

   379     def hasWarnings(self):

   380         """Checks if warnings are present, returns bool."""

   381         return bool(len(self.__warnings))

   382 

   383     def getWarnings(self):

   384         """Returns a list with all available warnings."""

   385         return self.__warnings

   386 

   387     def cfgDget(self, option):

   388         return self.__Cfg.dget(option)

   389 

   390     def cfgPget(self, option):

   391         return self.__Cfg.pget(option)

   392 

   393     def cfgSet(self, option, value):

   394         return self.__Cfg.set(option, value)

   395 

   396     def configure(self, section=None):

   397         """Starts interactive configuration.

   398 

   399         Configures in interactive mode options in the given section.

   400         If no section is given (default) all options from all sections

   401         will be prompted.

   402 

   403         Keyword arguments:

   404         section -- the section to configure (default None):

   405         """

   406         if section is None:

   407             self.__Cfg.configure(self.__Cfg.getsections())

   408         elif self.__Cfg.has_section(section):

   409             self.__Cfg.configure([section])

   410         else:

   411             raise VMMException(_(u"Invalid section: “%s”") % section,

   412                                ERR.INVALID_SECTION)

   413 

   414     def domainAdd(self, domainname, transport=None):

   415         dom = self.__getDomain(domainname, transport)

   416         dom.save()

   417         self.__domDirMake(dom.getDir(), dom.getID())

   418 

   419     def domainTransport(self, domainname, transport, force=None):

   420         if force is not None and force != 'force':

   421             raise VMMDomainException(_(u"Invalid argument: “%s”") % force,

   422                 ERR.INVALID_OPTION)

   423         dom = self.__getDomain(domainname, None)

   424         if force is None:

   425             dom.updateTransport(transport)

   426         else:

   427             dom.updateTransport(transport, force=True)

   428 

   429     def domainDelete(self, domainname, force=None):

   430         if not force is None and force not in ['deluser','delalias','delall']:

   431             raise VMMDomainException(_(u"Invalid argument: “%s”") % force,

   432                 ERR.INVALID_OPTION)

   433         dom = self.__getDomain(domainname)

   434         gid = dom.getID()

   435         domdir = dom.getDir()

   436         if self.__Cfg.dget('domain.force_deletion') or force == 'delall':

   437             dom.delete(True, True)

   438         elif force == 'deluser':

   439             dom.delete(delUser=True)

   440         elif force == 'delalias':

   441             dom.delete(delAlias=True)

   442         else:

   443             dom.delete()

   444         if self.__Cfg.dget('domain.delete_directory'):

   445             self.__domDirDelete(domdir, gid)

   446 

   447     def domainInfo(self, domainname, details=None):

   448         if details not in [None, 'accounts', 'aliasdomains', 'aliases', 'full',

   449                 'relocated', 'detailed']:

   450             raise VMMException(_(u'Invalid argument: “%s”') % details,

   451                     ERR.INVALID_AGUMENT)

   452         if details == 'detailed':

   453             details = 'full'

   454             self.__warnings.append(_(u'\

   455 The keyword “detailed” is deprecated and will be removed in a future release.\n\

   456    Please use the keyword “full” to get full details.'))

   457         dom = self.__getDomain(domainname)

   458         dominfo = dom.getInfo()

   459         if dominfo['domainname'].startswith('xn--'):

   460             dominfo['domainname'] += ' (%s)' % ace2idna(dominfo['domainname'])

   461         if details is None:

   462             return dominfo

   463         elif details == 'accounts':

   464             return (dominfo, dom.getAccounts())

   465         elif details == 'aliasdomains':

   466             return (dominfo, dom.getAliaseNames())

   467         elif details == 'aliases':

   468             return (dominfo, dom.getAliases())

   469         elif details == 'relocated':

   470             return(dominfo, dom.getRelocated())

   471         else:

   472             return (dominfo, dom.getAliaseNames(), dom.getAccounts(),

   473                     dom.getAliases(), dom.getRelocated())

   474 

   475     def aliasDomainAdd(self, aliasname, domainname):

   476         """Adds an alias domain to the domain.

   477 

   478         Keyword arguments:

   479         aliasname -- the name of the alias domain (str)

   480         domainname -- name of the target domain (str)

   481         """

   482         dom = self.__getDomain(domainname)

   483         aliasDom = AliasDomain(self.__dbh, aliasname, dom)

   484         aliasDom.save()

   485 

   486     def aliasDomainInfo(self, aliasname):

   487         self.__dbConnect()

   488         aliasDom = AliasDomain(self.__dbh, aliasname, None)

   489         return aliasDom.info()

   490 

   491     def aliasDomainSwitch(self, aliasname, domainname):

   492         """Modifies the target domain of an existing alias domain.

   493 

   494         Keyword arguments:

   495         aliasname -- the name of the alias domain (str)

   496         domainname -- name of the new target domain (str)

   497         """

   498         dom = self.__getDomain(domainname)

   499         aliasDom = AliasDomain(self.__dbh, aliasname, dom)

   500         aliasDom.switch()

   501 

   502     def aliasDomainDelete(self, aliasname):

   503         """Deletes the specified alias domain.

   504 

   505         Keyword arguments:

   506         aliasname -- the name of the alias domain (str)

   507         """

   508         self.__dbConnect()

   509         aliasDom = AliasDomain(self.__dbh, aliasname, None)

   510         aliasDom.delete()

   511 

   512     def domainList(self, pattern=None):

   513         from Domain import search

   514         like = False

   515         if pattern is not None:

   516             if pattern.startswith('%') or pattern.endswith('%'):

   517                 like = True

   518                 if pattern.startswith('%') and pattern.endswith('%'):

   519                     domain = pattern[1:-1]

   520                 elif pattern.startswith('%'):

   521                     domain = pattern[1:]

   522                 elif pattern.endswith('%'):

   523                     domain = pattern[:-1]

   524                 if not re.match(RE_DOMAIN_SRCH, domain):

   525                     raise VMMException(

   526                     _(u"The pattern “%s” contains invalid characters.") %

   527                     pattern, ERR.DOMAIN_INVALID)

   528         self.__dbConnect()

   529         return search(self.__dbh, pattern=pattern, like=like)

   530 

   531     def userAdd(self, emailaddress, password):

   532         acc = self.__getAccount(emailaddress, password)

   533         if password is None:

   534             password = read_pass()

   535             acc.setPassword(self.__pwhash(password))

   536         acc.save(self.__Cfg.dget('maildir.name'),

   537                  self.__Cfg.dget('misc.dovecot_version'),

   538                  self.__Cfg.dget('account.smtp'),

   539                  self.__Cfg.dget('account.pop3'),

   540                  self.__Cfg.dget('account.imap'),

   541                  self.__Cfg.dget('account.sieve'))

   542         self.__mailDirMake(acc.getDir('domain'), acc.getUID(), acc.getGID())

   543 

   544     def aliasAdd(self, aliasaddress, targetaddress):

   545         alias = self.__getAlias(aliasaddress, targetaddress)

   546         alias.save(long(self._postconf.read('virtual_alias_expansion_limit')))

   547         gid = self.__getDomain(alias._dest._domainname).getID()

   548         if gid > 0 and not Handler.accountExists(self.__dbh,

   549         alias._dest) and not Handler.aliasExists(self.__dbh,

   550         alias._dest):

   551             self.__warnings.append(

   552                 _(u"The destination account/alias “%s” doesn't exist.")%\

   553                         alias._dest)

   554 

   555     def userDelete(self, emailaddress, force=None):

   556         if force not in [None, 'delalias']:

   557             raise VMMException(_(u"Invalid argument: “%s”") % force,

   558                     ERR.INVALID_AGUMENT)

   559         acc = self.__getAccount(emailaddress)

   560         uid = acc.getUID()

   561         gid = acc.getGID()

   562         acc.delete(force)

   563         if self.__Cfg.dget('account.delete_directory'):

   564             try:

   565                 self.__userDirDelete(acc.getDir('domain'), uid, gid)

   566             except VMMException, e:

   567                 if e.code() in [ERR.FOUND_DOTS_IN_PATH,

   568                         ERR.MAILDIR_PERM_MISMATCH, ERR.NO_SUCH_DIRECTORY]:

   569                     warning = _(u"""\

   570 The account has been successfully deleted from the database.

   571     But an error occurred while deleting the following directory:

   572     “%(directory)s”

   573     Reason: %(reason)s""") % {'directory': acc.getDir('home'),'reason': e.msg()}

   574                     self.__warnings.append(warning)

   575                 else:

   576                     raise e

   577 

   578     def aliasInfo(self, aliasaddress):

   579         alias = self.__getAlias(aliasaddress)

   580         return alias.getInfo()

   581 

   582     def aliasDelete(self, aliasaddress, targetaddress=None):

   583         alias = self.__getAlias(aliasaddress, targetaddress)

   584         alias.delete()

   585 

   586     def userInfo(self, emailaddress, details=None):

   587         if details not in (None, 'du', 'aliases', 'full'):

   588             raise VMMException(_(u'Invalid argument: “%s”') % details,

   589                                ERR.INVALID_AGUMENT)

   590         acc = self.__getAccount(emailaddress)

   591         info = acc.getInfo(self.__Cfg.dget('misc.dovecot_version'))

   592         if self.__Cfg.dget('account.disk_usage') or details in ('du', 'full'):

   593             info['disk usage'] = self.__getDiskUsage('%(maildir)s' % info)

   594             if details in (None, 'du'):

   595                 return info

   596         if details in ('aliases', 'full'):

   597             return (info, acc.getAliases())

   598         return info

   599 

   600     def userByID(self, uid):

   601         from Handler.Account import getAccountByID

   602         self.__dbConnect()

   603         return getAccountByID(uid, self.__dbh)

   604 

   605     def userPassword(self, emailaddress, password):

   606         acc = self.__getAccount(emailaddress)

   607         if acc.getUID() == 0:

   608            raise VMMException(_(u"Account doesn't exist"), ERR.NO_SUCH_ACCOUNT)

   609         if password is None:

   610             password = read_pass()

   611         acc.modify('password', self.__pwhash(password, user=emailaddress))

   612 

   613     def userName(self, emailaddress, name):

   614         acc = self.__getAccount(emailaddress)

   615         acc.modify('name', name)

   616 

   617     def userTransport(self, emailaddress, transport):

   618         acc = self.__getAccount(emailaddress)

   619         acc.modify('transport', transport)

   620 

   621     def userDisable(self, emailaddress, service=None):

   622         if service == 'managesieve':

   623             service = 'sieve'

   624             self.__warnings.append(_(u'\

   625 The service name “managesieve” is deprecated and will be removed\n\

   626    in a future release.\n\

   627    Please use the service name “sieve” instead.'))

   628         acc = self.__getAccount(emailaddress)

   629         acc.disable(self.__Cfg.dget('misc.dovecot_version'), service)

   630 

   631     def userEnable(self, emailaddress, service=None):

   632         if service == 'managesieve':

   633             service = 'sieve'

   634             self.__warnings.append(_(u'\

   635 The service name “managesieve” is deprecated and will be removed\n\

   636    in a future release.\n\

   637    Please use the service name “sieve” instead.'))

   638         acc = self.__getAccount(emailaddress)

   639         acc.enable(self.__Cfg.dget('misc.dovecot_version'), service)

   640 

   641     def relocatedAdd(self, emailaddress, targetaddress):

   642         relocated = self.__getRelocated(emailaddress, targetaddress)

   643         relocated.save()

   644 

   645     def relocatedInfo(self, emailaddress):

   646         relocated = self.__getRelocated(emailaddress)

   647         return relocated.getInfo()

   648 

   649     def relocatedDelete(self, emailaddress):

   650         relocated = self.__getRelocated(emailaddress)

   651         relocated.delete()

   652 

   653     def __del__(self):

   654         if isinstance(self.__dbh, PgSQL.Connection) and self.__dbh._isOpen:

   655             self.__dbh.close()