conf/format-options.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (C) 2014-2019 Tobias Brunner
   4 # HSR Hochschule fuer Technik Rapperswil
   5 #
   6 # This program is free software; you can redistribute it and/or modify it
   7 # under the terms of the GNU General Public License as published by the
   8 # Free Software Foundation; either version 2 of the License, or (at your
   9 # option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 # for more details.
  15
  16 """
  17 Parses strongswan.conf option descriptions and produces configuration file
  18 and man page snippets.
  19
  20 The format for description files is as follows:
  21
  22 full.option.name [[:]= default]
  23         Short description intended as comment in config snippet
  24
  25         Long description for use in the man page, with
  26         simple formatting: _italic_, **bold**
  27
  28         Second paragraph of the long description
  29
  30 The descriptions must be indented by tabs or spaces but are both optional.
  31 If only a short description is given it is used for both intended usages.
  32 Line breaks within a paragraph of the long description or the short description
  33 are not preserved.  But multiple paragraphs will be separated in the man page.
  34 Any formatting in the short description is removed when producing config
  35 snippets.
  36
  37 Options for which a value is assigned with := are not commented out in the
  38 produced configuration file snippet.  This allows to override a default value,
  39 that e.g. has to be preserved for legacy reasons, in the generated default
  40 config.
  41
  42 To describe sections the following format can be used:
  43
  44 full.section.name {[#]}
  45         Short description of this section
  46
  47         Long description as above
  48
  49 If a # is added between the curly braces the section header will be commented
  50 out in the configuration file snippet, which is useful for example sections.
  51
  52 To add include statements to generated config files (ignored when generating
  53 man pages) the following format can be used:
  54
  55 full.section.name.include files/to/include
  56         Description of this include statement
  57
  58 Dots in section/option names may be escaped with a backslash.  For instance,
  59 with the following section description
  60
  61 charon.filelog./var/log/daemon\.log {}
  62         Section to define logging into /var/log/daemon.log
  63
  64 /var/log/daemon.log will be the name of the last section.
  65 """
  66
  67 import sys
  68 import re
  69 from textwrap import TextWrapper
  70 from argparse import ArgumentParser
  71 from functools import cmp_to_key, total_ordering
  72
  73 @total_ordering
  74 class ConfigOption:
  75         """Representing a configuration option or described section in strongswan.conf"""
  76         def __init__(self, path, default = None, section = False, commented = False, include = False):
  77                 self.path = path
  78                 self.name = path[-1]
  79                 self.fullname = '.'.join(path)
  80                 self.default = default
  81                 self.section = section
  82                 self.commented = commented
  83                 self.include = include
  84                 self.desc = []
  85                 self.options = []
  86
  87         def __eq__(self, other):
  88                 return self.name == other.name
  89
  90         def __lt__(self, other):
  91                 return self.name < other.name
  92
  93         def add_paragraph(self):
  94                 """Adds a new paragraph to the description"""
  95                 if len(self.desc) and len(self.desc[-1]):
  96                         self.desc.append("")
  97
  98         def add(self, line):
  99                 """Adds a line to the last paragraph"""
 100                 if not len(self.desc):
 101                         self.desc.append(line)
 102                 elif not len(self.desc[-1]):
 103                         self.desc[-1] = line
 104                 else:
 105                         self.desc[-1] += ' ' + line
 106
 107         def adopt(self, other):
 108                 """Adopts settings from other, which should be more recently parsed"""
 109                 self.default = other.default
 110                 self.commented = other.commented
 111                 self.desc = other.desc
 112
 113         @staticmethod
 114         def cmp(a, b):
 115                 # order options before sections and includes last
 116                 if a.include or b.include:
 117                         return a.include - b.include
 118                 return a.section - b.section
 119
 120 class Parser:
 121         """Parses one or more files of configuration options"""
 122         def __init__(self, sort = True):
 123                 self.options = []
 124                 self.sort = sort
 125
 126         def parse(self, file):
 127                 """Parses the given file and adds all options to the internal store"""
 128                 self.__current = None
 129                 for line in file:
 130                         self.__parse_line(line)
 131                 if self.__current:
 132                         self.__add_option(self.__current)
 133
 134         def __parse_line(self, line):
 135                 """Parses a single line"""
 136                 if re.match(r'^\s*#', line):
 137                         return
 138                 # option definition
 139                 m = re.match(r'^(?P<name>\S+)\s*((?P<assign>:)?=\s*(?P<default>.+)?)?\s*$', line)
 140                 if m:
 141                         if self.__current:
 142                                 self.__add_option(self.__current)
 143                         path = self.__split_name(m.group('name'))
 144                         self.__current = ConfigOption(path, m.group('default'),
 145                                                                                   commented = not m.group('assign'))
 146                         return
 147                 # section definition
 148                 m = re.match(r'^(?P<name>\S+)\s*\{\s*(?P<comment>#)?\s*\}\s*$', line)
 149                 if m:
 150                         if self.__current:
 151                                 self.__add_option(self.__current)
 152                         path = self.__split_name(m.group('name'))
 153                         self.__current = ConfigOption(path, section = True,
 154                                                                                   commented = m.group('comment'))
 155                         return
 156                 # include definition
 157                 m = re.match(r'^(?P<name>\S+\.include|include)\s+(?P<pattern>\S+)\s*$', line)
 158                 if m:
 159                         if self.__current:
 160                                 self.__add_option(self.__current)
 161                         path = self.__split_name(m.group('name'))
 162                         self.__current = ConfigOption(path, m.group('pattern'), include = True)
 163                         return
 164                 # paragraph separator
 165                 m = re.match(r'^\s*$', line)
 166                 if m and self.__current:
 167                         self.__current.add_paragraph()
 168                 # description line
 169                 m = re.match(r'^\s+(?P<text>.+?)\s*$', line)
 170                 if m and self.__current:
 171                         self.__current.add(m.group('text'))
 172
 173         def __split_name(self, name):
 174                 """Split the given full name in a list of section/option names"""
 175                 return [x.replace('\.', '.') for x in re.split(r'(?<!\\)\.', name)]
 176
 177         def __add_option(self, option):
 178                 """Adds the given option to the abstract storage"""
 179                 option.desc = [desc for desc in option.desc if len(desc)]
 180                 parent = self.__get_option(option.path[:-1], True)
 181                 if not parent:
 182                         parent = self
 183                 found = next((x for x in parent.options if x.name == option.name
 184                                                                                 and x.section == option.section), None)
 185                 if found:
 186                         found.adopt(option)
 187                 else:
 188                         parent.options.append(option)
 189                         if self.sort:
 190                                 parent.options.sort()
 191
 192         def __get_option(self, path, create = False):
 193                 """Searches/Creates the option (section) based on a list of section names"""
 194                 option = None
 195                 options = self.options
 196                 for i, name in enumerate(path, 1):
 197                         option = next((x for x in options if x.name == name and x.section), None)
 198                         if not option:
 199                                 if not create:
 200                                         break
 201                                 option = ConfigOption(path[:i], section = True)
 202                                 options.append(option)
 203                                 if self.sort:
 204                                         options.sort()
 205                         options = option.options
 206                 return option
 207
 208         def get_option(self, name):
 209                 """Retrieves the option with the given name"""
 210                 return self.__get_option(self.__split_name(name))
 211
 212 class TagReplacer:
 213         """Replaces formatting tags in text"""
 214         def __init__(self):
 215                 self.__matcher_b = self.__create_matcher('**')
 216                 self.__matcher_i = self.__create_matcher('_')
 217                 self.__replacer = None
 218
 219         def __create_matcher(self, tag):
 220                 tag = re.escape(tag)
 221                 return re.compile(r'''
 222                         (^|\s|(?P<brack>[(\[])) # prefix with optional opening bracket
 223                         (?P<tag>''' + tag + r''') # start tag
 224                         (?P<text>\S|\S.*?\S) # text
 225                         ''' + tag + r''' # end tag
 226                         (?P<punct>([.,!:)\]]|\(\d+\))*) # punctuation
 227                         (?=$|\s) # suffix (don't consume it so that subsequent tags can match)
 228                         ''', flags = re.DOTALL | re.VERBOSE)
 229
 230         def _create_replacer(self):
 231                 def replacer(m):
 232                         punct = m.group('punct')
 233                         if not punct:
 234                                 punct = ''
 235                         return '{0}{1}{2}'.format(m.group(1), m.group('text'), punct)
 236                 return replacer
 237
 238         def replace(self, text):
 239                 if not self.__replacer:
 240                         self.__replacer = self._create_replacer()
 241                 text = re.sub(self.__matcher_b, self.__replacer, text)
 242                 return re.sub(self.__matcher_i, self.__replacer, text)
 243
 244 class GroffTagReplacer(TagReplacer):
 245         def _create_replacer(self):
 246                 def replacer(m):
 247                         nl = '\n' if m.group(1) else ''
 248                         format = 'I' if m.group('tag') == '_' else 'B'
 249                         brack = m.group('brack')
 250                         if not brack:
 251                                 brack = ''
 252                         punct = m.group('punct')
 253                         if not punct:
 254                                 punct = ''
 255                         text = re.sub(r'[\r\n\t]', ' ', m.group('text'))
 256                         return '{0}.R{1} "{2}" "{3}" "{4}"\n'.format(nl, format, brack, text, punct)
 257                 return replacer
 258
 259 class ConfFormatter:
 260         """Formats options to a strongswan.conf snippet"""
 261         def __init__(self):
 262                 self.__indent = '    '
 263                 self.__wrapper = TextWrapper(width = 80, replace_whitespace = True,
 264                                                                          break_long_words = False, break_on_hyphens = False)
 265                 self.__tags = TagReplacer()
 266
 267         def __print_description(self, opt, indent):
 268                 if len(opt.desc):
 269                         self.__wrapper.initial_indent = '{0}# '.format(self.__indent * indent)
 270                         self.__wrapper.subsequent_indent = self.__wrapper.initial_indent
 271                         print(self.__wrapper.fill(self.__tags.replace(opt.desc[0])))
 272
 273         def __print_option(self, opt, indent, commented):
 274                 """Print a single option with description and default value"""
 275                 comment = "# " if commented or opt.commented else ""
 276                 self.__print_description(opt, indent)
 277                 if opt.include:
 278                         print('{0}{1} {2}'.format(self.__indent * indent, opt.name, opt.default))
 279                 elif opt.default:
 280                         print('{0}{1}{2} = {3}'.format(self.__indent * indent, comment, opt.name, opt.default))
 281                 else:
 282                         print('{0}{1}{2} ='.format(self.__indent * indent, comment, opt.name))
 283                 print('')
 284
 285         def __print_section(self, section, indent, commented):
 286                 """Print a section with all options"""
 287                 commented = commented or section.commented
 288                 comment = "# " if commented else ""
 289                 self.__print_description(section, indent)
 290                 print('{0}{1}{2} {{'.format(self.__indent * indent, comment, section.name))
 291                 print('')
 292                 for o in sorted(section.options, key=cmp_to_key(ConfigOption.cmp)):
 293                         if o.section:
 294                                 self.__print_section(o, indent + 1, commented)
 295                         else:
 296                                 self.__print_option(o, indent + 1, commented)
 297                 print('{0}{1}}}'.format(self.__indent * indent, comment))
 298                 print('')
 299
 300         def format(self, options):
 301                 """Print a list of options"""
 302                 if not options:
 303                         return
 304                 for option in sorted(options, key=cmp_to_key(ConfigOption.cmp)):
 305                         if option.section:
 306                                 self.__print_section(option, 0, False)
 307                         else:
 308                                 self.__print_option(option, 0, False)
 309
 310 class ManFormatter:
 311         """Formats a list of options into a groff snippet"""
 312         def __init__(self):
 313                 self.__wrapper = TextWrapper(width = 80, replace_whitespace = False,
 314                                                                          break_long_words = False, break_on_hyphens = False)
 315                 self.__tags = GroffTagReplacer()
 316
 317         def __groffize(self, text):
 318                 """Encode text as groff text"""
 319                 text = self.__tags.replace(text)
 320                 text = re.sub(r'(?<!\\)-', r'\\-', text)
 321                 # remove any leading whitespace
 322                 return re.sub(r'^\s+', '', text, flags = re.MULTILINE)
 323
 324         def __format_option(self, option):
 325                 """Print a single option"""
 326                 if option.section and not len(option.desc):
 327                         return
 328                 if option.include:
 329                         return
 330                 if option.section:
 331                         print('.TP\n.B {0}\n.br'.format(option.fullname))
 332                 else:
 333                         print('.TP')
 334                         default = option.default if option.default else ''
 335                         print('.BR {0} " [{1}]"'.format(option.fullname, default))
 336                 for para in option.desc if len(option.desc) < 2 else option.desc[1:]:
 337                         print(self.__groffize(self.__wrapper.fill(para)))
 338                         print('')
 339
 340         def format(self, options):
 341                 """Print a list of options"""
 342                 if not options:
 343                         return
 344                 for option in options:
 345                         if option.section:
 346                                 self.__format_option(option)
 347                                 self.format(option.options)
 348                         else:
 349                                 self.__format_option(option)
 350
 351 args = ArgumentParser()
 352 args.add_argument('file', nargs='*',
 353                                   help="files to process, omit to read input from stdin")
 354 args.add_argument("-f", "--format", dest="format", choices=["conf", "man"],
 355                                   help="output format (default: %(default)s)", default="conf")
 356 args.add_argument("-r", "--root", dest="root", metavar="NAME",
 357                                   help="root section of which options are printed; everything"
 358                                   "is printed if not found")
 359 args.add_argument("-n", "--nosort", action="store_false", dest="sort",
 360                                   default=True, help="do not sort sections alphabetically")
 361
 362 opts = args.parse_args()
 363
 364 parser = Parser(opts.sort)
 365 if len(opts.file):
 366         for filename in opts.file:
 367                 try:
 368                         with open(filename, 'r') as file:
 369                                 parser.parse(file)
 370                 except IOError as e:
 371                         sys.stderr.write("Unable to open '{0}': {1}\n".format(filename, e.strerror))
 372 else:
 373         parser.parse(sys.stdin)
 374
 375 options = parser.options
 376 if (opts.root):
 377         root = parser.get_option(opts.root)
 378         if root:
 379                 options = root.options
 380
 381 if opts.format == "conf":
 382         formatter = ConfFormatter()
 383 elif opts.format == "man":
 384         formatter = ManFormatter()
 385
 386 formatter.format(options)