wmi-1.3.16 from opsview.com

Samba/testprogs/ejs/argv.js

@@ -0,0 +1,14 @@
+/*
+	demonstrate use of GetOptions
+*/
+
+var options = GetOptions(ARGV, 
+		"POPT_AUTOHELP",
+		"POPT_COMMON_SAMBA",
+		"myopt=s",
+		"intopt=i",
+		"noopt");
+
+println("You called this script with arguments:");
+
+printVars(options);

Samba/testprogs/ejs/base.js

@@ -0,0 +1,23 @@
+#!/bin/sh
+exec smbscript "$0" ${1+"$@"}
+
+var options = GetOptions(ARGV, 
+		"POPT_COMMON_SAMBA");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+libinclude("base.js");
+
+var obj = new Object();
+obj.FOO = "foo";
+obj.BAR = "bar";
+var str1 = "${FOO}:${BAR}";
+var str2 = "${FOO}:${BAR} "; // note the space after the brace
+var sub1 = substitute_var(str1, obj);
+var sub2 = substitute_var(str2, obj);
+
+assert(str1 + " " == str2);
+assert(sub1 + " " == sub2);
+exit(0);

Samba/testprogs/ejs/bugs.js

@@ -0,0 +1,155 @@
+/*
+	demonstrate some bugs in ejs
+
+	tridge <appweb@tridgell.net>
+*/
+
+
+/****************************************
+demo a bug in constructing arrays
+fix at http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7124
+status: FIXED
+*****************************************/
+function arraybug() {
+	 var a;
+
+	 println("First with 3 elements");
+	 a = new Array("one", "two", "three");
+	 printVars(a);
+	 assert(a.length == 3);
+	 assert(a[0] == "one");
+	 assert(a[1] == "two");
+	 assert(a[2] == "three");
+
+	 println("with a array length");
+	 a = new Array(5);
+	 printVars(a);
+	 assert(a.length == 5);
+
+	 println("\nNow with 1 element");
+	 a = new Array("one");
+	 printVars(a);
+	 assert(a.length == 1);
+	 assert(a[0] == "one");
+
+	 println("ALL OK");
+}
+
+
+/****************************************
+demo a bug in variable arguments
+fix at http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7085
+status: FIXED
+*****************************************/
+function argsbug() {
+	 println("we should have been called with 3 arguments");
+	 assert(arguments.length == 3);
+	 assert(arguments[0] == "one");
+	 assert(arguments[1] == "two");
+	 assert(arguments[2] == "three");
+}
+
+
+/****************************************
+demo a bug in constructing objects
+no fix available yet
+status: SUBMITTED
+*****************************************/
+function MyObj() {
+	 var o = new Object();
+	 o.test = 42;
+	 return o;
+}
+
+function objbug() {
+	 println("the docs say you should use 'new'");
+	 var o1 = new MyObj();
+	 var o2 = MyObj();
+	 printVars(o1);
+	 printVars(o2);
+	 assert(o1.test == 42);
+	 assert(o2.test == 42);
+}
+
+/*
+ demo a expression handling bug
+ status: FIXED
+*/
+function exprbug() {
+	var a = new Array(10);
+	var i;
+	for (i=0;i<4;i++) {
+		a[1+(i*2)] = i;
+		a[2+(i*2)] = i*2;
+	}
+}
+
+/****************************************
+demo lack of recursion
+fix in http://build.samba.org/build.pl?function=diff;tree=samba4;revision=7127
+status: FIXED
+*****************************************/
+function fibonacci(n) {
+	if (n < 3) {
+		return 1;
+	}
+	return fibonacci(n-1) + fibonacci(n-2);
+}
+
+function recursebug() {
+	 println("First 10 fibonacci numbers:");
+	 for (i=0;i<10;i++) {
+		 println("fibonacci(" + i + ")=" + fibonacci(i));
+	 }
+}
+
+/****************************************
+demo lack of function variables inside functions
+status: FIXED IN SAMBA
+*****************************************/
+function callback()
+{
+	return "testing";
+}
+
+function fnbug(c)
+{
+	s = c();
+	assert(s == "testing");
+}
+
+/****************************************
+demo incorrect handling of reserved words in strings
+status: SUBMITTED
+*****************************************/
+function reservedbug()
+{
+	assert("funct" + "ion" == 'function');
+}
+
+
+/****************************************
+demo incorrect handling of boolean functions
+status: SUBMITTED
+*****************************************/
+function no()
+{
+	return false;
+}
+
+function boolbug()
+{
+	assert(false == no());
+	assert(!no());
+}
+
+
+/* run the tests */
+arraybug();
+argsbug("one", "two", "three");
+recursebug();
+exprbug();
+fnbug(callback);
+reservedbug();
+boolbug();
+objbug();

Samba/testprogs/ejs/echo.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env smbscript
+/*
+	test echo pipe calls from ejs
+*/	
+
+var options = GetOptions(ARGV, 
+		"POPT_AUTOHELP",
+		"POPT_COMMON_SAMBA",
+		"POPT_COMMON_CREDENTIALS");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+libinclude("base.js");
+
+/*
+  generate a ramp as an integer array
+ */
+function ramp_array(N)
+{
+	var a = new Array(N);
+	var data = datablob_init();
+	for (i=0;i<N;i++) {
+		a[i] = i;
+	}
+	return data.blobFromArray(a);
+}
+
+
+/*
+  test the echo_AddOne interface
+*/
+function test_AddOne(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_AddOne\n");
+
+	for (i=0;i<10;i++) {
+		io.input.in_data = i;
+		status = echo.echo_AddOne(io);
+		check_status_ok(status);
+		assert(io.output.out_data == i + 1);
+	}
+}
+
+/*
+  test the echo_EchoData interface
+*/
+function test_EchoData(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_EchoData\n");
+
+	for (i=0; i<30; i=i+5) {
+		io.input.len = i;
+		io.input.in_data = ramp_array(i);
+		status = echo.echo_EchoData(io);
+		check_status_ok(status);
+		assert(true == echo.blobCompare(io.input.in_data, io.output.out_data));
+	}
+}
+
+
+/*
+  test the echo_SinkData interface
+*/
+function test_SinkData(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_SinkData\n");
+
+	for (i=0; i<30; i=i+5) {
+		io.input.len = i;
+		io.input.data = ramp_array(i);
+		status = echo.echo_SinkData(io);
+		check_status_ok(status);
+	}
+}
+
+
+/*
+  test the echo_SourceData interface
+*/
+function test_SourceData(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_SourceData\n");
+
+	for (i=0; i<30; i=i+5) {
+		io.input.len = i;
+		status = echo.echo_SourceData(io);
+		check_status_ok(status);
+		correct = ramp_array(i);
+		assert(true == echo.blobCompare(correct, io.output.data));
+	}
+}
+
+
+/*
+  test the echo_TestCall interface
+*/
+function test_TestCall(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestCall\n");
+
+	io.input.s1 = "my test string";
+	status = echo.echo_TestCall(io);
+	check_status_ok(status);
+	assert("this is a test string" == io.output.s2);
+}
+
+/*
+  test the echo_TestCall2 interface
+*/
+function test_TestCall2(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestCall2\n");
+
+	for (i=1;i<=7;i++) {
+		io.input.level = i;
+		status = echo.echo_TestCall2(io);
+		check_status_ok(status);
+	}
+}
+
+/*
+  test the echo_TestSleep interface
+*/
+function test_TestSleep(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestSleep\n");
+
+	io.input.seconds = 1;
+	status = echo.echo_TestSleep(io);
+	check_status_ok(status);
+}
+
+/*
+  test the echo_TestEnum interface
+*/
+function test_TestEnum(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestEnum\n");
+
+	io.input.foo1 = echo.ECHO_ENUM1;
+	io.input.foo2 = new Object();
+	io.input.foo2.e1 = echo.ECHO_ENUM1;
+	io.input.foo2.e2 = echo.ECHO_ENUM1_32;
+	io.input.foo3 = new Object();
+	io.input.foo3.e1 = echo.ECHO_ENUM2;
+	status = echo.echo_TestEnum(io);
+	check_status_ok(status);
+	assert(io.output.foo1    == echo.ECHO_ENUM1);
+	assert(io.output.foo2.e1 == echo.ECHO_ENUM2);
+	assert(io.output.foo2.e2 == echo.ECHO_ENUM1_32);
+	assert(io.output.foo3.e1 == echo.ECHO_ENUM2);
+}
+
+/*
+  test the echo_TestSurrounding interface
+*/
+function test_TestSurrounding(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestSurrounding\n");
+	
+	io.input.data = new Object();
+	io.input.data.x = 10;
+	io.input.data.surrounding = new Array(10);
+	status = echo.echo_TestSurrounding(io);
+	check_status_ok(status);
+	assert(io.output.data.surrounding.length == 20);
+	check_array_zero(io.output.data.surrounding);
+}
+
+/*
+  test the echo_TestDoublePointer interface
+*/
+function test_TestDoublePointer(echo)
+{
+	var io = irpcObj();
+
+	print("Testing echo_TestDoublePointer\n");
+	
+	io.input.data = 7;
+	status = echo.echo_TestDoublePointer(io);
+	check_status_ok(status);
+	assert(io.input.data == io.input.data);
+}
+
+
+if (options.ARGV.length != 1) {
+   println("Usage: echo.js <BINDING>");
+   return -1;
+}
+var binding = options.ARGV[0];
+var echo = rpcecho_init();
+datablob_init(echo);
+
+print("Connecting to " + binding + "\n");
+status = echo.connect(binding);
+if (status.is_ok != true) {
+   printf("Failed to connect to %s - %s\n", binding, status.errstr);
+   return;
+}
+
+test_AddOne(echo);
+test_EchoData(echo);
+test_SinkData(echo);
+test_SourceData(echo);
+
+print("SKIPPING test_TestCall as pidl cannot generate code for it\n");
+/* test_TestCall(echo); */
+test_TestCall2(echo);
+test_TestSleep(echo);
+test_TestEnum(echo);
+test_TestSurrounding(echo);
+test_TestDoublePointer(echo);
+
+println("All OK\n");
+return 0;

Samba/testprogs/ejs/ejsnet.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env smbscript
+
+var options = GetOptions(ARGV, 
+		"POPT_AUTOHELP",
+		"POPT_COMMON_SAMBA",
+		"POPT_COMMON_CREDENTIALS");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+if (options.ARGV.length != 2) {
+   println("Usage: ejsnet.js <DOMAIN> <NEW USER NAME>");
+   return -1;
+}
+
+/* use command line creds if available */
+var creds = options.get_credentials();
+
+var ctx = NetContext(creds);
+var usr_ctx = ctx.UserMgr(options.ARGV[0]);
+if (usr_ctx == undefined) {
+	println("Couldn't get user management context.");
+	return -1;
+}
+
+var status = usr_ctx.Create(options.ARGV[1]);
+if (status.is_ok != true) {
+	println("Failed to create user account " + options.ARGV[1] + ": " + status.errstr);
+	return -1;
+}
+
+var status = usr_ctx.Delete(options.ARGV[1]);
+if (status.is_ok != true) {
+	println("Failed to delete user account " + options.ARGV[1] + ": " + status.errstr);
+	return -1;
+}
+
+print ("OK\n");
+return 0;

Samba/testprogs/ejs/ldap.js

@@ -0,0 +1,485 @@
+#!/bin/sh
+exec smbscript "$0" ${1+"$@"}
+/*
+	test certin LDAP behaviours
+*/
+
+var ldb = ldb_init();
+var gc_ldb = ldb_init();
+
+var options = GetOptions(ARGV, 
+		"POPT_AUTOHELP",
+		"POPT_COMMON_SAMBA",
+		"POPT_COMMON_CREDENTIALS");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+libinclude("base.js");
+
+if (options.ARGV.length != 1) {
+   println("Usage: ldap.js <HOST>");
+   return -1;
+}
+
+var host = options.ARGV[0];
+
+function basic_tests(ldb, gc_ldb, base_dn, configuration_dn)
+{
+	println("Running basic tests");
+
+	ldb.del("cn=ldaptestuser,cn=users," + base_dn);
+
+	var ok = ldb.add("
+dn: cn=ldaptestuser,cn=users," + base_dn + "
+objectClass: user
+objectClass: person
+cn: LDAPtestUSER
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptestuser,cn=users," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+		ok = ldb.add("
+dn: cn=ldaptestuser,cn=users," + base_dn + "
+objectClass: user
+objectClass: person
+cn: LDAPtestUSER
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	var ok = ldb.add("
+dn: cn=ldaptestcomputer,cn=computers," + base_dn + "
+objectClass: computer
+cn: LDAPtestCOMPUTER
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptestcomputer,cn=computers," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+		ok = ldb.add("
+dn: cn=ldaptestcomputer,cn=computers," + base_dn + "
+objectClass: computer
+cn: LDAPtestCOMPUTER
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	var ok = ldb.add("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+objectClass: computer
+cn: LDAPtest2COMPUTER
+userAccountControl: 4096
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptest2computer,cn=computers," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+		ok = ldb.add("
+dn: cn=ldaptest2computer,cn=computers," + base_dn + "
+objectClass: computer
+cn: LDAPtest2COMPUTER
+userAccountControl: 4096
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	ok = ldb.add("
+dn: cn=ldaptestuser2,cn=users," + base_dn + "
+objectClass: person
+objectClass: user
+cn: LDAPtestUSER2
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptestuser2,cn=users," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	        ok = ldb.add("
+dn: cn=ldaptestuser2,cn=users," + base_dn + "
+objectClass: person
+objectClass: user
+cn: LDAPtestUSER2
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	ok = ldb.add("
+dn: cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn + "
+objectClass: user
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	ok = ldb.add("
+dn: cn=ldaptestutf8user èùéìòà ,cn=users," + base_dn + "
+objectClass: user
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	ok = ldb.add("
+dn: cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn + "
+objectClass: user
+");
+	if (!ok) {
+		ok = ldb.del("cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn);
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	ok = ldb.add("
+dn: cn=ldaptestutf8user2  èùéìòà ,cn=users," + base_dn + "
+objectClass: user
+");
+		if (!ok) {
+			println(ldb.errstring());
+			assert(ok);
+		}
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestuser)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptestuser)(objectClass=user))");
+	if (res.length != 1) {
+		println("Could not find (&(cn=ldaptestuser)(objectClass=user))");
+		assert(res.length == 1);
+	}
+
+	assert(res[0].dn == "cn=ldaptestuser,cn=users," + base_dn);
+	assert(res[0].cn == "ldaptestuser");
+	assert(res[0].name == "ldaptestuser");
+	assert(res[0].objectClass[0] == "top");
+	assert(res[0].objectClass[1] == "person");
+	assert(res[0].objectClass[2] == "organizationalPerson");
+	assert(res[0].objectClass[3] == "user");
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].whenCreated != undefined);
+	assert(res[0].objectCategory == "cn=Person,cn=Schema,cn=Configuration," + base_dn);
+	assert(res[0].sAMAccountType == 805306368);
+//	assert(res[0].userAccountControl == 546);
+
+	println("Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))");
+	var res2 = ldb.search("(&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))");
+	if (res2.length != 1) {
+		println("Could not find (&(cn=ldaptestuser)(objectCategory=cn=person,cn=schema,cn=configuration," + base_dn + "))");
+		assert(res2.length == 1);
+	}
+
+	assert(res[0].dn == res2[0].dn);
+
+	println("Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon))");
+	var res3 = ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))");
+	if (res3.length != 1) {
+		println("Could not find (&(cn=ldaptestuser)(objectCategory=PerSon))");
+		assert(res3.length == 1);
+	}
+
+	assert(res[0].dn == res3[0].dn);
+
+	if (gc_ldb != undefined) {
+		println("Testing ldb.search for (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog");
+		var res3gc = gc_ldb.search("(&(cn=ldaptestuser)(objectCategory=PerSon))");
+		if (res3gc.length != 1) {
+			println("Could not find (&(cn=ldaptestuser)(objectCategory=PerSon)) in Global Catalog");
+			assert(res3gc.length == 1);
+		}
+	
+		assert(res[0].dn == res3gc[0].dn);
+	}
+
+	ok = ldb.del(res[0].dn);
+	if (!ok) {
+		println(ldb.errstring());
+		assert(ok);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestcomputer)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptestcomputer)(objectClass=user))");
+	if (res.length != 1) {
+		println("Could not find (&(cn=ldaptestuser)(objectClass=user))");
+		assert(res.length == 1);
+	}
+
+	assert(res[0].dn == "cn=ldaptestcomputer,cn=computers," + base_dn);
+	assert(res[0].cn == "ldaptestcomputer");
+	assert(res[0].name == "ldaptestcomputer");
+	assert(res[0].objectClass[0] == "top");
+	assert(res[0].objectClass[1] == "person");
+	assert(res[0].objectClass[2] == "organizationalPerson");
+	assert(res[0].objectClass[3] == "user");
+	assert(res[0].objectClass[4] == "computer");
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].whenCreated != undefined);
+	assert(res[0].objectCategory == "cn=Computer,cn=Schema,cn=Configuration," + base_dn);
+//	assert(res[0].sAMAccountType == 805306368);
+//	assert(res[0].userAccountControl == 546);
+
+	println("Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))");
+	var res2 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))");
+	if (res2.length != 1) {
+		println("Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))");
+		assert(res2.length == 1);
+	}
+
+	assert(res[0].dn == res2[0].dn);
+
+	if (gc_ldb != undefined) {
+		println("Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog");
+		var res2gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + "))");
+		if (res2gc.length != 1) {
+			println("Could not find (&(cn=ldaptestcomputer)(objectCategory=cn=computer,cn=schema,cn=configuration," + base_dn + ")) in Global Catlog");
+			assert(res2gc.length == 1);
+		}
+
+		assert(res[0].dn == res2gc[0].dn);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER))");
+	var res3 = ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))");
+	if (res3.length != 1) {
+		println("Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER))");
+		assert(res3.length == 1);
+	}
+
+	assert(res[0].dn == res3[0].dn);
+
+	if (gc_ldb != undefined) {
+		println("Testing ldb.search for (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog");
+		var res3gc = gc_ldb.search("(&(cn=ldaptestcomputer)(objectCategory=compuTER))");
+		if (res3gc.length != 1) {
+			println("Could not find (&(cn=ldaptestcomputer)(objectCategory=compuTER)) in Global Catalog");
+			assert(res3gc.length == 1);
+		}
+
+		assert(res[0].dn == res3gc[0].dn);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestcomp*r)(objectCategory=compuTER))");
+	var res4 = ldb.search("(&(cn=ldaptestcomp*r)(objectCategory=compuTER))");
+	if (res4.length != 1) {
+		println("Could not find (&(cn=ldaptestcomp*r)(objectCategory=compuTER))");
+		assert(res4.length == 1);
+	}
+
+	assert(res[0].dn == res4[0].dn);
+
+	println("Testing ldb.search for (&(cn=ldaptestcomput*)(objectCategory=compuTER))");
+	var res5 = ldb.search("(&(cn=ldaptestcomput*)(objectCategory=compuTER))");
+	if (res5.length != 1) {
+		println("Could not find (&(cn=ldaptestcomput*)(objectCategory=compuTER))");
+		assert(res5.length == 1);
+	}
+
+	assert(res[0].dn == res5[0].dn);
+
+	println("Testing ldb.search for (&(cn=*daptestcomputer)(objectCategory=compuTER))");
+	var res6 = ldb.search("(&(cn=*daptestcomputer)(objectCategory=compuTER))");
+	if (res6.length != 1) {
+		println("Could not find (&(cn=*daptestcomputer)(objectCategory=compuTER))");
+		assert(res6.length == 1);
+	}
+
+	assert(res[0].dn == res6[0].dn);
+
+	ok = ldb.del(res[0].dn);
+	if (!ok) {
+		println(ldb.errstring());
+		assert(ok);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptest2computer)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptest2computer)(objectClass=user))");
+	if (res.length != 1) {
+		println("Could not find (&(cn=ldaptest2computer)(objectClass=user))");
+		assert(res.length == 1);
+	}
+
+	assert(res[0].dn == "cn=ldaptest2computer,cn=computers," + base_dn);
+	assert(res[0].cn == "ldaptest2computer");
+	assert(res[0].name == "ldaptest2computer");
+	assert(res[0].objectClass[0] == "top");
+	assert(res[0].objectClass[1] == "person");
+	assert(res[0].objectClass[2] == "organizationalPerson");
+	assert(res[0].objectClass[3] == "user");
+	assert(res[0].objectClass[4] == "computer");
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].whenCreated != undefined);
+	assert(res[0].objectCategory == "cn=Computer,cn=Schema,cn=Configuration," + base_dn);
+	assert(res[0].sAMAccountType == 805306369);
+//	assert(res[0].userAccountControl == 4098);
+
+
+	println("Testing ldb.search for (&(cn=ldaptestUSer2)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptestUSer2)(objectClass=user))");
+	if (res.length != 1) {
+		println("Could not find (&(cn=ldaptestUSer2)(objectClass=user))");
+		assert(res.length == 1);
+	}
+
+	assert(res[0].dn == "cn=ldaptestuser2,cn=users," + base_dn);
+	assert(res[0].cn == "ldaptestuser2");
+	assert(res[0].name == "ldaptestuser2");
+	assert(res[0].objectClass[0] == "top");
+	assert(res[0].objectClass[1] == "person");
+	assert(res[0].objectClass[2] == "organizationalPerson");
+	assert(res[0].objectClass[3] == "user");
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].whenCreated != undefined);
+
+	ok = ldb.del(res[0].dn);
+	if (!ok) {
+		println(ldb.errstring());
+		assert(ok);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))");
+
+	if (res.length != 1) {
+		println("Could not find (&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))");
+		assert(res.length == 1);
+	}
+
+	assert(res[0].dn == "cn=ldaptestutf8user èùéìòà,cn=users," + base_dn);
+	assert(res[0].cn == "ldaptestutf8user èùéìòà");
+	assert(res[0].name == "ldaptestutf8user èùéìòà");
+	assert(res[0].objectClass[0] == "top");
+	assert(res[0].objectClass[1] == "person");
+	assert(res[0].objectClass[2] == "organizationalPerson");
+	assert(res[0].objectClass[3] == "user");
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].whenCreated != undefined);
+
+	ok = ldb.del(res[0].dn);
+	if (!ok) {
+		println(ldb.errstring());
+		assert(ok);
+	}
+
+	println("Testing ldb.search for (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))");
+	var res = ldb.search("(&(cn=ldaptestutf8user ÈÙÉÌÒÀ)(objectClass=user))");
+
+	if (res.length != 1) {
+		println("Could not find (expect space collapse, win2k3 fails) (&(cn=ldaptestutf8user2 ÈÙÉÌÒÀ)(objectClass=user))");
+	} else {
+		assert(res[0].dn == "cn=ldaptestutf8user2 èùéìòà,cn=users," + base_dn);
+		assert(res[0].cn == "ldaptestutf8user2 èùéìòà");
+	}
+
+	println("Testing that we can't get at the configuration DN from the main search base");
+	var attrs = new Array("cn");
+	var res = ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs);
+	assert (res.length == 0);
+
+	if (gc_ldb != undefined) {
+		println("Testing that we do find configuration elements in the global catlog");
+		var attrs = new Array("cn");
+		var res = gc_ldb.search("objectClass=crossRef", base_dn, ldb.SCOPE_SUBTREE, attrs);
+		assert (res.length > 0);
+	
+		println("Testing that we do find configuration elements and user elements at the same time");
+		var attrs = new Array("cn");
+		var res = gc_ldb.search("(|(objectClass=crossRef)(objectClass=person))", base_dn, ldb.SCOPE_SUBTREE, attrs);
+		assert (res.length > 0);
+
+		println("Testing that we do find configuration elements in the global catlog, with the configuration basedn");
+		var attrs = new Array("cn");
+		var res = gc_ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs);
+		assert (res.length > 0);
+	}
+
+	println("Testing that we can get at the configuration DN on the main LDAP port");
+	var attrs = new Array("cn");
+	var res = ldb.search("objectClass=crossRef", configuration_dn, ldb.SCOPE_SUBTREE, attrs);
+	assert (res.length > 0);
+
+}
+
+function basedn_tests(ldb, gc_ldb)
+{
+	println("Testing for all rootDSE attributes");
+	var attrs = new Array();
+	var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(res.length == 1);
+
+	println("Testing for highestCommittedUSN");
+	var attrs = new Array("highestCommittedUSN");
+	var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(res.length == 1);
+	assert(res[0].highestCommittedUSN != undefined);
+	assert(res[0].highestCommittedUSN != 0);
+
+	println("Testing for netlogon via LDAP");
+	var attrs = new Array("netlogon");
+	var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(res.length == 0);
+
+	println("Testing for netlogon and highestCommittedUSN via LDAP");
+	var attrs = new Array("netlogon", "highestCommittedUSN");
+	var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(res.length == 0);
+}
+
+function find_basedn(ldb)
+{
+    var attrs = new Array("defaultNamingContext");
+    var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+    assert(res.length == 1);
+    return res[0].defaultNamingContext;
+}
+
+function find_configurationdn(ldb)
+{
+    var attrs = new Array("configurationNamingContext");
+    var res = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+    assert(res.length == 1);
+    return res[0].configurationNamingContext;
+}
+
+/* use command line creds if available */
+ldb.credentials = options.get_credentials();
+gc_ldb.credentials = options.get_credentials();
+
+var ok = ldb.connect("ldap://" + host);
+var base_dn = find_basedn(ldb);
+var configuration_dn = find_configurationdn(ldb);
+
+printf("baseDN: %s\n", base_dn);
+
+var ok = gc_ldb.connect("ldap://" + host + ":3268");
+if (!ok) {
+	gc_ldb = undefined;
+}
+
+basic_tests(ldb, gc_ldb, base_dn, configuration_dn)
+
+basedn_tests(ldb, gc_ldb)
+
+return 0;

Samba/testprogs/ejs/ldb.js

@@ -0,0 +1,381 @@
+#!/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);
+
+	println("Testing ldb.search");
+	var res = ldb.search("(objectClass=*)");
+	assert(res[0].objectClass[0] == "foo");
+	assert(res[0].dn == "cn=x,cn=test");
+	assert(res[0].x == 3);
+
+	ok = ldb.add("
+dn: cn=x2,cn=test
+objectClass: foo
+x: 4
+");
+	assert(ok);
+	var attrs = new Array("x");
+	res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
+	assert(res[0].x == 4);
+	assert(res[0].objectClass == undefined);
+	assert(res[0].dn == "cn=x2,cn=test");
+
+	ok = ldb.del("cn=x,cn=test");
+	assert(ok);
+
+	ok = ldb.rename("cn=x2,cn=test", "cn=x3,cn=test");
+	assert(ok);
+	res = ldb.search("x=4", NULL, ldb.SCOPE_DEFAULT, attrs);
+	assert(res[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.length == 1);
+	assert(res[0].x.length == 2);
+
+	/* Check a few things before we add modules */
+	assert(res[0].objectGUID == undefined);
+	assert(res[0].createTimestamp == undefined);
+	assert(res[0].whenCreated == undefined);
+
+}
+	
+function setup_modules(ldb)
+{
+	ok = ldb.add("
+dn: @MODULES
+@LIST: rootdse,operational,rdn_name,partition
+
+dn: cn=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: @SUBCLASSES
+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) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	/* Confirm that the attributes were replicated */
+	var res_attrs =  parttestldb.search("cn=*", "@ATTRIBUTES",  parttestldb.SCOPE_BASE);
+	assert(res_attrs[0].cn == "CASE_INSENSITIVE");
+
+	ok = ldb.add("
+dn: cn=x8,cn=PartTest
+objectClass: foo
+x: 8
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	ok = ldb.add("
+dn: cn=x9,cn=PartTest
+objectClass: foo
+x: 9
+cn: X9
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	ok = ldb.add("
+dn: cn=X9,cn=PartTest
+objectClass: foo
+x: 9
+cn: X9
+");
+	if (ok) {
+		println("Should have failed to add cn=X9,cn=PartTest");
+		assert(!ok);
+	}
+
+	var res = ldb.search("x=8", "cn=PartTest", ldb.SCOPE_DEFAULT);
+	assert(res[0].objectGUID != undefined);
+	assert(res[0].uSNCreated != undefined);
+	assert(res[0].uSNChanged != undefined);
+	assert(res[0].createTimestamp == undefined);
+	assert(res[0].whenCreated != undefined);
+	assert(res[0].name == "x8");
+	assert(res[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[0].objectGUID != undefined);
+	assert(res_otherldb[0].createTimestamp == undefined);
+	assert(res_otherldb[0].whenCreated != undefined);
+	assert(res_otherldb[0].name == "x8");
+	assert(res_otherldb[0].cn == "x8");
+
+	var attrs = new Array("*", "createTimestamp");
+	var res2 = ldb.search("x=9", "cn=PartTest", ldb.SCOPE_DEFAULT, attrs);
+	assert(res2[0].objectGUID != undefined);
+	assert(res2[0].createTimestamp != undefined);
+	assert(res2[0].whenCreated != undefined);
+	assert(res2[0].name == "x9");
+	assert(res2[0].cn == "x9");
+
+	assert(res[0].objectGUID != res2[0].objectGUID);
+
+	var attrs = new Array("*");
+	var res3 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(res3[0].cn == undefined);
+	assert(res3[0].distinguishedName == undefined);
+	assert(res3[0].name == undefined);
+	assert(res3[0].currentTime != undefined);
+	assert(res3[0].highestCommittedUSN != undefined);
+
+	assert(res3[0].namingContexts[0] == "cn=Sub,cn=Sub,cn=PartTest");
+	assert(res3[0].namingContexts[1] == "cn=Sub,cn=PartTest");
+	assert(res3[0].namingContexts[2] == "cn=PartTest");
+	assert(res3[0].namingContexts[3] == "cn=SideTest");
+	var usn = res3[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: " + ldb.errstring());
+		assert(ok);
+	}
+
+	
+	ok = ldb.add("
+dn: cn=x10,cn=parttest
+objectClass: foo
+x: 10
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	var attrs = new Array("highestCommittedUSN");
+	var res4 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	var usn2 = res4[0].highestCommittedUSN;
+	assert(usn < res4[0].highestCommittedUSN);
+
+	ok = ldb.add("
+dn: cn=x11,cn=sub,cn=parttest
+objectClass: foo
+x: 11
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	var attrs = new Array("highestCommittedUSN");
+	var res5 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(usn2 < res5[0].highestCommittedUSN);
+	
+	var attrs = new Array("*", "createTimestamp");
+	var res6 = ldb.search("x=11", "cn=parttest", ldb.SCOPE_SUB, attrs);
+	assert(res6.length == 0);
+
+	var attrs = new Array("*", "createTimestamp");
+	var res7 = ldb.search("x=10", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(res7.length == 0);
+
+	var res8 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	
+	assert(res8[0].objectGUID == undefined); /* The objectGUID module is not loaded here */
+	assert(res8[0].uSNCreated == undefined); /* The objectGUID module is not loaded here */
+	assert(res8[0].name == "x11");
+	assert(res8[0].cn == "x11");
+
+	ok = ldb.add("
+dn: caseattr=XY,cn=PartTest
+objectClass: foo
+x: Y
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	ok = ldb.add("
+dn: caseattr=XZ,cn=PartTest
+objectClass: foo
+x: Z
+caseattr: XZ
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	ok = ldb.add("
+dn: caseattr=xz,cn=PartTest
+objectClass: foo
+x: Z
+caseattr: xz
+");
+	if (ok) {
+		println("Should have failed to add caseattr=xz,cn=PartTest");
+		assert(!ok);
+	}
+
+	ok = ldb.add("
+dn: caseattr2=XZ,cn=PartTest
+objectClass: foo
+x: Z
+caseattr2: XZ
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	ok = ldb.add("
+dn: caseattr2=Xz,cn=PartTest
+objectClass: foo
+x: Z
+caseattr2: Xz
+");
+	if (!ok) {
+		println("Failed to add: " + ldb.errstring());
+		assert(ok);
+	}
+
+	var resX = ldb.search("caseattr=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(resX.length == 1); 
+	assert(resX[0].objectGUID != undefined);
+	assert(resX[0].createTimestamp != undefined);
+	assert(resX[0].whenCreated != undefined);
+	assert(resX[0].name == "XZ");
+
+	var rescount = ldb.search("(|(caseattr=*)(cn=*))", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(rescount.length == 5); 
+
+	/* Check this attribute is *not* case sensitive */
+	var resXcount = ldb.search("caseattr=x*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(resXcount.length == 2); 
+	
+	/* Check that this attribute *is* case sensitive */
+	var resXcount2 = ldb.search("caseattr2=xz", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(resXcount2.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: " + ldb.errstring());
+		assert(ok);
+	}
+
+	/* now check it all went away */
+
+	var attrs = new Array("highestCommittedUSN");
+	var res9 = ldb.search("", "", ldb.SCOPE_BASE, attrs);
+	assert(usn == res9[0].highestCommittedUSN);
+	
+	var attrs = new Array("*");
+	var res10 = ldb.search("x=11", "cn=sub,cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(res10.length == 0);
+
+	var attrs = new Array("*");
+	var res11 = ldb.search("x=10", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(res11.length == 0);
+
+	var attrs = new Array("*");
+	var res12 = ldb.search("caseattr=*", "cn=parttest", ldb.SCOPE_DEFAULT, attrs);
+	assert(res12.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;

Samba/testprogs/ejs/loadparm.js

@@ -0,0 +1,25 @@
+/*
+	demonstrate access to loadparm functions from ejs
+*/	
+
+loadparm_init(local);
+
+function showParameter(name) {
+	 print(name + ": ");
+	 printVars(get(name));
+}
+
+for (v in ARGV) {
+    showParameter(ARGV[v]);
+}
+
+print("defined services: ");
+printVars(services());
+
+showParameter("server services");
+showParameter("netbios name");
+showParameter("security");
+showParameter("workgroup");
+showParameter("log level");
+showParameter("server signing");
+showParameter("interfaces");

Samba/testprogs/ejs/minschema.js

@@ -0,0 +1,761 @@
+#!/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");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+verbose = options["verbose"];
+
+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", 
+			"auxiliaryClass", "systemAuxiliaryClass",
+			"possSuperiors", "systemPossSuperiors",
+			"lDAPDisplayName", "governsID",
+			"rDNAttID", "mustContain", "systemMustContain",
+			"mayContain", "systemMayContain",
+			"objectClassCategory", "subClassOf", 
+			"defaultObjectCategory", "defaultHidingValue", 
+			"systemFlags", "systemOnly", "defaultSecurityDescriptor",
+			"objectCategory", "possibleInferiors", "displaySpecification",
+			"schemaIDGUID");
+
+attrib_attrs = new Array("objectClass", "lDAPDisplayName", 
+			 "isSingleValued", "linkID", "systemFlags", "systemOnly",
+			 "schemaIDGUID", "adminDisplayName", "attributeID",
+			 "attributeSyntax", "oMSyntax", "oMObjectClass");
+
+/*
+  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.length == 1);
+
+        var cn = res[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 ${BASEDN}
+*/
+function fix_dn(dn) {
+	var s = strstr(dn, rootDse.defaultNamingContext);
+	if (s == NULL) {
+		return dn;
+	}
+	return substr(dn, 0, strlen(dn) - strlen(s)) + "${BASEDN}";
+}
+
+/*
+  dump an object as ldif
+*/
+function write_ldif_one(o, attrs) {
+	var i;
+	printf("dn: CN=%s,CN=Schema,CN=Configuration,${BASEDN}\n", o.cn);
+	printf("cn: %s\n", o.cn);
+	printf("name: %s\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.length == 1);
+	var msg = res[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.length == 1);
+	var msg = res[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) {
+		dprintf("error adding %s: %s\n", o.name, ldb.errstring());
+		dprintf("%s\n", ldif);
+		return;
+	}
+
+	var res = ldb.search("", testdn, ldb.SCOPE_BASE);
+	ok = ldb.del(testdn);
+	assert(ok);
+
+	var a;
+	for (a in res[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.length == 1);
+	var msg = res[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 == undefined) {
+		dprintf("Unable to fetch allowedAttributes for '%s' - %s\n", 
+		       dn, ldb.errstring());
+		return;
+	}
+	var allattrs = res[0].allowedAttributes;
+	res = ldb.search("objectClass=*", dn, ldb.SCOPE_BASE, allattrs);
+	if (res == undefined) {
+		dprintf("Unable to fetch all attributes for '%s' - %s\n", 
+		       dn, ldb.errstring());
+		return;
+	}
+	var a;
+	var msg = res[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 == undefined) {
+		dprintf("Unable to fetch objectClasses for '%s' - %s\n", 
+		       namingContext, ldb.errstring());
+		return;
+	}
+	var r;
+	for (r=0;r<res.length;r++) {
+		var msg = res[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[r].dn;
+			}
+		}
+		walk_dn(ldb, res[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 == undefined) {
+		dprintf("unknown class '%s'\n", name);
+		return undefined;
+	}
+	if (res.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 ");
+	}
+	printf(")\n");
+}
+
+
+/*
+  write the aggregate record
+*/
+function write_aggregate() {
+	printf("dn: CN=Aggregate,CN=Schema,CN=Configuration,${BASEDN}\n");
+	print("objectClass: top
+objectClass: subSchema
+cn: Aggregate
+instanceType: 4
+name: Aggregate
+objectCategory: CN=SubSchema,CN=Schema,CN=Configuration,${BASEDN}
+");
+	for (i in objectclasses) {
+		write_aggregate_objectclass(objectclasses[i]);
+	}
+	for (i in attributes) {
+		write_aggregate_attribute(attributes[i]);
+	}
+	for (i in objectclasses) {
+		write_aggregate_ditcontentrule(objectclasses[i]);
+	}
+}
+
+/*
+  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[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
+   can't 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
+*/
+write_ldif(attributes, attrib_attrs);
+write_ldif(objectclasses, class_attrs);
+
+write_aggregate();
+
+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;

Samba/testprogs/ejs/minschema_classes.txt

@@ -0,0 +1,32 @@
+applicationSettings
+builtinDomain
+classSchema
+computer
+configuration
+container
+crossRef
+crossRefContainer
+dMD
+domain
+domainDNS
+foreignSecurityPrincipal
+group
+infrastructureUpdate
+leaf
+nTDSDSA
+nTDSService
+organizationalPerson
+organizationalUnit
+person
+primaryDomain
+rIDManager
+secret
+server
+serversContainer
+site
+sitesContainer
+subSchema
+user
+displaySpecifier
+foreignSecurityPrincipal
+trustedDomain

Samba/testprogs/ejs/nbtstats

@@ -0,0 +1,33 @@
+#!/usr/bin/env smbscript
+/*
+	demonstrate access to irpc calls from ejs
+*/	
+
+var options = GetOptions(ARGV, 
+			 "POPT_AUTOHELP",
+			 "POPT_COMMON_SAMBA");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+var conn = new Object();
+var irpc = irpc_init();
+
+status = irpc_connect(conn, "nbt_server");
+assert(status.is_ok == true);
+
+io = new Object();
+io.input = new Object();
+io.input.level = irpc.NBTD_INFO_STATISTICS;
+status = irpc.nbtd_information(conn, io);
+assert(status.is_ok == true);
+assert(io.results.length == 1);
+
+print("nbt_server statistics:\n");
+stats = io.results[0].info.stats;
+
+for (r in stats) {
+    print("\t" + r + ":\t" + stats[r] + "\n");
+}
+return 0;

Samba/testprogs/ejs/resolveName.js

@@ -0,0 +1,13 @@
+/* 
+  Demonstrate use of resolveName() js function
+*/
+
+var result = new Object();
+
+res = resolveName(result, ARGV[0]);
+
+if (res.is_ok) {
+	println(result.value);
+} else {
+	println(res.errstr);
+}

Samba/testprogs/ejs/samr.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env smbscript
+/*
+  test samr calls from ejs
+*/	
+
+var options = GetOptions(ARGV, 
+			 "POPT_AUTOHELP",
+			 "POPT_COMMON_SAMBA",
+			 "POPT_COMMON_CREDENTIALS");
+if (options == undefined) {
+   println("Failed to parse options");
+   return -1;
+}
+
+libinclude("base.js");
+libinclude("samr.js");
+
+
+/*
+  test the samr_Connect interface
+*/
+function test_Connect(samr)
+{
+	print("Testing samr_Connect\n");
+	return samrConnect(samr);
+}
+
+
+/*
+  test the samr_LookupDomain interface
+*/
+function test_LookupDomain(samr, handle, domain)
+{
+	print("Testing samr_LookupDomain\n");
+	return samrLookupDomain(samr, handle, domain);
+}
+
+/*
+  test the samr_OpenDomain interface
+*/
+function test_OpenDomain(samr, handle, sid)
+{
+	print("Testing samr_OpenDomain\n");
+	return samrOpenDomain(samr, handle, sid);
+}
+
+/*
+  test the samr_EnumDomainUsers interface
+*/
+function test_EnumDomainUsers(samr, dom_handle)
+{
+	var i, users;
+	print("Testing samr_EnumDomainUsers\n");
+	users = samrEnumDomainUsers(samr, dom_handle);
+	print("Found " + users.length + " users\n");
+	for (i=0;i<users.length;i++) {
+		println("\t" + users[i].name + "\t(" + users[i].idx + ")");
+	}
+}
+
+/*
+  test the samr_EnumDomainGroups interface
+*/
+function test_EnumDomainGroups(samr, dom_handle)
+{
+	print("Testing samr_EnumDomainGroups\n");
+	var i, groups = samrEnumDomainGroups(samr, dom_handle);
+	print("Found " + groups.length + " groups\n");
+	for (i=0;i<groups.length;i++) {
+		println("\t" + groups[i].name + "\t(" + groups[i].idx + ")");
+	}
+}
+
+/*
+  test domain specific ops
+*/
+function test_domain_ops(samr, dom_handle)
+{
+	test_EnumDomainUsers(samr, dom_handle);
+	test_EnumDomainGroups(samr, dom_handle);
+}
+
+
+
+/*
+  test the samr_EnumDomains interface
+*/
+function test_EnumDomains(samr, handle)
+{
+	var i, domains;
+	print("Testing samr_EnumDomains\n");
+
+	domains = samrEnumDomains(samr, handle);
+	print("Found " + domains.length + " domains\n");
+	for (i=0;i<domains.length;i++) {
+		print("\t" + domains[i].name + "\n");
+	}
+	for (i=0;i<domains.length;i++) {
+		print("Testing domain " + domains[i].name + "\n");
+		sid = samrLookupDomain(samr, handle, domains[i].name);
+		dom_handle = test_OpenDomain(samr, handle, sid);
+		test_domain_ops(samr, dom_handle);
+		samrClose(samr, dom_handle);
+	}
+}
+
+if (options.ARGV.length != 1) {
+   println("Usage: samr.js <BINDING>");
+   return -1;
+}
+var binding = options.ARGV[0];
+var samr = samr_init();
+
+print("Connecting to " + binding + "\n");
+status = samr.connect(binding);
+if (status.is_ok != true) {
+   print("Failed to connect to " + binding + " - " + status.errstr + "\n");
+   return -1;
+}
+
+handle = test_Connect(samr);
+test_EnumDomains(samr, handle);
+samrClose(samr, handle);
+
+print("All OK\n");
+return 0;

Samba/testprogs/ejs/sprintf.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env smbscript
+/*
+	test sprintf function
+*/
+
+string_init(local);
+
+function check_result(s, v)
+{
+	if (s != v) {
+		println("expected '" + v + "' but got '" + s + "'");
+	}
+	assert(s == v);
+}
+
+function xprintf()
+{
+	return "XX{" + vsprintf(arguments) + "}XX";
+}
+
+check_result(sprintf("%d", 7), "7");
+check_result(sprintf("%04d", 42), "0042");
+check_result(sprintf("my string=%7.2s", "foo%7"), "my string=     fo");
+check_result(sprintf("blah=0x%*x", 4, 19), "blah=0x  13");
+check_result(sprintf("blah=0x%0*x", 4, 19), "blah=0x0013");
+check_result(sprintf("blah=%.0f", 1032), "blah=1032");
+check_result(sprintf("%4.2f%%", 72.32), "72.32%");
+
+check_result(xprintf("%4.2f%% and %s", 72.32, "foo"),"XX{72.32% and foo}XX");
+
+println("ALL OK");

Samba/testprogs/win32/npecho/GNUmakefile

@@ -0,0 +1,20 @@
+INCLUDES=-I.
+CFLAGS=$(INCLUDES) 
+
+all: npecho_client.exe npecho_server.exe
+
+CC = i586-mingw32msvc-gcc
+
+.SUFFIXES: .c .obj
+
+.c.obj: 
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clean:
+	del *~ *.obj *.exe 
+
+npecho_client.exe: npecho_client.obj
+npecho_server.exe: npecho_server.obj
+
+%.exe: 
+	$(CC) $(CFLAGS) -o $@ $< $(LIBS)

Samba/testprogs/win32/npecho/NMakefile

@@ -0,0 +1,13 @@
+INCLUDES=-I 
+CFLAGS=$(INCLUDES) -Zi -nologo
+
+all: npecho_client.exe npecho_server.exe
+
+clean:
+	del *~ *.obj *.exe 
+
+npecho_client.exe: npecho_client.obj 
+	$(CC) $(CFLAGS) -o npecho_client.exe npecho_client.obj $(LIBS)
+
+npecho_server.exe: npecho_server.obj 
+	$(CC) $(CFLAGS) -o npecho_server.exe npecho_server.obj $(LIBS)

Samba/testprogs/win32/npecho/npecho_client.c

@@ -0,0 +1,50 @@
+/*
+ * Simple Named Pipe Client
+ * (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+ * Published to the public domain
+ */
+
+#include <windows.h>
+#include <stdio.h>
+
+#define ECHODATA "Black Dog"
+
+int main(int argc, char *argv[])
+{
+	HANDLE h;
+	DWORD numread = 0;
+	char *outbuffer = malloc(strlen(ECHODATA));
+
+	if (argc == 1) {
+		printf("Usage: %s pipename\n", argv[0]);
+		printf("  Where pipename is something like \\\\servername\\NPECHO\n");
+		return -1;
+	}
+
+	h = CreateFile(argv[1], GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+	if (h == INVALID_HANDLE_VALUE) {
+		printf("Error opening: %d\n", GetLastError());
+		return -1;
+	}
+
+	if (!WriteFile(h, ECHODATA, strlen(ECHODATA), &numread, NULL)) {
+		printf("Error writing: %d\n", GetLastError());
+		return -1;
+	}
+
+	if (!ReadFile(h, outbuffer, strlen(ECHODATA), &numread, NULL)) {
+		printf("Error reading: %d\n", GetLastError());
+		return -1;
+	}
+
+	printf("Read: %s\n", outbuffer);
+	
+	if (!TransactNamedPipe(h, ECHODATA, strlen(ECHODATA), outbuffer, strlen(ECHODATA), &numread, NULL)) {
+		printf("TransactNamedPipe failed: %d!\n", GetLastError());
+		return -1;
+	}
+
+	printf("Result: %s\n", outbuffer);
+
+	return 0;
+}

Samba/testprogs/win32/rpcecho/Makefile

@@ -0,0 +1,23 @@
+INCLUDES=-I 
+CFLAGS=$(INCLUDES) -Zi -nologo
+LIBS=rpcrt4.lib
+
+all: client server
+
+clean:
+	del *~ *.obj client server rpcecho_c.c rpcecho_s.c rpcecho.h
+
+rpcecho.h rpcecho_s.c rpcecho_c.c: rpcecho.idl rpcecho.acf
+	midl rpcecho.idl
+
+client: client.obj rpcecho_c.obj utils.obj
+	$(CC) $(CFLAGS) -o client client.obj rpcecho_c.obj utils.obj $(LIBS)
+
+server: server.obj rpcecho_s.obj utils.obj
+	$(CC) $(CFLAGS) -o server server.obj rpcecho_s.obj utils.obj $(LIBS)
+
+client.obj: rpcecho.h client.c
+server.obj: rpcecho.h server.c
+rpcecho_c.obj: rpcecho.h rpcecho_c.c
+rpcecho_s.obj: rpcecho.h rpcecho_s.c
+utils.obj: rpcecho.h utils.c

Samba/testprogs/win32/rpcecho/README

@@ -0,0 +1,46 @@
+This directory contains two win32 programs to test large RPC requests
+and responses.  The two programs are:
+
+  server        A command line RPC server that listens and processes
+                RPC requests on the \pipe\rpcecho named pipe.
+
+  client        A command line RPC client program that 
+
+Samba also implements the client and server sides of the rpcecho pipe
+if the --enable-developer option to configure has been used.  The
+rpcclient(1) program is used to implement the client side RPC
+operations.
+
+There are currently four RPC calls defined in the rpcecho pipe.  They
+are: 
+
+  AddOne	Adds one to an integer sent by the client
+
+  EchoData	The client sends an array of bytes and it is echoed
+ 		back by the server.
+
+  SourceData	The client sends an array of bytes and it is discarded
+		by the server.
+
+  SinkData	The server returns an array of bytes.
+
+The Ethereal network protocol decoder (http://www.ethereal.com/) also
+contains support for the rpcecho pipe as part of its DCERPC for
+Windows.
+
+Starting the win32 server program is easy.  Just run server.exe in a
+command window.  The win32 client program is also run from a command
+window.  The usage information is shown below:
+
+  Usage: client hostname cmd [args]
+
+  Where hostname is the name of the host to connect to,
+  and cmd is the command to execute with optional args:
+
+  	addone num	Add one to num and return the result
+	echodata size	Send an array of size bytes and receive it back
+	sinkdata size	Send an array of size bytes
+	sourcedata size	Receive an array of size bytes
+
+Tim Potter 
+tpot@samba.org

Samba/testprogs/win32/rpcecho/client.c

@@ -0,0 +1,368 @@
+/* 
+   RPC echo client.
+
+   Copyright (C) Tim Potter 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "rpcecho.h"
+
+void main(int argc, char **argv)
+{
+	RPC_STATUS status;
+	char *binding = NULL;
+	const char *username=NULL;
+	const char *password=NULL;
+	const char *domain=NULL;
+	unsigned sec_options = 0;
+
+	argv += 1;
+	argc -= 1;
+
+	while (argc > 2 && argv[0][0] == '-') {
+		const char *option;
+
+		switch (argv[0][1]) {
+		case 'e':
+			binding = argv[1];
+			break;
+		case 'u':
+			username = argv[1];
+			break;
+		case 'p':
+			password = argv[1];
+			break;
+		case 'd':
+			domain = argv[1];
+			break;
+		case '-':
+			option = &argv[0][2];
+			if (strcmp(option, "sign") == 0) {
+				if (sec_options == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) {
+					printf("You must choose sign or seal, not both\n");
+					exit(1);
+				}
+				sec_options = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY;
+			} else if (strcmp(option, "seal") == 0) {
+				if (sec_options == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY) {
+					printf("You must choose sign or seal, not both\n");
+					exit(1);
+				}
+				sec_options = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
+			} else {
+				printf("Bad security option '%s'\n", option);
+				exit(1);
+			}
+			argv++;
+			argc--;
+			continue;
+		default:
+			printf("Bad option -%c\n", argv[0][0]);
+			exit(1);
+		}
+		argv += 2;
+		argc -= 2;
+	}
+
+	if (argc < 2) {
+		printf("Usage: client [options] hostname cmd [args]\n\n");
+		printf("Where hostname is the name of the host to connect to,\n");
+		printf("and cmd is the command to execute with optional args:\n\n");
+		printf("\taddone num\tAdd one to num and return the result\n");
+		printf("\techodata size\tSend an array of size bytes and receive it back\n");
+		printf("\tsinkdata size\tSend an array of size bytes\n");
+		printf("\tsourcedata size\tReceive an array of size bytes\n");
+		printf("\ttest\trun testcall\n");
+		printf("\noptions:\n");
+		printf("\t-u username -d domain -p password -e endpoint\n");
+		printf("\t--sign --seal\n");
+		printf("\nExamples:\n");
+		printf("\tclient HOSTNAME addone 3\n");
+		printf("\tclient 192.168.115.1 addone 3\n");
+		printf("\tclient -e ncacn_np:HOSTNAME[\\\\pipe\\\\rpcecho] addone 3\n");
+		printf("\tclient -e ncacn_ip_tcp:192.168.115.1 addone 3\n");
+		printf("\tclient -e ncacn_ip_tcp:192.168.115.1 -u tridge -d MYDOMAIN -p PASSWORD addone 3\n");
+		exit(0);
+	}
+
+
+	if (!binding) {
+		char *network_address = argv[0];
+
+		argc--;
+		argv++;
+
+		status = RpcStringBindingCompose(
+			NULL, /* uuid */
+			"ncacn_np",
+			network_address,
+			"\\pipe\\rpcecho",
+			NULL, /* options */
+			&binding);
+
+		if (status) {
+			printf("RpcStringBindingCompose returned %d\n", status);
+			exit(status);
+		}
+	}
+
+	printf("Endpoint is %s\n", binding);
+
+	status = RpcBindingFromStringBinding(
+			binding,
+			&rpcecho_IfHandle);
+
+	if (status) {
+		printf("RpcBindingFromStringBinding returned %d\n", status);
+		exit(status);
+	}
+
+	if (username) {
+		SEC_WINNT_AUTH_IDENTITY ident = { username, strlen(username),
+						  domain, strlen(domain),
+						  password, strlen(password),
+						  SEC_WINNT_AUTH_IDENTITY_ANSI };
+
+		status = RpcBindingSetAuthInfo(rpcecho_IfHandle, NULL,
+					       sec_options,
+					       RPC_C_AUTHN_WINNT,
+					       &ident, 0);
+		if (status) {
+			printf ("RpcBindingSetAuthInfo failed: 0x%x\n", status);
+			exit (1);
+		}
+	}
+
+
+	while (argc > 0) {
+	RpcTryExcept {
+
+		/* Add one to a number */
+
+		if (strcmp(argv[0], "addone") == 0) {
+			int arg, result;
+
+			if (argc < 2) {
+				printf("Usage: addone num\n");
+				exit(1);
+			}
+
+			arg = atoi(argv[1]);
+
+			AddOne(arg, &result);
+			printf("%d + 1 = %d\n", arg, result);
+
+			argc -= 2;
+			argv += 2;
+			continue;
+		}
+
+		/* Echo an array */
+
+		if (strcmp(argv[0], "echodata") == 0) {
+			int arg, i;
+			char *indata, *outdata;
+
+			if (argc < 2) {
+				printf("Usage: echo num\n");
+				exit(1);
+			}
+
+			arg = atoi(argv[1]);
+
+			if ((indata = malloc(arg)) == NULL) {
+				printf("Error allocating %d bytes for input\n", arg);
+				exit(1);
+			}
+
+			if ((outdata = malloc(arg)) == NULL) {
+				printf("Error allocating %d bytes for output\n", arg);
+				exit(1);
+			}
+
+			for (i = 0; i < arg; i++)
+				indata[i] = i & 0xff;
+
+			EchoData(arg, indata, outdata);
+
+			printf("echo %d\n", arg);
+
+			for (i = 0; i < arg; i++) {
+				if (indata[i] != outdata[i]) {
+					printf("data mismatch at offset %d, %d != %d\n",
+						i, indata[i], outdata[i]);
+					exit(0);
+				}
+			}
+
+			argc -= 2;
+			argv += 2;
+			continue;
+		}
+
+		if (strcmp(argv[0], "sinkdata") == 0) {
+			int arg, i;
+			char *indata;
+
+			if (argc < 2) {
+				printf("Usage: sinkdata num\n");
+				exit(1);
+			}
+
+			arg = atoi(argv[1]);		
+
+			if ((indata = malloc(arg)) == NULL) {
+				printf("Error allocating %d bytes for input\n", arg);
+				exit(1);
+			}			
+
+			for (i = 0; i < arg; i++)
+				indata[i] = i & 0xff;
+
+			SinkData(arg, indata);
+
+			printf("sinkdata %d\n", arg);
+			argc -= 2;
+			argv += 2;
+			continue;
+		}
+
+		if (strcmp(argv[0], "sourcedata") == 0) {
+			int arg, i;
+			unsigned char *outdata;
+
+			if (argc < 2) {
+				printf("Usage: sourcedata num\n");
+				exit(1);
+			}
+
+			arg = atoi(argv[1]);		
+
+			if ((outdata = malloc(arg)) == NULL) {
+				printf("Error allocating %d bytes for output\n", arg);
+				exit(1);
+			}			
+
+			SourceData(arg, outdata);
+
+			printf("sourcedata %d\n", arg);
+
+			for (i = 0; i < arg; i++) {
+				if (outdata[i] != (i & 0xff)) {
+					printf("data mismatch at offset %d, %d != %d\n",
+						i, outdata[i], i & 0xff);
+				}
+			}
+
+			argc -= 2;
+			argv += 2;
+			continue;
+		}
+
+		if (strcmp(argv[0], "test") == 0) {
+			printf("no TestCall\n");
+
+			argc -= 1;
+			argv += 1;
+			continue;
+		}
+
+
+		if (strcmp(argv[0], "enum") == 0) {
+			enum echo_Enum1 v = ECHO_ENUM1;
+			echo_Enum2 e2;
+			echo_Enum3 e3;
+
+			e2.e1 = 76;
+			e2.e2 = ECHO_ENUM1_32;
+			e3.e1 = ECHO_ENUM2;
+			
+			argc -= 1;
+			argv += 1;
+
+			echo_TestEnum(&v, &e2, &e3);
+			
+			continue;
+		}
+
+		if (strcmp(argv[0], "double") == 0) {
+			typedef unsigned short uint16;
+			uint16 v = 13;
+			uint16 *pv = &v;
+			uint16 **ppv = &pv;
+			uint16 ret;
+
+			argc -= 1;
+			argv += 1;
+
+			ret = echo_TestDoublePointer(&ppv);
+
+			printf("TestDoublePointer v=%d ret=%d\n", v, ret);
+			
+			continue;
+		}
+
+		if (strcmp(argv[0], "sleep") == 0) {
+			long arg, result;
+
+			if (argc < 2) {
+				printf("Usage: sleep num\n");
+				exit(1);
+			}
+
+			arg = atoi(argv[1]);
+
+//			result = TestSleep(arg);
+//			printf("Slept for %d seconds\n", result);
+			printf("Sleep disabled (need async code)\n");
+
+			argc -= 2;
+			argv += 2;
+			continue;
+		}
+
+		printf("Invalid command '%s'\n", argv[0]);
+		goto done;
+
+	} RpcExcept(1) {
+		unsigned long ex;
+
+		ex = RpcExceptionCode();
+		printf("Runtime error 0x%x\n", ex);
+	} RpcEndExcept
+		  }
+
+done:
+
+	status = RpcStringFree(&binding);
+
+	if (status) {
+		printf("RpcStringFree returned %d\n", status);
+		exit(status);
+	}
+
+	status = RpcBindingFree(&rpcecho_IfHandle);
+
+	if (status) {
+		printf("RpcBindingFree returned %d\n", status);
+		exit(status);
+	}
+
+	exit(0);
+}

Samba/testprogs/win32/rpcecho/rpcecho.acf

@@ -0,0 +1,27 @@
+/* 
+   RPC echo ACF.
+
+   Copyright (C) Tim Potter 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+[
+	implicit_handle (handle_t rpcecho_IfHandle)
+]
+interface rpcecho
+{
+/*	[async] TestSleep(); */
+}

Samba/testprogs/win32/rpcecho/rpcecho.idl

@@ -0,0 +1,147 @@
+/* 
+   RPC echo IDL.
+
+   Copyright (C) Tim Potter 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __PIDL__
+#define unistr [string] wchar_t *
+#endif
+
+[
+uuid(60a15ec5-4de8-11d7-a637-005056a20182),
+version(1.0)
+]
+interface rpcecho
+{
+	// Add one to an integer
+	void AddOne(
+		[in] int in_data,
+		[out] int *out_data
+	);
+	// Echo an array of bytes back at the caller
+	void EchoData(
+		[in] int len,
+		[in] [size_is(len)] char in_data[],
+		[out] [size_is(len)] char out_data[]
+	);
+	// Sink data to the server
+	void SinkData(
+		[in] int len,
+		[in] [size_is(len)] char in_data[]
+	);
+	// Source data from server
+	void SourceData(
+		[in] int len,
+		[out] [size_is(len)] char out_data[]
+	);
+	const long myconstant = 42;
+
+	/* test strings */
+ 	void TestCall (
+		[in]   unistr *s1,
+		[out]  unistr *s2
+ 		);
+
+	/* test some alignment issues */
+	typedef struct {
+		char v;
+	} echo_info1;
+
+	typedef struct {
+		short v;
+	} echo_info2;
+
+	typedef struct {
+		long v;
+	} echo_info3;
+
+	typedef struct {
+		hyper v;
+	} echo_info4;
+
+	typedef struct {
+		char v1;
+		hyper v2;
+	} echo_info5;
+
+	typedef struct {
+		char v1;
+		echo_info1 info1;
+	} echo_info6;
+
+	typedef struct {
+		char v1;
+		echo_info4 info4;
+	} echo_info7;
+
+	typedef union {
+		[case(1)]  echo_info1 info1;
+		[case(2)]  echo_info2 info2;
+		[case(3)]  echo_info3 info3;
+		[case(4)]  echo_info4 info4;
+		[case(5)]  echo_info5 info5;
+		[case(6)]  echo_info6 info6;
+		[case(7)]  echo_info7 info7;
+	} echo_Info;
+
+	long TestCall2 (
+		[in]                     uint16 level,
+		[out,switch_is(level)]   echo_Info **info
+		);
+
+	long TestSleep(
+		[in] long seconds
+		);
+
+	typedef enum {
+		ECHO_ENUM1 = 1,
+		ECHO_ENUM2 = 2
+	} echo_Enum1;
+
+	typedef [v1_enum] enum {
+		ECHO_ENUM1_32 = 1,
+		ECHO_ENUM2_32 = 2
+	} echo_Enum1_32;
+
+	typedef struct {
+		echo_Enum1 e1;
+		echo_Enum1_32 e2;
+	} echo_Enum2;
+
+	typedef union {
+		[case(ECHO_ENUM1)] echo_Enum1 e1;
+		[case(ECHO_ENUM2)] echo_Enum2 e2;
+	} echo_Enum3;
+
+	void echo_TestEnum(
+		[in,out,ref] echo_Enum1 *foo1,
+		[in,out,ref] echo_Enum2 *foo2,
+		[in,out,ref,switch_is(*foo1)] echo_Enum3 *foo3
+		);
+
+	typedef struct {
+		long x;
+		[size_is(x)] short surrounding[*];
+	} echo_Surrounding;
+
+	void echo_TestSurrounding(
+		[in,out,ref] echo_Surrounding *data
+	);
+
+	short echo_TestDoublePointer([in] short ***data);
+}

Samba/testprogs/win32/rpcecho/server.c

@@ -0,0 +1,209 @@
+/* 
+   RPC echo server.
+
+   Copyright (C) Tim Potter 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#define _WIN32_WINNT 0x0500
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "rpcecho.h"
+
+#define RPC_MIN_CALLS 1
+#define RPC_MAX_CALLS 20
+#define RPC_ENDPOINT "\\pipe\\rpcecho"
+
+void AddOne(int in_data, __RPC_FAR int *out_data)
+{
+	printf("AddOne: got in_data = %d\n", in_data);
+	*out_data = in_data + 1;
+}
+
+void EchoData(int len, unsigned char __RPC_FAR in_data[],
+	unsigned char __RPC_FAR out_data[])
+{
+	printf("EchoData: got len = %d\n", len);
+	
+	memcpy(out_data, in_data, len);
+}
+
+void SinkData(int len, unsigned char __RPC_FAR in_data[  ])
+{
+	printf("SinkData: got len = %d\n", len);
+}
+
+void SourceData(int len, unsigned char __RPC_FAR out_data[  ])
+{
+	int i;
+
+	printf("SourceData: got len = %d\n", len);
+
+	for (i = 0; i < len; i++)
+		out_data[i] = i & 0xff;
+}
+
+void TestCall(wchar_t **s1, wchar_t **s2)
+{
+	if (*s1) {
+		printf("s1='%S'\n", *s1);
+	} else {
+		printf("s1=NULL\n");
+	}
+	*s2 = L"test string";
+}
+
+long TestCall2(short level, echo_Info **info)
+{
+	static echo_Info i;
+
+	printf("TestCall2 level %d\n", level);
+
+	*info = &i;
+
+	switch (level) {
+	case 1:
+		i.info1.v = 10;
+		break;
+	case 2:
+		i.info2.v = 20;
+		break;
+	case 3:
+		i.info3.v = 30;
+		break;
+	case 4:
+		i.info4.v = 40;
+		break;
+	case 5:
+		i.info5.v1 = 50;
+		i.info5.v2 = 51;
+		break;
+	case 6:
+		i.info6.v1 = 60;
+		i.info6.info1.v = 61;
+		break;
+	case 7:
+		i.info7.v1 = 70;
+		i.info7.info4.v = 71;
+		break;
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+#if 0
+void TestSleep(PRPC_ASYNC_STATE pAsync, long seconds)
+{
+	long ret;
+	printf("async Sleeping for %d seconds\n", seconds);
+	Sleep(1000 * seconds);
+	ret = seconds;
+	RpcAsyncCompleteCall(pAsync, &ret);
+}
+#else
+long TestSleep(long seconds)
+{
+	printf("non-async Sleeping for %d seconds\n", seconds);
+	Sleep(1000 * seconds);
+	return seconds;
+}
+#endif
+
+
+void echo_TestEnum(echo_Enum1 *foo1,
+		   echo_Enum2 *foo2,
+		   echo_Enum3 *foo3)
+{
+	foo2->e1 = ECHO_ENUM2;
+}
+
+void echo_TestSurrounding(echo_Surrounding *data)
+{
+	printf("Incoming array of size %d\n", data->x);
+	data->x *= 2;
+}
+
+short echo_TestDoublePointer(short ***data)
+{
+	if (!*data) {
+		printf("WARNING: *data == NULL\n");
+		return 0;
+	}
+	if (!**data) {
+		printf("WARNING: **data == NULL\n");
+		return 0;
+	}
+	printf("Incoming double pointer: %d\n", ***data);
+	return ***data;
+}
+
+void main(int argc, char **argv)
+{
+	RPC_STATUS status;
+	RPC_BINDING_VECTOR *pBindingVector;
+
+	if (argc != 1) {
+		printf("Usage: rpcechosrv\n");
+		exit(0);
+	}
+
+	status = RpcServerUseProtseqEp("ncacn_np", RPC_MAX_CALLS, "\\pipe\\rpcecho", NULL);
+	if (status) {
+		printf("Failed to register ncacn_np endpoint\n");
+		exit(status);
+	}
+
+	status = RpcServerUseProtseqEp("ncacn_ip_tcp", RPC_MAX_CALLS, "1234", NULL);
+	if (status) {
+		printf("Failed to register ncacn_ip_tcp endpoint\n");
+		exit(status);
+	}
+
+	status = RpcServerInqBindings(&pBindingVector);
+	if (status) {
+		printf("Failed RpcServerInqBindings\n");
+		exit(status);
+	}
+
+	status = RpcEpRegister(rpcecho_v1_0_s_ifspec, pBindingVector, NULL, "rpcecho server");
+	if (status) {
+		printf("Failed RpcEpRegister\n");
+		exit(status);
+	}
+
+	status = RpcServerRegisterIf(rpcecho_v1_0_s_ifspec, NULL, NULL);
+
+	if (status) {
+		printf("Failed to register interface\n");
+		exit(status);
+	}
+
+	status = RpcServerRegisterAuthInfo(NULL, RPC_C_AUTHN_WINNT, NULL, NULL);
+	if (status) {
+		printf("Failed to setup auth info\n");
+	}
+		
+	status = RpcServerListen(RPC_MIN_CALLS, RPC_MAX_CALLS, FALSE);
+
+	if (status) {
+		printf("RpcServerListen returned error %d\n", status);
+		exit(status);
+	}
+}
+

Samba/testprogs/win32/rpcecho/utils.c

@@ -0,0 +1,33 @@
+/* 
+   RPC echo utility functions.
+
+   Copyright (C) Tim Potter 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "rpcecho.h"
+
+/* MIDL allocate and free functions */
+
+void __RPC_FAR *__RPC_USER midl_user_allocate(size_t len)
+{
+		return(malloc(len));
+}
+
+void __RPC_USER midl_user_free(void __RPC_FAR *ptr)
+{
+	free(ptr);
+}

Samba/testprogs/win32/testmailslot/GNUmakefile

@@ -0,0 +1,15 @@
+INCLUDES=-I.
+CFLAGS=$(INCLUDES) 
+CC=i586-mingw32msvc-gcc
+
+all: testmailslot.exe
+
+clean:
+	rm -f *~ *.obj testmailslot.exe 
+
+.SUFFIXES: .obj .exe .c
+
+testmailslot.exe: testmailslot.c
+
+.c.exe: 
+	$(CC) $(CFLAGS) -o $@ $^ $(LIBS)

Samba/testprogs/win32/testmailslot/NMakefile

@@ -0,0 +1,10 @@
+INCLUDES=-I 
+CFLAGS=$(INCLUDES) -Zi -nologo
+
+all: testmailslot.exe
+
+clean:
+	del *~ *.obj testmailslot.exe 
+
+testmailslot.exe: testmailslot.obj 
+	$(CC) $(CFLAGS) -o testmailslot.exe testmailslot.obj $(LIBS)

Samba/testprogs/win32/testmailslot/testmailslot.c

@@ -0,0 +1,80 @@
+/*
+ * Very simple test application for mailslots
+ * (C) 2005 Jelmer Vernooij <jelmer@samba.org>
+ * Published to the public domain
+ */
+
+#include <windows.h>
+#include <stdio.h>
+
+int read_slot(const char *mailslotname)
+{
+	HANDLE h;
+	DWORD nr;
+	char data[30000];
+	DWORD nextsize, nummsg = 0;
+
+	if (strncmp(mailslotname, "\\\\.\\mailslot\\", 13) && strncmp(mailslotname, "\\\\*\\mailslot\\", 13)) {
+		printf("Must specify local mailslot name (starting with \\\\.\\mailslot\\)\n");
+		return 1;
+	}
+
+	h = CreateMailslot(mailslotname, 0, MAILSLOT_WAIT_FOREVER, NULL);
+
+	if (h == INVALID_HANDLE_VALUE) {
+		printf("Unable to create mailslot %s: %d\n", mailslotname, GetLastError());
+		return 1;
+	}
+
+	if (!ReadFile(h, data, sizeof(data)-1, &nr, NULL)) {
+		printf("Error reading: %d\n", GetLastError());
+		return 1;
+	}
+
+	data[nr] = '\0';
+
+	printf("%s\n", data);
+
+	CloseHandle(h);
+}
+
+int write_slot(const char *mailslotname)
+{
+	HANDLE h;
+	DWORD nw;
+	char data[30000];
+	h = CreateFile(mailslotname, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,  NULL);
+
+	if (h == INVALID_HANDLE_VALUE) {
+		printf("Unable to open file: %d\n", GetLastError());
+		return 1;
+	}
+
+	gets(data);
+
+	if (!WriteFile(h, data, strlen(data), &nw, NULL)) {
+		printf("Error writing file: %d\n", GetLastError());
+		return 1;
+	}
+
+	CloseHandle(h);	
+}
+
+int main(int argc, char **argv)
+{
+	if (argc < 3 || 
+			(strcmp(argv[1], "read") && strcmp(argv[1], "write"))) {
+		printf("Usage: %s read|write mailslot\n", argv[0]);
+		return 1;
+	}
+
+	if (!strcmp(argv[1], "read")) {
+		return read_slot(argv[2]);
+	}
+
+	if (!strcmp(argv[1], "write")) {
+		return write_slot(argv[2]);
+	}
+
+	return 0;
+}

Samba/testprogs/win32/wmi/echoprocessor.vbs

@@ -0,0 +1,10 @@
+For Each Host In WScript.Arguments
+	Set WMIservice = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & host & "\root\cimv2")
+
+	Set colsettings = WMIservice.ExecQuery("SELECT * FROM Win32_Processor")
+
+
+	For Each proc In colsettings
+		Wscript.Echo(host & ": " & proc.description)
+	Next
+Next