source4/scripting/bin/w32err_code.py

   1 #!/usr/bin/env python
   2
   3 # Unix SMB/CIFS implementation.
   4 # Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19
  20 """Import generete werror.h/doserr.c files from WSPP HTML"""
  21
  22 import re
  23 import os
  24 import sys
  25 import urllib
  26 import pprint
  27 from xml.dom import minidom
  28 from optparse import OptionParser, OptionGroup
  29
  30 _wspp_werror_url = 'http://msdn.microsoft.com/en-us/library/cc231199%28PROT.10%29.aspx'
  31
  32 class WerrorHtmlParser(object):
  33     """
  34     Parses HTML from WSPP documentation generating dictionary of
  35     dictionaries with following keys:
  36       - "err_hex" - hex number (as string)
  37       - "err_name" - error name
  38       - "err_desc" - error long description
  39     For the key of returned dictionary err_hex is used,
  40     i.e. "hex-error-code-str" => {error dictionary object}
  41     """
  42
  43     ERROR_PREFIX = ['ERROR_', 'NERR_', 'FRS_', 'RPC_', 'EPT_', 'OR_', 'WAIT_TIMEOUT']
  44     ERROR_REPLACE = ['ERROR_']
  45
  46     def __init__(self, opt):
  47         self.opt = opt
  48         self._errors_skipped = []
  49         pass
  50
  51     def _is_error_code_name(self, err_name):
  52         for pref in self.ERROR_PREFIX:
  53             if err_name.startswith(pref):
  54                 return True
  55         return False
  56
  57     def _make_werr_name(self, err_name):
  58         err_name = err_name.upper()
  59         for pref in self.ERROR_REPLACE:
  60             if err_name.startswith(pref):
  61                 return err_name.replace(pref, 'WERR_', 1)
  62         return 'WERR_' + err_name
  63
  64     def parse_url(self, url):
  65         errors = {}
  66         html = self._load_url(url)
  67
  68         # let minidom to parse the tree, should be:
  69         # table -> tr -> td
  70         #     p -> [hex code, br, error code]
  71         #     p -> [description]
  72         table_node = minidom.parseString(html)
  73         for row_node in table_node.getElementsByTagName("tr"):
  74             # verify we got right number of td elements
  75             td_nodes = row_node.getElementsByTagName('td')
  76             if len(td_nodes) != 2:
  77                 continue
  78             # now get the real data
  79             p_nodes = row_node.getElementsByTagName('p')
  80             if len(p_nodes) != 2:   continue
  81             if len(p_nodes[0].childNodes) != 3: continue
  82             if len(p_nodes[1].childNodes) != 1: continue
  83             err_hex = str(p_nodes[0].childNodes[0].nodeValue)
  84             err_name = str(p_nodes[0].childNodes[2].nodeValue)
  85             err_desc = p_nodes[1].childNodes[0].nodeValue.encode('utf-8')
  86             err_desc = err_desc.replace('"', '\\"').replace("\'", "\\'")
  87             # do some checking
  88             if not err_hex.startswith('0x'):    continue
  89             if not self._is_error_code_name(err_name):
  90                 self._errors_skipped.append("%s - %s - %d" % (err_name, err_hex, int(err_hex, 16)))
  91                 continue
  92             # create entry
  93             err_name = self._make_werr_name(err_name)
  94             err_def = {'err_hex': err_hex,
  95                        'err_name': err_name,
  96                        'err_desc': err_desc,
  97                        'code': int(err_hex, 16)}
  98             errors[err_def['code']] = err_def
  99
 100         # print skipped errors
 101         if self.opt.print_skipped and len(self._errors_skipped):
 102             print "\nErrors skipped during HTML parsing:"
 103             pprint.pprint(self._errors_skipped)
 104             print "\n"
 105
 106         return errors
 107
 108     def _load_url(self, url):
 109         html_str = ""
 110         try:
 111             fp = urllib.urlopen(url)
 112             for line in fp:
 113                 html_str += line.strip()
 114             fp.close()
 115         except IOError, e:
 116             print "error loading url: " + e.strerror
 117             pass
 118
 119         # currently ERROR codes are rendered as table
 120         # locate table chunk with ERROR_SUCCESS
 121         html = [x for x in html_str.split('<table ') if "ERROR_SUCCESS" in x]
 122         html = '<table ' + html[0]
 123         pos = html.find('</table>')
 124         if pos == -1:
 125             return '';
 126         html = html[:pos] + '</table>'
 127
 128         # html clean up
 129         html = re.sub(r'<a[^>]*>(.*?)</a>', r'\1', html)
 130
 131         return html
 132
 133
 134 class WerrorGenerator(object):
 135     """
 136     provides methods to generate parts of werror.h and doserr.c files
 137     """
 138
 139     FNAME_WERRORS   = 'w32errors.lst'
 140     FNAME_WERROR_DEFS  = 'werror_defs.h'
 141     FNAME_DOSERR_DEFS = 'doserr_defs.c'
 142     FNAME_DOSERR_DESC = 'doserr_desc.c'
 143
 144     def __init__(self, opt):
 145         self.opt = opt
 146         self._out_dir = opt.out_dir
 147         pass
 148
 149     def _open_out_file(self, fname):
 150         fname = os.path.join(self._out_dir, fname)
 151         return open(fname, "w")
 152
 153     def _gen_werrors_list(self, errors):
 154         """uses 'errors' dictionary to display list of Win32 Errors"""
 155
 156         fp = self._open_out_file(self.FNAME_WERRORS)
 157         for err_code in sorted(errors.keys()):
 158             err_name = errors[err_code]['err_name']
 159             fp.write(err_name)
 160             fp.write("\n")
 161         fp.close()
 162
 163     def _gen_werror_defs(self, errors):
 164         """uses 'errors' dictionary to generate werror.h file"""
 165
 166         fp = self._open_out_file(self.FNAME_WERROR_DEFS)
 167         for err_code in sorted(errors.keys()):
 168             err_name = errors[err_code]['err_name']
 169             err_hex = errors[err_code]['err_hex']
 170             fp.write('#define %s\tW_ERROR(%s)' % (err_name, err_hex))
 171             fp.write("\n")
 172         fp.close()
 173
 174     def _gen_doserr_defs(self, errors):
 175         """uses 'errors' dictionary to generate defines in doserr.c file"""
 176
 177         fp = self._open_out_file(self.FNAME_DOSERR_DEFS)
 178         for err_code in sorted(errors.keys()):
 179             err_name = errors[err_code]['err_name']
 180             fp.write('\t{ "%s", %s },' % (err_name, err_name))
 181             fp.write("\n")
 182         fp.close()
 183
 184     def _gen_doserr_descriptions(self, errors):
 185         """uses 'errors' dictionary to generate descriptions in doserr.c file"""
 186
 187         fp = self._open_out_file(self.FNAME_DOSERR_DESC)
 188         for err_code in sorted(errors.keys()):
 189             err_name = errors[err_code]['err_name']
 190             fp.write('\t{ %s, "%s" },' % (err_name, errors[err_code]['err_desc']))
 191             fp.write("\n")
 192         fp.close()
 193
 194     def _lookup_error_by_name(self, err_name, defined_errors):
 195         for err in defined_errors.itervalues():
 196             if err['err_name'] == err_name:
 197                 return err
 198         return None
 199
 200     def _filter_errors(self, errors, defined_errors):
 201         """
 202         returns tuple (new_erros, diff_code_errors, diff_name_errors)
 203         new_errors - dictionary of errors not in defined_errors
 204         diff_code_errors - list of errors found in defined_errors
 205                            but with different value
 206         diff_name_errors - list of errors found with same code in
 207                             defined_errors, but with different name
 208         Most critical is diff_code_errors list to be empty!
 209         """
 210         new_errors = {}
 211         diff_code_errors = []
 212         diff_name_errors = []
 213         for err_def in errors.itervalues():
 214             add_error = True
 215             # try get defined error by code
 216             if defined_errors.has_key(err_def['code']):
 217                 old_err = defined_errors[err_def['code']]
 218                 if err_def['err_name'] != old_err['err_name']:
 219                     warning = {'msg': 'New and Old errors has different error names',
 220                                'err_new': err_def,
 221                                'err_old': old_err}
 222                     diff_name_errors.append(warning)
 223
 224             # sanity check for errors with same name but different values
 225             old_err = self._lookup_error_by_name(err_def['err_name'], defined_errors)
 226             if old_err:
 227                 if err_def['code'] != old_err['code']:
 228                     warning = {'msg': 'New and Old error defs has different error value',
 229                                'err_new': err_def,
 230                                'err_old': old_err}
 231                     diff_code_errors.append(warning)
 232                 # exclude error already defined with same name
 233                 add_error = False
 234             # do add the error in new_errors if everything is fine
 235             if add_error:
 236                 new_errors[err_def['code']] = err_def
 237             pass
 238         return (new_errors, diff_code_errors, diff_name_errors)
 239
 240     def generate(self, errors):
 241         # load already defined error codes
 242         werr_parser = WerrorParser(self.opt)
 243         (defined_errors,
 244          no_value_errors) = werr_parser.load_err_codes(self.opt.werror_file)
 245         if not defined_errors:
 246             print "\nUnable to load existing errors file: %s" % self.opt.werror_file
 247             sys.exit(1)
 248         if self.opt.verbose and len(no_value_errors):
 249             print "\nWarning: there are errors defines using macro value:"
 250             pprint.pprint(no_value_errors)
 251             print ""
 252         # filter generated error codes
 253         (new_errors,
 254          diff_code_errors,
 255          diff_name_errors) = self._filter_errors(errors, defined_errors)
 256         if diff_code_errors:
 257             print("\nFound %d errors with same names but different error values! Aborting."
 258                   % len(diff_code_errors))
 259             pprint.pprint(diff_code_errors)
 260             sys.exit(2)
 261
 262         if diff_name_errors:
 263             print("\nFound %d errors with same values but different names (should be normal)"
 264                   % len(diff_name_errors))
 265             pprint.pprint(diff_name_errors)
 266
 267         # finally generate output files
 268         self._gen_werror_defs(new_errors)
 269         self._gen_doserr_defs(new_errors)
 270         self._gen_werrors_list(errors)
 271         self._gen_doserr_descriptions(errors)
 272         pass
 273
 274 class WerrorParser(object):
 275     """
 276     Parses errors defined in werror.h file
 277     """
 278
 279     def __init__(self, opt):
 280         self.opt = opt
 281         pass
 282
 283     def _parse_werror_line(self, line):
 284         m = re.match('#define[ \t]*(.*?)[ \t]*W_ERROR\((.*?)\)', line)
 285         if not m or (len(m.groups()) != 2):
 286             return None
 287         if len(m.group(1)) == 0:
 288             return None
 289         if str(m.group(2)).startswith('0x'):
 290             err_code = int(m.group(2), 16)
 291         elif m.group(2).isdigit():
 292             err_code = int(m.group(2))
 293         else:
 294             self.err_no_values.append(line)
 295             return None
 296         return {'err_name': str(m.group(1)),
 297                 'err_hex': "0x%08X" % err_code,
 298                 'code': err_code}
 299         pass
 300
 301     def load_err_codes(self, fname):
 302         """
 303         Returns tuple of:
 304             dictionary of "hex_err_code" => {code, name}
 305                 "hex_err_code" is string
 306                 "code" is int value for the error
 307             list of errors that was ignored for some reason
 308         """
 309         # reset internal variables
 310         self.err_no_values = []
 311         err_codes = {}
 312         fp = open(fname)
 313         for line in fp.readlines():
 314             err_def = self._parse_werror_line(line)
 315             if err_def:
 316                 err_codes[err_def['code']] = err_def
 317         fp.close();
 318         return (err_codes, self.err_no_values)
 319
 320
 321
 322 def _generate_files(opt):
 323     parser = WerrorHtmlParser(opt)
 324     errors = parser.parse_url(opt.url)
 325
 326     out = WerrorGenerator(opt)
 327     out.generate(errors)
 328     pass
 329
 330
 331 if __name__ == '__main__':
 332     _cur_dir = os.path.abspath(os.path.dirname(__file__))
 333     opt_parser = OptionParser(usage="usage: %prog [options]", version="%prog 0.3")
 334     opt_group = OptionGroup(opt_parser, "Main options")
 335     opt_group.add_option("--url", dest="url",
 336                          default=_wspp_werror_url,
 337                          help="url for w32 error codes html - may be local file")
 338     opt_group.add_option("--out", dest="out_dir",
 339                          default=_cur_dir,
 340                          help="output dir for generated files")
 341     opt_group.add_option("--werror", dest="werror_file",
 342                          default=os.path.join(_cur_dir, 'werror.h'),
 343                          help="path to werror.h file")
 344     opt_group.add_option("--print_skipped",
 345                         action="store_true", dest="print_skipped", default=False,
 346                         help="print errors skipped during HTML parsing")
 347     opt_group.add_option("-q", "--quiet",
 348                         action="store_false", dest="verbose", default=True,
 349                         help="don't print warnings to stdout")
 350
 351     opt_parser.add_option_group(opt_group)
 352
 353     (options, args) = opt_parser.parse_args()
 354
 355     # add some options to be used internally
 356     options.err_defs_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_WERROR_DEFS)
 357     options.dos_defs_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_DOSERR_DEFS)
 358     options.dos_desc_file = os.path.join(options.out_dir, WerrorGenerator.FNAME_DOSERR_DESC)
 359
 360     # check options
 361     _generate_files(options)