summaryrefslogtreecommitdiff
path: root/examples/libmsrpc/test
diff options
context:
space:
mode:
Diffstat (limited to 'examples/libmsrpc/test')
-rw-r--r--examples/libmsrpc/test/Makefile99
-rw-r--r--examples/libmsrpc/test/README8
-rw-r--r--examples/libmsrpc/test/lsa/ear.c261
-rw-r--r--examples/libmsrpc/test/lsa/lsaenum.c96
-rw-r--r--examples/libmsrpc/test/lsa/lsaenumprivs.c79
-rw-r--r--examples/libmsrpc/test/lsa/lsapol.c87
-rw-r--r--examples/libmsrpc/test/lsa/lsapriv.c113
-rw-r--r--examples/libmsrpc/test/lsa/lsaq.c245
-rw-r--r--examples/libmsrpc/test/lsa/lsatrust.c151
-rw-r--r--examples/libmsrpc/test/reg/regdelete.c102
-rw-r--r--examples/libmsrpc/test/reg/regkey.c76
-rw-r--r--examples/libmsrpc/test/reg/regkeycreate.c115
-rw-r--r--examples/libmsrpc/test/reg/regkeyenum.c99
-rw-r--r--examples/libmsrpc/test/reg/regopen.c66
-rw-r--r--examples/libmsrpc/test/reg/regopenkey.c69
-rw-r--r--examples/libmsrpc/test/reg/regqueryval.c79
-rw-r--r--examples/libmsrpc/test/reg/regsetval.c59
-rw-r--r--examples/libmsrpc/test/reg/regvalenum.c103
-rw-r--r--examples/libmsrpc/test/reg/security.c74
-rw-r--r--examples/libmsrpc/test/reg/shutdown.c68
-rw-r--r--examples/libmsrpc/test/sam/adduser.c92
-rw-r--r--examples/libmsrpc/test/sam/disable.c63
-rw-r--r--examples/libmsrpc/test/sam/dominfo.c55
-rw-r--r--examples/libmsrpc/test/sam/enable.c64
-rw-r--r--examples/libmsrpc/test/sam/samenum.c117
-rw-r--r--examples/libmsrpc/test/sam/samgroup.c480
-rw-r--r--examples/libmsrpc/test/sam/samlookup.c140
-rw-r--r--examples/libmsrpc/test/sam/samuser.c294
-rw-r--r--examples/libmsrpc/test/smbc_test/smbc.c87
-rw-r--r--examples/libmsrpc/test/svcctl/svc.c303
-rw-r--r--examples/libmsrpc/test/test_util.c408
-rw-r--r--examples/libmsrpc/test/test_util.h31
32 files changed, 4183 insertions, 0 deletions
diff --git a/examples/libmsrpc/test/Makefile b/examples/libmsrpc/test/Makefile
new file mode 100644
index 0000000000..95fa5effa5
--- /dev/null
+++ b/examples/libmsrpc/test/Makefile
@@ -0,0 +1,99 @@
+CC=gcc
+INCLUDES= -I`pwd` -I../../../source/ -I../../../source/include -I../../../source/ubiqx
+
+DEFS= -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+#CFLAGS= -O -D_SAMBA_BUILD_ -gstabs -Wall -Wshadow -Wstrict-prototypes -Wpointer-arith -Wcast-align -Wwrite-strings -DDEBUG_PASSWORD -DDEVELOPER -Wdeclaration-after-statement -g $(INCLUDES) $(DEFS) -fPIC
+
+CFLAGS= -g -Wall -ansi $(INCLUDES)
+
+LDFLAGS=-L. -L../../bin/
+LIBS=../../../source/bin/libmsrpc.so
+
+TESTS= lsapol lsaq lsaenum lsaenumprivs lsapriv ear \
+ regkey regopenkey regkeyenum regvalenum regsetval regqueryval regdelete security \
+ adduser samenum samlookup samgroup enable disable dominfo samuser \
+ svc \
+ smbc
+
+all: $(TESTS)
+
+lsapol: lsa/lsapol.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+lsapriv: lsa/lsapriv.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+lsaq: lsa/lsaq.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+lsaenum: lsa/lsaenum.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+lsaenumprivs: lsa/lsaenumprivs.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+lsaaddrights: lsa/lsaaddrights.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+ear: lsa/ear.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+regkey: reg/regkey.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+regopenkey: reg/regopenkey.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+regkeyenum: reg/regkeyenum.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+regkeycreate: reg/regkeycreate.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LIBS)
+
+regvalenum: reg/regvalenum.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+regsetval: reg/regsetval.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+regqueryval: reg/regqueryval.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+regdelete: reg/regdelete.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+security: reg/security.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+adduser: sam/adduser.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+samenum: sam/samenum.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+samlookup: sam/samlookup.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+samgroup: sam/samgroup.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+enable: sam/enable.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+disable: sam/disable.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+samuser: sam/samuser.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+dominfo: sam/dominfo.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+svc: svcctl/svc.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS)
+
+smbc: smbc_test/smbc.o test_util.o
+ $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< test_util.o $(LIBS) ../../../source/bin/libsmbclient.so
+
+clean:
+ rm -f $(TESTS) *.o lsa/*.o reg/*.o sam/*.o
diff --git a/examples/libmsrpc/test/README b/examples/libmsrpc/test/README
new file mode 100644
index 0000000000..9352905b5b
--- /dev/null
+++ b/examples/libmsrpc/test/README
@@ -0,0 +1,8 @@
+This code was written to test the different library functions. However, a simple example of almost every libmsrpc call can be found
+in this code.
+
+notes: most of the programs use a modified smbc_get_auth_data_fn which will not prompt for a user/domain/password so expect flaky results
+if you run the tests with just a server, ie: svc remote_machine
+
+
+If you get errors about the libmsrpc.so object, make sure your LD_LIBRARY_PATH points to /path/to/samba3/source/bin
diff --git a/examples/libmsrpc/test/lsa/ear.c b/examples/libmsrpc/test/lsa/ear.c
new file mode 100644
index 0000000000..8a8202543d
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/ear.c
@@ -0,0 +1,261 @@
+/* connects to an LSA, asks for a list of server names, prints out their sids, then looks up their names from the sids and prints them out again
+ * if you run as lsaq -p, then it will simulate a partial success for cac_GetNamesFromSids. It will try to lookup the server's local and domain sids
+ */
+
+
+#include "libmsrpc.h"
+#include "includes.h"
+
+void fill_conn_info(CacServerHandle *hnd) {
+ pstring domain;
+ pstring username;
+ pstring password;
+ pstring server;
+
+ fprintf(stdout, "Enter domain name: ");
+ fscanf(stdin, "%s", domain);
+
+ fprintf(stdout, "Enter username: ");
+ fscanf(stdin, "%s", username);
+
+ fprintf(stdout, "Enter password (no input masking): ");
+ fscanf(stdin, "%s", password);
+
+ fprintf(stdout, "Enter server (ip or name): ");
+ fscanf(stdin, "%s", server);
+
+ hnd->domain = SMB_STRDUP(domain);
+ hnd->username = SMB_STRDUP(username);
+ hnd->password = SMB_STRDUP(password);
+ hnd->server = SMB_STRDUP(server);
+}
+
+void get_server_names(TALLOC_CTX *mem_ctx, int *num_names, char ***names) {
+ int i = 0;
+ pstring tmp;
+
+ fprintf(stdout, "How many names do you want to lookup?: ");
+ fscanf(stdin, "%d", num_names);
+
+ *names = TALLOC_ARRAY(mem_ctx, char *, *num_names);
+ if(*names == NULL) {
+ fprintf(stderr, "No memory for allocation\n");
+ exit(-1);
+ }
+
+ for(i = 0; i < *num_names; i++) {
+ fprintf(stdout, "Enter name: ");
+ fscanf(stdin, "%s", tmp);
+ (*names)[i] = talloc_strdup(mem_ctx, tmp);
+ }
+}
+
+int main(int argc, char **argv) {
+ int i;
+ int result;
+ char **names;
+ int num_names;
+ int num_sids;
+ CacServerHandle *hnd = NULL;
+ POLICY_HND *lsa_pol = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ DOM_SID *sid_buf = NULL;
+
+ BOOL sim_partial = False;
+
+ if(argc > 1 && strcmp(argv[1], "-p") == 0)
+ sim_partial = True;
+
+ mem_ctx = talloc_init("lsaq");
+
+ hnd = cac_NewServerHandle(False);
+
+ fill_conn_info(hnd);
+
+ get_server_names(mem_ctx, &num_names, &names);
+
+ /*connect to the PDC and open a LSA handle*/
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error %s.\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ fprintf(stdout, "Connected to server: %s\n", hnd->server);
+
+ struct LsaOpenPolicy lop;
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ lop.in.security_qos = True;
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not get lsa policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ fprintf(stdout, "Opened Policy Handle\n");
+
+ /*just to make things neater*/
+ lsa_pol = lop.out.pol;
+
+ /*fetch the local sid and domain sid for the pdc*/
+
+ struct LsaFetchSid fsop;
+ ZERO_STRUCT(fsop);
+
+ fsop.in.pol = lsa_pol;
+ fsop.in.info_class = (CAC_LOCAL_INFO|CAC_DOMAIN_INFO);
+
+ fprintf(stdout, "fetching SID info for %s\n", hnd->server);
+
+ result = cac_LsaFetchSid(hnd, mem_ctx, &fsop);
+ if(!result) {
+ fprintf(stderr, "Could not get sid for server: %s\n. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+ exit(-1);
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "could not retrieve both domain and local information\n");
+ }
+
+
+ fprintf(stdout, "Fetched SID info for %s\n", hnd->server);
+ if(fsop.out.local_sid != NULL)
+ fprintf(stdout, " domain: %s. Local SID: %s\n", fsop.out.local_sid->domain, sid_string_static(&fsop.out.local_sid->sid));
+
+ if(fsop.out.domain_sid != NULL)
+ fprintf(stdout, " domain: %s, Domain SID: %s\n", fsop.out.domain_sid->domain, sid_string_static(&fsop.out.domain_sid->sid));
+
+ fprintf(stdout, "Looking up sids\n");
+
+
+ struct LsaGetSidsFromNames gsop;
+ ZERO_STRUCT(gsop);
+
+ gsop.in.pol = lsa_pol;
+ gsop.in.num_names = num_names;
+ gsop.in.names = names;
+
+ result = cac_LsaGetSidsFromNames(hnd, mem_ctx, &gsop);
+
+ if(!result) {
+ fprintf(stderr, "Could not lookup any sids!\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "Not all names could be looked up.\nThe following names were not found:\n");
+
+ for(i = 0; i < (num_names - gsop.out.num_found); i++) {
+ fprintf(stdout, " %s\n", gsop.out.unknown[i]);
+ }
+
+ fprintf(stdout, "\n");
+ }
+
+ /*buffer the sids so we can look them up back to names*/
+ num_sids = (sim_partial) ? gsop.out.num_found + 2: gsop.out.num_found;
+ sid_buf = TALLOC_ARRAY(mem_ctx, DOM_SID, num_sids);
+
+ fprintf(stdout, "%d names were resolved: \n", gsop.out.num_found);
+
+
+ i = 0;
+ while(i < gsop.out.num_found) {
+ fprintf(stdout, " Name: %s\n SID: %s\n\n", gsop.out.sids[i].name, sid_string_static(&gsop.out.sids[i].sid));
+
+ sid_buf[i] = gsop.out.sids[i].sid;
+
+ printf("Attempting to open account\n");
+
+ struct LsaOpenAccount loa;
+ ZERO_STRUCT(loa);
+
+ loa.in.pol = lsa_pol;
+ loa.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ loa.in.sid = &gsop.out.sids[i].sid;
+
+ if(!cac_LsaOpenAccount(hnd, mem_ctx, &loa)) {
+ fprintf(stderr, "Could not open account.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ printf("\nEnumerating privs:");
+ struct LsaEnumAccountRights earop;
+ ZERO_STRUCT(earop);
+
+ earop.in.pol = lsa_pol;
+
+ earop.in.sid = &gsop.out.sids[i].sid;
+
+ if(!cac_LsaEnumAccountRights(hnd, mem_ctx, &earop)) {
+ fprintf(stderr, "Could not enumerate account rights.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ int j;
+ printf( "Rights: ");
+ for(j = 0; j < earop.out.num_privs; j++) {
+ printf(" %s\n", earop.out.priv_names[j]);
+ }
+
+ printf("\n");
+
+
+ i++;
+ }
+
+ /*if we want a partial success to occur below, then add the server's SIDs to the end of the array*/
+ if(sim_partial) {
+ sid_buf[i] = fsop.out.local_sid->sid;
+ sid_buf[i+1] = fsop.out.domain_sid->sid;
+ }
+
+ fprintf(stdout, "Looking up Names from SIDs\n");
+
+ struct LsaGetNamesFromSids gnop;
+ ZERO_STRUCT(gnop);
+
+ gnop.in.pol = lsa_pol;
+ gnop.in.num_sids = num_sids;
+ gnop.in.sids = sid_buf;
+
+ result = cac_LsaGetNamesFromSids(hnd, mem_ctx, &gnop);
+
+ if(!result) {
+ fprintf(stderr, "Could not lookup any names!.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "\nNot all SIDs could be looked up.\n. The following SIDs were not found:\n");
+
+ for(i = 0; i < (num_sids - gnop.out.num_found); i++) {
+ fprintf(stdout, "SID: %s\n", sid_string_static(&gnop.out.unknown[i]));
+ }
+
+ fprintf(stdout, "\n");
+ }
+
+ fprintf(stdout, "%d SIDs were resolved: \n", gnop.out.num_found);
+ for(i = 0; i < gnop.out.num_found; i++) {
+ fprintf(stdout, " SID: %s\n Name: %s\n", sid_string_static(&gnop.out.sids[i].sid), gsop.out.sids[i].name);
+ }
+
+done:
+
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, lsa_pol)) {
+ fprintf(stderr, "Could not close LSA policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ fprintf(stdout, "Closed Policy handle.\n");
+ }
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/lsa/lsaenum.c b/examples/libmsrpc/test/lsa/lsaenum.c
new file mode 100644
index 0000000000..d4ad4f73aa
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsaenum.c
@@ -0,0 +1,96 @@
+/*enumerates SIDs*/
+
+#include "libmsrpc.h"
+#include "includes.h"
+
+int main(int argc, char **argv) {
+
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ POLICY_HND *pol = NULL;
+
+ int i;
+ int max_sids;
+
+ mem_ctx = talloc_init("lsaenum");
+
+ hnd = cac_NewServerHandle(True);
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("How many sids do you want to grab at a time? ");
+ fscanf(stdin, "%d", &max_sids);
+
+ struct LsaOpenPolicy lop;
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ lop.in.security_qos = True;
+
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not open policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ pol = lop.out.pol;
+
+
+ struct LsaEnumSids esop;
+ ZERO_STRUCT(esop);
+ esop.in.pol = pol;
+ /*grab a couple at a time to demonstrate multiple calls*/
+ esop.in.pref_max_sids = max_sids;
+
+ printf("Attempting to fetch SIDs %d at a time\n", esop.in.pref_max_sids);
+
+ while(cac_LsaEnumSids(hnd, mem_ctx, &esop)) {
+
+ printf("\nEnumerated %d sids: \n", esop.out.num_sids);
+ for(i = 0; i < esop.out.num_sids; i++) {
+ printf(" SID: %s\n", sid_string_static(&esop.out.sids[i]));
+ }
+
+ printf("Resolving names\n");
+
+ struct LsaGetNamesFromSids gnop;
+ ZERO_STRUCT(gnop);
+
+ gnop.in.pol = pol;
+ gnop.in.sids = esop.out.sids;
+ gnop.in.num_sids = esop.out.num_sids;
+
+ if(!cac_LsaGetNamesFromSids(hnd, mem_ctx, &gnop)) {
+ fprintf(stderr, "Could not resolve names.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("\nResolved %d names: \n", gnop.out.num_found);
+ for(i = 0; i < gnop.out.num_found; i++) {
+ printf(" SID: %s\n", sid_string_static(&gnop.out.sids[i].sid));
+ printf(" Name: %s\n", gnop.out.sids[i].name);
+ }
+
+ /*clean up a little*/
+ talloc_free(gnop.out.sids);
+ }
+
+done:
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, pol)) {
+ fprintf(stderr, "Could not close policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/lsa/lsaenumprivs.c b/examples/libmsrpc/test/lsa/lsaenumprivs.c
new file mode 100644
index 0000000000..8b5c9deca6
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsaenumprivs.c
@@ -0,0 +1,79 @@
+/*enumerates privileges*/
+
+#include "libmsrpc.h"
+#include "includes.h"
+
+#define MAX_STRING_LEN 50;
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+ POLICY_HND *lsa_pol = NULL;
+
+ int i;
+
+ mem_ctx = talloc_init("lsatrust");
+
+ hnd = cac_NewServerHandle(True);
+
+ printf("Server: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("Connecting to server....\n");
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s\n errno %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("Connected to server\n");
+
+ struct LsaOpenPolicy lop;
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ lop.in.security_qos = True;
+
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not open policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ lsa_pol = lop.out.pol;
+
+ printf("Enumerating Privileges\n");
+
+ struct LsaEnumPrivileges ep;
+ ZERO_STRUCT(ep);
+
+ ep.in.pol = lsa_pol;
+ ep.in.pref_max_privs = 50;
+
+ while(cac_LsaEnumPrivileges(hnd, mem_ctx, &ep)) {
+ printf(" Enumerated %d privileges\n", ep.out.num_privs);
+
+ for(i = 0; i < ep.out.num_privs; i++) {
+ printf("\"%s\"\n", ep.out.priv_names[i]);
+ }
+
+ printf("\n");
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Error while enumerating privileges.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+done:
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, lsa_pol)) {
+ fprintf(stderr, "Could not close policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/lsa/lsapol.c b/examples/libmsrpc/test/lsa/lsapol.c
new file mode 100644
index 0000000000..58407e4343
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsapol.c
@@ -0,0 +1,87 @@
+/* simple test code, opens and closes an LSA policy handle using libmsrpc, careful.. there's no password input masking*/
+
+#include "includes.h"
+#include "libmsrpc.h"
+
+void fill_conn_info(CacServerHandle *hnd) {
+ pstring domain;
+ pstring username;
+ pstring password;
+ pstring server;
+
+ fprintf(stdout, "Enter domain name: ");
+ fscanf(stdin, "%s", domain);
+
+ fprintf(stdout, "Enter username: ");
+ fscanf(stdin, "%s", username);
+
+ fprintf(stdout, "Enter password (no input masking): ");
+ fscanf(stdin, "%s", password);
+
+ fprintf(stdout, "Enter server (ip or name): ");
+ fscanf(stdin, "%s", server);
+
+ hnd->domain = SMB_STRDUP(domain);
+ hnd->username = SMB_STRDUP(username);
+ hnd->password = SMB_STRDUP(password);
+ hnd->server = SMB_STRDUP(server);
+}
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx;
+ struct LsaOpenPolicy op;
+
+ mem_ctx = talloc_init("lsapol");
+
+
+ hnd = cac_NewServerHandle(False);
+
+ /*this line is unnecesary*/
+ cac_SetAuthDataFn(hnd, cac_GetAuthDataFn);
+
+ hnd->debug = 0;
+
+ fill_conn_info(hnd);
+
+ /*connect to the server, its name/ip is already in the handle so just pass NULL*/
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server. \n Error %s\n errno(%d): %s\n", nt_errstr(hnd->status), errno, strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+ else {
+ fprintf(stdout, "Connected to server\n");
+ }
+
+ op.in.access = GENERIC_EXECUTE_ACCESS;
+ op.in.security_qos = True;
+
+ /*open the handle*/
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &op)) {
+ fprintf(stderr, "Could not open policy.\n Error: %s.errno: %d.\n", nt_errstr(hnd->status), errno);
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+ else {
+ fprintf(stdout, "Opened Policy handle\n");
+ }
+
+ /*close the handle*/
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, op.out.pol)) {
+ fprintf(stderr, "Could not close policy. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ fprintf(stdout, "Closed Policy handle\n");
+ }
+
+ /*cleanup*/
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ fprintf(stdout, "Free'd server handle\n");
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/lsa/lsapriv.c b/examples/libmsrpc/test/lsa/lsapriv.c
new file mode 100644
index 0000000000..80b3ea102f
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsapriv.c
@@ -0,0 +1,113 @@
+/*tries to set privileges for an account*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+#define BIGGEST_UINT32 0xffffffff
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ struct LsaOpenPolicy lop;
+ struct LsaEnumPrivileges ep;
+ struct LsaEnumAccountRights ar;
+ struct LsaAddPrivileges ap;
+
+ fstring tmp;
+
+ uint32 i = 0;
+
+ mem_ctx = talloc_init("lsapriv");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not open LSA policy. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ /*first enumerate possible privileges*/
+ ZERO_STRUCT(ep);
+
+ ep.in.pol = lop.out.pol;
+ ep.in.pref_max_privs = BIGGEST_UINT32;
+
+ printf("Enumerating supported privileges:\n");
+ while(cac_LsaEnumPrivileges(hnd, mem_ctx, &ep)) {
+ for(i = 0; i < ep.out.num_privs; i++) {
+ printf("\t%s\n", ep.out.priv_names[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Could not enumerate privileges. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Enter account name: ");
+ cactest_readline(stdin, tmp);
+
+ ZERO_STRUCT(ar);
+
+ ar.in.pol = lop.out.pol;
+ ar.in.name = talloc_strdup(mem_ctx, tmp);
+
+ printf("Enumerating privileges for %s:\n", ar.in.name);
+ if(!cac_LsaEnumAccountRights(hnd, mem_ctx, &ar)) {
+ fprintf(stderr, "Could not enumerate privileges. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Enumerated %d privileges:\n", ar.out.num_privs);
+
+ for(i = 0; i < ar.out.num_privs; i++)
+ printf("\t%s\n", ar.out.priv_names[i]);
+
+ ZERO_STRUCT(ap);
+
+ ap.in.pol = lop.out.pol;
+ ap.in.name = ar.in.name;
+
+ printf("How many privileges will you set: ");
+ scanf("%d", &ap.in.num_privs);
+
+ ap.in.priv_names = talloc_array(mem_ctx, char *, ap.in.num_privs);
+ if(!ap.in.priv_names) {
+ fprintf(stderr, "No memory\n");
+ goto done;
+ }
+
+ for(i = 0; i < ap.in.num_privs; i++) {
+ printf("Enter priv %d: ", i);
+ cactest_readline(stdin, tmp);
+
+ ap.in.priv_names[i] = talloc_strdup(mem_ctx, tmp);
+ }
+
+ if(!cac_LsaSetPrivileges(hnd, mem_ctx, &ap)) {
+ fprintf(stderr, "Could not set privileges. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+done:
+ talloc_destroy(mem_ctx);
+ cac_FreeHandle(hnd);
+
+ return 0;
+
+}
+
diff --git a/examples/libmsrpc/test/lsa/lsaq.c b/examples/libmsrpc/test/lsa/lsaq.c
new file mode 100644
index 0000000000..54c1849bfd
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsaq.c
@@ -0,0 +1,245 @@
+/* connects to an LSA, asks for a list of server names, prints out their sids, then looks up their names from the sids and prints them out again
+ * if you run as lsaq -p, then it will simulate a partial success for cac_GetNamesFromSids. It will try to lookup the server's local and domain sids
+ */
+
+
+#include "libmsrpc.h"
+#include "includes.h"
+
+void fill_conn_info(CacServerHandle *hnd) {
+ pstring domain;
+ pstring username;
+ pstring password;
+ pstring server;
+
+ fprintf(stdout, "Enter domain name: ");
+ fscanf(stdin, "%s", domain);
+
+ fprintf(stdout, "Enter username: ");
+ fscanf(stdin, "%s", username);
+
+ fprintf(stdout, "Enter password (no input masking): ");
+ fscanf(stdin, "%s", password);
+
+ fprintf(stdout, "Enter server (ip or name): ");
+ fscanf(stdin, "%s", server);
+
+ hnd->domain = SMB_STRDUP(domain);
+ hnd->username = SMB_STRDUP(username);
+ hnd->password = SMB_STRDUP(password);
+ hnd->server = SMB_STRDUP(server);
+}
+
+void get_server_names(TALLOC_CTX *mem_ctx, int *num_names, char ***names) {
+ int i = 0;
+ pstring tmp;
+
+ fprintf(stdout, "How many names do you want to lookup?: ");
+ fscanf(stdin, "%d", num_names);
+
+ *names = TALLOC_ARRAY(mem_ctx, char *, *num_names);
+ if(*names == NULL) {
+ fprintf(stderr, "No memory for allocation\n");
+ exit(-1);
+ }
+
+ for(i = 0; i < *num_names; i++) {
+ fprintf(stdout, "Enter name: ");
+ fscanf(stdin, "%s", tmp);
+ (*names)[i] = talloc_strdup(mem_ctx, tmp);
+ }
+}
+
+int main(int argc, char **argv) {
+ int i;
+ int result;
+ char **names;
+ int num_names;
+ int num_sids;
+ CacServerHandle *hnd = NULL;
+ POLICY_HND *lsa_pol = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ DOM_SID *sid_buf = NULL;
+
+ BOOL sim_partial = False;
+
+ if(argc > 1 && strcmp(argv[1], "-p") == 0)
+ sim_partial = True;
+
+ mem_ctx = talloc_init("lsaq");
+
+ hnd = cac_NewServerHandle(False);
+
+ fill_conn_info(hnd);
+
+ get_server_names(mem_ctx, &num_names, &names);
+
+ /*connect to the PDC and open a LSA handle*/
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error %s.\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ fprintf(stdout, "Connected to server: %s\n", hnd->server);
+
+ struct LsaOpenPolicy lop;
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ lop.in.security_qos = True;
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not get lsa policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ fprintf(stdout, "Opened Policy Handle\n");
+
+ /*just to make things neater*/
+ lsa_pol = lop.out.pol;
+
+ /*fetch the local sid and domain sid for the pdc*/
+
+ struct LsaFetchSid fsop;
+ ZERO_STRUCT(fsop);
+
+ fsop.in.pol = lsa_pol;
+ fsop.in.info_class = (CAC_LOCAL_INFO|CAC_DOMAIN_INFO);
+
+ fprintf(stdout, "fetching SID info for %s\n", hnd->server);
+
+ result = cac_LsaFetchSid(hnd, mem_ctx, &fsop);
+ if(!result) {
+ fprintf(stderr, "Could not get sid for server: %s\n. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+ exit(-1);
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "could not retrieve both domain and local information\n");
+ }
+
+
+ fprintf(stdout, "Fetched SID info for %s\n", hnd->server);
+ if(fsop.out.local_sid != NULL)
+ fprintf(stdout, " domain: %s. Local SID: %s\n", fsop.out.local_sid->domain, sid_string_static(&fsop.out.local_sid->sid));
+
+ if(fsop.out.domain_sid != NULL)
+ fprintf(stdout, " domain: %s, Domain SID: %s\n", fsop.out.domain_sid->domain, sid_string_static(&fsop.out.domain_sid->sid));
+
+ fprintf(stdout, "\nAttempting to query info policy\n");
+
+ struct LsaQueryInfoPolicy qop;
+ ZERO_STRUCT(qop);
+
+ qop.in.pol = lsa_pol;
+
+ if(!cac_LsaQueryInfoPolicy(hnd, mem_ctx, &qop)) {
+ fprintf(stderr, "Could not query information policy!.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ fprintf(stdout, "Query result: \n");
+ fprintf(stdout, " domain name: %s\n", qop.out.domain_name);
+ fprintf(stdout, " dns name: %s\n", qop.out.dns_name);
+ fprintf(stdout, " forest name: %s\n", qop.out.forest_name);
+ fprintf(stdout, " domain guid: %s\n", smb_uuid_string_static(*qop.out.domain_guid));
+ fprintf(stdout, " domain sid: %s\n", sid_string_static(qop.out.domain_sid));
+
+ fprintf(stdout, "\nLooking up sids\n");
+
+ struct LsaGetSidsFromNames gsop;
+ ZERO_STRUCT(gsop);
+
+ gsop.in.pol = lsa_pol;
+ gsop.in.num_names = num_names;
+ gsop.in.names = names;
+
+ result = cac_LsaGetSidsFromNames(hnd, mem_ctx, &gsop);
+
+ if(!result) {
+ fprintf(stderr, "Could not lookup any sids!\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "Not all names could be looked up.\nThe following names were not found:\n");
+
+ for(i = 0; i < (num_names - gsop.out.num_found); i++) {
+ fprintf(stdout, " %s\n", gsop.out.unknown[i]);
+ }
+
+ fprintf(stdout, "\n");
+ }
+
+ /*buffer the sids so we can look them up back to names*/
+ num_sids = (sim_partial) ? gsop.out.num_found + 2: gsop.out.num_found;
+ sid_buf = TALLOC_ARRAY(mem_ctx, DOM_SID, num_sids);
+
+ fprintf(stdout, "%d names were resolved: \n", gsop.out.num_found);
+
+
+ i = 0;
+ while(i < gsop.out.num_found) {
+ fprintf(stdout, " Name: %s\n SID: %s\n\n", gsop.out.sids[i].name, sid_string_static(&gsop.out.sids[i].sid));
+
+ sid_buf[i] = gsop.out.sids[i].sid;
+
+ i++;
+ }
+
+ /*if we want a partial success to occur below, then add the server's SIDs to the end of the array*/
+ if(sim_partial) {
+ sid_buf[i] = fsop.out.local_sid->sid;
+ sid_buf[i+1] = fsop.out.domain_sid->sid;
+ }
+
+ fprintf(stdout, "Looking up Names from SIDs\n");
+
+ struct LsaGetNamesFromSids gnop;
+ ZERO_STRUCT(gnop);
+
+ gnop.in.pol = lsa_pol;
+ gnop.in.num_sids = num_sids;
+ gnop.in.sids = sid_buf;
+
+ result = cac_LsaGetNamesFromSids(hnd, mem_ctx, &gnop);
+
+ if(!result) {
+ fprintf(stderr, "Could not lookup any names!.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(result == CAC_PARTIAL_SUCCESS) {
+ fprintf(stdout, "\nNot all SIDs could be looked up.\n. The following SIDs were not found:\n");
+
+ for(i = 0; i < (num_sids - gnop.out.num_found); i++) {
+ fprintf(stdout, "SID: %s\n", sid_string_static(&gnop.out.unknown[i]));
+ }
+
+ fprintf(stdout, "\n");
+ }
+
+ fprintf(stdout, "%d SIDs were resolved: \n", gnop.out.num_found);
+ for(i = 0; i < gnop.out.num_found; i++) {
+ fprintf(stdout, " SID: %s\n Name: %s\n", sid_string_static(&gnop.out.sids[i].sid), gsop.out.sids[i].name);
+ }
+
+done:
+
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, lsa_pol)) {
+ fprintf(stderr, "Could not close LSA policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ fprintf(stdout, "Closed Policy handle.\n");
+ }
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/lsa/lsatrust.c b/examples/libmsrpc/test/lsa/lsatrust.c
new file mode 100644
index 0000000000..6ad293f832
--- /dev/null
+++ b/examples/libmsrpc/test/lsa/lsatrust.c
@@ -0,0 +1,151 @@
+/*queries trusted domain information*/
+
+#include "libmsrpc.h"
+#include "includes.h"
+
+#define MAX_STRING_LEN 50;
+
+void print_info(LSA_TRUSTED_DOMAIN_INFO *info) {
+ switch(info->info_class) {
+ case CAC_INFO_TRUSTED_DOMAIN_FULL_INFO:
+ case CAC_INFO_TRUSTED_DOMAIN_INFO_ALL:
+ printf(" Domain Name: %s\n", unistr2_static(&info->info_ex.domain_name.unistring));
+ printf(" Netbios Name: %s\n", unistr2_static(&info->info_ex.netbios_name.unistring));
+ printf(" Domain Sid: %s\n", sid_string_static(&info->info_ex.sid.sid));
+ printf(" Trust direction: %d\n", info->info_ex.trust_direction);
+ printf(" Trust Type: %d\n", info->info_ex.trust_type);
+ printf(" Trust attr: %d\n", info->info_ex.trust_attributes);
+ printf(" Posix Offset: %d\n", info->posix_offset.posix_offset);
+ break;
+ }
+}
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+ POLICY_HND *lsa_pol = NULL;
+
+ int i;
+
+ mem_ctx = talloc_init("lsatrust");
+
+ hnd = cac_NewServerHandle(False);
+
+ /*malloc some memory so get_auth_data_fn can work*/
+ hnd->username = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->domain = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->netbios_name = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->password = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+
+ hnd->server = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+
+
+ printf("Server: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("Connecting to server....\n");
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s\n errno %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("Connected to server\n");
+
+ struct LsaOpenPolicy lop;
+ ZERO_STRUCT(lop);
+
+ lop.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+ lop.in.security_qos = True;
+
+
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop)) {
+ fprintf(stderr, "Could not open policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ lsa_pol = lop.out.pol;
+
+ printf("Enumerating Trusted Domains\n");
+
+ struct LsaEnumTrustedDomains etd;
+ ZERO_STRUCT(etd);
+
+ etd.in.pol = lsa_pol;
+
+ while(cac_LsaEnumTrustedDomains(hnd, mem_ctx, &etd)) {
+ printf(" Enumerated %d domains\n", etd.out.num_domains);
+
+ for(i = 0; i < etd.out.num_domains; i++) {
+ printf(" Name: %s\n", etd.out.domain_names[i]);
+ printf(" SID: %s\n", sid_string_static(&etd.out.domain_sids[i]));
+
+ printf("\n Attempting to open domain...\n");
+
+ struct LsaOpenTrustedDomain otd;
+ ZERO_STRUCT(otd);
+
+ otd.in.pol = lsa_pol;
+ otd.in.domain_sid = &etd.out.domain_sids[i];
+ otd.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+
+ /*try to query trusted domain info by name*/
+ struct LsaQueryTrustedDomainInfo qtd;
+ ZERO_STRUCT(qtd);
+
+ qtd.in.pol = lsa_pol;
+ qtd.in.domain_name = etd.out.domain_names[i];
+
+
+ int j;
+ for(j = 0; j < 100; j++ ) {
+ qtd.in.info_class = j;
+
+ printf(" Querying trustdom by name\n");
+ if(!cac_LsaQueryTrustedDomainInfo(hnd, mem_ctx, &qtd)) {
+ fprintf(stderr, " could not query trusted domain info.\n Error %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf(" info_class %d succeeded\n", j);
+ printf(" Query result:\n");
+ printf(" size %d\n", sizeof(*qtd.out.info));
+ }
+
+ /*try to query trusted domain info by SID*/
+ printf(" Querying trustdom by sid\n");
+ qtd.in.domain_sid = &etd.out.domain_sids[i];
+ if(!cac_LsaQueryTrustedDomainInfo(hnd, mem_ctx, &qtd)) {
+ fprintf(stderr, " could not query trusted domain info.\n Error %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf(" Query result:\n");
+/* print_info(qtd.out.info);*/
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, " Could not enum sids.\n Error: %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+ }
+
+ printf("\n");
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Error while enumerating trusted domains.\n Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+done:
+ if(!cac_LsaClosePolicy(hnd, mem_ctx, lsa_pol)) {
+ fprintf(stderr, "Could not close policy handle.\n Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/reg/regdelete.c b/examples/libmsrpc/test/reg/regdelete.c
new file mode 100644
index 0000000000..50b08ba468
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regdelete.c
@@ -0,0 +1,102 @@
+/*tests deleting a key or value*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring tmp;
+ char input = 'v';
+
+ mem_ctx = talloc_init("regdelete");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ printf("enter key to open: \n");
+ cactest_readline(stdin, tmp);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.name = talloc_strdup(mem_ctx, tmp);
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s. Error %s\n", rok.in.name, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ printf("getting version (just for testing\n");
+
+ struct RegGetVersion rgv;
+ ZERO_STRUCT(rgv);
+
+ rgv.in.key = rok.out.key;
+
+ if(!cac_RegGetVersion(hnd, mem_ctx, &rgv))
+ fprintf(stderr, "Could not get version. Error: %s\n", nt_errstr(hnd->status));
+ else
+ printf("Version: %d\n", rgv.out.version);
+
+
+ while(input == 'v' || input == 'k') {
+ printf("Delete [v]alue [k]ey or [q]uit: ");
+ scanf("%c", &input);
+
+ switch(input) {
+ case 'v':
+ printf("Value to delete: ");
+ cactest_readline(stdin, tmp);
+
+ struct RegDeleteValue rdv;
+ ZERO_STRUCT(rdv);
+
+ rdv.in.parent_key = rok.out.key;
+ rdv.in.name = talloc_strdup(mem_ctx, tmp);
+
+ if(!cac_RegDeleteValue(hnd, mem_ctx, &rdv))
+ fprintf(stderr, "Could not delete value %s. Error: %s\n", rdv.in.name, nt_errstr(hnd->status));
+
+ break;
+ case 'k':
+ printf("Key to delete: ");
+ cactest_readline(stdin, tmp);
+
+ struct RegDeleteKey rdk;
+ ZERO_STRUCT(rdk);
+
+ rdk.in.parent_key = rok.out.key;
+ rdk.in.name = talloc_strdup(mem_ctx, tmp);
+
+ printf("delete recursively? [y/n]: ");
+ cactest_readline(stdin, tmp);
+
+ rdk.in.recursive = (tmp[0] == 'y') ? True : False;
+
+ if(!cac_RegDeleteKey(hnd, mem_ctx, &rdk))
+ fprintf(stderr, "Could not delete key %s. Error %s\n", rdk.in.name, nt_errstr(hnd->status));
+
+ break;
+ }
+ }
+ cac_RegClose(hnd, mem_ctx, rok.out.key);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
+
diff --git a/examples/libmsrpc/test/reg/regkey.c b/examples/libmsrpc/test/reg/regkey.c
new file mode 100644
index 0000000000..a90d06c6ef
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regkey.c
@@ -0,0 +1,76 @@
+/*opens and closes a key*/
+
+#include "libmsrpc.h"
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring key;
+
+ mem_ctx = talloc_init("regkey");
+
+ hnd = cac_NewServerHandle(False);
+
+ /*allocate some memory so get_auth_data_fn can do it's magic*/
+ hnd->username = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->domain = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->netbios_name = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+ hnd->password = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+
+ hnd->server = SMB_MALLOC_ARRAY(char, sizeof(fstring));
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ struct RegConnect rc;
+ ZERO_STRUCT(rc);
+
+ rc.in.access = REG_KEY_ALL;
+ rc.in.root = HKEY_LOCAL_MACHINE;
+
+ if(!cac_RegConnect(hnd, mem_ctx, &rc)) {
+ fprintf(stderr, " Could not connect to registry. %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("trying to open key %s...\n", key);
+
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = rc.out.key;
+ rok.in.name = key;
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+
+ if(!cac_RegClose(hnd, mem_ctx, rc.out.key)) {
+ fprintf(stderr, " Could not close handle. %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regkeycreate.c b/examples/libmsrpc/test/reg/regkeycreate.c
new file mode 100644
index 0000000000..50764f1682
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regkeycreate.c
@@ -0,0 +1,115 @@
+/*tests creating a registry key*/
+
+#include "libmsrpc.h"
+
+#define MAX_KEYS_PER_ENUM 3
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring key_name;
+
+ fstring key_to_create;
+
+ mem_ctx = talloc_init("regcreatekey");
+
+ hnd = cac_NewServerHandle(True);
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key_name);
+
+ printf("Enter key to create: ");
+ fscanf(stdin, "%s", key_to_create);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("trying to open key %s...\n", key_name);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = NULL;
+ rok.in.name = key_name;
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Creating key %s...\n", key_to_create);
+
+ struct RegCreateKey rck;
+ ZERO_STRUCT(rck);
+
+ rck.in.parent_key = rok.out.key;
+ rck.in.key_name = talloc_strdup(mem_ctx, key_to_create);
+ rck.in.class_name = talloc_strdup(mem_ctx, "");
+ rck.in.access = REG_KEY_ALL;
+
+ if(!cac_RegCreateKey(hnd, mem_ctx, &rck)) {
+ fprintf(stderr, "Could not create key. Error %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ if(!cac_RegClose(hnd, mem_ctx, rck.out.key)) {
+ fprintf(stderr, "Could not close key. Error %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ /**enumerate all the subkeys*/
+ printf("Enumerating all subkeys:\n");
+
+ struct RegEnumKeys ek;
+ ZERO_STRUCT(ek);
+
+ ek.in.key = rok.out.key;
+ ek.in.max_keys = 50;
+
+ while(cac_RegEnumKeys(hnd, mem_ctx, &ek)) {
+ int j;
+
+ for(j = 0; j < ek.out.num_keys; j++) {
+ printf(" Key name: %s\n", ek.out.key_names[j]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Could not enumerate keys: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("deleting key %s\n", key_to_create);
+
+ struct RegDeleteKey rdk;
+ ZERO_STRUCT(rdk);
+
+ rdk.in.parent_key = rok.out.key;
+ rdk.in.name = key_to_create;
+
+ if(!cac_RegDeleteKey(hnd, mem_ctx, &rdk)) {
+ fprintf(stderr, "Could not delete key. Error %s\n", nt_errstr(hnd->status));
+ }
+
+ printf("closing key %s...\n", key_name);
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regkeyenum.c b/examples/libmsrpc/test/reg/regkeyenum.c
new file mode 100644
index 0000000000..f140d95723
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regkeyenum.c
@@ -0,0 +1,99 @@
+/*tests enumerating keys or values*/
+
+#include "libmsrpc.h"
+
+#define MAX_KEYS_PER_ENUM 3
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ int num_keys;
+
+ int max_enum;
+
+ int i;
+
+ fstring *key_names;
+
+ mem_ctx = talloc_init("regkeyenum");
+
+ hnd = cac_NewServerHandle(True);
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("How many keys do you want to open?: ");
+ fscanf(stdin, "%d", &num_keys);
+
+ printf("How many keys per enum?: ");
+ fscanf(stdin, "%d", &max_enum);
+
+ key_names = TALLOC_ARRAY(mem_ctx, fstring , num_keys);
+ if(!key_names) {
+ fprintf(stderr, "No memory\n");
+ exit(-1);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key_names[i]);
+ }
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("trying to open key %s...\n", key_names[i]);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = NULL;
+ rok.in.name = key_names[i];
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ continue;
+ }
+
+ /**enumerate all the subkeys*/
+ printf("Enumerating all subkeys:\n");
+
+ struct RegEnumKeys ek;
+ ZERO_STRUCT(ek);
+
+ ek.in.key = rok.out.key;
+ ek.in.max_keys = max_enum;
+
+ while(cac_RegEnumKeys(hnd, mem_ctx, &ek)) {
+ int j;
+
+ for(j = 0; j < ek.out.num_keys; j++) {
+ printf(" Key name: %s\n", ek.out.key_names[j]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Could not enumerate keys: %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf("closing key %s...\n", key_names[i]);
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+ }
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regopen.c b/examples/libmsrpc/test/reg/regopen.c
new file mode 100644
index 0000000000..fedc52e40d
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regopen.c
@@ -0,0 +1,66 @@
+/*opens and closes a registry handle*/
+
+#include "libmsrpc.h"
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ POLICY_HND **keys = NULL;
+
+ char roots[4][50] = { {CAC_HKCR}, {CAC_HKLM}, {CAC_HKU}, {CAC_HKPD} };
+
+ int i;
+
+
+ mem_ctx = talloc_init("regopen");
+
+ hnd = cac_NewServerHandle(True);
+
+ keys = TALLOC_ARRAY(mem_ctx, POLICY_HND *, 4);
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ struct RegConnect rc;
+ ZERO_STRUCT(rc);
+
+ rc.in.access = SEC_RIGHT_MAXIMUM_ALLOWED;
+
+ for(i = 0; i < 4; i++) {
+ printf("opening: %s\n", roots[i]);
+
+ rc.in.root = roots[i];
+
+ if(!cac_RegConnect(hnd, mem_ctx, &rc)) {
+ fprintf(stderr, " Could not connect to registry. %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ keys[i] = rc.out.key;
+ }
+
+ for(i = 3; i >= 0; i--) {
+ if(keys[i] == NULL)
+ continue;
+
+ printf("closing: %s\n", roots[i]);
+
+ if(!cac_RegClose(hnd, mem_ctx, keys[i])) {
+ fprintf(stderr, " Could not close handle. %s\n", nt_errstr(hnd->status));
+ }
+ }
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regopenkey.c b/examples/libmsrpc/test/reg/regopenkey.c
new file mode 100644
index 0000000000..732da17ccf
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regopenkey.c
@@ -0,0 +1,69 @@
+/*tests cac_RegOpenKey()*/
+
+#include "libmsrpc.h"
+
+int main() {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ int num_keys;
+ int i;
+
+ fstring *key_names;
+
+ mem_ctx = talloc_init("regopenkey");
+
+ hnd = cac_NewServerHandle(True);
+
+ printf("Enter server to connect to: ");
+ fscanf(stdin, "%s", hnd->server);
+
+ printf("How many keys do you want to open?: ");
+ fscanf(stdin, "%d", &num_keys);
+
+ key_names = TALLOC_ARRAY(mem_ctx, fstring , num_keys);
+ if(!key_names) {
+ fprintf(stderr, "No memory\n");
+ exit(-1);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key_names[i]);
+ }
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("trying to open key %s...\n", key_names[i]);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = NULL;
+ rok.in.name = key_names[i];
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf("closing key %s...\n", key_names[i]);
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+ }
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regqueryval.c b/examples/libmsrpc/test/reg/regqueryval.c
new file mode 100644
index 0000000000..9989651898
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regqueryval.c
@@ -0,0 +1,79 @@
+/*tests cac_RegQueryValue()*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+#define MAX_KEYS_PER_ENUM 3
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring key_name;
+
+ fstring val_name;
+
+ mem_ctx = talloc_init("regqueryval");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key_name);
+
+ printf("Enter value to query: ");
+ fscanf(stdin, "%s", val_name);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("trying to open key %s...\n", key_name);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = NULL;
+ rok.in.name = key_name;
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ goto done;
+ }
+
+ struct RegQueryValue rqv;
+ ZERO_STRUCT(rqv);
+
+ rqv.in.key = rok.out.key;
+ rqv.in.val_name = talloc_strdup(mem_ctx, val_name);
+
+ printf("querying value %s...\n", rqv.in.val_name);
+ if(!cac_RegQueryValue(hnd, mem_ctx, &rqv)) {
+ fprintf(stderr, "Could not query value. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Queried value %s\n", rqv.in.val_name);
+ print_value(rqv.out.type, rqv.out.data);
+ }
+
+
+ printf("closing key %s...\n", key_name);
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/regsetval.c b/examples/libmsrpc/test/reg/regsetval.c
new file mode 100644
index 0000000000..e7327910c2
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regsetval.c
@@ -0,0 +1,59 @@
+/*tests cac_RegSetVal()*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring tmp;
+
+ mem_ctx = talloc_init("regsetval");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ printf("enter key to open: \n");
+ scanf("%s", tmp);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.name = talloc_strdup(mem_ctx, tmp);
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s. Error %s\n", rok.in.name, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct RegSetValue rsv;
+ ZERO_STRUCT(rsv);
+
+ rsv.in.key = rok.out.key;
+
+ cactest_reg_input_val(mem_ctx, &rsv.in.type, &rsv.in.val_name, &rsv.in.value);
+
+ if(!cac_RegSetValue(hnd, mem_ctx, &rsv)) {
+ fprintf(stderr, "Could not set value. Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ cac_RegClose(hnd, mem_ctx, rok.out.key);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
+
diff --git a/examples/libmsrpc/test/reg/regvalenum.c b/examples/libmsrpc/test/reg/regvalenum.c
new file mode 100644
index 0000000000..9778f4e2b3
--- /dev/null
+++ b/examples/libmsrpc/test/reg/regvalenum.c
@@ -0,0 +1,103 @@
+/*tests enumerating registry values*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+#define MAX_KEYS_PER_ENUM 3
+
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ int num_keys;
+
+ int max_enum;
+
+ fstring *key_names;
+
+ int i;
+
+ mem_ctx = talloc_init("regvalenum");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server.\n Error: %s.\n errno: %s\n", nt_errstr(hnd->status), strerror(errno));
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+ printf("How many keys do you want to open?: ");
+ fscanf(stdin, "%d", &num_keys);
+
+ printf("How many values per enum?: ");
+ fscanf(stdin, "%d", &max_enum);
+
+ key_names = TALLOC_ARRAY(mem_ctx, fstring , num_keys);
+ if(!key_names) {
+ fprintf(stderr, "No memory\n");
+ exit(-1);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("Enter key to open: ");
+ fscanf(stdin, "%s", key_names[i]);
+ }
+
+ for(i = 0; i < num_keys; i++) {
+ printf("trying to open key %s...\n", key_names[i]);
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ rok.in.parent_key = NULL;
+ rok.in.name = key_names[i];
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s\n Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ continue;
+ }
+
+ /**enumerate all the subkeys*/
+ printf("Enumerating all values:\n");
+
+ struct RegEnumValues rev;
+ ZERO_STRUCT(rev);
+
+ rev.in.key = rok.out.key;
+ rev.in.max_values = max_enum;
+
+ while(cac_RegEnumValues(hnd, mem_ctx, &rev)) {
+ int j;
+
+ for(j = 0; j < rev.out.num_values; j++) {
+ printf(" Value name: %s\n", rev.out.value_names[j]);
+ print_value(rev.out.types[j], rev.out.values[j]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ fprintf(stderr, "Could not enumerate values: %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf("closing key %s...\n", key_names[i]);
+
+ if(!cac_RegClose(hnd, mem_ctx, rok.out.key)) {
+ fprintf(stderr, "Could not close handle %s\n", nt_errstr(hnd->status));
+ }
+ }
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+
+}
diff --git a/examples/libmsrpc/test/reg/security.c b/examples/libmsrpc/test/reg/security.c
new file mode 100644
index 0000000000..6808f8c1f3
--- /dev/null
+++ b/examples/libmsrpc/test/reg/security.c
@@ -0,0 +1,74 @@
+/*tests cac_RegSetKeySecurity()*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring tmp;
+
+ mem_ctx = talloc_init("regsetval");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct RegOpenKey rok;
+ ZERO_STRUCT(rok);
+
+ printf("enter key to query: ");
+ cactest_readline(stdin, tmp);
+
+ rok.in.name = talloc_strdup(mem_ctx, tmp);
+ rok.in.access = REG_KEY_ALL;
+
+ if(!cac_RegOpenKey(hnd, mem_ctx, &rok)) {
+ fprintf(stderr, "Could not open key %s. Error %s\n", rok.in.name, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct RegGetKeySecurity rks;
+ ZERO_STRUCT(rks);
+
+ rks.in.key = rok.out.key;
+ rks.in.info_type = ALL_SECURITY_INFORMATION;
+
+ if(!cac_RegGetKeySecurity(hnd, mem_ctx, &rks)) {
+ fprintf(stderr, "Could not query security for %s. Error: %s\n", rok.in.name, nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("resetting key security...\n");
+
+ struct RegSetKeySecurity rss;
+ ZERO_STRUCT(rss);
+
+ rss.in.key = rok.out.key;
+ rss.in.info_type = ALL_SECURITY_INFORMATION;
+ rss.in.size = rks.out.size;
+ rss.in.descriptor = rks.out.descriptor;
+
+ if(!cac_RegSetKeySecurity(hnd, mem_ctx, &rss)) {
+ fprintf(stderr, "Could not set security. Error %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_RegClose(hnd, mem_ctx, rok.out.key);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
+
diff --git a/examples/libmsrpc/test/reg/shutdown.c b/examples/libmsrpc/test/reg/shutdown.c
new file mode 100644
index 0000000000..6184fbd976
--- /dev/null
+++ b/examples/libmsrpc/test/reg/shutdown.c
@@ -0,0 +1,68 @@
+/*tries to shut down a remote pc*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring tmp;
+
+ mem_ctx = talloc_init("cac_shutdown");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ hnd->_internal.srv_level = SRV_WIN_NT4;
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct Shutdown s;
+ ZERO_STRUCT(s);
+
+ printf("Message: ");
+ cactest_readline(stdin, tmp);
+
+ s.in.message = talloc_strdup(mem_ctx, tmp);
+
+ printf("timeout: ");
+ scanf("%d", &s.in.timeout);
+
+ printf("Reboot? [y/n]: ");
+ cactest_readline(stdin, tmp);
+
+ s.in.reboot = ( tmp[0] == 'y') ? True : False;
+
+ printf("Force? [y/n]: ");
+ cactest_readline(stdin, tmp);
+
+ s.in.force = (tmp[0] == 'y') ? True : False;
+
+ if(!cac_Shutdown(hnd, mem_ctx, &s)) {
+ fprintf(stderr, "could not shut down server: error %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Server %s is shutting down. Would you like to try to abort? [y/n]: ", hnd->server);
+ fscanf(stdin, "%s", tmp);
+
+ if(tmp[0] == 'y') {
+ if(!cac_AbortShutdown(hnd, mem_ctx)) {
+ fprintf(stderr, "Could not abort shutdown. Error %s\n", nt_errstr(hnd->status));
+ }
+ }
+
+done:
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/sam/adduser.c b/examples/libmsrpc/test/sam/adduser.c
new file mode 100644
index 0000000000..94482d0704
--- /dev/null
+++ b/examples/libmsrpc/test/sam/adduser.c
@@ -0,0 +1,92 @@
+/*add's a user to a domain*/
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ fstring tmp;
+
+ struct SamOpenUser ou;
+
+ POLICY_HND *user_hnd = NULL;
+
+ mem_ctx = talloc_init("cac_adduser");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ struct SamCreateUser cdu;
+ ZERO_STRUCT(cdu);
+
+ printf("Enter account name: ");
+ cactest_readline(stdin, tmp);
+
+ cdu.in.dom_hnd = sod.out.dom_hnd;
+ cdu.in.name = talloc_strdup(mem_ctx, tmp);
+ cdu.in.acb_mask = ACB_NORMAL;
+
+ if(!cac_SamCreateUser(hnd, mem_ctx, &cdu)) {
+ fprintf(stderr, "Could not create user %s. Error: %s\n", cdu.in.name, nt_errstr(hnd->status));
+ }
+
+ printf("would you like to delete this user? [y/n]: ");
+ cactest_readline(stdin, tmp);
+
+ if(tmp[0] == 'y') {
+
+ if(!cdu.out.user_hnd) {
+ ZERO_STRUCT(ou);
+ ou.in.dom_hnd = sod.out.dom_hnd;
+ ou.in.access = MAXIMUM_ALLOWED_ACCESS;
+ ou.in.name = talloc_strdup(mem_ctx, cdu.in.name);
+
+ if(!cac_SamOpenUser(hnd, mem_ctx, &ou)) {
+ fprintf(stderr, "Could not open user for deletion. Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ user_hnd = ou.out.user_hnd;
+ }
+
+ else {
+ user_hnd = cdu.out.user_hnd;
+ }
+
+ if(!cac_SamDeleteUser(hnd, mem_ctx, user_hnd))
+ fprintf(stderr, "Could not delete user. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Nope..ok\n");
+ }
+
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+ cac_SamClose(hnd, mem_ctx, sod.out.sam);
+
+done:
+ talloc_destroy(mem_ctx);
+
+ cac_FreeHandle(hnd);
+
+ return 0;
+}
+
+/*TODO: add a function that will create a user and set userinfo and set the password*/
diff --git a/examples/libmsrpc/test/sam/disable.c b/examples/libmsrpc/test/sam/disable.c
new file mode 100644
index 0000000000..f140bad50b
--- /dev/null
+++ b/examples/libmsrpc/test/sam/disable.c
@@ -0,0 +1,63 @@
+/*disable a user*/
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ struct SamOpenUser ou;
+
+ fstring tmp;
+
+ mem_ctx = talloc_init("cac_disable");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ ZERO_STRUCT(ou);
+ printf("Enter username: ");
+ cactest_readline(stdin, tmp);
+
+ ou.in.name = talloc_strdup(mem_ctx, tmp);
+ ou.in.access = MAXIMUM_ALLOWED_ACCESS;
+ ou.in.dom_hnd = sod.out.dom_hnd;
+
+ if(!cac_SamOpenUser(hnd, mem_ctx, &ou)) {
+ fprintf(stderr, "Could not open user. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ /*enable the user*/
+ if(!cac_SamDisableUser(hnd, mem_ctx, ou.out.user_hnd)) {
+ fprintf(stderr, "Could not disable user: %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/sam/dominfo.c b/examples/libmsrpc/test/sam/dominfo.c
new file mode 100644
index 0000000000..cd2eccefba
--- /dev/null
+++ b/examples/libmsrpc/test/sam/dominfo.c
@@ -0,0 +1,55 @@
+/*gets domain info and prints it out*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ mem_ctx = talloc_init("cac_dominfo");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ struct SamGetDomainInfo gdi;
+ ZERO_STRUCT(gdi);
+
+ gdi.in.dom_hnd = sod.out.dom_hnd;
+
+ if(!cac_SamGetDomainInfo(hnd, mem_ctx, &gdi)) {
+ fprintf(stderr, "Could not get domain info. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Got domain info:\n");
+ print_cac_domain_info(gdi.out.info);
+
+done:
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/sam/enable.c b/examples/libmsrpc/test/sam/enable.c
new file mode 100644
index 0000000000..bb91fb241c
--- /dev/null
+++ b/examples/libmsrpc/test/sam/enable.c
@@ -0,0 +1,64 @@
+/*enable a user*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ struct SamOpenUser ou;
+
+ fstring tmp;
+
+ mem_ctx = talloc_init("cac_samgroup");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ ZERO_STRUCT(ou);
+ printf("Enter username: ");
+ cactest_readline(stdin, tmp);
+
+ ou.in.name = talloc_strdup(mem_ctx, tmp);
+ ou.in.access = MAXIMUM_ALLOWED_ACCESS;
+ ou.in.dom_hnd = sod.out.dom_hnd;
+
+ if(!cac_SamOpenUser(hnd, mem_ctx, &ou)) {
+ fprintf(stderr, "Could not open user. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ /*enable the user*/
+ if(!cac_SamEnableUser(hnd, mem_ctx, ou.out.user_hnd)) {
+ fprintf(stderr, "Could not enable user: %s\n", nt_errstr(hnd->status));
+ }
+
+done:
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/sam/samenum.c b/examples/libmsrpc/test/sam/samenum.c
new file mode 100644
index 0000000000..5b10475aac
--- /dev/null
+++ b/examples/libmsrpc/test/sam/samenum.c
@@ -0,0 +1,117 @@
+/*enumerate users/groups/aliases*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+
+ struct SamEnumUsers eu;
+ struct SamEnumGroups eg;
+ struct SamEnumAliases ea;
+
+ fstring tmp;
+
+ int i;
+
+ mem_ctx = talloc_init("cac_samenum");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ tmp[0] = 0x00;
+ while(tmp[0] != 'q') {
+ printf("Enumerate [u]sers, [g]roups or [a]liases or [q]uit: ");
+ cactest_readline(stdin, tmp);
+
+ switch(tmp[0]) {
+ case 'u':
+ ZERO_STRUCT(eu);
+
+ eu.in.dom_hnd = sod.out.dom_hnd;
+
+ printf("ACB mask (can be 0): ");
+ scanf("%hx", &eu.in.acb_mask);
+
+ while(cac_SamEnumUsers(hnd, mem_ctx, &eu)) {
+ printf("Enumerated %d users:\n", eu.out.num_users);
+ for(i = 0; i < eu.out.num_users; i++) {
+ printf(" Name: %s\n", eu.out.names[i]);
+ printf(" RID: %d\n", eu.out.rids[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate users. Error: %s\n", nt_errstr(hnd->status));
+ }
+ break;
+ case 'g':
+ ZERO_STRUCT(eg);
+ eg.in.dom_hnd = sod.out.dom_hnd;
+
+ printf("Enumerating groups...\n");
+ while(cac_SamEnumGroups(hnd, mem_ctx, &eg)) {
+ printf("Enumerated %d groups:\n", eg.out.num_groups);
+ for(i = 0; i < eg.out.num_groups; i++) {
+ printf("RID: %d\n", eg.out.rids[i]);
+ printf("Name: %s\n", eg.out.names[i]);
+ printf("Desc: %s\n", eg.out.descriptions[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate Groups. Error: %s\n", nt_errstr(hnd->status));
+ }
+ break;
+ case 'a':
+ ZERO_STRUCT(ea);
+ ea.in.dom_hnd = sod.out.dom_hnd;
+
+ printf("Enumerating Aliases...\n");
+ while(cac_SamEnumAliases(hnd, mem_ctx, &ea)) {
+ printf("Enumerated %d aliases:\n", ea.out.num_aliases);
+
+ for(i = 0; i < ea.out.num_aliases; i++) {
+ printf("RID: %d\n", ea.out.rids[i]);
+ printf("Name: %s\n", ea.out.names[i]);
+ printf("Desc: %s\n", ea.out.descriptions[i]);
+ }
+ }
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate Aliases. Error: %s\n", nt_errstr(hnd->status));
+ }
+ break;
+ }
+ }
+
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+ cac_SamClose(hnd, mem_ctx, sod.out.sam);
+
+done:
+ talloc_destroy(mem_ctx);
+ cac_FreeHandle(hnd);
+
+ return 0;
+
+}
+
diff --git a/examples/libmsrpc/test/sam/samgroup.c b/examples/libmsrpc/test/sam/samgroup.c
new file mode 100644
index 0000000000..39d9fa1137
--- /dev/null
+++ b/examples/libmsrpc/test/sam/samgroup.c
@@ -0,0 +1,480 @@
+/*Some group management stuff*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+
+ struct SamEnumGroups eg;
+ struct SamEnumUsers eu;
+ struct SamCreateGroup cg;
+ struct SamOpenGroup og;
+ struct SamGetGroupMembers ggm;
+ struct SamGetNamesFromRids gn;
+ struct SamAddGroupMember add;
+ struct SamRemoveGroupMember del;
+ struct SamSetGroupMembers set;
+ struct SamGetGroupsForUser gg;
+ struct SamOpenUser ou;
+ struct SamGetGroupInfo gi;
+ struct SamSetGroupInfo si;
+ struct SamRenameGroup rg;
+ struct SamGetSecurityObject gso;
+
+ POLICY_HND *group_hnd = NULL;
+
+ fstring tmp;
+ fstring input;
+
+ int i;
+
+ mem_ctx = talloc_init("cac_samgroup");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ tmp[0] = 0x00;
+ while(tmp[0] != 'q') {
+ printf("\n");
+ printf("[l]ist groups\n");
+ printf("[c]reate group\n");
+ printf("[o]pen group\n");
+ printf("[d]elete group\n");
+ printf("list [m]embers\n");
+ printf("list [u]sers\n");
+ printf("list [g]roup for users\n");
+ printf("[a]dd member\n");
+ printf("[r]emove member\n");
+ printf("[x] clear members\n");
+ printf("get group [i]nfo\n");
+ printf("[e]dit group info\n");
+ printf("[s]et members\n");
+ printf("re[n]ame group\n");
+ printf("[z] close group\n");
+ printf("[t] get security info\n");
+
+ printf("[q]uit\n\n");
+ printf("Enter option: ");
+ cactest_readline(stdin, tmp);
+
+ printf("\n");
+
+ switch(tmp[0]) {
+ case 'c': /*create group*/
+ if(group_hnd != NULL) {
+ /*then we have an open handle.. close it*/
+ cac_SamClose(hnd, mem_ctx, group_hnd);
+ group_hnd = NULL;
+ }
+
+ printf("Enter group name: ");
+ cactest_readline(stdin, input);
+
+ ZERO_STRUCT(cg);
+
+ cg.in.name = talloc_strdup(mem_ctx, input);
+ cg.in.access = MAXIMUM_ALLOWED_ACCESS;
+ cg.in.dom_hnd = sod.out.dom_hnd;
+
+ if(!cac_SamCreateGroup(hnd, mem_ctx, &cg)) {
+ fprintf(stderr, "Could not create group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Created group %s\n", cg.in.name);
+
+ group_hnd = cg.out.group_hnd;
+ }
+ break;
+
+ case 'o': /*open group*/
+ if(group_hnd != NULL) {
+ /*then we have an open handle.. close it*/
+ cac_SamClose(hnd, mem_ctx, group_hnd);
+ group_hnd = NULL;
+ }
+
+ ZERO_STRUCT(og);
+
+ og.in.dom_hnd = sod.out.dom_hnd;
+ og.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ printf("Enter RID: 0x");
+ scanf("%x", &og.in.rid);
+
+ if(!cac_SamOpenGroup(hnd, mem_ctx, &og)) {
+ fprintf(stderr, "Could not open group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Opened group\n");
+ group_hnd = og.out.group_hnd;
+ }
+
+ break;
+
+ case 'l': /*list groups*/
+ ZERO_STRUCT(eg);
+ eg.in.dom_hnd = sod.out.dom_hnd;
+
+ while(cac_SamEnumGroups(hnd, mem_ctx, &eg)) {
+ for(i = 0; i < eg.out.num_groups; i++) {
+ printf("RID: 0x%x Name: %s\n", eg.out.rids[i], eg.out.names[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate Groups. Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ break;
+
+ case 'm': /*list group members*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(ggm);
+ ggm.in.group_hnd = group_hnd;
+
+ if(!cac_SamGetGroupMembers(hnd, mem_ctx, &ggm)) {
+ fprintf(stderr, "Could not get group members. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ printf("Group has %d members:\n", ggm.out.num_members);
+
+ if(ggm.out.num_members == 0) /*just skip the rest of this case*/
+ break;
+
+ /**get the user names*/
+ gn.in.dom_hnd = sod.out.dom_hnd;
+ gn.in.num_rids = ggm.out.num_members;
+ gn.in.rids = ggm.out.rids;
+
+ if(!cac_SamGetNamesFromRids(hnd, mem_ctx, &gn)) {
+ fprintf(stderr, "Could not lookup names. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ for(i = 0; i < gn.out.num_names; i++) {
+ printf("RID: 0x%x Name: %s\n", gn.out.map[i].rid, gn.out.map[i].name);
+ }
+
+ break;
+
+ case 'd': /*delete group*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ if(!cac_SamDeleteGroup(hnd, mem_ctx, group_hnd)) {
+ fprintf(stderr, "Could not delete group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Deleted group.\n");
+ group_hnd = NULL;
+ }
+ break;
+
+ case 'u': /*list users*/
+ ZERO_STRUCT(eu);
+
+ eu.in.dom_hnd = sod.out.dom_hnd;
+
+ while(cac_SamEnumUsers(hnd, mem_ctx, &eu)) {
+ for(i = 0; i < eu.out.num_users; i++) {
+ printf(" RID: 0x%x Name: %s\n", eu.out.rids[i], eu.out.names[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate users. Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ break;
+
+ case 'a': /*add member to group*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(add);
+
+ add.in.group_hnd = group_hnd;
+
+ printf("Enter user RID: 0x");
+ scanf("%x", &add.in.rid);
+
+ if(!cac_SamAddGroupMember(hnd, mem_ctx, &add)) {
+ fprintf(stderr, "Could not add user to group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Successfully added user to group\n");
+ }
+ break;
+
+ case 'r': /*remove user from group*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(del);
+ del.in.group_hnd = group_hnd;
+
+ printf("Enter RID: 0x");
+ scanf("%x", &del.in.rid);
+
+ if(!cac_SamRemoveGroupMember(hnd, mem_ctx, &del)) {
+ fprintf(stderr, "Could not remove user from group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Removed user from group.\n");
+ }
+
+ break;
+
+ case 'x': /*clear group members*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ if(!cac_SamClearGroupMembers(hnd, mem_ctx, group_hnd)) {
+ fprintf(stderr, "Could not clear group members. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Cleared group members\n");
+ }
+
+ break;
+
+ case 's': /*set members*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(set);
+
+ set.in.group_hnd = group_hnd;
+
+ printf("Enter the number of members: ");
+ scanf("%d", &set.in.num_members);
+
+ set.in.rids = TALLOC_ARRAY(mem_ctx, uint32, set.in.num_members);
+
+ for(i = 0; i < set.in.num_members; i++) {
+ printf("Enter RID #%d: 0x", (i+1));
+ scanf("%x", (set.in.rids + i));
+ }
+
+ if(!cac_SamSetGroupMembers(hnd, mem_ctx, &set)) {
+ printf("could not set members. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Set users\n");
+ }
+
+ break;
+
+ case 'g': /*list groups for user*/
+ ZERO_STRUCT(ou);
+ ZERO_STRUCT(gg);
+
+ printf("Enter username: ");
+ cactest_readline(stdin, input);
+
+ if(input[0] != '\0') {
+ ou.in.name = talloc_strdup(mem_ctx, input);
+ }
+ else {
+ printf("Enter RID: 0x");
+ scanf("%x", &ou.in.rid);
+ }
+
+ ou.in.access = MAXIMUM_ALLOWED_ACCESS;
+ ou.in.dom_hnd = sod.out.dom_hnd;
+
+ if(!cac_SamOpenUser(hnd, mem_ctx, &ou)) {
+ fprintf(stderr, "Could not open user %s. Error: %s\n", ou.in.name, nt_errstr(hnd->status));
+ break;
+ }
+
+ /*now find the groups*/
+ gg.in.user_hnd = ou.out.user_hnd;
+
+ if(!cac_SamGetGroupsForUser(hnd, mem_ctx, &gg)) {
+ fprintf(stderr, "Could not get groups for user. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ cac_SamClose(hnd, mem_ctx, ou.out.user_hnd);
+
+ ZERO_STRUCT(gn);
+
+ gn.in.dom_hnd = sod.out.dom_hnd;
+ gn.in.num_rids = gg.out.num_groups;
+ gn.in.rids = gg.out.rids;
+
+ if(!cac_SamGetNamesFromRids(hnd, mem_ctx, &gn)) {
+ fprintf(stderr, "Could not get names from RIDs. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ printf("%d groups: \n", gn.out.num_names);
+
+ for(i = 0; i < gn.out.num_names; i++) {
+ printf("RID: 0x%x ", gn.out.map[i].rid);
+
+ if(gn.out.map[i].found)
+ printf("Name: %s\n", gn.out.map[i].name);
+ else
+ printf("Unknown RID\n");
+ }
+
+ break;
+
+ case 'z': /*close group*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ if(!cac_SamClose(hnd, mem_ctx, group_hnd)) {
+ printf("Could not close group\n");
+ break;
+ }
+
+ group_hnd = NULL;
+ break;
+
+ case 'i': /*get group info*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gi);
+ gi.in.group_hnd = group_hnd;
+
+ if(!cac_SamGetGroupInfo(hnd, mem_ctx, &gi)) {
+ printf("Could not get group info. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Retrieved Group info\n");
+ print_cac_group_info(gi.out.info);
+ }
+
+ break;
+
+ case 'e': /*edit group info*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gi);
+ ZERO_STRUCT(si);
+
+ gi.in.group_hnd = group_hnd;
+
+ if(!cac_SamGetGroupInfo(hnd, mem_ctx, &gi)) {
+ printf("Could not get group info. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ edit_cac_group_info(mem_ctx, gi.out.info);
+
+ si.in.group_hnd = group_hnd;
+ si.in.info = gi.out.info;
+
+ if(!cac_SamSetGroupInfo(hnd, mem_ctx, &si)) {
+ printf("Could not set group info. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf(" Done.\n");
+ }
+
+ break;
+
+ case 'n': /*rename group*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(rg);
+
+ printf("Enter new group name: ");
+ cactest_readline(stdin, tmp);
+
+ rg.in.group_hnd = group_hnd;
+ rg.in.new_name = talloc_strdup(mem_ctx, tmp);
+
+ if(!cac_SamRenameGroup(hnd, mem_ctx, &rg))
+ printf("Could not rename group. Error: %s\n", nt_errstr(hnd->status));
+ else
+ printf("Done.\n");
+
+ break;
+ case 't': /*get security info*/
+ if(!group_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gso);
+
+ gso.in.pol = group_hnd;
+
+ if(!cac_SamGetSecurityObject(hnd, mem_ctx, &gso)) {
+ printf("Could not get security descriptor info. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Got it.\n");
+ }
+ break;
+
+ case 'q':
+ break;
+
+ default:
+ printf("Invalid command\n");
+ }
+ }
+
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ if(group_hnd)
+ cac_SamClose(hnd, mem_ctx, group_hnd);
+
+done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/sam/samlookup.c b/examples/libmsrpc/test/sam/samlookup.c
new file mode 100644
index 0000000000..32be50d4b9
--- /dev/null
+++ b/examples/libmsrpc/test/sam/samlookup.c
@@ -0,0 +1,140 @@
+/*lookup names or rids*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+
+ struct SamGetNamesFromRids sgn;
+ struct SamGetRidsFromNames sgr;
+
+ fstring tmp;
+ fstring input;
+
+ int i;
+
+ mem_ctx = talloc_init("cac_samenum");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ tmp[0] = 0x00;
+ while(tmp[0] != 'q') {
+ printf("get [n]ames or get [r]ids or [q]uit: ");
+ cactest_readline(stdin, tmp);
+
+ switch(tmp[0]) {
+ case 'n':
+ ZERO_STRUCT(sgn);
+
+ sgn.in.dom_hnd = sod.out.dom_hnd;
+
+ printf("How many rids will you enter: ");
+ scanf("%d", &sgn.in.num_rids);
+
+ sgn.in.rids = talloc_array(mem_ctx, int, sgn.in.num_rids);
+
+ for(i = 0; i < sgn.in.num_rids; i++) {
+ printf(" Enter RID %d: 0x", i);
+ scanf("%x", &sgn.in.rids[i]);
+ }
+
+ printf("Getting names...\n");
+
+ if(!cac_SamGetNamesFromRids(hnd, mem_ctx, &sgn)) {
+ fprintf(stderr, "could not lookup names. Error: %s\n", nt_errstr(hnd->status));
+ talloc_free(sgn.in.rids);
+ continue;
+ }
+
+ printf("Found %d names:\n", sgn.out.num_names);
+
+ for(i = 0; i < sgn.out.num_names; i++) {
+ printf(" RID: 0x%x ", sgn.out.map[i].rid);
+
+ if(sgn.out.map[i].found) {
+ printf("Name: %s\n", sgn.out.map[i].name);
+ }
+ else {
+ printf("Unknown RID\n");
+ }
+
+ }
+
+ break;
+
+ case 'r':
+ ZERO_STRUCT(sgr);
+
+ sgr.in.dom_hnd = sod.out.dom_hnd;
+
+ printf("How many names will you enter: ");
+ scanf("%d", &sgr.in.num_names);
+
+ sgr.in.names = talloc_array(mem_ctx, char *, sgr.in.num_names);
+
+ for(i = 0; i < sgr.in.num_names; i++) {
+ printf(" Enter name %d: ", (i+1));
+ cactest_readline(stdin, input);
+
+ sgr.in.names[i] = talloc_strdup(mem_ctx, input);
+ }
+
+ if(!cac_SamGetRidsFromNames(hnd, mem_ctx, &sgr)) {
+ fprintf(stderr, "Could not lookup names. Error: %s\n", nt_errstr(hnd->status));
+ continue;
+ }
+
+ printf("Found %d RIDs:\n", sgr.out.num_rids);
+
+ for(i = 0; i < sgr.out.num_rids; i++) {
+ printf(" Name: %s ", sgr.out.map[i].name);
+
+ if(sgr.out.map[i].found) {
+ printf("RID: 0x%x\n", sgr.out.map[i].rid);
+ }
+ else {
+ printf("Unknown name\n");
+ }
+ }
+
+ break;
+ case 'q':
+ printf("\n");
+ break;
+ default:
+ printf("Invalid command!\n");
+ }
+ }
+
+
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+ cac_SamClose(hnd, mem_ctx, sod.out.sam);
+
+done:
+ talloc_destroy(mem_ctx);
+ cac_FreeHandle(hnd);
+
+ return 0;
+
+}
+
diff --git a/examples/libmsrpc/test/sam/samuser.c b/examples/libmsrpc/test/sam/samuser.c
new file mode 100644
index 0000000000..df56a2d991
--- /dev/null
+++ b/examples/libmsrpc/test/sam/samuser.c
@@ -0,0 +1,294 @@
+/*Some user management stuff*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+
+ struct SamOpenUser ou;
+ struct SamEnumUsers eu;
+ struct SamCreateUser cu;
+ struct SamGetUserInfo gi;
+ struct SamSetUserInfo si;
+ struct SamRenameUser ru;
+ struct SamSetPassword sp;
+
+ POLICY_HND *user_hnd = NULL;
+
+ fstring tmp;
+ fstring input;
+
+ char *pass1 = NULL;
+ char *pass2 = NULL;
+
+ int i;
+
+ mem_ctx = talloc_init("cac_samgroup");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ struct SamOpenDomain sod;
+ ZERO_STRUCT(sod);
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod)) {
+ fprintf(stderr, "Could not open domain. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ tmp[0] = 0x00;
+ while(tmp[0] != 'q') {
+ printf("\n");
+ printf("[l]ist users\n");
+ printf("[c]reate user\n");
+ printf("[o]pen user\n");
+ printf("[d]elete user\n");
+ printf("[g]et user info\n");
+ printf("[e]dit user info\n");
+ printf("[r]ename user\n");
+ printf("reset [p]assword\n");
+ printf("[n] close user\n");
+
+ printf("[q]uit\n\n");
+ printf("Enter option: ");
+ cactest_readline(stdin, tmp);
+
+ printf("\n");
+
+ switch(tmp[0]) {
+ case 'c': /*create user*/
+ if(user_hnd != NULL) {
+ /*then we have an open handle.. close it*/
+ cac_SamClose(hnd, mem_ctx, user_hnd);
+ user_hnd = NULL;
+ }
+
+ printf("Enter user name: ");
+ cactest_readline(stdin, input);
+
+ ZERO_STRUCT(cu);
+
+ cu.in.name = talloc_strdup(mem_ctx, input);
+ cu.in.dom_hnd = sod.out.dom_hnd;
+ cu.in.acb_mask = ACB_NORMAL;
+
+ if(!cac_SamCreateUser(hnd, mem_ctx, &cu)) {
+ printf("Could not create user. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Created user %s with RID 0x%x\n", cu.in.name, cu.out.rid);
+ user_hnd = cu.out.user_hnd;
+ }
+
+ break;
+
+ case 'o': /*open group*/
+ if(user_hnd != NULL) {
+ /*then we have an open handle.. close it*/
+ cac_SamClose(hnd, mem_ctx, user_hnd);
+ user_hnd = NULL;
+ }
+
+ ZERO_STRUCT(ou);
+
+ ou.in.dom_hnd = sod.out.dom_hnd;
+ ou.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ printf("Enter RID: 0x");
+ scanf("%x", &ou.in.rid);
+
+ if(!cac_SamOpenUser(hnd, mem_ctx, &ou)) {
+ fprintf(stderr, "Could not open user. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Opened user\n");
+ user_hnd = ou.out.user_hnd;
+ }
+
+ break;
+
+ case 'l': /*list users*/
+ ZERO_STRUCT(eu);
+ eu.in.dom_hnd = sod.out.dom_hnd;
+
+ while(cac_SamEnumUsers(hnd, mem_ctx, &eu)) {
+ for(i = 0; i < eu.out.num_users; i++) {
+ printf("RID: 0x%x Name: %s\n", eu.out.rids[i], eu.out.names[i]);
+ }
+ }
+
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Could not enumerate Users. Error: %s\n", nt_errstr(hnd->status));
+ }
+
+ break;
+
+ break;
+
+ case 'd': /*delete group*/
+ if(!user_hnd) {
+ printf("Must open group first!\n");
+ break;
+ }
+
+ if(!cac_SamDeleteGroup(hnd, mem_ctx, user_hnd)) {
+ fprintf(stderr, "Could not delete group. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Deleted group.\n");
+ user_hnd = NULL;
+ }
+ break;
+
+
+ case 'n':
+ if(!user_hnd) {
+ printf("Must open user first!\n");
+ break;
+ }
+
+ if(!cac_SamClose(hnd, mem_ctx, user_hnd)) {
+ printf("Could not user group\n");
+ break;
+ }
+
+ user_hnd = NULL;
+ break;
+
+ case 'g': /*get user info*/
+ if(!user_hnd) {
+ printf("Must open user first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gi);
+ gi.in.user_hnd = ou.out.user_hnd;
+
+ if(!cac_SamGetUserInfo(hnd, mem_ctx, &gi)) {
+ printf("Could not get user info. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Retrieved User information:\n");
+ print_cac_user_info(gi.out.info);
+ }
+
+ break;
+
+ case 'e': /*edit user info*/
+ if(!user_hnd) {
+ printf("Must Open user first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gi);
+ gi.in.user_hnd = ou.out.user_hnd;
+ if(!cac_SamGetUserInfo(hnd, mem_ctx, &gi)) {
+ printf("Could not get user info. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ edit_cac_user_info(mem_ctx, gi.out.info);
+
+ printf("setting following info:\n");
+ print_cac_user_info(gi.out.info);
+
+ ZERO_STRUCT(si);
+
+ si.in.user_hnd = user_hnd;
+ si.in.info = gi.out.info;
+
+ if(!cac_SamSetUserInfo(hnd, mem_ctx, &si)) {
+ printf("Could not set user info. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Done.\n");
+ }
+
+ break;
+
+ case 'r': /*rename user*/
+ if(!user_hnd) {
+ printf("Must open user first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(ru);
+
+ printf("Enter new username: ");
+ cactest_readline(stdin, tmp);
+
+ ru.in.user_hnd = user_hnd;
+ ru.in.new_name = talloc_strdup(mem_ctx, tmp);
+
+ if(!cac_SamRenameUser(hnd, mem_ctx, &ru)) {
+ printf("Could not rename user. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Renamed user\n");
+ }
+
+ break;
+
+ case 'p': /*reset password*/
+
+ if(!user_hnd) {
+ printf("Must open user first!\n");
+ break;
+ }
+
+ do {
+ if(pass1 && pass2) {
+ printf("Passwords do not match. Please try again\n");
+ }
+
+ pass1 = getpass("Enter new password: ");
+ pass2 = getpass("Re-enter new password: ");
+ } while(strncmp(pass1, pass2, MAX_PASS_LEN));
+
+ ZERO_STRUCT(sp);
+ sp.in.user_hnd = user_hnd;
+ sp.in.password = talloc_strdup(mem_ctx, pass1);
+
+ if(!cac_SamSetPassword(hnd, mem_ctx, &sp)) {
+ printf("Could not set password. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Done.\n");
+ }
+
+ break;
+
+ case 'q':
+ break;
+
+ default:
+ printf("Invalid command\n");
+ }
+ }
+
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ if(user_hnd)
+ cac_SamClose(hnd, mem_ctx, user_hnd);
+
+done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/smbc_test/smbc.c b/examples/libmsrpc/test/smbc_test/smbc.c
new file mode 100644
index 0000000000..3db3ceadc6
--- /dev/null
+++ b/examples/libmsrpc/test/smbc_test/smbc.c
@@ -0,0 +1,87 @@
+/*simple test for libsmbclient compatibility. initialize a smbc context, open sessions on a couple pipes and quit*/
+
+#include "libmsrpc.h"
+#include "libsmbclient.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ SMBCCTX *ctx = NULL;
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+ struct LsaOpenPolicy lop;
+ struct RegConnect rc;
+ struct SamOpenDomain sod;
+
+ ZERO_STRUCT(lop);
+ ZERO_STRUCT(rc);
+ ZERO_STRUCT(sod);
+
+ mem_ctx = talloc_init("cac_smbc");
+ if(!mem_ctx) {
+ printf("Could not initialize talloc context\n");
+ exit(-1);
+ }
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ /*initialize smbc context*/
+ if( (ctx = smbc_new_context()) == NULL) {
+ exit(1);
+ }
+
+ /*this probably isn't what someone would want to do, but it initializes the values we need*/
+ ctx->debug = hnd->debug;
+ ctx->callbacks.auth_fn = cac_GetAuthDataFn;
+
+
+ if(smbc_init_context(ctx) == NULL)
+ exit(1);
+
+ cac_SetSmbcContext(hnd, ctx);
+
+ /*still have to call cac_Connect()*/
+ if(!cac_Connect(hnd, NULL)) {
+ printf("Could not connect to server\n");
+ exit(1);
+ }
+
+ lop.in.access = MAXIMUM_ALLOWED_ACCESS;
+ if(!cac_LsaOpenPolicy(hnd, mem_ctx, &lop))
+ printf("Could not open LSA policy. Error: %s\n", nt_errstr(hnd->status));
+
+ printf("Opened LSA policy.\n");
+
+ rc.in.access = MAXIMUM_ALLOWED_ACCESS;
+ rc.in.root = HKEY_LOCAL_MACHINE;
+ if(!cac_RegConnect(hnd, mem_ctx, &rc))
+ printf("Could not connect to registry. Error: %s\n", nt_errstr(hnd->status));
+
+ printf("Connceted to Registry.\n");
+
+ sod.in.access = MAXIMUM_ALLOWED_ACCESS;
+
+ if(!cac_SamOpenDomain(hnd, mem_ctx, &sod))
+ printf("Could not open domain SAM. Error: %s\n", nt_errstr(hnd->status));
+
+ printf("Opened domain.\n");
+
+ if(lop.out.pol)
+ cac_LsaClosePolicy(hnd, mem_ctx, lop.out.pol);
+
+ if(rc.out.key)
+ cac_RegClose(hnd, mem_ctx, rc.out.key);
+
+ if(sod.out.sam)
+ cac_SamClose(hnd, mem_ctx, sod.out.sam);
+
+ if(sod.out.dom_hnd)
+ cac_SamClose(hnd, mem_ctx, sod.out.dom_hnd);
+
+ cac_FreeHandle(hnd);
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
diff --git a/examples/libmsrpc/test/svcctl/svc.c b/examples/libmsrpc/test/svcctl/svc.c
new file mode 100644
index 0000000000..db5fa27895
--- /dev/null
+++ b/examples/libmsrpc/test/svcctl/svc.c
@@ -0,0 +1,303 @@
+/*Tests all of the svcctl calls (at least at time of writing)*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+int main(int argc, char **argv) {
+ CacServerHandle *hnd = NULL;
+ TALLOC_CTX *mem_ctx = NULL;
+
+
+ struct SvcOpenScm sos;
+ struct SvcEnumServices es;
+ struct SvcOpenService os;
+ struct SvcGetStatus gs;
+ struct SvcStartService start;
+ struct SvcStopService stop;
+ struct SvcPauseService pause;
+ struct SvcContinueService res;
+ struct SvcGetDisplayName gdn;
+ struct SvcGetServiceConfig sgc;
+
+ POLICY_HND *svc_hnd = NULL;
+
+ fstring tmp;
+ fstring input;
+
+ int i;
+
+ mem_ctx = talloc_init("cac_samgroup");
+
+ hnd = cac_NewServerHandle(True);
+
+ cac_SetAuthDataFn(hnd, cactest_GetAuthDataFn);
+
+ cac_parse_cmd_line(argc, argv, hnd);
+
+ if(!cac_Connect(hnd, NULL)) {
+ fprintf(stderr, "Could not connect to server %s. Error: %s\n", hnd->server, nt_errstr(hnd->status));
+ exit(-1);
+ }
+
+ /*open a handle to the scm*/
+ ZERO_STRUCT(sos);
+
+ sos.in.access = SC_MANAGER_ALL_ACCESS;
+
+ if(!cac_SvcOpenScm(hnd, mem_ctx, &sos)) {
+ fprintf(stderr, "Could not open SCM. Error: %s\n", nt_errstr(hnd->status));
+ goto done;
+ }
+
+ printf("Opened SCM\n");
+
+ tmp[0] = 0x00;
+ while(tmp[0] != 'q') {
+ printf("\n");
+ printf("[e] Enum Services\n");
+ printf("[o] Open Service\n");
+ printf("[x] Close Service\n");
+ printf("[g] Get service status\n");
+ printf("[s] Start service\n");
+ printf("[t] Stop service\n");
+ printf("[p] Pause service\n");
+ printf("[r] Resume service\n");
+ printf("[c] Get service config\n");
+
+ printf("[d] Get display name\n");
+
+ printf("[q]uit\n\n");
+ printf("Enter option: ");
+ cactest_readline(stdin, tmp);
+
+ printf("\n");
+
+ switch(tmp[0]) {
+ case 'e': /*enum services*/
+ ZERO_STRUCT(es);
+ es.in.scm_hnd = sos.out.scm_hnd;
+
+ if(!cac_SvcEnumServices(hnd, mem_ctx, &es)) {
+ printf("Could not enumerate services. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ for(i = 0; i < es.out.num_services; i++) {
+ print_cac_service(es.out.services[i]);
+ }
+ printf("Enumerated %d services:\n", es.out.num_services);
+
+ break;
+
+ case 'o': /*Open service*/
+ ZERO_STRUCT(os);
+
+ printf("Enter service name: ");
+ cactest_readline(stdin, tmp);
+
+ os.in.name = talloc_strdup(mem_ctx, tmp);
+ os.in.scm_hnd = sos.out.scm_hnd;
+ os.in.access = SERVICE_ALL_ACCESS;
+
+ if(!cac_SvcOpenService(hnd, mem_ctx, &os)) {
+ printf("Could not open service. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ printf("Opened service.\n");
+ svc_hnd = os.out.svc_hnd;
+
+ break;
+ case 'x': /*close service*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ cac_SvcClose(hnd, mem_ctx, svc_hnd);
+ svc_hnd = NULL;
+ break;
+ case 'g': /*get svc status*/
+
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gs);
+
+ gs.in.svc_hnd = svc_hnd;
+
+ if(!cac_SvcGetStatus(hnd, mem_ctx, &gs)) {
+ printf("Could not get status. Error: %s\n", nt_errstr(hnd->status));
+ break;
+ }
+
+ print_service_status(gs.out.status);
+ break;
+ case 's': /*start service*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(start);
+
+ start.in.svc_hnd = svc_hnd;
+
+ printf("Enter number of parameters: ");
+ scanf("%d", &start.in.num_parms);
+
+ start.in.parms = talloc_array(mem_ctx, char *, start.in.num_parms);
+
+ for(i = 0; i < start.in.num_parms; i++) {
+ printf("Parm %d: ", i);
+ cactest_readline(stdin, tmp);
+ start.in.parms[i] = talloc_strdup(mem_ctx, tmp);
+ }
+
+ printf("Timeout (seconds): ");
+ scanf("%d", &start.in.timeout);
+
+ if(!cac_SvcStartService(hnd, mem_ctx, &start)) {
+ printf("Could not start service. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Started service.\n");
+ }
+
+ break;
+ case 't': /*stop service*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(stop);
+ stop.in.svc_hnd = svc_hnd;
+
+ printf("Timeout (seconds): ");
+ scanf("%d", &stop.in.timeout);
+
+ if(!cac_SvcStopService(hnd, mem_ctx, &stop)) {
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Error occured: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Service was not stopped within %d seconds.\n", stop.in.timeout);
+ print_service_status(stop.out.status);
+ }
+ }
+ else {
+ printf("Done.\n");
+ print_service_status(stop.out.status);
+ }
+ break;
+ case 'd': /*get display name*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(gdn);
+ gdn.in.svc_hnd = svc_hnd;
+
+ if(!cac_SvcGetDisplayName(hnd, mem_ctx, &gdn)) {
+ printf("Could not get display name. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("\tDisplay Name: %s\n", gdn.out.display_name);
+ }
+ break;
+
+ case 'p': /*pause service*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(pause);
+ pause.in.svc_hnd = svc_hnd;
+
+ printf("Timeout (seconds): ");
+ scanf("%d", &pause.in.timeout);
+
+ if(!cac_SvcPauseService(hnd, mem_ctx, &pause)) {
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Error occured: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Service was not paused within %d seconds.\n", pause.in.timeout);
+ print_service_status(pause.out.status);
+ }
+ }
+ else {
+ printf("Done.\n");
+ print_service_status(pause.out.status);
+ }
+
+ break;
+
+ case 'r': /*resume service*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(res);
+ res.in.svc_hnd = svc_hnd;
+
+ printf("Timeout (seconds): ");
+ scanf("%d", &res.in.timeout);
+
+ if(!cac_SvcContinueService(hnd, mem_ctx, &res)) {
+ if(CAC_OP_FAILED(hnd->status)) {
+ printf("Error occured: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ printf("Service was not resumed within %d seconds.\n", res.in.timeout);
+ print_service_status(res.out.status);
+ }
+ }
+ else {
+ printf("Done.\n");
+ print_service_status(res.out.status);
+ }
+
+ break;
+
+ case 'c': /*get service config*/
+ if(!svc_hnd) {
+ printf("Must open service first!\n");
+ break;
+ }
+
+ ZERO_STRUCT(sgc);
+
+ sgc.in.svc_hnd = svc_hnd;
+
+ if(!cac_SvcGetServiceConfig(hnd, mem_ctx, &sgc)) {
+ printf("Could not get service config. Error: %s\n", nt_errstr(hnd->status));
+ }
+ else {
+ print_service_config(&sgc.out.config);
+ }
+ break;
+
+ case 'q': /*quit*/
+ break;
+ default:
+ printf("Invalid command\n");
+ }
+ }
+
+ cac_SvcClose(hnd, mem_ctx, sos.out.scm_hnd);
+
+ done:
+ cac_FreeHandle(hnd);
+
+ talloc_destroy(mem_ctx);
+
+ return 0;
+}
+
diff --git a/examples/libmsrpc/test/test_util.c b/examples/libmsrpc/test/test_util.c
new file mode 100644
index 0000000000..81a9c9203d
--- /dev/null
+++ b/examples/libmsrpc/test/test_util.c
@@ -0,0 +1,408 @@
+/*some utility functions for the registry tests*/
+
+#include "libmsrpc.h"
+#include "test_util.h"
+
+
+void cactest_print_usage(char **argv) {
+ printf("Usage:\n");
+ printf(" %s server [-U username] [-W domain] [-P passwprd] [-N netbios_name]\n", argv[0]);
+}
+
+/*allocates memory for auth info and parses domain/user/server out of command line*/
+void cac_parse_cmd_line(int argc, char **argv, CacServerHandle *hnd) {
+ int i = 0;
+
+ ZERO_STRUCTP(hnd->username);
+ ZERO_STRUCTP(hnd->domain);
+ ZERO_STRUCTP(hnd->netbios_name);
+ ZERO_STRUCTP(hnd->password);
+
+ for(i = 1; i < argc; i++) {
+ if( strncmp(argv[i], "-U", sizeof(fstring)) == 0) {
+ strncpy(hnd->username, argv[i+1], sizeof(fstring));
+ i++;
+ }
+
+ else if(strncmp(argv[i], "-W", sizeof(fstring)) == 0) {
+ strncpy(hnd->domain, argv[i+1], sizeof(fstring));
+ i++;
+
+ }
+
+ else if(strncmp(argv[i], "-P", sizeof(fstring)) == 0) {
+ strncpy(hnd->password, argv[i+1], sizeof(fstring));
+ i++;
+
+ }
+
+ else if(strncmp(argv[i], "-N", sizeof(fstring)) == 0) {
+ strncpy(hnd->netbios_name, argv[i+1], sizeof(fstring));
+ i++;
+ }
+
+ else if(strncmp(argv[i], "-d", sizeof(fstring)) == 0) {
+ sscanf(argv[i+1], "%d", &hnd->debug);
+ i++;
+ }
+
+ else { /*assume this is the server name*/
+ strncpy(hnd->server, argv[i], sizeof(fstring));
+ }
+ }
+
+ if(!hnd->server) {
+ cactest_print_usage(argv);
+ cac_FreeHandle(hnd);
+ exit(-1);
+ }
+
+}
+
+void print_value(uint32 type, REG_VALUE_DATA *data) {
+ int i = 0;
+
+ switch(type) {
+ case REG_SZ:
+ printf(" Type: REG_SZ\n");
+ printf(" Value: %s\n", data->reg_sz);
+ break;
+ case REG_EXPAND_SZ:
+ printf(" Type: REG_EXPAND_SZ\n");
+ printf(" Value: %s\n", data->reg_expand_sz);
+ break;
+ case REG_MULTI_SZ:
+ printf(" Type: REG_MULTI_SZ\n");
+ printf(" Values: ");
+
+ for(i = 0; i < data->reg_multi_sz.num_strings; i++) {
+ printf(" %d: %s\n", i, data->reg_multi_sz.strings[i]);
+ }
+ break;
+ case REG_DWORD:
+ printf(" Type: REG_DWORD\n");
+ printf(" Value: %d\n", data->reg_dword);
+ break;
+ case REG_DWORD_BE:
+ printf(" Type: REG_DWORD_BE\n");
+ printf(" Value: 0x%x\n", data->reg_dword_be);
+ break;
+ case REG_BINARY:
+ printf(" Type: REG_BINARY\n");
+ break;
+ default:
+ printf(" Invalid type: %d\n", type);
+
+ }
+
+ printf("\n");
+
+}
+
+void cactest_readline(FILE *in, fstring line) {
+
+ int c;
+
+ c = fgetc(in);
+ if(c != '\n')
+ ungetc(c, in);
+
+ fgets(line, sizeof(fstring), in);
+
+ if(line[strlen(line) - 1] == '\n')
+ line[strlen(line) - 1] = '\0';
+
+}
+
+void cactest_GetAuthDataFn(const char * pServer,
+ const char * pShare,
+ char * pWorkgroup,
+ int maxLenWorkgroup,
+ char * pUsername,
+ int maxLenUsername,
+ char * pPassword,
+ int maxLenPassword)
+
+{
+ char temp[sizeof(fstring)];
+
+ static char authUsername[sizeof(fstring)];
+ static char authWorkgroup[sizeof(fstring)];
+ static char authPassword[sizeof(fstring)];
+ static char authSet = 0;
+
+ char *pass = NULL;
+
+ if (authSet)
+ {
+ strncpy(pWorkgroup, authWorkgroup, maxLenWorkgroup - 1);
+ strncpy(pUsername, authUsername, maxLenUsername - 1);
+ strncpy(pPassword, authPassword, maxLenPassword - 1);
+ }
+ else
+ {
+ if(pWorkgroup[0] != '\0') {
+ strncpy(authWorkgroup, pWorkgroup, maxLenWorkgroup - 1);
+ }
+ else {
+ d_printf("Domain: [%s] ", pWorkgroup);
+ fscanf(stdin, "%s", temp);
+
+ if (temp[0] != '\0')
+ {
+ strncpy(pWorkgroup, temp, maxLenWorkgroup - 1);
+ strncpy(authWorkgroup, temp, maxLenWorkgroup - 1);
+ }
+ }
+
+
+ if(pUsername[0] != '\0') {
+ strncpy(authUsername, pUsername, maxLenUsername - 1);
+ }
+ else {
+ d_printf("Username: [%s] ", pUsername);
+ fscanf(stdin, "%s", temp);
+
+ if (temp[strlen(temp) - 1] == '\n') /* A new line? */
+ {
+ temp[strlen(temp) - 1] = '\0';
+ }
+
+ if (temp[0] != '\0')
+ {
+ strncpy(pUsername, temp, maxLenUsername - 1);
+ strncpy(authUsername, pUsername, maxLenUsername - 1);
+ }
+ }
+ if(pPassword[0] != '\0') {
+ strncpy(authPassword, pPassword, maxLenPassword - 1);
+ }
+ else {
+ pass = getpass("Password: ");
+ if (pass)
+ fstrcpy(temp, pass);
+ if (temp[strlen(temp) - 1] == '\n') /* A new line? */
+ {
+ temp[strlen(temp) - 1] = '\0';
+ }
+ if (temp[0] != '\0')
+ {
+ strncpy(pPassword, temp, maxLenPassword - 1);
+ strncpy(authPassword, pPassword, maxLenPassword - 1);
+ }
+ }
+ authSet = 1;
+ }
+}
+
+void cactest_reg_input_val(TALLOC_CTX *mem_ctx, int *type, char **name, REG_VALUE_DATA *data) {
+ fstring tmp;
+ int i;
+
+ printf("Enter value name: \n");
+ cactest_readline(stdin, tmp);
+ *name = talloc_strdup(mem_ctx, tmp);
+
+ do {
+ printf("Enter type. %d = REG_SZ, %d = REG_DWORD, %d = REG_MULTI_SZ: ", REG_SZ, REG_DWORD, REG_MULTI_SZ);
+ scanf("%d", type);
+ } while(*type != REG_SZ && *type != REG_DWORD && *type != REG_MULTI_SZ);
+
+ switch(*type) {
+ case REG_SZ:
+ printf("Enter string:\n");
+ cactest_readline(stdin, tmp);
+
+ data->reg_sz = talloc_strdup(mem_ctx, tmp);
+ break;
+
+ case REG_DWORD:
+ printf("Enter dword: ");
+ scanf("%d", &data->reg_dword);
+ break;
+
+ case REG_MULTI_SZ:
+ printf("Enter number of strings: ");
+ scanf("%d", &data->reg_multi_sz.num_strings);
+
+ data->reg_multi_sz.strings = talloc_array(mem_ctx, char *, data->reg_multi_sz.num_strings);
+
+ for(i = 0; i < data->reg_multi_sz.num_strings; i++) {
+ printf("String %d: ", i+1);
+ cactest_readline(stdin, tmp);
+
+ data->reg_multi_sz.strings[i] = talloc_strdup(mem_ctx, tmp);
+ }
+ break;
+ }
+}
+
+void print_cac_user_info(CacUserInfo *info) {
+ printf(" User Name : %s\n", info->username);
+ printf(" Full Name : %s\n", info->full_name);
+ printf(" Home Dir : %s\n", info->home_dir);
+ printf(" Home Drive : %s\n", info->home_drive);
+ printf(" Profile Path : %s\n", info->profile_path);
+ printf(" Logon Script : %s\n", info->logon_script);
+ printf(" Description : %s\n", info->description);
+ printf(" Workstations : %s\n", info->workstations);
+ printf(" Remote Dial : %s\n", info->dial);
+
+ printf(" Logon Time : %s\n", http_timestring(info->logon_time));
+ printf(" Logoff Time : %s\n", http_timestring(info->logoff_time));
+ printf(" Kickoff Time : %s\n", http_timestring(info->kickoff_time));
+ printf(" Pass last set: %s\n", http_timestring(info->pass_last_set_time));
+ printf(" Pass can set : %s\n", http_timestring(info->pass_can_change_time));
+ printf(" Pass must set: %s\n", http_timestring(info->pass_must_change_time));
+
+ printf(" User RID : 0x%x\n", info->rid);
+ printf(" Group RID : 0x%x\n", info->group_rid);
+ printf(" ACB Mask : 0x%x\n", info->acb_mask);
+
+ printf(" Bad pwd count: %d\n", info->bad_passwd_count);
+ printf(" Logon Cuont : %d\n", info->logon_count);
+
+ printf(" NT Password : %s\n", info->nt_password);
+ printf(" LM Password : %s\n", info->lm_password);
+
+}
+
+void edit_readline(fstring line) {
+ fgets(line, sizeof(fstring), stdin);
+
+ if(line[strlen(line)-1] == '\n')
+ line[strlen(line)-1] = '\0';
+}
+void edit_cac_user_info(TALLOC_CTX *mem_ctx, CacUserInfo *info) {
+ fstring tmp;
+
+ printf(" User Name [%s]: ", info->username);
+ edit_readline(tmp);
+
+ if(tmp[0] != '\0')
+ info->username = talloc_strdup(mem_ctx, tmp);
+
+ printf(" Full Name [%s]: ", info->full_name);
+
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ info->full_name = talloc_strdup(mem_ctx, tmp);
+
+ printf(" Description [%s]: ", info->description);
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ info->description = talloc_strdup(mem_ctx, tmp);
+
+ printf(" Remote Dial [%s]: ", info->dial);
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ info->dial = talloc_strdup(mem_ctx, tmp);
+
+ printf(" ACB Mask [0x%x]: ", info->acb_mask);
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ sscanf(tmp, "%x", &info->acb_mask);
+
+ printf(" Must change pass at next logon? [y/N]: ");
+ edit_readline(tmp);
+
+ if(tmp[0] == 'y' || tmp[0] == 'Y')
+ info->pass_must_change= True;
+
+}
+
+void print_cac_group_info(CacGroupInfo *info) {
+ printf(" Group Name : %s\n", info->name);
+ printf(" Description : %s\n", info->description);
+ printf(" Num Members : %d\n", info->num_members);
+}
+
+void edit_cac_group_info(TALLOC_CTX *mem_ctx, CacGroupInfo *info) {
+ fstring tmp;
+
+ printf("Group Name [%s]: ", info->name);
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ info->name = talloc_strdup(mem_ctx, tmp);
+
+ printf("Description [%s]: ", info->description);
+ edit_readline(tmp);
+ if(tmp[0] != '\0')
+ info->description = talloc_strdup(mem_ctx, tmp);
+}
+
+char *srv_role_str(uint32 role) {
+ switch(role) {
+ case ROLE_STANDALONE:
+ return "STANDALONE";
+ break;
+ case ROLE_DOMAIN_MEMBER:
+ return "DOMAIN_MEMBER";
+ break;
+ case ROLE_DOMAIN_BDC:
+ return "DOMAIN_BDC";
+ break;
+ case ROLE_DOMAIN_PDC:
+ return "DOMAIN_PDC";
+ break;
+ }
+
+ return "Invalid role!\n";
+}
+
+char *cactime_str(CacTime ctime, fstring tmp) {
+
+ snprintf(tmp, sizeof(fstring), "%u Days, %u Hours, %u Minutes, %u Seconds", ctime.days, ctime.hours, ctime.minutes, ctime.seconds);
+
+ return tmp;
+}
+
+void print_cac_domain_info(CacDomainInfo *info) {
+ fstring tmp;
+
+ printf(" Server Role : %s\n", srv_role_str(info->server_role));
+ printf(" Num Users : %d\n", info->num_users);
+ printf(" Num Domain Groups: %d\n", info->num_domain_groups);
+ printf(" Num Local Groups : %d\n", info->num_local_groups);
+ printf(" Comment : %s\n", info->comment);
+ printf(" Domain Name : %s\n", info->domain_name);
+ printf(" Server Name : %s\n", info->server_name);
+ printf(" Min. Pass. Length: %d\n", info->min_pass_length);
+ printf(" Password History : %d\n", info->pass_history);
+ printf("\n");
+ printf(" Passwords Expire In : %s\n", cactime_str(info->expire, tmp));
+ printf(" Passwords Can Change in: %s\n", cactime_str(info->min_pass_age, tmp));
+ printf(" Lockouts last : %s\n", cactime_str(info->lockout_duration, tmp));
+ printf(" Allowed Bad Attempts : %d\n", info->num_bad_attempts);
+}
+
+void print_cac_service(CacService svc) {
+ printf("\tService Name: %s\n", svc.service_name);
+ printf("\tDisplay Name: %s\n", svc.display_name);
+ print_service_status(svc.status);
+}
+
+void print_service_status(SERVICE_STATUS status) {
+ printf("\tStatus:\n");
+ printf("\t Type: 0x%x\n", status.type);
+ printf("\t State: 0x%x\n", status.state);
+ printf("\t Controls: 0x%x\n", status.controls_accepted);
+ printf("\t W32 Exit Code: 0x%x\n", status.win32_exit_code);
+ printf("\t SVC Exit Code: 0x%x\n", status.service_exit_code);
+ printf("\t Checkpoint: 0x%x\n", status.check_point);
+ printf("\t Wait Hint: 0x%x\n", status.wait_hint);
+ printf("\n");
+}
+
+void print_service_config(CacServiceConfig *config) {
+ printf("\tConfig:\n");
+ printf("\tType: 0x%x\n", config->type);
+ printf("\tStart Type: 0x%x\n", config->start_type);
+ printf("\tError config: 0x%x\n", config->error_control);
+ printf("\tExecutable Path: %s\n", config->exe_path);
+ printf("\tLoad Order Group: %s\n", config->load_order_group);
+ printf("\tTag ID: 0x%x\n", config->tag_id);
+ printf("\tDependencies: %s\n", config->dependencies);
+ printf("\tStart Name: %s\n", config->start_name);
+ printf("\tDisplay Name: %s\n", config->display_name);
+}
diff --git a/examples/libmsrpc/test/test_util.h b/examples/libmsrpc/test/test_util.h
new file mode 100644
index 0000000000..9b27599da1
--- /dev/null
+++ b/examples/libmsrpc/test/test_util.h
@@ -0,0 +1,31 @@
+#ifndef TEST_UTIL_H
+#define TEST_UTIL_H
+
+#include "libmsrpc.h"
+
+/*prototypes*/
+void cactest_GetAuthDataFn(const char * pServer,
+ const char * pShare,
+ char * pWorkgroup,
+ int maxLenWorkgroup,
+ char * pUsername,
+ int maxLenUsername,
+ char * pPassword,
+ int maxLenPassword);
+
+
+void cactest_print_usage(char **argv);
+void cac_parse_cmd_line(int argc, char **argv, CacServerHandle *hnd);
+void print_value(uint32 type, REG_VALUE_DATA *data);
+void cactest_readline(FILE *in, fstring line);
+void cactest_reg_input_val(TALLOC_CTX *mem_ctx, int *type, char **name, REG_VALUE_DATA *data);
+void print_cac_user_info(CacUserInfo *info);
+void edit_cac_user_info(TALLOC_CTX *mem_ctx, CacUserInfo *info);
+void print_cac_group_info(CacGroupInfo *info);
+void edit_cac_group_info(TALLOC_CTX *mem_ctx, CacGroupInfo *info);
+void print_cac_domain_info(CacDomainInfo *info);
+void print_cac_service(CacService svc);
+void print_service_status(SERVICE_STATUS status);
+void print_service_config(CacServiceConfig *config);
+
+#endif /*TEST_UTIL_H*/