1 #!/usr/bin/env python 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. 3 # Use of this source code is governed by a BSD-style license that can be 4 # found in the LICENSE file. 5 6 '''python %prog [options] platform chromium_os_flag template 7 8 platform specifies which platform source is being generated for 9 and can be one of (win, mac, linux) 10 chromium_os_flag should be 1 if this is a Chromium OS build 11 template is the path to a .json policy template file.''' 12 13 from __future__ import with_statement 14 from functools import partial 15 import json 16 from optparse import OptionParser 17 import re 18 import sys 19 import textwrap 20 import types 21 22 23 CHROME_POLICY_KEY = 'SOFTWARE\\\\Policies\\\\Google\\\\Chrome' 24 CHROMIUM_POLICY_KEY = 'SOFTWARE\\\\Policies\\\\Chromium' 25 26 27 class PolicyDetails: 28 """Parses a policy template and caches all its details.""" 29 30 # Maps policy types to a tuple with 3 other types: 31 # - the equivalent base::Value::Type or 'TYPE_EXTERNAL' if the policy 32 # references external data 33 # - the equivalent Protobuf field type 34 # - the name of one of the protobufs for shared policy types 35 # TODO(joaodasilva): refactor the 'dict' type into a more generic 'json' type 36 # that can also be used to represent lists of other JSON objects. 37 TYPE_MAP = { 38 'dict': ('TYPE_DICTIONARY', 'string', 'String'), 39 'external': ('TYPE_EXTERNAL', 'string', 'String'), 40 'int': ('TYPE_INTEGER', 'int64', 'Integer'), 41 'int-enum': ('TYPE_INTEGER', 'int64', 'Integer'), 42 'list': ('TYPE_LIST', 'StringList', 'StringList'), 43 'main': ('TYPE_BOOLEAN', 'bool', 'Boolean'), 44 'string': ('TYPE_STRING', 'string', 'String'), 45 'string-enum': ('TYPE_STRING', 'string', 'String'), 46 'string-enum-list': ('TYPE_LIST', 'StringList', 'StringList'), 47 } 48 49 class EnumItem: 50 def __init__(self, item): 51 self.caption = PolicyDetails._RemovePlaceholders(item['caption']) 52 self.value = item['value'] 53 54 def __init__(self, policy, os, is_chromium_os): 55 self.id = policy['id'] 56 self.name = policy['name'] 57 features = policy.get('features', {}) 58 self.can_be_recommended = features.get('can_be_recommended', False) 59 self.can_be_mandatory = features.get('can_be_mandatory', True) 60 self.is_deprecated = policy.get('deprecated', False) 61 self.is_device_only = policy.get('device_only', False) 62 self.schema = policy.get('schema', {}) 63 self.has_enterprise_default = 'default_for_enterprise_users' in policy 64 if self.has_enterprise_default: 65 self.enterprise_default = policy['default_for_enterprise_users'] 66 67 expected_platform = 'chrome_os' if is_chromium_os else os.lower() 68 self.platforms = [] 69 for platform, version in [ p.split(':') for p in policy['supported_on'] ]: 70 if not version.endswith('-'): 71 continue 72 73 if platform.startswith('chrome.'): 74 platform_sub = platform[7:] 75 if platform_sub == '*': 76 self.platforms.extend(['win', 'mac', 'linux']) 77 else: 78 self.platforms.append(platform_sub) 79 else: 80 self.platforms.append(platform) 81 82 self.platforms.sort() 83 self.is_supported = expected_platform in self.platforms 84 85 if not PolicyDetails.TYPE_MAP.has_key(policy['type']): 86 raise NotImplementedError('Unknown policy type for %s: %s' % 87 (policy['name'], policy['type'])) 88 self.policy_type, self.protobuf_type, self.policy_protobuf_type = \ 89 PolicyDetails.TYPE_MAP[policy['type']] 90 self.schema = policy['schema'] 91 92 self.desc = '\n'.join( 93 map(str.strip, 94 PolicyDetails._RemovePlaceholders(policy['desc']).splitlines())) 95 self.caption = PolicyDetails._RemovePlaceholders(policy['caption']) 96 self.max_size = policy.get('max_size', 0) 97 98 items = policy.get('items') 99 if items is None: 100 self.items = None 101 else: 102 self.items = [ PolicyDetails.EnumItem(entry) for entry in items ] 103 104 PH_PATTERN = re.compile('<ph[^>]*>([^<]*|[^<]*<ex>([^<]*)</ex>[^<]*)</ph>') 105 106 # Simplistic grit placeholder stripper. 107 @staticmethod 108 def _RemovePlaceholders(text): 109 result = '' 110 pos = 0 111 for m in PolicyDetails.PH_PATTERN.finditer(text): 112 result += text[pos:m.start(0)] 113 result += m.group(2) or m.group(1) 114 pos = m.end(0) 115 result += text[pos:] 116 return result 117 118 119 def main(): 120 parser = OptionParser(usage=__doc__) 121 parser.add_option('--pch', '--policy-constants-header', dest='header_path', 122 help='generate header file of policy constants', 123 metavar='FILE') 124 parser.add_option('--pcc', '--policy-constants-source', dest='source_path', 125 help='generate source file of policy constants', 126 metavar='FILE') 127 parser.add_option('--cpp', '--cloud-policy-protobuf', 128 dest='cloud_policy_proto_path', 129 help='generate cloud policy protobuf file', 130 metavar='FILE') 131 parser.add_option('--csp', '--chrome-settings-protobuf', 132 dest='chrome_settings_proto_path', 133 help='generate chrome settings protobuf file', 134 metavar='FILE') 135 parser.add_option('--cpd', '--cloud-policy-decoder', 136 dest='cloud_policy_decoder_path', 137 help='generate C++ code decoding the cloud policy protobuf', 138 metavar='FILE') 139 140 (opts, args) = parser.parse_args() 141 142 if len(args) != 3: 143 print 'exactly platform, chromium_os flag and input file must be specified.' 144 parser.print_help() 145 return 2 146 147 os = args[0] 148 is_chromium_os = args[1] == '1' 149 template_file_name = args[2] 150 151 template_file_contents = _LoadJSONFile(template_file_name) 152 policy_details = [ PolicyDetails(policy, os, is_chromium_os) 153 for policy in _Flatten(template_file_contents) ] 154 sorted_policy_details = sorted(policy_details, key=lambda policy: policy.name) 155 156 def GenerateFile(path, writer, sorted=False): 157 if path: 158 with open(path, 'w') as f: 159 _OutputGeneratedWarningHeader(f, template_file_name) 160 writer(sorted and sorted_policy_details or policy_details, os, f) 161 162 GenerateFile(opts.header_path, _WritePolicyConstantHeader, sorted=True) 163 GenerateFile(opts.source_path, _WritePolicyConstantSource, sorted=True) 164 GenerateFile(opts.cloud_policy_proto_path, _WriteCloudPolicyProtobuf) 165 GenerateFile(opts.chrome_settings_proto_path, _WriteChromeSettingsProtobuf) 166 GenerateFile(opts.cloud_policy_decoder_path, _WriteCloudPolicyDecoder) 167 168 return 0 169 170 171 #------------------ shared helpers ---------------------------------# 172 173 def _OutputGeneratedWarningHeader(f, template_file_path): 174 f.write('//\n' 175 '// DO NOT MODIFY THIS FILE DIRECTLY!\n' 176 '// IT IS GENERATED BY generate_policy_source.py\n' 177 '// FROM ' + template_file_path + '\n' 178 '//\n\n') 179 180 181 COMMENT_WRAPPER = textwrap.TextWrapper() 182 COMMENT_WRAPPER.width = 80 183 COMMENT_WRAPPER.initial_indent = '// ' 184 COMMENT_WRAPPER.subsequent_indent = '// ' 185 COMMENT_WRAPPER.replace_whitespace = False 186 187 188 # Writes a comment, each line prefixed by // and wrapped to 80 spaces. 189 def _OutputComment(f, comment): 190 for line in comment.splitlines(): 191 if len(line) == 0: 192 f.write('//') 193 else: 194 f.write(COMMENT_WRAPPER.fill(line)) 195 f.write('\n') 196 197 198 # Returns an iterator over all the policies in |template_file_contents|. 199 def _Flatten(template_file_contents): 200 for policy in template_file_contents['policy_definitions']: 201 if policy['type'] == 'group': 202 for sub_policy in policy['policies']: 203 yield sub_policy 204 else: 205 yield policy 206 207 208 def _LoadJSONFile(json_file): 209 with open(json_file, 'r') as f: 210 text = f.read() 211 return eval(text) 212 213 214 #------------------ policy constants header ------------------------# 215 216 def _WritePolicyConstantHeader(policies, os, f): 217 f.write('#ifndef CHROME_COMMON_POLICY_CONSTANTS_H_\n' 218 '#define CHROME_COMMON_POLICY_CONSTANTS_H_\n' 219 '\n' 220 '#include <string>\n' 221 '\n' 222 '#include "base/basictypes.h"\n' 223 '#include "base/values.h"\n' 224 '#include "components/policy/core/common/policy_details.h"\n' 225 '#include "components/policy/core/common/policy_map.h"\n' 226 '\n' 227 'namespace policy {\n' 228 '\n' 229 'namespace internal {\n' 230 'struct SchemaData;\n' 231 '}\n\n') 232 233 if os == 'win': 234 f.write('// The windows registry path where Chrome policy ' 235 'configuration resides.\n' 236 'extern const wchar_t kRegistryChromePolicyKey[];\n') 237 238 f.write('#if defined (OS_CHROMEOS)\n' 239 '// Sets default values for enterprise users.\n' 240 'void SetEnterpriseUsersDefaults(PolicyMap* policy_map);\n' 241 '#endif\n' 242 '\n' 243 '// Returns the PolicyDetails for |policy| if |policy| is a known\n' 244 '// Chrome policy, otherwise returns NULL.\n' 245 'const PolicyDetails* GetChromePolicyDetails(' 246 'const std::string& policy);\n' 247 '\n' 248 '// Returns the schema data of the Chrome policy schema.\n' 249 'const internal::SchemaData* GetChromeSchemaData();\n' 250 '\n') 251 f.write('// Key names for the policy settings.\n' 252 'namespace key {\n\n') 253 for policy in policies: 254 # TODO(joaodasilva): Include only supported policies in 255 # configuration_policy_handler.cc and configuration_policy_handler_list.cc 256 # so that these names can be conditional on 'policy.is_supported'. 257 # http://crbug.com/223616 258 f.write('extern const char k' + policy.name + '[];\n') 259 f.write('\n} // namespace key\n\n' 260 '} // namespace policy\n\n' 261 '#endif // CHROME_COMMON_POLICY_CONSTANTS_H_\n') 262 263 264 #------------------ policy constants source ------------------------# 265 266 # A mapping of the simple schema types to base::Value::Types. 267 SIMPLE_SCHEMA_NAME_MAP = { 268 'boolean': 'TYPE_BOOLEAN', 269 'integer': 'TYPE_INTEGER', 270 'null' : 'TYPE_NULL', 271 'number' : 'TYPE_DOUBLE', 272 'string' : 'TYPE_STRING', 273 } 274 275 class SchemaNodesGenerator: 276 """Builds the internal structs to represent a JSON schema.""" 277 278 def __init__(self, shared_strings): 279 """Creates a new generator. 280 281 |shared_strings| is a map of strings to a C expression that evaluates to 282 that string at runtime. This mapping can be used to reuse existing string 283 constants.""" 284 self.shared_strings = shared_strings 285 self.schema_nodes = [] 286 self.property_nodes = [] 287 self.properties_nodes = [] 288 self.restriction_nodes = [] 289 self.int_enums = [] 290 self.string_enums = [] 291 self.simple_types = { 292 'boolean': None, 293 'integer': None, 294 'null': None, 295 'number': None, 296 'string': None, 297 } 298 self.stringlist_type = None 299 self.ranges = {} 300 self.id_map = {} 301 302 def GetString(self, s): 303 if s in self.shared_strings: 304 return self.shared_strings[s] 305 # Generate JSON escaped string, which is slightly different from desired 306 # C/C++ escaped string. Known differences includes unicode escaping format. 307 return json.dumps(s) 308 309 def AppendSchema(self, type, extra, comment=''): 310 index = len(self.schema_nodes) 311 self.schema_nodes.append((type, extra, comment)) 312 return index 313 314 def AppendRestriction(self, first, second): 315 r = (str(first), str(second)) 316 if not r in self.ranges: 317 self.ranges[r] = len(self.restriction_nodes) 318 self.restriction_nodes.append(r) 319 return self.ranges[r] 320 321 def GetSimpleType(self, name): 322 if self.simple_types[name] == None: 323 self.simple_types[name] = self.AppendSchema( 324 SIMPLE_SCHEMA_NAME_MAP[name], 325 -1, 326 'simple type: ' + name) 327 return self.simple_types[name] 328 329 def GetStringList(self): 330 if self.stringlist_type == None: 331 self.stringlist_type = self.AppendSchema( 332 'TYPE_LIST', 333 self.GetSimpleType('string'), 334 'simple type: stringlist') 335 return self.stringlist_type 336 337 def SchemaHaveRestriction(self, schema): 338 return any(keyword in schema for keyword in 339 ['minimum', 'maximum', 'enum', 'pattern']) 340 341 def IsConsecutiveInterval(self, seq): 342 sortedSeq = sorted(seq) 343 return all(sortedSeq[i] + 1 == sortedSeq[i + 1] 344 for i in xrange(len(sortedSeq) - 1)) 345 346 def GetEnumIntegerType(self, schema, name): 347 assert all(type(x) == int for x in schema['enum']) 348 possible_values = schema['enum'] 349 if self.IsConsecutiveInterval(possible_values): 350 index = self.AppendRestriction(max(possible_values), min(possible_values)) 351 return self.AppendSchema('TYPE_INTEGER', index, 352 'integer with enumeration restriction (use range instead): %s' % name) 353 offset_begin = len(self.int_enums) 354 self.int_enums += possible_values 355 offset_end = len(self.int_enums) 356 return self.AppendSchema('TYPE_INTEGER', 357 self.AppendRestriction(offset_begin, offset_end), 358 'integer with enumeration restriction: %s' % name) 359 360 def GetEnumStringType(self, schema, name): 361 assert all(type(x) == str for x in schema['enum']) 362 offset_begin = len(self.string_enums) 363 self.string_enums += schema['enum'] 364 offset_end = len(self.string_enums) 365 return self.AppendSchema('TYPE_STRING', 366 self.AppendRestriction(offset_begin, offset_end), 367 'string with enumeration restriction: %s' % name) 368 369 def GetEnumType(self, schema, name): 370 if len(schema['enum']) == 0: 371 raise RuntimeError('Empty enumeration in %s' % name) 372 elif schema['type'] == 'integer': 373 return self.GetEnumIntegerType(schema, name) 374 elif schema['type'] == 'string': 375 return self.GetEnumStringType(schema, name) 376 else: 377 raise RuntimeError('Unknown enumeration type in %s' % name) 378 379 def GetPatternType(self, schema, name): 380 if schema['type'] != 'string': 381 raise RuntimeError('Unknown pattern type in %s' % name) 382 pattern = schema['pattern'] 383 # Try to compile the pattern to validate it, note that the syntax used 384 # here might be slightly different from re2. 385 # TODO(binjin): Add a python wrapper of re2 and use it here. 386 re.compile(pattern) 387 index = len(self.string_enums); 388 self.string_enums.append(pattern); 389 return self.AppendSchema('TYPE_STRING', 390 self.AppendRestriction(index, index), 391 'string with pattern restriction: %s' % name); 392 393 def GetRangedType(self, schema, name): 394 if schema['type'] != 'integer': 395 raise RuntimeError('Unknown ranged type in %s' % name) 396 min_value_set, max_value_set = False, False 397 if 'minimum' in schema: 398 min_value = int(schema['minimum']) 399 min_value_set = True 400 if 'maximum' in schema: 401 max_value = int(schema['minimum']) 402 max_value_set = True 403 if min_value_set and max_value_set and min_value > max_value: 404 raise RuntimeError('Invalid ranged type in %s' % name) 405 index = self.AppendRestriction( 406 str(max_value) if max_value_set else 'INT_MAX', 407 str(min_value) if min_value_set else 'INT_MIN') 408 return self.AppendSchema('TYPE_INTEGER', 409 index, 410 'integer with ranged restriction: %s' % name) 411 412 def Generate(self, schema, name): 413 """Generates the structs for the given schema. 414 415 |schema|: a valid JSON schema in a dictionary. 416 |name|: the name of the current node, for the generated comments.""" 417 if schema.has_key('$ref'): 418 if schema.has_key('id'): 419 raise RuntimeError("Schemas with a $ref can't have an id") 420 if not isinstance(schema['$ref'], types.StringTypes): 421 raise RuntimeError("$ref attribute must be a string") 422 return schema['$ref'] 423 if schema['type'] in self.simple_types: 424 if not self.SchemaHaveRestriction(schema): 425 # Simple types use shared nodes. 426 return self.GetSimpleType(schema['type']) 427 elif 'enum' in schema: 428 return self.GetEnumType(schema, name) 429 elif 'pattern' in schema: 430 return self.GetPatternType(schema, name) 431 else: 432 return self.GetRangedType(schema, name) 433 434 if schema['type'] == 'array': 435 # Special case for lists of strings, which is a common policy type. 436 # The 'type' may be missing if the schema has a '$ref' attribute. 437 if schema['items'].get('type', '') == 'string': 438 return self.GetStringList() 439 return self.AppendSchema('TYPE_LIST', 440 self.GenerateAndCollectID(schema['items'], 'items of ' + name)) 441 elif schema['type'] == 'object': 442 # Reserve an index first, so that dictionaries come before their 443 # properties. This makes sure that the root node is the first in the 444 # SchemaNodes array. 445 index = self.AppendSchema('TYPE_DICTIONARY', -1) 446 447 if 'additionalProperties' in schema: 448 additionalProperties = self.GenerateAndCollectID( 449 schema['additionalProperties'], 450 'additionalProperties of ' + name) 451 else: 452 additionalProperties = -1 453 454 # Properties must be sorted by name, for the binary search lookup. 455 # Note that |properties| must be evaluated immediately, so that all the 456 # recursive calls to Generate() append the necessary child nodes; if 457 # |properties| were a generator then this wouldn't work. 458 sorted_properties = sorted(schema.get('properties', {}).items()) 459 properties = [ 460 (self.GetString(key), self.GenerateAndCollectID(subschema, key)) 461 for key, subschema in sorted_properties ] 462 463 pattern_properties = [] 464 for pattern, subschema in schema.get('patternProperties', {}).items(): 465 pattern_properties.append((self.GetString(pattern), 466 self.GenerateAndCollectID(subschema, pattern))); 467 468 begin = len(self.property_nodes) 469 self.property_nodes += properties 470 end = len(self.property_nodes) 471 self.property_nodes += pattern_properties 472 pattern_end = len(self.property_nodes) 473 474 if index == 0: 475 self.root_properties_begin = begin 476 self.root_properties_end = end 477 478 extra = len(self.properties_nodes) 479 self.properties_nodes.append((begin, end, pattern_end, 480 additionalProperties, name)) 481 482 # Set the right data at |index| now. 483 self.schema_nodes[index] = ('TYPE_DICTIONARY', extra, name) 484 return index 485 else: 486 assert False 487 488 def GenerateAndCollectID(self, schema, name): 489 """A wrapper of Generate(), will take the return value, check and add 'id' 490 attribute to self.id_map. The wrapper needs to be used for every call to 491 Generate(). 492 """ 493 index = self.Generate(schema, name) 494 if not schema.has_key('id'): 495 return index 496 id_str = schema['id'] 497 if self.id_map.has_key(id_str): 498 raise RuntimeError('Duplicated id: ' + id_str) 499 self.id_map[id_str] = index 500 return index 501 502 def Write(self, f): 503 """Writes the generated structs to the given file. 504 505 |f| an open file to write to.""" 506 f.write('const internal::SchemaNode kSchemas[] = {\n' 507 '// Type Extra\n') 508 for type, extra, comment in self.schema_nodes: 509 type += ',' 510 f.write(' { base::Value::%-18s %3d }, // %s\n' % (type, extra, comment)) 511 f.write('};\n\n') 512 513 if self.property_nodes: 514 f.write('const internal::PropertyNode kPropertyNodes[] = {\n' 515 '// Property #Schema\n') 516 for key, schema in self.property_nodes: 517 key += ',' 518 f.write(' { %-50s %6d },\n' % (key, schema)) 519 f.write('};\n\n') 520 521 if self.properties_nodes: 522 f.write('const internal::PropertiesNode kProperties[] = {\n' 523 '// Begin End PatternEnd Additional Properties\n') 524 for node in self.properties_nodes: 525 f.write(' { %5d, %5d, %10d, %5d }, // %s\n' % node) 526 f.write('};\n\n') 527 528 if self.restriction_nodes: 529 f.write('const internal::RestrictionNode kRestrictionNodes[] = {\n') 530 f.write('// FIRST, SECOND\n') 531 for first, second in self.restriction_nodes: 532 f.write(' {{ %-8s %4s}},\n' % (first + ',', second)) 533 f.write('};\n\n') 534 535 if self.int_enums: 536 f.write('const int kIntegerEnumerations[] = {\n') 537 for possible_values in self.int_enums: 538 f.write(' %d,\n' % possible_values) 539 f.write('};\n\n') 540 541 if self.string_enums: 542 f.write('const char* kStringEnumerations[] = {\n') 543 for possible_values in self.string_enums: 544 f.write(' %s,\n' % self.GetString(possible_values)) 545 f.write('};\n\n') 546 547 f.write('const internal::SchemaData kChromeSchemaData = {\n' 548 ' kSchemas,\n') 549 f.write(' kPropertyNodes,\n' if self.property_nodes else ' NULL,\n') 550 f.write(' kProperties,\n' if self.properties_nodes else ' NULL,\n') 551 f.write(' kRestrictionNodes,\n' if self.restriction_nodes else ' NULL,\n') 552 f.write(' kIntegerEnumerations,\n' if self.int_enums else ' NULL,\n') 553 f.write(' kStringEnumerations,\n' if self.string_enums else ' NULL,\n') 554 f.write('};\n\n') 555 556 def GetByID(self, id_str): 557 if not isinstance(id_str, types.StringTypes): 558 return id_str 559 if not self.id_map.has_key(id_str): 560 raise RuntimeError('Invalid $ref: ' + id_str) 561 return self.id_map[id_str] 562 563 def ResolveID(self, index, params): 564 return params[:index] + (self.GetByID(params[index]),) + params[index+1:] 565 566 def ResolveReferences(self): 567 """Resolve reference mapping, required to be called after Generate() 568 569 After calling Generate(), the type of indices used in schema structures 570 might be either int or string. An int type suggests that it's a resolved 571 index, but for string type it's unresolved. Resolving a reference is as 572 simple as looking up for corresponding ID in self.id_map, and replace the 573 old index with the mapped index. 574 """ 575 self.schema_nodes = map(partial(self.ResolveID, 1), self.schema_nodes) 576 self.property_nodes = map(partial(self.ResolveID, 1), self.property_nodes) 577 self.properties_nodes = map(partial(self.ResolveID, 3), 578 self.properties_nodes) 579 580 def _WritePolicyConstantSource(policies, os, f): 581 f.write('#include "policy/policy_constants.h"\n' 582 '\n' 583 '#include <algorithm>\n' 584 '#include <climits>\n' 585 '\n' 586 '#include "base/logging.h"\n' 587 '#include "components/policy/core/common/schema_internal.h"\n' 588 '\n' 589 'namespace policy {\n' 590 '\n' 591 'namespace {\n' 592 '\n') 593 594 # Generate the Chrome schema. 595 chrome_schema = { 596 'type': 'object', 597 'properties': {}, 598 } 599 shared_strings = {} 600 for policy in policies: 601 shared_strings[policy.name] = "key::k%s" % policy.name 602 if policy.is_supported: 603 chrome_schema['properties'][policy.name] = policy.schema 604 605 # Note: this list must be kept in sync with the known property list of the 606 # Chrome schema, so that binary seaching in the PropertyNode array gets the 607 # right index on this array as well. See the implementation of 608 # GetChromePolicyDetails() below. 609 f.write('const PolicyDetails kChromePolicyDetails[] = {\n' 610 '// is_deprecated is_device_policy id max_external_data_size\n') 611 for policy in policies: 612 if policy.is_supported: 613 f.write(' { %-14s %-16s %3s, %24s },\n' % ( 614 'true,' if policy.is_deprecated else 'false,', 615 'true,' if policy.is_device_only else 'false,', 616 policy.id, 617 policy.max_size)) 618 f.write('};\n\n') 619 620 schema_generator = SchemaNodesGenerator(shared_strings) 621 schema_generator.GenerateAndCollectID(chrome_schema, 'root node') 622 schema_generator.ResolveReferences() 623 schema_generator.Write(f) 624 625 f.write('bool CompareKeys(const internal::PropertyNode& node,\n' 626 ' const std::string& key) {\n' 627 ' return node.key < key;\n' 628 '}\n\n') 629 630 f.write('} // namespace\n\n') 631 632 if os == 'win': 633 f.write('#if defined(GOOGLE_CHROME_BUILD)\n' 634 'const wchar_t kRegistryChromePolicyKey[] = ' 635 'L"' + CHROME_POLICY_KEY + '";\n' 636 '#else\n' 637 'const wchar_t kRegistryChromePolicyKey[] = ' 638 'L"' + CHROMIUM_POLICY_KEY + '";\n' 639 '#endif\n\n') 640 641 f.write('const internal::SchemaData* GetChromeSchemaData() {\n' 642 ' return &kChromeSchemaData;\n' 643 '}\n\n') 644 645 f.write('#if defined (OS_CHROMEOS)\n' 646 'void SetEnterpriseUsersDefaults(PolicyMap* policy_map) {\n') 647 648 for policy in policies: 649 if policy.has_enterprise_default: 650 if policy.policy_type == 'TYPE_BOOLEAN': 651 creation_expression = 'new base::FundamentalValue(%s)' %\ 652 ('true' if policy.enterprise_default else 'false') 653 elif policy.policy_type == 'TYPE_INTEGER': 654 creation_expression = 'new base::FundamentalValue(%s)' %\ 655 policy.enterprise_default 656 elif policy.policy_type == 'TYPE_STRING': 657 creation_expression = 'new base::StringValue("%s")' %\ 658 policy.enterprise_default 659 else: 660 raise RuntimeError('Type %s of policy %s is not supported at ' 661 'enterprise defaults' % (policy.policy_type, 662 policy.name)) 663 f.write(' if (!policy_map->Get(key::k%s)) {\n' 664 ' policy_map->Set(key::k%s,\n' 665 ' POLICY_LEVEL_MANDATORY,\n' 666 ' POLICY_SCOPE_USER,\n' 667 ' %s,\n' 668 ' NULL);\n' 669 ' }\n' % (policy.name, policy.name, creation_expression)) 670 671 f.write('}\n' 672 '#endif\n\n') 673 674 f.write('const PolicyDetails* GetChromePolicyDetails(' 675 'const std::string& policy) {\n' 676 ' // First index in kPropertyNodes of the Chrome policies.\n' 677 ' static const int begin_index = %s;\n' 678 ' // One-past-the-end of the Chrome policies in kPropertyNodes.\n' 679 ' static const int end_index = %s;\n' % 680 (schema_generator.root_properties_begin, 681 schema_generator.root_properties_end)) 682 f.write(' const internal::PropertyNode* begin =\n' 683 ' kPropertyNodes + begin_index;\n' 684 ' const internal::PropertyNode* end = kPropertyNodes + end_index;\n' 685 ' const internal::PropertyNode* it =\n' 686 ' std::lower_bound(begin, end, policy, CompareKeys);\n' 687 ' if (it == end || it->key != policy)\n' 688 ' return NULL;\n' 689 ' // This relies on kPropertyNodes from begin_index to end_index\n' 690 ' // having exactly the same policies (and in the same order) as\n' 691 ' // kChromePolicyDetails, so that binary searching on the first\n' 692 ' // gets the same results as a binary search on the second would.\n' 693 ' // However, kPropertyNodes has the policy names and\n' 694 ' // kChromePolicyDetails doesn\'t, so we obtain the index into\n' 695 ' // the second array by searching the first to avoid duplicating\n' 696 ' // the policy name pointers.\n' 697 ' // Offsetting |it| from |begin| here obtains the index we\'re\n' 698 ' // looking for.\n' 699 ' size_t index = it - begin;\n' 700 ' CHECK_LT(index, arraysize(kChromePolicyDetails));\n' 701 ' return kChromePolicyDetails + index;\n' 702 '}\n\n') 703 704 f.write('namespace key {\n\n') 705 for policy in policies: 706 # TODO(joaodasilva): Include only supported policies in 707 # configuration_policy_handler.cc and configuration_policy_handler_list.cc 708 # so that these names can be conditional on 'policy.is_supported'. 709 # http://crbug.com/223616 710 f.write('const char k{name}[] = "{name}";\n'.format(name=policy.name)) 711 f.write('\n} // namespace key\n\n' 712 '} // namespace policy\n') 713 714 715 #------------------ policy protobufs --------------------------------# 716 717 CHROME_SETTINGS_PROTO_HEAD = ''' 718 syntax = "proto2"; 719 720 option optimize_for = LITE_RUNTIME; 721 722 package enterprise_management; 723 724 // For StringList and PolicyOptions. 725 import "cloud_policy.proto"; 726 727 ''' 728 729 730 CLOUD_POLICY_PROTO_HEAD = ''' 731 syntax = "proto2"; 732 733 option optimize_for = LITE_RUNTIME; 734 735 package enterprise_management; 736 737 message StringList { 738 repeated string entries = 1; 739 } 740 741 message PolicyOptions { 742 enum PolicyMode { 743 // The given settings are applied regardless of user choice. 744 MANDATORY = 0; 745 // The user may choose to override the given settings. 746 RECOMMENDED = 1; 747 // No policy value is present and the policy should be ignored. 748 UNSET = 2; 749 } 750 optional PolicyMode mode = 1 [default = MANDATORY]; 751 } 752 753 message BooleanPolicyProto { 754 optional PolicyOptions policy_options = 1; 755 optional bool value = 2; 756 } 757 758 message IntegerPolicyProto { 759 optional PolicyOptions policy_options = 1; 760 optional int64 value = 2; 761 } 762 763 message StringPolicyProto { 764 optional PolicyOptions policy_options = 1; 765 optional string value = 2; 766 } 767 768 message StringListPolicyProto { 769 optional PolicyOptions policy_options = 1; 770 optional StringList value = 2; 771 } 772 773 ''' 774 775 776 # Field IDs [1..RESERVED_IDS] will not be used in the wrapping protobuf. 777 RESERVED_IDS = 2 778 779 780 def _WritePolicyProto(f, policy, fields): 781 _OutputComment(f, policy.caption + '\n\n' + policy.desc) 782 if policy.items is not None: 783 _OutputComment(f, '\nValid values:') 784 for item in policy.items: 785 _OutputComment(f, ' %s: %s' % (str(item.value), item.caption)) 786 if policy.policy_type == 'TYPE_DICTIONARY': 787 _OutputComment(f, '\nValue schema:\n%s' % 788 json.dumps(policy.schema, sort_keys=True, indent=4, 789 separators=(',', ': '))) 790 _OutputComment(f, '\nSupported on: %s' % ', '.join(policy.platforms)) 791 if policy.can_be_recommended and not policy.can_be_mandatory: 792 _OutputComment(f, '\nNote: this policy must have a RECOMMENDED ' +\ 793 'PolicyMode set in PolicyOptions.') 794 f.write('message %sProto {\n' % policy.name) 795 f.write(' optional PolicyOptions policy_options = 1;\n') 796 f.write(' optional %s %s = 2;\n' % (policy.protobuf_type, policy.name)) 797 f.write('}\n\n') 798 fields += [ ' optional %sProto %s = %s;\n' % 799 (policy.name, policy.name, policy.id + RESERVED_IDS) ] 800 801 802 def _WriteChromeSettingsProtobuf(policies, os, f): 803 f.write(CHROME_SETTINGS_PROTO_HEAD) 804 805 fields = [] 806 f.write('// PBs for individual settings.\n\n') 807 for policy in policies: 808 # Note: this protobuf also gets the unsupported policies, since it's an 809 # exaustive list of all the supported user policies on any platform. 810 if not policy.is_device_only: 811 _WritePolicyProto(f, policy, fields) 812 813 f.write('// --------------------------------------------------\n' 814 '// Big wrapper PB containing the above groups.\n\n' 815 'message ChromeSettingsProto {\n') 816 f.write(''.join(fields)) 817 f.write('}\n\n') 818 819 820 def _WriteCloudPolicyProtobuf(policies, os, f): 821 f.write(CLOUD_POLICY_PROTO_HEAD) 822 f.write('message CloudPolicySettings {\n') 823 for policy in policies: 824 if policy.is_supported and not policy.is_device_only: 825 f.write(' optional %sPolicyProto %s = %s;\n' % 826 (policy.policy_protobuf_type, policy.name, 827 policy.id + RESERVED_IDS)) 828 f.write('}\n\n') 829 830 831 #------------------ protobuf decoder -------------------------------# 832 833 CPP_HEAD = ''' 834 #include <limits> 835 #include <string> 836 837 #include "base/basictypes.h" 838 #include "base/callback.h" 839 #include "base/json/json_reader.h" 840 #include "base/logging.h" 841 #include "base/memory/scoped_ptr.h" 842 #include "base/memory/weak_ptr.h" 843 #include "base/values.h" 844 #include "components/policy/core/common/cloud/cloud_external_data_manager.h" 845 #include "components/policy/core/common/external_data_fetcher.h" 846 #include "components/policy/core/common/policy_map.h" 847 #include "policy/policy_constants.h" 848 #include "policy/proto/cloud_policy.pb.h" 849 850 using google::protobuf::RepeatedPtrField; 851 852 namespace policy { 853 854 namespace em = enterprise_management; 855 856 base::Value* DecodeIntegerValue(google::protobuf::int64 value) { 857 if (value < std::numeric_limits<int>::min() || 858 value > std::numeric_limits<int>::max()) { 859 LOG(WARNING) << "Integer value " << value 860 << " out of numeric limits, ignoring."; 861 return NULL; 862 } 863 864 return new base::FundamentalValue(static_cast<int>(value)); 865 } 866 867 base::ListValue* DecodeStringList(const em::StringList& string_list) { 868 base::ListValue* list_value = new base::ListValue; 869 RepeatedPtrField<std::string>::const_iterator entry; 870 for (entry = string_list.entries().begin(); 871 entry != string_list.entries().end(); ++entry) { 872 list_value->AppendString(*entry); 873 } 874 return list_value; 875 } 876 877 base::Value* DecodeJson(const std::string& json) { 878 scoped_ptr<base::Value> root( 879 base::JSONReader::Read(json, base::JSON_ALLOW_TRAILING_COMMAS)); 880 881 if (!root) 882 LOG(WARNING) << "Invalid JSON string, ignoring: " << json; 883 884 // Accept any Value type that parsed as JSON, and leave it to the handler to 885 // convert and check the concrete type. 886 return root.release(); 887 } 888 889 void DecodePolicy(const em::CloudPolicySettings& policy, 890 base::WeakPtr<CloudExternalDataManager> external_data_manager, 891 PolicyMap* map) { 892 ''' 893 894 895 CPP_FOOT = '''} 896 897 } // namespace policy 898 ''' 899 900 901 def _CreateValue(type, arg): 902 if type == 'TYPE_BOOLEAN': 903 return 'new base::FundamentalValue(%s)' % arg 904 elif type == 'TYPE_INTEGER': 905 return 'DecodeIntegerValue(%s)' % arg 906 elif type == 'TYPE_STRING': 907 return 'new base::StringValue(%s)' % arg 908 elif type == 'TYPE_LIST': 909 return 'DecodeStringList(%s)' % arg 910 elif type == 'TYPE_DICTIONARY' or type == 'TYPE_EXTERNAL': 911 return 'DecodeJson(%s)' % arg 912 else: 913 raise NotImplementedError('Unknown type %s' % type) 914 915 916 def _CreateExternalDataFetcher(type, name): 917 if type == 'TYPE_EXTERNAL': 918 return 'new ExternalDataFetcher(external_data_manager, key::k%s)' % name 919 return 'NULL' 920 921 922 def _WritePolicyCode(f, policy): 923 membername = policy.name.lower() 924 proto_type = '%sPolicyProto' % policy.policy_protobuf_type 925 f.write(' if (policy.has_%s()) {\n' % membername) 926 f.write(' const em::%s& policy_proto = policy.%s();\n' % 927 (proto_type, membername)) 928 f.write(' if (policy_proto.has_value()) {\n') 929 f.write(' PolicyLevel level = POLICY_LEVEL_MANDATORY;\n' 930 ' bool do_set = true;\n' 931 ' if (policy_proto.has_policy_options()) {\n' 932 ' do_set = false;\n' 933 ' switch(policy_proto.policy_options().mode()) {\n' 934 ' case em::PolicyOptions::MANDATORY:\n' 935 ' do_set = true;\n' 936 ' level = POLICY_LEVEL_MANDATORY;\n' 937 ' break;\n' 938 ' case em::PolicyOptions::RECOMMENDED:\n' 939 ' do_set = true;\n' 940 ' level = POLICY_LEVEL_RECOMMENDED;\n' 941 ' break;\n' 942 ' case em::PolicyOptions::UNSET:\n' 943 ' break;\n' 944 ' }\n' 945 ' }\n' 946 ' if (do_set) {\n') 947 f.write(' base::Value* value = %s;\n' % 948 (_CreateValue(policy.policy_type, 'policy_proto.value()'))) 949 # TODO(bartfab): |value| == NULL indicates that the policy value could not be 950 # parsed successfully. Surface such errors in the UI. 951 f.write(' if (value) {\n') 952 f.write(' ExternalDataFetcher* external_data_fetcher = %s;\n' % 953 _CreateExternalDataFetcher(policy.policy_type, policy.name)) 954 f.write(' map->Set(key::k%s, level, POLICY_SCOPE_USER,\n' % 955 policy.name) 956 f.write(' value, external_data_fetcher);\n' 957 ' }\n' 958 ' }\n' 959 ' }\n' 960 ' }\n') 961 962 963 def _WriteCloudPolicyDecoder(policies, os, f): 964 f.write(CPP_HEAD) 965 for policy in policies: 966 if policy.is_supported and not policy.is_device_only: 967 _WritePolicyCode(f, policy) 968 f.write(CPP_FOOT) 969 970 971 if __name__ == '__main__': 972 sys.exit(main()) 973
