class OptCheck:
# Constructor without the 'expected' parameter is for option presence checks (any value is OK)
def __init__(self, reason, decision, name, expected=None):
- if not reason or not decision or not name:
- sys.exit('[!] ERROR: invalid {} check for "{}"'.format(self.__class__.__name__, name))
+ assert(reason and decision and name), \
+ 'invalid {} check for "{}"'.format(self.__class__.__name__, name)
self.name = name
self.expected = expected
self.decision = decision
class ComplexOptCheck:
def __init__(self, *opts):
self.opts = opts
- if not self.opts:
- sys.exit('[!] ERROR: empty {} check'.format(self.__class__.__name__))
- if len(self.opts) == 1:
- sys.exit('[!] ERROR: useless {} check'.format(self.__class__.__name__))
- if not isinstance(opts[0], KconfigCheck) and not isinstance(opts[0], CmdlineCheck):
- sys.exit('[!] ERROR: invalid {} check: {}'.format(self.__class__.__name__, opts))
+ assert(self.opts), \
+ 'empty {} check'.format(self.__class__.__name__)
+ assert(len(self.opts) != 1), \
+ 'useless {} check: {}'.format(self.__class__.__name__, opts)
+ assert(isinstance(opts[0], (KconfigCheck, CmdlineCheck))), \
+ 'invalid {} check: {}'.format(self.__class__.__name__, opts)
self.result = None
- @property
- def name(self):
- return self.opts[0].name
-
@property
def type(self):
return 'complex'
@property
- def expected(self):
- return self.opts[0].expected
-
- @property
- def decision(self):
- return self.opts[0].decision
+ def name(self):
+ return self.opts[0].name
@property
- def reason(self):
- return self.opts[0].reason
+ def expected(self):
+ return self.opts[0].expected
def table_print(self, mode, with_results):
if mode == 'verbose':
# OR(<X_is_hardened>, <X_is_disabled>)
# OR(<X_is_hardened>, <old_X_is_hardened>)
def check(self):
- if not self.opts:
- sys.exit('[!] ERROR: invalid OR check')
for i, opt in enumerate(self.opts):
opt.check()
if opt.result.startswith('OK'):
self.result = 'OK: {} not found'.format(opt.name)
elif opt.result == 'OK: is present':
self.result = 'OK: {} is present'.format(opt.name)
- # VersionCheck provides enough info
- elif not opt.result.startswith('OK: version'):
- sys.exit('[!] ERROR: unexpected OK description "{}"'.format(opt.result))
+ else:
+ # VersionCheck provides enough info
+ assert(opt.result.startswith('OK: version')), \
+ 'unexpected OK description "{}"'.format(opt.result)
return
self.result = self.opts[0].result
else:
# VersionCheck provides enough info
self.result = opt.result
- if not opt.result.startswith('FAIL: version'):
- sys.exit('[!] ERROR: unexpected FAIL description "{}"'.format(opt.result))
+ assert(opt.result.startswith('FAIL: version')), \
+ 'unexpected FAIL description "{}"'.format(opt.result)
return
- sys.exit('[!] ERROR: invalid AND check')
def detect_arch(fname, archs):
known_options.append(o2.name)
continue
for o3 in o2.opts:
- if o3.type == 'complex':
- sys.exit('[!] ERROR: unexpected ComplexOptCheck inside {}'.format(o2.name))
+ assert(o3.type != 'complex'), \
+ 'unexpected ComplexOptCheck inside {}'.format(o2.name)
if hasattr(o3, 'name'):
known_options.append(o3.name)
def populate_simple_opt_with_data(opt, data, data_type):
- if opt.type == 'complex':
- sys.exit('[!] ERROR: unexpected ComplexOptCheck {}: {}'.format(opt.name, vars(opt)))
- if opt.type not in SIMPLE_OPTION_TYPES:
- sys.exit('[!] ERROR: invalid opt type "{}" for {}'.format(opt.type, opt.name))
- if data_type not in SIMPLE_OPTION_TYPES:
- sys.exit('[!] ERROR: invalid data type "{}"'.format(data_type))
+ assert(opt.type != 'complex'), \
+ 'unexpected ComplexOptCheck "{}"'.format(opt.name)
+ assert(opt.type in SIMPLE_OPTION_TYPES), \
+ 'invalid opt type "{}"'.format(opt.type)
+ assert(data_type in SIMPLE_OPTION_TYPES), \
+ 'invalid data type "{}"'.format(data_type)
if data_type != opt.type:
return
if data_type in ('kconfig', 'cmdline'):
opt.state = data.get(opt.name, None)
- elif data_type == 'version':
- opt.ver = data
else:
- sys.exit('[!] ERROR: unexpected data type "{}"'.format(data_type))
+ assert(data_type == 'version'), \
+ 'unexpected data type "{}"'.format(data_type)
+ opt.ver = data
def populate_opt_with_data(opt, data, data_type):
else:
populate_simple_opt_with_data(o, data, data_type)
else:
- if opt.type not in ('kconfig', 'cmdline'):
- sys.exit('[!] ERROR: bad type "{}" for a simple check {}'.format(opt.type, opt.name))
+ assert(opt.type in ('kconfig', 'cmdline')), \
+ 'bad type "{}" for a simple check'.format(opt.type)
populate_simple_opt_with_data(opt, data, data_type)
# add relevant kconfig checks to the checklist
add_kconfig_checks(config_checklist, arch)
+ if args.cmdline:
+ # add relevant cmdline checks to the checklist
+ add_cmdline_checks(config_checklist, arch)
+
# populate the checklist with the parsed kconfig data
parsed_kconfig_options = OrderedDict()
parse_kconfig_file(parsed_kconfig_options, args.config)
populate_with_data(config_checklist, kernel_version, 'version')
if args.cmdline:
- # add relevant cmdline checks to the checklist
- add_cmdline_checks(config_checklist, arch)
-
# populate the checklist with the parsed kconfig data
parsed_cmdline_options = OrderedDict()
parse_cmdline_file(parsed_cmdline_options, args.cmdline)
parser.print_help()
sys.exit(0)
-
-if __name__ == '__main__':
- main()