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

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

     3 # See COPYING for distribution information.

     4 """

     5     VirtualMailManager.config

     6     ~~~~~~~~~~~~~~~~~~~~~~~~~

     7 

     8     VMM's configuration module for simplified configuration access.

     9 """

    10 

    11 from ConfigParser import \

    12      Error, MissingSectionHeaderError, NoOptionError, NoSectionError, \

    13      ParsingError, RawConfigParser

    14 from cStringIO import StringIO

    15 

    16 from VirtualMailManager.common import VERSION_RE, \

    17      exec_ok, expand_path, get_unicode, lisdir, size_in_bytes, version_hex

    18 from VirtualMailManager.constants import CONF_ERROR

    19 from VirtualMailManager.errors import ConfigError, VMMError

    20 from VirtualMailManager.maillocation import known_format

    21 from VirtualMailManager.password import verify_scheme as _verify_scheme

    22 

    23 DB_MODULES = ('psycopg2', 'pypgsql')

    24 DB_SSL_MODES = ('allow', 'disabled', 'prefer', 'require', 'verify-ca',

    25                 'verify-full')

    26 

    27 _ = lambda msg: msg

    28 

    29 

    30 class BadOptionError(Error):

    31     """Raised when a option isn't in the format 'section.option'."""

    32     pass

    33 

    34 

    35 class ConfigValueError(Error):

    36     """Raised when creating or validating of new values fails."""

    37     pass

    38 

    39 

    40 class NoDefaultError(Error):

    41     """Raised when the requested option has no default value."""

    42 

    43     def __init__(self, section, option):

    44         Error.__init__(self, 'Option %r in section %r has no default value' %

    45                              (option, section))

    46 

    47 

    48 class LazyConfig(RawConfigParser):

    49     """The **lazy** derivate of the `RawConfigParser`.

    50 

    51     There are two additional getters:

    52 

    53     `pget()`

    54       The polymorphic getter, which returns a option's value with the

    55       appropriate type.

    56     `dget()`

    57       Like `LazyConfig.pget()`, but returns the option's default, from

    58       `LazyConfig._cfg['sectionname']['optionname'].default`, if the

    59       option is not configured in a ini-like configuration file.

    60 

    61     `set()` differs from `RawConfigParser`'s `set()` method. `set()`

    62     takes the `section` and `option` arguments combined to a single

    63     string in the form "section.option".

    64     """

    65 

    66     def __init__(self):

    67         RawConfigParser.__init__(self)

    68         self._modified = False

    69         # sample _cfg dict.  Create your own in your derived class.

    70         self._cfg = {

    71             'sectionname': {

    72                 'optionname': LazyConfigOption(int, 1, self.getint),

    73             }

    74         }

    75 

    76     def bool_new(self, value):

    77         """Converts the string `value` into a `bool` and returns it.

    78 

    79         | '1', 'on', 'yes' and 'true' will become `True`

    80         | '0', 'off', 'no' and 'false' will become `False`

    81 

    82         Throws a `ConfigValueError` for all other values, except bools.

    83         """

    84         if isinstance(value, bool):

    85             return value

    86         if value.lower() in self._boolean_states:

    87             return self._boolean_states[value.lower()]

    88         else:

    89             raise ConfigValueError(_(u"Not a boolean: '%s'") %

    90                                    get_unicode(value))

    91 

    92     def getboolean(self, section, option):

    93         """Returns the boolean value of the option, in the given

    94         section.

    95 

    96         For a boolean True, the value must be set to '1', 'on', 'yes',

    97         'true' or True. For a boolean False, the value must set to '0',

    98         'off', 'no', 'false' or False.

    99         If the option has another value assigned this method will raise

   100         a ValueError.

   101         """

   102         # if the setting was modified it may be still a boolean value lets see

   103         tmp = self.get(section, option)

   104         if isinstance(tmp, bool):

   105             return tmp

   106         if not tmp.lower() in self._boolean_states:

   107             raise ValueError('Not a boolean: %s' % tmp)

   108         return self._boolean_states[tmp.lower()]

   109 

   110     def _get_section_option(self, section_option):

   111         """splits ``section_option`` (section.option) in two parts and

   112         returns them as list ``[section, option]``, if:

   113 

   114           * it likes the format of ``section_option``

   115           * the ``section`` is known

   116           * the ``option`` is known

   117 

   118         Else one of the following exceptions will be thrown:

   119 

   120           * `BadOptionError`

   121           * `NoSectionError`

   122           * `NoOptionError`

   123         """

   124         sect_opt = section_option.lower().split('.')

   125         # TODO: cache it

   126         if len(sect_opt) != 2 or not sect_opt[0] or not sect_opt[1]:

   127             raise BadOptionError(_(u"Bad format: '%s' - expected: "

   128                                    u"section.option") %

   129                                  get_unicode(section_option))

   130         if not sect_opt[0] in self._cfg:

   131             raise NoSectionError(sect_opt[0])

   132         if not sect_opt[1] in self._cfg[sect_opt[0]]:

   133             raise NoOptionError(sect_opt[1], sect_opt[0])

   134         return sect_opt

   135 

   136     def items(self, section):

   137         """returns an iterable that returns key, value ``tuples`` from

   138         the given ``section``.

   139         """

   140         if section in self._sections:  # check if the section was parsed

   141             sect = self._sections[section]

   142         elif not section in self._cfg:

   143             raise NoSectionError(section)

   144         else:

   145             return ((k, self._cfg[section][k].default) \

   146                     for k in self._cfg[section].iterkeys())

   147         # still here? Get defaults and merge defaults with configured setting

   148         defaults = dict((k, self._cfg[section][k].default) \

   149                         for k in self._cfg[section].iterkeys())

   150         defaults.update(sect)

   151         if '__name__' in defaults:

   152             del defaults['__name__']

   153         return defaults.iteritems()

   154 

   155     def dget(self, option):

   156         """Returns the value of the `option`.

   157 

   158         If the option could not be found in the configuration file, the

   159         configured default value, from ``LazyConfig._cfg`` will be

   160         returned.

   161 

   162         Arguments:

   163 

   164         `option` : string

   165             the configuration option in the form "section.option"

   166 

   167         Throws a `NoDefaultError`, if no default value was passed to

   168         `LazyConfigOption.__init__()` for the `option`.

   169         """

   170         section, option = self._get_section_option(option)

   171         try:

   172             return self._cfg[section][option].getter(section, option)

   173         except (NoSectionError, NoOptionError):

   174             if not self._cfg[section][option].default is None:  # may be False

   175                 return self._cfg[section][option].default

   176             else:

   177                 raise NoDefaultError(section, option)

   178 

   179     def pget(self, option):

   180         """Returns the value of the `option`."""

   181         section, option = self._get_section_option(option)

   182         return self._cfg[section][option].getter(section, option)

   183 

   184     def set(self, option, value):

   185         """Set the `value` of the `option`.

   186 

   187         Throws a `ValueError` if `value` couldn't be converted using

   188         `LazyConfigOption.cls`.

   189         """

   190         # pylint: disable=W0221

   191         # @pylint: _L A Z Y_

   192         section, option = self._get_section_option(option)

   193         val = self._cfg[section][option].cls(value)

   194         if self._cfg[section][option].validate:

   195             val = self._cfg[section][option].validate(val)

   196         if not RawConfigParser.has_section(self, section):

   197             self.add_section(section)

   198         RawConfigParser.set(self, section, option, val)

   199         self._modified = True

   200 

   201     def has_section(self, section):

   202         """Checks if `section` is a known configuration section."""

   203         return section.lower() in self._cfg

   204 

   205     def has_option(self, option):

   206         """Checks if the option (section.option) is a known

   207         configuration option.

   208         """

   209         # pylint: disable=W0221

   210         # @pylint: _L A Z Y_

   211         try:

   212             self._get_section_option(option)

   213             return True

   214         except(BadOptionError, NoSectionError, NoOptionError):

   215             return False

   216 

   217     def sections(self):

   218         """Returns an iterator object for all configuration sections."""

   219         return self._cfg.iterkeys()

   220 

   221 

   222 class LazyConfigOption(object):

   223     """A simple container class for configuration settings.

   224 

   225     `LazyConfigOption` instances are required by `LazyConfig` instances,

   226     and instances of classes derived from `LazyConfig`, like the

   227     `Config` class.

   228     """

   229     __slots__ = ('__cls', '__default', '__getter', '__validate')

   230 

   231     def __init__(self, cls, default, getter, validate=None):

   232         """Creates a new `LazyConfigOption` instance.

   233 

   234         Arguments:

   235 

   236         `cls` : type

   237           The class/type of the option's value

   238         `default`

   239           Default value of the option. Use ``None`` if the option should

   240           not have a default value.

   241         `getter` : callable

   242           A method's name of `RawConfigParser` and derived classes, to

   243           get a option's value, e.g. `self.getint`.

   244         `validate` : NoneType or a callable

   245           None or any method, that takes one argument, in order to

   246           check the value, when `LazyConfig.set()` is called.

   247         """

   248         self.__cls = cls

   249         if not default is None:  # enforce the type of the default value

   250             self.__default = self.__cls(default)

   251         else:

   252             self.__default = default

   253         if not callable(getter):

   254             raise TypeError('getter has to be a callable, got a %r' %

   255                             getter.__class__.__name__)

   256         self.__getter = getter

   257         if validate and not callable(validate):

   258             raise TypeError('validate has to be callable or None, got a %r' %

   259                             validate.__class__.__name__)

   260         self.__validate = validate

   261 

   262     @property

   263     def cls(self):

   264         """The class of the option's value e.g. `str`, `unicode` or `bool`."""

   265         return self.__cls

   266 

   267     @property

   268     def default(self):

   269         """The option's default value, may be `None`"""

   270         return self.__default

   271 

   272     @property

   273     def getter(self):

   274         """The getter method or function to get the option's value"""

   275         return self.__getter

   276 

   277     @property

   278     def validate(self):

   279         """A method or function to validate the value"""

   280         return self.__validate

   281 

   282 

   283 class Config(LazyConfig):

   284     """This class is for reading vmm's configuration file."""

   285 

   286     def __init__(self, filename):

   287         """Creates a new Config instance

   288 

   289         Arguments:

   290 

   291         `filename` : str

   292           path to the configuration file

   293         """

   294         LazyConfig.__init__(self)

   295         self._cfg_filename = filename

   296         self._cfg_file = None

   297         self._missing = {}

   298 

   299         LCO = LazyConfigOption

   300         bool_t = self.bool_new

   301         self._cfg = {

   302             'account': {

   303                 'delete_directory': LCO(bool_t, False, self.getboolean),

   304                 'directory_mode': LCO(int, 448, self.getint),

   305                 'disk_usage': LCO(bool_t, False, self.getboolean),

   306                 'password_length': LCO(int, 8, self.getint),

   307                 'random_password': LCO(bool_t, False, self.getboolean),

   308             },

   309             'bin': {

   310                 'dovecotpw': LCO(str, '/usr/sbin/dovecotpw', self.get,

   311                                  exec_ok),

   312                 'du': LCO(str, '/usr/bin/du', self.get, exec_ok),

   313                 'postconf': LCO(str, '/usr/sbin/postconf', self.get, exec_ok),

   314             },

   315             'database': {

   316                 'host': LCO(str, 'localhost', self.get),

   317                 'module': LCO(str, 'psycopg2', self.get, check_db_module),

   318                 'name': LCO(str, 'mailsys', self.get),

   319                 'pass': LCO(str, None, self.get),

   320                 'port': LCO(int, 5432, self.getint),

   321                 'sslmode': LCO(str, 'prefer', self.get, check_db_ssl_mode),

   322                 'user': LCO(str, None, self.get),

   323             },

   324             'domain': {

   325                 'auto_postmaster': LCO(bool_t, True, self.getboolean),

   326                 'delete_directory': LCO(bool_t, False, self.getboolean),

   327                 'directory_mode': LCO(int, 504, self.getint),

   328                 'force_deletion': LCO(bool_t, False, self.getboolean),

   329                 'imap': LCO(bool_t, True, self.getboolean),

   330                 'pop3': LCO(bool_t, True, self.getboolean),

   331                 'sieve': LCO(bool_t, True, self.getboolean),

   332                 'smtp': LCO(bool_t, True, self.getboolean),

   333                 'quota_bytes': LCO(str, '0', self.get_in_bytes,

   334                                    check_size_value),

   335                 'quota_messages': LCO(int, 0, self.getint),

   336                 'transport': LCO(str, 'dovecot:', self.get),

   337             },

   338             'mailbox': {

   339                 'folders': LCO(str, 'Drafts:Sent:Templates:Trash',

   340                                self.unicode),

   341                 'format': LCO(str, 'maildir', self.get, check_mailbox_format),

   342                 'root': LCO(str, 'Maildir', self.unicode),

   343                 'subscribe': LCO(bool_t, True, self.getboolean),

   344             },

   345             'misc': {

   346                 'base_directory': LCO(str, '/srv/mail', self.get, is_dir),

   347                 'crypt_blowfish_rounds': LCO(int, 5, self.getint),

   348                 'crypt_sha256_rounds': LCO(int, 5000, self.getint),

   349                 'crypt_sha512_rounds': LCO(int, 5000, self.getint),

   350                 'dovecot_version': LCO(str, None, self.hexversion,

   351                                        check_version_format),

   352                 'password_scheme': LCO(str, 'CRAM-MD5', self.get,

   353                                        verify_scheme),

   354             },

   355         }

   356 

   357     def load(self):

   358         """Loads the configuration, read only.

   359 

   360         Raises a ConfigError if the configuration syntax is

   361         invalid.

   362         """

   363         self._cfg_file = open(self._cfg_filename, 'r')

   364         try:

   365             self.readfp(self._cfg_file)

   366         except (MissingSectionHeaderError, ParsingError), err:

   367             raise ConfigError(str(err), CONF_ERROR)

   368         self._cfg_file.close()

   369 

   370     def check(self):

   371         """Performs a configuration check.

   372 

   373         Raises a ConfigError if settings w/o a default value are missed.

   374         Or some settings have a invalid value.

   375         """

   376         def iter_dict():

   377             for section, options in self._missing.iteritems():

   378                 errmsg.write(_(u'* Section: %s\n') % section)

   379                 errmsg.writelines(u'    %s\n' % option for option in options)

   380             self._missing.clear()

   381 

   382         errmsg = None

   383         self._chk_non_default()

   384         miss_vers = 'misc' in self._missing and \

   385                     'dovecot_version' in self._missing['misc']

   386         if self._missing:

   387             errmsg = StringIO()

   388             errmsg.write(_(u'Check of configuration file %s failed.\n') %

   389                          self._cfg_filename)

   390             errmsg.write(_(u'Missing options, which have no default value.\n'))

   391             iter_dict()

   392         self._chk_possible_values(miss_vers)

   393         if self._missing:

   394             if not errmsg:

   395                 errmsg = StringIO()

   396                 errmsg.write(_(u'Check of configuration file %s failed.\n') %

   397                              self._cfg_filename)

   398                 errmsg.write(_(u'Invalid configuration values.\n'))

   399             else:

   400                 errmsg.write('\n' + _(u'Invalid configuration values.\n'))

   401             iter_dict()

   402         if errmsg:

   403             raise ConfigError(errmsg.getvalue(), CONF_ERROR)

   404 

   405     def hexversion(self, section, option):

   406         """Converts the version number (e.g.: 1.2.3) from the *option*'s

   407         value to an int."""

   408         return version_hex(self.get(section, option))

   409 

   410     def get_in_bytes(self, section, option):

   411         """Converts the size value (e.g.: 1024k) from the *option*'s

   412         value to a long"""

   413         return size_in_bytes(self.get(section, option))

   414 

   415     def unicode(self, section, option):

   416         """Returns the value of the `option` from `section`, converted

   417         to Unicode."""

   418         return get_unicode(self.get(section, option))

   419 

   420     def _chk_non_default(self):

   421         """Checks all section's options for settings w/o a default

   422         value. Missing items will be stored in _missing.

   423         """

   424         for section in self._cfg.iterkeys():

   425             missing = []

   426             for option, value in self._cfg[section].iteritems():

   427                 if (value.default is None and

   428                     not RawConfigParser.has_option(self, section, option)):

   429                     missing.append(option)

   430             if missing:

   431                 self._missing[section] = missing

   432 

   433     def _chk_possible_values(self, miss_vers):

   434         """Check settings for which the possible values are known."""

   435         if not miss_vers:

   436             value = self.get('misc', 'dovecot_version')

   437             if not VERSION_RE.match(value):

   438                 self._missing['misc'] = ['version: ' +\

   439                         _(u"Not a valid Dovecot version: '%s'") % value]

   440         # section database

   441         db_err = []

   442         value = self.dget('database.module').lower()

   443         if value not in DB_MODULES:

   444             db_err.append('module: ' + \

   445                           _(u"Unsupported database module: '%s'") % value)

   446         if value == 'psycopg2':

   447             value = self.dget('database.sslmode')

   448             if value not in DB_SSL_MODES:

   449                 db_err.append('sslmode: ' + \

   450                               _(u"Unknown pgsql SSL mode: '%s'") % value)

   451         if db_err:

   452             self._missing['database'] = db_err

   453         # section mailbox

   454         value = self.dget('mailbox.format')

   455         if not known_format(value):

   456             self._missing['mailbox'] = ['format: ' +\

   457                               _(u"Unsupported mailbox format: '%s'") % value]

   458         # section domain

   459         try:

   460             value = self.dget('domain.quota_bytes')

   461         except (ValueError, TypeError), err:

   462             self._missing['domain'] = [u'quota_bytes: ' + str(err)]

   463 

   464 

   465 def is_dir(path):

   466     """Check if the expanded path is a directory.  When the expanded path

   467     is a directory the expanded path will be returned.  Otherwise a

   468     ConfigValueError will be raised.

   469     """

   470     path = expand_path(path)

   471     if lisdir(path):

   472         return path

   473     raise ConfigValueError(_(u"No such directory: %s") % get_unicode(path))

   474 

   475 

   476 def check_db_module(module):

   477     """Check if the *module* is a supported pgsql module."""

   478     if module.lower() in DB_MODULES:

   479         return module

   480     raise ConfigValueError(_(u"Unsupported database module: '%s'") %

   481                            get_unicode(module))

   482 

   483 

   484 def check_db_ssl_mode(ssl_mode):

   485     """Check if the *ssl_mode* is one of the SSL modes, known by pgsql."""

   486     if ssl_mode in DB_SSL_MODES:

   487         return ssl_mode

   488     raise ConfigValueError(_(u"Unknown pgsql SSL mode: '%s'") %

   489                            get_unicode(ssl_mode))

   490 

   491 

   492 def check_mailbox_format(format):

   493     """

   494     Check if the mailbox format *format* is supported.  When the *format*

   495     is supported it will be returned, otherwise a `ConfigValueError` will

   496     be raised.

   497     """

   498     format = format.lower()

   499     if known_format(format):

   500         return format

   501     raise ConfigValueError(_(u"Unsupported mailbox format: '%s'") %

   502                            get_unicode(format))

   503 

   504 

   505 def check_size_value(value):

   506     """Check if the size value *value* has the proper format, e.g.: 1024k.

   507     Returns the validated value string if it has the expected format.

   508     Otherwise a `ConfigValueError` will be raised."""

   509     try:

   510         tmp = size_in_bytes(value)

   511     except (TypeError, ValueError), err:

   512         raise ConfigValueError(_(u"Not a valid size value: '%s'") %

   513                                get_unicode(value))

   514     return value

   515 

   516 

   517 def check_version_format(version_string):

   518     """Check if the *version_string* has the proper format, e.g.: '1.2.3'.

   519     Returns the validated version string if it has the expected format.

   520     Otherwise a `ConfigValueError` will be raised.

   521     """

   522     if not VERSION_RE.match(version_string):

   523         raise ConfigValueError(_(u"Not a valid Dovecot version: '%s'") %

   524                                get_unicode(version_string))

   525     return version_string

   526 

   527 

   528 def verify_scheme(scheme):

   529     """Checks if the password scheme *scheme* can be accepted and returns

   530     the verified scheme.

   531     """

   532     try:

   533         scheme, encoding = _verify_scheme(scheme)

   534     except VMMError, err:  # 'cast' it

   535         raise ConfigValueError(err.msg)

   536     if not encoding:

   537         return scheme

   538     return '%s.%s' % (scheme, encoding)

   539 

   540 del _