mirror of
https://github.com/samba-team/samba.git
synced 2025-03-01 04:58:35 +03:00
Remove minschema js tests.
This commit is contained in:
Jelmer Vernooij
parent
f594044d79
commit
f3a517a92e
@ -1,385 +0,0 @@
|
||||
#!/bin/sh
|
||||
exec smbscript "$0" ${1+"$@"}
|
||||
/*
|
||||
demonstrate access to ldb databases from ejs
|
||||
*/
|
||||
|
||||
|
||||
var ldb = ldb_init();
|
||||
var sys;
|
||||
var options = GetOptions(ARGV,
|
||||
"POPT_AUTOHELP",
|
||||
"POPT_COMMON_SAMBA");
|
||||
if (options == undefined) {
|
||||
println("Failed to parse options");
|
||||
return -1;
|
||||
}
|
||||
|
||||
libinclude("base.js");
|
||||
|
||||
if (options.ARGV.length != 1) {
|
||||
println("Usage: ldb.js <prefix>");
|
||||
return -1;
|
||||
}
|
||||
|
||||
prefix = options.ARGV[0];
|
||||
|
||||
function basic_tests(ldb)
|
||||
{
|
||||
println("Running basic tests");
|
||||
ok = ldb.add("
|
||||
dn: cn=x,cn=test
|
||||
objectClass: foo
|
||||
x: 3
|
||||
");
|
||||
assert(ok.error == 0);
|
||||
|
||||
println("Testing ldb.search");
|
||||
var res = ldb.search("(objectClass=*)");
|
||||
assert(res.msgs[0].objectClass[0] == "foo");
|
||||
assert(res.msgs[0].dn == "cn=x,cn=test");
|
||||
assert(res.msgs[0].x == 3);
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=x2,cn=test
|
||||
objectClass: foo
|
||||
x: 4
|
||||
");
|
||||
assert(ok.error == 0);
|
||||
var attrs = new Array("x");
|
||||
res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res.msgs[0].x == 4);
|
||||
assert(res.msgs[0].objectClass == undefined);
|
||||
assert(res.msgs[0].dn == "cn=x2,cn=test");
|
||||
|
||||
ok = ldb.del("cn=x,cn=test");
|
||||
assert(ok.error == 0);
|
||||
|
||||
ok = ldb.rename("cn=x2,cn=test", "cn=x3,cn=test");
|
||||
assert(ok.error == 0);
|
||||
res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res.msgs[0].dn == "cn=x3,cn=test");
|
||||
|
||||
ok = ldb.rename("cn=x3,cn=test", "cn=X3,cn=test");
|
||||
assert(ok.error == 0);
|
||||
res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res.msgs[0].dn == "cn=X3,cn=test");
|
||||
|
||||
ok = ldb.modify("
|
||||
dn: cn=x3,cn=test
|
||||
changetype: modify
|
||||
add: x
|
||||
x: 7
|
||||
");
|
||||
|
||||
res = ldb.search("x=7");
|
||||
assert(res.msgs.length == 1);
|
||||
assert(res.msgs[0].x.length == 2);
|
||||
|
||||
/* Check a few things before we add modules */
|
||||
assert(res.msgs[0].objectGUID == undefined);
|
||||
assert(res.msgs[0].createTimestamp == undefined);
|
||||
assert(res.msgs[0].whenCreated == undefined);
|
||||
|
||||
}
|
||||
|
||||
function setup_modules(ldb)
|
||||
{
|
||||
ok = ldb.add("
|
||||
dn: @MODULES
|
||||
@LIST: rootdse,operational,rdn_name,partition
|
||||
|
||||
dn: @ROOTDSE
|
||||
defaultNamingContext: cn=Test
|
||||
|
||||
dn: @PARTITION
|
||||
partition: cn=SideTest:" + prefix + "/" + "testside.ldb
|
||||
partition: cn=Sub,cn=PartTest:" + prefix + "/" + "testsub.ldb
|
||||
partition: cn=PartTest:" + prefix + "/" + "testpartition.ldb
|
||||
partition: cn=Sub,cn=Sub,cn=PartTest:" + prefix + "/" + "testsubsub.ldb
|
||||
replicateEntries: @ATTRIBUTES
|
||||
replicateEntries: @INDEXLIST
|
||||
modules: cn=PartTest:objectguid
|
||||
");
|
||||
}
|
||||
|
||||
/* Test the basic operation of the timestamps,objectguid and name_rdn
|
||||
modules */
|
||||
|
||||
function modules_test(ldb, parttestldb)
|
||||
{
|
||||
println("Running modules tests");
|
||||
|
||||
ok = ldb.add("
|
||||
dn: @ATTRIBUTES
|
||||
cn: CASE_INSENSITIVE
|
||||
caseattr: CASE_INSENSITIVE
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
/* Confirm that the attributes were replicated */
|
||||
var res_attrs = parttestldb.search("cn=*", "@ATTRIBUTES", parttestldb.SCOPE_BASE);
|
||||
assert(res_attrs.msgs[0].cn == "CASE_INSENSITIVE");
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=x8,cn=PartTest
|
||||
objectClass: foo
|
||||
x: 8
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=x9,cn=PartTest
|
||||
objectClass: foo
|
||||
x: 9
|
||||
cn: X9
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=X9,cn=PartTest
|
||||
objectClass: foo
|
||||
x: 9
|
||||
cn: X9
|
||||
");
|
||||
if (ok.error == 0) {
|
||||
println("Should have failed to add cn=X9,cn=PartTest");
|
||||
assert(ok.error != 0);
|
||||
}
|
||||
|
||||
var res = ldb.search("x=8", "cn=PartTest", ldb.SCOPE_DEFAULT);
|
||||
assert(res.msgs[0].objectGUID != undefined);
|
||||
assert(res.msgs[0].uSNCreated != undefined);
|
||||
assert(res.msgs[0].uSNChanged != undefined);
|
||||
assert(res.msgs[0].createTimestamp == undefined);
|
||||
assert(res.msgs[0].whenCreated != undefined);
|
||||
assert(res.msgs[0].name == "x8");
|
||||
assert(res.msgs[0].cn == "x8");
|
||||
|
||||
/* Confirm that this ended up in the correct LDB */
|
||||
var res_otherldb = parttestldb.search("x=8", "cn=PartTest", parttestldb.SCOPE_DEFAULT);
|
||||
assert(res_otherldb.msgs[0].objectGUID != undefined);
|
||||
assert(res_otherldb.msgs[0].createTimestamp == undefined);
|
||||
assert(res_otherldb.msgs[0].whenCreated != undefined);
|
||||
assert(res_otherldb.msgs[0].name == "x8");
|
||||
assert(res_otherldb.msgs[0].cn == "x8");
|
||||
|
||||
var attrs = new Array("*", "createTimestamp");
|
||||
var res2 = ldb.search("x=9", "cn=PartTest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res2.msgs[0].objectGUID != undefined);
|
||||
assert(res2.msgs[0].createTimestamp != undefined);
|
||||
assert(res2.msgs[0].whenCreated != undefined);
|
||||
assert(res2.msgs[0].name == "x9");
|
||||
assert(res2.msgs[0].cn == "x9");
|
||||
|
||||
assert(res.msgs[0].objectGUID != res2.msgs[0].objectGUID);
|
||||
|
||||
var attrs = new Array("*");
|
||||
var res3 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
|
||||
assert(res3.msgs[0].cn == undefined);
|
||||
assert(res3.msgs[0].distinguishedName == undefined);
|
||||
assert(res3.msgs[0].name == undefined);
|
||||
assert(res3.msgs[0].currentTime != undefined);
|
||||
assert(res3.msgs[0].highestCommittedUSN != undefined);
|
||||
|
||||
assert(res3.msgs[0].namingContexts[0] == "cn=Sub,cn=Sub,cn=PartTest");
|
||||
assert(res3.msgs[0].namingContexts[1] == "cn=Sub,cn=PartTest");
|
||||
assert(res3.msgs[0].namingContexts[2] == "cn=PartTest");
|
||||
assert(res3.msgs[0].namingContexts[3] == "cn=SideTest");
|
||||
var usn = res3.msgs[0].highestCommittedUSN;
|
||||
|
||||
/* Start a transaction. We are going to abort it later, to
|
||||
* show we clean up all partitions */
|
||||
|
||||
ok = ldb.transaction_start()
|
||||
if (!ok) {
|
||||
println("Failed to start a transaction: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=x10,cn=parttest
|
||||
objectClass: foo
|
||||
x: 10
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
var attrs = new Array("highestCommittedUSN");
|
||||
var res4 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
|
||||
var usn2 = res4.msgs[0].highestCommittedUSN;
|
||||
assert(usn < res4.msgs[0].highestCommittedUSN);
|
||||
|
||||
ok = ldb.add("
|
||||
dn: cn=x11,cn=sub,cn=parttest
|
||||
objectClass: foo
|
||||
x: 11
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
var attrs = new Array("highestCommittedUSN");
|
||||
var res5 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
|
||||
assert(usn2 < res5.msgs[0].highestCommittedUSN);
|
||||
|
||||
var attrs = new Array("*", "createTimestamp");
|
||||
var res6 = ldb.search("x=11", "cn=parttest", ldb.SCOPE_SUB, attrs);
|
||||
assert(res6.msgs.length == 0);
|
||||
|
||||
var attrs = new Array("*", "createTimestamp");
|
||||
var res7 = ldb.search("x=10", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res7.msgs.length == 0);
|
||||
|
||||
var res8 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
|
||||
assert(res8.msgs[0].objectGUID == undefined); /* The objectGUID module is not loaded here */
|
||||
assert(res8.msgs[0].uSNCreated == undefined); /* The objectGUID module is not loaded here */
|
||||
assert(res8.msgs[0].name == "x11");
|
||||
assert(res8.msgs[0].cn == "x11");
|
||||
|
||||
ok = ldb.add("
|
||||
dn: caseattr=XY,cn=PartTest
|
||||
objectClass: foo
|
||||
x: Y
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: caseattr=XZ,cn=PartTest
|
||||
objectClass: foo
|
||||
x: Z
|
||||
caseattr: XZ
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: caseattr=xz,cn=PartTest
|
||||
objectClass: foo
|
||||
x: Z
|
||||
caseattr: xz
|
||||
");
|
||||
if (ok.error == 0) {
|
||||
println("Should have failed to add caseattr=xz,cn=PartTest");
|
||||
assert(ok.error != 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: caseattr2=XZ,cn=PartTest
|
||||
objectClass: foo
|
||||
x: Z
|
||||
caseattr2: XZ
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
ok = ldb.add("
|
||||
dn: caseattr2=Xz,cn=PartTest
|
||||
objectClass: foo
|
||||
x: Z
|
||||
caseattr2: Xz
|
||||
");
|
||||
if (ok.error != 0) {
|
||||
println("Failed to add: " + ok.errstr);
|
||||
assert(ok.error == 0);
|
||||
}
|
||||
|
||||
var resX = ldb.search("caseattr=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(resX.msgs.length == 1);
|
||||
assert(resX.msgs[0].objectGUID != undefined);
|
||||
assert(resX.msgs[0].createTimestamp != undefined);
|
||||
assert(resX.msgs[0].whenCreated != undefined);
|
||||
assert(resX.msgs[0].name == "XZ");
|
||||
|
||||
var rescount = ldb.search("(|(caseattr=*)(cn=*))", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(rescount.msgs.length == 5);
|
||||
|
||||
/* Check this attribute is *not* case sensitive */
|
||||
var resXcount = ldb.search("caseattr=x*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(resXcount.msgs.length == 2);
|
||||
|
||||
/* Check that this attribute *is* case sensitive */
|
||||
var resXcount2 = ldb.search("caseattr2=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(resXcount2.msgs.length == 0);
|
||||
|
||||
|
||||
/* Now abort the transaction to show that even with
|
||||
* partitions, it is aborted everywhere */
|
||||
ok = ldb.transaction_cancel();
|
||||
if (!ok) {
|
||||
println("Failed to cancel a transaction: " + ok.errstr);
|
||||
assert(ok);
|
||||
}
|
||||
|
||||
/* now check it all went away */
|
||||
|
||||
var attrs = new Array("highestCommittedUSN");
|
||||
var res9 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
|
||||
assert(usn == res9.msgs[0].highestCommittedUSN);
|
||||
|
||||
var attrs = new Array("*");
|
||||
var res10 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res10.msgs.length == 0);
|
||||
|
||||
var attrs = new Array("*");
|
||||
var res11 = ldb.search("x=10", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res11.msgs.length == 0);
|
||||
|
||||
var attrs = new Array("*");
|
||||
var res12 = ldb.search("caseattr=*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
|
||||
assert(res12.msgs.length == 0);
|
||||
|
||||
}
|
||||
|
||||
sys = sys_init();
|
||||
var dbfile = "test.ldb";
|
||||
|
||||
sys.unlink(prefix + "/" + dbfile);
|
||||
sys.unlink(prefix + "/" + "testpartition.ldb");
|
||||
sys.unlink(prefix + "/" + "testsub.ldb");
|
||||
sys.unlink(prefix + "/" + "testsubsub.ldb");
|
||||
sys.unlink(prefix + "/" + "testside.ldb");
|
||||
|
||||
var ok = ldb.connect("tdb://" + prefix + "/" + dbfile);
|
||||
assert(ok);
|
||||
|
||||
basic_tests(ldb);
|
||||
|
||||
setup_modules(ldb);
|
||||
ldb = ldb_init();
|
||||
var ok = ldb.connect("tdb://" + prefix + "/" + dbfile);
|
||||
assert(ok);
|
||||
|
||||
parttestldb = ldb_init();
|
||||
var ok = parttestldb.connect("tdb://" + prefix + "/" + "testpartition.ldb");
|
||||
assert(ok);
|
||||
|
||||
modules_test(ldb, parttestldb);
|
||||
|
||||
sys.unlink(prefix + "/" + dbfile);
|
||||
sys.unlink(prefix + "/" + "testpartition.ldb");
|
||||
sys.unlink(prefix + "/" + "testsub.ldb");
|
||||
sys.unlink(prefix + "/" + "testsubsub.ldb");
|
||||
sys.unlink(prefix + "/" + "testside.ldb");
|
||||
return 0;
|
||||
@ -1,804 +0,0 @@
|
||||
#!/bin/sh
|
||||
exec smbscript "$0" ${1+"$@"}
|
||||
/*
|
||||
work out the minimal schema for a set of objectclasses
|
||||
*/
|
||||
|
||||
libinclude("base.js");
|
||||
|
||||
var ldb = ldb_init();
|
||||
|
||||
var options = GetOptions(ARGV,
|
||||
"POPT_AUTOHELP",
|
||||
"POPT_COMMON_SAMBA",
|
||||
"POPT_COMMON_CREDENTIALS",
|
||||
"verbose",
|
||||
"classes",
|
||||
"attributes");
|
||||
if (options == undefined) {
|
||||
println("Failed to parse options");
|
||||
return -1;
|
||||
}
|
||||
verbose = options["verbose"];
|
||||
dump_all = "yes";
|
||||
dump_classes = options["classes"];
|
||||
dump_attributes = options["attributes"];
|
||||
|
||||
if (dump_classes != undefined) {
|
||||
dump_all = undefined;
|
||||
}
|
||||
if (dump_attributes != undefined) {
|
||||
dump_all = undefined;
|
||||
}
|
||||
if (dump_all != undefined) {
|
||||
dump_classes = "yes";
|
||||
dump_attributes = "yes";
|
||||
}
|
||||
|
||||
if (options.ARGV.length != 2) {
|
||||
println("Usage: minschema.js <URL> <classfile>");
|
||||
return -1;
|
||||
}
|
||||
|
||||
var url = options.ARGV[0];
|
||||
var classfile = options.ARGV[1];
|
||||
|
||||
/* use command line creds if available */
|
||||
ldb.credentials = options.get_credentials();
|
||||
|
||||
var ok = ldb.connect(url);
|
||||
assert(ok);
|
||||
|
||||
objectclasses = new Object();
|
||||
attributes = new Object();
|
||||
rootDse = new Object();
|
||||
|
||||
objectclasses_expanded = new Object();
|
||||
|
||||
/* the attributes we need for objectclasses */
|
||||
class_attrs = new Array("objectClass",
|
||||
"subClassOf",
|
||||
"governsID",
|
||||
"possSuperiors",
|
||||
"possibleInferiors",
|
||||
"mayContain",
|
||||
"mustContain",
|
||||
"auxiliaryClass",
|
||||
"rDNAttID",
|
||||
"showInAdvancedViewOnly",
|
||||
"adminDisplayName",
|
||||
"adminDescription",
|
||||
"objectClassCategory",
|
||||
"lDAPDisplayName",
|
||||
"schemaIDGUID",
|
||||
"systemOnly",
|
||||
"systemPossSuperiors",
|
||||
"systemMayContain",
|
||||
"systemMustContain",
|
||||
"systemAuxiliaryClass",
|
||||
"defaultSecurityDescriptor",
|
||||
"systemFlags",
|
||||
"defaultHidingValue",
|
||||
"defaultObjectCategory",
|
||||
|
||||
/* this attributes are not used by w2k3 */
|
||||
"schemaFlagsEx",
|
||||
"msDs-IntId",
|
||||
"msDs-Schema-Extensions",
|
||||
"classDisplayName",
|
||||
"isDefunct");
|
||||
|
||||
|
||||
attrib_attrs = new Array("objectClass",
|
||||
"attributeID",
|
||||
"attributeSyntax",
|
||||
"isSingleValued",
|
||||
"rangeLower",
|
||||
"rangeUpper",
|
||||
"mAPIID",
|
||||
"linkID",
|
||||
"showInAdvancedViewOnly",
|
||||
"adminDisplayName",
|
||||
"oMObjectClass",
|
||||
"adminDescription",
|
||||
"oMSyntax",
|
||||
"searchFlags",
|
||||
"extendedCharsAllowed",
|
||||
"lDAPDisplayName",
|
||||
"schemaIDGUID",
|
||||
"attributeSecurityGUID",
|
||||
"systemOnly",
|
||||
"systemFlags",
|
||||
"isMemberOfPartialAttributeSet",
|
||||
|
||||
/* this attributes are not used by w2k3 */
|
||||
"schemaFlagsEx",
|
||||
"msDs-IntId",
|
||||
"msDs-Schema-Extensions",
|
||||
"classDisplayName",
|
||||
"isEphemeral",
|
||||
"isDefunct");
|
||||
|
||||
/*
|
||||
notes:
|
||||
|
||||
objectClassCategory
|
||||
1: structural
|
||||
2: abstract
|
||||
3: auxiliary
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
print only if verbose is set
|
||||
*/
|
||||
function dprintf() {
|
||||
if (verbose != undefined) {
|
||||
print(vsprintf(arguments));
|
||||
}
|
||||
}
|
||||
|
||||
function get_object_cn(ldb, name) {
|
||||
var attrs = new Array("cn");
|
||||
|
||||
var res = ldb.search(sprintf("(ldapDisplayName=%s)", name), rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
|
||||
assert(res != undefined);
|
||||
assert(res.msgs.length == 1);
|
||||
|
||||
var cn = res.msgs[0]["cn"];
|
||||
assert(cn != undefined);
|
||||
if (typeof(cn) == "string") {
|
||||
return cn;
|
||||
}
|
||||
return cn[0];
|
||||
}
|
||||
/*
|
||||
create an objectclass object
|
||||
*/
|
||||
function obj_objectClass(ldb, name) {
|
||||
var o = new Object();
|
||||
o.name = name;
|
||||
o.cn = get_object_cn(ldb, name);
|
||||
return o;
|
||||
}
|
||||
|
||||
/*
|
||||
create an attribute object
|
||||
*/
|
||||
function obj_attribute(ldb, name) {
|
||||
var o = new Object();
|
||||
o.name = name;
|
||||
o.cn = get_object_cn(ldb, name);
|
||||
return o;
|
||||
}
|
||||
|
||||
|
||||
syntaxmap = new Object();
|
||||
|
||||
syntaxmap['2.5.5.1'] = '1.3.6.1.4.1.1466.115.121.1.12';
|
||||
syntaxmap['2.5.5.2'] = '1.3.6.1.4.1.1466.115.121.1.38';
|
||||
syntaxmap['2.5.5.3'] = '1.2.840.113556.1.4.1362';
|
||||
syntaxmap['2.5.5.4'] = '1.2.840.113556.1.4.905';
|
||||
syntaxmap['2.5.5.5'] = '1.3.6.1.4.1.1466.115.121.1.26';
|
||||
syntaxmap['2.5.5.6'] = '1.3.6.1.4.1.1466.115.121.1.36';
|
||||
syntaxmap['2.5.5.7'] = '1.2.840.113556.1.4.903';
|
||||
syntaxmap['2.5.5.8'] = '1.3.6.1.4.1.1466.115.121.1.7';
|
||||
syntaxmap['2.5.5.9'] = '1.3.6.1.4.1.1466.115.121.1.27';
|
||||
syntaxmap['2.5.5.10'] = '1.3.6.1.4.1.1466.115.121.1.40';
|
||||
syntaxmap['2.5.5.11'] = '1.3.6.1.4.1.1466.115.121.1.24';
|
||||
syntaxmap['2.5.5.12'] = '1.3.6.1.4.1.1466.115.121.1.15';
|
||||
syntaxmap['2.5.5.13'] = '1.3.6.1.4.1.1466.115.121.1.43';
|
||||
syntaxmap['2.5.5.14'] = '1.2.840.113556.1.4.904';
|
||||
syntaxmap['2.5.5.15'] = '1.2.840.113556.1.4.907';
|
||||
syntaxmap['2.5.5.16'] = '1.2.840.113556.1.4.906';
|
||||
syntaxmap['2.5.5.17'] = '1.3.6.1.4.1.1466.115.121.1.40';
|
||||
|
||||
/*
|
||||
map some attribute syntaxes from some apparently MS specific
|
||||
syntaxes to the standard syntaxes
|
||||
*/
|
||||
function map_attribute_syntax(s) {
|
||||
if (syntaxmap[s] != undefined) {
|
||||
return syntaxmap[s];
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
fix a string DN to use ${SCHEMADN}
|
||||
*/
|
||||
function fix_dn(dn) {
|
||||
var s = strstr(dn, rootDse.schemaNamingContext);
|
||||
if (s == NULL) {
|
||||
return dn;
|
||||
}
|
||||
return substr(dn, 0, strlen(dn) - strlen(s)) + "${SCHEMADN}";
|
||||
}
|
||||
|
||||
/*
|
||||
dump an object as ldif
|
||||
*/
|
||||
function write_ldif_one(o, attrs) {
|
||||
var i;
|
||||
printf("dn: CN=%s,${SCHEMADN}\n", o.cn);
|
||||
for (i=0;i<attrs.length;i++) {
|
||||
var a = attrs[i];
|
||||
if (o[a] == undefined) {
|
||||
continue;
|
||||
}
|
||||
/* special case for oMObjectClass, which is a binary object */
|
||||
if (a == "oMObjectClass") {
|
||||
printf("%s:: %s\n", a, o[a]);
|
||||
continue;
|
||||
}
|
||||
var v = o[a];
|
||||
if (typeof(v) == "string") {
|
||||
v = new Array(v);
|
||||
}
|
||||
var j;
|
||||
for (j=0;j<v.length;j++) {
|
||||
printf("%s: %s\n", a, fix_dn(v[j]));
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/*
|
||||
dump an array of objects as ldif
|
||||
*/
|
||||
function write_ldif(o, attrs) {
|
||||
var i;
|
||||
for (i in o) {
|
||||
write_ldif_one(o[i], attrs);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
create a testDN based an an example DN
|
||||
the idea is to ensure we obey any structural rules
|
||||
*/
|
||||
function create_testdn(exampleDN) {
|
||||
var a = split(",", exampleDN);
|
||||
a[0] = "CN=TestDN";
|
||||
return join(",", a);
|
||||
}
|
||||
|
||||
/*
|
||||
find the properties of an objectclass
|
||||
*/
|
||||
function find_objectclass_properties(ldb, o) {
|
||||
var res = ldb.search(
|
||||
sprintf("(ldapDisplayName=%s)", o.name),
|
||||
rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, class_attrs);
|
||||
assert(res != undefined);
|
||||
assert(res.msgs.length == 1);
|
||||
var msg = res.msgs[0];
|
||||
var a;
|
||||
for (a in msg) {
|
||||
o[a] = msg[a];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
find the properties of an attribute
|
||||
*/
|
||||
function find_attribute_properties(ldb, o) {
|
||||
var res = ldb.search(
|
||||
sprintf("(ldapDisplayName=%s)", o.name),
|
||||
rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrib_attrs);
|
||||
assert(res != undefined);
|
||||
assert(res.msgs.length == 1);
|
||||
var msg = res.msgs[0];
|
||||
var a;
|
||||
for (a in msg) {
|
||||
/* special case for oMObjectClass, which is a binary object */
|
||||
if (a == "oMObjectClass") {
|
||||
o[a] = ldb.encode(msg[a]);
|
||||
continue;
|
||||
}
|
||||
o[a] = msg[a];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
find the auto-created properties of an objectclass. Only works for classes
|
||||
that can be created using just a DN and the objectclass
|
||||
*/
|
||||
function find_objectclass_auto(ldb, o) {
|
||||
if (o["exampleDN"] == undefined) {
|
||||
return;
|
||||
}
|
||||
var testdn = create_testdn(o.exampleDN);
|
||||
var ok;
|
||||
|
||||
dprintf("testdn is '%s'\n", testdn);
|
||||
|
||||
var ldif = "dn: " + testdn;
|
||||
ldif = ldif + "\nobjectClass: " + o.name;
|
||||
ok = ldb.add(ldif);
|
||||
if (ok.error != 0) {
|
||||
dprintf("error adding %s: %s\n", o.name, ok.errstr);
|
||||
dprintf("%s\n", ldif);
|
||||
return;
|
||||
}
|
||||
|
||||
var res = ldb.search("", testdn, ldb.SCOPE_BASE);
|
||||
ok = ldb.del(testdn);
|
||||
assert(ok.error == 0);
|
||||
|
||||
var a;
|
||||
for (a in res.msgs[0]) {
|
||||
attributes[a].autocreate = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
look at auxiliary information from a class to intuit the existance of more
|
||||
classes needed for a minimal schema
|
||||
*/
|
||||
function expand_objectclass(ldb, o) {
|
||||
var attrs = new Array("auxiliaryClass", "systemAuxiliaryClass",
|
||||
"possSuperiors", "systemPossSuperiors",
|
||||
"subClassOf");
|
||||
var res = ldb.search(
|
||||
sprintf("(&(objectClass=classSchema)(ldapDisplayName=%s))", o.name),
|
||||
rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
|
||||
var a;
|
||||
dprintf("Expanding class %s\n", o.name);
|
||||
assert(res != undefined);
|
||||
assert(res.msgs.length == 1);
|
||||
var msg = res.msgs[0];
|
||||
for (a=0;a<attrs.length;a++) {
|
||||
var aname = attrs[a];
|
||||
if (msg[aname] == undefined) {
|
||||
continue;
|
||||
}
|
||||
var list = msg[aname];
|
||||
if (typeof(list) == "string") {
|
||||
list = new Array(msg[aname]);
|
||||
}
|
||||
var i;
|
||||
for (i=0;i<list.length;i++) {
|
||||
var name = list[i];
|
||||
if (objectclasses[name] == undefined) {
|
||||
dprintf("Found new objectclass '%s'\n", name);
|
||||
objectclasses[name] = obj_objectClass(ldb, name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
add the must and may attributes from an objectclass to the full list
|
||||
of attributes
|
||||
*/
|
||||
function add_objectclass_attributes(ldb, class) {
|
||||
var attrs = new Array("mustContain", "systemMustContain",
|
||||
"mayContain", "systemMayContain");
|
||||
var i;
|
||||
for (i=0;i<attrs.length;i++) {
|
||||
var aname = attrs[i];
|
||||
if (class[aname] == undefined) {
|
||||
continue;
|
||||
}
|
||||
var alist = class[aname];
|
||||
if (typeof(alist) == "string") {
|
||||
alist = new Array(alist);
|
||||
}
|
||||
var j;
|
||||
var len = alist.length;
|
||||
for (j=0;j<len;j++) {
|
||||
var a = alist[j];
|
||||
if (attributes[a] == undefined) {
|
||||
attributes[a] = obj_attribute(ldb, a);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
process an individual record, working out what attributes it has
|
||||
*/
|
||||
function walk_dn(ldb, dn) {
|
||||
/* get a list of all possible attributes for this object */
|
||||
var attrs = new Array("allowedAttributes");
|
||||
var res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, attrs);
|
||||
if (res.error != 0) {
|
||||
dprintf("Unable to fetch allowedAttributes for '%s' - %s\n",
|
||||
dn, res.errstr);
|
||||
return;
|
||||
}
|
||||
var allattrs = res.msgs[0].allowedAttributes;
|
||||
res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, allattrs);
|
||||
if (res.error != 0) {
|
||||
dprintf("Unable to fetch all attributes for '%s' - %s\n",
|
||||
dn, res.errstr);
|
||||
return;
|
||||
}
|
||||
var a;
|
||||
var msg = res.msgs[0];
|
||||
for (a in msg) {
|
||||
if (attributes[a] == undefined) {
|
||||
attributes[a] = obj_attribute(ldb, a);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
walk a naming context, looking for all records
|
||||
*/
|
||||
function walk_naming_context(ldb, namingContext) {
|
||||
var attrs = new Array("objectClass");
|
||||
var res = ldb.search("objectClass=*", namingContext, ldb.SCOPE_DEFAULT, attrs);
|
||||
if (res.error != 0) {
|
||||
dprintf("Unable to fetch objectClasses for '%s' - %s\n",
|
||||
namingContext, res.errstr);
|
||||
return;
|
||||
}
|
||||
var r;
|
||||
for (r=0;r<res.msgs.length;r++) {
|
||||
var msg = res.msgs[r].objectClass;
|
||||
var c;
|
||||
for (c=0;c<msg.length;c++) {
|
||||
var objectClass = msg[c];
|
||||
if (objectclasses[objectClass] == undefined) {
|
||||
objectclasses[objectClass] = obj_objectClass(ldb, objectClass);
|
||||
objectclasses[objectClass].exampleDN = res.msgs[r].dn;
|
||||
}
|
||||
}
|
||||
walk_dn(ldb, res.msgs[r].dn);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
trim the may attributes for an objectClass
|
||||
*/
|
||||
function trim_objectclass_attributes(ldb, class) {
|
||||
var i,j,n;
|
||||
|
||||
/* trim possibleInferiors,
|
||||
* include only the classes we extracted */
|
||||
var possinf = class["possibleInferiors"];
|
||||
if (possinf != undefined) {
|
||||
var newpossinf = new Array();
|
||||
if (typeof(possinf) == "string") {
|
||||
possinf = new Array(possinf);
|
||||
}
|
||||
n = 0;
|
||||
for (j = 0;j < possinf.length; j++) {
|
||||
var x = possinf[j];
|
||||
if (objectclasses[x] != undefined) {
|
||||
newpossinf[n] = x;
|
||||
n++;
|
||||
}
|
||||
}
|
||||
class["possibleInferiors"] = newpossinf;
|
||||
}
|
||||
|
||||
/* trim systemMayContain,
|
||||
* remove duplicates */
|
||||
var sysmay = class["systemMayContain"];
|
||||
if (sysmay != undefined) {
|
||||
var newsysmay = new Array();
|
||||
if (typeof(sysmay) == "string") {
|
||||
sysmay = new Array(sysmay);
|
||||
}
|
||||
for (j = 0;j < sysmay.length; j++) {
|
||||
var x = sysmay[j];
|
||||
var dup = false;
|
||||
if (newsysmay[0] == undefined) {
|
||||
newsysmay[0] = x;
|
||||
} else {
|
||||
for (n = 0; n < newsysmay.length; n++) {
|
||||
if (newsysmay[n] == x) {
|
||||
dup = true;
|
||||
}
|
||||
}
|
||||
if (dup == false) {
|
||||
newsysmay[n] = x;
|
||||
}
|
||||
}
|
||||
}
|
||||
class["systemMayContain"] = newsysmay;
|
||||
}
|
||||
|
||||
/* trim mayContain,
|
||||
* remove duplicates */
|
||||
var may = class["mayContain"];
|
||||
if (may != undefined) {
|
||||
var newmay = new Array();
|
||||
if (typeof(may) == "string") {
|
||||
may = new Array(may);
|
||||
}
|
||||
for (j = 0;j < may.length; j++) {
|
||||
var x = may[j];
|
||||
var dup = false;
|
||||
if (newmay[0] == undefined) {
|
||||
newmay[0] = x;
|
||||
} else {
|
||||
for (n = 0; n < newmay.length; n++) {
|
||||
if (newmay[n] == x) {
|
||||
dup = true;
|
||||
}
|
||||
}
|
||||
if (dup == false) {
|
||||
newmay[n] = x;
|
||||
}
|
||||
}
|
||||
}
|
||||
class["mayContain"] = newmay;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
load the basic attributes of an objectClass
|
||||
*/
|
||||
function build_objectclass(ldb, name) {
|
||||
var attrs = new Array("name");
|
||||
var res = ldb.search(
|
||||
sprintf("(&(objectClass=classSchema)(ldapDisplayName=%s))", name),
|
||||
rootDse.schemaNamingContext, ldb.SCOPE_SUBTREE, attrs);
|
||||
if (res.error != 0) {
|
||||
dprintf("unknown class '%s'\n", name);
|
||||
return undefined;
|
||||
}
|
||||
if (res.msgs.length == 0) {
|
||||
dprintf("unknown class '%s'\n", name);
|
||||
return undefined;
|
||||
}
|
||||
return obj_objectClass(ldb, name);
|
||||
}
|
||||
|
||||
/*
|
||||
append 2 lists
|
||||
*/
|
||||
function list_append(a1, a2) {
|
||||
var i;
|
||||
if (a1 == undefined) {
|
||||
return a2;
|
||||
}
|
||||
if (a2 == undefined) {
|
||||
return a1;
|
||||
}
|
||||
for (i=0;i<a2.length;i++) {
|
||||
a1[a1.length] = a2[i];
|
||||
}
|
||||
return a1;
|
||||
}
|
||||
|
||||
/*
|
||||
form a coalesced attribute list
|
||||
*/
|
||||
function attribute_list(class, attr1, attr2) {
|
||||
var a1 = class[attr1];
|
||||
var a2 = class[attr2];
|
||||
if (typeof(a1) == "string") {
|
||||
a1 = new Array(a1);
|
||||
}
|
||||
if (typeof(a2) == "string") {
|
||||
a2 = new Array(a2);
|
||||
}
|
||||
return list_append(a1, a2);
|
||||
}
|
||||
|
||||
/*
|
||||
write out a list in aggregate form
|
||||
*/
|
||||
function aggregate_list(name, list) {
|
||||
if (list == undefined) {
|
||||
return;
|
||||
}
|
||||
var i;
|
||||
printf("%s ( ", name);
|
||||
for (i=0;i<list.length;i++) {
|
||||
printf("%s ", list[i]);
|
||||
if (i < (list.length - 1)) {
|
||||
printf("$ ");
|
||||
}
|
||||
}
|
||||
printf(") ");
|
||||
}
|
||||
|
||||
/*
|
||||
write the aggregate record for an objectclass
|
||||
*/
|
||||
function write_aggregate_objectclass(class) {
|
||||
printf("objectClasses: ( %s NAME '%s' ", class.governsID, class.name);
|
||||
if (class['subClassOf'] != undefined) {
|
||||
printf("SUP %s ", class['subClassOf']);
|
||||
}
|
||||
if (class.objectClassCategory == 1) {
|
||||
printf("STRUCTURAL ");
|
||||
} else if (class.objectClassCategory == 2) {
|
||||
printf("ABSTRACT ");
|
||||
} else if (class.objectClassCategory == 3) {
|
||||
printf("AUXILIARY ");
|
||||
}
|
||||
|
||||
var list;
|
||||
|
||||
list = attribute_list(class, "systemMustContain", "mustContain");
|
||||
aggregate_list("MUST", list);
|
||||
|
||||
list = attribute_list(class, "systemMayContain", "mayContain");
|
||||
aggregate_list("MAY", list);
|
||||
|
||||
printf(")\n");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
write the aggregate record for an ditcontentrule
|
||||
*/
|
||||
function write_aggregate_ditcontentrule(class) {
|
||||
var list = attribute_list(class, "auxiliaryClass", "systemAuxiliaryClass");
|
||||
var i;
|
||||
if (list == undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
printf("dITContentRules: ( %s NAME '%s' ", class.governsID, class.name);
|
||||
|
||||
aggregate_list("AUX", list);
|
||||
|
||||
var may_list = undefined;
|
||||
var must_list = undefined;
|
||||
|
||||
for (i=0;i<list.length;i++) {
|
||||
var c = list[i];
|
||||
var list2;
|
||||
list2 = attribute_list(objectclasses[c],
|
||||
"mayContain", "systemMayContain");
|
||||
may_list = list_append(may_list, list2);
|
||||
list2 = attribute_list(objectclasses[c],
|
||||
"mustContain", "systemMustContain");
|
||||
must_list = list_append(must_list, list2);
|
||||
}
|
||||
|
||||
aggregate_list("MUST", must_list);
|
||||
aggregate_list("MAY", may_list);
|
||||
|
||||
printf(")\n");
|
||||
}
|
||||
|
||||
/*
|
||||
write the aggregate record for an attribute
|
||||
*/
|
||||
function write_aggregate_attribute(attrib) {
|
||||
printf("attributeTypes: ( %s NAME '%s' SYNTAX '%s' ",
|
||||
attrib.attributeID, attrib.name,
|
||||
map_attribute_syntax(attrib.attributeSyntax));
|
||||
if (attrib['isSingleValued'] == "TRUE") {
|
||||
printf("SINGLE-VALUE ");
|
||||
}
|
||||
if (attrib['systemOnly'] == "TRUE") {
|
||||
printf("NO-USER-MODIFICATION ");
|
||||
}
|
||||
|
||||
printf(")\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
load a list from a file
|
||||
*/
|
||||
function load_list(file) {
|
||||
var sys = sys_init();
|
||||
var s = sys.file_load(file);
|
||||
var a = split("\n", s);
|
||||
return a;
|
||||
}
|
||||
|
||||
/* get the rootDSE */
|
||||
var res = ldb.search("", "", ldb.SCOPE_BASE);
|
||||
rootDse = res.msgs[0];
|
||||
|
||||
/* load the list of classes we are interested in */
|
||||
var classes = load_list(classfile);
|
||||
var i;
|
||||
for (i=0;i<classes.length;i++) {
|
||||
var classname = classes[i];
|
||||
var class = build_objectclass(ldb, classname);
|
||||
if (class != undefined) {
|
||||
objectclasses[classname] = class;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
expand the objectclass list as needed
|
||||
*/
|
||||
var num_classes = 0;
|
||||
var expanded = 0;
|
||||
/* calculate the actual number of classes */
|
||||
for (i in objectclasses) {
|
||||
num_classes++;
|
||||
}
|
||||
/* so EJS do not have while nor the break statement
|
||||
cannot find any other way than doing more loops
|
||||
than necessary to recursively expand all classes
|
||||
*/
|
||||
var inf;
|
||||
for (inf = 0;inf < 500; inf++) {
|
||||
if (expanded < num_classes) {
|
||||
for (i in objectclasses) {
|
||||
var n = objectclasses[i];
|
||||
if (objectclasses_expanded[i] != "DONE") {
|
||||
expand_objectclass(ldb, objectclasses[i]);
|
||||
objectclasses_expanded[i] = "DONE";
|
||||
expanded++;
|
||||
}
|
||||
}
|
||||
/* recalculate the actual number of classes */
|
||||
num_classes = 0;
|
||||
for (i in objectclasses) {
|
||||
num_classes++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
find objectclass properties
|
||||
*/
|
||||
for (i in objectclasses) {
|
||||
find_objectclass_properties(ldb, objectclasses[i]);
|
||||
}
|
||||
|
||||
/*
|
||||
form the full list of attributes
|
||||
*/
|
||||
for (i in objectclasses) {
|
||||
add_objectclass_attributes(ldb, objectclasses[i]);
|
||||
}
|
||||
|
||||
/* and attribute properties */
|
||||
for (i in attributes) {
|
||||
find_attribute_properties(ldb, attributes[i]);
|
||||
}
|
||||
|
||||
/*
|
||||
trim the 'may' attribute lists to those really needed
|
||||
*/
|
||||
for (i in objectclasses) {
|
||||
trim_objectclass_attributes(ldb, objectclasses[i]);
|
||||
}
|
||||
|
||||
/*
|
||||
dump an ldif form of the attributes and objectclasses
|
||||
*/
|
||||
if (dump_attributes != undefined) {
|
||||
write_ldif(attributes, attrib_attrs);
|
||||
}
|
||||
if (dump_classes != undefined) {
|
||||
write_ldif(objectclasses, class_attrs);
|
||||
}
|
||||
if (verbose == undefined) {
|
||||
exit(0);
|
||||
}
|
||||
|
||||
/*
|
||||
dump list of objectclasses
|
||||
*/
|
||||
printf("objectClasses:\n")
|
||||
for (i in objectclasses) {
|
||||
printf("\t%s\n", i);
|
||||
}
|
||||
printf("attributes:\n")
|
||||
for (i in attributes) {
|
||||
printf("\t%s\n", i);
|
||||
}
|
||||
|
||||
printf("autocreated attributes:\n");
|
||||
for (i in attributes) {
|
||||
if (attributes[i].autocreate == true) {
|
||||
printf("\t%s\n", i);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
Loading…
x
Reference in New Issue
Block a user