Fix up minschema after the conversion from JavaScript.
[amitay/samba.git] / source4 / scripting / bin / minschema
1 #!/usr/bin/python
2
3 #  work out the minimal schema for a set of objectclasses 
4 #
5
6 import base64
7 import optparse
8 import os
9 import sys
10
11 # Find right directory when running from source tree
12 sys.path.insert(0, "bin/python")
13
14 import samba
15 from samba import getopt as options, Ldb
16 from ldb import SCOPE_SUBTREE, SCOPE_BASE, LdbError
17 import sys
18
19 parser = optparse.OptionParser("minschema <URL> <classfile>")
20 sambaopts = options.SambaOptions(parser)
21 parser.add_option_group(sambaopts)
22 credopts = options.CredentialsOptions(parser)
23 parser.add_option_group(credopts)
24 parser.add_option_group(options.VersionOptions(parser))
25 parser.add_option("--verbose", help="Be verbose", action="store_true")
26 parser.add_option("--dump-classes", action="store_true")
27 parser.add_option("--dump-attributes", action="store_true")
28 parser.add_option("--dump-subschema", action="store_true")
29 parser.add_option("--dump-subschema-auto", action="store_true")
30
31 opts, args = parser.parse_args()
32 opts.dump_all = True
33
34 if opts.dump_classes:
35     opts.dump_all = False
36 if opts.dump_attributes:
37     opts.dump_all = False
38 if opts.dump_subschema:
39     opts.dump_all = False
40 if opts.dump_subschema_auto:
41     opts.dump_all = False
42     opts.dump_subschema = True
43 if opts.dump_all:
44     opts.dump_classes = True
45     opts.dump_attributes = True
46     opts.dump_subschema = True
47     opts.dump_subschema_auto = True
48
49 if len(args) != 2:
50     parser.print_usage()
51     sys.exit(1)
52
53 (url, classfile) = args
54
55 lp_ctx = sambaopts.get_loadparm()
56
57 creds = credopts.get_credentials(lp_ctx)
58 ldb = Ldb(url, credentials=creds, lp=lp_ctx)
59
60 objectclasses = {}
61 attributes = {}
62
63 objectclasses_expanded = set()
64
65 # the attributes we need for objectclasses
66 class_attrs = ["objectClass", 
67                "subClassOf", 
68                "governsID", 
69                "possSuperiors", 
70                "possibleInferiors",
71                "mayContain",
72                "mustContain",
73                "auxiliaryClass",
74                "rDNAttID",
75                "showInAdvancedViewOnly",
76                "adminDisplayName",
77                "adminDescription",
78                "objectClassCategory",
79                "lDAPDisplayName",
80                "schemaIDGUID",
81                "systemOnly",
82                "systemPossSuperiors",
83                "systemMayContain",
84                "systemMustContain",
85                "systemAuxiliaryClass",
86                "defaultSecurityDescriptor",
87                "systemFlags",
88                "defaultHidingValue",
89                "objectCategory",
90                "defaultObjectCategory", 
91                
92                # this attributes are not used by w2k3
93                "schemaFlagsEx",
94                "msDs-IntId",
95                "msDs-Schema-Extensions",
96                "classDisplayName",
97                "isDefunct"]
98
99 attrib_attrs = ["objectClass",
100                 "attributeID", 
101                 "attributeSyntax",
102                 "isSingleValued",
103                 "rangeLower",
104                 "rangeUpper",
105                 "mAPIID",
106                 "linkID",
107                 "showInAdvancedViewOnly",
108                 "adminDisplayName",
109                 "oMObjectClass",
110                 "adminDescription",
111                 "oMSyntax", 
112                 "searchFlags",
113                 "extendedCharsAllowed",
114                 "lDAPDisplayName",
115                 "schemaIDGUID",
116                 "attributeSecurityGUID",
117                 "systemOnly",
118                 "systemFlags",
119                 "isMemberOfPartialAttributeSet",
120                 "objectCategory", 
121                 
122                 # this attributes are not used by w2k3
123                 "schemaFlagsEx",
124                 "msDs-IntId",
125                 "msDs-Schema-Extensions",
126                 "classDisplayName",
127                 "isEphemeral",
128                 "isDefunct"]
129
130 #
131 #  notes:
132 #
133 #  objectClassCategory 
134 #      1: structural
135 #      2: abstract
136 #      3: auxiliary
137
138 def get_object_cn(ldb, name):
139     attrs = ["cn"]
140     res = ldb.search(expression="(ldapDisplayName=%s)" % name, base=rootDse["schemaNamingContext"][0], scope=SCOPE_SUBTREE, attrs=attrs)
141     assert len(res) == 1
142     return res[0]["cn"]
143
144
145 class Objectclass(dict):
146
147     def __init__(self, ldb, name):
148         """create an objectclass object"""
149         self.name = name
150         self["cn"] = get_object_cn(ldb, name)
151
152
153 class Attribute(dict):
154
155     def __init__(self, ldb, name):
156         """create an attribute object"""
157         self.name = name
158         self["cn"] = get_object_cn(ldb, name)
159
160
161 syntaxmap = dict()
162
163 syntaxmap['2.5.5.1']  = '1.3.6.1.4.1.1466.115.121.1.12'
164 syntaxmap['2.5.5.2']  = '1.3.6.1.4.1.1466.115.121.1.38'
165 syntaxmap['2.5.5.3']  = '1.2.840.113556.1.4.1362'
166 syntaxmap['2.5.5.4']  = '1.2.840.113556.1.4.905'
167 syntaxmap['2.5.5.5']  = '1.3.6.1.4.1.1466.115.121.1.26'
168 syntaxmap['2.5.5.6']  = '1.3.6.1.4.1.1466.115.121.1.36'
169 syntaxmap['2.5.5.7']  = '1.2.840.113556.1.4.903'
170 syntaxmap['2.5.5.8']  = '1.3.6.1.4.1.1466.115.121.1.7'
171 syntaxmap['2.5.5.9']  = '1.3.6.1.4.1.1466.115.121.1.27'
172 syntaxmap['2.5.5.10'] = '1.3.6.1.4.1.1466.115.121.1.40'
173 syntaxmap['2.5.5.11'] = '1.3.6.1.4.1.1466.115.121.1.24'
174 syntaxmap['2.5.5.12'] = '1.3.6.1.4.1.1466.115.121.1.15'
175 syntaxmap['2.5.5.13'] = '1.3.6.1.4.1.1466.115.121.1.43'
176 syntaxmap['2.5.5.14'] = '1.2.840.113556.1.4.904'
177 syntaxmap['2.5.5.15'] = '1.2.840.113556.1.4.907'
178 syntaxmap['2.5.5.16'] = '1.2.840.113556.1.4.906'
179 syntaxmap['2.5.5.17'] = '1.3.6.1.4.1.1466.115.121.1.40'
180
181
182 def map_attribute_syntax(s):
183     """map some attribute syntaxes from some apparently MS specific
184     syntaxes to the standard syntaxes"""
185     if s in list(syntaxmap):
186         return syntaxmap[s]
187     return s
188
189
190 def fix_dn(dn):
191     """fix a string DN to use ${SCHEMADN}"""
192     return dn.replace(rootDse["schemaNamingContext"][0], "${SCHEMADN}")
193
194
195 def write_ldif_one(o, attrs):
196     """dump an object as ldif"""
197     print "dn: CN=%s,${SCHEMADN}" % o["cn"]
198     for a in attrs:
199         if not o.has_key(a):
200             continue
201         # special case for oMObjectClass, which is a binary object
202         v = o[a]
203         for j in v:
204                         value = fix_dn(j)
205                         if a == "oMObjectClass":
206                                 print "%s:: %s" % (a, base64.b64encode(value))
207                         elif a.endswith("GUID"):
208                                 print "%s: %s" % (a, ldb.schema_format_value(a, value))
209                         else:
210                                 print "%s: %s" % (a, value)
211     print ""
212
213
214 def write_ldif(o, attrs):
215     """dump an array of objects as ldif"""
216     for n, i in o.items():
217         write_ldif_one(i, attrs)
218
219
220 def create_testdn(exampleDN):
221     """create a testDN based an an example DN
222     the idea is to ensure we obey any structural rules"""
223     a = exampleDN.split(",")
224     a[0] = "CN=TestDN"
225     return ",".join(a)
226
227
228 def find_objectclass_properties(ldb, o):
229     """the properties of an objectclass"""
230     res = ldb.search(
231         expression="(ldapDisplayName=%s)" % o.name,
232         base=rootDse["schemaNamingContext"][0], scope=SCOPE_SUBTREE, attrs=class_attrs)
233     assert(len(res) == 1)
234     msg = res[0]
235     for a in msg:
236         o[a] = msg[a]
237
238 def find_attribute_properties(ldb, o):
239     """find the properties of an attribute"""
240     res = ldb.search(
241         expression="(ldapDisplayName=%s)" % o.name,
242         base=rootDse["schemaNamingContext"][0], scope=SCOPE_SUBTREE, 
243         attrs=attrib_attrs)
244     assert(len(res) == 1)
245     msg = res[0]
246     for a in msg:
247         o[a] = msg[a]
248
249
250 def find_objectclass_auto(ldb, o):
251     """find the auto-created properties of an objectclass. Only works for 
252     classes that can be created using just a DN and the objectclass"""
253     if not o.has_key("exampleDN"):
254         return
255     testdn = create_testdn(o.exampleDN)
256
257     print "testdn is '%s'" % testdn
258
259     ldif = "dn: " + testdn
260     ldif += "\nobjectClass: " + o.name
261     try:
262         ldb.add(ldif)
263     except LdbError, e:
264         print "error adding %s: %s" % (o.name, e)
265         print "%s" % ldif
266         return
267
268     res = ldb.search(base=testdn, scope=ldb.SCOPE_BASE)
269     ldb.delete(testdn)
270
271     for a in res.msgs[0]:
272         attributes[a].autocreate = True
273
274
275 def expand_objectclass(ldb, o):
276     """look at auxiliary information from a class to intuit the existance of 
277     more classes needed for a minimal schema"""
278     attrs = ["auxiliaryClass", "systemAuxiliaryClass",
279                   "possSuperiors", "systemPossSuperiors",
280                   "subClassOf"]
281     res = ldb.search(
282         expression="(&(objectClass=classSchema)(ldapDisplayName=%s))" % o.name,
283         base=rootDse["schemaNamingContext"][0], scope=SCOPE_SUBTREE, 
284         attrs=attrs)
285     print >>sys.stderr, "Expanding class %s" % o.name
286     assert(len(res) == 1)
287     msg = res[0]
288     for aname in attrs:
289         if not aname in msg:
290             continue
291         list = msg[aname]
292         if isinstance(list, str):
293             list = [msg[aname]]
294         for name in list:
295             if not objectclasses.has_key(name):
296                 print >>sys.stderr, "Found new objectclass '%s'" % name
297                 objectclasses[name] = Objectclass(ldb, name)
298
299
300 def add_objectclass_attributes(ldb, objectclass):
301     """add the must and may attributes from an objectclass to the full list
302     of attributes"""
303     attrs = ["mustContain", "systemMustContain", 
304                   "mayContain", "systemMayContain"]
305     for aname in attrs:
306         if not objectclass.has_key(aname):
307             continue
308         alist = objectclass[aname]
309         if isinstance(alist, str):
310             alist = [alist]
311         for a in alist:
312             if not attributes.has_key(a):
313                 attributes[a] = Attribute(ldb, a)
314
315
316 def walk_dn(ldb, dn):
317     """process an individual record, working out what attributes it has"""
318     # get a list of all possible attributes for this object 
319     attrs = ["allowedAttributes"]
320     try:
321         res = ldb.search("objectClass=*", dn, SCOPE_BASE, attrs)
322     except LdbError, e:
323         print >>sys.stderr, "Unable to fetch allowedAttributes for '%s' - %r" % (dn, e)
324         return
325     allattrs = res[0]["allowedAttributes"]
326     try:
327         res = ldb.search("objectClass=*", dn, SCOPE_BASE, allattrs)
328     except LdbError, e:
329         print >>sys.stderr, "Unable to fetch all attributes for '%s' - %s" % (dn, e)
330         return
331     msg = res[0]
332     for a in msg:
333         if not attributes.has_key(a):
334             attributes[a] = Attribute(ldb, a)
335
336 def walk_naming_context(ldb, namingContext):
337     """walk a naming context, looking for all records"""
338     try:
339         res = ldb.search("objectClass=*", namingContext, SCOPE_DEFAULT, 
340                          ["objectClass"])
341     except LdbError, e:
342         print >>sys.stderr, "Unable to fetch objectClasses for '%s' - %s" % (namingContext, e)
343         return
344     for msg in res:
345         msg = res.msgs[r]["objectClass"]
346         for objectClass in msg:
347             if not objectclasses.has_key(objectClass):
348                 objectclasses[objectClass] = Objectclass(ldb, objectClass)
349                 objectclasses[objectClass].exampleDN = res.msgs[r]["dn"]
350         walk_dn(ldb, res.msgs[r].dn)
351
352 def trim_objectclass_attributes(ldb, objectclass):
353     """trim the may attributes for an objectClass"""
354     # trim possibleInferiors,
355     # include only the classes we extracted
356     if objectclass.has_key("possibleInferiors"):
357         possinf = objectclass["possibleInferiors"]
358         newpossinf = []
359         for x in possinf:
360             if objectclasses.has_key(x):
361                 newpossinf.append(x)
362         objectclass["possibleInferiors"] = newpossinf
363
364     # trim systemMayContain,
365     # remove duplicates
366     if objectclass.has_key("systemMayContain"):
367         sysmay = objectclass["systemMayContain"]
368         newsysmay = []
369         for x in sysmay:
370             if not x in newsysmay:
371                 newsysmay.append(x)
372         objectclass["systemMayContain"] = newsysmay
373
374     # trim mayContain,
375     # remove duplicates
376     if objectclass.has_key("mayContain"):
377         may = objectclass["mayContain"]
378         newmay = []
379         if isinstance(may, str):
380             may = [may]
381         for x in may:
382             if not x in newmay:
383                 newmay.append(x)
384         objectclass["mayContain"] = newmay
385
386
387 def build_objectclass(ldb, name):
388     """load the basic attributes of an objectClass"""
389     attrs = ["name"]
390     res = ldb.search(
391         expression="(&(objectClass=classSchema)(ldapDisplayName=%s))" % name,
392         base=rootDse["schemaNamingContext"][0], scope=SCOPE_SUBTREE, 
393         attrs=attrs)
394     if len(res) == 0:
395         print >>sys.stderr, "unknown class '%s'" % name
396         return None
397     return Objectclass(ldb, name)
398
399
400 def attribute_list(objectclass, attr1, attr2):
401     """form a coalesced attribute list"""
402     a1 = list(objectclass.get(attr1, []))
403     a2 = list(objectclass.get(attr2, []))
404     return a1 + a2
405
406 def aggregate_list(name, list):
407     """write out a list in aggregate form"""
408     if list is None:
409         return
410     print "%s ( %s )" % (name, "$ ".join(list))
411
412 def write_aggregate_objectclass(objectclass):
413     """write the aggregate record for an objectclass"""
414     print "objectClasses: ( %s NAME '%s' " % (objectclass["governsID"], objectclass.name),
415     if not objectclass.has_key('subClassOf'):
416         print "SUP %s " % objectclass['subClassOf'],
417     if objectclass["objectClassCategory"] == 1:
418         print "STRUCTURAL ",
419     elif objectclass["objectClassCategory"] == 2:
420         print "ABSTRACT ",
421     elif objectclass["objectClassCategory"] == 3:
422         print "AUXILIARY ",
423
424     list = attribute_list(objectclass, "systemMustContain", "mustContain")
425     aggregate_list("MUST", list)
426
427     list = attribute_list(objectclass, "systemMayContain", "mayContain")
428     aggregate_list("MAY", list)
429
430     print ")"
431
432
433 def write_aggregate_ditcontentrule(objectclass):
434     """write the aggregate record for an ditcontentrule"""
435     list = attribute_list(objectclass, "auxiliaryClass", "systemAuxiliaryClass")
436     if list is None:
437         return
438
439     print "dITContentRules: ( %s NAME '%s' " % (objectclass["governsID"], objectclass.name)
440
441     aggregate_list("AUX", list)
442
443     may_list = []
444     must_list = []
445
446     for c in list:
447         list2 = attribute_list(objectclasses[c], 
448                        "mayContain", "systemMayContain")
449         may_list = may_list + list2
450         list2 = attribute_list(objectclasses[c], 
451                        "mustContain", "systemMustContain")
452         must_list = must_list + list2
453
454     aggregate_list("MUST", must_list)
455     aggregate_list("MAY", may_list)
456
457     print ")\n"
458
459 def write_aggregate_attribute(attrib):
460     """write the aggregate record for an attribute"""
461     print "attributeTypes: ( %s NAME '%s' SYNTAX '%s' " % (
462            attrib["attributeID"], attrib.name, 
463            map_attribute_syntax(attrib["attributeSyntax"]))
464     if attrib.get('isSingleValued') == "TRUE":
465         print "SINGLE-VALUE "
466     if attrib.get('systemOnly') == "TRUE":
467         print "NO-USER-MODIFICATION "
468
469     print ")\n"
470
471
472 def write_aggregate():
473     """write the aggregate record"""
474     print "dn: CN=Aggregate,${SCHEMADN}\n"
475     print """objectClass: top
476 objectClass: subSchema
477 objectCategory: CN=SubSchema,${SCHEMADN}
478 """
479     if not opts.dump_subschema_auto:
480         return
481
482     for objectclass in objectclasses.values():
483         write_aggregate_objectclass(objectclass)
484     for attr in attributes.values():
485         write_aggregate_attribute(attr)
486     for objectclass in objectclasses.values():
487         write_aggregate_ditcontentrule(objectclass)
488
489 def load_list(file):
490     """load a list from a file"""
491     return [l.strip("\n") for l in open(file, 'r').readlines()]
492
493 # get the rootDSE
494 res = ldb.search(base="", expression="", scope=SCOPE_BASE, attrs=["schemaNamingContext"])
495 rootDse = res[0]
496
497 # load the list of classes we are interested in
498 classes = load_list(classfile)
499 for classname in classes:
500     objectclass = build_objectclass(ldb, classname)
501     if objectclass is not None:
502         objectclasses[classname] = objectclass
503
504
505 #
506 #  expand the objectclass list as needed
507 #
508 expanded = 0
509
510 # so EJS do not have while nor the break statement
511 # cannot find any other way than doing more loops
512 # than necessary to recursively expand all classes
513 #
514 for inf in range(500):
515     for n, o in objectclasses.items():
516         if not n in objectclasses_expanded:
517             expand_objectclass(ldb, o)
518             objectclasses_expanded.add(n)
519
520 #
521 #  find objectclass properties
522 #
523 for name, objectclass in objectclasses.items():
524     find_objectclass_properties(ldb, objectclass)
525
526
527 #
528 #  form the full list of attributes
529 #
530 for name, objectclass in objectclasses.items():
531     add_objectclass_attributes(ldb, objectclass)
532
533 # and attribute properties
534 for name, attr in attributes.items():
535     find_attribute_properties(ldb, attr)
536
537 #
538 # trim the 'may' attribute lists to those really needed
539 #
540 for name, objectclass in objectclasses.items():
541     trim_objectclass_attributes(ldb, objectclass)
542
543 #
544 #  dump an ldif form of the attributes and objectclasses
545 #
546 if opts.dump_attributes:
547     write_ldif(attributes, attrib_attrs)
548 if opts.dump_classes:
549     write_ldif(objectclasses, class_attrs)
550 if opts.dump_subschema:
551     write_aggregate()
552
553 if not opts.verbose:
554     sys.exit(0)
555
556 #
557 #  dump list of objectclasses
558 #
559 print "objectClasses:\n"
560 for objectclass in objectclasses:
561     print "\t%s\n" % objectclass
562
563 print "attributes:\n"
564 for attr in attributes:
565     print "\t%s\n" % attr
566
567 print "autocreated attributes:\n"
568 for attr in attributes:
569     if attr.autocreate:
570         print "\t%s\n" % i