From 3c6b0f965588aab0edbc4d115fb9e72c884ded3b Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Sat, 3 Sep 2005 16:55:45 +0000 Subject: r10003: in the rush for 10k, I forgot to run add the rest of Chris' libmsrpc files (This used to be commit 32bebc452dffa8348b94c5b866350b1fe761986f) --- examples/libmsrpc/test/Makefile | 99 ++++++ examples/libmsrpc/test/README | 8 + examples/libmsrpc/test/lsa/ear.c | 261 ++++++++++++++++ examples/libmsrpc/test/lsa/lsaenum.c | 96 ++++++ examples/libmsrpc/test/lsa/lsaenumprivs.c | 79 +++++ examples/libmsrpc/test/lsa/lsapol.c | 87 ++++++ examples/libmsrpc/test/lsa/lsapriv.c | 113 +++++++ examples/libmsrpc/test/lsa/lsaq.c | 245 +++++++++++++++ examples/libmsrpc/test/lsa/lsatrust.c | 151 ++++++++++ examples/libmsrpc/test/reg/regdelete.c | 102 +++++++ examples/libmsrpc/test/reg/regkey.c | 76 +++++ examples/libmsrpc/test/reg/regkeycreate.c | 115 +++++++ examples/libmsrpc/test/reg/regkeyenum.c | 99 ++++++ examples/libmsrpc/test/reg/regopen.c | 66 ++++ examples/libmsrpc/test/reg/regopenkey.c | 69 +++++ examples/libmsrpc/test/reg/regqueryval.c | 79 +++++ examples/libmsrpc/test/reg/regsetval.c | 59 ++++ examples/libmsrpc/test/reg/regvalenum.c | 103 +++++++ examples/libmsrpc/test/reg/security.c | 74 +++++ examples/libmsrpc/test/reg/shutdown.c | 68 +++++ examples/libmsrpc/test/sam/adduser.c | 92 ++++++ examples/libmsrpc/test/sam/disable.c | 63 ++++ examples/libmsrpc/test/sam/dominfo.c | 55 ++++ examples/libmsrpc/test/sam/enable.c | 64 ++++ examples/libmsrpc/test/sam/samenum.c | 117 ++++++++ examples/libmsrpc/test/sam/samgroup.c | 480 ++++++++++++++++++++++++++++++ examples/libmsrpc/test/sam/samlookup.c | 140 +++++++++ examples/libmsrpc/test/sam/samuser.c | 294 ++++++++++++++++++ examples/libmsrpc/test/smbc_test/smbc.c | 87 ++++++ examples/libmsrpc/test/svcctl/svc.c | 303 +++++++++++++++++++ examples/libmsrpc/test/test_util.c | 408 +++++++++++++++++++++++++ examples/libmsrpc/test/test_util.h | 31 ++ 32 files changed, 4183 insertions(+) create mode 100644 examples/libmsrpc/test/Makefile create mode 100644 examples/libmsrpc/test/README create mode 100644 examples/libmsrpc/test/lsa/ear.c create mode 100644 examples/libmsrpc/test/lsa/lsaenum.c create mode 100644 examples/libmsrpc/test/lsa/lsaenumprivs.c create mode 100644 examples/libmsrpc/test/lsa/lsapol.c create mode 100644 examples/libmsrpc/test/lsa/lsapriv.c create mode 100644 examples/libmsrpc/test/lsa/lsaq.c create mode 100644 examples/libmsrpc/test/lsa/lsatrust.c create mode 100644 examples/libmsrpc/test/reg/regdelete.c create mode 100644 examples/libmsrpc/test/reg/regkey.c create mode 100644 examples/libmsrpc/test/reg/regkeycreate.c create mode 100644 examples/libmsrpc/test/reg/regkeyenum.c create mode 100644 examples/libmsrpc/test/reg/regopen.c create mode 100644 examples/libmsrpc/test/reg/regopenkey.c create mode 100644 examples/libmsrpc/test/reg/regqueryval.c create mode 100644 examples/libmsrpc/test/reg/regsetval.c create mode 100644 examples/libmsrpc/test/reg/regvalenum.c create mode 100644 examples/libmsrpc/test/reg/security.c create mode 100644 examples/libmsrpc/test/reg/shutdown.c create mode 100644 examples/libmsrpc/test/sam/adduser.c create mode 100644 examples/libmsrpc/test/sam/disable.c create mode 100644 examples/libmsrpc/test/sam/dominfo.c create mode 100644 examples/libmsrpc/test/sam/enable.c create mode 100644 examples/libmsrpc/test/sam/samenum.c create mode 100644 examples/libmsrpc/test/sam/samgroup.c create mode 100644 examples/libmsrpc/test/sam/samlookup.c create mode 100644 examples/libmsrpc/test/sam/samuser.c create mode 100644 examples/libmsrpc/test/smbc_test/smbc.c create mode 100644 examples/libmsrpc/test/svcctl/svc.c create mode 100644 examples/libmsrpc/test/test_util.c create mode 100644 examples/libmsrpc/test/test_util.h (limited to 'examples/libmsrpc/test') 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*/ -- cgit