Changeset 740 for vendor/current/source3/utils

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source3/utils

Files:

• dbwrap_tool.c (modified) (3 diffs)
• dbwrap_torture.c (added)
• eventlogadm.c (modified) (9 diffs)
• log2pcaphex.c (modified) (1 diff)
• net.c (modified) (13 diffs)
• net.h (modified) (5 diffs)
• net_ads.c (modified) (23 diffs)
• net_ads_gpo.c (modified) (12 diffs)
• net_afs.c (modified) (4 diffs)
• net_cache.c (modified) (6 diffs)
• net_conf.c (modified) (46 diffs)
• net_dns.c (modified) (5 diffs)
• net_dom.c (modified) (2 diffs)
• net_eventlog.c (modified) (4 diffs)
• net_g_lock.c (modified) (3 diffs)
• net_group.c (modified) (1 diff)
• net_groupmap.c (modified) (18 diffs)
• net_idmap.c (modified) (18 diffs)
• net_idmap_check.c (added)
• net_idmap_check.h (added)
• net_lookup.c (modified) (4 diffs)
• net_printing.c (added)
• net_proto.h (modified) (24 diffs)
• net_rap.c (modified) (7 diffs)
• net_registry.c (modified) (23 diffs)
• net_registry_util.c (modified) (6 diffs)
• net_rpc.c (modified) (209 diffs)
• net_rpc_audit.c (modified) (17 diffs)
• net_rpc_join.c (modified) (18 diffs)
• net_rpc_printer.c (modified) (82 diffs)
• net_rpc_registry.c (modified) (58 diffs)
• net_rpc_rights.c (modified) (35 diffs)
• net_rpc_samsync.c (modified) (10 diffs)
• net_rpc_service.c (modified) (49 diffs)
• net_rpc_sh_acct.c (modified) (7 diffs)
• net_rpc_shell.c (modified) (2 diffs)
• net_rpc_trust.c (added)
• net_sam.c (modified) (44 diffs)
• net_serverid.c (added)
• net_share.c (modified) (1 diff)
• net_status.c (modified) (8 diffs)
• net_time.c (modified) (2 diffs)
• net_usershare.c (modified) (17 diffs)
• net_util.c (modified) (10 diffs)
• netlookup.c (modified) (4 diffs)
• nmblookup.c (modified) (11 diffs)
• ntlm_auth.c (modified) (63 diffs)
• ntlm_auth_diagnostics.c (modified) (1 diff)
• pdbedit.c (modified) (18 diffs)
• profiles.c (modified) (10 diffs)
• rpccheck.c (deleted)
• sharesec.c (modified) (17 diffs)
• smbcacls.c (modified) (34 diffs)
• smbcontrol.c (modified) (31 diffs)
• smbcquotas.c (modified) (16 diffs)
• smbfilter.c (modified) (8 diffs)
• smbget.c (modified) (18 diffs)
• smbpasswd.c (modified) (6 diffs)
• smbta-util.c (added)
• smbtree.c (modified) (5 diffs)
• split_tokens.c (added)
• status.c (modified) (7 diffs)
• status_profile.c (modified) (4 diffs)
• testparm.c (modified) (10 diffs)

vendor/current/source3/utils/dbwrap_tool.c

@@ -21 +21 @@
 
 #include "includes.h"
-
-extern bool AllowDebugChange;
+#include "system/filesys.h"
+#include "dbwrap.h"
+#include "messages.h"
 
 typedef enum { OP_FETCH, OP_STORE, OP_DELETE, OP_ERASE, OP_LISTKEYS } dbwrap_op;
@@ -214 +215 @@
 
         load_case_tables();
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
-        dbf = x_stderr;
-        AllowDebugChange = false;
+        lp_set_cmdline("log level", "0");
+        setup_logging(argv[0], DEBUG_STDERR);
         lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
 
@@ -299 +299 @@
         }
 
-        msg_ctx = messaging_init(mem_ctx, server_id_self(), evt_ctx);
+        msg_ctx = messaging_init(mem_ctx, procid_self(), evt_ctx);
         if (msg_ctx == NULL) {
                 d_fprintf(stderr, "ERROR: could not init messaging context\n");

vendor/current/source3/utils/eventlogadm.c

@@ -24 +24 @@
 
 #include "includes.h"
-
-#undef  DBGC_CLASS
-#define DBGC_CLASS DBGC_UTIL_EVENTLOG
-
+#include "lib/eventlog/eventlog.h"
+#include "registry.h"
+#include "registry/reg_backend_db.h"
+#include "registry/reg_objects.h"
+#include "../libcli/registry/util_reg.h"
 
 extern int optind;
@@ -41 +42 @@
         printf( " -o dump <Eventlog Name> <starting_record>\t\t\t\t\tDump stored eventlog entries on STDOUT\n" );
         printf( "\nMiscellaneous options:\n" );
+        printf( " -s <filename>\t\t\t\t\t\t\tUse configuration file <filename>.\n");
         printf( " -d\t\t\t\t\t\t\t\tturn debug on\n" );
         printf( " -h\t\t\t\t\t\t\t\tdisplay help\n\n" );
@@ -51 +53 @@
 
         elogs = lp_eventlog_list(  );
-        printf( "Active eventlog names (from smb.conf):\n" );
+        printf( "Active eventlog names:\n" );
         printf( "--------------------------------------\n" );
         if ( elogs ) {
@@ -60 +62 @@
         else
                 printf( "\t<None specified>\n");
+}
+
+/*********************************************************************
+ for an eventlog, add in a source name. If the eventlog doesn't
+ exist (not in the list) do nothing.   If a source for the log
+ already exists, change the information (remove, replace)
+*********************************************************************/
+static bool eventlog_add_source( const char *eventlog, const char *sourcename,
+                                 const char *messagefile )
+{
+        /* Find all of the eventlogs, add keys for each of them */
+        /* need to add to the value KEY_EVENTLOG/<eventlog>/Sources string (Creating if necessary)
+           need to add KEY of source to KEY_EVENTLOG/<eventlog>/<source> */
+
+        const char **elogs = lp_eventlog_list(  );
+        const char **wrklist, **wp;
+        char *evtlogpath = NULL;
+        struct regsubkey_ctr *subkeys;
+        struct regval_ctr *values;
+        struct regval_blob *rval;
+        int ii = 0;
+        bool already_in;
+        int i;
+        int numsources = 0;
+        TALLOC_CTX *ctx = talloc_tos();
+        WERROR werr;
+        DATA_BLOB blob;
+
+        if (!elogs) {
+                return False;
+        }
+
+        for ( i = 0; elogs[i]; i++ ) {
+                if ( strequal( elogs[i], eventlog ) )
+                        break;
+        }
+
+        if ( !elogs[i] ) {
+                d_printf("Eventlog [%s] not found in list of valid event logs\n",
+                         eventlog);
+                return false;   /* invalid named passed in */
+        }
+
+        /* have to assume that the evenlog key itself exists at this point */
+        /* add in a key of [sourcename] under the eventlog key */
+
+        /* todo add to Sources */
+
+        werr = regval_ctr_init(ctx, &values);
+        if(!W_ERROR_IS_OK(werr)) {
+                d_printf("talloc() failure!\n");
+                return false;
+        }
+
+        evtlogpath = talloc_asprintf(ctx, "%s\\%s", KEY_EVENTLOG, eventlog);
+        if (!evtlogpath) {
+                TALLOC_FREE(values);
+                return false;
+        }
+
+        regdb_fetch_values( evtlogpath, values );
+
+
+        if ( !( rval = regval_ctr_getvalue( values, "Sources" ) ) ) {
+                d_printf("No Sources value for [%s]!\n", eventlog);
+                return False;
+        }
+        /* perhaps this adding a new string to a multi_sz should be a fn? */
+        /* check to see if it's there already */
+
+        if ( regval_type(rval) != REG_MULTI_SZ ) {
+                d_printf("Wrong type for Sources, should be REG_MULTI_SZ\n");
+                return False;
+        }
+        /* convert to a 'regulah' chars to do some comparisons */
+
+        already_in = False;
+        wrklist = NULL;
+        dump_data(1, regval_data_p(rval), regval_size(rval));
+
+        blob = data_blob_const(regval_data_p(rval), regval_size(rval));
+        if (!pull_reg_multi_sz(talloc_tos(), &blob, &wrklist)) {
+                return false;
+        }
+
+        for (ii=0; wrklist[ii]; ii++) {
+                numsources++;
+        }
+
+        if (numsources > 0) {
+                /* see if it's in there already */
+                wp = wrklist;
+
+                while (wp && *wp ) {
+                        if ( strequal( *wp, sourcename ) ) {
+                                d_printf("Source name [%s] already in list for [%s] \n",
+                                         sourcename, eventlog);
+                                already_in = True;
+                                break;
+                        }
+                        wp++;
+                }
+        } else {
+                d_printf("Nothing in the sources list, this might be a problem\n");
+        }
+
+        wp = wrklist;
+
+        if ( !already_in ) {
+                /* make a new list with an additional entry; copy values, add another */
+                wp = TALLOC_ARRAY(ctx, const char *, numsources + 2 );
+
+                if ( !wp ) {
+                        d_printf("talloc() failed \n");
+                        return False;
+                }
+                memcpy( wp, wrklist, sizeof( char * ) * numsources );
+                *( wp + numsources ) = ( char * ) sourcename;
+                *( wp + numsources + 1 ) = NULL;
+                if (!push_reg_multi_sz(ctx, &blob, wp)) {
+                        return false;
+                }
+                dump_data( 1, blob.data, blob.length);
+                regval_ctr_addvalue( values, "Sources", REG_MULTI_SZ,
+                                     blob.data, blob.length);
+                regdb_store_values( evtlogpath, values );
+                data_blob_free(&blob);
+        } else {
+                d_printf("Source name [%s] found in existing list of sources\n",
+                         sourcename);
+        }
+        TALLOC_FREE(values);
+        TALLOC_FREE(wrklist);   /*  */
+
+        werr = regsubkey_ctr_init(ctx, &subkeys);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_printf("talloc() failure!\n");
+                return False;
+        }
+        TALLOC_FREE(evtlogpath);
+        evtlogpath = talloc_asprintf(ctx, "%s\\%s", KEY_EVENTLOG, eventlog );
+        if (!evtlogpath) {
+                TALLOC_FREE(subkeys);
+                return false;
+        }
+
+        regdb_fetch_keys( evtlogpath, subkeys );
+
+        if ( !regsubkey_ctr_key_exists( subkeys, sourcename ) ) {
+                d_printf(" Source name [%s] for eventlog [%s] didn't exist, adding \n",
+                         sourcename, eventlog);
+                regsubkey_ctr_addkey( subkeys, sourcename );
+                if ( !regdb_store_keys( evtlogpath, subkeys ) )
+                        return False;
+        }
+        TALLOC_FREE(subkeys);
+
+        /* at this point KEY_EVENTLOG/<eventlog>/<sourcename> key is in there. Now need to add EventMessageFile */
+
+        /* now allocate room for the source's subkeys */
+
+        werr = regsubkey_ctr_init(ctx, &subkeys);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_printf("talloc() failure!\n");
+                return False;
+        }
+        TALLOC_FREE(evtlogpath);
+        evtlogpath = talloc_asprintf(ctx, "%s\\%s\\%s",
+                  KEY_EVENTLOG, eventlog, sourcename);
+        if (!evtlogpath) {
+                TALLOC_FREE(subkeys);
+                return false;
+        }
+
+        regdb_fetch_keys( evtlogpath, subkeys );
+
+        /* now add the values to the KEY_EVENTLOG/Application form key */
+        werr = regval_ctr_init(ctx, &values);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_printf("talloc() failure!\n");
+                return False;
+        }
+        d_printf("Storing EventMessageFile [%s] to eventlog path of [%s]\n",
+                 messagefile, evtlogpath);
+
+        regdb_fetch_values( evtlogpath, values );
+
+        regval_ctr_addvalue_sz(values, "EventMessageFile", messagefile);
+        regdb_store_values( evtlogpath, values );
+
+        TALLOC_FREE(values);
+
+        return True;
 }
 
@@ -221 +416 @@
         int opt, rc;
         char *exename;
+        char *configfile = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
 
@@ -229 +425 @@
 
         opt_debug = 0;          /* todo set this from getopts */
-
-        lp_load(get_dyn_CONFIGFILE(), True, False, False, True);
 
         exename = argv[0];
@@ -241 +435 @@
         eventlog_add_source( "System", "TestSourceX", "SomeTestPathX" );
 #endif
-        while ( ( opt = getopt( argc, argv, "dho:" ) ) != EOF ) {
+        while ( ( opt = getopt( argc, argv, "dho:s:" ) ) != EOF ) {
                 switch ( opt ) {
 
@@ -257 +451 @@
                         opt_debug = 1;
                         break;
+                case 's':
+                        configfile = talloc_strdup(frame, optarg);
+                        break;
+
                 }
         }
@@ -266 +464 @@
                 printf( "\nNot enough arguments!\n" );
                 usage( exename );
+                exit( 1 );
+        }
+
+        if ( configfile == NULL ) {
+                lp_load(get_dyn_CONFIGFILE(), True, False, False, True);
+        } else if (!lp_load(configfile, True, False, False, True)) {
+                printf("Unable to parse configfile '%s'\n",configfile);
                 exit( 1 );
         }

vendor/current/source3/utils/log2pcaphex.c

@@ -52 +52 @@
 
 #include "includes.h"
+#include "popt_common.h"
 
 /* We don't care about the paranoid malloc checker in this standalone

vendor/current/source3/utils/net.c

@@ -42 +42 @@
 
 #include "includes.h"
+#include "popt_common.h"
 #include "utils/net.h"
-
-extern bool AllowDebugChange;
+#include "secrets.h"
+#include "lib/netapi/netapi.h"
+#include "../libcli/security/security.h"
+#include "passdb.h"
+#include "messages.h"
 
 #ifdef WITH_FAKE_KASERVER
@@ -232 +236 @@
 static int net_getlocalsid(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         const char *name;
         fstring sid_str;
@@ -272 +276 @@
 static int net_setlocalsid(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
 
         if ( (argc != 1)
@@ -293 +297 @@
 static int net_setdomainsid(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
 
         if ( (argc != 1)
@@ -314 +318 @@
 static int net_getdomainsid(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID domain_sid;
+        struct dom_sid domain_sid;
         fstring sid_str;
 
@@ -668 +672 @@
                 net_maxrid,
                 NET_TRANSPORT_LOCAL,
-                N_("Display the maximul RID currently used"),
+                N_("Display the maximum RID currently used"),
                 N_("  net maxrid")
         },
@@ -719 +723 @@
                 N_("  Use 'net help eventlog' to get more information about "
                    "'net eventlog' commands.")
+        },
+        {       "printing",
+                net_printing,
+                NET_TRANSPORT_LOCAL,
+                N_("Process tdb printer files"),
+                N_("  Use 'net help printing' to get more information about "
+                   "'net printing' commands.")
+        },
+
+        {       "serverid",
+                net_serverid,
+                NET_TRANSPORT_LOCAL,
+                N_("Manage the serverid tdb"),
+                N_("  Use 'net help serverid' to get more information about "
+                   "'net serverid' commands.")
         },
 
@@ -797 +816 @@
                 {"single-obj-repl", 0, POPT_ARG_NONE, &c->opt_single_obj_repl},
                 {"clean-old-entries", 0, POPT_ARG_NONE, &c->opt_clean_old_entries},
-
+                /* Options for 'net idmap'*/
+                {"db", 0, POPT_ARG_STRING, &c->opt_db},
+                {"lock", 0, POPT_ARG_NONE,   &c->opt_lock},
+                {"auto", 'a', POPT_ARG_NONE,   &c->opt_auto},
+                {"repair", 0, POPT_ARG_NONE,   &c->opt_repair},
                 POPT_COMMON_SAMBA
                 { 0, 0, 0, 0}
@@ -804 +827 @@
         zero_sockaddr(&c->opt_dest_ip);
 
+        setup_logging(argv[0], DEBUG_STDERR);
+
         load_case_tables();
 
         setlocale(LC_ALL, "");
 #if defined(HAVE_BINDTEXTDOMAIN)
-        bindtextdomain(MODULE_NAME, dyn_LOCALEDIR);
+        bindtextdomain(MODULE_NAME, get_dyn_LOCALEDIR());
 #endif
 #if defined(HAVE_TEXTDOMAIN)
@@ -815 +840 @@
 
         /* set default debug level to 0 regardless of what smb.conf sets */
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
-        dbf = x_stderr;
+        lp_set_cmdline("log level", "0");
         c->private_data = net_func;
 
@@ -855 +879 @@
         }
 
-        /*
-         * Don't load debug level from smb.conf. It should be
-         * set by cmdline arg or remain default (0)
-         */
-        AllowDebugChange = false;
         lp_load(get_dyn_CONFIGFILE(), true, false, false, true);
 
@@ -898 +917 @@
 
         /* this makes sure that when we do things like call scripts,
-           that it won't assert becouse we are not root */
+           that it won't assert because we are not root */
         sec_init();
 
@@ -912 +931 @@
         }
 
+        /* Failing to init the msg_ctx isn't a fatal error. Only
+           root-level things (joining/leaving domains etc.) will be denied. */
+
+        c->msg_ctx = messaging_init(c, procid_self(),
+                                    event_context_init(c));
+
         rc = net_run_function(c, argc_new-1, argv_new+1, "net", net_func);
 

vendor/current/source3/utils/net.h

@@ -23 +23 @@
  */
 
-#include "lib/netapi/netapi.h"
-#include "libnet/libnet.h"
-#include "localedir.h"
+struct cli_state;
 
+#include "../librpc/gen_ndr/lsa.h"
+
+#include "intl.h"
 #ifdef HAVE_LIBINTL_H
 #include <libintl.h>
@@ -76 +77 @@
         int opt_single_obj_repl;
         int opt_clean_old_entries;
+        const char *opt_db;
+        int opt_lock;
+        int opt_auto;
+        int opt_repair;
 
         int opt_have_ip;
@@ -81 +86 @@
         bool smb_encrypt;
         struct libnetapi_ctx *netapi_ctx;
+        struct messaging_context *msg_ctx;
 
         bool display_usage;
@@ -110 +116 @@
 
 typedef NTSTATUS (*rpc_command_fn)(struct net_context *c,
-                                const DOM_SID *,
+                                const struct dom_sid *,
                                 const char *,
                                 struct cli_state *cli,
@@ -130 +136 @@
         struct cli_state *cli;
 
-        DOM_SID *domain_sid;
+        struct dom_sid *domain_sid;
         const char *domain_name;
 

vendor/current/source3/utils/net_ads.c

@@ -23 +23 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "rpc_client/cli_pipe.h"
 #include "librpc/gen_ndr/ndr_krb5pac.h"
-#include "../librpc/gen_ndr/cli_spoolss.h"
+#include "../librpc/gen_ndr/ndr_spoolss.h"
 #include "nsswitch/libwbclient/wbclient.h"
+#include "ads.h"
+#include "libads/cldap.h"
+#include "libads/dns.h"
+#include "../libds/common/flags.h"
+#include "librpc/gen_ndr/libnet_join.h"
+#include "libnet/libnet_join.h"
+#include "smb_krb5.h"
+#include "secrets.h"
+#include "krb5_env.h"
+#include "../libcli/security/security.h"
+#include "libsmb/libsmb.h"
 
 #ifdef HAVE_ADS
@@ -104 +116 @@
         printf(_("Domain Controller:\t%s\n"), reply.pdc_dns_name);
 
-        printf(_("Pre-Win2k Domain:\t%s\n"), reply.domain);
+        printf(_("Pre-Win2k Domain:\t%s\n"), reply.domain_name);
         printf(_("Pre-Win2k Hostname:\t%s\n"), reply.pdc_name);
 
@@ -402 +414 @@
         }
 
-        d_printf(_("Workgroup: %s\n"), reply.domain);
+        d_printf(_("Workgroup: %s\n"), reply.domain_name);
 
         ads_destroy(&ads);
@@ -476 +488 @@
                 ou_str = SMB_STRDUP(c->opt_container);
         } else {
-                ou_str = ads_default_ou_string(ads, WELL_KNOWN_GUID_USERS);
+                ou_str = ads_default_ou_string(ads, DS_GUID_USERS_CONTAINER);
         }
 
@@ -540 +552 @@
         char *primary_group;
         char *escaped_user;
-        DOM_SID primary_group_sid;
+        struct dom_sid primary_group_sid;
         uint32_t group_rid;
         enum wbcSidType type;
@@ -770 +782 @@
                 ou_str = SMB_STRDUP(c->opt_container);
         } else {
-                ou_str = ads_default_ou_string(ads, WELL_KNOWN_GUID_USERS);
+                ou_str = ads_default_ou_string(ads, DS_GUID_USERS_CONTAINER);
         }
 
@@ -959 +971 @@
         }
 
+        if (!c->msg_ctx) {
+                d_fprintf(stderr, _("Could not initialise message context. "
+                        "Try running as root\n"));
+                return -1;
+        }
+
         werr = libnet_init_UnjoinCtx(ctx, &r);
         if (!W_ERROR_IS_OK(werr)) {
@@ -978 +996 @@
                                   WKSSVC_JOIN_FLAGS_ACCOUNT_DELETE;
         r->in.delete_machine_account = true;
+        r->in.msg_ctx           = c->msg_ctx;
 
         werr = libnet_Unjoin(ctx, r);
@@ -1104 +1123 @@
 
 #if defined(WITH_DNS_UPDATES)
-#include "dns.h"
+#include "../lib/addns/dns.h"
 DNS_ERROR DoDNSUpdate(char *pszServerName,
                       const char *pszDomainName, const char *pszHostName,
@@ -1116 +1135 @@
 {
         struct dns_rr_ns *nameservers = NULL;
-        int ns_count = 0;
+        int ns_count = 0, i;
         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
         DNS_ERROR dns_err;
@@ -1181 +1200 @@
         }
 
-        /* Now perform the dns update - we'll try non-secure and if we fail,
-           we'll follow it up with a secure update */
-
-        fstrcpy( dns_server, nameservers[0].hostname );
-
-        dns_err = DoDNSUpdate(dns_server, dnsdomain, machine_name, addrs, num_addrs);
-        if (!ERR_DNS_IS_OK(dns_err)) {
+        for (i=0; i < ns_count; i++) {
+
+                /* Now perform the dns update - we'll try non-secure and if we fail,
+                   we'll follow it up with a secure update */
+
+                fstrcpy( dns_server, nameservers[i].hostname );
+
+                dns_err = DoDNSUpdate(dns_server, dnsdomain, machine_name, addrs, num_addrs);
+                if (ERR_DNS_IS_OK(dns_err)) {
+                        status = NT_STATUS_OK;
+                        goto done;
+                }
+
+                if (ERR_DNS_EQUAL(dns_err, ERROR_DNS_INVALID_NAME_SERVER) ||
+                    ERR_DNS_EQUAL(dns_err, ERROR_DNS_CONNECTION_FAILED) ||
+                    ERR_DNS_EQUAL(dns_err, ERROR_DNS_SOCKET_ERROR)) {
+                        DEBUG(1,("retrying DNS update with next nameserver after receiving %s\n",
+                                dns_errstr(dns_err)));
+                        continue;
+                }
+
+                d_printf(_("DNS Update for %s failed: %s\n"),
+                        machine_name, dns_errstr(dns_err));
                 status = NT_STATUS_UNSUCCESSFUL;
+                goto done;
         }
 
@@ -1348 +1384 @@
                 d_fprintf(stderr, _("Please supply a valid domain name\n"));
                 werr = WERR_INVALID_PARAM;
+                goto fail;
+        }
+
+        if (!c->msg_ctx) {
+                d_fprintf(stderr, _("Could not initialise message context. "
+                        "Try running as root\n"));
+                werr = WERR_ACCESS_DENIED;
                 goto fail;
         }
@@ -1368 +1411 @@
                                   WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE |
                                   WKSSVC_JOIN_FLAGS_DOMAIN_JOIN_IF_JOINED;
+        r->in.msg_ctx           = c->msg_ctx;
 
         werr = libnet_Join(ctx, r);
+        if (W_ERROR_EQUAL(werr, WERR_DCNOTFOUND) &&
+            strequal(domain, lp_realm())) {
+                r->in.domain_name = lp_workgroup();
+                werr = libnet_Join(ctx, r);
+        }
         if (!W_ERROR_IS_OK(werr)) {
                 goto fail;
@@ -1438 +1487 @@
                 ads_destroy(&ads_dns);
         }
+
+done:
 #endif
 
-done:
         TALLOC_FREE(r);
         TALLOC_FREE( ctx );
@@ -1583 +1633 @@
         err = do_gethostbyname(argv[0], argv[1]);
 
-        d_printf(_("do_gethostbyname returned %d\n"), ERROR_DNS_V(err));
+        d_printf(_("do_gethostbyname returned %s (%d)\n"),
+                dns_errstr(err), ERROR_DNS_V(err));
 #endif
         return 0;
@@ -1783 +1834 @@
                                         c->opt_password ? c->opt_password : "",
                                         CLI_FULL_CONNECTION_USE_KERBEROS,
-                                        Undefined, NULL);
+                                        Undefined);
 
         if (NT_STATUS_IS_ERR(nt_status)) {
-                d_fprintf(stderr, _("Unable to open a connnection to %s to "
+                d_fprintf(stderr, _("Unable to open a connection to %s to "
                                     "obtain data for %s\n"),
                           servername, printername);
@@ -1835 +1886 @@
         nt_status = cli_rpc_pipe_open_noauth(cli, &ndr_table_spoolss.syntax_id, &pipe_hnd);
         if (!NT_STATUS_IS_OK(nt_status)) {
-                d_fprintf(stderr, _("Unable to open a connnection to the spoolss pipe on %s\n"),
+                d_fprintf(stderr, _("Unable to open a connection to the spoolss pipe on %s\n"),
                          servername);
                 SAFE_FREE(prt_dn);
@@ -2265 +2316 @@
         const char **attrs;
         LDAPMessage *res = NULL;
-        DOM_SID sid;
+        struct dom_sid sid;
 
         if (argc < 1 || c->display_usage) {
@@ -2463 +2514 @@
 static int net_ads_kerberos_pac(struct net_context *c, int argc, const char **argv)
 {
-        struct PAC_DATA *pac = NULL;
         struct PAC_LOGON_INFO *info = NULL;
         TALLOC_CTX *mem_ctx = NULL;
@@ -2493 +2543 @@
                                      c->opt_user_name,
                                      c->opt_password,
-                                     0,
+                                     0,
                                      NULL,
                                      NULL,
@@ -2501 +2551 @@
                                      2592000, /* one month */
                                      impersonate_princ_s,
-                                     &pac);
+                                     &info);
         if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("failed to query kerberos PAC: %s\n"),
@@ -2508 +2558 @@
         }
 
-        info = get_logon_info_from_pac(pac);
         if (info) {
                 const char *s;
@@ -2794 +2843 @@
 }
 
+int net_ads_gpo(struct net_context *c, int argc, const char **argv)
+{
+        return net_ads_noads();
+}
+
 /* this one shouldn't display a message */
 int net_ads_check(struct net_context *c)

vendor/current/source3/utils/net_ads_gpo.c

@@ -20 +20 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "ads.h"
+#include "../libgpo/gpo.h"
+#include "libgpo/gpo_proto.h"
+#include "../libds/common/flags.h"
 
 #ifdef HAVE_ADS
@@ -35 +39 @@
         struct GROUP_POLICY_OBJECT *gpo;
         NTSTATUS result;
-        struct nt_user_token *token = NULL;
+        struct security_token *token = NULL;
 
         if (argc < 1 || c->display_usage) {
@@ -154 +158 @@
         {
                 WERROR werr = gp_reg_state_read(mem_ctx, flags,
-                                                &token->user_sids[0],
+                                                &token->sids[0],
                                                 &read_list);
                 if (!W_ERROR_IS_OK(werr)) {
@@ -247 +251 @@
                                             "(objectclass=groupPolicyContainer)",
                                             attrs,
-                                            DACL_SECURITY_INFORMATION,
+                                            SECINFO_DACL,
                                             &res);
 
@@ -290 +294 @@
 static int net_ads_gpo_list(struct net_context *c, int argc, const char **argv)
 {
-        ADS_STRUCT *ads;
+        ADS_STRUCT *ads = NULL;
         ADS_STATUS status;
         LDAPMessage *res = NULL;
@@ -298 +302 @@
         uint32 flags = 0;
         struct GROUP_POLICY_OBJECT *gpo_list;
-        struct nt_user_token *token = NULL;
+        struct security_token *token = NULL;
 
         if (argc < 1 || c->display_usage) {
@@ -359 +363 @@
 }
 
-#if 0
 static int net_ads_gpo_apply(struct net_context *c, int argc, const char **argv)
 {
@@ -369 +372 @@
         uint32 uac = 0;
         uint32 flags = 0;
-        struct nt_user_token *token = NULL;
+        struct security_token *token = NULL;
         const char *filter = NULL;
 
@@ -391 +394 @@
 
         status = ads_startup(c, false, &ads);
+        /* filter = cse_gpo_name_to_guid_string("Security"); */
+
         if (!ADS_ERR_OK(status)) {
                 d_printf("got: %s\n", ads_errstr(status));
@@ -443 +448 @@
         return 0;
 }
-#endif
 
 static int net_ads_gpo_link_get(struct net_context *c, int argc, const char **argv)
@@ -625 +629 @@
 {
         struct functable func[] = {
-#if 0
                 {
                         "apply",
@@ -634 +637 @@
                         "    Apply GPO to container"
                 },
-#endif
                 {
                         "getgpo",

vendor/current/source3/utils/net_afs.c

@@ -20 +20 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "secrets.h"
+#include "system/filesys.h"
 
 int net_afs_usage(struct net_context *c, int argc, const char **argv)
@@ -36 +38 @@
 
         if (argc != 2) {
-                d_printf(_("Usage:")," net afs key <keyfile> cell\n");
+                d_printf("%s net afs key <keyfile> cell\n", _("Usage:"));
                 return -1;
         }
@@ -52 +54 @@
         if (read(fd, &keyfile, sizeof(keyfile)) != sizeof(keyfile)) {
                 d_fprintf(stderr, _("Could not read keyfile\n"));
+                close(fd);
                 return -1;
         }
+        close(fd);
 
         if (!secrets_store_afs_keyfile(argv[1], &keyfile)) {
@@ -69 +73 @@
 
         if (argc != 2) {
-                fprintf(stderr, _("Usage:")," net afs impersonate <user> <cell>\n");
+                d_fprintf(stderr, "%s net afs impersonate <user> <cell>\n",
+                          _("Usage:"));
                 exit(1);
         }

vendor/current/source3/utils/net_cache.c

@@ -34 +34 @@
  * Both of them are defined by first arg of gencache_iterate() routine.
  */
-static void print_cache_entry(const char* keystr, const char* datastr,
+static void print_cache_entry(const char* keystr, DATA_BLOB value,
                               const time_t timeout, void* dptr)
 {
         char *timeout_str;
         char *alloc_str = NULL;
+        const char *datastr;
+        char *datastr_free = NULL;
         time_t now_t = time(NULL);
-        struct tm timeout_tm, *now_tm;
-        /* localtime returns statically allocated pointer, so timeout_tm
-           has to be copied somewhere else */
-
-        now_tm = localtime(&timeout);
-        if (!now_tm) {
+        struct tm timeout_tm, now_tm;
+        struct tm *ptimeout_tm, *pnow_tm;
+
+        ptimeout_tm = localtime_r(&timeout, &timeout_tm);
+        if (ptimeout_tm == NULL) {
                 return;
         }
-        memcpy(&timeout_tm, now_tm, sizeof(struct tm));
-        now_tm = localtime(&now_t);
-        if (!now_tm) {
+        pnow_tm = localtime_r(&now_t, &now_tm);
+        if (pnow_tm == NULL) {
                 return;
         }
 
         /* form up timeout string depending whether it's today's date or not */
-        if (timeout_tm.tm_year != now_tm->tm_year ||
-                        timeout_tm.tm_mon != now_tm->tm_mon ||
-                        timeout_tm.tm_mday != now_tm->tm_mday) {
+        if (timeout_tm.tm_year != now_tm.tm_year ||
+                        timeout_tm.tm_mon != now_tm.tm_mon ||
+                        timeout_tm.tm_mday != now_tm.tm_mday) {
 
                 timeout_str = asctime(&timeout_tm);
@@ -72 +72 @@
         }
 
+        datastr = (char *)value.data;
+
+        if ((value.length > 0) && (value.data[value.length-1] != '\0')) {
+                datastr_free = talloc_asprintf(
+                        talloc_tos(), "<binary length %d>",
+                        (int)value.length);
+                datastr = datastr_free;
+                if (datastr == NULL) {
+                        datastr = "<binary>";
+                }
+        }
+
         d_printf(_("Key: %s\t Timeout: %s\t Value: %s  %s\n"), keystr,
                  timeout_str, datastr, timeout > now_t ? "": _("(expired)"));
@@ -221 +233 @@
 {
         const char* keystr = argv[0];
-        char* valuestr = NULL;
+        DATA_BLOB value;
         time_t timeout;
 
@@ -231 +243 @@
         }
 
-        if (gencache_get(keystr, &valuestr, &timeout)) {
-                print_cache_entry(keystr, valuestr, timeout, NULL);
-                SAFE_FREE(valuestr);
+        if (gencache_get_data_blob(keystr, &value, &timeout, NULL)) {
+                print_cache_entry(keystr, value, timeout, NULL);
+                data_blob_free(&value);
                 return 0;
         }
@@ -261 +273 @@
 
         pattern = argv[0];
-        gencache_iterate(print_cache_entry, NULL, pattern);
+        gencache_iterate_blobs(print_cache_entry, NULL, pattern);
         return 0;
 }
@@ -285 +297 @@
                 return 0;
         }
-        gencache_iterate(print_cache_entry, NULL, pattern);
+        gencache_iterate_blobs(print_cache_entry, NULL, pattern);
         return 0;
 }

vendor/current/source3/utils/net_conf.c

@@ -29 +29 @@
 
 #include "includes.h"
+#include "system/filesys.h"
 #include "utils/net.h"
+#include "lib/smbconf/smbconf.h"
+#include "lib/smbconf/smbconf_init.h"
+#include "lib/smbconf/smbconf_reg.h"
 
 /**********************************************************************
@@ -171 +175 @@
  * This functions process a service previously loaded with libsmbconf.
  */
-static WERROR import_process_service(struct net_context *c,
+static sbcErr import_process_service(struct net_context *c,
                                      struct smbconf_ctx *conf_ctx,
                                      struct smbconf_service *service)
 {
         uint32_t idx;
-        WERROR werr = WERR_OK;
+        sbcErr err = SBC_ERR_OK;
         uint32_t num_includes = 0;
         char **includes = NULL;
@@ -197 +201 @@
 
         if (smbconf_share_exists(conf_ctx, service->name)) {
-                werr = smbconf_delete_share(conf_ctx, service->name);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_delete_share(conf_ctx, service->name);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
                 }
         }
-        werr = smbconf_create_share(conf_ctx, service->name);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_create_share(conf_ctx, service->name);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
         }
@@ -214 +218 @@
                                                         num_includes+1);
                         if (includes == NULL) {
-                                werr = WERR_NOMEM;
+                                err = SBC_ERR_NOMEM;
                                 goto done;
                         }
@@ -220 +224 @@
                                                 service->param_values[idx]);
                         if (includes[num_includes] == NULL) {
-                                werr = WERR_NOMEM;
+                                err = SBC_ERR_NOMEM;
                                 goto done;
                         }
                         num_includes++;
                 } else {
-                        werr = smbconf_set_parameter(conf_ctx,
+                        err = smbconf_set_parameter(conf_ctx,
                                                      service->name,
                                                      service->param_names[idx],
                                                      service->param_values[idx]);
-                        if (!W_ERROR_IS_OK(werr)) {
+                        if (!SBC_ERROR_IS_OK(err)) {
                                 d_fprintf(stderr,
                                           _("Error in section [%s], parameter \"%s\": %s\n"),
                                           service->name, service->param_names[idx],
-                                          win_errstr(werr));
+                                          sbcErrorString(err));
                                 goto done;
                         }
@@ -239 +243 @@
         }
 
-        werr = smbconf_set_includes(conf_ctx, service->name, num_includes,
-                                    (const char **)includes);
-
+        err = smbconf_set_includes(conf_ctx, service->name, num_includes,
+                                   (const char **)includes);
+        if (!SBC_ERROR_IS_OK(err)) {
+                goto done;
+        }
+
+        err = SBC_ERR_OK;
 done:
         TALLOC_FREE(mem_ctx);
-        return werr;
+        return err;
 }
 
@@ -257 +265 @@
                          int argc, const char **argv)
 {
-        WERROR werr = WERR_OK;
+        sbcErr err;
         int ret = -1;
         TALLOC_CTX *mem_ctx;
@@ -271 +279 @@
         }
 
-        werr = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &shares);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &shares);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error getting config: %s\n"),
-                          win_errstr(werr));
+                          sbcErrorString(err));
                 goto done;
         }
@@ -312 +320 @@
         TALLOC_CTX *mem_ctx;
         struct smbconf_ctx *txt_ctx;
-        WERROR werr;
+        sbcErr err;
 
         if (c->display_usage)
@@ -344 +352 @@
         }
 
-        werr = smbconf_init(mem_ctx, &txt_ctx, conf_source);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_init(mem_ctx, &txt_ctx, conf_source);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error loading file '%s': %s\n"), filename,
-                         win_errstr(werr));
+                         sbcErrorString(err));
                 goto done;
         }
@@ -359 +367 @@
                 struct smbconf_service *service = NULL;
 
-                werr = smbconf_get_share(txt_ctx, mem_ctx,
-                                         servicename,
-                                         &service);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_get_share(txt_ctx, mem_ctx,
+                                        servicename,
+                                        &service);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto cancel;
                 }
 
-                werr = smbconf_transaction_start(conf_ctx);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_transaction_start(conf_ctx);
+                if (!SBC_ERROR_IS_OK(err)) {
                         d_printf(_("error starting transaction: %s\n"),
-                                 win_errstr(werr));
+                                 sbcErrorString(err));
                         goto done;
                 }
 
-                werr = import_process_service(c, conf_ctx, service);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = import_process_service(c, conf_ctx, service);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto cancel;
                 }
@@ -381 +389 @@
                 uint32_t num_shares, sidx;
 
-                werr = smbconf_get_config(txt_ctx, mem_ctx,
+                err = smbconf_get_config(txt_ctx, mem_ctx,
                                           &num_shares,
                                           &services);
-                if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto cancel;
                 }
                 if (!c->opt_testmode) {
-                        werr = smbconf_drop(conf_ctx);
-                        if (!W_ERROR_IS_OK(werr)) {
+                        if (!SBC_ERROR_IS_OK(smbconf_drop(conf_ctx))) {
                                 goto cancel;
                         }
@@ -396 +403 @@
                 /*
                  * Wrap the importing of shares into a transaction,
-                 * but only 100 at a time, in order to serve memory.
+                 * but only 100 at a time, in order to save memory.
                  * The allocated memory accumulates across the actions
                  * within the transaction, and for me, some 1500
@@ -402 +409 @@
                  * was exceeded.
                  */
-                werr = smbconf_transaction_start(conf_ctx);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_transaction_start(conf_ctx);
+                if (!SBC_ERROR_IS_OK(err)) {
                         d_printf(_("error starting transaction: %s\n"),
-                                 win_errstr(werr));
+                                 sbcErrorString(err));
                         goto done;
                 }
 
                 for (sidx = 0; sidx < num_shares; sidx++) {
-                        werr = import_process_service(c, conf_ctx,
-                                                      services[sidx]);
-                        if (!W_ERROR_IS_OK(werr)) {
+                        err = import_process_service(c, conf_ctx,
+                                                     services[sidx]);
+                        if (!SBC_ERROR_IS_OK(err)) {
                                 goto cancel;
                         }
@@ -420 +427 @@
                         }
 
-                        werr = smbconf_transaction_commit(conf_ctx);
-                        if (!W_ERROR_IS_OK(werr)) {
+                        err = smbconf_transaction_commit(conf_ctx);
+                        if (!SBC_ERROR_IS_OK(err)) {
                                 d_printf(_("error committing transaction: "
                                            "%s\n"),
-                                         win_errstr(werr));
+                                         sbcErrorString(err));
                                 goto done;
                         }
-                        werr = smbconf_transaction_start(conf_ctx);
-                        if (!W_ERROR_IS_OK(werr)) {
+                        err = smbconf_transaction_start(conf_ctx);
+                        if (!SBC_ERROR_IS_OK(err)) {
                                 d_printf(_("error starting transaction: %s\n"),
-                                         win_errstr(werr));
+                                         sbcErrorString(err));
                                 goto done;
                         }
@@ -436 +443 @@
         }
 
-        werr = smbconf_transaction_commit(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_commit(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error committing transaction: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
         } else {
                 ret = 0;
@@ -447 +454 @@
 
 cancel:
-        werr = smbconf_transaction_cancel(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_cancel(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error cancelling transaction: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
         }
 
@@ -462 +469 @@
                                const char **argv)
 {
-        WERROR werr = WERR_OK;
+        sbcErr err;
         int ret = -1;
         uint32_t count, num_shares = 0;
@@ -475 +482 @@
         }
 
-        werr = smbconf_get_share_names(conf_ctx, mem_ctx, &num_shares,
-                                       &share_names);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_get_share_names(conf_ctx, mem_ctx, &num_shares,
+                                      &share_names);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
         }
@@ -497 +504 @@
 {
         int ret = -1;
-        WERROR werr;
+        sbcErr err;
 
         if (argc != 0 || c->display_usage) {
@@ -504 +511 @@
         }
 
-        werr = smbconf_drop(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_drop(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error deleting configuration: %s\n"),
-                          win_errstr(werr));
+                          sbcErrorString(err));
                 goto done;
         }
@@ -522 +529 @@
 {
         int ret = -1;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         const char *sharename = NULL;
         TALLOC_CTX *mem_ctx;
@@ -541 +548 @@
         }
 
-        werr = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error getting share parameters: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
                 goto done;
         }
@@ -573 +580 @@
 {
         int ret = -1;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         char *sharename = NULL;
         const char *path = NULL;
@@ -579 +586 @@
         const char *guest_ok = "no";
         const char *writeable = "no";
-        SMB_STRUCT_STAT sbuf;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
 
@@ -679 +685 @@
         }
 
-        if (sys_stat(path, &sbuf, false) != 0) {
-                d_fprintf(stderr,
-                          _("ERROR: cannot stat path '%s' to ensure "
-                            "this is a directory.\n"
-                            "Error was '%s'.\n"),
-                          path, strerror(errno));
-                goto done;
-        }
-
-        if (!S_ISDIR(sbuf.st_ex_mode)) {
-                d_fprintf(stderr,
-                          _("ERROR: path '%s' is not a directory.\n"),
-                          path);
-                goto done;
-        }
-
         /*
          * start a transaction
          */
 
-        werr = smbconf_transaction_start(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_start(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf("error starting transaction: %s\n",
-                         win_errstr(werr));
+                         sbcErrorString(err));
                 goto done;
         }
@@ -710 +700 @@
          */
 
-        werr = smbconf_create_share(conf_ctx, sharename);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_create_share(conf_ctx, sharename);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error creating share %s: %s\n"),
-                          sharename, win_errstr(werr));
+                          sharename, sbcErrorString(err));
                 goto cancel;
         }
@@ -721 +711 @@
          */
 
-        werr = smbconf_set_parameter(conf_ctx, sharename, "path", path);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_parameter(conf_ctx, sharename, "path", path);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
-                          "path", win_errstr(werr));
+                          "path", sbcErrorString(err));
                 goto cancel;
         }
 
         if (comment != NULL) {
-                werr = smbconf_set_parameter(conf_ctx, sharename, "comment",
-                                             comment);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_set_parameter(conf_ctx, sharename, "comment",
+                                            comment);
+                if (!SBC_ERROR_IS_OK(err)) {
                         d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
-                                  "comment", win_errstr(werr));
+                                  "comment", sbcErrorString(err));
                         goto cancel;
                 }
         }
 
-        werr = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
-                          "'guest ok'", win_errstr(werr));
+                          "'guest ok'", sbcErrorString(err));
                 goto cancel;
         }
 
-        werr = smbconf_set_parameter(conf_ctx, sharename, "writeable",
-                                     writeable);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_parameter(conf_ctx, sharename, "writeable",
+                                    writeable);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
-                          "writeable", win_errstr(werr));
+                          "writeable", sbcErrorString(err));
                 goto cancel;
         }
@@ -757 +747 @@
          */
 
-        werr = smbconf_transaction_commit(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_commit(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf("error committing transaction: %s\n",
-                         win_errstr(werr));
+                         sbcErrorString(err));
         } else {
                 ret = 0;
@@ -768 +758 @@
 
 cancel:
-        werr = smbconf_transaction_cancel(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_cancel(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf("error cancelling transaction: %s\n",
-                         win_errstr(werr));
+                         sbcErrorString(err));
         }
 
@@ -785 +775 @@
         int ret = -1;
         const char *sharename = NULL;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
 
@@ -798 +788 @@
         }
 
-        werr = smbconf_delete_share(conf_ctx, sharename);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_delete_share(conf_ctx, sharename);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error deleting share %s: %s\n"),
-                          sharename, win_errstr(werr));
+                          sharename, sbcErrorString(err));
                 goto done;
         }
@@ -815 +805 @@
 {
         int ret = -1;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         char *service = NULL;
         char *param = NULL;
@@ -843 +833 @@
         value_str = argv[2];
 
-        werr = smbconf_transaction_start(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_start(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error starting transaction: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
                 goto done;
         }
 
         if (!smbconf_share_exists(conf_ctx, service)) {
-                werr = smbconf_create_share(conf_ctx, service);
-                if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_create_share(conf_ctx, service);
+                if (!SBC_ERROR_IS_OK(err)) {
                         d_fprintf(stderr, _("Error creating share '%s': %s\n"),
-                                  service, win_errstr(werr));
+                                  service, sbcErrorString(err));
                         goto cancel;
                 }
         }
 
-        werr = smbconf_set_parameter(conf_ctx, service, param, value_str);
-
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_parameter(conf_ctx, service, param, value_str);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error setting value '%s': %s\n"),
-                          param, win_errstr(werr));
+                          param, sbcErrorString(err));
                 goto cancel;
         }
 
-        werr = smbconf_transaction_commit(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_commit(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error committing transaction: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
         } else {
                 ret = 0;
@@ -878 +867 @@
 
 cancel:
-        werr = smbconf_transaction_cancel(conf_ctx);
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_transaction_cancel(conf_ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 d_printf(_("error cancelling transaction: %s\n"),
-                         win_errstr(werr));
+                         sbcErrorString(err));
         }
 
@@ -893 +882 @@
 {
         int ret = -1;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         char *service = NULL;
         char *param = NULL;
@@ -922 +911 @@
         }
 
-        werr = smbconf_get_parameter(conf_ctx, mem_ctx, service, param, &valstr);
-
-        if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
+        err = smbconf_get_parameter(conf_ctx, mem_ctx, service, param, &valstr);
+        if (SBC_ERROR_EQUAL(err, SBC_ERR_NO_SUCH_SERVICE)) {
                 d_fprintf(stderr,
                           _("Error: given service '%s' does not exist.\n"),
                           service);
                 goto done;
-        } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
+        } else if (SBC_ERROR_EQUAL(err, SBC_ERR_INVALID_PARAM)) {
                 d_fprintf(stderr,
                           _("Error: given parameter '%s' is not set.\n"),
                           param);
                 goto done;
-        } else if (!W_ERROR_IS_OK(werr)) {
+        } else if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error getting value '%s': %s.\n"),
-                          param, win_errstr(werr));
+                          param, sbcErrorString(err));
                 goto done;
         }
@@ -952 +940 @@
 {
         int ret = -1;
-        WERROR werr = WERR_OK;
+        sbcErr err;
         char *service = NULL;
         char *param = NULL;
@@ -978 +966 @@
         }
 
-        werr = smbconf_delete_parameter(conf_ctx, service, param);
-
-        if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
+        err = smbconf_delete_parameter(conf_ctx, service, param);
+        if (SBC_ERROR_EQUAL(err, SBC_ERR_NO_SUCH_SERVICE)) {
                 d_fprintf(stderr,
                           _("Error: given service '%s' does not exist.\n"),
                           service);
                 goto done;
-        } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
+        } else if (SBC_ERROR_EQUAL(err, SBC_ERR_INVALID_PARAM)) {
                 d_fprintf(stderr,
                           _("Error: given parameter '%s' is not set.\n"),
                           param);
                 goto done;
-        } else if (!W_ERROR_IS_OK(werr)) {
+        } else if (!SBC_ERROR_IS_OK(err)) {
                 d_fprintf(stderr, _("Error deleting value '%s': %s.\n"),
-                          param, win_errstr(werr));
+                          param, sbcErrorString(err));
                 goto done;
         }
@@ -1007 +994 @@
                                 int argc, const char **argv)
 {
-        WERROR werr;
+        sbcErr err;
         uint32_t num_includes;
         uint32_t count;
@@ -1026 +1013 @@
         }
 
-        werr = smbconf_get_includes(conf_ctx, mem_ctx, service,
+        err = smbconf_get_includes(conf_ctx, mem_ctx, service,
                                     &num_includes, &includes);
-        if (!W_ERROR_IS_OK(werr)) {
-                d_printf(_("error getting includes: %s\n"), win_errstr(werr));
+        if (!SBC_ERROR_IS_OK(err)) {
+                d_printf(_("error getting includes: %s\n"), sbcErrorString(err));
                 goto done;
         }
@@ -1048 +1035 @@
                                 int argc, const char **argv)
 {
-        WERROR werr;
+        sbcErr err;
         char *service;
         uint32_t num_includes;
@@ -1073 +1060 @@
         }
 
-        werr = smbconf_set_includes(conf_ctx, service, num_includes, includes);
-        if (!W_ERROR_IS_OK(werr)) {
-                d_printf(_("error setting includes: %s\n"), win_errstr(werr));
+        err = smbconf_set_includes(conf_ctx, service, num_includes, includes);
+        if (!SBC_ERROR_IS_OK(err)) {
+                d_printf(_("error setting includes: %s\n"), sbcErrorString(err));
                 goto done;
         }
@@ -1090 +1077 @@
                                 int argc, const char **argv)
 {
-        WERROR werr;
+        sbcErr err;
         char *service;
         int ret = -1;
@@ -1106 +1093 @@
         }
 
-        werr = smbconf_delete_includes(conf_ctx, service);
-        if (!W_ERROR_IS_OK(werr)) {
-                d_printf(_("error deleting includes: %s\n"), win_errstr(werr));
+        err = smbconf_delete_includes(conf_ctx, service);
+        if (!SBC_ERROR_IS_OK(err)) {
+                d_printf(_("error deleting includes: %s\n"), sbcErrorString(err));
                 goto done;
         }
@@ -1137 +1124 @@
                                   int argc, const char **argv)
 {
-        WERROR werr;
+        sbcErr err;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
         struct smbconf_ctx *conf_ctx;
         int ret = -1;
 
-        werr = smbconf_init(mem_ctx, &conf_ctx, "registry:");
-
-        if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_init(mem_ctx, &conf_ctx, "registry:");
+        if (!SBC_ERROR_IS_OK(err)) {
                 return -1;
         }

vendor/current/source3/utils/net_dns.c

@@ -1 @@
-
 /* 
    Samba Unix/Linux Dynamic DNS Update
@@ -11 +10 @@
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  
@@ -23 +22 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "dns.h"
+#include "../lib/addns/dns.h"
 
 #if defined(WITH_DNS_UPDATES)
-
 /*
  * Silly prototype to get rid of a warning
@@ -56 +54 @@
                 return ERROR_DNS_NO_MEMORY;
         }
-                
+
         err = dns_open_connection( pszServerName, DNS_TCP, mem_ctx, &conn );
         if (!ERR_DNS_IS_OK(err)) {
@@ -115 +113 @@
                                                      DNS_SRV_WIN2000 );
                 }
-                
+
                 if (!ERR_DNS_IS_OK(err))
                         goto error;
-                
 
                 err = dns_sign_update(req, gss_context, keyname,

vendor/current/source3/utils/net_dom.c

@@ -20 +20 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_initshutdown.h"
+#include "../librpc/gen_ndr/ndr_initshutdown.h"
+#include "../librpc/gen_ndr/ndr_winreg.h"
+#include "lib/netapi/netapi.h"
+#include "lib/netapi/netapi_net.h"
+#include "libsmb/libsmb.h"
 
 int net_dom_usage(struct net_context *c, int argc, const char **argv)
@@ -371 +375 @@
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;

vendor/current/source3/utils/net_eventlog.c

@@ -22 +22 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "lib/eventlog/eventlog.h"
 
 /**
@@ -55 +56 @@
         }
 
-        ndr_err = ndr_pull_struct_blob(&blob, ctx, NULL, &evt,
+        ndr_err = ndr_pull_struct_blob(&blob, ctx, &evt,
                    (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_EVT_FILE);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -113 +114 @@
 
         /* dump_data(0, blob.data, blob.length); */
-        ndr_err = ndr_pull_struct_blob(&blob, ctx, NULL, &evt_header,
+        ndr_err = ndr_pull_struct_blob(&blob, ctx, &evt_header,
                    (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGHEADER);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -126 +127 @@
         }
 
-        ndr_err = ndr_pull_struct_blob(&blob, ctx, NULL, &evt,
+        ndr_err = ndr_pull_struct_blob(&blob, ctx, &evt,
                    (ndr_pull_flags_fn_t)ndr_pull_EVENTLOG_EVT_FILE);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {

vendor/current/source3/utils/net_g_lock.c

@@ -21 +21 @@
 #include "net.h"
 #include "g_lock.h"
+#include "messages.h"
 
 static bool net_g_lock_init(TALLOC_CTX *mem_ctx,
@@ -31 +32 @@
         struct g_lock_ctx *g_ctx = NULL;
 
-        ev = tevent_context_init(talloc_tos());
+        ev = tevent_context_init(mem_ctx);
         if (ev == NULL) {
                 d_fprintf(stderr, "ERROR: could not init event context\n");
                 goto fail;
         }
-        msg = messaging_init(talloc_tos(), server_id_self(), ev);
+        msg = messaging_init(mem_ctx, procid_self(), ev);
         if (msg == NULL) {
                 d_fprintf(stderr, "ERROR: could not init messaging context\n");
                 goto fail;
         }
-        g_ctx = g_lock_ctx_init(talloc_tos(), msg);
+        g_ctx = g_lock_ctx_init(mem_ctx, msg);
         if (g_ctx == NULL) {
                 d_fprintf(stderr, "ERROR: could not init g_lock context\n");
@@ -91 +92 @@
         status = g_lock_do(name, G_LOCK_WRITE,
                            timeval_set(timeout / 1000, timeout % 1000),
-                           net_g_lock_do_fn, &state);
+                           procid_self(), net_g_lock_do_fn, &state);
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "ERROR: g_lock_do failed: %s\n",

vendor/current/source3/utils/net_group.c

@@ -64 +64 @@
                 return net_ads_group(c, argc, argv);
 
-        if (argc == 0 && net_rpc_check(c, NET_FLAGS_PDC))
-                return net_rpc_group(c,argc, argv);
-
         return net_rap_group(c, argc, argv);
 }

vendor/current/source3/utils/net_groupmap.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "system/passwd.h"
 #include "utils/net.h"
+#include "../libcli/security/security.h"
+#include "passdb.h"
 
 /*********************************************************
@@ -29 +32 @@
  Return the SID.
 **********************************************************/
-static bool get_sid_from_input(DOM_SID *sid, char *input)
+static bool get_sid_from_input(struct dom_sid *sid, char *input)
 {
         GROUP_MAP map;
@@ -124 +127 @@
         /* list a single group is given a name */
         if ( ntgroup[0] || sid_string[0] ) {
-                DOM_SID sid;
+                struct dom_sid sid;
                 GROUP_MAP map;
 
@@ -166 +169 @@
 static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         fstring ntgroup = "";
         fstring unixgrp = "";
@@ -201 +204 @@
                 if ( !StrnCaseCmp(argv[i], "rid", strlen("rid")) ) {
                         rid = get_int_param(argv[i]);
-                        if ( rid < DOMAIN_GROUP_RID_ADMINS ) {
+                        if ( rid < DOMAIN_RID_ADMINS ) {
                                 d_fprintf(stderr,
                                           _("RID must be greater than %d\n"),
-                                          (uint32)DOMAIN_GROUP_RID_ADMINS-1);
+                                          (uint32)DOMAIN_RID_ADMINS-1);
                                 return -1;
                         }
@@ -300 +303 @@
         /* append the rid to our own domain/machine SID if we don't have a full SID */
         if ( !string_sid[0] ) {
-                sid_copy(&sid, get_global_sam_sid());
-                sid_append_rid(&sid, rid);
+                sid_compose(&sid, get_global_sam_sid(), rid);
                 sid_to_fstring(string_sid, &sid);
         }
@@ -337 +339 @@
 static int net_groupmap_modify(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         GROUP_MAP map;
         fstring ntcomment = "";
@@ -485 +487 @@
 static int net_groupmap_delete(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         fstring ntgroup = "";
         fstring sid_string = "";
@@ -582 +584 @@
 
         if (!have_map) {
-                DOM_SID sid;
+                struct dom_sid sid;
                 have_map = ( (strncmp(ntgroup, "S-", 2) == 0) &&
                              string_to_sid(&sid, ntgroup) &&
@@ -613 +615 @@
                 }
 
-                sid_copy(&map.sid, get_global_sam_sid());
-                sid_append_rid(&map.sid, c->opt_rid);
+                sid_compose(&map.sid, get_global_sam_sid(), c->opt_rid);
 
                 map.sid_name_use = SID_NAME_DOM_GRP;
@@ -708 +709 @@
 static int net_groupmap_addmem(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID alias, member;
+        struct dom_sid alias, member;
 
         if ( (argc != 2) ||
@@ -731 +732 @@
 static int net_groupmap_delmem(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID alias, member;
+        struct dom_sid alias, member;
 
         if ( (argc != 2) ||
@@ -754 +755 @@
 static int net_groupmap_listmem(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID alias;
-        DOM_SID *members;
+        struct dom_sid alias;
+        struct dom_sid *members;
         size_t i, num;
 
@@ -787 +788 @@
 
 static bool print_alias_memberships(TALLOC_CTX *mem_ctx,
-                                    const DOM_SID *domain_sid,
-                                    const DOM_SID *member)
+                                    const struct dom_sid *domain_sid,
+                                    const struct dom_sid *member)
 {
         uint32 *alias_rids;
@@ -805 +806 @@
 
         for (i = 0; i < num_alias_rids; i++) {
-                DOM_SID alias;
-                sid_copy(&alias, domain_sid);
-                sid_append_rid(&alias, alias_rids[i]);
+                struct dom_sid alias;
+                sid_compose(&alias, domain_sid, alias_rids[i]);
                 printf("%s\n", sid_string_tos(&alias));
         }
@@ -817 +817 @@
 {
         TALLOC_CTX *mem_ctx;
-        DOM_SID *domain_sid, *builtin_sid, member;
+        struct dom_sid *domain_sid, member;
 
         if ( (argc != 1) ||
@@ -835 +835 @@
 
         domain_sid = get_global_sam_sid();
-        builtin_sid = string_sid_talloc(mem_ctx, "S-1-5-32");
-        if ((domain_sid == NULL) || (builtin_sid == NULL)) {
+        if (domain_sid == NULL) {
                 d_fprintf(stderr, _("Could not get domain sid\n"));
                 return -1;
@@ -842 +841 @@
 
         if (!print_alias_memberships(mem_ctx, domain_sid, &member) ||
-            !print_alias_memberships(mem_ctx, builtin_sid, &member))
+            !print_alias_memberships(mem_ctx, &global_sid_Builtin, &member))
                 return -1;
 

vendor/current/source3/utils/net_idmap.c

@@ -18 +18 @@
 */
 
-#define FOO(x) (x)
 #include "includes.h"
+#include "system/filesys.h"
 #include "utils/net.h"
+#include "secrets.h"
+#include "idmap.h"
+#include "dbwrap.h"
+#include "../libcli/security/security.h"
+#include "net_idmap_check.h"
+#include "util_tdb.h"
 
 #define ALLOC_CHECK(mem) do { \
@@ -32 +38 @@
  Helper function for net_idmap_dump. Dump one entry.
  **********************************************************/
-static int net_idmap_dump_one_entry(TDB_CONTEXT *tdb,
-                                    TDB_DATA key,
-                                    TDB_DATA data,
+static int net_idmap_dump_one_entry(struct db_record *rec,
                                     void *unused)
 {
-        if (strcmp((char *)key.dptr, "USER HWM") == 0) {
-                printf(_("USER HWM %d\n"), IVAL(data.dptr,0));
+        if (strcmp((char *)rec->key.dptr, "USER HWM") == 0) {
+                printf(_("USER HWM %d\n"), IVAL(rec->value.dptr,0));
                 return 0;
         }
 
-        if (strcmp((char *)key.dptr, "GROUP HWM") == 0) {
-                printf(_("GROUP HWM %d\n"), IVAL(data.dptr,0));
+        if (strcmp((char *)rec->key.dptr, "GROUP HWM") == 0) {
+                printf(_("GROUP HWM %d\n"), IVAL(rec->value.dptr,0));
                 return 0;
         }
 
-        if (strncmp((char *)key.dptr, "S-", 2) != 0)
+        if (strncmp((char *)rec->key.dptr, "S-", 2) != 0)
                 return 0;
 
-        printf("%s %s\n", data.dptr, key.dptr);
+        printf("%s %s\n", rec->value.dptr, rec->key.dptr);
         return 0;
+}
+
+static const char* net_idmap_dbfile(struct net_context *c)
+{
+        const char* dbfile = NULL;
+
+        if (c->opt_db != NULL) {
+                dbfile = talloc_strdup(talloc_tos(), c->opt_db);
+                if (dbfile == NULL) {
+                        d_fprintf(stderr, _("Out of memory!\n"));
+                }
+        } else if (strequal(lp_idmap_backend(), "tdb")) {
+                dbfile = state_path("winbindd_idmap.tdb");
+                if (dbfile == NULL) {
+                        d_fprintf(stderr, _("Out of memory!\n"));
+                }
+        } else if (strequal(lp_idmap_backend(), "tdb2")) {
+                dbfile = lp_parm_talloc_string(-1, "tdb", "idmap2.tdb", NULL);
+                if (dbfile == NULL) {
+                        dbfile = talloc_asprintf(talloc_tos(), "%s/idmap2.tdb",
+                                                 lp_private_dir());
+                }
+                if (dbfile == NULL) {
+                        d_fprintf(stderr, _("Out of memory!\n"));
+                }
+        } else {
+                char* backend = talloc_strdup(talloc_tos(), lp_idmap_backend());
+                char* args = strchr(backend, ':');
+                if (args != NULL) {
+                        *args = '\0';
+                }
+
+                d_printf(_("Sorry, 'idmap backend = %s' is currently not supported\n"),
+                         backend);
+
+                talloc_free(backend);
+        }
+
+        return dbfile;
 }
 
@@ -59 +102 @@
 static int net_idmap_dump(struct net_context *c, int argc, const char **argv)
 {
-        TDB_CONTEXT *idmap_tdb;
-
-        if ( argc != 1  || c->display_usage) {
+        struct db_context *db;
+        TALLOC_CTX *mem_ctx;
+        const char* dbfile;
+        int ret = -1;
+
+        if ( argc > 1  || c->display_usage) {
                 d_printf("%s\n%s",
                          _("Usage:"),
-                         _("net idmap dump <inputfile>\n"
+                         _("net idmap dump [[--db=]<inputfile>]\n"
                            "  Dump current ID mapping.\n"
                            "    inputfile\tTDB file to read mappings from.\n"));
@@ -70 +116 @@
         }
 
-        idmap_tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0);
-
-        if (idmap_tdb == NULL) {
-                d_fprintf(stderr, _("Could not open idmap: %s\n"), argv[0]);
-                return -1;
-        }
-
-        tdb_traverse(idmap_tdb, net_idmap_dump_one_entry, NULL);
-
-        tdb_close(idmap_tdb);
-
-        return 0;
+        mem_ctx = talloc_stackframe();
+
+        dbfile = (argc > 0) ? argv[0] : net_idmap_dbfile(c);
+        if (dbfile == NULL) {
+                goto done;
+        }
+        d_fprintf(stderr, _("dumping id mapping from %s\n"), dbfile);
+
+        db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDONLY, 0);
+        if (db == NULL) {
+                d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
+                          dbfile, strerror(errno));
+                goto done;
+        }
+
+        db->traverse_read(db, net_idmap_dump_one_entry, NULL);
+        ret = 0;
+
+done:
+        talloc_free(mem_ctx);
+        return ret;
 }
 
@@ -88 +143 @@
  **********************************************************/
 
+static int net_idmap_store_id_mapping(struct db_context *db,
+                                      enum id_type type,
+                                      unsigned long idval,
+                                      const char *sid_string)
+{
+        NTSTATUS status;
+        char *idstr = NULL;
+
+        switch(type) {
+        case ID_TYPE_UID:
+                idstr = talloc_asprintf(talloc_tos(), "UID %lu", idval);
+                break;
+        case ID_TYPE_GID:
+                idstr = talloc_asprintf(talloc_tos(), "GID %lu", idval);
+                break;
+        default:
+                d_fprintf(stderr, "Invalid id mapping type: %d\n", type);
+                return -1;
+        }
+
+        status = dbwrap_store_bystring(db, idstr,
+                                       string_term_tdb_data(sid_string),
+                                       TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, "Error storing ID -> SID: "
+                         "%s\n", nt_errstr(status));
+                talloc_free(idstr);
+                return -1;
+        }
+        status = dbwrap_store_bystring(db, sid_string,
+                                       string_term_tdb_data(idstr),
+                                       TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, "Error storing SID -> ID: "
+                         "%s\n", nt_errstr(status));
+                talloc_free(idstr);
+                return -1;
+        }
+
+        return 0;
+}
+
 static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
 {
-        TALLOC_CTX *ctx;
-        FILE *input;
+        TALLOC_CTX *mem_ctx;
+        FILE *input = NULL;
+        struct db_context *db;
+        const char *dbfile = NULL;
+        int ret = 0;
 
         if (c->display_usage) {
                 d_printf("%s\n%s",
                          _("Usage:"),
-                         _("net idmap restore [inputfile]\n"
+                         _("net idmap restore [--db=<TDB>] [<inputfile>]\n"
                            "  Restore ID mappings from file\n"
-                           "    inputfile\tFile to load ID mappings from. If "
-                           "not given, load data from stdin.\n"));
+                           "    TDB\tFile to store ID mappings to."
+                           "    inputfile\tFile to load ID mappings from. If not "
+                           "given, load data from stdin.\n"));
                 return 0;
         }
 
-        if (! winbind_ping()) {
-                d_fprintf(stderr,
-                          _("To use net idmap Winbindd must be running.\n"));
-                return -1;
-        }
-
-        ctx = talloc_new(NULL);
-        ALLOC_CHECK(ctx);
+        mem_ctx = talloc_stackframe();
+
+        dbfile = net_idmap_dbfile(c);
+
+        if (dbfile == NULL) {
+                ret = -1;
+                goto done;
+        }
+
+        d_fprintf(stderr, _("restoring id mapping to %s\n"), dbfile);
 
         if (argc == 1) {
                 input = fopen(argv[0], "r");
+                if (input == NULL) {
+                        d_fprintf(stderr, _("Could not open input file (%s): %s\n"),
+                                  argv[0], strerror(errno));
+                        ret = -1;
+                        goto done;
+                }
         } else {
                 input = stdin;
+        }
+
+        db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0644);
+        if (db == NULL) {
+                d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
+                          dbfile, strerror(errno));
+                ret = -1;
+                goto done;
+        }
+
+        if (db->transaction_start(db) != 0) {
+                d_fprintf(stderr, _("Failed to start transaction.\n"));
+                ret = -1;
+                goto done;
         }
 
@@ -121 +244 @@
                 char line[128], sid_string[128];
                 int len;
-                struct wbcDomainSid sid;
-                enum id_type type = ID_TYPE_NOT_SPECIFIED;
                 unsigned long idval;
-                wbcErr wbc_status;
 
                 if (fgets(line, 127, input) == NULL)
@@ -134 +254 @@
                         line[len-1] = '\0';
 
-                if (sscanf(line, "GID %lu %128s", &idval, sid_string) == 2) {
-                        type = ID_TYPE_GID;
-                } else if (sscanf(line, "UID %lu %128s", &idval, sid_string) == 2) {
-                        type = ID_TYPE_UID;
+                if (sscanf(line, "GID %lu %128s", &idval, sid_string) == 2)
+                {
+                        ret = net_idmap_store_id_mapping(db, ID_TYPE_GID,
+                                                         idval, sid_string);
+                        if (ret != 0) {
+                                break;
+                        }
+                } else if (sscanf(line, "UID %lu %128s", &idval, sid_string) == 2)
+                {
+                        ret = net_idmap_store_id_mapping(db, ID_TYPE_UID,
+                                                         idval, sid_string);
+                        if (ret != 0) {
+                                break;
+                        }
                 } else if (sscanf(line, "USER HWM %lu", &idval) == 1) {
-                        /* set uid hwm */
-                        wbc_status = wbcSetUidHwm(idval);
-                        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                        ret = dbwrap_store_int32(db, "USER HWM", idval);
+                        if (ret != 0) {
+                                d_fprintf(stderr, _("Could not store USER HWM.\n"));
+                                break;
+                        }
+                } else if (sscanf(line, "GROUP HWM %lu", &idval) == 1) {
+                        ret = dbwrap_store_int32(db, "GROUP HWM", idval);
+                        if (ret != 0) {
                                 d_fprintf(stderr,
-                                          _("Could not set USER HWM: %s\n"),
-                                          wbcErrorString(wbc_status));
+                                          _("Could not store GROUP HWM.\n"));
+                                break;
                         }
-                        continue;
-                } else if (sscanf(line, "GROUP HWM %lu", &idval) == 1) {
-                        /* set gid hwm */
-                        wbc_status = wbcSetGidHwm(idval);
-                        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                                d_fprintf(stderr,
-                                          _("Could not set GROUP HWM: %s\n"),
-                                          wbcErrorString(wbc_status));
-                        }
-                        continue;
                 } else {
                         d_fprintf(stderr, _("ignoring invalid line [%s]\n"),
@@ -161 +286 @@
                         continue;
                 }
-
-                wbc_status = wbcStringToSid(sid_string, &sid);
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        d_fprintf(stderr, _("ignoring invalid sid [%s]: %s\n"),
-                                  sid_string, wbcErrorString(wbc_status));
-                        continue;
-                }
-
-                if (type == ID_TYPE_UID) {
-                        wbc_status = wbcSetUidMapping(idval, &sid);
-                } else {
-                        wbc_status = wbcSetGidMapping(idval, &sid);
-                }
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        d_fprintf(stderr,
-                                  _("Could not set mapping of %s %lu to sid %s: %s\n"),
-                                 (type == ID_TYPE_GID) ? "GID" : "UID",
-                                 idval, sid_string,
-                                 wbcErrorString(wbc_status));
-                        continue;
-                }
-        }
-
-        if (input != stdin) {
+        }
+
+        if (ret == 0) {
+                if(db->transaction_commit(db) != 0) {
+                        d_fprintf(stderr, _("Failed to commit transaction.\n"));
+                        ret = -1;
+                }
+        } else {
+                if (db->transaction_cancel(db) != 0) {
+                        d_fprintf(stderr, _("Failed to cancel transaction.\n"));
+                }
+        }
+
+done:
+        if ((input != NULL) && (input != stdin)) {
                 fclose(input);
         }
 
-        talloc_free(ctx);
-        return 0;
+        talloc_free(mem_ctx);
+        return ret;
+}
+
+static
+NTSTATUS dbwrap_delete_mapping(struct db_context *db, TDB_DATA key1, bool force)
+{
+        TALLOC_CTX* mem_ctx = talloc_tos();
+        struct db_record *rec1=NULL, *rec2=NULL;
+        TDB_DATA key2;
+        bool is_valid_mapping;
+        NTSTATUS status = NT_STATUS_OK;
+
+        rec1 = db->fetch_locked(db, mem_ctx, key1);
+        if (rec1 == NULL) {
+                DEBUG(1, ("failed to fetch: %.*s\n", (int)key1.dsize, key1.dptr));
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        key2 = rec1->value;
+        if (key2.dptr == NULL) {
+                DEBUG(1, ("could not find %.*s\n", (int)key1.dsize, key1.dptr));
+                status = NT_STATUS_NOT_FOUND;
+                goto done;
+        }
+
+        DEBUG(2, ("mapping: %.*s -> %.*s\n",
+                  (int)key1.dsize, key1.dptr, (int)key2.dsize, key2.dptr));
+
+        rec2 = db->fetch_locked(db, mem_ctx, key2);
+        if (rec2 == NULL) {
+                DEBUG(1, ("failed to fetch: %.*s\n", (int)key2.dsize, key2.dptr));
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        is_valid_mapping = tdb_data_equal(key1, rec2->value);
+
+        if (!is_valid_mapping) {
+                DEBUG(1, ("invalid mapping: %.*s -> %.*s -> %.*s\n",
+                          (int)key1.dsize, key1.dptr, (int)key2.dsize, key2.dptr,
+                          (int)rec2->value.dsize, rec2->value.dptr ));
+                if ( !force ) {
+                        status = NT_STATUS_FILE_INVALID;
+                        goto done;
+                }
+        }
+
+        status = rec1->delete_rec(rec1);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("failed to delete: %.*s\n", (int)key1.dsize, key1.dptr));
+                goto done;
+        }
+
+        if (is_valid_mapping) {
+                status = rec2->delete_rec(rec2);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("failed to delete: %.*s\n", (int)key2.dsize, key2.dptr));
+                }
+        }
+done:
+        TALLOC_FREE(rec1);
+        TALLOC_FREE(rec2);
+        return status;
+}
+
+static
+NTSTATUS delete_mapping_action(struct db_context *db, void* data)
+{
+        return dbwrap_delete_mapping(db, *(TDB_DATA*)data, false);
+}
+static
+NTSTATUS delete_mapping_action_force(struct db_context *db, void* data)
+{
+        return dbwrap_delete_mapping(db, *(TDB_DATA*)data, true);
 }
 
@@ -195 +384 @@
  Delete a SID mapping from a winbindd_idmap.tdb
  **********************************************************/
+static bool delete_args_ok(int argc, const char **argv)
+{
+        if (argc != 1)
+                return false;
+        if (strncmp(argv[0], "S-", 2) == 0)
+                return true;
+        if (strncmp(argv[0], "GID ", 4) == 0)
+                return true;
+        if (strncmp(argv[0], "UID ", 4) == 0)
+                return true;
+        return false;
+}
+
 static int net_idmap_delete(struct net_context *c, int argc, const char **argv)
+{
+        int ret = -1;
+        struct db_context *db;
+        TALLOC_CTX *mem_ctx;
+        TDB_DATA key;
+        NTSTATUS status;
+        const char* dbfile;
+
+        if ( !delete_args_ok(argc,argv) || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net idmap delete [-f] [--db=<TDB>] <ID>\n"
+                           "  Delete mapping of ID from TDB.\n"
+                           "    -f\tforce\n"
+                           "    TDB\tidmap database\n"
+                           "    ID\tSID|GID|UID\n"));
+                return c->display_usage ? 0 : -1;
+        }
+
+        mem_ctx = talloc_stackframe();
+
+        dbfile = net_idmap_dbfile(c);
+        if (dbfile == NULL) {
+                goto done;
+        }
+        d_fprintf(stderr, _("deleting id mapping from %s\n"), dbfile);
+
+        db = db_open(mem_ctx, dbfile, 0, TDB_DEFAULT, O_RDWR, 0);
+        if (db == NULL) {
+                d_fprintf(stderr, _("Could not open idmap db (%s): %s\n"),
+                          dbfile, strerror(errno));
+                goto done;
+        }
+
+        key = string_term_tdb_data(argv[0]);
+
+        status = dbwrap_trans_do(db, (c->opt_force
+                                      ? delete_mapping_action_force
+                                      : delete_mapping_action),  &key);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("could not delete mapping: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        ret = 0;
+done:
+        talloc_free(mem_ctx);
+        return ret;
+}
+
+static int net_idmap_set(struct net_context *c, int argc, const char **argv)
 {
         d_printf("%s\n", _("Not implemented yet"));
         return -1;
 }
-
-static int net_idmap_set(struct net_context *c, int argc, const char **argv)
-{
-        d_printf("%s\n", _("Not implemented yet"));
-        return -1;
-}
-bool idmap_store_secret(const char *backend, bool alloc,
-                        const char *domain, const char *identity,
-                        const char *secret)
+static bool idmap_store_secret(const char *backend,
+                               const char *domain,
+                               const char *identity,
+                               const char *secret)
 {
         char *tmp;
@@ -214 +463 @@
         bool ret;
 
-        if (alloc) {
-                r = asprintf(&tmp, "IDMAP_ALLOC_%s", backend);
-        } else {
-                r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
-        }
+        r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
 
         if (r < 0) return false;
@@ -242 +487 @@
         if (argc != 2 || c->display_usage) {
                 d_printf("%s\n%s",
-                         _("Usage:"),
-                         _("net idmap secret {<DOMAIN>|alloc} <secret>\n"
-                           "  Set the secret for the specified domain "
-                           "(or alloc module)\n"
+                         _("Usage:\n"),
+                         _("net idmap secret <DOMAIN> <secret>\n"
+                           "  Set the secret for the specified domain\n"
                            "    DOMAIN\tDomain to set secret for.\n"
-                           "    alloc\tSet secret for the alloc module\n"
                            "    secret\tNew secret to set.\n"));
                 return c->display_usage?0:-1;
@@ -257 +500 @@
         ALLOC_CHECK(ctx);
 
-        if (strcmp(argv[0], "alloc") == 0) {
-                domain = NULL;
-                backend = lp_idmap_alloc_backend();
-        } else {
-                domain = talloc_strdup(ctx, argv[0]);
-                ALLOC_CHECK(domain);
-
-                opt = talloc_asprintf(ctx, "idmap config %s", domain);
-                ALLOC_CHECK(opt);
-
-                backend = talloc_strdup(ctx, lp_parm_const_string(-1, opt, "backend", "tdb"));
-                ALLOC_CHECK(backend);
-        }
+        domain = talloc_strdup(ctx, argv[0]);
+        ALLOC_CHECK(domain);
+
+        opt = talloc_asprintf(ctx, "idmap config %s", domain);
+        ALLOC_CHECK(opt);
+
+        backend = talloc_strdup(ctx, lp_parm_const_string(-1, opt, "backend", "tdb"));
+        ALLOC_CHECK(backend);
 
         if ( ( ! backend) || ( ! strequal(backend, "ldap"))) {
@@ -278 +516 @@
         }
 
-        if (domain) {
-
-                dn = lp_parm_const_string(-1, opt, "ldap_user_dn", NULL);
-                if ( ! dn) {
-                        d_fprintf(stderr,
-                                  _("Missing ldap_user_dn option for domain "
-                                    "%s\n"), domain);
-                        talloc_free(ctx);
-                        return -1;
-                }
-
-                ret = idmap_store_secret("ldap", false, domain, dn, secret);
-        } else {
-                dn = lp_parm_const_string(-1, "idmap alloc config", "ldap_user_dn", NULL);
-                if ( ! dn) {
-                        d_fprintf(stderr,
-                                  _("Missing ldap_user_dn option for alloc "
-                                    "backend\n"));
-                        talloc_free(ctx);
-                        return -1;
-                }
-
-                ret = idmap_store_secret("ldap", true, NULL, dn, secret);
-        }
+        dn = lp_parm_const_string(-1, opt, "ldap_user_dn", NULL);
+        if ( ! dn) {
+                d_fprintf(stderr,
+                          _("Missing ldap_user_dn option for domain %s\n"),
+                          domain);
+                talloc_free(ctx);
+                return -1;
+        }
+
+        ret = idmap_store_secret("ldap", domain, dn, secret);
 
         if ( ! ret) {
@@ -313 +537 @@
 }
 
-int net_help_idmap(struct net_context *c, int argc, const char **argv)
-{
-        d_printf(_("net idmap dump <inputfile>\n"
-                   "    Dump current id mapping\n"));
-
-        d_printf(_("net idmap restore\n"
-                   "    Restore entries from stdin\n"));
-
-        /* Deliberately *not* document net idmap delete */
-
-        d_printf(_("net idmap secret <DOMAIN>|alloc <secret>\n"
-                   "    Set the secret for the specified DOMAIN (or the alloc "
-                   "module)\n"));
-
-        return -1;
+static int net_idmap_check(struct net_context *c, int argc, const char **argv)
+{
+        const char* dbfile;
+        struct check_options opts;
+
+        if ( argc > 1 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net idmap check  [-v] [-r] [-a] [-T] [-f] [-l] [[--db=]<TDB>]\n"
+                           "  Check an idmap database.\n"
+                           "    --verbose,-v\tverbose\n"
+                           "    --repair,-r\trepair\n"
+                           "    --auto,-a\tnoninteractive mode\n"
+                           "    --test,-T\tdry run\n"
+                           "    --fore,-f\tforce\n"
+                           "    --lock,-l\tlock db while doing the check\n"
+                           "    TDB\tidmap database\n"));
+                return c->display_usage ? 0 : -1;
+        }
+
+        dbfile = (argc > 0) ? argv[0] : net_idmap_dbfile(c);
+        if (dbfile == NULL) {
+                return -1;
+        }
+        d_fprintf(stderr, _("check database: %s\n"), dbfile);
+
+        opts = (struct check_options) {
+                .lock = c->opt_lock || c->opt_long_list_entries,
+                .test = c->opt_testmode,
+                .automatic = c->opt_auto,
+                .verbose = c->opt_verbose,
+                .force = c->opt_force,
+                .repair = c->opt_repair || c->opt_reboot,
+        };
+
+        return net_idmap_check_db(dbfile, &opts);
 }
 
@@ -334 +579 @@
         TALLOC_CTX *mem_ctx;
         int result = -1;
-        DOM_SID src_sid, dst_sid;
+        struct dom_sid src_sid, dst_sid;
         char *src, *dst;
         struct db_context *db;
@@ -428 +673 @@
                         net_idmap_delete,
                         NET_TRANSPORT_LOCAL,
-                        N_("Not implemented yet"),
-                        N_("net idmap delete\n"
-                           "  Not implemented yet")
+                        N_("Delete ID mapping"),
+                        N_("net idmap delete <ID>\n"
+                           "  Delete ID mapping")
                 },
                 {
@@ -437 +682 @@
                         NET_TRANSPORT_LOCAL,
                         N_("Set secret for specified domain"),
-                        N_("net idmap secret {<DOMAIN>|alloc} <secret>\n"
-                           "  Set secret for specified domain or alloc module")
+                        N_("net idmap secret <DOMAIN> <secret>\n"
+                           "  Set secret for specified domain")
                 },
                 {
@@ -448 +693 @@
                            "  Set acl map")
                 },
+                {
+                        "check",
+                        net_idmap_check,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Check id mappings"),
+                        N_("net idmap check\n"
+                           "  Check id mappings")
+                },
                 {NULL, NULL, 0, NULL, NULL}
         };

vendor/current/source3/utils/net_lookup.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "libads/sitename_cache.h"
+#include "libads/dns.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "smb_krb5.h"
+#include "../libcli/security/security.h"
+#include "passdb/lookup_sid.h"
 
 int net_lookup_usage(struct net_context *c, int argc, const char **argv)
@@ -320 +326 @@
 {
         const char *dom, *name;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
 
@@ -344 +350 @@
 {
         const char *dom, *name;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
 
@@ -406 +412 @@
         }
 
-        status = dsgetdcname(mem_ctx, NULL, domain_name, NULL, site_name,
+        if (!c->msg_ctx) {
+                d_fprintf(stderr, _("Could not initialise message context. "
+                        "Try running as root\n"));
+                return -1;
+        }
+
+        status = dsgetdcname(mem_ctx, c->msg_ctx, domain_name, NULL, site_name,
                              flags, &info);
         if (!NT_STATUS_IS_OK(status)) {

vendor/current/source3/utils/net_proto.h

@@ -24 +24 @@
 #define _NET_PROTO_H_
 
-
-/* The following definitions come from auth/token_util.c  */
-
-bool nt_token_check_sid ( const DOM_SID *sid, const NT_USER_TOKEN *token );
-bool nt_token_check_domain_rid( NT_USER_TOKEN *token, uint32 rid );
-NT_USER_TOKEN *get_root_nt_token( void );
-NTSTATUS add_aliases(const DOM_SID *domain_sid,
-                     struct nt_user_token *token);
-struct nt_user_token *create_local_nt_token(TALLOC_CTX *mem_ctx,
-                                            const DOM_SID *user_sid,
-                                            bool is_guest,
-                                            int num_groupsids,
-                                            const DOM_SID *groupsids);
-void debug_nt_user_token(int dbg_class, int dbg_lev, NT_USER_TOKEN *token);
-void debug_unix_user_token(int dbg_class, int dbg_lev, uid_t uid, gid_t gid,
-                           int n_groups, gid_t *groups);
+#include "libads/ads_status.h"
 
 /* The following definitions come from utils/net.c  */
@@ -46 +31 @@
 
 /* The following definitions come from utils/net_ads.c  */
-
-ADS_STATUS ads_startup(struct net_context *c, bool only_own_domain, ADS_STRUCT **ads);
-ADS_STATUS ads_startup_nobind(struct net_context *c, bool only_own_domain, ADS_STRUCT **ads);
+struct ads_struct;
+ADS_STATUS ads_startup(struct net_context *c, bool only_own_domain, struct ads_struct **ads);
+ADS_STATUS ads_startup_nobind(struct net_context *c, bool only_own_domain, struct ads_struct **ads);
 int net_ads_check_our_domain(struct net_context *c);
 int net_ads_check(struct net_context *c);
@@ -103 +88 @@
 /* The following definitions come from utils/net_idmap.c  */
 
-bool idmap_store_secret(const char *backend, bool alloc,
-                        const char *domain, const char *identity,
-                        const char *secret);
-int net_help_idmap(struct net_context *c, int argc, const char **argv);
 int net_idmap(struct net_context *c, int argc, const char **argv);
 
@@ -155 +136 @@
 
 NTSTATUS net_get_remote_domain_sid(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                                   DOM_SID **domain_sid,
+                                   struct dom_sid **domain_sid,
                                    const char **domain_name);
 int run_rpc_command(struct net_context *c,
@@ -167 +148 @@
 int net_rpc_join(struct net_context *c, int argc, const char **argv);
 NTSTATUS rpc_info_internals(struct net_context *c,
-                        const DOM_SID *domain_sid,
+                        const struct dom_sid *domain_sid,
                         const char *domain_name,
                         struct cli_state *cli,
@@ -194 +175 @@
 int net_rpc_file(struct net_context *c, int argc, const char **argv);
 NTSTATUS rpc_init_shutdown_internals(struct net_context *c,
-                                     const DOM_SID *domain_sid,
+                                     const struct dom_sid *domain_sid,
                                      const char *domain_name,
                                      struct cli_state *cli,
@@ -202 +183 @@
                                      const char **argv);
 NTSTATUS rpc_reg_shutdown_internals(struct net_context *c,
-                                    const DOM_SID *domain_sid,
+                                    const struct dom_sid *domain_sid,
                                     const char *domain_name,
                                     struct cli_state *cli,
@@ -243 +224 @@
                        bool copy_timestamps, bool is_file);
 NTSTATUS rpc_printer_list_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -251 +232 @@
                                         const char **argv);
 NTSTATUS rpc_printer_driver_list_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -259 +240 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_publish_publish_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -267 +248 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_publish_unpublish_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -275 +256 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_publish_update_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -283 +264 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_publish_list_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -291 +272 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_migrate_security_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -299 +280 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_migrate_forms_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -307 +288 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_migrate_drivers_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -315 +296 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_migrate_printers_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -323 +304 @@
                                                 const char **argv);
 NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -344 +325 @@
 
 NTSTATUS rpc_samdump_internals(struct net_context *c,
-                                const DOM_SID *domain_sid,
+                                const struct dom_sid *domain_sid,
                                 const char *domain_name,
                                 struct cli_state *cli,
@@ -352 +333 @@
                                 const char **argv);
 int rpc_vampire_usage(struct net_context *c, int argc, const char **argv);
-NTSTATUS rpc_vampire_internals(struct net_context *c,
-                                const DOM_SID *domain_sid,
-                                const char *domain_name,
-                                struct cli_state *cli,
-                                struct rpc_pipe_client *pipe_hnd,
-                                TALLOC_CTX *mem_ctx,
-                                int argc,
-                                const char **argv);
 int rpc_vampire_passdb(struct net_context *c, int argc, const char **argv);
 int rpc_vampire_ldif(struct net_context *c, int argc, const char **argv);
-NTSTATUS rpc_vampire_ldif_internals(struct net_context *c,
-                                    const DOM_SID *domain_sid,
-                                    const char *domain_name,
-                                    struct cli_state *cli,
-                                    struct rpc_pipe_client *pipe_hnd,
-                                    TALLOC_CTX *mem_ctx,
-                                    int argc,
-                                    const char **argv);
-NTSTATUS rpc_vampire_keytab_internals(struct net_context *c,
-                                      const DOM_SID *domain_sid,
-                                      const char *domain_name,
-                                      struct cli_state *cli,
-                                      struct rpc_pipe_client *pipe_hnd,
-                                      TALLOC_CTX *mem_ctx,
-                                      int argc,
-                                      const char **argv);
 int rpc_vampire_keytab(struct net_context *c, int argc, const char **argv);
 
@@ -428 +385 @@
 int net_eventlog(struct net_context *c, int argc, const char **argv);
 
+/* The following definitions come from utils/net_printing.c  */
+
+int net_printing(struct net_context *c, int argc, const char **argv);
+
+/* The following definitions come from utils/net_serverid.c  */
+
+int net_serverid(struct net_context *c, int argc, const char **argv);
+
 /* The following definitions come from utils/net_util.c  */
 
@@ -433 +398 @@
                              TALLOC_CTX *mem_ctx, struct cli_state *cli,
                              const char *name, const char **ret_domain,
-                             const char **ret_name, DOM_SID *ret_sid,
+                             const char **ret_name, struct dom_sid *ret_sid,
                              enum lsa_SidType *ret_type);
 NTSTATUS connect_to_service(struct net_context *c,
@@ -487 +452 @@
 NTSTATUS net_lookup_name_from_sid(struct net_context *c,
                                 TALLOC_CTX *ctx,
-                                DOM_SID *psid,
+                                struct dom_sid *psid,
                                 const char **ppdomain,
                                 const char **ppname);
 NTSTATUS net_lookup_sid_from_name(struct net_context *c, TALLOC_CTX *ctx,
-                                  const char *full_name, DOM_SID *pret_sid);
+                                  const char *full_name, struct dom_sid *pret_sid);
 
 /* The following definitions come from utils/passwd_util.c  */
@@ -501 +466 @@
 int net_g_lock(struct net_context *c, int argc, const char **argv);
 
+/* The following definitions come from utils/net_rpc_trust.c  */
+int net_rpc_trust(struct net_context *c, int argc, const char **argv);
+
 #endif /*  _NET_PROTO_H_  */

vendor/current/source3/utils/net_rap.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "../librpc/gen_ndr/rap.h"
+#include "../librpc/gen_ndr/svcctl.h"
 #include "utils/net.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
 
 /* The following messages were for error checking that is not properly
@@ -227 +231 @@
         int ret;
 
-        RAP_SHARE_INFO_2 sinfo;
+        struct rap_share_info_2 sinfo;
         char *p;
         char *sharename;
@@ -246 +250 @@
         }
         *p = 0;
-        strlcpy(sinfo.share_name, sharename, sizeof(sinfo.share_name));
+        strlcpy((char *)sinfo.share_name, sharename, sizeof(sinfo.share_name));
         sinfo.reserved1 = '\0';
         sinfo.share_type = 0;
-        sinfo.comment = smb_xstrdup(c->opt_comment);
+        sinfo.comment = c->opt_comment ? smb_xstrdup(c->opt_comment) : "";
         sinfo.perms = 0;
         sinfo.maximum_users = c->opt_maxusers;
@@ -813 +817 @@
         struct cli_state *cli;
         int ret;
-        RAP_USER_INFO_1 userinfo;
+        struct rap_user_info_1 userinfo;
 
         if (argc == 0 || c->display_usage) {
@@ -822 +826 @@
                 return -1;
 
-        safe_strcpy(userinfo.user_name, argv[0], sizeof(userinfo.user_name)-1);
-        if (c->opt_flags == -1)
+        safe_strcpy((char *)userinfo.user_name, argv[0], sizeof(userinfo.user_name)-1);
+        if (c->opt_flags == 0)
                 c->opt_flags = 0x21;
 
@@ -957 +961 @@
         struct cli_state *cli;
         int ret;
-        RAP_GROUP_INFO_1 grinfo;
+        struct rap_group_info_1 grinfo;
 
         if (argc == 0 || c->display_usage) {
@@ -967 +971 @@
 
         /* BB check for length 21 or smaller explicitly ? BB */
-        safe_strcpy(grinfo.group_name, argv[0], sizeof(grinfo.group_name)-1);
+        safe_strcpy((char *)grinfo.group_name, argv[0], sizeof(grinfo.group_name)-1);
         grinfo.reserved1 = '\0';
         grinfo.comment = smb_xstrdup(c->opt_comment ? c->opt_comment : "");

vendor/current/source3/utils/net_registry.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "registry.h"
+#include "registry/reg_api.h"
+#include "registry/reg_util_token.h"
+#include "registry/reg_init_basic.h"
 #include "utils/net.h"
 #include "utils/net_registry_util.h"
-
+#include "include/g_lock.h"
+#include "registry/reg_backend_db.h"
+#include "registry/reg_import.h"
+#include "registry/reg_format.h"
+#include <assert.h>
+#include "../libcli/security/display_sec.h"
+#include "../libcli/security/sddl.h"
+#include "../libcli/registry/util_reg.h"
+#include "passdb/machine_sid.h"
 
 /*
@@ -40 +52 @@
 {
         WERROR werr;
-        NT_USER_TOKEN *token = NULL;
+        struct security_token *token = NULL;
         char *hivename = NULL;
         char *tmp_subkeyname = NULL;
@@ -111 +123 @@
 }
 
-/*
- *
- * the main "net registry" function implementations
- *
- */
-
-static int net_registry_enumerate(struct net_context *c, int argc,
-                                  const char **argv)
-{
-        WERROR werr;
-        struct registry_key *key = NULL;
-        TALLOC_CTX *ctx = talloc_stackframe();
-        char *subkey_name;
+static WERROR registry_enumkey(struct registry_key* parent, const char* keyname, bool recursive)
+{
+        WERROR werr;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        char*  subkey_name;
         NTTIME modtime;
         uint32_t count;
-        char *valname = NULL;
+        char* valname = NULL;
         struct registry_value *valvalue = NULL;
-        int ret = -1;
-
-        if (argc != 1 || c->display_usage) {
-                d_printf("%s\n%s",
-                         _("Usage:"),
-                         _("net registry enumerate <path>\n"));
-                d_printf("%s\n%s",
-                         _("Example:"),
-                         _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
-                goto done;
-        }
-
-        werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
-        if (!W_ERROR_IS_OK(werr)) {
-                d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
-                goto done;
-        }
-
-        for (count = 0;
-             werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
-             W_ERROR_IS_OK(werr);
-             count++)
-        {
-                print_registry_key(subkey_name, &modtime);
-        }
-        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
-                goto done;
+        struct registry_key* key = NULL;
+
+        werr = reg_openkey(ctx, parent, keyname, REG_KEY_READ, &key);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+
+        if (recursive) {
+                printf("[%s]\n\n", key->key->name);
+        } else {
+                for (count = 0;
+                     werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
+                     W_ERROR_IS_OK(werr);
+                     count++)
+                {
+                        print_registry_key(subkey_name, &modtime);
+                }
+                if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                        goto done;
+                }
         }
 
@@ -168 +165 @@
         }
 
-        ret = 0;
-done:
-        TALLOC_FREE(ctx);
-        return ret;
-}
+        if (!recursive) {
+                werr = WERR_OK;
+                goto done;
+        }
+
+        for (count = 0;
+             werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
+             W_ERROR_IS_OK(werr);
+             count++)
+        {
+                werr = registry_enumkey(key, subkey_name, recursive);
+                if (!W_ERROR_IS_OK(werr)) {
+                        goto done;
+                }
+        }
+        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                goto done;
+        }
+
+        werr = WERR_OK;
+
+done:
+        TALLOC_FREE(ctx);
+        return werr;
+}
+
+
+
+/*
+ *
+ * the main "net registry" function implementations
+ *
+ */
+static int net_registry_enumerate(struct net_context *c, int argc,
+                                  const char **argv)
+{
+        WERROR werr;
+        struct registry_key *key = NULL;
+        char* name = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        int ret = -1;
+
+        if (argc != 1 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry enumerate <path>\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
+                goto done;
+        }
+
+        werr = open_hive(ctx, argv[0], REG_KEY_READ, &key, &name);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
+                goto done;
+        }
+
+        werr = registry_enumkey(key, name, c->opt_reboot);
+        if (W_ERROR_IS_OK(werr)) {
+                ret = 0;
+        }
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+
+static int net_registry_enumerate_recursive(struct net_context *c, int argc,
+                                            const char **argv)
+{
+        WERROR werr;
+        struct registry_key *key = NULL;
+        char* name = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        int ret = -1;
+
+        if (argc != 1 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry enumerate <path>\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry enumerate 'HKLM\\Software\\Samba'\n"));
+                goto done;
+        }
+
+        werr = open_hive(ctx, argv[0], REG_KEY_READ, &key, &name);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
+                goto done;
+        }
+
+        werr = registry_enumkey(key, name, true);
+        if (W_ERROR_IS_OK(werr)) {
+                ret = 0;
+        }
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+
 
 static int net_registry_createkey(struct net_context *c, int argc,
@@ -233 +326 @@
 }
 
-static int net_registry_deletekey(struct net_context *c, int argc,
-                                  const char **argv)
+static int net_registry_deletekey_internal(struct net_context *c, int argc,
+                                           const char **argv,
+                                           bool recursive)
 {
         WERROR werr;
@@ -264 +358 @@
         }
 
-        werr = reg_deletekey(hivekey, subkeyname);
-        if (!W_ERROR_IS_OK(werr)) {
+        if (recursive) {
+                werr = reg_deletekey_recursive(hivekey, subkeyname);
+        } else {
+                werr = reg_deletekey(hivekey, subkeyname);
+        }
+        if (!W_ERROR_IS_OK(werr) &&
+            !(c->opt_force && W_ERROR_EQUAL(werr, WERR_BADFILE)))
+        {
                 d_fprintf(stderr, "reg_deletekey %s: %s\n", _("failed"),
                           win_errstr(werr));
@@ -276 +376 @@
         TALLOC_FREE(ctx);
         return ret;
+}
+
+static int net_registry_deletekey(struct net_context *c, int argc,
+                                  const char **argv)
+{
+        return net_registry_deletekey_internal(c, argc, argv, false);
+}
+
+static int net_registry_deletekey_recursive(struct net_context *c, int argc,
+                                            const char **argv)
+{
+        return net_registry_deletekey_internal(c, argc, argv, true);
 }
 
@@ -290 +402 @@
                 d_fprintf(stderr, "%s\n%s",
                           _("Usage:"),
-                          _("net rpc registry getvalue <key> <valuename>\n"));
+                          _("net registry getvalue <key> <valuename>\n"));
                 goto done;
         }
@@ -326 +438 @@
 {
         return net_registry_getvalue_internal(c, argc, argv, true);
+}
+
+static int net_registry_getvaluesraw(struct net_context *c, int argc,
+                                     const char **argv)
+{
+        WERROR werr;
+        int ret = -1;
+        struct registry_key *key = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        uint32_t idx;
+
+        if (argc != 1 || c->display_usage) {
+                d_fprintf(stderr, "usage: net rpc registry getvaluesraw "
+                          "<key>\n");
+                goto done;
+        }
+
+        werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
+                goto done;
+        }
+
+        idx = 0;
+        while (true) {
+                struct registry_value *val;
+
+                werr = reg_enumvalue(talloc_tos(), key, idx, NULL, &val);
+
+                if (W_ERROR_EQUAL(werr, WERR_NO_MORE_ITEMS)) {
+                        ret = 0;
+                        break;
+                }
+                if (!W_ERROR_IS_OK(werr)) {
+                        break;
+                }
+                print_registry_value(val, true);
+                TALLOC_FREE(val);
+                idx += 1;
+        }
+done:
+        TALLOC_FREE(ctx);
+        return ret;
 }
 
@@ -340 +495 @@
                 d_fprintf(stderr, "%s\n%s",
                           _("Usage:"),
-                          _("net rpc registry setvalue <key> <valuename> "
+                          _("net registry setvalue <key> <valuename> "
                             "<type> [<val>]+\n"));
                 goto done;
@@ -351 +506 @@
 
         if (strequal(argv[2], "dword")) {
+                uint32_t v = strtoul(argv[3], NULL, 10);
                 value.type = REG_DWORD;
-                value.v.dword = strtoul(argv[3], NULL, 10);
+                value.data = data_blob_talloc(ctx, NULL, 4);
+                SIVAL(value.data.data, 0, v);
         } else if (strequal(argv[2], "sz")) {
                 value.type = REG_SZ;
-                value.v.sz.len = strlen(argv[3])+1;
-                value.v.sz.str = CONST_DISCARD(char *, argv[3]);
+                if (!push_reg_sz(ctx, &value.data, argv[3])) {
+                        goto done;
+                }
         } else if (strequal(argv[2], "multi_sz")) {
+                const char **array;
+                int count = argc - 3;
+                int i;
                 value.type = REG_MULTI_SZ;
-                value.v.multi_sz.num_strings = argc - 3;
-                value.v.multi_sz.strings = (char **)(argv + 3);
+                array = talloc_zero_array(ctx, const char *, count + 1);
+                if (array == NULL) {
+                        goto done;
+                }
+                for (i=0; i < count; i++) {
+                        array[i] = talloc_strdup(array, argv[count+i]);
+                        if (array[i] == NULL) {
+                                goto done;
+                        }
+                }
+                if (!push_reg_multi_sz(ctx, &value.data, array)) {
+                        goto done;
+                }
         } else {
                 d_fprintf(stderr, _("type \"%s\" not implemented\n"), argv[2]);
@@ -383 +555 @@
 done:
         TALLOC_FREE(ctx);
+        return ret;
+}
+
+struct net_registry_increment_state {
+        const char *keyname;
+        const char *valuename;
+        uint32_t increment;
+        uint32_t newvalue;
+        WERROR werr;
+};
+
+static void net_registry_increment_fn(void *private_data)
+{
+        struct net_registry_increment_state *state =
+                (struct net_registry_increment_state *)private_data;
+        struct registry_value *value;
+        struct registry_key *key = NULL;
+        uint32_t v;
+
+        state->werr = open_key(talloc_tos(), state->keyname,
+                               REG_KEY_READ|REG_KEY_WRITE, &key);
+        if (!W_ERROR_IS_OK(state->werr)) {
+                d_fprintf(stderr, _("open_key failed: %s\n"),
+                          win_errstr(state->werr));
+                goto done;
+        }
+
+        state->werr = reg_queryvalue(key, key, state->valuename, &value);
+        if (!W_ERROR_IS_OK(state->werr)) {
+                d_fprintf(stderr, _("reg_queryvalue failed: %s\n"),
+                          win_errstr(state->werr));
+                goto done;
+        }
+
+        if (value->type != REG_DWORD) {
+                d_fprintf(stderr, _("value not a DWORD: %s\n"),
+                          str_regtype(value->type));
+                goto done;
+        }
+
+        if (value->data.length < 4) {
+                d_fprintf(stderr, _("value too short for regular DWORD\n"));
+                goto done;
+        }
+
+        v = IVAL(value->data.data, 0);
+        v += state->increment;
+        state->newvalue = v;
+
+        SIVAL(value->data.data, 0, v);
+
+        state->werr = reg_setvalue(key, state->valuename, value);
+        if (!W_ERROR_IS_OK(state->werr)) {
+                d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
+                          win_errstr(state->werr));
+                goto done;
+        }
+
+done:
+        TALLOC_FREE(key);
+        return;
+}
+
+static int net_registry_increment(struct net_context *c, int argc,
+                                  const char **argv)
+{
+        struct net_registry_increment_state state;
+        NTSTATUS status;
+        int ret = -1;
+
+        if (argc < 2 || c->display_usage) {
+                d_fprintf(stderr, "%s\n%s",
+                          _("Usage:"),
+                          _("net registry increment <key> <valuename> "
+                            "[<increment>]\n"));
+                goto done;
+        }
+
+        state.keyname = argv[0];
+        state.valuename = argv[1];
+
+        state.increment = 1;
+        if (argc == 3) {
+                state.increment = strtoul(argv[2], NULL, 10);
+        }
+
+        status = g_lock_do("registry_increment_lock", G_LOCK_WRITE,
+                           timeval_set(600, 0), procid_self(),
+                           net_registry_increment_fn, &state);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("g_lock_do failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(state.werr)) {
+                d_fprintf(stderr, _("increment failed: %s\n"),
+                          win_errstr(state.werr));
+                goto done;
+        }
+
+        d_printf(_("%u\n"), (unsigned)state.newvalue);
+
+        ret = 0;
+
+done:
         return ret;
 }
@@ -397 +674 @@
                 d_fprintf(stderr, "%s\n%s",
                           _("Usage:"),
-                          _("net rpc registry deletevalue <key> <valuename>\n"));
+                          _("net registry deletevalue <key> <valuename>\n"));
                 goto done;
         }
@@ -409 +686 @@
         werr = reg_deletevalue(key, argv[1]);
         if (!W_ERROR_IS_OK(werr)) {
-                d_fprintf(stderr, _("reg_deletekey failed: %s\n"),
+                d_fprintf(stderr, _("reg_deletevalue failed: %s\n"),
                           win_errstr(werr));
                 goto done;
@@ -421 +698 @@
 }
 
-static int net_registry_getsd(struct net_context *c, int argc,
-                              const char **argv)
-{
-        WERROR werr;
-        int ret = -1;
+static WERROR net_registry_getsd_internal(struct net_context *c,
+                                          TALLOC_CTX *mem_ctx,
+                                          const char *keyname,
+                                          struct security_descriptor **sd)
+{
+        WERROR werr;
         struct registry_key *key = NULL;
-        struct security_descriptor *secdesc = NULL;
         TALLOC_CTX *ctx = talloc_stackframe();
         uint32_t access_mask = REG_KEY_READ |
@@ -439 +716 @@
         access_mask = REG_KEY_READ;
 
+        if (sd == NULL) {
+                d_fprintf(stderr, _("internal error: invalid argument\n"));
+                werr = WERR_INVALID_PARAM;
+                goto done;
+        }
+
+        if (strlen(keyname) == 0) {
+                d_fprintf(stderr, _("error: zero length key name given\n"));
+                werr = WERR_INVALID_PARAM;
+                goto done;
+        }
+
+        werr = open_key(ctx, keyname, access_mask, &key);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        werr = reg_getkeysecurity(mem_ctx, key, sd);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "%s%s\n", _("reg_getkeysecurity failed: "),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        werr = WERR_OK;
+
+done:
+        TALLOC_FREE(ctx);
+        return werr;
+}
+
+static int net_registry_getsd(struct net_context *c, int argc,
+                              const char **argv)
+{
+        WERROR werr;
+        int ret = -1;
+        struct security_descriptor *secdesc = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+
         if (argc != 1 || c->display_usage) {
                 d_printf("%s\n%s",
@@ -448 +766 @@
                 goto done;
         }
-        if (strlen(argv[0]) == 0) {
-                d_fprintf(stderr, "error: zero length key name given\n");
-                goto done;
-        }
-
-        werr = open_key(ctx, argv[0], access_mask, &key);
+
+        werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+
+        display_sec_desc(secdesc);
+
+        ret = 0;
+
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+
+static int net_registry_getsd_sddl(struct net_context *c,
+                                   int argc, const char **argv)
+{
+        WERROR werr;
+        int ret = -1;
+        struct security_descriptor *secdesc = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+
+        if (argc != 1 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry getsd_sddl <path>\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry getsd_sddl 'HKLM\\Software\\Samba'\n"));
+                goto done;
+        }
+
+        werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+
+        d_printf("%s\n", sddl_encode(ctx, secdesc, get_global_sam_sid()));
+
+        ret = 0;
+
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+
+static WERROR net_registry_setsd_internal(struct net_context *c,
+                                          TALLOC_CTX *mem_ctx,
+                                          const char *keyname,
+                                          struct security_descriptor *sd)
+{
+        WERROR werr;
+        struct registry_key *key = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        uint32_t access_mask = REG_KEY_WRITE |
+                               SEC_FLAG_MAXIMUM_ALLOWED |
+                               SEC_FLAG_SYSTEM_SECURITY;
+
+        /*
+         * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
+         * is denied with these perms right now...
+         */
+        access_mask = REG_KEY_WRITE;
+
+        if (strlen(keyname) == 0) {
+                d_fprintf(stderr, _("error: zero length key name given\n"));
+                werr = WERR_INVALID_PARAM;
+                goto done;
+        }
+
+        werr = open_key(ctx, keyname, access_mask, &key);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "%s%s\n", _("open_key failed: "),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        werr = reg_setkeysecurity(key, sd);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "%s%s\n", _("reg_setkeysecurity failed: "),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        werr = WERR_OK;
+
+done:
+        TALLOC_FREE(ctx);
+        return werr;
+}
+
+static int net_registry_setsd_sddl(struct net_context *c,
+                                   int argc, const char **argv)
+{
+        WERROR werr;
+        int ret = -1;
+        struct security_descriptor *secdesc = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+
+        if (argc != 2 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry setsd_sddl <path> <security_descriptor>\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry setsd_sddl 'HKLM\\Software\\Samba'\n"));
+                goto done;
+        }
+
+        secdesc = sddl_decode(ctx, argv[1], get_global_sam_sid());
+        if (secdesc == NULL) {
+                goto done;
+        }
+
+        werr = net_registry_setsd_internal(c, ctx, argv[0], secdesc);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+
+        ret = 0;
+
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+
+/******************************************************************************/
+/**
+ * @defgroup net_registry net registry
+ */
+
+/**
+ * @defgroup net_registry_import Import
+ * @ingroup net_registry
+ * @{
+ */
+
+struct import_ctx {
+        TALLOC_CTX *mem_ctx;
+};
+
+
+static WERROR import_create_key(struct import_ctx* ctx,
+                                struct registry_key* parent,
+                                const char* name, void** pkey, bool* existing)
+{
+        WERROR werr;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+
+        struct registry_key* key = NULL;
+        enum winreg_CreateAction action;
+
+        if (parent == NULL) {
+                char* subkeyname = NULL;
+                werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
+                         &parent, &subkeyname);
+                if (!W_ERROR_IS_OK(werr)) {
+                        d_fprintf(stderr, _("open_hive failed: %s\n"),
+                                  win_errstr(werr));
+                        goto done;
+                }
+                name = subkeyname;
+        }
+
+        action = REG_ACTION_NONE;
+        werr = reg_createkey(mem_ctx, parent, name, REG_KEY_WRITE,
+                             &key, &action);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("reg_createkey failed: %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        if (action == REG_ACTION_NONE) {
+                d_fprintf(stderr, _("createkey did nothing -- huh?\n"));
+                werr = WERR_CREATE_FAILED;
+                goto done;
+        }
+
+        if (existing != NULL) {
+                *existing = (action == REG_OPENED_EXISTING_KEY);
+        }
+
+        if (pkey!=NULL) {
+                *pkey = talloc_steal(ctx->mem_ctx, key);
+        }
+
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_close_key(struct import_ctx* ctx,
+                               struct registry_key* key)
+{
+        return WERR_OK;
+}
+
+static WERROR import_delete_key(struct import_ctx* ctx,
+                                struct registry_key* parent, const char* name)
+{
+        WERROR werr;
+        void* mem_ctx = talloc_new(talloc_tos());
+
+        if (parent == NULL) {
+                char* subkeyname = NULL;
+                werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
+                         &parent, &subkeyname);
+                if (!W_ERROR_IS_OK(werr)) {
+                        d_fprintf(stderr, _("open_hive failed: %s\n"),
+                                  win_errstr(werr));
+                        goto done;
+                }
+                name = subkeyname;
+        }
+
+        werr = reg_deletekey_recursive(parent, name);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, "reg_deletekey_recursive %s: %s\n", _("failed"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_create_val (struct import_ctx* ctx,
+                                 struct registry_key* parent, const char* name,
+                                 const struct registry_value* value)
+{
+        WERROR werr;
+
+        if (parent == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        werr = reg_setvalue(parent, name, value);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("reg_setvalue failed: %s\n"),
+                          win_errstr(werr));
+        }
+        return werr;
+}
+
+static WERROR import_delete_val (struct import_ctx* ctx, struct registry_key* parent, const char* name) {
+        WERROR werr;
+
+        if (parent == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        werr = reg_deletevalue(parent, name);
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("reg_deletevalue failed: %s\n"),
+                          win_errstr(werr));
+        }
+
+        return werr;
+}
+
+
+static int net_registry_import(struct net_context *c, int argc,
+                               const char **argv)
+{
+        struct import_ctx import_ctx;
+        struct reg_import_callback import_callback = {
+                .openkey     = NULL,
+                .closekey    = (reg_import_callback_closekey_t)&import_close_key,
+                .createkey   = (reg_import_callback_createkey_t)&import_create_key,
+                .deletekey   = (reg_import_callback_deletekey_t)&import_delete_key,
+                .deleteval   = (reg_import_callback_deleteval_t)&import_delete_val,
+                .setval      = {
+                        .registry_value = (reg_import_callback_setval_registry_value_t)
+                                          &import_create_val,
+                },
+                .setval_type = REGISTRY_VALUE,
+                .data        = &import_ctx
+        };
+
+        int ret;
+
+        if (argc < 1 || argc > 2 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry import <reg> [options]\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry import file.reg enc=CP1252\n"));
+                return -1;
+        }
+
+        ZERO_STRUCT(import_ctx);
+        import_ctx.mem_ctx = talloc_stackframe();
+
+        regdb_open();
+        regdb_transaction_start();
+
+        ret = reg_parse_file(argv[0],
+                             reg_import_adapter(import_ctx.mem_ctx,
+                                                import_callback),
+                             (argc > 1) ? argv[1] : NULL
+                );
+        if (ret < 0) {
+                d_printf("reg_parse_file failed: transaction canceled\n");
+                regdb_transaction_cancel();
+        } else{
+                regdb_transaction_commit();
+        }
+
+        regdb_close();
+        talloc_free(import_ctx.mem_ctx);
+
+        return ret;
+}
+/**@}*/
+
+/******************************************************************************/
+
+/**
+ * @defgroup net_registry_export Export
+ * @ingroup net_registry
+ * @{
+ */
+
+static int registry_export(TALLOC_CTX *ctx, /*const*/ struct registry_key* key,
+                           struct reg_format* f)
+{
+        int ret=-1;
+        WERROR werr;
+        uint32_t count;
+
+        struct registry_value *valvalue = NULL;
+        char *valname = NULL;
+
+        struct registry_key* subkey = NULL;
+        char *subkey_name = NULL;
+        NTTIME modtime = 0;
+
+        reg_format_registry_key(f, key, false);
+
+        /* print values */
+        for (count = 0;
+             werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
+                     W_ERROR_IS_OK(werr);
+             count++)
+        {
+                reg_format_registry_value(f, valname, valvalue);
+        }
+        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                d_fprintf(stderr, _("reg_enumvalue failed: %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        /* recurse on subkeys */
+        for (count = 0;
+             werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
+                     W_ERROR_IS_OK(werr);
+             count++)
+        {
+                werr = reg_openkey(ctx, key, subkey_name, REG_KEY_READ,
+                                   &subkey);
+                if (!W_ERROR_IS_OK(werr)) {
+                        d_fprintf(stderr, _("reg_openkey failed: %s\n"),
+                                  win_errstr(werr));
+                        goto done;
+                }
+
+                registry_export(ctx, subkey, f);
+        }
+        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                d_fprintf(stderr, _("reg_enumkey failed: %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+        ret = 0;
+done:
+        return ret;
+}
+
+static int net_registry_export(struct net_context *c, int argc,
+                               const char **argv)
+{
+        int ret=-1;
+        WERROR werr;
+        struct registry_key *key = NULL;
+        TALLOC_CTX *ctx = talloc_stackframe();
+        struct reg_format* f=NULL;
+
+        if (argc < 2 || argc > 3 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry export <path> <file> [opt]\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry export 'HKLM\\Software\\Samba' "
+                           "samba.reg regedit5\n"));
+                goto done;
+        }
+
+        werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
         if (!W_ERROR_IS_OK(werr)) {
                 d_fprintf(stderr, _("open_key failed: %s\n"), win_errstr(werr));
@@ -459 +1175 @@
         }
 
-        werr = reg_getkeysecurity(ctx, key, &secdesc);
-        if (!W_ERROR_IS_OK(werr)) {
-                d_fprintf(stderr, _("reg_getkeysecurity failed: %s\n"),
-                          win_errstr(werr));
-                goto done;
-        }
-
-        display_sec_desc(secdesc);
-
-        ret = 0;
-
-done:
-        TALLOC_FREE(ctx);
-        return ret;
-}
+        f = reg_format_file(ctx, argv[1], (argc > 2) ? argv[2] : NULL);
+        if (f == NULL) {
+                d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
+                goto done;
+        }
+
+        ret = registry_export(ctx, key, f);
+
+done:
+        TALLOC_FREE(ctx);
+        return ret;
+}
+/**@}*/
+
+/******************************************************************************/
+/**
+ * @defgroup net_registry_convert Convert
+ * @ingroup net_registry
+ * @{
+ */
+
+static int net_registry_convert(struct net_context *c, int argc,
+                               const char **argv)
+{
+        int ret;
+        void* mem_ctx;
+        const char* in_opt  = NULL;
+        const char* out_opt = NULL;
+
+        if (argc < 2 || argc > 4|| c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net registry convert <in> <out> [in_opt] [out_opt]\n"
+                           "net registry convert <in> <out> [out_opt]\n"));
+                d_printf("%s\n%s",
+                         _("Example:"),
+                         _("net registry convert in.reg out.reg regedit4,enc=CP1252\n"));
+                return -1;
+        }
+
+        mem_ctx = talloc_stackframe();
+
+        switch (argc ) {
+        case 2:
+                break;
+        case 3:
+                out_opt = argv[2];
+                break;
+        case 4:
+                out_opt = argv[3];
+                in_opt  = argv[2];
+                break;
+        default:
+                assert(false);
+        }
+
+
+        ret = reg_parse_file(argv[0], (struct reg_parse_callback*)
+                             reg_format_file(mem_ctx, argv[1], out_opt),
+                             in_opt);
+
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+/**@}*/
+
+/******************************************************************************/
 
 int net_registry(struct net_context *c, int argc, const char **argv)
@@ -489 +1258 @@
                 },
                 {
+                        "enumerate_recursive",
+                        net_registry_enumerate_recursive,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Enumerate registry keys and values"),
+                        N_("net registry enumerate_recursive\n"
+                           "    Enumerate registry keys and values")
+                },
+                {
                         "createkey",
                         net_registry_createkey,
@@ -505 +1282 @@
                 },
                 {
+                        "deletekey_recursive",
+                        net_registry_deletekey_recursive,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Delete a registry key with subkeys"),
+                        N_("net registry deletekey_recursive\n"
+                           "    Delete a registry key with subkeys")
+                },
+                {
                         "getvalue",
                         net_registry_getvalue,
@@ -521 +1306 @@
                 },
                 {
+                        "getvaluesraw",
+                        net_registry_getvaluesraw,
+                        NET_TRANSPORT_LOCAL,
+                        "Print all values of a key in raw format",
+                        "net registry getvaluesraw <key>\n"
+                        "    Print a registry value (raw format)"
+                },
+                {
                         "setvalue",
                         net_registry_setvalue,
@@ -529 +1322 @@
                 },
                 {
+                        "increment",
+                        net_registry_increment,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Increment a DWORD registry value under a lock"),
+                        N_("net registry increment\n"
+                           "    Increment a DWORD registry value under a lock")
+                },
+                {
                         "deletevalue",
                         net_registry_deletevalue,
@@ -544 +1345 @@
                            "    Get security descriptor")
                 },
+                {
+                        "getsd_sddl",
+                        net_registry_getsd_sddl,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Get security descriptor in sddl format"),
+                        N_("net registry getsd_sddl\n"
+                           "    Get security descriptor in sddl format")
+                },
+                {
+                        "setsd_sddl",
+                        net_registry_setsd_sddl,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Set security descriptor from sddl format string"),
+                        N_("net registry setsd_sddl\n"
+                           "    Set security descriptor from sddl format string")
+                },
+                {
+                        "import",
+                        net_registry_import,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Import .reg file"),
+                        N_("net registry import\n"
+                           "    Import .reg file")
+                },
+                {
+                        "export",
+                        net_registry_export,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Export .reg file"),
+                        N_("net registry export\n"
+                           "    Export .reg file")
+                },
+                {
+                        "convert",
+                        net_registry_convert,
+                        NET_TRANSPORT_LOCAL,
+                        N_("Convert .reg file"),
+                        N_("net registry convert\n"
+                           "    Convert .reg file")
+                },
         { NULL, NULL, 0, NULL, NULL }
         };

vendor/current/source3/utils/net_registry_util.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "registry.h"
 #include "utils/net_registry_util.h"
 #include "utils/net.h"
+#include "../libcli/registry/util_reg.h"
 
 void print_registry_key(const char *keyname, NTTIME *modtime)
@@ -38 +40 @@
         if (!raw) {
                 d_printf(_("Type       = %s\n"),
-                         reg_type_lookup(valvalue->type));
+                         str_regtype(valvalue->type));
         }
         switch(valvalue->type) {
-        case REG_DWORD:
+        case REG_DWORD: {
+                uint32_t v = 0;
+                if (valvalue->data.length >= 4) {
+                        v = IVAL(valvalue->data.data, 0);
+                }
                 if (!raw) {
                         d_printf(_("Value      = "));
                 }
-                d_printf("%d\n", valvalue->v.dword);
+                d_printf("%d\n", v);
                 break;
+        }
         case REG_SZ:
-        case REG_EXPAND_SZ:
+        case REG_EXPAND_SZ: {
+                const char *s;
+
+                if (!pull_reg_sz(talloc_tos(), &valvalue->data, &s)) {
+                        break;
+                }
                 if (!raw) {
                         d_printf(_("Value      = \""));
                 }
-                d_printf("%s", valvalue->v.sz.str);
+                d_printf("%s", s);
                 if (!raw) {
                         d_printf("\"");
@@ -58 +70 @@
                 d_printf("\n");
                 break;
+        }
         case REG_MULTI_SZ: {
                 uint32 j;
-                for (j = 0; j < valvalue->v.multi_sz.num_strings; j++) {
+                const char **a;
+
+                if (!pull_reg_multi_sz(talloc_tos(), &valvalue->data, &a)) {
+                        break;
+                }
+                for (j = 0; a[j] != NULL; j++) {
                         if (!raw) {
                                 d_printf(_("Value[%3.3d] = \""), j);
                         }
-                        d_printf("%s", valvalue->v.multi_sz.strings[j]);
+                        d_printf("%s", a[j]);
                         if (!raw) {
                                 d_printf("\"");
@@ -76 +94 @@
                         d_printf(_("Value      = "));
                 }
-                d_printf(_("%d bytes\n"), (int)valvalue->v.binary.length);
+                d_printf(_("%d bytes\n"), (int)valvalue->data.length);
                 break;
         default:
@@ -98 +116 @@
  * Split path into hive name and subkeyname
  * normalizations performed:
- *  - convert '/' to '\\'
+ *  - if the path contains no '\\' characters,
+ *    assume that the legacy format of using '/'
+ *    as a separator is used and  convert '/' to '\\'
  *  - strip trailing '\\' chars
  */
@@ -115 +135 @@
         }
 
-        *hivename = talloc_string_sub(ctx, path, "/", "\\");
+        if (strchr(path, '\\') == NULL) {
+                *hivename = talloc_string_sub(ctx, path, "/", "\\");
+        } else {
+                *hivename = talloc_strdup(ctx, path);
+        }
+
         if (*hivename == NULL) {
                 return WERR_NOMEM;

vendor/current/source3/utils/net_rpc.c

@@ -23 +23 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "rpc_client/cli_pipe.h"
 #include "../libcli/auth/libcli_auth.h"
-#include "../librpc/gen_ndr/cli_samr.h"
-#include "../librpc/gen_ndr/cli_lsa.h"
-#include "../librpc/gen_ndr/cli_netlogon.h"
-#include "../librpc/gen_ndr/cli_srvsvc.h"
-#include "../librpc/gen_ndr/cli_spoolss.h"
-#include "../librpc/gen_ndr/cli_initshutdown.h"
-#include "../librpc/gen_ndr/cli_winreg.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "rpc_client/cli_samr.h"
+#include "rpc_client/init_samr.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "../librpc/gen_ndr/ndr_netlogon_c.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
+#include "../librpc/gen_ndr/ndr_spoolss.h"
+#include "../librpc/gen_ndr/ndr_initshutdown_c.h"
+#include "../librpc/gen_ndr/ndr_winreg_c.h"
+#include "secrets.h"
+#include "lib/netapi/netapi.h"
+#include "lib/netapi/netapi_net.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/security.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "nsswitch/libwbclient/wbclient.h"
+#include "passdb.h"
 
 static int net_mode_share;
-static bool sync_files(struct copy_clistate *cp_clistate, const char *mask);
+static NTSTATUS sync_files(struct copy_clistate *cp_clistate, const char *mask);
 
 /**
@@ -60 +73 @@
 
 NTSTATUS net_get_remote_domain_sid(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                                   DOM_SID **domain_sid,
+                                   struct dom_sid **domain_sid,
                                    const char **domain_name)
 {
         struct rpc_pipe_client *lsa_pipe = NULL;
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_OK;
+        NTSTATUS status, result;
         union lsa_PolicyInformation *info = NULL;
-
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+        struct dcerpc_binding_handle *b;
+
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
                                           &lsa_pipe);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Could not initialise lsa pipe\n"));
-                return result;
-        }
-
-        result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, false,
+                return status;
+        }
+
+        b = lsa_pipe->binding_handle;
+
+        status = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, false,
                                      SEC_FLAG_MAXIMUM_ALLOWED,
                                      &pol);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "open_policy %s: %s\n",
                           _("failed"),
-                          nt_errstr(result));
-                return result;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(lsa_pipe, mem_ctx,
+                          nt_errstr(status));
+                return status;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_ACCOUNT_DOMAIN,
-                                            &info);
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, "lsaquery %s: %s\n",
+                          _("failed"),
+                          nt_errstr(status));
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 d_fprintf(stderr, "lsaquery %s: %s\n",
@@ -99 +122 @@
         *domain_sid = info->account_domain.sid;
 
-        rpccli_lsa_Close(lsa_pipe, mem_ctx, &pol);
+        dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
         TALLOC_FREE(lsa_pipe);
 
@@ -129 +152 @@
         TALLOC_CTX *mem_ctx;
         NTSTATUS nt_status;
-        DOM_SID *domain_sid;
+        struct dom_sid *domain_sid;
         const char *domain_name;
         int ret = -1;
@@ -242 +265 @@
 
 static NTSTATUS rpc_changetrustpw_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -310 +333 @@
 
 static NTSTATUS rpc_oldjoin_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -489 +512 @@
 
 NTSTATUS rpc_info_internals(struct net_context *c,
-                        const DOM_SID *domain_sid,
+                        const struct dom_sid *domain_sid,
                         const char *domain_name,
                         struct cli_state *cli,
@@ -498 +521 @@
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union samr_DomainInfo *info = NULL;
         fstring sid_str;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         sid_to_fstring(sid_str, domain_sid);
 
         /* Get sam policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Could not connect to SAM: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("Could not connect to SAM: %s\n"),
                           nt_errstr(result));
@@ -516 +548 @@
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Could not open domain: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("Could not open domain: %s\n"),
                           nt_errstr(result));
@@ -527 +566 @@
         }
 
-        result = rpccli_samr_QueryDomainInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                              &domain_pol,
                                              2,
-                                             &info);
+                                             &info,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = result;
         if (NT_STATUS_IS_OK(result)) {
                 d_printf(_("Domain Name: %s\n"),
@@ -543 +587 @@
 
  done:
-        return result;
+        return status;
 }
 
@@ -586 +630 @@
 
 static NTSTATUS rpc_getsid_internals(struct net_context *c,
-                        const DOM_SID *domain_sid,
+                        const struct dom_sid *domain_sid,
                         const char *domain_name,
                         struct cli_state *cli,
@@ -728 +772 @@
         }
 
+        return status;
+}
+
+/**
+ * Set a user's primary group
+ *
+ * @param argc  Standard main() style argc.
+ * @param argv  Standard main() style argv. Initial components are already
+ *              stripped.
+ *
+ * @return A shell status integer (0 for success).
+ **/
+
+static int rpc_user_setprimarygroup(struct net_context *c, int argc,
+                                    const char **argv)
+{
+        NET_API_STATUS status;
+        uint8_t *buffer;
+        struct GROUP_INFO_2 *g2;
+        struct USER_INFO_1051 u1051;
+        uint32_t parm_err = 0;
+
+        if (argc != 2 || c->display_usage) {
+                rpc_user_usage(c, argc, argv);
+                return 0;
+        }
+
+        status = NetGroupGetInfo(c->opt_host, argv[1], 2, &buffer);
+        if (status) {
+                d_fprintf(stderr, _("Failed to find group name %s -- %s\n"),
+                          argv[1],
+                          libnetapi_get_error_string(c->netapi_ctx, status));
+                return status;
+        }
+        g2 = (struct GROUP_INFO_2 *)buffer;
+
+        u1051.usri1051_primary_group_id = g2->grpi2_group_id;
+
+        NetApiBufferFree(buffer);
+
+        status = NetUserSetInfo(c->opt_host, argv[0], 1051,
+                                (uint8_t *)&u1051, &parm_err);
+        if (status) {
+                d_fprintf(stderr,
+                          _("Failed to set user's primary group %s to %s - "
+                            "%s\n"), argv[0], argv[1],
+                          libnetapi_get_error_string(c->netapi_ctx, status));
+        } else {
+                d_printf(_("Set primary group of user %s to %s\n"), argv[0],
+                         argv[1]);
+        }
         return status;
 }
@@ -894 +989 @@
                 uint32_t max_entries, max_size;
 
-                get_query_dispinfo_params(
+                dcerpc_get_query_dispinfo_params(
                         loop_count, &max_entries, &max_size);
 
@@ -956 +1051 @@
                         N_("List domain groups of user"),
                         N_("net rpc user info\n"
-                           "    Lis domain groups of user")
+                           "    List domain groups of user")
                 },
                 {
@@ -982 +1077 @@
                            "    Rename specified user")
                 },
+                {
+                        "setprimarygroup",
+                        rpc_user_setprimarygroup,
+                        NET_TRANSPORT_RPC,
+                        "Set a user's primary group",
+                        "net rpc user setprimarygroup\n"
+                        "    Set a user's primary group"
+                },
                 {NULL, NULL, 0, NULL, NULL}
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;
@@ -1044 +1147 @@
 {
         struct policy_handle connect_pol, domain_pol, user_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
-        DOM_SID sid;
+        NTSTATUS status, result;
+        struct dom_sid sid;
         uint32 rid;
         enum lsa_SidType type;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc == 0) {
@@ -1059 +1163 @@
         ZERO_STRUCT(user_pol);
 
-        result = net_rpc_lookup_name(c, mem_ctx, rpc_pipe_np_smb_conn(pipe_hnd),
+        status = net_rpc_lookup_name(c, mem_ctx, rpc_pipe_np_smb_conn(pipe_hnd),
                                      argv[0], NULL, NULL, &sid, &type);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Could not lookup %s: %s\n"), argv[0],
-                          nt_errstr(result));
+                          nt_errstr(status));
                 goto done;
         }
@@ -1070 +1174 @@
                 d_fprintf(stderr, _("%s is a %s, not a user\n"), argv[0],
                           sid_type_lookup(type));
-                result = NT_STATUS_NO_SUCH_USER;
+                status = NT_STATUS_NO_SUCH_USER;
                 goto done;
         }
@@ -1076 +1180 @@
         if (!sid_peek_check_rid(ctx->domain_sid, &sid, &rid)) {
                 d_fprintf(stderr, _("%s is not in our domain\n"), argv[0]);
-                result = NT_STATUS_NO_SUCH_USER;
-                goto done;
-        }
-
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+                status = NT_STATUS_NO_SUCH_USER;
+                goto done;
+        }
+
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         ctx->domain_sid,
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_OpenUser(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenUser(b, mem_ctx,
                                       &domain_pol,
                                       MAXIMUM_ALLOWED_ACCESS,
                                       rid,
-                                      &user_pol);
+                                      &user_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = fn(c, mem_ctx, ctx, pipe_hnd, &user_pol, argc-1, argv+1);
+                status = result;
+                goto done;
+        }
+
+        status = fn(c, mem_ctx, ctx, pipe_hnd, &user_pol, argc-1, argv+1);
 
  done:
         if (is_valid_policy_hnd(&user_pol)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &user_pol);
+                dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
         }
         if (is_valid_policy_hnd(&domain_pol)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_pol);
+                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
         }
         if (is_valid_policy_hnd(&connect_pol)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        }
-        return result;
+                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        }
+        return status;
 }
 
@@ -1128 +1247 @@
                                            int argc, const char **argv)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         union samr_UserInfo *info = NULL;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 0) {
@@ -1137 +1257 @@
         }
 
-        result = rpccli_samr_QueryUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
                                            user_hnd,
                                            21,
-                                           &info);
+                                           &info,
+                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -1180 +1304 @@
                                                int argc, const char **argv)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         const char *username;
         const char *oldval = "";
         union samr_UserInfo *info = NULL;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc > 1) {
@@ -1191 +1316 @@
         }
 
-        result = rpccli_samr_QueryUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
                                            user_hnd,
                                            21,
-                                           &info);
+                                           &info,
+                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -1226 +1355 @@
         SETSTR("description", description, DESCRIPTION);
 
-        result = rpccli_samr_SetUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_SetUserInfo(b, mem_ctx,
                                          user_hnd,
                                          21,
-                                         info);
+                                         info,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        status = result;
 
         d_printf(_("Set %s's %s from [%s] to [%s]\n"), username,
@@ -1236 +1371 @@
  done:
 
-        return result;
+        return status;
 }
 
@@ -1265 +1400 @@
                                                 int argc, const char **argv)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         const char *username;
         const char *oldval = "unknown";
@@ -1271 +1406 @@
         bool newval;
         union samr_UserInfo *info = NULL;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if ((argc > 1) ||
@@ -1284 +1420 @@
         newval = strequal(argv[0], "yes");
 
-        result = rpccli_samr_QueryUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
                                            user_hnd,
                                            21,
-                                           &info);
+                                           &info,
+                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -1312 +1452 @@
         info->info21.fields_present = SAMR_FIELD_ACCT_FLAGS;
 
-        result = rpccli_samr_SetUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_SetUserInfo(b, mem_ctx,
                                          user_hnd,
                                          21,
-                                         info);
-
+                                         info,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = result;
         if (NT_STATUS_IS_OK(result)) {
                 d_printf(_("Set %s's %s flag from [%s] to [%s]\n"), username,
@@ -1324 +1468 @@
  done:
 
-        return result;
+        return status;
 }
 
@@ -1434 +1578 @@
 
 static NTSTATUS rpc_group_delete_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -1444 +1588 @@
         struct policy_handle connect_pol, domain_pol, group_pol, user_pol;
         bool group_is_primary = false;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         uint32_t group_rid;
-        struct samr_RidTypeArray *rids = NULL;
+        struct samr_RidAttrArray *rids = NULL;
         /* char **names; */
         int i;
         /* struct samr_RidWithAttribute *user_gids; */
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         struct samr_Ids group_rids, name_types;
@@ -1460 +1605 @@
         }
 
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Request samr_Connect2 failed\n"));
+                goto done;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("Request samr_Connect2 failed\n"));
-                goto done;
+                goto done;
         }
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Request open_domain failed\n"));
+                goto done;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("Request open_domain failed\n"));
-                goto done;
+                goto done;
         }
 
         init_lsa_String(&lsa_acct_name, argv[0]);
 
-        result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          &domain_pol,
                                          1,
                                          &lsa_acct_name,
                                          &group_rids,
-                                         &name_types);
+                                         &name_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Lookup of '%s' failed\n"),argv[0]);
+                goto done;
+        }
+
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("Lookup of '%s' failed\n"),argv[0]);
-                goto done;
+                goto done;
         }
 
@@ -1497 +1661 @@
         {
         case SID_NAME_DOM_GRP:
-                result = rpccli_samr_OpenGroup(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_OpenGroup(b, mem_ctx,
                                                &domain_pol,
                                                MAXIMUM_ALLOWED_ACCESS,
                                                group_rids.ids[0],
-                                               &group_pol);
+                                               &group_pol,
+                                               &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr, _("Request open_group failed"));
+                        goto done;
+                }
+
                 if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
                         d_fprintf(stderr, _("Request open_group failed"));
-                        goto done;
+                        goto done;
                 }
 
                 group_rid = group_rids.ids[0];
 
-                result = rpccli_samr_QueryGroupMember(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_QueryGroupMember(b, mem_ctx,
                                                       &group_pol,
-                                                      &rids);
-
-                if (!NT_STATUS_IS_OK(result)) {
+                                                      &rids,
+                                                      &result);
+                if (!NT_STATUS_IS_OK(status)) {
                         d_fprintf(stderr,
                                   _("Unable to query group members of %s"),
                                   argv[0]);
-                        goto done;
+                        goto done;
+                }
+
+                if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
+                        d_fprintf(stderr,
+                                  _("Unable to query group members of %s"),
+                                  argv[0]);
+                        goto done;
                 }
 
@@ -1529 +1708 @@
                 for (i = 0; i < rids->count; i++)
                 {
-                        result = rpccli_samr_OpenUser(pipe_hnd, mem_ctx,
+                        status = dcerpc_samr_OpenUser(b, mem_ctx,
                                                       &domain_pol,
                                                       MAXIMUM_ALLOWED_ACCESS,
                                                       rids->rids[i],
-                                                      &user_pol);
-
-                        if (!NT_STATUS_IS_OK(result)) {
+                                                      &user_pol,
+                                                      &result);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 d_fprintf(stderr,
                                         _("Unable to open group member %d\n"),
                                         rids->rids[i]);
-                                goto done;
-                        }
-
-                        result = rpccli_samr_QueryUserInfo(pipe_hnd, mem_ctx,
+                                goto done;
+                        }
+
+                        if (!NT_STATUS_IS_OK(result)) {
+                                status = result;
+                                d_fprintf(stderr,
+                                        _("Unable to open group member %d\n"),
+                                        rids->rids[i]);
+                                goto done;
+                        }
+
+                        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
                                                            &user_pol,
                                                            21,
-                                                           &info);
-
-                        if (!NT_STATUS_IS_OK(result)) {
+                                                           &info,
+                                                           &result);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 d_fprintf(stderr,
                                         _("Unable to lookup userinfo for group "
                                           "member %d\n"),
                                         rids->rids[i]);
-                                goto done;
-                        }
+                                goto done;
+                        }
+
+                        if (!NT_STATUS_IS_OK(result)) {
+                                status = result;
+                                d_fprintf(stderr,
+                                        _("Unable to lookup userinfo for group "
+                                          "member %d\n"),
+                                        rids->rids[i]);
+                                goto done;
+                        }
 
                         if (info->info21.primary_gid == group_rid) {
@@ -1564 +1760 @@
                         }
 
-                        rpccli_samr_Close(pipe_hnd, mem_ctx, &user_pol);
+                        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
                 }
 
@@ -1571 +1767 @@
                                  "some of it's members have it as primary "
                                  "group\n"));
-                        result = NT_STATUS_MEMBERS_PRIMARY_GROUP;
+                        status = NT_STATUS_MEMBERS_PRIMARY_GROUP;
                         goto done;
                 }
@@ -1581 +1777 @@
                                 d_printf(_("Remove group member %d..."),
                                         rids->rids[i]);
-                        result = rpccli_samr_DeleteGroupMember(pipe_hnd, mem_ctx,
+                        status = dcerpc_samr_DeleteGroupMember(b, mem_ctx,
                                                                &group_pol,
-                                                               rids->rids[i]);
-
+                                                               rids->rids[i],
+                                                               &result);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                goto done;
+                        }
+                        status = result;
                         if (NT_STATUS_IS_OK(result)) {
                                 if (c->opt_verbose)
@@ -1595 +1795 @@
                 }
 
-                result = rpccli_samr_DeleteDomainGroup(pipe_hnd, mem_ctx,
-                                                       &group_pol);
+                status = dcerpc_samr_DeleteDomainGroup(b, mem_ctx,
+                                                       &group_pol,
+                                                       &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        break;
+                }
+
+                status = result;
 
                 break;
         /* removing a local group is easier... */
         case SID_NAME_ALIAS:
-                result = rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                                &domain_pol,
                                                MAXIMUM_ALLOWED_ACCESS,
                                                group_rids.ids[0],
-                                               &group_pol);
-
+                                               &group_pol,
+                                               &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr, _("Request open_alias failed\n"));
+                        goto done;
+                }
                 if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
                         d_fprintf(stderr, _("Request open_alias failed\n"));
-                        goto done;
+                        goto done;
                 }
 
-                result = rpccli_samr_DeleteDomAlias(pipe_hnd, mem_ctx,
-                                                    &group_pol);
+                status = dcerpc_samr_DeleteDomAlias(b, mem_ctx,
+                                                    &group_pol,
+                                                    &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        break;
+                }
+
+                status = result;
+
                 break;
         default:
@@ -1619 +1837 @@
                                     "for deleting local or global groups\n"),
                         argv[0],sid_type_lookup(name_types.ids[0]));
-                result = NT_STATUS_UNSUCCESSFUL;
-                goto done;
-        }
-
-        if (NT_STATUS_IS_OK(result)) {
+                status = NT_STATUS_UNSUCCESSFUL;
+                goto done;
+        }
+
+        if (NT_STATUS_IS_OK(status)) {
                 if (c->opt_verbose)
                         d_printf(_("Deleted %s '%s'\n"),
@@ -1629 +1847 @@
         } else {
                 d_fprintf(stderr, _("Deleting of %s failed: %s\n"), argv[0],
-                        get_friendly_nt_error_msg(result));
+                        get_friendly_nt_error_msg(status));
         }
 
  done:
-        return result;
+        return status;
 
 }
@@ -1720 +1938 @@
                                 TALLOC_CTX *mem_ctx,
                                 const char *name,
-                                DOM_SID *sid,
+                                struct dom_sid *sid,
                                 enum lsa_SidType *type)
 {
-        DOM_SID *sids = NULL;
+        struct dom_sid *sids = NULL;
         enum lsa_SidType *types = NULL;
         struct rpc_pipe_client *pipe_hnd = NULL;
         struct policy_handle lsa_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
-
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+        NTSTATUS status, result;
+        struct dcerpc_binding_handle *b;
+
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
                                           &pipe_hnd);
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, false,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        b = pipe_hnd->binding_handle;
+
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, false,
                                      SEC_FLAG_MAXIMUM_ALLOWED, &lsa_pol);
 
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &lsa_pol, 1,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &lsa_pol, 1,
                                       &name, NULL, 1, &sids, &types);
 
-        if (NT_STATUS_IS_OK(result)) {
+        if (NT_STATUS_IS_OK(status)) {
                 sid_copy(sid, &sids[0]);
                 *type = types[0];
         }
 
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
+        dcerpc_lsa_Close(b, mem_ctx, &lsa_pol, &result);
 
  done:
@@ -1757 +1978 @@
         }
 
-        if (!NT_STATUS_IS_OK(result) && (StrnCaseCmp(name, "S-", 2) == 0)) {
+        if (!NT_STATUS_IS_OK(status) && (StrnCaseCmp(name, "S-", 2) == 0)) {
 
                 /* Try as S-1-5-whatever */
 
-                DOM_SID tmp_sid;
+                struct dom_sid tmp_sid;
 
                 if (string_to_sid(&tmp_sid, name)) {
                         sid_copy(sid, &tmp_sid);
                         *type = SID_NAME_UNKNOWN;
-                        result = NT_STATUS_OK;
+                        status = NT_STATUS_OK;
                 }
         }
 
-        return result;
+        return status;
 }
 
 static NTSTATUS rpc_add_groupmem(struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
-                                const DOM_SID *group_sid,
+                                const struct dom_sid *group_sid,
                                 const char *member)
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 group_rid;
         struct policy_handle group_pol;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         struct samr_Ids rids, rid_types;
         struct lsa_String lsa_acct_name;
 
-        DOM_SID sid;
+        struct dom_sid sid;
 
         sid_copy(&sid, group_sid);
@@ -1795 +2017 @@
 
         /* Get sam policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -1804 +2030 @@
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         &sid,
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -1815 +2045 @@
         init_lsa_String(&lsa_acct_name, member);
 
-        result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          &domain_pol,
                                          1,
                                          &lsa_acct_name,
                                          &rids,
-                                         &rid_types);
-
-        if (!NT_STATUS_IS_OK(result)) {
+                                         &rid_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
                           member);
@@ -1828 +2058 @@
         }
 
-        result = rpccli_samr_OpenGroup(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                d_fprintf(stderr, _("Could not lookup up group member %s\n"),
+                          member);
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenGroup(b, mem_ctx,
                                        &domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        group_rid,
-                                       &group_pol);
+                                       &group_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_AddGroupMember(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_AddGroupMember(b, mem_ctx,
                                             &group_pol,
                                             rids.ids[0],
-                                            0x0005); /* unknown flags */
+                                            0x0005, /* unknown flags */
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = result;
 
  done:
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        return result;
+        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        return status;
 }
 
 static NTSTATUS rpc_add_aliasmem(struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
-                                const DOM_SID *alias_sid,
+                                const struct dom_sid *alias_sid,
                                 const char *member)
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 alias_rid;
         struct policy_handle alias_pol;
-
-        DOM_SID member_sid;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        struct dom_sid member_sid;
         enum lsa_SidType member_type;
 
-        DOM_SID sid;
+        struct dom_sid sid;
 
         sid_copy(&sid, alias_sid);
@@ -1879 +2128 @@
 
         /* Get sam policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         &sid,
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                        &domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        alias_rid,
-                                       &alias_pol);
-
+                                       &alias_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
         }
 
-        result = rpccli_samr_AddAliasMember(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_AddAliasMember(b, mem_ctx,
                                             &alias_pol,
-                                            &member_sid);
-
-        if (!NT_STATUS_IS_OK(result)) {
-                return result;
-        }
+                                            &member_sid,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        status = result;
 
  done:
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        return result;
+        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        return status;
 }
 
 static NTSTATUS rpc_group_addmem_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -1929 +2193 @@
                                         const char **argv)
 {
-        DOM_SID group_sid;
+        struct dom_sid group_sid;
         enum lsa_SidType group_type;
 
@@ -1987 +2251 @@
                                 struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
-                                const DOM_SID *group_sid,
+                                const struct dom_sid *group_sid,
                                 const char *member)
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 group_rid;
         struct policy_handle group_pol;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         struct samr_Ids rids, rid_types;
         struct lsa_String lsa_acct_name;
 
-        DOM_SID sid;
+        struct dom_sid sid;
 
         sid_copy(&sid, group_sid);
@@ -2006 +2271 @@
 
         /* Get sam policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
-        if (!NT_STATUS_IS_OK(result))
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
+
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         &sid,
-                                        &domain_pol);
-        if (!NT_STATUS_IS_OK(result))
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         init_lsa_String(&lsa_acct_name, member);
 
-        result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          &domain_pol,
                                          1,
                                          &lsa_acct_name,
                                          &rids,
-                                         &rid_types);
-        if (!NT_STATUS_IS_OK(result)) {
+                                         &rid_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
                           member);
@@ -2036 +2313 @@
         }
 
-        result = rpccli_samr_OpenGroup(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                d_fprintf(stderr, _("Could not lookup up group member %s\n"),
+                          member);
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenGroup(b, mem_ctx,
                                        &domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        group_rid,
-                                       &group_pol);
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
-
-        result = rpccli_samr_DeleteGroupMember(pipe_hnd, mem_ctx,
+                                       &group_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_DeleteGroupMember(b, mem_ctx,
                                                &group_pol,
-                                               rids.ids[0]);
-
+                                               rids.ids[0],
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = result;
  done:
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        return result;
+        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        return status;
 }
 
 static NTSTATUS rpc_del_aliasmem(struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
-                                const DOM_SID *alias_sid,
+                                const struct dom_sid *alias_sid,
                                 const char *member)
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 alias_rid;
         struct policy_handle alias_pol;
-
-        DOM_SID member_sid;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        struct dom_sid member_sid;
         enum lsa_SidType member_type;
 
-        DOM_SID sid;
+        struct dom_sid sid;
 
         sid_copy(&sid, alias_sid);
@@ -2084 +2379 @@
 
         /* Get sam policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         &sid,
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                        &domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        alias_rid,
-                                       &alias_pol);
-
-        if (!NT_STATUS_IS_OK(result))
+                                       &alias_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
-
-        result = rpccli_samr_DeleteAliasMember(pipe_hnd, mem_ctx,
+        }
+
+        status = dcerpc_samr_DeleteAliasMember(b, mem_ctx,
                                                &alias_pol,
-                                               &member_sid);
-
-        if (!NT_STATUS_IS_OK(result))
-                return result;
+                                               &member_sid,
+                                               &result);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        status = result;
 
  done:
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        return result;
+        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        return status;
 }
 
 static NTSTATUS rpc_group_delmem_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -2132 +2446 @@
                                         const char **argv)
 {
-        DOM_SID group_sid;
+        struct dom_sid group_sid;
         enum lsa_SidType group_type;
 
@@ -2204 +2518 @@
 
 static NTSTATUS rpc_group_list_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -2213 +2527 @@
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         uint32 start_idx=0, max_entries=250, num_entries, i, loop_count = 0;
         struct samr_SamArray *groups = NULL;
@@ -2219 +2533 @@
         bool local = false;
         bool builtin = false;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (c->display_usage) {
@@ -2253 +2568 @@
         /* Get sam policy handle */
 
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -2263 +2583 @@
         /* Get domain policy handle */
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -2282 +2607 @@
                 if (!global) break;
 
-                get_query_dispinfo_params(
+                dcerpc_get_query_dispinfo_params(
                         loop_count, &max_entries, &max_size);
 
-                result = rpccli_samr_QueryDisplayInfo(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_QueryDisplayInfo(b, mem_ctx,
                                                       &domain_pol,
                                                       3,
@@ -2293 +2618 @@
                                                       &total_size,
                                                       &returned_size,
-                                                      &info);
+                                                      &info,
+                                                      &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
                 num_entries = info.info3.count;
                 start_idx += info.info3.count;
@@ -2321 +2650 @@
                 if (!local) break;
 
-                result = rpccli_samr_EnumDomainAliases(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
                                                        &domain_pol,
                                                        &start_idx,
                                                        &groups,
                                                        0xffff,
-                                                       &num_entries);
+                                                       &num_entries,
+                                                       &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
                 if (!NT_STATUS_IS_OK(result) &&
                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
@@ -2339 +2672 @@
                                 struct policy_handle alias_pol;
                                 union samr_AliasInfo *info = NULL;
-
-                                if ((NT_STATUS_IS_OK(rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
-                                                                           &domain_pol,
-                                                                           0x8,
-                                                                           groups->entries[i].idx,
-                                                                           &alias_pol))) &&
-                                    (NT_STATUS_IS_OK(rpccli_samr_QueryAliasInfo(pipe_hnd, mem_ctx,
-                                                                                &alias_pol,
-                                                                                3,
-                                                                                &info))) &&
-                                    (NT_STATUS_IS_OK(rpccli_samr_Close(pipe_hnd, mem_ctx,
-                                                                    &alias_pol)))) {
-                                        description = info->description.string;
+                                NTSTATUS _result;
+
+                                status = dcerpc_samr_OpenAlias(b, mem_ctx,
+                                                               &domain_pol,
+                                                               0x8,
+                                                               groups->entries[i].idx,
+                                                               &alias_pol,
+                                                               &_result);
+                                if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                        status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
+                                                                            &alias_pol,
+                                                                            3,
+                                                                            &info,
+                                                                            &_result);
+                                        if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                                status = dcerpc_samr_Close(b, mem_ctx,
+                                                                           &alias_pol,
+                                                                           &_result);
+                                                if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                                        description = info->description.string;
+                                                }
+                                        }
                                 }
                         }
@@ -2364 +2706 @@
                 }
         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_pol);
+        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
         /* Get builtin policy handle */
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
+                status = result;
+                goto done;
+        }
+
         /* query builtin aliases */
         start_idx = 0;
@@ -2380 +2728 @@
                 if (!builtin) break;
 
-                result = rpccli_samr_EnumDomainAliases(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
                                                        &domain_pol,
                                                        &start_idx,
                                                        &groups,
                                                        max_entries,
-                                                       &num_entries);
+                                                       &num_entries,
+                                                       &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        break;
+                }
                 if (!NT_STATUS_IS_OK(result) &&
-                    !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
+                    !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
+                        status = result;
                         break;
+                }
 
                 for (i = 0; i < num_entries; i++) {
@@ -2398 +2752 @@
                                 struct policy_handle alias_pol;
                                 union samr_AliasInfo *info = NULL;
-
-                                if ((NT_STATUS_IS_OK(rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
-                                                                           &domain_pol,
-                                                                           0x8,
-                                                                           groups->entries[i].idx,
-                                                                           &alias_pol))) &&
-                                    (NT_STATUS_IS_OK(rpccli_samr_QueryAliasInfo(pipe_hnd, mem_ctx,
-                                                                                &alias_pol,
-                                                                                3,
-                                                                                &info))) &&
-                                    (NT_STATUS_IS_OK(rpccli_samr_Close(pipe_hnd, mem_ctx,
-                                                                    &alias_pol)))) {
-                                        description = info->description.string;
+                                NTSTATUS _result;
+
+                                status = dcerpc_samr_OpenAlias(b, mem_ctx,
+                                                               &domain_pol,
+                                                               0x8,
+                                                               groups->entries[i].idx,
+                                                               &alias_pol,
+                                                               &_result);
+                                if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                        status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
+                                                                            &alias_pol,
+                                                                            3,
+                                                                            &info,
+                                                                            &_result);
+                                        if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                                status = dcerpc_samr_Close(b, mem_ctx,
+                                                                           &alias_pol,
+                                                                           &_result);
+                                                if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
+                                                        description = info->description.string;
+                                                }
+                                        }
                                 }
                         }
@@ -2424 +2787 @@
         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
 
+        status = result;
+
  done:
-        return result;
+        return status;
 }
 
@@ -2439 +2804 @@
                                         TALLOC_CTX *mem_ctx,
                                         const char *domain_name,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         struct policy_handle *domain_pol,
                                         uint32 rid)
 {
-        NTSTATUS result;
+        NTSTATUS result, status;
         struct policy_handle group_pol;
         uint32 num_members, *group_rids;
         int i;
-        struct samr_RidTypeArray *rids = NULL;
+        struct samr_RidAttrArray *rids = NULL;
         struct lsa_Strings names;
         struct samr_Ids types;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         fstring sid_str;
         sid_to_fstring(sid_str, domain_sid);
 
-        result = rpccli_samr_OpenGroup(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenGroup(b, mem_ctx,
                                        domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        rid,
-                                       &group_pol);
-
-        if (!NT_STATUS_IS_OK(result))
+                                       &group_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
-
-        result = rpccli_samr_QueryGroupMember(pipe_hnd, mem_ctx,
+        }
+
+        status = dcerpc_samr_QueryGroupMember(b, mem_ctx,
                                               &group_pol,
-                                              &rids);
-
-        if (!NT_STATUS_IS_OK(result))
+                                              &rids,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         num_members = rids->count;
@@ -2479 +2853 @@
                         this_time = num_members;
 
-                result = rpccli_samr_LookupRids(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_LookupRids(b, mem_ctx,
                                                 domain_pol,
                                                 this_time,
                                                 group_rids,
                                                 &names,
-                                                &types);
-
-                if (!NT_STATUS_IS_OK(result))
+                                                &types,
+                                                &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
                         return result;
+                }
 
                 /* We only have users as members, but make the output
@@ -2518 +2896 @@
                                         uint32 rid)
 {
-        NTSTATUS result;
+        NTSTATUS result, status;
         struct rpc_pipe_client *lsa_pipe;
         struct policy_handle alias_pol, lsa_pol;
         uint32 num_members;
-        DOM_SID *alias_sids;
+        struct dom_sid *alias_sids;
         char **domains;
         char **names;
@@ -2528 +2906 @@
         int i;
         struct lsa_SidArray sid_array;
-
-        result = rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                        domain_pol,
                                        MAXIMUM_ALLOWED_ACCESS,
                                        rid,
-                                       &alias_pol);
-
-        if (!NT_STATUS_IS_OK(result))
+                                       &alias_pol,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
-
-        result = rpccli_samr_GetMembersInAlias(pipe_hnd, mem_ctx,
+        }
+
+        status = dcerpc_samr_GetMembersInAlias(b, mem_ctx,
                                                &alias_pol,
-                                               &sid_array);
-
+                                               &sid_array,
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("Couldn't list alias members\n"));
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 d_fprintf(stderr, _("Couldn't list alias members\n"));
@@ -2571 +2958 @@
         }
 
-        alias_sids = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID, num_members);
+        alias_sids = TALLOC_ZERO_ARRAY(mem_ctx, struct dom_sid, num_members);
         if (!alias_sids) {
                 d_fprintf(stderr, _("Out of memory\n"));
@@ -2614 +3001 @@
 
 static NTSTATUS rpc_group_members_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -2622 +3009 @@
                                         const char **argv)
 {
-        NTSTATUS result;
+        NTSTATUS result, status;
         struct policy_handle connect_pol, domain_pol;
         struct samr_Ids rids, rid_types;
         struct lsa_String lsa_acct_name;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* Get sam policy handle */
 
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
-
-        if (!NT_STATUS_IS_OK(result))
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         /* Get domain policy handle */
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
-
-        if (!NT_STATUS_IS_OK(result))
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         init_lsa_String(&lsa_acct_name, argv[0]); /* sure? */
 
-        result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          &domain_pol,
                                          1,
                                          &lsa_acct_name,
                                          &rids,
-                                         &rid_types);
+                                         &rid_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
@@ -2661 +3061 @@
                 /* Ok, did not find it in the global sam, try with builtin */
 
-                DOM_SID sid_Builtin;
-
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_pol);
+                struct dom_sid sid_Builtin;
+
+                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
 
                 sid_copy(&sid_Builtin, &global_sid_Builtin);
 
-                result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                                 &connect_pol,
                                                 MAXIMUM_ALLOWED_ACCESS,
                                                 &sid_Builtin,
-                                                &domain_pol);
-
+                                                &domain_pol,
+                                                &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
                 if (!NT_STATUS_IS_OK(result)) {
                         d_fprintf(stderr, _("Couldn't find group %s\n"),
@@ -2679 +3082 @@
                 }
 
-                result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_LookupNames(b, mem_ctx,
                                                  &domain_pol,
                                                  1,
                                                  &lsa_acct_name,
                                                  &rids,
-                                                 &rid_types);
-
+                                                 &rid_types,
+                                                 &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
                 if (!NT_STATUS_IS_OK(result)) {
                         d_fprintf(stderr, _("Couldn't find group %s\n"),
@@ -2834 +3240 @@
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;
@@ -2975 +3381 @@
         NTSTATUS status;
         union srvsvc_NetShareInfo info;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* no specific share requested, enumerate all */
@@ -2985 +3392 @@
                 info_ctr->level = level;
 
-                status = rpccli_srvsvc_NetShareEnumAll(pipe_hnd, mem_ctx,
+                status = dcerpc_srvsvc_NetShareEnumAll(b, mem_ctx,
                                                        pipe_hnd->desthost,
                                                        info_ctr,
@@ -2992 +3399 @@
                                                        &resume_handle,
                                                        &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return ntstatus_to_werror(status);
+                }
                 return result;
         }
 
         /* request just one share */
-        status = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
                                                pipe_hnd->desthost,
                                                argv[0],
@@ -3003 +3413 @@
                                                &result);
 
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                goto done;
+        }
+
+        if (!W_ERROR_IS_OK(result)) {
                 goto done;
         }
@@ -3024 +3439 @@
 
                 info_ctr->ctr.ctr1 = ctr1;
+
+                break;
         }
         case 2:
@@ -3036 +3453 @@
 
                 info_ctr->ctr.ctr2 = ctr2;
+
+                break;
         }
         case 502:
@@ -3048 +3467 @@
 
                 info_ctr->ctr.ctr502 = ctr502;
+
+                break;
         }
         } /* switch */
@@ -3105 +3526 @@
 static bool check_share_availability(struct cli_state *cli, const char *netname)
 {
-        if (!NT_STATUS_IS_OK(cli_tcon_andx(cli, netname, "A:", "", 0))) {
+        NTSTATUS status;
+
+        status = cli_tcon_andx(cli, netname, "A:", "", 0);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("skipping   [%s]: not a file share.\n"), netname);
                 return false;
         }
 
-        if (!cli_tdis(cli))
+        status = cli_tdis(cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf(_("cli_tdis returned %s\n"), nt_errstr(status));
                 return false;
+        }
 
         return true;
@@ -3157 +3584 @@
 
 static NTSTATUS rpc_share_migrate_shares_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -3173 +3600 @@
         uint32 level = 502; /* includes secdesc */
         uint32_t parm_error = 0;
+        struct dcerpc_binding_handle *b;
 
         result = get_share_info(c, pipe_hnd, mem_ctx, level, argc, argv,
@@ -3185 +3613 @@
                 return nt_status;
 
+        b = srvsvc_pipe->binding_handle;
 
         for (i = 0; i < ctr_src.ctr.ctr502->count; i++) {
@@ -3206 +3635 @@
                 info.info502 = &info502;
 
-                nt_status = rpccli_srvsvc_NetShareAdd(srvsvc_pipe, mem_ctx,
+                nt_status = dcerpc_srvsvc_NetShareAdd(b, mem_ctx,
                                                       srvsvc_pipe->desthost,
                                                       502,
@@ -3212 +3641 @@
                                                       &parm_error,
                                                       &result);
-
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        printf(_("cannot add share: %s\n"),
+                                nt_errstr(nt_status));
+                        goto done;
+                }
                 if (W_ERROR_V(result) == W_ERROR_V(WERR_FILE_EXISTS)) {
                         printf(_("           [%s] does already exist\n"),
@@ -3219 +3652 @@
                 }
 
-                if (!NT_STATUS_IS_OK(nt_status) || !W_ERROR_IS_OK(result)) {
-                        printf(_("cannot add share: %s\n"), win_errstr(result));
+                if (!W_ERROR_IS_OK(result)) {
+                        nt_status = werror_to_ntstatus(result);
+                        printf(_("cannot add share: %s\n"),
+                                win_errstr(result));
                         goto done;
                 }
@@ -3276 +3711 @@
  *
  **/
-static void copy_fn(const char *mnt, file_info *f,
+static NTSTATUS copy_fn(const char *mnt, struct file_info *f,
                     const char *mask, void *state)
 {
@@ -3292 +3727 @@
 
         if (strequal(f->name, ".") || strequal(f->name, ".."))
-                return;
+                return NT_STATUS_OK;
 
         DEBUG(3,("got mask: %s, name: %s\n", mask, f->name));
 
         /* DIRECTORY */
-        if (f->mode & aDIR) {
+        if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
 
                 DEBUG(3,("got dir: %s\n", f->name));
@@ -3320 +3755 @@
                 default:
                         d_fprintf(stderr, _("Unsupported mode %d\n"), net_mode_share);
-                        return;
+                        return NT_STATUS_INTERNAL_ERROR;
                 }
 
-                if (!NT_STATUS_IS_OK(nt_status))
+                if (!NT_STATUS_IS_OK(nt_status)) {
                         printf(_("could not handle dir %s: %s\n"),
                                 dir, nt_errstr(nt_status));
+                        return nt_status;
+                }
 
                 /* search below that directory */
@@ -3333 +3770 @@
                 old_dir = local_state->cwd;
                 local_state->cwd = dir;
-                if (!sync_files(local_state, new_mask))
+                nt_status = sync_files(local_state, new_mask);
+                if (!NT_STATUS_IS_OK(nt_status)) {
                         printf(_("could not handle files\n"));
+                }
                 local_state->cwd = old_dir;
 
-                return;
+                return nt_status;
         }
 
@@ -3363 +3802 @@
                 d_fprintf(stderr, _("Unsupported file mode %d\n"),
                           net_mode_share);
-                return;
+                return NT_STATUS_INTERNAL_ERROR;
         }
 
@@ -3369 +3808 @@
                 printf(_("could not handle file %s: %s\n"),
                         filename, nt_errstr(nt_status));
-
+        return nt_status;
 }
 
@@ -3381 +3820 @@
  * @return              Boolean result
  **/
-static bool sync_files(struct copy_clistate *cp_clistate, const char *mask)
+static NTSTATUS sync_files(struct copy_clistate *cp_clistate, const char *mask)
 {
         struct cli_state *targetcli;
         char *targetpath = NULL;
+        NTSTATUS status;
 
         DEBUG(3,("calling cli_list with mask: %s\n", mask));
@@ -3393 +3833 @@
                                     "%s\n"),
                         mask, cli_errstr(cp_clistate->cli_share_src));
-                return false;
-        }
-
-        if (cli_list(targetcli, targetpath, cp_clistate->attribute, copy_fn, cp_clistate) == -1) {
+                return cli_nt_error(cp_clistate->cli_share_src);
+        }
+
+        status = cli_list(targetcli, targetpath, cp_clistate->attribute,
+                          copy_fn, cp_clistate);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("listing %s failed with error: %s\n"),
-                        mask, cli_errstr(targetcli));
-                return false;
-        }
-
-        return true;
+                          mask, nt_errstr(status));
+        }
+
+        return status;
 }
 
@@ -3462 +3903 @@
 
 static NTSTATUS rpc_share_migrate_files_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -3529 +3970 @@
                 cp_clistate.cli_share_dst = NULL;
                 cp_clistate.cwd = NULL;
-                cp_clistate.attribute = aSYSTEM | aHIDDEN | aDIR;
+                cp_clistate.attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
                 cp_clistate.c = c;
 
@@ -3559 +4000 @@
                 }
 
-                if (!sync_files(&cp_clistate, mask)) {
+                nt_status = sync_files(&cp_clistate, mask);
+                if (!NT_STATUS_IS_OK(nt_status)) {
                         d_fprintf(stderr, _("could not handle files for share: "
                                             "%s\n"), info502.name);
-                        nt_status = NT_STATUS_UNSUCCESSFUL;
                         goto done;
                 }
@@ -3620 +4061 @@
 
 static NTSTATUS rpc_share_migrate_security_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -3637 +4078 @@
         uint32 level = 502; /* includes secdesc */
         uint32_t parm_error = 0;
+        struct dcerpc_binding_handle *b;
 
         result = get_share_info(c, pipe_hnd, mem_ctx, level, argc, argv,
@@ -3650 +4092 @@
                 return nt_status;
 
+        b = srvsvc_pipe->binding_handle;
 
         for (i = 0; i < ctr_src.ctr.ctr502->count; i++) {
@@ -3673 +4116 @@
 
                 /* finally modify the share on the dst server */
-                nt_status = rpccli_srvsvc_NetShareSetInfo(srvsvc_pipe, mem_ctx,
+                nt_status = dcerpc_srvsvc_NetShareSetInfo(b, mem_ctx,
                                                           srvsvc_pipe->desthost,
                                                           info502.name,
@@ -3680 +4123 @@
                                                           &parm_error,
                                                           &result);
-                if (!NT_STATUS_IS_OK(nt_status) || !W_ERROR_IS_OK(result)) {
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        printf(_("cannot set share-acl: %s\n"),
+                               nt_errstr(nt_status));
+                        goto done;
+                }
+                if (!W_ERROR_IS_OK(result)) {
+                        nt_status = werror_to_ntstatus(result);
                         printf(_("cannot set share-acl: %s\n"),
                                win_errstr(result));
@@ -3830 +4279 @@
 
 struct full_alias {
-        DOM_SID sid;
+        struct dom_sid sid;
         uint32 num_members;
-        DOM_SID *members;
+        struct dom_sid *members;
 };
 
@@ -3858 +4307 @@
                                         TALLOC_CTX *mem_ctx,
                                         struct policy_handle *connect_pol,
-                                        const DOM_SID *domain_sid)
+                                        const struct dom_sid *domain_sid)
 {
         uint32 start_idx, max_entries, num_entries, i;
         struct samr_SamArray *groups = NULL;
-        NTSTATUS result;
+        NTSTATUS result, status;
         struct policy_handle domain_pol;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* Get domain policy handle */
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
-        if (!NT_STATUS_IS_OK(result))
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         start_idx = 0;
@@ -3879 +4334 @@
 
         do {
-                result = rpccli_samr_EnumDomainAliases(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
                                                        &domain_pol,
                                                        &start_idx,
                                                        &groups,
                                                        max_entries,
-                                                       &num_entries);
+                                                       &num_entries,
+                                                       &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
                 for (i = 0; i < num_entries; i++) {
 
@@ -3891 +4350 @@
                         struct lsa_SidArray sid_array;
                         int j;
-
-                        result = rpccli_samr_OpenAlias(pipe_hnd, mem_ctx,
+                        NTSTATUS _result;
+
+                        status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                                        &domain_pol,
                                                        MAXIMUM_ALLOWED_ACCESS,
                                                        groups->entries[i].idx,
-                                                       &alias_pol);
-                        if (!NT_STATUS_IS_OK(result))
+                                                       &alias_pol,
+                                                       &_result);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto done;
-
-                        result = rpccli_samr_GetMembersInAlias(pipe_hnd, mem_ctx,
+                        }
+                        if (!NT_STATUS_IS_OK(_result)) {
+                                status = _result;
+                                goto done;
+                        }
+
+                        status = dcerpc_samr_GetMembersInAlias(b, mem_ctx,
                                                                &alias_pol,
-                                                               &sid_array);
-                        if (!NT_STATUS_IS_OK(result))
+                                                               &sid_array,
+                                                               &_result);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto done;
+                        }
+                        if (!NT_STATUS_IS_OK(_result)) {
+                                status = _result;
+                                goto done;
+                        }
 
                         alias.num_members = sid_array.num_sids;
 
-                        result = rpccli_samr_Close(pipe_hnd, mem_ctx, &alias_pol);
-                        if (!NT_STATUS_IS_OK(result))
+                        status = dcerpc_samr_Close(b, mem_ctx, &alias_pol, &_result);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto done;
+                        }
+                        if (!NT_STATUS_IS_OK(_result)) {
+                                status = _result;
+                                goto done;
+                        }
 
                         alias.members = NULL;
 
                         if (alias.num_members > 0) {
-                                alias.members = SMB_MALLOC_ARRAY(DOM_SID, alias.num_members);
+                                alias.members = SMB_MALLOC_ARRAY(struct dom_sid, alias.num_members);
 
                                 for (j = 0; j < alias.num_members; j++)
@@ -3922 +4399 @@
                         }
 
-                        sid_copy(&alias.sid, domain_sid);
-                        sid_append_rid(&alias.sid, groups->entries[i].idx);
+                        sid_compose(&alias.sid, domain_sid,
+                                    groups->entries[i].idx);
 
                         push_alias(mem_ctx, &alias);
@@ -3929 +4406 @@
         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
 
-        result = NT_STATUS_OK;
+        status = NT_STATUS_OK;
 
  done:
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_pol);
-
-        return result;
+        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
+
+        return status;
 }
 
@@ -3942 +4419 @@
 
 static NTSTATUS rpc_aliaslist_dump(struct net_context *c,
-                                const DOM_SID *domain_sid,
+                                const struct dom_sid *domain_sid,
                                 const char *domain_name,
                                 struct cli_state *cli,
@@ -3953 +4430 @@
         NTSTATUS result;
         struct policy_handle lsa_pol;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
@@ -3997 +4475 @@
         }
 
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
+        dcerpc_lsa_Close(b, mem_ctx, &lsa_pol, &result);
 
         return NT_STATUS_OK;
@@ -4008 +4486 @@
 
 static NTSTATUS rpc_aliaslist_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -4016 +4494 @@
                                         const char **argv)
 {
-        NTSTATUS result;
+        NTSTATUS result, status;
         struct policy_handle connect_pol;
-
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
-
-        result = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+
+        status = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
                                           &global_sid_Builtin);
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
-
-        result = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
                                           domain_sid);
 
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
+        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
  done:
-        return result;
-}
-
-static void init_user_token(NT_USER_TOKEN *token, DOM_SID *user_sid)
+        return status;
+}
+
+static void init_user_token(struct security_token *token, struct dom_sid *user_sid)
 {
         token->num_sids = 4;
 
-        if (!(token->user_sids = SMB_MALLOC_ARRAY(DOM_SID, 4))) {
+        if (!(token->sids = SMB_MALLOC_ARRAY(struct dom_sid, 4))) {
                 d_fprintf(stderr, "malloc %s\n",_("failed"));
                 token->num_sids = 0;
@@ -4051 +4535 @@
         }
 
-        token->user_sids[0] = *user_sid;
-        sid_copy(&token->user_sids[1], &global_sid_World);
-        sid_copy(&token->user_sids[2], &global_sid_Network);
-        sid_copy(&token->user_sids[3], &global_sid_Authenticated_Users);
-}
-
-static void free_user_token(NT_USER_TOKEN *token)
-{
-        SAFE_FREE(token->user_sids);
-}
-
-static void add_sid_to_token(NT_USER_TOKEN *token, DOM_SID *sid)
-{
-        if (is_sid_in_token(token, sid))
+        token->sids[0] = *user_sid;
+        sid_copy(&token->sids[1], &global_sid_World);
+        sid_copy(&token->sids[2], &global_sid_Network);
+        sid_copy(&token->sids[3], &global_sid_Authenticated_Users);
+}
+
+static void free_user_token(struct security_token *token)
+{
+        SAFE_FREE(token->sids);
+}
+
+static void add_sid_to_token(struct security_token *token, struct dom_sid *sid)
+{
+        if (security_token_has_sid(token, sid))
                 return;
 
-        token->user_sids = SMB_REALLOC_ARRAY(token->user_sids, DOM_SID, token->num_sids+1);
-        if (!token->user_sids) {
+        token->sids = SMB_REALLOC_ARRAY(token->sids, struct dom_sid, token->num_sids+1);
+        if (!token->sids) {
                 return;
         }
 
-        sid_copy(&token->user_sids[token->num_sids], sid);
+        sid_copy(&token->sids[token->num_sids], sid);
 
         token->num_sids += 1;
@@ -4079 +4563 @@
 struct user_token {
         fstring name;
-        NT_USER_TOKEN token;
+        struct security_token token;
 };
 
@@ -4089 +4573 @@
 
         for (i=0; i<token->token.num_sids; i++) {
-                d_printf(" %s\n", sid_string_tos(&token->token.user_sids[i]));
-        }
-}
-
-static bool is_alias_member(DOM_SID *sid, struct full_alias *alias)
+                d_printf(" %s\n", sid_string_tos(&token->token.sids[i]));
+        }
+}
+
+static bool is_alias_member(struct dom_sid *sid, struct full_alias *alias)
 {
         int i;
 
         for (i=0; i<alias->num_members; i++) {
-                if (sid_compare(sid, &alias->members[i]) == 0)
+                if (dom_sid_compare(sid, &alias->members[i]) == 0)
                         return true;
         }
@@ -4105 +4589 @@
 }
 
-static void collect_sid_memberships(NT_USER_TOKEN *token, DOM_SID sid)
+static void collect_sid_memberships(struct security_token *token, struct dom_sid sid)
 {
         int i;
@@ -4122 +4606 @@
  */
 
-static void collect_alias_memberships(NT_USER_TOKEN *token)
+static void collect_alias_memberships(struct security_token *token)
 {
         int num_global_sids = token->num_sids;
@@ -4128 +4612 @@
 
         for (i=0; i<num_global_sids; i++) {
-                collect_sid_memberships(token, token->user_sids[i]);
-        }
-}
-
-static bool get_user_sids(const char *domain, const char *user, NT_USER_TOKEN *token)
+                collect_sid_memberships(token, token->sids[i]);
+        }
+}
+
+static bool get_user_sids(const char *domain, const char *user, struct security_token *token)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -4138 +4622 @@
         fstring full_name;
         struct wbcDomainSid wsid;
-        char *sid_str = NULL;
-        DOM_SID user_sid;
+        char sid_str[WBC_SID_STRING_BUFLEN];
+        struct dom_sid user_sid;
         uint32_t num_groups;
         gid_t *groups = NULL;
@@ -4157 +4641 @@
         }
 
-        wbc_status = wbcSidToString(&wsid, &sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
-
-        if (type != SID_NAME_USER) {
-                wbcFreeMemory(sid_str);
+        wbcSidToStringBuf(&wsid, sid_str, sizeof(sid_str));
+
+        if (type != WBC_SID_NAME_USER) {
                 DEBUG(1, ("%s is not a user\n", full_name));
                 return false;
@@ -4172 +4652 @@
                 return false;
         }
-
-        wbcFreeMemory(sid_str);
-        sid_str = NULL;
 
         init_user_token(token, &user_sid);
@@ -4189 +4666 @@
         for (i = 0; i < num_groups; i++) {
                 gid_t gid = groups[i];
-                DOM_SID sid;
+                struct dom_sid sid;
 
                 wbc_status = wbcGidToSid(gid, &wsid);
@@ -4199 +4676 @@
                 }
 
-                wbc_status = wbcSidToString(&wsid, &sid_str);
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        wbcFreeMemory(groups);
-                        return false;
-                }
+                wbcSidToStringBuf(&wsid, sid_str, sizeof(sid_str));
 
                 DEBUG(3, (" %s\n", sid_str));
 
                 string_to_sid(&sid, sid_str);
-                wbcFreeMemory(sid_str);
-                sid_str = NULL;
-
                 add_sid_to_token(token, &sid);
         }
@@ -4277 +4747 @@
 
                 get_user_sids(domain, user, &(result[i].token));
-                i+=1;
         }
         TALLOC_FREE(frame);
@@ -4308 +4777 @@
                         /* We have a SID */
 
-                        DOM_SID sid;
+                        struct dom_sid sid;
                         if(!string_to_sid(&sid, &line[1])) {
                                 DEBUG(1,("get_user_tokens_from_file: Could "
@@ -4337 +4806 @@
                 fstrcpy(token->name, line);
                 token->token.num_sids = 0;
-                token->token.user_sids = NULL;
+                token->token.sids = NULL;
                 continue;
         }
@@ -4356 +4825 @@
 {
         uint16_t fnum;
-        SEC_DESC *share_sd = NULL;
-        SEC_DESC *root_sd = NULL;
+        struct security_descriptor *share_sd = NULL;
+        struct security_descriptor *root_sd = NULL;
         struct cli_state *cli = rpc_pipe_np_smb_conn(pipe_hnd);
         int i;
@@ -4364 +4833 @@
         NTSTATUS status;
         uint16 cnum;
-
-        status = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
                                                pipe_hnd->desthost,
                                                netname,
@@ -4472 +4942 @@
 
 static NTSTATUS rpc_share_allowedusers_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -4668 +5138 @@
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;
@@ -4761 +5231 @@
         WERROR result;
         NTSTATUS status;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1) {
@@ -4767 +5238 @@
         }
 
-        status = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
                                                pipe_hnd->desthost,
                                                argv[0],
@@ -4773 +5244 @@
                                                &info,
                                                &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result)) {
                 goto done;
         }
@@ -4944 +5419 @@
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;
@@ -4987 +5462 @@
 
 static NTSTATUS rpc_shutdown_abort_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -4995 +5470 @@
                                         const char **argv)
 {
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
-
-        result = rpccli_initshutdown_Abort(pipe_hnd, mem_ctx, NULL, NULL);
-
-        if (NT_STATUS_IS_OK(result)) {
+        NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+        WERROR result;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_initshutdown_Abort(b, mem_ctx, NULL, &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (W_ERROR_IS_OK(result)) {
                 d_printf(_("\nShutdown successfully aborted\n"));
                 DEBUG(5,("cmd_shutdown_abort: query succeeded\n"));
@@ -5005 +5484 @@
                 DEBUG(5,("cmd_shutdown_abort: query failed\n"));
 
-        return result;
+        return werror_to_ntstatus(result);
 }
 
@@ -5026 +5505 @@
 
 static NTSTATUS rpc_reg_shutdown_abort_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -5035 +5514 @@
 {
         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
-
-        result = rpccli_winreg_AbortSystemShutdown(pipe_hnd, mem_ctx, NULL, NULL);
-
-        if (NT_STATUS_IS_OK(result)) {
+        WERROR werr;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        result = dcerpc_winreg_AbortSystemShutdown(b, mem_ctx, NULL, &werr);
+
+        if (!NT_STATUS_IS_OK(result)) {
+                DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
+                return result;
+        }
+        if (W_ERROR_IS_OK(werr)) {
                 d_printf(_("\nShutdown successfully aborted\n"));
                 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
@@ -5044 +5529 @@
                 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
 
-        return result;
+        return werror_to_ntstatus(werr);
 }
 
@@ -5102 +5587 @@
 
 NTSTATUS rpc_init_shutdown_internals(struct net_context *c,
-                                     const DOM_SID *domain_sid,
+                                     const struct dom_sid *domain_sid,
                                      const char *domain_name,
                                      struct cli_state *cli,
@@ -5110 +5595 @@
                                      const char **argv)
 {
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+        WERROR result;
         const char *msg = N_("This machine will be shutdown shortly");
         uint32 timeout = 20;
         struct lsa_StringLarge msg_string;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (c->opt_comment) {
@@ -5125 +5612 @@
 
         /* create an entry */
-        result = rpccli_initshutdown_Init(pipe_hnd, mem_ctx, NULL,
+        status = dcerpc_initshutdown_Init(b, mem_ctx, NULL,
                         &msg_string, timeout, c->opt_force, c->opt_reboot,
-                        NULL);
-
-        if (NT_STATUS_IS_OK(result)) {
+                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (W_ERROR_IS_OK(result)) {
                 d_printf(_("\nShutdown of remote machine succeeded\n"));
                 DEBUG(5,("Shutdown of remote machine succeeded\n"));
@@ -5135 +5624 @@
                 DEBUG(1,("Shutdown of remote machine failed!\n"));
         }
-        return result;
+        return werror_to_ntstatus(result);
 }
 
@@ -5156 +5645 @@
 
 NTSTATUS rpc_reg_shutdown_internals(struct net_context *c,
-                                    const DOM_SID *domain_sid,
+                                    const struct dom_sid *domain_sid,
                                     const char *domain_name,
                                     struct cli_state *cli,
@@ -5169 +5658 @@
         NTSTATUS result;
         WERROR werr;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (c->opt_comment) {
@@ -5180 +5670 @@
 
         /* create an entry */
-        result = rpccli_winreg_InitiateSystemShutdown(pipe_hnd, mem_ctx, NULL,
+        result = dcerpc_winreg_InitiateSystemShutdown(b, mem_ctx, NULL,
                         &msg_string, timeout, c->opt_force, c->opt_reboot,
                         &werr);
-
-        if (NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(result)) {
+                d_fprintf(stderr, "\nShutdown of remote machine failed\n");
+                return result;
+        }
+
+        if (W_ERROR_IS_OK(werr)) {
                 d_printf(_("\nShutdown of remote machine succeeded\n"));
         } else {
@@ -5194 +5688 @@
         }
 
-        return result;
+        return werror_to_ntstatus(werr);
 }
 
@@ -5253 +5747 @@
 
 static NTSTATUS rpc_trustdom_add_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -5262 +5756 @@
 {
         struct policy_handle connect_pol, domain_pol, user_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         char *acct_name;
         struct lsa_String lsa_acct_name;
@@ -5271 +5765 @@
         union samr_UserInfo info;
         unsigned int orig_timeout;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 2) {
@@ -5293 +5788 @@
 
         /* Get samr policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -5324 +5829 @@
                      SAMR_USER_ACCESS_SET_ATTRIBUTES;
 
-        result = rpccli_samr_CreateUser2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_CreateUser2(b, mem_ctx,
                                          &domain_pol,
                                          &lsa_acct_name,
@@ -5331 +5836 @@
                                          &user_pol,
                                          &access_granted,
-                                         &user_rid);
-
+                                         &user_rid,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         /* And restore our original timeout. */
         rpccli_set_timeout(pipe_hnd, orig_timeout);
 
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_printf(_("net rpc trustdom add: create user %s failed %s\n"),
                         acct_name, nt_errstr(result));
@@ -5356 +5865 @@
                 info.info23.password = crypt_pwd;
 
-                result = rpccli_samr_SetUserInfo2(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_SetUserInfo2(b, mem_ctx,
                                                   &user_pol,
                                                   23,
-                                                  &info);
+                                                  &info,
+                                                  &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
 
                 if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
                         DEBUG(0,("Could not set trust account password: %s\n",
                                  nt_errstr(result)));
@@ -5370 +5884 @@
  done:
         SAFE_FREE(acct_name);
-        return result;
+        return status;
 }
 
@@ -5414 +5928 @@
 
 static NTSTATUS rpc_trustdom_del_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -5423 +5937 @@
 {
         struct policy_handle connect_pol, domain_pol, user_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         char *acct_name;
-        DOM_SID trust_acct_sid;
+        struct dom_sid trust_acct_sid;
         struct samr_Ids user_rids, name_types;
         struct lsa_String lsa_acct_name;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1) {
@@ -5447 +5962 @@
 
         /* Get samr policy handle */
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
 
         /* Get domain policy handle */
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         CONST_DISCARD(struct dom_sid2 *, domain_sid),
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -5467 +5992 @@
         init_lsa_String(&lsa_acct_name, acct_name);
 
-        result = rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          &domain_pol,
                                          1,
                                          &lsa_acct_name,
                                          &user_rids,
-                                         &name_types);
-
+                                         &name_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf(_("net rpc trustdom del: LookupNames on user %s "
+                           "failed %s\n"),
+                        acct_name, nt_errstr(status));
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_printf(_("net rpc trustdom del: LookupNames on user %s "
                            "failed %s\n"),
@@ -5481 +6013 @@
         }
 
-        result = rpccli_samr_OpenUser(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenUser(b, mem_ctx,
                                       &domain_pol,
                                       MAXIMUM_ALLOWED_ACCESS,
                                       user_rids.ids[0],
-                                      &user_pol);
+                                      &user_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf(_("net rpc trustdom del: OpenUser on user %s failed "
+                           "%s\n"),
+                        acct_name, nt_errstr(status) );
+                goto done;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_printf(_("net rpc trustdom del: OpenUser on user %s failed "
                            "%s\n"),
@@ -5495 +6035 @@
 
         /* append the rid to the domain sid */
-        sid_copy(&trust_acct_sid, domain_sid);
-        if (!sid_append_rid(&trust_acct_sid, user_rids.ids[0])) {
+        if (!sid_compose(&trust_acct_sid, domain_sid, user_rids.ids[0])) {
                 goto done;
         }
@@ -5502 +6041 @@
         /* remove the sid */
 
-        result = rpccli_samr_RemoveMemberFromForeignDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_RemoveMemberFromForeignDomain(b, mem_ctx,
                                                            &user_pol,
-                                                           &trust_acct_sid);
+                                                           &trust_acct_sid,
+                                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf(_("net rpc trustdom del: RemoveMemberFromForeignDomain"
+                           " on user %s failed %s\n"),
+                        acct_name, nt_errstr(status));
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_printf(_("net rpc trustdom del: RemoveMemberFromForeignDomain"
                            " on user %s failed %s\n"),
@@ -5512 +6059 @@
         }
 
+
         /* Delete user */
 
-        result = rpccli_samr_DeleteUser(pipe_hnd, mem_ctx,
-                                        &user_pol);
+        status = dcerpc_samr_DeleteUser(b, mem_ctx,
+                                        &user_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_printf(_("net rpc trustdom del: DeleteUser on user %s failed "
+                           "%s\n"),
+                        acct_name, nt_errstr(status));
+                goto done;
+        }
 
         if (!NT_STATUS_IS_OK(result)) {
+                result = status;
                 d_printf(_("net rpc trustdom del: DeleteUser on user %s failed "
                            "%s\n"),
@@ -5531 +6087 @@
 
  done:
-        return result;
+        return status;
 }
 
@@ -5565 +6121 @@
         struct rpc_pipe_client *netr;
         NTSTATUS status;
+        WERROR result;
+        struct dcerpc_binding_handle *b;
 
         /* Use NetServerEnum2 */
@@ -5584 +6142 @@
         }
 
-        status = rpccli_netr_GetDcName(netr, mem_ctx,
+        b = netr->binding_handle;
+
+        status = dcerpc_netr_GetDcName(b, mem_ctx,
                                        cli->desthost,
                                        domain_name,
                                        &buffer,
-                                       NULL);
+                                       &result);
         TALLOC_FREE(netr);
 
-        if (NT_STATUS_IS_OK(status)) {
+        if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
                 return status;
         }
@@ -5598 +6158 @@
                  for domain %s\n", domain_name));
 
-        return status;
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        return werror_to_ntstatus(result);
 }
 
@@ -5620 +6184 @@
         struct policy_handle connect_hnd;
         TALLOC_CTX *mem_ctx;
-        NTSTATUS nt_status;
-        DOM_SID *domain_sid;
+        NTSTATUS nt_status, result;
+        struct dom_sid *domain_sid;
 
         char* domain_name;
@@ -5627 +6191 @@
         fstring pdc_name;
         union lsa_PolicyInformation *info = NULL;
+        struct dcerpc_binding_handle *b;
 
         /*
@@ -5719 +6284 @@
                 return -1;
         }
+
+        b = pipe_hnd->binding_handle;
 
         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, true, KEY_QUERY_VALUE,
@@ -5732 +6299 @@
         /* Querying info level 5 */
 
-        nt_status = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        nt_status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                                &connect_hnd,
                                                LSA_POLICY_INFO_ACCOUNT_DOMAIN,
-                                               &info);
+                                               &info,
+                                               &result);
         if (NT_STATUS_IS_ERR(nt_status)) {
                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
@@ -5743 +6311 @@
                 return -1;
         }
+        if (NT_STATUS_IS_ERR(result)) {
+                DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
+                        nt_errstr(result)));
+                cli_shutdown(cli);
+                talloc_destroy(mem_ctx);
+                return -1;
+        }
 
         domain_sid = info->account_domain.sid;
@@ -5764 +6339 @@
          */
 
-        nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
+        nt_status = dcerpc_lsa_Close(b, mem_ctx, &connect_hnd, &result);
         if (NT_STATUS_IS_ERR(nt_status)) {
                 DEBUG(0, ("Couldn't close LSA pipe. Error was %s\n",
@@ -5824 +6399 @@
 
 static NTSTATUS rpc_query_domain_sid(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -5840 +6415 @@
 }
 
-static void print_trusted_domain(DOM_SID *dom_sid, const char *trusted_dom_name)
+static void print_trusted_domain(struct dom_sid *dom_sid, const char *trusted_dom_name)
 {
         fstring ascii_sid;
@@ -5853 +6428 @@
                                       TALLOC_CTX *mem_ctx,
                                       struct policy_handle *pol,
-                                      DOM_SID dom_sid,
+                                      struct dom_sid dom_sid,
                                       const char *trusted_dom_name)
 {
-        NTSTATUS nt_status;
+        NTSTATUS nt_status, result;
         union lsa_TrustedDomainInfo *info = NULL;
         char *cleartextpwd = NULL;
@@ -5862 +6437 @@
         DATA_BLOB session_key_blob;
         DATA_BLOB data = data_blob_null;
-
-        nt_status = rpccli_lsa_QueryTrustedDomainInfoBySid(pipe_hnd, mem_ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        nt_status = dcerpc_lsa_QueryTrustedDomainInfoBySid(b, mem_ctx,
                                                            pol,
                                                            &dom_sid,
                                                            LSA_TRUSTED_DOMAIN_INFO_PASSWORD,
-                                                           &info);
+                                                           &info,
+                                                           &result);
         if (NT_STATUS_IS_ERR(nt_status)) {
                 DEBUG(0,("Could not query trusted domain info. Error was %s\n",
                 nt_errstr(nt_status)));
+                goto done;
+        }
+        if (NT_STATUS_IS_ERR(result)) {
+                nt_status = result;
+                DEBUG(0,("Could not query trusted domain info. Error was %s\n",
+                nt_errstr(result)));
                 goto done;
         }
@@ -5917 +6500 @@
         struct cli_state *cli = NULL;
         struct rpc_pipe_client *pipe_hnd = NULL;
-        NTSTATUS nt_status;
+        NTSTATUS nt_status, result;
         const char *domain_name = NULL;
-        DOM_SID *queried_dom_sid;
+        struct dom_sid *queried_dom_sid;
         struct policy_handle connect_hnd;
         union lsa_PolicyInformation *info = NULL;
@@ -5928 +6511 @@
         struct lsa_DomainList dom_list;
         fstring pdc_name;
+        struct dcerpc_binding_handle *b;
 
         if (c->display_usage) {
@@ -5977 +6561 @@
         };
 
+        b = pipe_hnd->binding_handle;
+
         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, false, KEY_QUERY_VALUE,
                                         &connect_hnd);
@@ -5988 +6574 @@
 
         /* query info level 5 to obtain sid of a domain being queried */
-        nt_status = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        nt_status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                                &connect_hnd,
                                                LSA_POLICY_INFO_ACCOUNT_DOMAIN,
-                                               &info);
+                                               &info,
+                                               &result);
 
         if (NT_STATUS_IS_ERR(nt_status)) {
@@ -6000 +6587 @@
                 return -1;
         }
+        if (NT_STATUS_IS_ERR(result)) {
+                DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
+                        nt_errstr(result)));
+                cli_shutdown(cli);
+                talloc_destroy(mem_ctx);
+                return -1;
+        }
 
         queried_dom_sid = info->account_domain.sid;
@@ -6011 +6605 @@
 
         do {
-                nt_status = rpccli_lsa_EnumTrustDom(pipe_hnd, mem_ctx,
+                nt_status = dcerpc_lsa_EnumTrustDom(b, mem_ctx,
                                                     &connect_hnd,
                                                     &enum_ctx,
                                                     &dom_list,
-                                                    (uint32_t)-1);
+                                                    (uint32_t)-1,
+                                                    &result);
                 if (NT_STATUS_IS_ERR(nt_status)) {
                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
@@ -6023 +6618 @@
                         return -1;
                 };
+                if (NT_STATUS_IS_ERR(result)) {
+                        nt_status = result;
+                        DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
+                                nt_errstr(result)));
+                        cli_shutdown(cli);
+                        talloc_destroy(mem_ctx);
+                        return -1;
+                };
+
 
                 for (i = 0; i < dom_list.count; i++) {
@@ -6048 +6652 @@
 
         /* close this connection before doing next one */
-        nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
+        nt_status = dcerpc_lsa_Close(b, mem_ctx, &connect_hnd, &result);
         if (NT_STATUS_IS_ERR(nt_status)) {
                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
@@ -6070 +6674 @@
         struct cli_state *cli = NULL, *remote_cli = NULL;
         struct rpc_pipe_client *pipe_hnd = NULL;
-        NTSTATUS nt_status;
+        NTSTATUS nt_status, result;
         const char *domain_name = NULL;
-        DOM_SID *queried_dom_sid;
+        struct dom_sid *queried_dom_sid;
         int ascii_dom_name_len;
         struct policy_handle connect_hnd;
         union lsa_PolicyInformation *info = NULL;
+        struct dcerpc_binding_handle *b = NULL;
 
         /* trusted domains listing variables */
@@ -6135 +6740 @@
                 return -1;
         };
+
+        b = pipe_hnd->binding_handle;
 
         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, false, KEY_QUERY_VALUE,
@@ -6147 +6754 @@
         
         /* query info level 5 to obtain sid of a domain being queried */
-        nt_status = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        nt_status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                                &connect_hnd,
                                                LSA_POLICY_INFO_ACCOUNT_DOMAIN,
-                                               &info);
+                                               &info,
+                                               &result);
 
         if (NT_STATUS_IS_ERR(nt_status)) {
@@ -6159 +6767 @@
                 return -1;
         }
+        if (NT_STATUS_IS_ERR(result)) {
+                DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
+                        nt_errstr(result)));
+                cli_shutdown(cli);
+                talloc_destroy(mem_ctx);
+                return -1;
+        }
 
         queried_dom_sid = info->account_domain.sid;
@@ -6172 +6787 @@
 
         do {
-                nt_status = rpccli_lsa_EnumTrustDom(pipe_hnd, mem_ctx,
+                nt_status = dcerpc_lsa_EnumTrustDom(b, mem_ctx,
                                                     &connect_hnd,
                                                     &enum_ctx,
                                                     &dom_list,
-                                                    (uint32_t)-1);
+                                                    (uint32_t)-1,
+                                                    &result);
                 if (NT_STATUS_IS_ERR(nt_status)) {
                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
@@ -6184 +6800 @@
                         return -1;
                 };
+                if (NT_STATUS_IS_ERR(result)) {
+                        DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
+                                nt_errstr(result)));
+                        cli_shutdown(cli);
+                        talloc_destroy(mem_ctx);
+                        return -1;
+                };
+
 
                 for (i = 0; i < dom_list.count; i++) {
@@ -6203 +6827 @@
 
         /* close this connection before doing next one */
-        nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
+        nt_status = dcerpc_lsa_Close(b, mem_ctx, &connect_hnd, &result);
         if (NT_STATUS_IS_ERR(nt_status)) {
                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
@@ -6232 +6856 @@
         };
 
+        b = pipe_hnd->binding_handle;
+
         /* SamrConnect2 */
-        nt_status = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        nt_status = dcerpc_samr_Connect2(b, mem_ctx,
                                          pipe_hnd->desthost,
                                          SAMR_ACCESS_LOOKUP_DOMAIN,
-                                         &connect_hnd);
+                                         &connect_hnd,
+                                         &result);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0, ("Couldn't open SAMR policy handle. Error was %s\n",
@@ -6244 +6871 @@
                 return -1;
         };
+        if (!NT_STATUS_IS_OK(result)) {
+                nt_status = result;
+                DEBUG(0, ("Couldn't open SAMR policy handle. Error was %s\n",
+                        nt_errstr(result)));
+                cli_shutdown(cli);
+                talloc_destroy(mem_ctx);
+                return -1;
+        };
 
         /* SamrOpenDomain - we have to open domain policy handle in order to be
            able to enumerate accounts*/
-        nt_status = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        nt_status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                            &connect_hnd,
                                            SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS,
                                            queried_dom_sid,
-                                           &domain_hnd);
+                                           &domain_hnd,
+                                           &result);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0, ("Couldn't open domain object. Error was %s\n",
@@ -6259 +6895 @@
                 return -1;
         };
+        if (!NT_STATUS_IS_OK(result)) {
+                nt_status = result;
+                DEBUG(0, ("Couldn't open domain object. Error was %s\n",
+                        nt_errstr(result)));
+                cli_shutdown(cli);
+                talloc_destroy(mem_ctx);
+                return -1;
+        };
 
         /*
@@ -6269 +6913 @@
         do {
 
-                nt_status = rpccli_samr_EnumDomainUsers(pipe_hnd, mem_ctx,
+                nt_status = dcerpc_samr_EnumDomainUsers(b, mem_ctx,
                                                         &domain_hnd,
                                                         &enum_ctx,
@@ -6275 +6919 @@
                                                         &trusts,
                                                         0xffff,
-                                                        &num_domains);
+                                                        &num_domains,
+                                                        &result);
                 if (NT_STATUS_IS_ERR(nt_status)) {
                         DEBUG(0, ("Couldn't enumerate accounts. Error was: %s\n",
                                 nt_errstr(nt_status)));
+                        cli_shutdown(cli);
+                        talloc_destroy(mem_ctx);
+                        return -1;
+                };
+                if (NT_STATUS_IS_ERR(result)) {
+                        nt_status = result;
+                        DEBUG(0, ("Couldn't enumerate accounts. Error was: %s\n",
+                                nt_errstr(result)));
                         cli_shutdown(cli);
                         talloc_destroy(mem_ctx);
@@ -6331 +6984 @@
                 }
 
-        } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
+        } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
 
         if (!found_domain) {
@@ -6338 +6991 @@
 
         /* close opened samr and domain policy handles */
-        nt_status = rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_hnd);
+        nt_status = dcerpc_samr_Close(b, mem_ctx, &domain_hnd, &result);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0, ("Couldn't properly close domain policy handle for domain %s\n", domain_name));
         };
 
-        nt_status = rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_hnd);
+        nt_status = dcerpc_samr_Close(b, mem_ctx, &connect_hnd, &result);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0, ("Couldn't properly close samr policy handle for domain %s\n", domain_name));
@@ -6521 +7174 @@
                 }
 
-                return run_rpc_command(c, NULL, &ndr_table_netlogon.syntax_id,
-                                       NET_FLAGS_ANONYMOUS,
-                                       rpc_vampire_internals,
-                                       argc, argv);
+                return rpc_vampire_passdb(c, argc, argv);
         }
 
@@ -7349 +7999 @@
                            "    Open interactive shell on remote server")
                 },
+                {
+                        "trust",
+                        net_rpc_trust,
+                        NET_TRANSPORT_RPC,
+                        N_("Manage trusts"),
+                        N_("net rpc trust\n"
+                           "    Manage trusts")
+                },
                 {NULL, NULL, 0, NULL, NULL}
         };
 
-        status = libnetapi_init(&c->netapi_ctx);
+        status = libnetapi_net_init(&c->netapi_ctx);
         if (status != 0) {
                 return -1;

vendor/current/source3/utils/net_rpc_audit.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_lsa.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
 
 /********************************************************************
@@ -56 +58 @@
 
 static NTSTATUS rpc_audit_get_internal(struct net_context *c,
-                                       const DOM_SID *domain_sid,
+                                       const struct dom_sid *domain_sid,
                                        const char *domain_name,
                                        struct cli_state *cli,
@@ -65 +67 @@
 {
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union lsa_PolicyInformation *info = NULL;
         int i;
         uint32_t audit_category;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc < 1 || argc > 2) {
@@ -81 +84 @@
         }
 
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                                         SEC_FLAG_MAXIMUM_ALLOWED,
                                         &pol);
 
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_AUDIT_EVENTS,
-                                            &info);
-
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -112 +119 @@
 
  done:
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("failed to get auditing policy: %s\n"),
-                        nt_errstr(result));
-        }
-
-        return result;
+                        nt_errstr(status));
+        }
+
+        return status;
 }
 
@@ -124 +131 @@
 
 static NTSTATUS rpc_audit_set_internal(struct net_context *c,
-                                       const DOM_SID *domain_sid,
+                                       const struct dom_sid *domain_sid,
                                        const char *domain_name,
                                        struct cli_state *cli,
@@ -133 +140 @@
 {
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union lsa_PolicyInformation *info = NULL;
         uint32_t audit_policy, audit_category;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc < 2 || argc > 3) {
@@ -163 +171 @@
         }
 
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                                         SEC_FLAG_MAXIMUM_ALLOWED,
                                         &pol);
 
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_AUDIT_EVENTS,
-                                            &info);
-
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -182 +194 @@
         info->audit_events.settings[audit_category] = audit_policy;
 
-        result = rpccli_lsa_SetInfoPolicy(pipe_hnd, mem_ctx,
+        status = dcerpc_lsa_SetInfoPolicy(b, mem_ctx,
                                           &pol,
                                           LSA_POLICY_INFO_AUDIT_EVENTS,
-                                          info);
-
+                                          info,
+                                          &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_AUDIT_EVENTS,
-                                            &info);
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = result;
+
         {
                 const char *val = audit_policy_str(mem_ctx, info->audit_events.settings[audit_category]);
@@ -202 +225 @@
 
  done:
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("failed to set audit policy: %s\n"),
-                         nt_errstr(result));
-        }
-
-        return result;
+                         nt_errstr(status));
+        }
+
+        return status;
 }
 
@@ -220 +243 @@
 {
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union lsa_PolicyInformation *info = NULL;
-
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                                         SEC_FLAG_MAXIMUM_ALLOWED,
                                         &pol);
 
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_AUDIT_EVENTS,
-                                            &info);
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -241 +270 @@
         info->audit_events.auditing_mode = enable;
 
-        result = rpccli_lsa_SetInfoPolicy(pipe_hnd, mem_ctx,
+        status = dcerpc_lsa_SetInfoPolicy(b, mem_ctx,
                                           &pol,
                                           LSA_POLICY_INFO_AUDIT_EVENTS,
-                                          info);
-
+                                          info,
+                                          &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
 
  done:
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("%s: %s\n"),
                         enable ? _("failed to enable audit policy"):
                                  _("failed to disable audit policy"),
-                        nt_errstr(result));
-        }
-
-        return result;
+                        nt_errstr(status));
+        }
+
+        return status;
 }
 
@@ -265 +298 @@
 
 static NTSTATUS rpc_audit_disable_internal(struct net_context *c,
-                                           const DOM_SID *domain_sid,
+                                           const struct dom_sid *domain_sid,
                                            const char *domain_name,
                                            struct cli_state *cli,
@@ -281 +314 @@
 
 static NTSTATUS rpc_audit_enable_internal(struct net_context *c,
-                                          const DOM_SID *domain_sid,
+                                          const struct dom_sid *domain_sid,
                                           const char *domain_name,
                                           struct cli_state *cli,
@@ -297 +330 @@
 
 static NTSTATUS rpc_audit_list_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -306 +339 @@
 {
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union lsa_PolicyInformation *info = NULL;
         int i;
-
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                                         SEC_FLAG_MAXIMUM_ALLOWED,
                                         &pol);
 
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
                                             &pol,
                                             LSA_POLICY_INFO_AUDIT_EVENTS,
-                                            &info);
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -351 +390 @@
 
  done:
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf(_("failed to list auditing policies: %s\n"),
-                        nt_errstr(result));
-        }
-
-        return result;
+                        nt_errstr(status));
+        }
+
+        return status;
 }
 

vendor/current/source3/utils/net_rpc_join.c

@@ -21 +21 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "rpc_client/cli_pipe.h"
 #include "../libcli/auth/libcli_auth.h"
-#include "../librpc/gen_ndr/cli_lsa.h"
-#include "../librpc/gen_ndr/cli_samr.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "rpc_client/init_samr.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "rpc_client/cli_netlogon.h"
+#include "secrets.h"
+#include "rpc_client/init_lsa.h"
+#include "libsmb/libsmb.h"
 
 /* Macro for checking RPC error codes to make things more readable */
 
 #define CHECK_RPC_ERR(rpc, msg) \
-        if (!NT_STATUS_IS_OK(result = rpc)) { \
-                DEBUG(0, (msg ": %s\n", nt_errstr(result))); \
+        if (!NT_STATUS_IS_OK(status = rpc)) { \
+                DEBUG(0, (msg ": %s\n", nt_errstr(status))); \
                 goto done; \
         }
 
+#define CHECK_DCERPC_ERR(rpc, msg) \
+        if (!NT_STATUS_IS_OK(status = rpc)) { \
+                DEBUG(0, (msg ": %s\n", nt_errstr(status))); \
+                goto done; \
+        } \
+        if (!NT_STATUS_IS_OK(result)) { \
+                status = result; \
+                DEBUG(0, (msg ": %s\n", nt_errstr(result))); \
+                goto done; \
+        }
+
+
 #define CHECK_RPC_ERR_DEBUG(rpc, debug_args) \
-        if (!NT_STATUS_IS_OK(result = rpc)) { \
+        if (!NT_STATUS_IS_OK(status = rpc)) { \
                 DEBUG(0, debug_args); \
                 goto done; \
         }
+
+#define CHECK_DCERPC_ERR_DEBUG(rpc, debug_args) \
+        if (!NT_STATUS_IS_OK(status = rpc)) { \
+                DEBUG(0, debug_args); \
+                goto done; \
+        } \
+        if (!NT_STATUS_IS_OK(result)) { \
+                status = result; \
+                DEBUG(0, debug_args); \
+                goto done; \
+        }
+
 
 /**
@@ -143 +175 @@
         enum netr_SchannelType sec_channel_type;
         struct rpc_pipe_client *pipe_hnd = NULL;
+        struct dcerpc_binding_handle *b = NULL;
 
         /* rpc variables */
 
         struct policy_handle lsa_pol, sam_pol, domain_pol, user_pol;
-        DOM_SID *domain_sid;
+        struct dom_sid *domain_sid;
         uint32 user_rid;
 
@@ -159 +192 @@
         /* Misc */
 
-        NTSTATUS result;
+        NTSTATUS status, result;
         int retval = 1;
         const char *domain = NULL;
@@ -169 +202 @@
         struct samr_Ids user_rids;
         struct samr_Ids name_types;
+
 
         /* check what type of join */
@@ -197 +231 @@
         /* Make authenticated connection to remote machine */
 
-        result = net_make_ipc_connection(c, NET_FLAGS_PDC, &cli);
-        if (!NT_STATUS_IS_OK(result)) {
+        status = net_make_ipc_connection(c, NET_FLAGS_PDC, &cli);
+        if (!NT_STATUS_IS_OK(status)) {
                 return 1;
         }
@@ -209 +243 @@
         /* Fetch domain sid */
 
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
                                           &pipe_hnd);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("Error connecting to LSA pipe. Error was %s\n",
-                        nt_errstr(result) ));
-                goto done;
-        }
-
+                        nt_errstr(status) ));
+                goto done;
+        }
+
+        b = pipe_hnd->binding_handle;
 
         CHECK_RPC_ERR(rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
@@ -223 +258 @@
                       "error opening lsa policy handle");
 
-        CHECK_RPC_ERR(rpccli_lsa_QueryInfoPolicy(pipe_hnd, mem_ctx,
-                                                 &lsa_pol,
-                                                 LSA_POLICY_INFO_ACCOUNT_DOMAIN,
-                                                 &info),
+        CHECK_DCERPC_ERR(dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
+                                                    &lsa_pol,
+                                                    LSA_POLICY_INFO_ACCOUNT_DOMAIN,
+                                                    &info,
+                                                    &result),
                       "error querying info policy");
 
@@ -232 +268 @@
         domain_sid = info->account_domain.sid;
 
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
+        dcerpc_lsa_Close(b, mem_ctx, &lsa_pol, &result);
         TALLOC_FREE(pipe_hnd); /* Done with this pipe */
 
@@ -242 +278 @@
 
         /* Create domain user */
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_samr.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_samr.syntax_id,
                                           &pipe_hnd);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("Error connecting to SAM pipe. Error was %s\n",
-                        nt_errstr(result) ));
-                goto done;
-        }
-
-        CHECK_RPC_ERR(rpccli_samr_Connect2(pipe_hnd, mem_ctx,
-                                           pipe_hnd->desthost,
-                                           SAMR_ACCESS_ENUM_DOMAINS
-                                           | SAMR_ACCESS_LOOKUP_DOMAIN,
-                                           &sam_pol),
+                        nt_errstr(status) ));
+                goto done;
+        }
+
+        b = pipe_hnd->binding_handle;
+
+        CHECK_DCERPC_ERR(dcerpc_samr_Connect2(b, mem_ctx,
+                                              pipe_hnd->desthost,
+                                              SAMR_ACCESS_ENUM_DOMAINS
+                                              | SAMR_ACCESS_LOOKUP_DOMAIN,
+                                              &sam_pol,
+                                              &result),
                       "could not connect to SAM database");
 
 
-        CHECK_RPC_ERR(rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
-                                             &sam_pol,
-                                             SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1
-                                             | SAMR_DOMAIN_ACCESS_CREATE_USER
-                                             | SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
-                                             domain_sid,
-                                             &domain_pol),
+        CHECK_DCERPC_ERR(dcerpc_samr_OpenDomain(b, mem_ctx,
+                                                &sam_pol,
+                                                SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1
+                                                | SAMR_DOMAIN_ACCESS_CREATE_USER
+                                                | SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
+                                                domain_sid,
+                                                &domain_pol,
+                                                &result),
                       "could not open domain");
 
         /* Create domain user */
         if ((acct_name = talloc_asprintf(mem_ctx, "%s$", global_myname())) == NULL) {
-                result = NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
                 goto done;
         }
@@ -284 +324 @@
         DEBUG(10, ("Creating account with flags: %d\n",acct_flags));
 
-        result = rpccli_samr_CreateUser2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_CreateUser2(b, mem_ctx,
                                          &domain_pol,
                                          &lsa_acct_name,
@@ -291 +331 @@
                                          &user_pol,
                                          &access_granted,
-                                         &user_rid);
-
+                                         &user_rid,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result) &&
             !NT_STATUS_EQUAL(result, NT_STATUS_USER_EXISTS)) {
+                status = result;
                 d_fprintf(stderr,_("Creation of workstation account failed\n"));
 
@@ -311 +355 @@
 
         if (NT_STATUS_IS_OK(result)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &user_pol);
-        }
-
-        CHECK_RPC_ERR_DEBUG(rpccli_samr_LookupNames(pipe_hnd, mem_ctx,
-                                                    &domain_pol,
-                                                    1,
-                                                    &lsa_acct_name,
-                                                    &user_rids,
-                                                    &name_types),
-                            ("error looking up rid for user %s: %s\n",
-                             acct_name, nt_errstr(result)));
+                dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
+        }
+
+        CHECK_DCERPC_ERR_DEBUG(dcerpc_samr_LookupNames(b, mem_ctx,
+                                                       &domain_pol,
+                                                       1,
+                                                       &lsa_acct_name,
+                                                       &user_rids,
+                                                       &name_types,
+                                                       &result),
+                            ("error looking up rid for user %s: %s/%s\n",
+                             acct_name, nt_errstr(status), nt_errstr(result)));
 
         if (name_types.ids[0] != SID_NAME_USER) {
@@ -332 +377 @@
         /* Open handle on user */
 
-        CHECK_RPC_ERR_DEBUG(
-                rpccli_samr_OpenUser(pipe_hnd, mem_ctx,
+        CHECK_DCERPC_ERR_DEBUG(
+                dcerpc_samr_OpenUser(b, mem_ctx,
                                      &domain_pol,
                                      SEC_FLAG_MAXIMUM_ALLOWED,
                                      user_rid,
-                                     &user_pol),
-                ("could not re-open existing user %s: %s\n",
-                 acct_name, nt_errstr(result)));
+                                     &user_pol,
+                                     &result),
+                ("could not re-open existing user %s: %s/%s\n",
+                 acct_name, nt_errstr(status), nt_errstr(result)));
         
         /* Create a random machine account password */
@@ -355 +401 @@
         set_info.info24.password_expired = PASS_DONT_CHANGE_AT_NEXT_LOGON;
 
-        CHECK_RPC_ERR(rpccli_samr_SetUserInfo2(pipe_hnd, mem_ctx,
-                                               &user_pol,
-                                               24,
-                                               &set_info),
+        CHECK_DCERPC_ERR(dcerpc_samr_SetUserInfo2(b, mem_ctx,
+                                                  &user_pol,
+                                                  24,
+                                                  &set_info,
+                                                  &result),
                       "error setting trust account password");
 
@@ -375 +422 @@
            as a normal user with "Add workstation to domain" privilege. */
 
-        result = rpccli_samr_SetUserInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_SetUserInfo(b, mem_ctx,
                                          &user_pol,
                                          16,
-                                         &set_info);
-
-        rpccli_samr_Close(pipe_hnd, mem_ctx, &user_pol);
+                                         &set_info,
+                                         &result);
+
+        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
         TALLOC_FREE(pipe_hnd); /* Done with this pipe */
 
         /* Now check the whole process from top-to-bottom */
 
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_netlogon.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_netlogon.syntax_id,
                                           &pipe_hnd);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("Error connecting to NETLOGON pipe. Error was %s\n",
-                        nt_errstr(result) ));
-                goto done;
-        }
-
-        result = rpccli_netlogon_setup_creds(pipe_hnd,
+                        nt_errstr(status) ));
+                goto done;
+        }
+
+        status = rpccli_netlogon_setup_creds(pipe_hnd,
                                         cli->desthost, /* server name */
                                         domain,        /* domain */
@@ -402 +450 @@
                                         &neg_flags);
 
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("Error in domain join verification (credential setup failed): %s\n\n",
-                          nt_errstr(result)));
-
-                if ( NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED) &&
+                          nt_errstr(status)));
+
+                if ( NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
                      (sec_channel_type == SEC_CHAN_BDC) ) {
                         d_fprintf(stderr, _("Please make sure that no computer "
@@ -425 +473 @@
                 struct rpc_pipe_client *netlogon_schannel_pipe;
 
-                result = cli_rpc_pipe_open_schannel_with_key(
+                status = cli_rpc_pipe_open_schannel_with_key(
                         cli, &ndr_table_netlogon.syntax_id, NCACN_NP,
                         DCERPC_AUTH_LEVEL_PRIVACY, domain, &pipe_hnd->dc,
                         &netlogon_schannel_pipe);
 
-                if (!NT_STATUS_IS_OK(result)) {
+                if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0, ("Error in domain join verification (schannel setup failed): %s\n\n",
-                                  nt_errstr(result)));
-
-                        if ( NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED) &&
+                                  nt_errstr(status)));
+
+                        if ( NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
                              (sec_channel_type == SEC_CHAN_BDC) ) {
                                 d_fprintf(stderr, _("Please make sure that no "
@@ -464 +512 @@
 
         /* double-check, connection from scratch */
-        result = net_rpc_join_ok(c, domain, cli->desthost, &cli->dest_ss);
-        retval = NT_STATUS_IS_OK(result) ? 0 : -1;
+        status = net_rpc_join_ok(c, domain, cli->desthost, &cli->dest_ss);
+        retval = NT_STATUS_IS_OK(status) ? 0 : -1;
 
 done:

vendor/current/source3/utils/net_rpc_printer.c

@@ -18 +18 @@
 */
 #include "includes.h"
+#include "system/filesys.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_spoolss.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_spoolss_c.h"
+#include "rpc_client/cli_spoolss.h"
+#include "rpc_client/init_spoolss.h"
+#include "nt_printing.h"
+#include "registry/reg_objects.h"
+#include "../libcli/security/security.h"
+#include "../libcli/registry/util_reg.h"
+#include "libsmb/libsmb.h"
 
 /* support itanium as well */
@@ -62 +71 @@
         printf(_("\tHelpfile: [%s]\n\n"), r->help_file);
 
-        for (i=0; r->dependent_files[i] != NULL; i++) {
+        for (i=0; r->dependent_files && r->dependent_files[i] != NULL; i++) {
                 printf(_("\tDependentfiles: [%s]\n"), r->dependent_files[i]);
         }
@@ -72 +81 @@
 }
 
-static void display_reg_value(const char *subkey, struct regval_blob value)
+static void display_reg_value(const char *subkey, struct regval_blob *value)
 {
         const char *text;
         DATA_BLOB blob;
 
-        switch(value.type) {
+        switch(regval_type(value)) {
         case REG_DWORD:
                 d_printf(_("\t[%s:%s]: REG_DWORD: 0x%08x\n"), subkey,
-                        value.valuename, *((uint32_t *) value.data_p));
+                        regval_name(value), *((uint32_t *) regval_data_p(value)));
                 break;
 
         case REG_SZ:
-                blob = data_blob_const(value.data_p, value.size);
+                blob = data_blob_const(regval_data_p(value), regval_size(value));
                 pull_reg_sz(talloc_tos(), &blob, &text);
                 if (!text) {
                         break;
                 }
-                d_printf(_("\t[%s:%s]: REG_SZ: %s\n"), subkey, value.valuename,
+                d_printf(_("\t[%s:%s]: REG_SZ: %s\n"), subkey, regval_name(value),
                          text);
                 break;
@@ -96 +105 @@
                 d_printf(_("\t[%s:%s]: REG_BINARY: unknown length value not "
                            "displayed\n"),
-                         subkey, value.valuename);
+                         subkey, regval_name(value));
                 break;
 
@@ -102 +111 @@
                 uint32_t i;
                 const char **values;
-                blob = data_blob_const(value.data_p, value.size);
+                blob = data_blob_const(regval_data_p(value), regval_size(value));
 
                 if (!pull_reg_multi_sz(NULL, &blob, &values)) {
@@ -109 +118 @@
                 }
 
-                printf("%s: REG_MULTI_SZ: \n", value.valuename);
+                printf("%s: REG_MULTI_SZ: \n", regval_name(value));
                 for (i=0; values[i] != NULL; i++) {
                         d_printf("%s\n", values[i]);
@@ -118 +127 @@
 
         default:
-                d_printf(_("\t%s: unknown type %d\n"), value.valuename,
-                         value.type);
+                d_printf(_("\t%s: unknown type %d\n"), regval_name(value),
+                         regval_type(value));
         }
 
@@ -153 +162 @@
         uint16_t fnum_src = 0;
         uint16_t fnum_dst = 0;
-        SEC_DESC *sd = NULL;
+        struct security_descriptor *sd = NULL;
         uint16_t attr;
         time_t f_atime, f_ctime, f_mtime;
@@ -226 +235 @@
 
         if (copy_acls) {
+                NTSTATUS status;
 
                 /* set acls */
-                if (!cli_set_secdesc(cli_share_dst, fnum_dst, sd)) {
-                        DEBUG(0,("could not set secdesc on %s: %s\n",
-                                dst_name, cli_errstr(cli_share_dst)));
-                        nt_status = cli_nt_error(cli_share_dst);
+                status = cli_set_secdesc(cli_share_dst, fnum_dst, sd);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("could not set secdesc on %s: %s\n",
+                                  dst_name, nt_errstr(status)));
+                        nt_status = status;
                         goto out;
                 }
@@ -377 +388 @@
 
                 /* copying file */
-                int n, ret;
+                int n;
                 n = cli_read(cli_share_src, fnum_src, data, nread,
                                 read_size);
@@ -384 +395 @@
                         break;
 
-                ret = cli_write(cli_share_dst, fnum_dst, 0, data,
-                        nread, n);
-
-                if (n != ret) {
+                nt_status = cli_writeall(cli_share_dst, fnum_dst, 0,
+                                         (uint8_t *)data, nread, n, NULL);
+
+                if (!NT_STATUS_IS_OK(nt_status)) {
                         d_fprintf(stderr, _("Error writing file: %s\n"),
-                                cli_errstr(cli_share_dst));
-                        nt_status = cli_nt_error(cli_share_dst);
+                                  nt_errstr(nt_status));
                         goto out;
                 }
@@ -487 +497 @@
                                     const char *file, const char *short_archi) {
 
-        NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
         const char *p;
         char *src_name;
         char *dst_name;
-        char *version;
-        char *filename;
+        char *version = NULL;
+        char *filename = NULL;
         char *tok;
 
@@ -509 +518 @@
         }
 
+        if (version == NULL || filename == NULL) {
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
         /* build source file name */
-        if (asprintf(&src_name, "\\%s\\%s\\%s", short_archi, version, filename) < 0 )
+        src_name = talloc_asprintf(mem_ctx, "\\%s\\%s\\%s",
+                                   short_archi, version, filename);
+        if (src_name == NULL) {
                 return NT_STATUS_NO_MEMORY;
-
+        }
 
         /* create destination file name */
-        if (asprintf(&dst_name, "\\%s\\%s", short_archi, filename) < 0 )
-                return NT_STATUS_NO_MEMORY;
+        dst_name = talloc_asprintf(mem_ctx, "\\%s\\%s", short_archi, filename);
+        if (dst_name == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
 
 
         /* finally copy the file */
-        nt_status = net_copy_file(c, mem_ctx, cli_share_src, cli_share_dst,
-                                  src_name, dst_name, false, false, false, true);
-        if (!NT_STATUS_IS_OK(nt_status))
-                goto out;
-
-        nt_status = NT_STATUS_OK;
-
-out:
-        SAFE_FREE(src_name);
-        SAFE_FREE(dst_name);
-
-        return nt_status;
+        return net_copy_file(c, mem_ctx, cli_share_src, cli_share_dst,
+                             src_name, dst_name, false, false, false, true);
 }
 
@@ -752 +759 @@
                                 union spoolss_PrinterInfo *info)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         WERROR result;
         NTSTATUS status;
@@ -812 +820 @@
         }
 
-        status = rpccli_spoolss_SetPrinter(pipe_hnd, mem_ctx,
+        status = dcerpc_spoolss_SetPrinter(b, mem_ctx,
                                            hnd,
                                            &info_ctr,
@@ -819 +827 @@
                                            0, /* command */
                                            &result);
-
+        if (!NT_STATUS_IS_OK(status)) {
+                printf(_("cannot set printer-info: %s\n"), nt_errstr(status));
+                return false;
+        }
         if (!W_ERROR_IS_OK(result)) {
                 printf(_("cannot set printer-info: %s\n"), win_errstr(result));
@@ -837 +848 @@
                                        uint32_t offered)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         WERROR result;
         NTSTATUS status;
 
         /* setprinterdata call */
-        status = rpccli_spoolss_SetPrinterData(pipe_hnd, mem_ctx,
+        status = dcerpc_spoolss_SetPrinterData(b, mem_ctx,
                                                hnd,
                                                value_name,
@@ -848 +860 @@
                                                offered,
                                                &result);
-
+        if (!NT_STATUS_IS_OK(status)) {
+                printf (_("unable to set printerdata: %s\n"),
+                        nt_errstr(status));
+                return false;
+        }
         if (!W_ERROR_IS_OK(result)) {
                 printf (_("unable to set printerdata: %s\n"),
@@ -911 +927 @@
                                         struct regval_blob *value)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         WERROR result;
         NTSTATUS status;
 
         /* setprinterdataex call */
-        status = rpccli_spoolss_SetPrinterDataEx(pipe_hnd, mem_ctx,
+        status = dcerpc_spoolss_SetPrinterDataEx(b, mem_ctx,
                                                  hnd,
                                                  keyname,
-                                                 value->valuename,
-                                                 value->type,
-                                                 value->data_p,
-                                                 value->size,
+                                                 regval_name(value),
+                                                 regval_type(value),
+                                                 regval_data_p(value),
+                                                 regval_size(value),
                                                  &result);
-
+        if (!NT_STATUS_IS_OK(status)) {
+                printf(_("could not set printerdataex: %s\n"),
+                       nt_errstr(status));
+                return false;
+        }
         if (!W_ERROR_IS_OK(result)) {
                 printf(_("could not set printerdataex: %s\n"),
@@ -974 +995 @@
                                                    info);
         if (!W_ERROR_IS_OK(result)) {
-                printf(_("cannot enum drivers: %s\n"), win_errstr(result));
-                return false;
+                if (W_ERROR_V(result) != W_ERROR_V(WERR_INVALID_ENVIRONMENT)) {
+                        printf(_("cannot enum drivers for environment %s: %s\n"), env,
+                                win_errstr(result));
+                        return false;
+                } else {
+                        printf(_("Server does not support environment [%s]\n"),
+                                env);
+                }
         }
 
@@ -1021 +1048 @@
                              union spoolss_DriverInfo *info)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         WERROR result;
         NTSTATUS status;
@@ -1042 +1070 @@
 
         /* addprinterdriver call */
-        status = rpccli_spoolss_AddPrinterDriver(pipe_hnd, mem_ctx,
+        status = dcerpc_spoolss_AddPrinterDriver(b, mem_ctx,
                                                  pipe_hnd->srv_name_slash,
                                                  &info_ctr,
                                                  &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf(_("cannot add driver: %s\n"), nt_errstr(status));
+                return false;
+        }
         /* be more verbose */
         if (W_ERROR_V(result) == W_ERROR_V(WERR_ACCESS_DENIED)) {
@@ -1072 +1104 @@
                         union spoolss_PrinterInfo **info_p)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         struct policy_handle hnd;
+        WERROR werr;
 
         /* no arguments given, enumerate all printers */
@@ -1098 +1132 @@
 
         if (!net_spoolss_getprinter(pipe_hnd, mem_ctx, &hnd, level, *info_p)) {
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
+                dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &werr);
                 return false;
         }
 
-        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
+        dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &werr);
 
         *num_printers = 1;
@@ -1131 +1165 @@
 
 NTSTATUS rpc_printer_list_internals(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -1183 +1217 @@
 
 NTSTATUS rpc_printer_driver_list_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1254 +1288 @@
                                         uint32_t action)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
         uint32_t i, num_printers;
@@ -1301 +1336 @@
                 default:
                         action_str = N_("unknown action");
-                        printf(_("unkown action: %d\n"), action);
+                        printf(_("unknown action: %d\n"), action);
                         break;
                 }
@@ -1313 +1348 @@
                 ZERO_STRUCT(secdesc_ctr);
 
-                nt_status = rpccli_spoolss_SetPrinter(pipe_hnd, mem_ctx,
+                nt_status = dcerpc_spoolss_SetPrinter(b, mem_ctx,
                                                       &hnd,
                                                       &info_ctr,
@@ -1320 +1355 @@
                                                       0, /* command */
                                                       &result);
-
-                if (!W_ERROR_IS_OK(result) && (W_ERROR_V(result) != W_ERROR_V(WERR_IO_PENDING))) {
+                if (!NT_STATUS_IS_OK(nt_status)) {
                         printf(_("cannot set printer-info: %s\n"),
-                               win_errstr(result));
+                               nt_errstr(nt_status));
+                        goto done;
+                }
+                if (!W_ERROR_IS_OK(result) && !W_ERROR_EQUAL(result, WERR_IO_PENDING)) {
+                        if ((action == DSPRINT_UPDATE) && W_ERROR_EQUAL(result, W_ERROR(0x80070002))) {
+                                printf(_("printer not published yet\n"));
+                        } else {
+                                printf(_("cannot set printer-info: %s\n"),
+                                       win_errstr(result));
+                        }
+                        nt_status = werror_to_ntstatus(result);
                         goto done;
                 }
@@ -1334 +1378 @@
 
 done:
-        if (is_valid_policy_hnd(&hnd))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
+        if (is_valid_policy_hnd(&hnd)) {
+                dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &result);
+        }
 
         return nt_status;
@@ -1341 +1386 @@
 
 NTSTATUS rpc_printer_publish_publish_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1353 +1398 @@
 
 NTSTATUS rpc_printer_publish_unpublish_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1365 +1410 @@
 
 NTSTATUS rpc_printer_publish_update_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1394 +1439 @@
 
 NTSTATUS rpc_printer_publish_list_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1402 +1447 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
         uint32_t i, num_printers;
@@ -1410 +1456 @@
         struct policy_handle hnd;
         int state;
+        WERROR werr;
 
         if (!get_printer_info(pipe_hnd, mem_ctx, 2, argc, argv, &num_printers, &info_enum))
@@ -1454 +1501 @@
                                 break;
                         default:
-                                printf(_("unkown state: %d\n"), state);
+                                printf(_("unknown state: %d\n"), state);
                                 break;
                 }
@@ -1462 +1509 @@
 
 done:
-        if (is_valid_policy_hnd(&hnd))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd, NULL);
+        if (is_valid_policy_hnd(&hnd)) {
+                dcerpc_spoolss_ClosePrinter(b, mem_ctx, &hnd, &werr);
+        }
 
         return nt_status;
@@ -1486 +1534 @@
 
 NTSTATUS rpc_printer_migrate_security_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1494 +1542 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b_src = pipe_hnd->binding_handle;
         /* TODO: what now, info2 or info3 ?
            convince jerry that we should add clientside setacls level 3 at least
@@ -1503 +1552 @@
         const char *printername, *sharename;
         struct rpc_pipe_client *pipe_hnd_dst = NULL;
+        struct dcerpc_binding_handle *b_dst = NULL;
         struct policy_handle hnd_src, hnd_dst;
         union spoolss_PrinterInfo *info_enum;
         struct cli_state *cli_dst = NULL;
         union spoolss_PrinterInfo info_src, info_dst;
+        WERROR werr;
 
         DEBUG(3,("copying printer ACLs\n"));
@@ -1513 +1564 @@
         nt_status = connect_dst_pipe(c, &cli_dst, &pipe_hnd_dst,
                                      &ndr_table_spoolss.syntax_id);
-        if (!NT_STATUS_IS_OK(nt_status))
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
-
+        }
+        b_dst = pipe_hnd_dst->binding_handle;
 
         /* enum source printers */
@@ -1589 +1641 @@
                 /* close printer handles here */
                 if (is_valid_policy_hnd(&hnd_src)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &werr);
                 }
 
                 if (is_valid_policy_hnd(&hnd_dst)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &werr);
                 }
 
@@ -1603 +1655 @@
 
         if (is_valid_policy_hnd(&hnd_src)) {
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &werr);
         }
 
         if (is_valid_policy_hnd(&hnd_dst)) {
-                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &werr);
         }
 
@@ -1634 +1686 @@
 
 NTSTATUS rpc_printer_migrate_forms_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1642 +1694 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b_src = pipe_hnd->binding_handle;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
         WERROR result;
@@ -1649 +1702 @@
         const char *printername, *sharename;
         struct rpc_pipe_client *pipe_hnd_dst = NULL;
+        struct dcerpc_binding_handle *b_dst = NULL;
         struct policy_handle hnd_src, hnd_dst;
         union spoolss_PrinterInfo *info_enum;
@@ -1661 +1715 @@
         nt_status = connect_dst_pipe(c, &cli_dst, &pipe_hnd_dst,
                                      &ndr_table_spoolss.syntax_id);
-        if (!NT_STATUS_IS_OK(nt_status))
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
+        }
+        b_dst = pipe_hnd_dst->binding_handle;
 
         /* enum src printers */
@@ -1737 +1793 @@
                         /* FIXME: there might be something wrong with samba's
                            builtin-forms */
-                        status = rpccli_spoolss_AddForm(pipe_hnd_dst, mem_ctx,
+                        status = dcerpc_spoolss_AddForm(b_dst, mem_ctx,
                                                         &hnd_dst,
                                                         1,
                                                         info,
                                                         &result);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                d_printf(_("\tdcerpc_spoolss_AddForm form %d: [%s] - %s\n"),
+                                        f, forms[f].info1.form_name, nt_errstr(status));
+                                continue;
+                        }
                         if (!W_ERROR_IS_OK(result)) {
                                 d_printf(_("\tAddForm form %d: [%s] refused.\n"),
@@ -1755 +1816 @@
                 /* close printer handles here */
                 if (is_valid_policy_hnd(&hnd_src)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
                 }
 
                 if (is_valid_policy_hnd(&hnd_dst)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
                 }
         }
@@ -1767 +1828 @@
 done:
 
-        if (is_valid_policy_hnd(&hnd_src))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
-
-        if (is_valid_policy_hnd(&hnd_dst))
-                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+        if (is_valid_policy_hnd(&hnd_src)) {
+                dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
+        }
+
+        if (is_valid_policy_hnd(&hnd_dst)) {
+                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
+        }
 
         if (cli_dst) {
@@ -1797 +1860 @@
 
 NTSTATUS rpc_printer_migrate_drivers_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -1805 +1868 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b_src = pipe_hnd->binding_handle;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
         uint32_t i, p;
@@ -1813 +1877 @@
         bool got_dst_driver_share = false;
         struct rpc_pipe_client *pipe_hnd_dst = NULL;
+        struct dcerpc_binding_handle *b_dst = NULL;
         struct policy_handle hnd_src, hnd_dst;
         union spoolss_DriverInfo drv_info_src;
@@ -1821 +1886 @@
         struct cli_state *cli_share_dst = NULL;
         const char *drivername = NULL;
+        WERROR werr;
 
         DEBUG(3,("copying printer-drivers\n"));
@@ -1826 +1892 @@
         nt_status = connect_dst_pipe(c, &cli_dst, &pipe_hnd_dst,
                                      &ndr_table_spoolss.syntax_id);
-        if (!NT_STATUS_IS_OK(nt_status))
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
+        }
+        b_dst = pipe_hnd_dst->binding_handle;
 
         /* open print$-share on the src server */
@@ -1956 +2024 @@
                 /* close dst */
                 if (is_valid_policy_hnd(&hnd_dst)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &werr);
                 }
 
                 /* close src */
                 if (is_valid_policy_hnd(&hnd_src)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &werr);
                 }
         }
@@ -1969 +2037 @@
 done:
 
-        if (is_valid_policy_hnd(&hnd_src))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
-
-        if (is_valid_policy_hnd(&hnd_dst))
-                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+        if (is_valid_policy_hnd(&hnd_dst)) {
+                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &werr);
+        }
+
+        /* close src */
+        if (is_valid_policy_hnd(&hnd_src)) {
+                dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &werr);
+        }
 
         if (cli_dst) {
@@ -2008 +2079 @@
 
 NTSTATUS rpc_printer_migrate_printers_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -2016 +2087 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b_src = pipe_hnd->binding_handle;
         WERROR result;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
@@ -2026 +2098 @@
         const char *printername, *sharename;
         struct rpc_pipe_client *pipe_hnd_dst = NULL;
+        struct dcerpc_binding_handle *b_dst = NULL;
         struct spoolss_SetPrinterInfoCtr info_ctr;
 
@@ -2033 +2106 @@
         nt_status = connect_dst_pipe(c, &cli_dst, &pipe_hnd_dst,
                                      &ndr_table_spoolss.syntax_id);
-        if (!NT_STATUS_IS_OK(nt_status))
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
+        }
+        b_dst = pipe_hnd_dst->binding_handle;
 
         /* enum printers */
@@ -2082 +2157 @@
                         /* close printer handle here - dst only, not got src yet. */
                         if (is_valid_policy_hnd(&hnd_dst)) {
-                                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
                         }
                         continue;
@@ -2125 +2200 @@
                 /* close printer handles here */
                 if (is_valid_policy_hnd(&hnd_src)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
                 }
 
                 if (is_valid_policy_hnd(&hnd_dst)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
                 }
         }
@@ -2136 +2211 @@
 
 done:
-        if (is_valid_policy_hnd(&hnd_src))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
-
-        if (is_valid_policy_hnd(&hnd_dst))
-                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+        if (is_valid_policy_hnd(&hnd_src)) {
+                dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
+        }
+
+        if (is_valid_policy_hnd(&hnd_dst)) {
+                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
+        }
 
         if (cli_dst) {
@@ -2167 +2244 @@
 
 NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -2175 +2252 @@
                                                 const char **argv)
 {
+        struct dcerpc_binding_handle *b_src = pipe_hnd->binding_handle;
 
         /* FIXME: Here the nightmare begins */
@@ -2180 +2258 @@
         WERROR result;
         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
-        uint32_t i = 0, p = 0, j = 0;
+        uint32_t i = 0, j = 0;
         uint32_t num_printers;
         uint32_t level = 2;
         const char *printername, *sharename;
         struct rpc_pipe_client *pipe_hnd_dst = NULL;
+        struct dcerpc_binding_handle *b_dst = NULL;
         struct policy_handle hnd_src, hnd_dst;
         union spoolss_PrinterInfo *info_enum;
@@ -2202 +2281 @@
         nt_status = connect_dst_pipe(c, &cli_dst, &pipe_hnd_dst,
                                      &ndr_table_spoolss.syntax_id);
-        if (!NT_STATUS_IS_OK(nt_status))
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
+        }
+        b_dst = pipe_hnd_dst->binding_handle;
 
         /* enum src printers */
@@ -2228 +2309 @@
         for (i = 0; i < num_printers; i++) {
 
-                uint32_t value_offered = 0, value_needed;
-                uint32_t data_offered = 0, data_needed;
+                uint32_t value_needed;
+                uint32_t data_needed;
                 enum winreg_Type type;
-                uint8_t *buffer = NULL;
-                const char *value_name = NULL;
+                struct spoolss_EnumPrinterData r;
 
                 /* do some initialization */
@@ -2324 +2404 @@
                 */
 
+                r.in.handle = &hnd_src;
+                r.in.enum_index = 0;
+                r.in.value_offered = 0;
+                r.in.data_offered = 0;
+                r.out.value_name = NULL;
+                r.out.value_needed = &value_needed;
+                r.out.type = &type;
+                r.out.data = NULL;
+                r.out.data_needed = &data_needed;
+
                 /* enumerate data on src handle */
-                nt_status = rpccli_spoolss_EnumPrinterData(pipe_hnd, mem_ctx,
-                                                           &hnd_src,
-                                                           p,
-                                                           value_name,
-                                                           value_offered,
-                                                           &value_needed,
-                                                           &type,
-                                                           buffer,
-                                                           data_offered,
-                                                           &data_needed,
-                                                           &result);
-
-                data_offered    = data_needed;
-                value_offered   = value_needed;
-                buffer          = talloc_zero_array(mem_ctx, uint8_t, data_needed);
-                value_name      = talloc_zero_array(mem_ctx, char, value_needed);
+                nt_status = dcerpc_spoolss_EnumPrinterData_r(b_src, mem_ctx, &r);
+
+                r.in.data_offered       = *r.out.data_needed;
+                r.in.value_offered      = *r.out.value_needed;
+                r.out.data              = talloc_zero_array(mem_ctx, uint8_t, r.in.data_offered);
+                r.out.value_name        = talloc_zero_array(mem_ctx, char, r.in.value_offered);
 
                 /* loop for all printerdata of "PrinterDriverData" */
-                while (NT_STATUS_IS_OK(nt_status) && W_ERROR_IS_OK(result)) {
-
-                        nt_status = rpccli_spoolss_EnumPrinterData(pipe_hnd, mem_ctx,
-                                                                   &hnd_src,
-                                                                   p++,
-                                                                   value_name,
-                                                                   value_offered,
-                                                                   &value_needed,
-                                                                   &type,
-                                                                   buffer,
-                                                                   data_offered,
-                                                                   &data_needed,
-                                                                   &result);
+                while (NT_STATUS_IS_OK(nt_status) && W_ERROR_IS_OK(r.out.result)) {
+
+                        r.in.enum_index++;
+
+                        nt_status = dcerpc_spoolss_EnumPrinterData_r(b_src, mem_ctx, &r);
+
                         /* loop for all reg_keys */
-                        if (NT_STATUS_IS_OK(nt_status) && W_ERROR_IS_OK(result)) {
-
-                                struct regval_blob v;
+                        if (NT_STATUS_IS_OK(nt_status) && W_ERROR_IS_OK(r.out.result)) {
 
                                 /* display_value */
                                 if (c->opt_verbose) {
-                                        fstrcpy(v.valuename, value_name);
-                                        v.type = type;
-                                        v.size = data_offered;
-                                        v.data_p = buffer;
+                                        struct regval_blob *v;
+
+                                        v = regval_compose(talloc_tos(),
+                                                           r.out.value_name,
+                                                           *r.out.type,
+                                                           r.out.data,
+                                                           r.in.data_offered);
+                                        if (v == NULL) {
+                                                nt_status = NT_STATUS_NO_MEMORY;
+                                                goto done;
+                                        }
+
                                         display_reg_value(SPOOL_PRINTERDATA_KEY, v);
+                                        talloc_free(v);
                                 }
 
                                 /* set_value */
                                 if (!net_spoolss_setprinterdata(pipe_hnd_dst, mem_ctx,
-                                                                &hnd_dst, value_name,
-                                                                type, buffer, data_offered))
+                                                                &hnd_dst, r.out.value_name,
+                                                                *r.out.type, r.out.data, r.in.data_offered))
                                         goto done;
 
                                 DEBUGADD(1,("\tSetPrinterData of [%s] succeeded\n",
-                                        v.valuename));
+                                            r.out.value_name));
                         }
                 }
@@ -2416 +2496 @@
                         for (j=0; j < count; j++) {
 
-                                struct regval_blob value;
+                                struct regval_blob *value;
                                 DATA_BLOB blob;
+
+                                ZERO_STRUCT(blob);
 
                                 /* although samba replies with sane data in most cases we
@@ -2432 +2514 @@
                                                 /* although windows uses a multi-sz, we use a sz */
                                                 push_reg_sz(mem_ctx, &blob, SAMBA_PRINTER_PORT_NAME);
-                                                fstrcpy(value.valuename, SPOOL_REG_PORTNAME);
                                         }
 
@@ -2442 +2523 @@
                                                 }
                                                 push_reg_sz(mem_ctx, &blob, unc_name);
-                                                fstrcpy(value.valuename, SPOOL_REG_UNCNAME);
                                         }
 
@@ -2455 +2535 @@
                                                         goto done;
                                                 }
-                                                push_reg_sz(mem_ctx, &blob, url);
+                                                push_reg_sz(mem_ctx, NULL, &blob, url);
                                                 fstrcpy(value.valuename, SPOOL_REG_URL);
 #endif
@@ -2463 +2543 @@
 
                                                 push_reg_sz(mem_ctx, &blob, longname);
-                                                fstrcpy(value.valuename, SPOOL_REG_SERVERNAME);
                                         }
 
@@ -2469 +2548 @@
 
                                                 push_reg_sz(mem_ctx, &blob, global_myname());
-                                                fstrcpy(value.valuename, SPOOL_REG_SHORTSERVERNAME);
                                         }
 
-                                        value.type = REG_SZ;
-                                        value.size = blob.length;
-                                        if (value.size) {
-                                                value.data_p = blob.data;
-                                        } else {
-                                                value.data_p = NULL;
+                                        value = regval_compose(talloc_tos(),
+                                                               info[j].value_name,
+                                                               REG_SZ,
+                                                               blob.length == 0 ? NULL : blob.data,
+                                                               blob.length);
+                                        if (value == NULL) {
+                                                nt_status = NT_STATUS_NO_MEMORY;
+                                                goto done;
                                         }
 
@@ -2485 +2565 @@
                                         /* here we have to set all subkeys on the dst server */
                                         if (!net_spoolss_setprinterdataex(pipe_hnd_dst, mem_ctx, &hnd_dst,
-                                                        subkey, &value))
+                                                        subkey, value))
+                                        {
+                                                talloc_free(value);
                                                 goto done;
-
+                                        }
+
+                                        talloc_free(value);
                                 } else {
 
-                                        struct regval_blob v;
-
-                                        fstrcpy(v.valuename, info[j].value_name);
-                                        v.type = info[j].type;
-                                        v.data_p = info[j].data->data;
-                                        v.size = info[j].data->length;
+                                        struct regval_blob *v;
+
+                                        v = regval_compose(talloc_tos(),
+                                                           info[j].value_name,
+                                                           info[j].type,
+                                                           info[j].data->data,
+                                                           info[j].data->length);
+                                        if (v == NULL) {
+                                                nt_status = NT_STATUS_NO_MEMORY;
+                                                goto done;
+                                        }
 
                                         if (c->opt_verbose) {
@@ -2503 +2592 @@
                                         /* here we have to set all subkeys on the dst server */
                                         if (!net_spoolss_setprinterdataex(pipe_hnd_dst, mem_ctx, &hnd_dst,
-                                                        subkey, &v)) {
+                                                        subkey, v)) {
                                                 goto done;
                                         }
 
+                                        talloc_free(v);
                                 }
 
@@ -2519 +2609 @@
                 /* close printer handles here */
                 if (is_valid_policy_hnd(&hnd_src)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
+                        dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
                 }
 
                 if (is_valid_policy_hnd(&hnd_dst)) {
-                        rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
-                }
-
+                        dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
+                }
         }
 
@@ -2535 +2624 @@
         SAFE_FREE(unc_name);
 
-        if (is_valid_policy_hnd(&hnd_src))
-                rpccli_spoolss_ClosePrinter(pipe_hnd, mem_ctx, &hnd_src, NULL);
-
-        if (is_valid_policy_hnd(&hnd_dst))
-                rpccli_spoolss_ClosePrinter(pipe_hnd_dst, mem_ctx, &hnd_dst, NULL);
+        if (is_valid_policy_hnd(&hnd_src)) {
+                dcerpc_spoolss_ClosePrinter(b_src, mem_ctx, &hnd_src, &result);
+        }
+
+        if (is_valid_policy_hnd(&hnd_dst)) {
+                dcerpc_spoolss_ClosePrinter(b_dst, mem_ctx, &hnd_dst, &result);
+        }
 
         if (cli_dst) {

vendor/current/source3/utils/net_rpc_registry.c

@@ -19 +19 @@
  
 #include "includes.h"
+#include "system/filesys.h"
+#include "rpc_client/rpc_client.h"
+#include "registry.h"
 #include "utils/net.h"
 #include "utils/net_registry_util.h"
-#include "regfio.h"
-#include "reg_objects.h"
-#include "../librpc/gen_ndr/cli_winreg.h"
+#include "registry/regfio.h"
+#include "../librpc/gen_ndr/ndr_winreg_c.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "registry/reg_format.h"
+#include "registry/reg_import.h"
+#include <assert.h>
+#include "../libcli/security/display_sec.h"
+#include "../libcli/registry/util_reg.h"
+#include "client.h"
+
 
 /*******************************************************************
@@ -29 +39 @@
 *******************************************************************/
 
-static NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+static NTSTATUS dcerpc_winreg_Connect(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx,
                                       uint32_t reg_type, uint32_t access_mask,
-                                      struct policy_handle *reg_hnd)
+                                      struct policy_handle *reg_hnd, WERROR *werr)
 {
         ZERO_STRUCTP(reg_hnd);
@@ -38 +48 @@
         {
         case HKEY_CLASSES_ROOT:
-                return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL,
-                        access_mask, reg_hnd, NULL);
+                return dcerpc_winreg_OpenHKCR(b, mem_ctx, NULL,
+                        access_mask, reg_hnd, werr);
 
         case HKEY_LOCAL_MACHINE:
-                return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL,
-                        access_mask, reg_hnd, NULL);
+                return dcerpc_winreg_OpenHKLM(b, mem_ctx, NULL,
+                        access_mask, reg_hnd, werr);
 
         case HKEY_USERS:
-                return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL,
-                        access_mask, reg_hnd, NULL);
+                return dcerpc_winreg_OpenHKU(b, mem_ctx, NULL,
+                        access_mask, reg_hnd, werr);
 
         case HKEY_CURRENT_USER:
-                return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL,
-                        access_mask, reg_hnd, NULL);
+                return dcerpc_winreg_OpenHKCU(b, mem_ctx, NULL,
+                        access_mask, reg_hnd, werr);
 
         case HKEY_PERFORMANCE_DATA:
-                return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL,
-                        access_mask, reg_hnd, NULL);
+                return dcerpc_winreg_OpenHKPD(b, mem_ctx, NULL,
+                        access_mask, reg_hnd, werr);
 
         default:
@@ -125 +135 @@
         uint32 hive;
         NTSTATUS status;
+        WERROR werr;
         struct winreg_String key;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(key);
@@ -133 +145 @@
         }
 
-        status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, access_mask,
-                                       hive_hnd);
+        status = dcerpc_winreg_Connect(b, mem_ctx, hive, access_mask,
+                                       hive_hnd, &werr);
         if (!(NT_STATUS_IS_OK(status))) {
                 return status;
         }
-
-        status = rpccli_winreg_OpenKey(pipe_hnd, mem_ctx, hive_hnd, key, 0,
-                                       access_mask, key_hnd, NULL);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werror_to_ntstatus(werr);
+        }
+
+        status = dcerpc_winreg_OpenKey(b, mem_ctx, hive_hnd, key, 0,
+                                       access_mask, key_hnd, &werr);
         if (!(NT_STATUS_IS_OK(status))) {
-                rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, hive_hnd, NULL);
+                dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &werr);
                 return status;
+        }
+        if (!(W_ERROR_IS_OK(werr))) {
+                WERROR _werr;
+                dcerpc_winreg_CloseKey(b, mem_ctx, hive_hnd, &_werr);
+                return werror_to_ntstatus(werr);
         }
 
@@ -157 +177 @@
         TALLOC_CTX *mem_ctx;
         NTSTATUS status;
+        WERROR werr;
         uint32 num_subkeys, max_subkeylen, max_classlen;
         uint32 num_values, max_valnamelen, max_valbufsize;
@@ -165 +186 @@
         char **names, **classes;
         NTTIME **modtimes;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (!(mem_ctx = talloc_new(ctx))) {
@@ -171 +193 @@
 
         ZERO_STRUCT(classname);
-        status = rpccli_winreg_QueryInfoKey(
-                pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
+        status = dcerpc_winreg_QueryInfoKey(
+                b, mem_ctx, key_hnd, &classname, &num_subkeys,
                 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
-                &max_valbufsize, &secdescsize, &last_changed_time, NULL );
-
-        if (!NT_STATUS_IS_OK(status)) {
+                &max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                goto error;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
                 goto error;
         }
@@ -199 +225 @@
                 struct winreg_StringBuf name_buf;
                 NTTIME modtime;
-                WERROR werr;
 
                 c = '\0';
@@ -211 +236 @@
                 ZERO_STRUCT(modtime);
 
-                status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, key_hnd,
+                status = dcerpc_winreg_EnumKey(b, mem_ctx, key_hnd,
                                                i, &name_buf, &class_buf,
                                                &modtime, &werr);
-
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto error;
+                }
                 if (W_ERROR_EQUAL(werr,
                                   WERR_NO_MORE_ITEMS) ) {
@@ -220 +247 @@
                         break;
                 }
-                if (!NT_STATUS_IS_OK(status)) {
+                if (!W_ERROR_IS_OK(werr)) {
+                        status = werror_to_ntstatus(werr);
                         goto error;
                 }
@@ -271 +299 @@
         TALLOC_CTX *mem_ctx;
         NTSTATUS status;
+        WERROR werr;
         uint32 num_subkeys, max_subkeylen, max_classlen;
         uint32 num_values, max_valnamelen, max_valbufsize;
@@ -279 +308 @@
         struct registry_value **values;
         char **names;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (!(mem_ctx = talloc_new(ctx))) {
@@ -285 +315 @@
 
         ZERO_STRUCT(classname);
-        status = rpccli_winreg_QueryInfoKey(
-                pipe_hnd, mem_ctx, key_hnd, &classname, &num_subkeys,
+        status = dcerpc_winreg_QueryInfoKey(
+                b, mem_ctx, key_hnd, &classname, &num_subkeys,
                 &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
-                &max_valbufsize, &secdescsize, &last_changed_time, NULL );
-
-        if (!NT_STATUS_IS_OK(status)) {
+                &max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                goto error;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
                 goto error;
         }
@@ -325 +359 @@
                 value_length = 0;
 
-                status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, key_hnd,
+                status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
                                                  i, &name_buf, &type,
                                                  data, &data_size,
                                                  &value_length, &err);
+                if (!(NT_STATUS_IS_OK(status))) {
+                        goto error;
+                }
 
                 if ( W_ERROR_EQUAL(err,
@@ -336 +373 @@
                 }
 
-                if (!(NT_STATUS_IS_OK(status))) {
+                if (!W_ERROR_IS_OK(err)) {
+                        status = werror_to_ntstatus(err);
                         goto error;
                 }
@@ -350 +388 @@
                 }
 
-                err = registry_pull_value(values, &values[i], type, data,
-                                          data_size, value_length);
+                values[i] = talloc_zero(values, struct registry_value);
+                if (values[i] == NULL) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto error;
+                }
+
+                values[i]->type = type;
+                values[i]->data = data_blob_talloc(values[i], data, data_size);
+        }
+
+        *pnum_values = num_values;
+
+        if (pvalnames) {
+                *pvalnames = talloc_move(ctx, &names);
+        }
+        if (pvalues) {
+                *pvalues = talloc_move(ctx, &values);
+        }
+
+        status = NT_STATUS_OK;
+
+ error:
+        TALLOC_FREE(mem_ctx);
+        return status;
+}
+
+static NTSTATUS registry_enumvalues2(TALLOC_CTX *ctx,
+                                     struct rpc_pipe_client *pipe_hnd,
+                                     struct policy_handle *key_hnd,
+                                     uint32 *pnum_values, char ***pvalnames,
+                                     struct regval_blob ***pvalues)
+{
+        TALLOC_CTX *mem_ctx;
+        NTSTATUS status;
+        WERROR werr;
+        uint32 num_subkeys, max_subkeylen, max_classlen;
+        uint32 num_values, max_valnamelen, max_valbufsize;
+        uint32 i;
+        NTTIME last_changed_time;
+        uint32 secdescsize;
+        struct winreg_String classname;
+        struct regval_blob **values;
+        char **names;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        if (!(mem_ctx = talloc_new(ctx))) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        ZERO_STRUCT(classname);
+        status = dcerpc_winreg_QueryInfoKey(
+                b, mem_ctx, key_hnd, &classname, &num_subkeys,
+                &max_subkeylen, &max_classlen, &num_values, &max_valnamelen,
+                &max_valbufsize, &secdescsize, &last_changed_time, &werr);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                goto error;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
+                goto error;
+        }
+
+        if (num_values == 0) {
+                *pnum_values = 0;
+                TALLOC_FREE(mem_ctx);
+                return NT_STATUS_OK;
+        }
+
+        if ((!(names = TALLOC_ARRAY(mem_ctx, char *, num_values))) ||
+            (!(values = TALLOC_ARRAY(mem_ctx, struct regval_blob *,
+                                     num_values)))) {
+                status = NT_STATUS_NO_MEMORY;
+                goto error;
+        }
+
+        for (i=0; i<num_values; i++) {
+                enum winreg_Type type = REG_NONE;
+                uint8 *data = NULL;
+                uint32 data_size;
+                uint32 value_length;
+
+                char n;
+                struct winreg_ValNameBuf name_buf;
+                WERROR err;
+
+                n = '\0';
+                name_buf.name = &n;
+                name_buf.size = max_valnamelen + 2;
+
+                data_size = max_valbufsize;
+                data = (uint8 *)TALLOC(mem_ctx, data_size);
+                value_length = 0;
+
+                status = dcerpc_winreg_EnumValue(b, mem_ctx, key_hnd,
+                                                 i, &name_buf, &type,
+                                                 data, &data_size,
+                                                 &value_length, &err);
+                if (!(NT_STATUS_IS_OK(status))) {
+                        goto error;
+                }
+
+                if ( W_ERROR_EQUAL(err, WERR_NO_MORE_ITEMS) ) {
+                        status = NT_STATUS_OK;
+                        break;
+                }
+
                 if (!W_ERROR_IS_OK(err)) {
                         status = werror_to_ntstatus(err);
                         goto error;
                 }
+
+                if (name_buf.name == NULL) {
+                        status = NT_STATUS_INVALID_PARAMETER;
+                        goto error;
+                }
+
+                if (!(names[i] = talloc_strdup(names, name_buf.name))) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto error;
+                }
+
+                assert(value_length<=data_size); //???
+
+                values[i] = regval_compose(values,
+                                           name_buf.name,
+                                           type,
+                                           data, value_length);
+                if (!values[i]) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto error;
+                }
         }
 
@@ -375 +539 @@
 
 static NTSTATUS registry_getsd(TALLOC_CTX *mem_ctx,
-                               struct rpc_pipe_client *pipe_hnd,
+                               struct dcerpc_binding_handle *b,
                                struct policy_handle *key_hnd,
                                uint32_t sec_info,
-                               struct KeySecurityData *sd)
-{
-        return rpccli_winreg_GetKeySecurity(pipe_hnd, mem_ctx, key_hnd,
-                                            sec_info, sd, NULL);
+                               struct KeySecurityData *sd,
+                               WERROR *werr)
+{
+        return dcerpc_winreg_GetKeySecurity(b, mem_ctx, key_hnd,
+                                            sec_info, sd, werr);
 }
 
@@ -392 +557 @@
 {
         struct winreg_String name_string;
-        DATA_BLOB blob;
         NTSTATUS result;
-        WERROR err;
-
-        err = registry_push_value(mem_ctx, value, &blob);
-        if (!W_ERROR_IS_OK(err)) {
-                return werror_to_ntstatus(err);
-        }
+        WERROR werr;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(name_string);
 
         name_string.name = name;
-        result = rpccli_winreg_SetValue(pipe_hnd, blob.data, key_hnd,
+        result = dcerpc_winreg_SetValue(b, mem_ctx, key_hnd,
                                         name_string, value->type,
-                                        blob.data, blob.length, NULL);
-        TALLOC_FREE(blob.data);
-        return result;
+                                        value->data.data, value->data.length, &werr);
+        if (!NT_STATUS_IS_OK(result)) {
+                return result;
+        }
+
+        return werror_to_ntstatus(werr);
 }
 
 static NTSTATUS rpc_registry_setvalue_internal(struct net_context *c,
-                                               const DOM_SID *domain_sid,
+                                               const struct dom_sid *domain_sid,
                                                const char *domain_name,
                                                struct cli_state *cli,
@@ -422 +585 @@
         struct policy_handle hive_hnd, key_hnd;
         NTSTATUS status;
+        WERROR werr;
         struct registry_value value;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         status = registry_openkey(mem_ctx, pipe_hnd, argv[0],
@@ -439 +604 @@
 
         if (strequal(argv[2], "dword")) {
+                uint32_t v = strtoul(argv[3], NULL, 10);
                 value.type = REG_DWORD;
-                value.v.dword = strtoul(argv[3], NULL, 10);
+                value.data = data_blob_talloc(mem_ctx, NULL, 4);
+                SIVAL(value.data.data, 0, v);
         }
         else if (strequal(argv[2], "sz")) {
                 value.type = REG_SZ;
-                value.v.sz.len = strlen(argv[3])+1;
-                value.v.sz.str = CONST_DISCARD(char *, argv[3]);
+                if (!push_reg_sz(mem_ctx, &value.data, argv[3])) {
+                        status = NT_STATUS_NO_MEMORY;
+                        goto error;
+                }
         }
         else {
@@ -462 +631 @@
 
  error:
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
 
         return NT_STATUS_OK;
@@ -484 +653 @@
 
 static NTSTATUS rpc_registry_deletevalue_internal(struct net_context *c,
-                                                  const DOM_SID *domain_sid,
+                                                  const struct dom_sid *domain_sid,
                                                   const char *domain_name,
                                                   struct cli_state *cli,
@@ -494 +663 @@
         struct policy_handle hive_hnd, key_hnd;
         NTSTATUS status;
+        WERROR werr;
         struct winreg_String valuename;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(valuename);
@@ -509 +680 @@
         valuename.name = argv[1];
 
-        status = rpccli_winreg_DeleteValue(pipe_hnd, mem_ctx, &key_hnd,
-                                           valuename, NULL);
-
+        status = dcerpc_winreg_DeleteValue(b, mem_ctx, &key_hnd,
+                                           valuename, &werr);
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
                           nt_errstr(status));
         }
-
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
+                d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+                          win_errstr(werr));
+        }
+
+        dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
 
         return status;
@@ -538 +713 @@
 
 static NTSTATUS rpc_registry_getvalue_internal(struct net_context *c,
-                                               const DOM_SID *domain_sid,
+                                               const struct dom_sid *domain_sid,
                                                const char *domain_name,
                                                struct cli_state *cli,
@@ -553 +728 @@
         struct registry_value *value = NULL;
         enum winreg_Type type = REG_NONE;
-        uint8_t *data = NULL;
         uint32_t data_size = 0;
         uint32_t value_length = 0;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(valuename);
@@ -570 +745 @@
 
         valuename.name = argv[1];
+
+        value = talloc_zero(tmp_ctx, struct registry_value);
+        if (value == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
 
         /*
@@ -576 +756 @@
          * data buffer and call again.
          */
-        status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
+        status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
                                           &valuename,
                                           &type,
-                                          data,
+                                          NULL,
                                           &data_size,
                                           &value_length,
-                                          NULL);
+                                          &werr);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -589 +769 @@
                 goto done;
         }
-
-        data = (uint8 *)TALLOC(tmp_ctx, data_size);
-        value_length = 0;
-
-        status = rpccli_winreg_QueryValue(pipe_hnd, tmp_ctx, &key_hnd,
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
+                d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
+        value->data = data_blob_talloc(tmp_ctx, NULL, data_size);
+
+        status = dcerpc_winreg_QueryValue(b, tmp_ctx, &key_hnd,
                                           &valuename,
                                           &type,
-                                          data,
+                                          value->data.data,
                                           &data_size,
                                           &value_length,
-                                          NULL);
+                                          &werr);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -606 +791 @@
                 goto done;
         }
-
-        werr = registry_pull_value(tmp_ctx, &value, type, data,
-                                   data_size, value_length);
         if (!W_ERROR_IS_OK(werr)) {
                 status = werror_to_ntstatus(werr);
+                d_fprintf(stderr, _("registry_queryvalue failed: %s\n"),
+                          win_errstr(werr));
                 goto done;
         }
 
+
+        value->type = type;
+
         print_registry_value(value, raw);
 
 done:
-        rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &key_hnd, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, tmp_ctx, &hive_hnd, NULL);
+        dcerpc_winreg_CloseKey(b, tmp_ctx, &key_hnd, &werr);
+        dcerpc_winreg_CloseKey(b, tmp_ctx, &hive_hnd, &werr);
 
         TALLOC_FREE(tmp_ctx);
@@ -626 +813 @@
 
 static NTSTATUS rpc_registry_getvalue_full(struct net_context *c,
-                                           const DOM_SID *domain_sid,
+                                           const struct dom_sid *domain_sid,
                                            const char *domain_name,
                                            struct cli_state *cli,
@@ -654 +841 @@
 
 static NTSTATUS rpc_registry_getvalue_raw(struct net_context *c,
-                                          const DOM_SID *domain_sid,
+                                          const struct dom_sid *domain_sid,
                                           const char *domain_name,
                                           struct cli_state *cli,
@@ -682 +869 @@
 
 static NTSTATUS rpc_registry_createkey_internal(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -695 +882 @@
         enum winreg_CreateAction action;
         NTSTATUS status;
+        WERROR werr;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(key);
@@ -703 +892 @@
         }
 
-        status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
+        status = dcerpc_winreg_Connect(b, mem_ctx, hive,
                                        SEC_FLAG_MAXIMUM_ALLOWED,
-                                       &hive_hnd);
+                                       &hive_hnd, &werr);
         if (!(NT_STATUS_IS_OK(status))) {
                 return status;
         }
+        if (!W_ERROR_IS_OK(werr)) {
+                return werror_to_ntstatus(werr);
+        }
 
         action = REG_ACTION_NONE;
         keyclass.name = "";
 
-        status = rpccli_winreg_CreateKey(pipe_hnd, mem_ctx, &hive_hnd, key,
+        status = dcerpc_winreg_CreateKey(b, mem_ctx, &hive_hnd, key,
                                          keyclass, 0, REG_KEY_READ, NULL,
-                                         &key_hnd, &action, NULL);
+                                         &key_hnd, &action, &werr);
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("createkey returned %s\n"),
                           nt_errstr(status));
-                rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+                dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
                 return status;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                WERROR _werr;
+                d_fprintf(stderr, _("createkey returned %s\n"),
+                          win_errstr(werr));
+                dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
+                return werror_to_ntstatus(werr);
         }
 
@@ -735 +934 @@
         }
 
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &key_hnd, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &key_hnd, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &werr);
 
         return status;
@@ -756 +955 @@
 
 static NTSTATUS rpc_registry_deletekey_internal(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -768 +967 @@
         struct winreg_String key;
         NTSTATUS status;
+        WERROR werr;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(key);
@@ -775 +976 @@
         }
 
-        status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive,
+        status = dcerpc_winreg_Connect(b, mem_ctx, hive,
                                        SEC_FLAG_MAXIMUM_ALLOWED,
-                                       &hive_hnd);
+                                       &hive_hnd, &werr);
         if (!(NT_STATUS_IS_OK(status))) {
                 return status;
         }
-
-        status = rpccli_winreg_DeleteKey(pipe_hnd, mem_ctx, &hive_hnd, key, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &hive_hnd, NULL);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werror_to_ntstatus(werr);
+        }
+
+        status = dcerpc_winreg_DeleteKey(b, mem_ctx, &hive_hnd, key, &werr);
+        if (is_valid_policy_hnd(&hive_hnd)) {
+                WERROR _werr;
+                dcerpc_winreg_CloseKey(b, mem_ctx, &hive_hnd, &_werr);
+        }
 
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("deletekey returned %s\n"),
                           nt_errstr(status));
+                return status;
+        }
+
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("deletekey returned %s\n"),
+                          win_errstr(werr));
+                return werror_to_ntstatus(werr);
         }
 
@@ -810 +1024 @@
 
 static NTSTATUS rpc_registry_enumerate_internal(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -820 +1034 @@
         struct policy_handle pol_hive, pol_key;
         NTSTATUS status;
+        WERROR werr;
         uint32 num_subkeys = 0;
         uint32 num_values = 0;
@@ -826 +1041 @@
         uint32 i;
         struct registry_value **values = NULL;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 || c->display_usage) {
@@ -868 +1084 @@
         }
 
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
 
         return status;
@@ -888 +1104 @@
 
 static NTSTATUS rpc_registry_save_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -900 +1116 @@
         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
         struct winreg_String filename;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 2 || c->display_usage) {
@@ -917 +1134 @@
 
         filename.name = argv[1];
-        status = rpccli_winreg_SaveKey( pipe_hnd, mem_ctx, &pol_key, &filename, NULL, NULL);
-        if ( !W_ERROR_IS_OK(result) ) {
+        status = dcerpc_winreg_SaveKey(b, mem_ctx, &pol_key, &filename, NULL, &result);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
                           cli->desthost, argv[1]);
         }
+        if (!W_ERROR_IS_OK(result)) {
+                status = werror_to_ntstatus(result);
+                d_fprintf(stderr, _("Unable to save [%s] to %s:%s\n"), argv[0],
+                          cli->desthost, argv[1]);
+        }
 
         /* cleanup */
 
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &result);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &result);
 
         return status;
@@ -956 +1178 @@
         for ( i=0; i<nk->num_values; i++ ) {
                 d_printf( "\"%s\" = ", nk->values[i].valuename ? nk->values[i].valuename : "(default)" );
-                d_printf( "(%s) ", reg_type_lookup( nk->values[i].type ) );
+                d_printf( "(%s) ", str_regtype( nk->values[i].type ) );
 
                 data_size = nk->values[i].data_size & ~VK_DATA_IN_OFFSET;
@@ -1038 +1260 @@
         }
 
-        if ( !(values = TALLOC_ZERO_P( subkeys, struct regval_ctr )) ) {
+        werr = regval_ctr_init(subkeys, &values);
+        if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(0,("write_registry_tree: talloc() failed!\n"));
                 TALLOC_FREE(subkeys);
@@ -1048 +1271 @@
         for ( i=0; i<nk->num_values; i++ ) {
                 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
-                        (const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
+                        nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
         }
 
@@ -1191 +1414 @@
 
 static NTSTATUS rpc_registry_getsd_internal(struct net_context *c,
-                                            const DOM_SID *domain_sid,
+                                            const struct dom_sid *domain_sid,
                                             const char *domain_name,
                                             struct cli_state *cli,
@@ -1201 +1424 @@
         struct policy_handle pol_hive, pol_key;
         NTSTATUS status;
+        WERROR werr;
         enum ndr_err_code ndr_err;
         struct KeySecurityData *sd = NULL;
@@ -1206 +1430 @@
         DATA_BLOB blob;
         struct security_descriptor sec_desc;
-        uint32_t access_mask = REG_KEY_READ |
-                               SEC_FLAG_MAXIMUM_ALLOWED |
+        uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED |
                                SEC_FLAG_SYSTEM_SECURITY;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc <1 || argc > 2 || c->display_usage) {
@@ -1242 +1466 @@
         }
 
-        status = registry_getsd(mem_ctx, pipe_hnd, &pol_key, sec_info, sd);
+        status = registry_getsd(mem_ctx, b, &pol_key, sec_info, sd, &werr);
         if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("getting sd failed: %s\n"),
                           nt_errstr(status));
+                goto out;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                status = werror_to_ntstatus(werr);
+                d_fprintf(stderr, _("getting sd failed: %s\n"),
+                          win_errstr(werr));
                 goto out;
         }
@@ -1252 +1482 @@
         blob.length = sd->size;
 
-        ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &sec_desc,
+        ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &sec_desc,
                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
@@ -1263 +1493 @@
 
  out:
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_key, NULL);
-        rpccli_winreg_CloseKey(pipe_hnd, mem_ctx, &pol_hive, NULL);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
 
         return status;
@@ -1277 +1507 @@
 
 /********************************************************************
-********************************************************************/
+ ********************************************************************/
+/**
+ * @defgroup net_rpc_registry net rpc registry
+ */
+
+/**
+ * @defgroup net_rpc_registry_export Export
+ * @ingroup net_rpc_registry
+ * @{
+ */
+
+static NTSTATUS registry_export(struct rpc_pipe_client* pipe_hnd,
+                                TALLOC_CTX* ctx,
+                                struct policy_handle* key_hnd,
+                                struct reg_format* f,
+                                const char* parentfullname,
+                                const char* name)
+{
+        NTSTATUS status;
+        uint32 num_subkeys = 0;
+        uint32 num_values = 0;
+        char **names = NULL, **classes = NULL;
+        NTTIME **modtimes = NULL;
+        struct regval_blob **values = NULL;
+        uint32 i;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        TALLOC_CTX* mem_ctx = talloc_new(ctx);
+
+
+        const char* fullname = name
+                ? talloc_asprintf(mem_ctx, "%s\\%s", parentfullname, name)
+                : parentfullname;
+        reg_format_key(f, &fullname, 1, false);
+
+        status = registry_enumvalues2(mem_ctx, pipe_hnd, key_hnd, &num_values,
+                                      &names, &values);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("enumerating values failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
+        for (i=0; i<num_values; i++) {
+                reg_format_regval_blob(f, names[i], values[i]);
+        }
+
+
+        status = registry_enumkeys(mem_ctx, pipe_hnd, key_hnd, &num_subkeys,
+                                   &names, &classes, &modtimes);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("enumerating keys failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
+        for (i=0; i<num_subkeys; i++) {
+                struct policy_handle subkey_hnd;
+                struct winreg_String key;
+                WERROR werr;
+                ZERO_STRUCT(key);
+                /* key.name = talloc_strdup(mem_ctx, names[i]); ??? */
+                key.name = names[i];
+
+                status = dcerpc_winreg_OpenKey(b, mem_ctx, key_hnd, key,
+                                               0, REG_KEY_READ,
+                                               &subkey_hnd, &werr);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr,
+                                  _("dcerpc_winreg_OpenKey failed: %s %s\n"),
+                                  names[i], nt_errstr(status));
+                        continue;
+                }
+                if (!W_ERROR_IS_OK(werr)) {
+                        status = werror_to_ntstatus(werr);
+                        d_fprintf(stderr,
+                                  _("dcerpc_winreg_OpenKey failed: %s %s\n"),
+                                  names[i], win_errstr(werr));
+                        continue;
+                }
+
+                status = registry_export(pipe_hnd, mem_ctx, &subkey_hnd,
+                                         f, fullname, names[i]);
+                if (!(NT_STATUS_IS_OK(status))) {
+                        d_fprintf(stderr,
+                                  _("export key failed: %s %s\n"),
+                                  names[i], nt_errstr(status));
+                }
+                dcerpc_winreg_CloseKey(b, mem_ctx,
+                                       &subkey_hnd, &werr);
+        }
+done:
+        talloc_free(mem_ctx);
+        return status;
+}
+
+static NTSTATUS rpc_registry_export_internal(struct net_context *c,
+                                             const struct dom_sid *domain_sid,
+                                             const char *domain_name,
+                                             struct cli_state *cli,
+                                             struct rpc_pipe_client *pipe_hnd,
+                                             TALLOC_CTX *mem_ctx,
+                                             int argc,
+                                             const char **argv )
+{
+        struct policy_handle pol_hive, pol_key;
+        NTSTATUS status;
+        WERROR werr;
+        struct reg_format* f;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        if (argc < 2 || argc > 3 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net rpc registry export <path> <file> [opt]\n"));
+                d_printf("%s  net rpc registry export "
+                         "'HKLM\\Software\\Samba' samba.reg\n", _("Example:"));
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+
+        status = registry_openkey(mem_ctx, pipe_hnd, argv[0], REG_KEY_READ,
+                                  &pol_hive, &pol_key);
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("registry_openkey failed: %s\n"),
+                          nt_errstr(status));
+                return status;
+        }
+
+        f = reg_format_file(mem_ctx, argv[1], (argc > 2) ? argv[2] : NULL);
+        if (f == NULL) {
+                d_fprintf(stderr, _("open file failed: %s\n"), strerror(errno));
+                return map_nt_error_from_unix(errno);
+        }
+
+        status = registry_export(pipe_hnd, mem_ctx, &pol_key,
+                                 f, argv[0], NULL );
+        if (!NT_STATUS_IS_OK(status))
+                return status;
+
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_key, &werr);
+        dcerpc_winreg_CloseKey(b, mem_ctx, &pol_hive, &werr);
+
+        return status;
+}
+/********************************************************************
+ ********************************************************************/
+
+static int rpc_registry_export(struct net_context *c, int argc,
+                               const char **argv )
+{
+        return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+                               rpc_registry_export_internal, argc, argv );
+}
+
+/**@}*/
+
+/********************************************************************
+ ********************************************************************/
+
+/**
+ * @defgroup net_rpc_registry_import Import
+ * @ingroup net_rpc_registry
+ * @{
+ */
+
+struct import_ctx {
+        struct rpc_pipe_client *pipe_hnd;
+        TALLOC_CTX *mem_ctx;
+};
+
+static WERROR import_create_key(struct import_ctx* ctx,
+                                struct policy_handle* parent, const char* name,
+                                void** pkey, bool* existing)
+{
+        WERROR werr;
+        NTSTATUS status;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+
+        struct policy_handle* key = NULL;
+        struct policy_handle  hive;
+        struct winreg_String  keyclass, keyname;
+        enum winreg_CreateAction action = REG_ACTION_NONE;
+        struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+        ZERO_STRUCT(keyname);
+        keyname.name = name;
+
+        if (parent == NULL) {
+                uint32 hive_idx = 0;
+                if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
+                        werr = WERR_FOOBAR;
+                        goto done;
+                }
+
+                status = dcerpc_winreg_Connect(b, mem_ctx,
+                                               hive_idx, SEC_FLAG_MAXIMUM_ALLOWED,
+                                               &hive, &werr);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+                                  nt_errstr(status));
+                        goto done;
+                }
+                if (!W_ERROR_IS_OK(werr)) {
+                        d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+                                  win_errstr(werr));
+                        goto done;
+                }
+
+                parent = &hive;
+        }
+
+        key = talloc_zero(mem_ctx, struct policy_handle);
+        if (key == NULL) {
+                werr = WERR_NOMEM;
+                goto done;
+        }
+
+        ZERO_STRUCT(keyclass);
+        keyclass.name = "";
+
+        status = dcerpc_winreg_CreateKey(b, mem_ctx,
+                                         parent, keyname,
+                                         keyclass, 0, REG_KEY_READ, NULL,
+                                         key, &action, &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("dcerpc_winreg_CreateKey returned %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        switch (action) {
+        case REG_CREATED_NEW_KEY:
+                d_printf(_("createkey created %s\n"), name);
+                if (existing != NULL)
+                        *existing = false;
+                break;
+
+        case REG_OPENED_EXISTING_KEY:
+                d_printf(_("createkey opened existing %s\n"), name);
+                if (existing != NULL)
+                        *existing = true;
+                break;
+
+        case REG_ACTION_NONE:
+                d_printf(_("createkey did nothing -- huh?\n"));
+                werr = WERR_CREATE_FAILED;
+                break;
+        default:
+                assert(false);
+        }
+
+done:
+        if ( parent == &hive ) {
+                WERROR _result;
+                dcerpc_winreg_CloseKey(b, mem_ctx,
+                                       parent, &_result);
+        }
+
+        if (pkey!=NULL) {
+                *pkey = talloc_steal(ctx->mem_ctx, key);
+        }
+
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_delete_key(struct import_ctx* ctx,
+                                struct policy_handle* parent, const char* name)
+{
+        WERROR werr;
+        NTSTATUS status;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+        struct winreg_String  keyname = { 0, };
+        struct policy_handle  hive;
+        struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+        keyname.name = name;
+
+        if (parent == NULL) {
+                uint32 hive_idx;
+                if (!reg_hive_key(mem_ctx, name, &hive_idx, &keyname.name)) {
+                        werr = WERR_FOOBAR;
+                        goto done;
+                }
+
+                status = dcerpc_winreg_Connect(b, mem_ctx, hive_idx,
+                                               SEC_FLAG_MAXIMUM_ALLOWED, &hive,
+                                               &werr);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+                                  nt_errstr(status));
+                        goto done;
+                }
+                if (!W_ERROR_IS_OK(werr)) {
+                        d_fprintf(stderr, _("dcerpc_winreg_Connect returned %s\n"),
+                                  win_errstr(werr));
+                        goto done;
+                }
+
+                parent = &hive;
+        }
+
+        status = dcerpc_winreg_DeleteKey(b, mem_ctx, parent,
+                                         keyname, &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("dcerpc_winreg_DeleteKey returned %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+done:
+        if ( parent == &hive ) {
+                WERROR _result;
+                dcerpc_winreg_CloseKey(b, mem_ctx, parent, &_result);
+        }
+
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_close_key(struct import_ctx* ctx,
+                               struct policy_handle* key)
+{
+        WERROR werr;
+        NTSTATUS status;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+        struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+        status = dcerpc_winreg_CloseKey(b, mem_ctx, key, &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("dcerpc_winreg_CloseKey returned %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+        werr = (talloc_free(key) == 0) ? WERR_OK : WERR_GENERAL_FAILURE;
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_create_val(struct import_ctx* ctx,
+                                struct policy_handle* parent, const char* name,
+                                uint32_t type, const uint8_t* val, uint32_t len)
+{
+        WERROR werr;
+        NTSTATUS status;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+        struct winreg_String valuename;
+        struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+        if (parent == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        ZERO_STRUCT(valuename);
+        valuename.name = name;
+
+        status = dcerpc_winreg_SetValue(b, mem_ctx, parent,
+                                        valuename, type,
+                                        (uint8_t *)discard_const(val), len, &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                d_fprintf(stderr, _("registry_setvalue failed: %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR import_delete_val(struct import_ctx* ctx,
+                                struct policy_handle* parent, const char* name)
+{
+        WERROR werr;
+        NTSTATUS status;
+        void* mem_ctx = talloc_new(ctx->mem_ctx);
+        struct winreg_String valuename;
+        struct dcerpc_binding_handle *b = ctx->pipe_hnd->binding_handle;
+
+        if (parent == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        ZERO_STRUCT(valuename);
+        valuename.name = name;
+
+        status = dcerpc_winreg_DeleteValue(b, mem_ctx,
+                                           parent, valuename, &werr);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                d_fprintf(stderr, _("registry_deletevalue failed: %s\n"),
+                          win_errstr(werr));
+                goto done;
+        }
+
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+
+
+static NTSTATUS rpc_registry_import_internal(struct net_context *c,
+                                             const struct dom_sid *domain_sid,
+                                             const char *domain_name,
+                                             struct cli_state *cli,
+                                             struct rpc_pipe_client *pipe_hnd,
+                                             TALLOC_CTX *mem_ctx,
+                                             int argc,
+                                             const char **argv )
+{
+        struct import_ctx import_ctx;
+
+        struct reg_import_callback import_callback = {
+                .openkey     = NULL,
+                .closekey    = (reg_import_callback_closekey_t)&import_close_key,
+                .createkey   = (reg_import_callback_createkey_t)&import_create_key,
+                .deletekey   = (reg_import_callback_deletekey_t)&import_delete_key,
+                .deleteval   = (reg_import_callback_deleteval_t)&import_delete_val,
+                .setval      = {
+                        .blob = (reg_import_callback_setval_blob_t)&import_create_val,
+                },
+                .setval_type = BLOB,
+                .data = &import_ctx
+        };
+
+        int ret;
+        if (argc < 1 || argc > 2 || c->display_usage) {
+                d_printf("%s\n%s",
+                         _("Usage:"),
+                         _("net rpc registry import <file> [options]\n"));
+                d_printf("%s  net rpc registry export "
+                         "samba.reg enc=CP1252,flags=0\n", _("Example:"));
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ZERO_STRUCT(import_ctx);
+        import_ctx.pipe_hnd = pipe_hnd;
+        import_ctx.mem_ctx  = mem_ctx;
+        ret = reg_parse_file(argv[0],
+                             reg_import_adapter(import_ctx.mem_ctx,
+                                                import_callback
+                                     ),
+                             (argc > 1) ? argv[1] : NULL
+                );
+
+        return ret==0 ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+}
+
+/********************************************************************
+ ********************************************************************/
+
+static int rpc_registry_import(struct net_context *c, int argc,
+                               const char **argv )
+{
+        return run_rpc_command(c, NULL, &ndr_table_winreg.syntax_id, 0,
+                               rpc_registry_import_internal, argc, argv );
+}
+
+/**@}*/
+/********************************************************************
+ ********************************************************************/
 
 int net_rpc_registry(struct net_context *c, int argc, const char **argv)
@@ -1370 +2094 @@
                            "    Get security descriptior")
                 },
+                {
+                        "import",
+                        rpc_registry_import,
+                        NET_TRANSPORT_RPC,
+                        N_("Import .reg file"),
+                        N_("net rpc registry import\n"
+                           "    Import .reg file")
+                },
+                {
+                        "export",
+                        rpc_registry_export,
+                        NET_TRANSPORT_RPC,
+                        N_("Export .reg file"),
+                        N_("net rpc registry export\n"
+                           "    Export .reg file")
+                },
                 {NULL, NULL, 0, NULL, NULL}
         };
-
         return net_run_function(c, argc, argv, "net rpc registry", func);
 }

vendor/current/source3/utils/net_rpc_rights.c

@@ -20 +20 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_lsa.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/security.h"
 
 /********************************************************************
@@ -27 +31 @@
 static NTSTATUS sid_to_name(struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
-                                DOM_SID *sid,
+                                struct dom_sid *sid,
                                 fstring name)
 {
         struct policy_handle pol;
         enum lsa_SidType *sid_types = NULL;
-        NTSTATUS result;
+        NTSTATUS status, result;
         char **domains = NULL, **names = NULL;
-
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                 SEC_FLAG_MAXIMUM_ALLOWED, &pol);
 
-        if ( !NT_STATUS_IS_OK(result) )
-                return result;
-
-        result = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &pol, 1, sid, &domains, &names, &sid_types);
-
-        if ( NT_STATUS_IS_OK(result) ) {
+        if ( !NT_STATUS_IS_OK(status) )
+                return status;
+
+        status = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &pol, 1, sid, &domains, &names, &sid_types);
+
+        if ( NT_STATUS_IS_OK(status) ) {
                 if ( *domains[0] )
                         fstr_sprintf( name, "%s\\%s", domains[0], names[0] );
@@ -50 +55 @@
         }
 
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &pol);
-        return result;
+        dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
+        return status;
 }
 
@@ -59 +64 @@
 static NTSTATUS name_to_sid(struct rpc_pipe_client *pipe_hnd,
                             TALLOC_CTX *mem_ctx,
-                            DOM_SID *sid, const char *name)
+                            struct dom_sid *sid, const char *name)
 {
         struct policy_handle pol;
         enum lsa_SidType *sid_types;
-        NTSTATUS result;
-        DOM_SID *sids;
+        NTSTATUS status, result;
+        struct dom_sid *sids;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* maybe its a raw SID */
@@ -71 +77 @@
         }
 
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                 SEC_FLAG_MAXIMUM_ALLOWED, &pol);
 
-        if ( !NT_STATUS_IS_OK(result) )
-                return result;
-
-        result = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &pol, 1, &name,
+        if ( !NT_STATUS_IS_OK(status) )
+                return status;
+
+        status = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &pol, 1, &name,
                                          NULL, 1, &sids, &sid_types);
 
-        if ( NT_STATUS_IS_OK(result) )
+        if ( NT_STATUS_IS_OK(status) )
                 sid_copy( sid, &sids[0] );
 
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &pol);
-        return result;
+        dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
+        return status;
 }
 
@@ -94 +100 @@
                                 struct policy_handle *pol )
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 enum_context = 0;
         uint32 pref_max_length=0x1000;
@@ -103 +109 @@
         struct lsa_StringLarge *description = NULL;
         struct lsa_PrivArray priv_array;
-
-        result = rpccli_lsa_EnumPrivs(pipe_hnd, ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_EnumPrivs(b, ctx,
                                       pol,
                                       &enum_context,
                                       &priv_array,
-                                      pref_max_length);
-
-        if ( !NT_STATUS_IS_OK(result) )
+                                      pref_max_length,
+                                      &result);
+
+        if ( !NT_STATUS_IS_OK(status) )
+                return status;
+        if (!NT_STATUS_IS_OK(result)) {
                 return result;
+        }
 
         /* Print results */
@@ -126 +137 @@
                 init_lsa_String(&lsa_name, priv_array.privs[i].name.string);
 
-                result = rpccli_lsa_LookupPrivDisplayName(pipe_hnd, ctx,
+                status = dcerpc_lsa_LookupPrivDisplayName(b, ctx,
                                                           pol,
                                                           &lsa_name,
@@ -132 +143 @@
                                                           lang_id_sys,
                                                           &description,
-                                                          &lang_id_desc);
-
+                                                          &lang_id_desc,
+                                                          &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_printf("??????\n");
+                        continue;
+                }
                 if (!NT_STATUS_IS_OK(result)) {
                         d_printf("??????\n");
@@ -151 +166 @@
                                         TALLOC_CTX *ctx,
                                         struct policy_handle *pol,
-                                        DOM_SID *sid,
+                                        struct dom_sid *sid,
                                         const char *right)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         struct lsa_RightSet rights;
         int i;
-
-        result = rpccli_lsa_EnumAccountRights(pipe_hnd, ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_EnumAccountRights(b, ctx,
                                               pol,
                                               sid,
-                                              &rights);
-
+                                              &rights,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         if (!NT_STATUS_IS_OK(result)) {
                 return result;
@@ -186 +205 @@
                                         TALLOC_CTX *ctx,
                                         struct policy_handle *pol,
-                                        DOM_SID *sid )
-{
-        NTSTATUS result;
+                                        struct dom_sid *sid )
+{
+        NTSTATUS status, result;
         struct lsa_RightSet rights;
         int i;
-
-        result = rpccli_lsa_EnumAccountRights(pipe_hnd, ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_EnumAccountRights(b, ctx,
                                               pol,
                                               sid,
-                                              &rights);
-
+                                              &rights,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status))
+                return status;
         if (!NT_STATUS_IS_OK(result))
                 return result;
@@ -219 +241 @@
                                                 const char *privilege)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 enum_context=0;
         uint32 pref_max_length=0x1000;
@@ -225 +247 @@
         int i;
         fstring name;
-
-        result = rpccli_lsa_EnumAccounts(pipe_hnd, ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_EnumAccounts(b, ctx,
                                          pol,
                                          &enum_context,
                                          &sid_array,
-                                         pref_max_length);
-
+                                         pref_max_length,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status))
+                return status;
         if (!NT_STATUS_IS_OK(result))
                 return result;
@@ -239 +264 @@
         for ( i=0; i<sid_array.num_sids; i++ ) {
 
-                result = check_privilege_for_user(pipe_hnd, ctx, pol,
+                status = check_privilege_for_user(pipe_hnd, ctx, pol,
                                                   sid_array.sids[i].sid,
                                                   privilege);
 
-                if ( ! NT_STATUS_IS_OK(result)) {
-                        if ( ! NT_STATUS_EQUAL(result, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-                                return result;
+                if ( ! NT_STATUS_IS_OK(status)) {
+                        if ( ! NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                                return status;
                         }
                         continue;
@@ -252 +277 @@
                 /* try to convert the SID to a name.  Fall back to
                    printing the raw SID if necessary */
-                result = sid_to_name( pipe_hnd, ctx, sid_array.sids[i].sid, name );
-                if ( !NT_STATUS_IS_OK (result) )
+                status = sid_to_name( pipe_hnd, ctx, sid_array.sids[i].sid, name );
+                if ( !NT_STATUS_IS_OK (status) )
                         sid_to_fstring(name, sid_array.sids[i].sid);
 
@@ -269 +294 @@
                                                 struct policy_handle *pol)
 {
-        NTSTATUS result;
+        NTSTATUS status, result;
         uint32 enum_context=0;
         uint32 pref_max_length=0x1000;
@@ -275 +300 @@
         int i;
         fstring name;
-
-        result = rpccli_lsa_EnumAccounts(pipe_hnd, ctx,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_EnumAccounts(b, ctx,
                                          pol,
                                          &enum_context,
                                          &sid_array,
-                                         pref_max_length);
-
+                                         pref_max_length,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status))
+                return status;
         if (!NT_STATUS_IS_OK(result))
                 return result;
@@ -290 +318 @@
                    printing the raw SID if necessary */
 
-                result = sid_to_name(pipe_hnd, ctx, sid_array.sids[i].sid, name);
-                if ( !NT_STATUS_IS_OK (result) )
+                status = sid_to_name(pipe_hnd, ctx, sid_array.sids[i].sid, name);
+                if ( !NT_STATUS_IS_OK (status) )
                         sid_to_fstring(name, sid_array.sids[i].sid);
 
                 d_printf("%s\n", name);
 
-                result = enum_privileges_for_user(pipe_hnd, ctx, pol,
+                status = enum_privileges_for_user(pipe_hnd, ctx, pol,
                                                   sid_array.sids[i].sid);
-                if ( !NT_STATUS_IS_OK(result) )
-                        return result;
+                if ( !NT_STATUS_IS_OK(status) )
+                        return status;
 
                 d_printf("\n");
@@ -311 +339 @@
 
 static NTSTATUS rpc_rights_list_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -320 +348 @@
 {
         struct policy_handle pol;
-        NTSTATUS result;
-        DOM_SID sid;
+        NTSTATUS status, result;
+        struct dom_sid sid;
         fstring privname;
         struct lsa_String lsa_name;
@@ -328 +356 @@
         uint16 lang_id_sys = 0;
         uint16 lang_id_desc;
-
-        result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
                 SEC_FLAG_MAXIMUM_ALLOWED, &pol);
 
-        if ( !NT_STATUS_IS_OK(result) )
-                return result;
+        if ( !NT_STATUS_IS_OK(status) )
+                return status;
 
         /* backwards compatibility; just list available privileges if no arguement */
 
         if (argc == 0) {
-                result = enum_privileges(pipe_hnd, mem_ctx, &pol );
+                status = enum_privileges(pipe_hnd, mem_ctx, &pol );
                 goto done;
         }
@@ -346 +375 @@
 
                 if (argv[1] == NULL) {
-                        result = enum_privileges(pipe_hnd, mem_ctx, &pol );
+                        status = enum_privileges(pipe_hnd, mem_ctx, &pol );
                         goto done;
                 }
@@ -356 +385 @@
 
                         /* verify that this is a valid privilege for error reporting */
-                        result = rpccli_lsa_LookupPrivDisplayName(pipe_hnd, mem_ctx,
+                        status = dcerpc_lsa_LookupPrivDisplayName(b, mem_ctx,
                                                                   &pol,
                                                                   &lsa_name,
@@ -362 +391 @@
                                                                   lang_id_sys,
                                                                   &description,
-                                                                  &lang_id_desc);
-
+                                                                  &lang_id_desc,
+                                                                  &result);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                continue;
+                        }
+                        status = result;
                         if ( !NT_STATUS_IS_OK(result) ) {
-                                if ( NT_STATUS_EQUAL( result, NT_STATUS_NO_SUCH_PRIVILEGE ) ) 
+                                if ( NT_STATUS_EQUAL(result, NT_STATUS_NO_SUCH_PRIVILEGE))
                                         d_fprintf(stderr, _("No such privilege "
                                                   "exists: %s.\n"), privname);
@@ -376 +409 @@
                         }
 
-                        result = enum_accounts_for_privilege(pipe_hnd, mem_ctx, &pol, privname);
-                        if (!NT_STATUS_IS_OK(result)) {
+                        status = enum_accounts_for_privilege(pipe_hnd, mem_ctx, &pol, privname);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 d_fprintf(stderr, _("Error enumerating "
                                           "accounts for privilege %s [%s].\n"),
-                                          privname, nt_errstr(result));
+                                          privname, nt_errstr(status));
                                 continue;
                         }
@@ -393 +426 @@
 
                 if (argv[1] == NULL) {
-                        result = enum_privileges_for_accounts(pipe_hnd, mem_ctx, &pol);
+                        status = enum_privileges_for_accounts(pipe_hnd, mem_ctx, &pol);
                         goto done;
                 }
 
                 while (argv[i] != NULL) {
-                        result = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[i]);
-                        if (!NT_STATUS_IS_OK(result)) {
+                        status = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[i]);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto done;
                         }
-                        result = enum_privileges_for_user(pipe_hnd, mem_ctx, &pol, &sid);
-                        if (!NT_STATUS_IS_OK(result)) {
+                        status = enum_privileges_for_user(pipe_hnd, mem_ctx, &pol, &sid);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto done;
                         }
@@ -416 +449 @@
                 d_printf("%s net rpc rights list [[accounts|privileges] "
                          "[name|SID]]\n", _("Usage:"));
-                result = NT_STATUS_OK;
-                goto done;
-        }
-
-        result = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
-        if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-        result = enum_privileges_for_user(pipe_hnd, mem_ctx, &pol, &sid );
+                status = NT_STATUS_OK;
+                goto done;
+        }
+
+        status = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = enum_privileges_for_user(pipe_hnd, mem_ctx, &pol, &sid );
 
 done:
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &pol);
-
-        return result;
+        dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
+
+        return status;
 }
 
@@ -436 +469 @@
 
 static NTSTATUS rpc_rights_grant_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -445 +478 @@
 {
         struct policy_handle dom_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         struct lsa_RightSet rights;
         int i;
-
-        DOM_SID sid;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
+
+        struct dom_sid sid;
 
         if (argc < 2 ) {
@@ -458 +492 @@
         }
 
-        result = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
-        if (NT_STATUS_EQUAL(result, NT_STATUS_NONE_MAPPED))
-                result = NT_STATUS_NO_SUCH_USER;
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
-
-        result = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, true,
+        status = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
+                status = NT_STATUS_NO_SUCH_USER;
+
+        if (!NT_STATUS_IS_OK(status))
+                goto done;
+
+        status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, true,
                                      SEC_FLAG_MAXIMUM_ALLOWED,
                                      &dom_pol);
 
-        if (!NT_STATUS_IS_OK(result))
-                return result;
+        if (!NT_STATUS_IS_OK(status))
+                return status;
 
         rights.count = argc-1;
@@ -483 +517 @@
         }
 
-        result = rpccli_lsa_AddAccountRights(pipe_hnd, mem_ctx,
+        status = dcerpc_lsa_AddAccountRights(b, mem_ctx,
                                              &dom_pol,
                                              &sid,
-                                             &rights);
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
+                                             &rights,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status))
+                goto done;
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
 
         d_printf(_("Successfully granted rights.\n"));
 
  done:
-        if ( !NT_STATUS_IS_OK(result) ) {
+        if ( !NT_STATUS_IS_OK(status) ) {
                 d_fprintf(stderr, _("Failed to grant privileges for %s (%s)\n"),
-                        argv[0], nt_errstr(result));
-        }
-
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &dom_pol);
-
-        return result;
+                        argv[0], nt_errstr(status));
+        }
+
+        dcerpc_lsa_Close(b, mem_ctx, &dom_pol, &result);
+
+        return status;
 }
 
@@ -508 +546 @@
 
 static NTSTATUS rpc_rights_revoke_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -517 +555 @@
 {
         struct policy_handle dom_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         struct lsa_RightSet rights;
-        DOM_SID sid;
+        struct dom_sid sid;
         int i;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc < 2 ) {
@@ -529 +568 @@
         }
 
-        result = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
-        if (!NT_STATUS_IS_OK(result))
-                return result;
-
-        result = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, true,
+        status = name_to_sid(pipe_hnd, mem_ctx, &sid, argv[0]);
+        if (!NT_STATUS_IS_OK(status))
+                return status;
+
+        status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, true,
                                      SEC_FLAG_MAXIMUM_ALLOWED,
                                      &dom_pol);
 
-        if (!NT_STATUS_IS_OK(result))
-                return result;
+        if (!NT_STATUS_IS_OK(status))
+                return status;
 
         rights.count = argc-1;
@@ -551 +590 @@
         }
 
-        result = rpccli_lsa_RemoveAccountRights(pipe_hnd, mem_ctx,
+        status = dcerpc_lsa_RemoveAccountRights(b, mem_ctx,
                                                 &dom_pol,
                                                 &sid,
                                                 false,
-                                                &rights);
-
-        if (!NT_STATUS_IS_OK(result))
-                goto done;
+                                                &rights,
+                                                &result);
+        if (!NT_STATUS_IS_OK(status))
+                goto done;
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
 
         d_printf(_("Successfully revoked rights.\n"));
 
 done:
-        if ( !NT_STATUS_IS_OK(result) ) {
+        if ( !NT_STATUS_IS_OK(status) ) {
                 d_fprintf(stderr,_("Failed to revoke privileges for %s (%s)\n"),
-                        argv[0], nt_errstr(result));
-        }
-
-        rpccli_lsa_Close(pipe_hnd, mem_ctx, &dom_pol);
-
-        return result;
+                        argv[0], nt_errstr(status));
+        }
+
+        dcerpc_lsa_Close(b, mem_ctx, &dom_pol, &result);
+
+        return status;
 }
 

vendor/current/source3/utils/net_rpc_samsync.c

@@ -26 +26 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "../librpc/gen_ndr/ndr_drsuapi.h"
+#include "libnet/libnet_samsync.h"
+#include "libnet/libnet_dssync.h"
+#include "../libcli/security/security.h"
+#include "passdb/machine_sid.h"
 
 static void parse_samsync_partial_replication_objects(TALLOC_CTX *mem_ctx,
@@ -104 +110 @@
 /* dump sam database via samsync rpc calls */
 NTSTATUS rpc_samdump_internals(struct net_context *c,
-                                const DOM_SID *domain_sid,
+                                const struct dom_sid *domain_sid,
                                 const char *domain_name,
                                 struct cli_state *cli,
@@ -170 +176 @@
 }
 
-
-/* dump sam database via samsync rpc calls */
-NTSTATUS rpc_vampire_internals(struct net_context *c,
-                                const DOM_SID *domain_sid,
-                                const char *domain_name,
-                                struct cli_state *cli,
-                                struct rpc_pipe_client *pipe_hnd,
-                                TALLOC_CTX *mem_ctx,
-                                int argc,
-                                const char **argv)
-{
-        NTSTATUS result;
-        struct samsync_context *ctx = NULL;
-
-        if (!sid_equal(domain_sid, get_global_sam_sid())) {
+static NTSTATUS rpc_vampire_ds_internals(struct net_context *c,
+                                         const struct dom_sid *domain_sid,
+                                         const char *domain_name,
+                                         struct cli_state *cli,
+                                         struct rpc_pipe_client *pipe_hnd,
+                                         TALLOC_CTX *mem_ctx,
+                                         int argc,
+                                         const char **argv)
+{
+        NTSTATUS status;
+        struct dssync_context *ctx = NULL;
+
+        if (!dom_sid_equal(domain_sid, get_global_sam_sid())) {
                 d_printf(_("Cannot import users from %s at this time, "
                            "as the current domain:\n\t%s: %s\nconflicts "
@@ -199 +203 @@
         }
 
+        status = libnet_dssync_init_context(mem_ctx,
+                                            &ctx);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        ctx->cli                = pipe_hnd;
+        ctx->domain_name        = domain_name;
+        ctx->ops                = &libnet_dssync_passdb_ops;
+
+        status = libnet_dssync(mem_ctx, ctx);
+        if (!NT_STATUS_IS_OK(status) && ctx->error_message) {
+                d_fprintf(stderr, "%s\n", ctx->error_message);
+                goto out;
+        }
+
+        if (ctx->result_message) {
+                d_fprintf(stdout, "%s\n", ctx->result_message);
+        }
+
+ out:
+        TALLOC_FREE(ctx);
+
+        return status;
+}
+
+/* dump sam database via samsync rpc calls */
+static NTSTATUS rpc_vampire_internals(struct net_context *c,
+                                      const struct dom_sid *domain_sid,
+                                      const char *domain_name,
+                                      struct cli_state *cli,
+                                      struct rpc_pipe_client *pipe_hnd,
+                                      TALLOC_CTX *mem_ctx,
+                                      int argc,
+                                      const char **argv)
+{
+        NTSTATUS result;
+        struct samsync_context *ctx = NULL;
+
+        if (!dom_sid_equal(domain_sid, get_global_sam_sid())) {
+                d_printf(_("Cannot import users from %s at this time, "
+                           "as the current domain:\n\t%s: %s\nconflicts "
+                           "with the remote domain\n\t%s: %s\n"
+                           "Perhaps you need to set: \n\n\tsecurity=user\n\t"
+                           "workgroup=%s\n\n in your smb.conf?\n"),
+                         domain_name,
+                         get_global_sam_name(),
+                         sid_string_dbg(get_global_sam_sid()),
+                         domain_name,
+                         sid_string_dbg(domain_sid),
+                         domain_name);
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+
         result = libnet_samsync_init_context(mem_ctx,
                                              domain_sid,
@@ -232 +290 @@
 
         /* fetch builtin */
-        ctx->domain_sid = sid_dup_talloc(mem_ctx, &global_sid_Builtin);
+        ctx->domain_sid = dom_sid_dup(mem_ctx, &global_sid_Builtin);
         ctx->domain_sid_str = sid_string_talloc(mem_ctx, ctx->domain_sid);
         result = libnet_samsync(SAM_DATABASE_BUILTIN, ctx);
@@ -252 +310 @@
 int rpc_vampire_passdb(struct net_context *c, int argc, const char **argv)
 {
+        int ret = 0;
+        NTSTATUS status;
+        struct cli_state *cli = NULL;
+        struct net_dc_info dc_info;
+
         if (c->display_usage) {
                 d_printf(  "%s\n"
@@ -261 +324 @@
         }
 
-        return run_rpc_command(c, NULL, &ndr_table_netlogon.syntax_id, 0,
-                               rpc_vampire_internals, argc, argv);
-}
-
-NTSTATUS rpc_vampire_ldif_internals(struct net_context *c,
-                                    const DOM_SID *domain_sid,
-                                    const char *domain_name,
-                                    struct cli_state *cli,
-                                    struct rpc_pipe_client *pipe_hnd,
-                                    TALLOC_CTX *mem_ctx,
-                                    int argc,
-                                    const char **argv)
+        status = net_make_ipc_connection(c, 0, &cli);
+        if (!NT_STATUS_IS_OK(status)) {
+                return -1;
+        }
+
+        status = net_scan_dc(c, cli, &dc_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                return -1;
+        }
+
+        if (!dc_info.is_ad) {
+                printf(_("DC is not running Active Directory\n"));
+                ret = run_rpc_command(c, cli, &ndr_table_netlogon.syntax_id,
+                                      0,
+                                      rpc_vampire_internals, argc, argv);
+                return ret;
+        }
+
+        if (!c->opt_force) {
+                d_printf(  "%s\n"
+                           "net rpc vampire passdb\n"
+                           "    %s\n",
+                         _("Usage:"),
+                         _("Should not be used against Active Directory, maybe use --force"));
+                return -1;
+        }
+
+        ret = run_rpc_command(c, cli, &ndr_table_drsuapi.syntax_id,
+                              NET_FLAGS_SEAL | NET_FLAGS_TCP,
+                              rpc_vampire_ds_internals, argc, argv);
+        if (ret != 0 && dc_info.is_mixed_mode) {
+                printf(_("Fallback to NT4 vampire on Mixed-Mode AD "
+                         "Domain\n"));
+                ret = run_rpc_command(c, cli, &ndr_table_netlogon.syntax_id,
+                                      0,
+                                      rpc_vampire_internals, argc, argv);
+        }
+
+        return ret;
+}
+
+static NTSTATUS rpc_vampire_ldif_internals(struct net_context *c,
+                                           const struct dom_sid *domain_sid,
+                                           const char *domain_name,
+                                           struct cli_state *cli,
+                                           struct rpc_pipe_client *pipe_hnd,
+                                           TALLOC_CTX *mem_ctx,
+                                           int argc,
+                                           const char **argv)
 {
         NTSTATUS status;
@@ -315 +415 @@
 
         /* fetch builtin */
-        ctx->domain_sid = sid_dup_talloc(mem_ctx, &global_sid_Builtin);
+        ctx->domain_sid = dom_sid_dup(mem_ctx, &global_sid_Builtin);
         ctx->domain_sid_str = sid_string_talloc(mem_ctx, ctx->domain_sid);
         status = libnet_samsync(SAM_DATABASE_BUILTIN, ctx);
@@ -350 +450 @@
 
 
-NTSTATUS rpc_vampire_keytab_internals(struct net_context *c,
-                                      const DOM_SID *domain_sid,
-                                      const char *domain_name,
-                                      struct cli_state *cli,
-                                      struct rpc_pipe_client *pipe_hnd,
-                                      TALLOC_CTX *mem_ctx,
-                                      int argc,
-                                      const char **argv)
+static NTSTATUS rpc_vampire_keytab_internals(struct net_context *c,
+                                             const struct dom_sid *domain_sid,
+                                             const char *domain_name,
+                                             struct cli_state *cli,
+                                             struct rpc_pipe_client *pipe_hnd,
+                                             TALLOC_CTX *mem_ctx,
+                                             int argc,
+                                             const char **argv)
 {
         NTSTATUS status;
@@ -411 +511 @@
 
 static NTSTATUS rpc_vampire_keytab_ds_internals(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,

vendor/current/source3/utils/net_rpc_service.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_svcctl.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_svcctl.h"
+#include "../librpc/gen_ndr/ndr_svcctl_c.h"
 
 struct svc_state_msg {
@@ -60 +62 @@
 ********************************************************************/
 
+static WERROR open_service(struct dcerpc_binding_handle *b,
+                           TALLOC_CTX *mem_ctx,
+                           struct policy_handle *hSCM,
+                           const char *service,
+                           uint32_t access_mask,
+                           struct policy_handle *hService)
+{
+        NTSTATUS status;
+        WERROR result;
+
+        status = dcerpc_svcctl_OpenServiceW(b, mem_ctx,
+                                            hSCM,
+                                            service,
+                                            access_mask,
+                                            hService,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
+                          nt_errstr(status));
+                return result;
+        }
+        if (!W_ERROR_IS_OK(result) ) {
+                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
+                          win_errstr(result));
+                return result;
+        }
+
+        return WERR_OK;
+}
+
+/********************************************************************
+********************************************************************/
+
+static WERROR open_scm(struct dcerpc_binding_handle *b,
+                       TALLOC_CTX *mem_ctx,
+                       const char *server_name,
+                       uint32_t access_mask,
+                       struct policy_handle *hSCM)
+{
+        NTSTATUS status;
+        WERROR result;
+
+        status = dcerpc_svcctl_OpenSCManagerW(b, mem_ctx,
+                                              server_name,
+                                              NULL,
+                                              access_mask,
+                                              hSCM,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr,
+                          _("Failed to open Service Control Manager. [%s]\n"),
+                          nt_errstr(status));
+                return result;
+        }
+        if (!W_ERROR_IS_OK(result)) {
+                d_fprintf(stderr,
+                          _("Failed to open Service Control Manager. [%s]\n"),
+                          win_errstr(result));
+                return result;
+        }
+
+        return WERR_OK;
+}
+
+/********************************************************************
+********************************************************************/
+
 static WERROR query_service_state(struct rpc_pipe_client *pipe_hnd,
                                 TALLOC_CTX *mem_ctx,
@@ -70 +141 @@
         WERROR result = WERR_GENERAL_FAILURE;
         NTSTATUS status;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* now cycle until the status is actually 'watch_state' */
 
-        status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
-                                            hSCM,
-                                            service,
-                                            SC_RIGHT_SVC_QUERY_STATUS,
-                                            &hService,
-                                            &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
-                          win_errstr(result));
+        result = open_service(b, mem_ctx, hSCM, service,
+                              SC_RIGHT_SVC_QUERY_STATUS,
+                              &hService);
+        if (!W_ERROR_IS_OK(result) ) {
                 return result;
         }
 
-        status = rpccli_svcctl_QueryServiceStatus(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_QueryServiceStatus(b, mem_ctx,
                                                   &hService,
                                                   &service_status,
                                                   &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                *state = service_status.state;
-        }
-
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result)) {
+                goto done;
+        }
+
+        *state = service_status.state;
+
+ done:
+        if (is_valid_policy_hnd(&hService)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
+        }
 
         return result;
@@ -149 +225 @@
         struct SERVICE_STATUS service_status;
         uint32 state = 0;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         /* Open the Service */
 
-        status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
-                                            hSCM,
-                                            service,
-                                            (SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE),
-                                            &hService,
-                                            &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
-                          win_errstr(result));
-                goto done;
+        result = open_service(b, mem_ctx, hSCM, service,
+                              (SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE),
+                              &hService);
+        if (!W_ERROR_IS_OK(result) ) {
+                return result;
         }
 
         /* get the status */
 
-        status = rpccli_svcctl_ControlService(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_ControlService(b, mem_ctx,
                                               &hService,
                                               control,
@@ -173 +244 @@
                                               &result);
 
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Control service request failed.  [%s]\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result) ) {
                 d_fprintf(stderr, _("Control service request failed.  [%s]\n"),
                           win_errstr(result));
@@ -186 +263 @@
 
 done:
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
+        if (is_valid_policy_hnd(&hService)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
+        }
 
         return result;
@@ -195 +275 @@
 
 static NTSTATUS rpc_service_list_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -208 +288 @@
         NTSTATUS status;
         int i;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         uint8_t *buffer = NULL;
@@ -220 +301 @@
         }
 
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager. [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
 
         do {
-                status = rpccli_svcctl_EnumServicesStatusW(pipe_hnd, mem_ctx,
+                status = dcerpc_svcctl_EnumServicesStatusW(b, mem_ctx,
                                                            &hSCM,
                                                            SERVICE_TYPE_WIN32,
@@ -245 +320 @@
                                                            &result);
 
-                if (NT_STATUS_IS_ERR(status)) {
+                if (!NT_STATUS_IS_OK(status)) {
+                        d_fprintf(stderr,
+                                _("Failed to enumerate services.  [%s]\n"),
+                                nt_errstr(status));
+                        break;
+                }
+
+                if (W_ERROR_EQUAL(result, WERR_MORE_DATA) && bytes_needed > 0) {
+                        buffer = talloc_array(mem_ctx, uint8_t, bytes_needed);
+                        buf_size = bytes_needed;
+                        continue;
+                }
+
+                if (!W_ERROR_IS_OK(result)) {
+                        status = werror_to_ntstatus(result);
                         d_fprintf(stderr,
                                 _("Failed to enumerate services.  [%s]\n"),
@@ -252 +341 @@
                 }
 
-                if (W_ERROR_EQUAL(result, WERR_MORE_DATA) && bytes_needed > 0) {
-                        buffer = talloc_array(mem_ctx, uint8_t, bytes_needed);
-                        buf_size = bytes_needed;
-                        continue;
-                }
-
                 if ( num_services == 0 ) {
                         d_printf(_("No services returned\n"));
@@ -277 +360 @@
                         }
 
-                        ndr = ndr_pull_init_blob(&blob, mem_ctx, NULL);
+                        ndr = ndr_pull_init_blob(&blob, mem_ctx);
                         if (ndr == NULL) {
                                 status = NT_STATUS_NO_MEMORY;
@@ -299 +382 @@
         } while (W_ERROR_EQUAL(result, WERR_MORE_DATA));
 
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return status;
@@ -308 +394 @@
 
 static NTSTATUS rpc_service_status_internal(struct net_context *c,
-                                                const DOM_SID *domain_sid,
+                                                const struct dom_sid *domain_sid,
                                                 const char *domain_name,
                                                 struct cli_state *cli,
@@ -323 +409 @@
         uint32_t buf_size = sizeof(config);
         uint32_t ret_size = 0;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -330 +417 @@
 
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager. [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
@@ -345 +426 @@
         /* Open the Service */
 
-        status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
-                                            &hSCM,
-                                            argv[0],
-                                            (SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_QUERY_CONFIG),
-                                            &hService,
-                                            &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
-                          win_errstr(result));
+        result = open_service(b, mem_ctx, &hSCM, argv[0],
+                              (SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_QUERY_CONFIG),
+                              &hService);
+        if (!W_ERROR_IS_OK(result) ) {
                 goto done;
         }
@@ -360 +435 @@
         /* get the status */
 
-        status = rpccli_svcctl_QueryServiceStatus(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_QueryServiceStatus(b, mem_ctx,
                                                   &hService,
                                                   &service_status,
                                                   &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
+        if (!W_ERROR_IS_OK(result) ) {
                 d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
                           win_errstr(result));
@@ -376 +457 @@
         /* get the config */
 
-        status = rpccli_svcctl_QueryServiceConfigW(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_QueryServiceConfigW(b, mem_ctx,
                                                    &hService,
                                                    &config,
@@ -382 +463 @@
                                                    &ret_size,
                                                    &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Query config request failed.  [%s]\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+
         if (W_ERROR_EQUAL(result, WERR_INSUFFICIENT_BUFFER)) {
                 buf_size = ret_size;
-                status = rpccli_svcctl_QueryServiceConfigW(pipe_hnd, mem_ctx,
+                status = dcerpc_svcctl_QueryServiceConfigW(b, mem_ctx,
                                                            &hService,
                                                            &config,
@@ -390 +478 @@
                                                            &ret_size,
                                                            &result);
-        }
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+                if (!NT_STATUS_IS_OK(status)) {
+                        result = ntstatus_to_werror(status);
+                        d_fprintf(stderr, _("Query config request failed.  [%s]\n"),
+                                  nt_errstr(status));
+                        goto done;
+                }
+        }
+
+        if (!W_ERROR_IS_OK(result) ) {
                 d_fprintf(stderr, _("Query config request failed.  [%s]\n"),
                           win_errstr(result));
@@ -433 +527 @@
 
 done:
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hService)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
+        }
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return werror_to_ntstatus(result);
@@ -443 +543 @@
 
 static NTSTATUS rpc_service_stop_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -453 +553 @@
         struct policy_handle hSCM;
         WERROR result = WERR_GENERAL_FAILURE;
-        NTSTATUS status;
-        fstring servicename;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -461 +560 @@
         }
 
-        fstrcpy( servicename, argv[0] );
-
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager.  [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
 
-        result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
+        result = control_service(pipe_hnd, mem_ctx, &hSCM, argv[0],
                 SVCCTL_CONTROL_STOP, SVCCTL_STOPPED );
 
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return werror_to_ntstatus(result);
@@ -489 +583 @@
 
 static NTSTATUS rpc_service_pause_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -499 +593 @@
         struct policy_handle hSCM;
         WERROR result = WERR_GENERAL_FAILURE;
-        NTSTATUS status;
-        fstring servicename;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -507 +600 @@
         }
 
-        fstrcpy( servicename, argv[0] );
-
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager.  [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
 
-        result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
+        result = control_service(pipe_hnd, mem_ctx, &hSCM, argv[0],
                 SVCCTL_CONTROL_PAUSE, SVCCTL_PAUSED );
 
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return werror_to_ntstatus(result);
@@ -535 +623 @@
 
 static NTSTATUS rpc_service_resume_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -545 +633 @@
         struct policy_handle hSCM;
         WERROR result = WERR_GENERAL_FAILURE;
-        NTSTATUS status;
-        fstring servicename;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -553 +640 @@
         }
 
-        fstrcpy( servicename, argv[0] );
-
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager.  [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
 
-        result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,
+        result = control_service(pipe_hnd, mem_ctx, &hSCM, argv[0],
                 SVCCTL_CONTROL_CONTINUE, SVCCTL_RUNNING );
 
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return werror_to_ntstatus(result);
@@ -581 +663 @@
 
 static NTSTATUS rpc_service_start_internal(struct net_context *c,
-                                        const DOM_SID *domain_sid,
+                                        const struct dom_sid *domain_sid,
                                         const char *domain_name,
                                         struct cli_state *cli,
@@ -593 +675 @@
         NTSTATUS status;
         uint32 state = 0;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -600 +683 @@
 
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                          _("Failed to open Service Control Manager.  [%s]\n"),
-                          win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
 
+
         /* Open the Service */
 
-        status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
-                                            &hSCM,
-                                            argv[0],
-                                            SC_RIGHT_SVC_START,
-                                            &hService,
-                                            &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
-                          win_errstr(result));
+        result = open_service(b, mem_ctx, &hSCM, argv[0],
+                              SC_RIGHT_SVC_START,
+                              &hService);
+        if (!W_ERROR_IS_OK(result) ) {
                 goto done;
         }
@@ -630 +702 @@
         /* get the status */
 
-        status = rpccli_svcctl_StartServiceW(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_StartServiceW(b, mem_ctx,
                                              &hService,
                                              0,
@@ -636 +708 @@
                                              &result);
 
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result) ) {
                 d_fprintf(stderr, _("Query status request failed.  [%s]\n"),
                           win_errstr(result));
@@ -652 +730 @@
 
 done:
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
-        rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+        if (is_valid_policy_hnd(&hService)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
+        }
+        if (is_valid_policy_hnd(&hSCM)) {
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
+        }
 
         return werror_to_ntstatus(result);
@@ -662 +746 @@
 
 static NTSTATUS rpc_service_delete_internal(struct net_context *c,
-                                            const DOM_SID *domain_sid,
+                                            const struct dom_sid *domain_sid,
                                             const char *domain_name,
                                             struct cli_state *cli,
@@ -673 +757 @@
         WERROR result = WERR_GENERAL_FAILURE;
         NTSTATUS status;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 1 ) {
@@ -679 +764 @@
         }
 
+        ZERO_STRUCT(hSCM);
+        ZERO_STRUCT(hService);
+
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_ENUMERATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                        _("Failed to open Service Control Manager.  [%s]\n"),
-                        win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_ENUMERATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
@@ -695 +777 @@
         /* Open the Service */
 
-        status = rpccli_svcctl_OpenServiceW(pipe_hnd, mem_ctx,
-                                            &hSCM,
-                                            argv[0],
-                                            SERVICE_ALL_ACCESS,
-                                            &hService,
-                                            &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
-                d_fprintf(stderr, _("Failed to open service.  [%s]\n"),
-                        win_errstr(result));
+        result = open_service(b, mem_ctx, &hSCM, argv[0],
+                              SERVICE_ALL_ACCESS,
+                              &hService);
+        if (!W_ERROR_IS_OK(result) ) {
                 goto done;
         }
@@ -710 +786 @@
         /* Delete the Service */
 
-        status = rpccli_svcctl_DeleteService(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_DeleteService(b, mem_ctx,
                                              &hService,
                                              &result);
 
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
+                d_fprintf(stderr, _("Delete service request failed.  [%s]\n"),
+                        nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result)) {
                 d_fprintf(stderr, _("Delete service request failed.  [%s]\n"),
                         win_errstr(result));
@@ -724 +806 @@
  done:
         if (is_valid_policy_hnd(&hService)) {
-                rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
         }
         if (is_valid_policy_hnd(&hSCM)) {
-                rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
         }
 
@@ -737 +821 @@
 
 static NTSTATUS rpc_service_create_internal(struct net_context *c,
-                                            const DOM_SID *domain_sid,
+                                            const struct dom_sid *domain_sid,
                                             const char *domain_name,
                                             struct cli_state *cli,
@@ -751 +835 @@
         const char *DisplayName;
         const char *binary_path;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         if (argc != 3) {
@@ -758 +843 @@
         }
 
+        ZERO_STRUCT(hSCM);
+        ZERO_STRUCT(hService);
+
         /* Open the Service Control Manager */
-        status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,
-                                              pipe_hnd->srv_name_slash,
-                                              NULL,
-                                              SC_RIGHT_MGR_CREATE_SERVICE,
-                                              &hSCM,
-                                              &result);
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {
-                d_fprintf(stderr,
-                        _("Failed to open Service Control Manager.  [%s]\n"),
-                        win_errstr(result));
+        result = open_scm(b, mem_ctx, pipe_hnd->srv_name_slash,
+                          SC_RIGHT_MGR_CREATE_SERVICE,
+                          &hSCM);
+        if (!W_ERROR_IS_OK(result)) {
                 return werror_to_ntstatus(result);
         }
@@ -778 +860 @@
         binary_path = argv[2];
 
-        status = rpccli_svcctl_CreateServiceW(pipe_hnd, mem_ctx,
+        status = dcerpc_svcctl_CreateServiceW(b, mem_ctx,
                                               &hSCM,
                                               ServiceName,
@@ -796 +878 @@
                                               &hService,
                                               &result);
-
-        if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result) ) {
+        if (!NT_STATUS_IS_OK(status)) {
+                result = ntstatus_to_werror(status);
                 d_fprintf(stderr, _("Create service request failed.  [%s]\n"),
-                        win_errstr(result));
+                          nt_errstr(status));
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result)) {
+                d_fprintf(stderr, _("Create service request failed.  [%s]\n"),
+                          win_errstr(result));
                 goto done;
         }
@@ -807 +894 @@
  done:
         if (is_valid_policy_hnd(&hService)) {
-                rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hService, NULL);
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hService, &_result);
         }
         if (is_valid_policy_hnd(&hSCM)) {
-                rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);
+                WERROR _result;
+                dcerpc_svcctl_CloseServiceHandle(b, mem_ctx, &hSCM, &_result);
         }
 

vendor/current/source3/utils/net_rpc_sh_acct.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_samr.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "../libcli/security/security.h"
 
 /*
@@ -41 +43 @@
 {
         struct policy_handle connect_pol, domain_pol;
-        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         union samr_DomainInfo *info1 = NULL;
         union samr_DomainInfo *info3 = NULL;
         union samr_DomainInfo *info12 = NULL;
         int store;
+        struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
 
         ZERO_STRUCT(connect_pol);
@@ -52 +55 @@
         /* Get sam policy handle */
 
-        result = rpccli_samr_Connect2(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_Connect2(b, mem_ctx,
                                       pipe_hnd->desthost,
                                       MAXIMUM_ALLOWED_ACCESS,
-                                      &connect_pol);
+                                      &connect_pol,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
         }
@@ -62 +70 @@
         /* Get domain policy handle */
 
-        result = rpccli_samr_OpenDomain(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         &connect_pol,
                                         MAXIMUM_ALLOWED_ACCESS,
                                         ctx->domain_sid,
-                                        &domain_pol);
+                                        &domain_pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
-                goto done;
-        }
-
-        result = rpccli_samr_QueryDomainInfo(pipe_hnd, mem_ctx,
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                              &domain_pol,
                                              1,
-                                             &info1);
-
+                                             &info1,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("query_domain_info level 1 failed: %s\n"),
                           nt_errstr(result));
@@ -82 +99 @@
         }
 
-        result = rpccli_samr_QueryDomainInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                              &domain_pol,
                                              3,
-                                             &info3);
-
+                                             &info3,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("query_domain_info level 3 failed: %s\n"),
                           nt_errstr(result));
@@ -93 +114 @@
         }
 
-        result = rpccli_samr_QueryDomainInfo(pipe_hnd, mem_ctx,
+        status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                              &domain_pol,
                                              12,
-                                             &info12);
-
+                                             &info12,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 d_fprintf(stderr, _("query_domain_info level 12 failed: %s\n"),
                           nt_errstr(result));
@@ -114 +139 @@
         switch (store) {
         case 1:
-                result = rpccli_samr_SetDomainInfo(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    &domain_pol,
                                                    1,
-                                                   info1);
+                                                   info1,
+                                                   &result);
                 break;
         case 3:
-                result = rpccli_samr_SetDomainInfo(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    &domain_pol,
                                                    3,
-                                                   info3);
+                                                   info3,
+                                                   &result);
                 break;
         case 12:
-                result = rpccli_samr_SetDomainInfo(pipe_hnd, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    &domain_pol,
                                                    12,
-                                                   info12);
+                                                   info12,
+                                                   &result);
                 break;
         default:
                 d_fprintf(stderr, _("Got unexpected info level %d\n"), store);
-                result = NT_STATUS_INTERNAL_ERROR;
-                goto done;
-        }
+                status = NT_STATUS_INTERNAL_ERROR;
+                goto done;
+        }
+
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = result;
 
  done:
         if (is_valid_policy_hnd(&domain_pol)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &domain_pol);
+                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
         }
         if (is_valid_policy_hnd(&connect_pol)) {
-                rpccli_samr_Close(pipe_hnd, mem_ctx, &connect_pol);
-        }
-
-        return result;
+                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
+        }
+
+        return status;
 }
 

vendor/current/source3/utils/net_rpc_shell.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "popt_common.h"
 #include "utils/net.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_samr.h"
+#include "lib/netapi/netapi.h"
+#include "lib/netapi/netapi_net.h"
+#include "../libcli/smbreadline/smbreadline.h"
+#include "libsmb/libsmb.h"
 
 static NTSTATUS rpc_sh_info(struct net_context *c,
@@ -219 +226 @@
         }
 
-        if (libnetapi_init(&c->netapi_ctx) != 0) {
+        if (libnetapi_net_init(&c->netapi_ctx) != 0) {
                 return -1;
         }

vendor/current/source3/utils/net_sam.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "system/passwd.h"
 #include "utils/net.h"
+#include "../librpc/gen_ndr/samr.h"
+#include "smbldap.h"
+#include "../libcli/security/security.h"
+#include "lib/winbind_util.h"
+#include "passdb.h"
+#include "lib/privileges.h"
 
 /*
@@ -32 +39 @@
 {
         struct samu *sam_acct = NULL;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -135 +142 @@
 {
         struct samu *sam_acct = NULL;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -228 +235 @@
 {
         struct samu *sam_acct = NULL;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -294 +301 @@
 {
         GROUP_MAP map;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -631 +638 @@
 }
 
-extern PRIVS privs[];
-
 static int net_sam_rights_list(struct net_context *c, int argc,
                                const char **argv)
 {
-        SE_PRIV mask;
+        enum sec_privilege privilege;
 
         if (argc > 1 || c->display_usage) {
@@ -647 +652 @@
         if (argc == 0) {
                 int i;
-                int num = count_all_privileges();
+                int num = num_privileges_in_short_list();
 
                 for (i=0; i<num; i++) {
-                        d_printf("%s\n", privs[i].name);
+                        d_printf("%s\n", sec_privilege_name_from_index(i));
                 }
                 return 0;
         }
 
-        if (se_priv_from_name(argv[0], &mask)) {
-                DOM_SID *sids;
+        privilege = sec_privilege_id(argv[0]);
+
+        if (privilege != SEC_PRIV_INVALID) {
+                struct dom_sid *sids;
                 int i, num_sids;
                 NTSTATUS status;
 
-                status = privilege_enum_sids(&mask, talloc_tos(),
+                status = privilege_enum_sids(privilege, talloc_tos(),
                                              &sids, &num_sids);
                 if (!NT_STATUS_IS_OK(status)) {
@@ -689 +696 @@
                                 const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
-        SE_PRIV mask;
         int i;
 
@@ -709 +715 @@
 
         for (i=1; i < argc; i++) {
-                if (!se_priv_from_name(argv[i], &mask)) {
+                enum sec_privilege privilege = sec_privilege_id(argv[i]);
+                if (privilege == SEC_PRIV_INVALID) {
                         d_fprintf(stderr, _("%s unknown\n"), argv[i]);
                         return -1;
                 }
 
-                if (!grant_privilege(&sid, &mask)) {
+                if (!grant_privilege_by_name(&sid, argv[i])) {
                         d_fprintf(stderr, _("Could not grant privilege\n"));
                         return -1;
@@ -728 +735 @@
                                 const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
-        SE_PRIV mask;
         int i;
 
@@ -748 +754 @@
 
         for (i=1; i < argc; i++) {
-
-                if (!se_priv_from_name(argv[i], &mask)) {
+                enum sec_privilege privilege = sec_privilege_id(argv[i]);
+                if (privilege == SEC_PRIV_INVALID) {
                         d_fprintf(stderr, _("%s unknown\n"), argv[i]);
                         return -1;
                 }
 
-                if (!revoke_privilege(&sid, &mask)) {
+                if (!revoke_privilege_by_name(&sid, argv[i])) {
                         d_fprintf(stderr, _("Could not revoke privilege\n"));
                         return -1;
@@ -895 +901 @@
 static NTSTATUS unmap_unix_group(const struct group *grp, GROUP_MAP *pmap)
 {
-        NTSTATUS status;
         GROUP_MAP map;
         const char *grpname;
-        DOM_SID dom_sid;
+        struct dom_sid dom_sid;
 
         map.gid = grp->gr_gid;
@@ -915 +920 @@
         }
 
-        status = pdb_delete_group_mapping_entry(dom_sid);
-
-        return status;
+        return pdb_delete_group_mapping_entry(dom_sid);
 }
 
@@ -990 +993 @@
                                      const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         uint32_t rid;
         enum lsa_SidType type;
@@ -1071 +1074 @@
 static int net_sam_deletelocalgroup(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -1118 +1121 @@
         enum lsa_SidType type;
         fstring groupname;
-        DOM_SID sid;
+        struct dom_sid sid;
 
         if (argc != 1 || c->display_usage) {
@@ -1170 +1173 @@
 {
         const char *groupdomain, *groupname, *memberdomain, *membername;
-        DOM_SID group, member;
+        struct dom_sid group, member;
         enum lsa_SidType grouptype, membertype;
         NTSTATUS status;
@@ -1259 +1262 @@
         const char *memberdomain = NULL;
         const char *membername = NULL;
-        DOM_SID group, member;
+        struct dom_sid group, member;
         enum lsa_SidType grouptype;
         NTSTATUS status;
@@ -1331 +1334 @@
 {
         const char *groupdomain, *groupname;
-        DOM_SID group;
-        DOM_SID *members = NULL;
+        struct dom_sid group;
+        struct dom_sid *members = NULL;
         size_t i, num_members = 0;
         enum lsa_SidType grouptype;
@@ -1543 +1546 @@
 static int net_sam_show(struct net_context *c, int argc, const char **argv)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         const char *dom, *name;
@@ -1581 +1584 @@
         struct smbldap_state *ls;
         GROUP_MAP gmap;
-        DOM_SID gsid;
+        struct dom_sid gsid;
         gid_t domusers_gid = -1;
         gid_t domadmins_gid = -1;
         struct samu *samuser;
         struct passwd *pwd;
+        bool is_ipa = false;
 
         if (c->display_usage) {
@@ -1616 +1620 @@
         trim_char(ldap_bk, ' ', ' ');
 
-        if (strcmp(ldap_bk, "ldapsam") != 0) {
+        if (strcmp(ldap_bk, "IPA_ldapsam") == 0 ) {
+                is_ipa = true;
+        }
+
+        if (strcmp(ldap_bk, "ldapsam") != 0 && !is_ipa ) {
                 d_fprintf(stderr,
                           _("Provisioning works only with ldapsam backend\n"));
@@ -1630 +1638 @@
         }
 
-        if (!winbind_ping()) {
+        if (!is_ipa && !winbind_ping()) {
                 d_fprintf(stderr, _("winbind seems not to run. Provisioning "
                             "LDAP only works when winbind runs.\n"));
@@ -1643 +1651 @@
         d_printf(_("Checking for Domain Users group.\n"));
 
-        sid_compose(&gsid, get_global_sam_sid(), DOMAIN_GROUP_RID_USERS);
+        sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_USERS);
 
         if (!pdb_getgrsid(&gmap, gsid)) {
@@ -1657 +1665 @@
 
                 /* lets allocate a new groupid for this group */
-                if (!winbind_allocate_gid(&domusers_gid)) {
-                        d_fprintf(stderr, _("Unable to allocate a new gid to "
-                                            "create Domain Users group!\n"));
-                        goto domu_done;
+                if (is_ipa) {
+                        domusers_gid = 999;
+                } else {
+                        if (!winbind_allocate_gid(&domusers_gid)) {
+                                d_fprintf(stderr, _("Unable to allocate a new gid to "
+                                                    "create Domain Users group!\n"));
+                                goto domu_done;
+                        }
                 }
 
@@ -1676 +1688 @@
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
+                if (is_ipa) {
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
+                }
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);
@@ -1691 +1708 @@
                                             "to ldap directory\n"));
                 }
+
+                if (is_ipa) {
+                        if (!pdb_getgrsid(&gmap, gsid)) {
+                                d_fprintf(stderr, _("Failed to read just "
+                                                    "created domain group.\n"));
+                                goto failed;
+                        } else {
+                                domusers_gid = gmap.gid;
+                        }
+                }
         } else {
                 domusers_gid = gmap.gid;
@@ -1700 +1727 @@
         d_printf(_("Checking for Domain Admins group.\n"));
 
-        sid_compose(&gsid, get_global_sam_sid(), DOMAIN_GROUP_RID_ADMINS);
+        sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_ADMINS);
 
         if (!pdb_getgrsid(&gmap, gsid)) {
@@ -1714 +1741 @@
 
                 /* lets allocate a new groupid for this group */
-                if (!winbind_allocate_gid(&domadmins_gid)) {
-                        d_fprintf(stderr, _("Unable to allocate a new gid to "
-                                            "create Domain Admins group!\n"));
-                        goto doma_done;
+                if (is_ipa) {
+                        domadmins_gid = 999;
+                } else {
+                        if (!winbind_allocate_gid(&domadmins_gid)) {
+                                d_fprintf(stderr, _("Unable to allocate a new gid to "
+                                                    "create Domain Admins group!\n"));
+                                goto doma_done;
+                        }
                 }
 
@@ -1733 +1764 @@
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
+                if (is_ipa) {
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
+                }
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);
@@ -1748 +1784 @@
                                             "to ldap directory\n"));
                 }
+
+                if (is_ipa) {
+                        if (!pdb_getgrsid(&gmap, gsid)) {
+                                d_fprintf(stderr, _("Failed to read just "
+                                                    "created domain group.\n"));
+                                goto failed;
+                        } else {
+                                domadmins_gid = gmap.gid;
+                        }
+                }
         } else {
                 domadmins_gid = gmap.gid;
@@ -1765 +1811 @@
         if (!pdb_getsampwnam(samuser, "Administrator")) {
                 LDAPMod **mods = NULL;
-                DOM_SID sid;
+                struct dom_sid sid;
                 char *dn;
                 char *name;
@@ -1772 +1818 @@
                 char *shell;
                 char *dir;
+                char *princ;
                 uid_t uid;
                 int rc;
@@ -1783 +1830 @@
                         goto done;
                 }
-                if (!winbind_allocate_uid(&uid)) {
-                        d_fprintf(stderr,
-                                  _("Unable to allocate a new uid to create "
-                                    "the Administrator user!\n"));
-                        goto done;
-                }
+
+                if (is_ipa) {
+                        uid = 999;
+                } else {
+                        if (!winbind_allocate_uid(&uid)) {
+                                d_fprintf(stderr,
+                                          _("Unable to allocate a new uid to create "
+                                            "the Administrator user!\n"));
+                                goto done;
+                        }
+                }
+
                 name = talloc_strdup(tc, "Administrator");
                 dn = talloc_asprintf(tc, "uid=Administrator,%s", lp_ldap_user_suffix());
@@ -1807 +1860 @@
                 }
 
-                sid_compose(&sid, get_global_sam_sid(), DOMAIN_USER_RID_ADMIN);
+                sid_compose(&sid, get_global_sam_sid(), DOMAIN_RID_ADMINISTRATOR);
+
+                if (!winbind_allocate_uid(&uid)) {
+                        d_fprintf(stderr,
+                                  _("Unable to allocate a new uid to create "
+                                    "the Administrator user!\n"));
+                        goto done;
+                }
 
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_ACCOUNT);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXACCOUNT);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SAMBASAMACCOUNT);
+                if (is_ipa) {
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "person");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "organizationalperson");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetorgperson");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetuser");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbprincipalaux");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbticketpolicyaux");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "sn", name);
+                        princ = talloc_asprintf(tc, "%s@%s", name, lp_realm());
+                        if (!princ) {
+                                d_fprintf(stderr, _("Out of Memory!\n"));
+                                goto failed;
+                        }
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "krbPrincipalName", princ);
+                }
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uid", name);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", name);
@@ -1833 +1908 @@
                                             "to ldap directory\n"));
                 }
+
+                if (is_ipa) {
+                        if (!pdb_getsampwnam(samuser, "Administrator")) {
+                                d_fprintf(stderr, _("Failed to read just "
+                                                    "created user.\n"));
+                                goto failed;
+                        }
+                }
         } else {
                 d_printf(_("found!\n"));
@@ -1847 +1930 @@
         if (!pdb_getsampwnam(samuser, lp_guestaccount())) {
                 LDAPMod **mods = NULL;
-                DOM_SID sid;
+                struct dom_sid sid;
                 char *dn;
                 char *uidstr;
@@ -1854 +1937 @@
 
                 d_printf(_("Adding the Guest user.\n"));
+
+                sid_compose(&sid, get_global_sam_sid(), DOMAIN_RID_GUEST);
 
                 pwd = Get_Pwnam_alloc(tc, lp_guestaccount());
@@ -1869 +1954 @@
                         }
                         pwd->pw_name = talloc_strdup(pwd, lp_guestaccount());
-                        if (!winbind_allocate_uid(&(pwd->pw_uid))) {
-                                d_fprintf(stderr,
-                                          _("Unable to allocate a new uid to "
-                                            "create the Guest user!\n"));
-                                goto done;
+
+                        if (is_ipa) {
+                                pwd->pw_uid = 999;
+                        } else {
+                                if (!winbind_allocate_uid(&(pwd->pw_uid))) {
+                                        d_fprintf(stderr,
+                                                  _("Unable to allocate a new uid to "
+                                                    "create the Guest user!\n"));
+                                        goto done;
+                                }
                         }
                         pwd->pw_gid = domusers_gid;
@@ -1884 +1974 @@
                 }
 
-                sid_compose(&sid, get_global_sam_sid(), DOMAIN_USER_RID_GUEST);
-
                 dn = talloc_asprintf(tc, "uid=%s,%s", pwd->pw_name, lp_ldap_user_suffix ());
                 uidstr = talloc_asprintf(tc, "%u", (unsigned int)pwd->pw_uid);
@@ -1897 +1985 @@
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXACCOUNT);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SAMBASAMACCOUNT);
+                if (is_ipa) {
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "person");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "organizationalperson");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetorgperson");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "inetuser");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbprincipalaux");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "krbticketpolicyaux");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "sn", pwd->pw_name);
+                }
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "uid", pwd->pw_name);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", pwd->pw_name);
@@ -1922 +2019 @@
                                             "ldap directory\n"));
                 }
+
+                if (is_ipa) {
+                        if (!pdb_getsampwnam(samuser, lp_guestaccount())) {
+                                d_fprintf(stderr, _("Failed to read just "
+                                                    "created user.\n"));
+                                goto failed;
+                        }
+                }
         } else {
                 d_printf(_("found!\n"));
@@ -1928 +2033 @@
         d_printf(_("Checking Guest's group.\n"));
 
-        pwd = Get_Pwnam_alloc(talloc_autofree_context(), lp_guestaccount());
+        pwd = Get_Pwnam_alloc(tc, lp_guestaccount());
         if (!pwd) {
                 d_fprintf(stderr,
@@ -1963 +2068 @@
                 }
 
-                sid_compose(&gsid, get_global_sam_sid(), DOMAIN_GROUP_RID_GUESTS);
+                sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_GUESTS);
 
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_POSIXGROUP);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_GROUPMAP);
+                if (is_ipa) {
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "groupofnames");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "nestedgroup");
+                        smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", "ipausergroup");
+                }
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "cn", uname);
                 smbldap_set_mod(&mods, LDAP_MOD_ADD, "displayName", wname);

vendor/current/source3/utils/net_share.c

@@ -63 +63 @@
 int net_share(struct net_context *c, int argc, const char **argv)
 {
-
         if (argc > 0 && StrCaseCmp(argv[0], "HELP") == 0) {
-                net_share_usage(c, argc, argv);
-                return 0;
+                        net_share_usage(c, argc, argv);
+                        return 0;
         }
 

vendor/current/source3/utils/net_status.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "session.h"
+#include "messages.h"
 
 int net_status_usage(struct net_context *c, int argc, const char **argv)
@@ -29 +31 @@
 }
 
-static int show_session(struct db_record *rec, void *private_data)
+static int show_session(const char *key, struct sessionid *session,
+                        void *private_data)
 {
         bool *parseable = (bool *)private_data;
-        struct sessionid sessionid;
-
-        if (rec->value.dsize != sizeof(sessionid))
-                return 0;
-
-        memcpy(&sessionid, rec->value.dptr, sizeof(sessionid));
-
-        if (!process_exists(sessionid.pid)) {
+
+        if (!process_exists(session->pid)) {
                 return 0;
         }
@@ -45 +42 @@
         if (*parseable) {
                 d_printf("%s\\%s\\%s\\%s\\%s\n",
-                         procid_str_static(&sessionid.pid), uidtoname(sessionid.uid),
-                         gidtoname(sessionid.gid),
-                         sessionid.remote_machine, sessionid.hostname);
+                         procid_str_static(&session->pid),
+                         uidtoname(session->uid),
+                         gidtoname(session->gid),
+                         session->remote_machine, session->hostname);
         } else {
                 d_printf("%7s   %-12s  %-12s  %-12s (%s)\n",
-                         procid_str_static(&sessionid.pid), uidtoname(sessionid.uid),
-                         gidtoname(sessionid.gid),
-                         sessionid.remote_machine, sessionid.hostname);
+                         procid_str_static(&session->pid),
+                         uidtoname(session->uid),
+                         gidtoname(session->gid),
+                         session->remote_machine, session->hostname);
         }
 
@@ -60 +59 @@
 static int net_status_sessions(struct net_context *c, int argc, const char **argv)
 {
-        struct db_context *db;
         bool parseable;
 
@@ -89 +87 @@
         }
 
-        db = db_open(NULL, lock_path("sessionid.tdb"), 0,
-                     TDB_CLEAR_IF_FIRST, O_RDONLY, 0644);
-        if (db == NULL) {
-                d_fprintf(stderr, _("%s not initialised\n"),
-                          lock_path("sessionid.tdb"));
-                return -1;
-        }
-
-        db->traverse_read(db, show_session, &parseable);
-        TALLOC_FREE(db);
-
+        sessionid_traverse_read(show_session, &parseable);
         return 0;
 }
@@ -128 +116 @@
 };
 
-static int collect_pid(struct db_record *rec, void *private_data)
+static int collect_pids(const char *key, struct sessionid *session,
+                        void *private_data)
 {
         struct sessionids *ids = (struct sessionids *)private_data;
-        struct sessionid sessionid;
-
-        if (rec->value.dsize != sizeof(sessionid))
-                return 0;
-
-        memcpy(&sessionid, rec->value.dptr, sizeof(sessionid));
-
-        if (!process_exists(sessionid.pid))
+
+        if (!process_exists(session->pid))
                 return 0;
 
@@ -147 +130 @@
                 return 0;
         }
-        ids->entries[ids->num_entries-1] = sessionid;
-
-        return 0;
-}
-
-static int show_share_parseable(struct db_record *rec,
-                                const struct connections_key *key,
+        ids->entries[ids->num_entries-1] = *session;
+
+        return 0;
+}
+
+static int show_share_parseable(const struct connections_key *key,
                                 const struct connections_data *crec,
                                 void *state)
@@ -190 +172 @@
 {
         struct sessionids ids;
-        struct db_context *db;
 
         ids.num_entries = 0;
         ids.entries = NULL;
 
-        db = db_open(NULL, lock_path("sessionid.tdb"), 0,
-                     TDB_CLEAR_IF_FIRST, O_RDONLY, 0644);
-        if (db == NULL) {
-                d_fprintf(stderr, _("%s not initialised\n"),
-                          lock_path("sessionid.tdb"));
-                return -1;
-        }
-
-        db->traverse_read(db, collect_pid, &ids);
-        TALLOC_FREE(db);
-
-        connections_forall(show_share_parseable, &ids);
+        sessionid_traverse_read(collect_pids, &ids);
+
+        connections_forall_read(show_share_parseable, &ids);
 
         SAFE_FREE(ids.entries);

vendor/current/source3/utils/net_time.c

@@ -19 +19 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "libsmb/nmblib.h"
+#include "libsmb/libsmb.h"
 
 /*
@@ -104 +106 @@
 }
 
-/* try to set the system clock using /bin/date */
+/* try to set the system clock */
 static int net_time_set(struct net_context *c, int argc, const char **argv)
 {
-        time_t t = nettime(c, NULL);
-        char *cmd;
+        struct timeval tv;
         int result;
 
-        if (t == 0) return -1;
-
-        /* yes, I know this is cheesy. Use "net time system" if you want to
-           roll your own. I'm putting this in as it works on a large number
-           of systems and the user has a choice in whether its used or not */
-        if (asprintf(&cmd, "/bin/date %s", systime(t)) == -1) {
-                return -1;
-        }
-        result = system(cmd);
+        tv.tv_sec = nettime(c, NULL);
+        tv.tv_usec=0;
+
+        if (tv.tv_sec == 0) return -1;
+
+        result = settimeofday(&tv,NULL);
+
         if (result)
-                d_fprintf(stderr, _("%s failed.  Error was (%s)\n"),
-                        cmd, strerror(errno));
-        free(cmd);
+                d_fprintf(stderr, _("setting system clock failed.  Error was (%s)\n"),
+                        strerror(errno));
 
         return result;

vendor/current/source3/utils/net_usershare.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "system/passwd.h"
+#include "system/filesys.h"
 #include "utils/net.h"
+#include "../libcli/security/security.h"
 
 struct {
@@ -38 +41 @@
         {N_("Path is not a directory"), USERSHARE_PATH_NOT_DIRECTORY},
         {N_("System error"), USERSHARE_POSIX_ERR},
+        {N_("Malformed sharename definition"), USERSHARE_MALFORMED_SHARENAME_DEF},
+        {N_("Bad sharename (doesn't match filename)"), USERSHARE_BAD_SHARENAME},
         {NULL,(enum usershare_err)-1}
 };
@@ -329 +334 @@
         int fd = -1;
         int numlines = 0;
-        SEC_DESC *psd = NULL;
+        struct security_descriptor *psd = NULL;
         char *basepath;
         char *sharepath = NULL;
         char *comment = NULL;
+        char *cp_sharename = NULL;
         char *acl_str;
         int num_aces;
@@ -393 +399 @@
                                 &sharepath,
                                 &comment,
+                                &cp_sharename,
                                 &psd,
                                 &guest_ok);
@@ -474 +481 @@
         /* NOTE: This is smb.conf-like output. Do not translate. */
         if (pi->op == US_INFO_OP) {
-                d_printf("[%s]\n", fl->pathname );
+                d_printf("[%s]\n", cp_sharename );
                 d_printf("path=%s\n", sharepath );
                 d_printf("comment=%s\n", comment);
@@ -480 +487 @@
                 d_printf("guest_ok=%c\n\n", guest_ok ? 'y' : 'n');
         } else if (pi->op == US_LIST_OP) {
-                d_printf("%s\n", fl->pathname);
+                d_printf("%s\n", cp_sharename);
         }
 
@@ -618 +625 @@
         SMB_STRUCT_STAT lsbuf;
         char *sharename;
+        const char *cp_sharename;
         char *full_path;
         char *full_path_tmp;
@@ -646 +654 @@
                         return net_usershare_add_usage(c, argc, argv);
                 case 2:
+                        cp_sharename = argv[0];
                         sharename = strlower_talloc(ctx, argv[0]);
                         us_path = argv[1];
                         break;
                 case 3:
+                        cp_sharename = argv[0];
                         sharename = strlower_talloc(ctx, argv[0]);
                         us_path = argv[1];
@@ -655 +665 @@
                         break;
                 case 4:
+                        cp_sharename = argv[0];
                         sharename = strlower_talloc(ctx, argv[0]);
                         us_path = argv[1];
@@ -661 +672 @@
                         break;
                 case 5:
+                        cp_sharename = argv[0];
                         sharename = strlower_talloc(ctx, argv[0]);
                         us_path = argv[1];
@@ -798 +810 @@
 
         for (i = 0; i < num_aces; i++) {
-                DOM_SID sid;
+                struct dom_sid sid;
                 const char *pcolon = strchr_m(pacl, ':');
                 const char *name;
@@ -898 +910 @@
                           full_path_tmp );
                 TALLOC_FREE(ctx);
+                close(tmpfd);
                 return -1;
         }
@@ -907 +920 @@
                           full_path_tmp );
                 TALLOC_FREE(ctx);
+                close(tmpfd);
                 return -1;
         }
@@ -916 +930 @@
                           full_path_tmp );
                 TALLOC_FREE(ctx);
+                close(tmpfd);
                 return -1;
         }
@@ -925 +940 @@
                           full_path_tmp );
                 TALLOC_FREE(ctx);
+                close(tmpfd);
                 return -1;
         }
@@ -930 +946 @@
         /* Create the in-memory image of the file. */
         file_img = talloc_strdup(ctx, "#VERSION 2\npath=");
-        file_img = talloc_asprintf_append(file_img, "%s\ncomment=%s\nusershare_acl=%s\nguest_ok=%c\n",
-                        us_path, us_comment, us_acl, guest_ok ? 'y' : 'n');
+        file_img = talloc_asprintf_append(file_img,
+                        "%s\ncomment=%s\nusershare_acl=%s\n"
+                        "guest_ok=%c\nsharename=%s\n",
+                        us_path,
+                        us_comment,
+                        us_acl,
+                        guest_ok ? 'y' : 'n',
+                        cp_sharename);
 
         to_write = strlen(file_img);
@@ -942 +964 @@
                 unlink(full_path_tmp);
                 TALLOC_FREE(ctx);
+                close(tmpfd);
                 return -1;
         }

vendor/current/source3/utils/net_util.c

@@ -22 +22 @@
 #include "includes.h"
 #include "utils/net.h"
-#include "../librpc/gen_ndr/cli_lsa.h"
-#include "../librpc/gen_ndr/cli_dssetup.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "../librpc/gen_ndr/ndr_dssetup_c.h"
+#include "secrets.h"
+#include "../libcli/security/security.h"
+#include "libsmb/libsmb.h"
 
 NTSTATUS net_rpc_lookup_name(struct net_context *c,
                              TALLOC_CTX *mem_ctx, struct cli_state *cli,
                              const char *name, const char **ret_domain,
-                             const char **ret_name, DOM_SID *ret_sid,
+                             const char **ret_name, struct dom_sid *ret_sid,
                              enum lsa_SidType *ret_type)
 {
         struct rpc_pipe_client *lsa_pipe = NULL;
         struct policy_handle pol;
-        NTSTATUS result = NT_STATUS_OK;
+        NTSTATUS status, result;
         const char **dom_names;
-        DOM_SID *sids;
+        struct dom_sid *sids;
         enum lsa_SidType *types;
+        struct dcerpc_binding_handle *b;
 
         ZERO_STRUCT(pol);
 
-        result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
                                           &lsa_pipe);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, _("Could not initialise lsa pipe\n"));
-                return result;
-        }
-
-        result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, false,
+                return status;
+        }
+
+        b = lsa_pipe->binding_handle;
+
+        status = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, false,
                                         SEC_FLAG_MAXIMUM_ALLOWED,
                                         &pol);
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 d_fprintf(stderr, "open_policy %s: %s\n", _("failed"),
-                          nt_errstr(result));
-                return result;
-        }
-
-        result = rpccli_lsa_lookup_names(lsa_pipe, mem_ctx, &pol, 1,
+                          nt_errstr(status));
+                return status;
+        }
+
+        status = rpccli_lsa_lookup_names(lsa_pipe, mem_ctx, &pol, 1,
                                          &name, &dom_names, 1, &sids, &types);
 
-        if (!NT_STATUS_IS_OK(result)) {
+        if (!NT_STATUS_IS_OK(status)) {
                 /* This can happen easily, don't log an error */
                 goto done;
@@ -79 +87 @@
  done:
         if (is_valid_policy_hnd(&pol)) {
-                rpccli_lsa_Close(lsa_pipe, mem_ctx, &pol);
+                dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
         }
         TALLOC_FREE(lsa_pipe);
 
-        return result;
+        return status;
 }
 
@@ -118 +126 @@
                                         service_name, service_type,
                                         c->opt_user_name, c->opt_workgroup,
-                                        c->opt_password, flags, Undefined, NULL);
+                                        c->opt_password, flags, Undefined);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 d_fprintf(stderr, _("Could not connect to server %s\n"),
@@ -202 +210 @@
                                         "IPC$", "IPC",
                                         "", "",
-                                        "", 0, Undefined, NULL);
+                                        "", 0, Undefined);
 
         if (NT_STATUS_IS_OK(nt_status)) {
@@ -262 +270 @@
                                         c->opt_password,
                                         CLI_FULL_CONNECTION_USE_KERBEROS,
-                                        Undefined, NULL);
+                                        Undefined);
 
         SAFE_FREE(user_and_realm);
@@ -416 +424 @@
                 }
 
-                if (is_zero_addr((struct sockaddr *)&pdc_ss)) {
+                if (is_zero_addr(&pdc_ss)) {
                         return false;
                 }
@@ -473 +481 @@
                 return false;
         }
-        if (is_zero_addr((struct sockaddr *)server_ss)) {
+        if (is_zero_addr(server_ss)) {
                 return false;
         }
@@ -619 +627 @@
 }
 
+static NTSTATUS net_scan_dc_noad(struct net_context *c,
+                                 struct cli_state *cli,
+                                 struct net_dc_info *dc_info)
+{
+        TALLOC_CTX *mem_ctx = talloc_tos();
+        struct rpc_pipe_client *pipe_hnd = NULL;
+        struct dcerpc_binding_handle *b;
+        NTSTATUS status, result;
+        struct policy_handle pol;
+        union lsa_PolicyInformation *info;
+
+        ZERO_STRUCTP(dc_info);
+        ZERO_STRUCT(pol);
+
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+                                          &pipe_hnd);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        b = pipe_hnd->binding_handle;
+
+        status = dcerpc_lsa_open_policy(b, mem_ctx,
+                                        false,
+                                        SEC_FLAG_MAXIMUM_ALLOWED,
+                                        &pol,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+
+        status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
+                                            &pol,
+                                            LSA_POLICY_INFO_ACCOUNT_DOMAIN,
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+
+        dc_info->netbios_domain_name = talloc_strdup(mem_ctx, info->account_domain.name.string);
+        if (dc_info->netbios_domain_name == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+ done:
+        if (is_valid_policy_hnd(&pol)) {
+                dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
+        }
+
+        TALLOC_FREE(pipe_hnd);
+
+        return status;
+}
+
 NTSTATUS net_scan_dc(struct net_context *c,
                      struct cli_state *cli,
@@ -625 +697 @@
         TALLOC_CTX *mem_ctx = talloc_tos();
         struct rpc_pipe_client *dssetup_pipe = NULL;
+        struct dcerpc_binding_handle *dssetup_handle = NULL;
         union dssetup_DsRoleInfo info;
         NTSTATUS status;
+        WERROR werr;
 
         ZERO_STRUCTP(dc_info);
@@ -633 +707 @@
                                           &dssetup_pipe);
         if (!NT_STATUS_IS_OK(status)) {
-                return status;
-        }
-
-        status = rpccli_dssetup_DsRoleGetPrimaryDomainInformation(dssetup_pipe, mem_ctx,
+                DEBUG(10,("net_scan_dc: failed to open dssetup pipe with %s, "
+                        "retrying with lsa pipe\n", nt_errstr(status)));
+                return net_scan_dc_noad(c, cli, dc_info);
+        }
+        dssetup_handle = dssetup_pipe->binding_handle;
+
+        status = dcerpc_dssetup_DsRoleGetPrimaryDomainInformation(dssetup_handle, mem_ctx,
                                                                   DS_ROLE_BASIC_INFORMATION,
                                                                   &info,
-                                                                  NULL);
+                                                                  &werr);
         TALLOC_FREE(dssetup_pipe);
 
+        if (NT_STATUS_IS_OK(status)) {
+                status = werror_to_ntstatus(werr);
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 return status;

vendor/current/source3/utils/netlookup.c

@@ -22 +22 @@
 #include "includes.h"
 #include "utils/net.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_lsa.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "libsmb/libsmb.h"
 
 /********************************************************
@@ -108 +112 @@
 #endif
                                         0,
-                                        Undefined,
-                                        NULL);
+                                        Undefined);
 
         if (!NT_STATUS_IS_OK(nt_status)) {
@@ -156 +159 @@
 NTSTATUS net_lookup_name_from_sid(struct net_context *c,
                                 TALLOC_CTX *ctx,
-                                DOM_SID *psid,
+                                struct dom_sid *psid,
                                 const char **ppdomain,
                                 const char **ppname)
@@ -198 +201 @@
 
 NTSTATUS net_lookup_sid_from_name(struct net_context *c, TALLOC_CTX *ctx,
-                                  const char *full_name, DOM_SID *pret_sid)
+                                  const char *full_name, struct dom_sid *pret_sid)
 {
         NTSTATUS nt_status;
         struct con_struct *csp = NULL;
-        DOM_SID *sids = NULL;
+        struct dom_sid *sids = NULL;
         enum lsa_SidType *types = NULL;
 

vendor/current/source3/utils/nmblookup.c

@@ -21 +21 @@
 
 #include "includes.h"
-
-extern bool AllowDebugChange;
+#include "popt_common.h"
+#include "libsmb/nmblib.h"
 
 static bool give_flags = false;
@@ -108 +108 @@
 ****************************************************************************/
 
-static void do_node_status(int fd,
-                const char *name,
+static void do_node_status(const char *name,
                 int type,
                 struct sockaddr_storage *pss)
@@ -115 +114 @@
         struct nmb_name nname;
         int count, i, j;
-        NODE_STATUS_STRUCT *status;
+        struct node_status *addrs;
         struct node_status_extra extra;
         fstring cleanname;
         char addr[INET6_ADDRSTRLEN];
+        NTSTATUS status;
 
         print_sockaddr(addr, sizeof(addr), pss);
         d_printf("Looking up status of %s\n",addr);
         make_nmb_name(&nname, name, type);
-        status = node_status_query(fd, &nname, pss, &count, &extra);
-        if (status) {
+        status = node_status_query(talloc_tos(), &nname, pss,
+                                   &addrs, &count, &extra);
+        if (NT_STATUS_IS_OK(status)) {
                 for (i=0;i<count;i++) {
-                        pull_ascii_fstring(cleanname, status[i].name);
+                        pull_ascii_fstring(cleanname, addrs[i].name);
                         for (j=0;cleanname[j];j++) {
                                 if (!isprint((int)cleanname[j])) {
@@ -133 +134 @@
                         }
                         d_printf("\t%-15s <%02x> - %s\n",
-                               cleanname,status[i].type,
-                               node_status_flags(status[i].flags));
+                               cleanname,addrs[i].type,
+                               node_status_flags(addrs[i].flags));
                 }
                 d_printf("\n\tMAC Address = %02X-%02X-%02X-%02X-%02X-%02X\n",
@@ -141 +142 @@
                                 extra.mac_addr[4], extra.mac_addr[5]);
                 d_printf("\n");
-                SAFE_FREE(status);
+                TALLOC_FREE(addrs);
         } else {
                 d_printf("No reply from %s\n\n",addr);
@@ -154 +155 @@
 static bool query_one(const char *lookup, unsigned int lookup_type)
 {
-        int j, count, flags = 0;
+        int j, count;
+        uint8_t flags;
         struct sockaddr_storage *ip_list=NULL;
+        NTSTATUS status = NT_STATUS_NOT_FOUND;
 
         if (got_bcast) {
@@ -161 +164 @@
                 print_sockaddr(addr, sizeof(addr), &bcast_addr);
                 d_printf("querying %s on %s\n", lookup, addr);
-                ip_list = name_query(ServerFD,lookup,lookup_type,use_bcast,
-                                     use_bcast?true:recursion_desired,
-                                     &bcast_addr, &count, &flags, NULL);
+                status = name_query(lookup,lookup_type,use_bcast,
+                                    use_bcast?true:recursion_desired,
+                                    &bcast_addr, talloc_tos(),
+                                    &ip_list, &count, &flags);
         } else {
                 const struct in_addr *bcast;
@@ -180 +184 @@
                         d_printf("querying %s on %s\n",
                                lookup, addr);
-                        ip_list = name_query(ServerFD,lookup,lookup_type,
-                                             use_bcast,
-                                             use_bcast?True:recursion_desired,
-                                             &bcast_ss,&count, &flags, NULL);
-                }
-        }
-
-        if (!ip_list) {
+                        status = name_query(lookup,lookup_type,
+                                            use_bcast,
+                                            use_bcast?True:recursion_desired,
+                                            &bcast_ss, talloc_tos(),
+                                            &ip_list, &count, &flags);
+                }
+        }
+
+        if (!NT_STATUS_IS_OK(status)) {
                 return false;
         }
@@ -215 +220 @@
                  */
                 if (find_status) {
-                        do_node_status(ServerFD, lookup,
-                                        lookup_type, &ip_list[j]);
-                }
-        }
-
-        free(ip_list);
-
-        return (ip_list != NULL);
+                        do_node_status(lookup, lookup_type, &ip_list[j]);
+                }
+        }
+
+        TALLOC_FREE(ip_list);
+
+        return NT_STATUS_IS_OK(status);
 }
 
@@ -259 +263 @@
         load_case_tables();
 
-        setup_logging(argv[0],True);
+        setup_logging(argv[0], DEBUG_STDOUT);
 
         pc = poptGetContext("nmblookup", argc, (const char **)argv,
@@ -336 +340 @@
                         in_addr_to_sockaddr_storage(&ss, ip);
                         fstrcpy(lookup,"*");
-                        do_node_status(ServerFD, lookup, lookup_type, &ss);
+                        do_node_status(lookup, lookup_type, &ss);
                         continue;
                 }

vendor/current/source3/utils/ntlm_auth.c

@@ -25 +25 @@
 
 #include "includes.h"
+#include "popt_common.h"
 #include "utils/ntlm_auth.h"
 #include "../libcli/auth/libcli_auth.h"
 #include "../libcli/auth/spnego.h"
+#include "../libcli/auth/ntlmssp.h"
 #include "smb_krb5.h"
 #include <iniparser.h>
+#include "../lib/crypto/arcfour.h"
+#include "libads/kerberos_proto.h"
+#include "nsswitch/winbind_client.h"
+#include "librpc/gen_ndr/krb5pac.h"
+#include "../lib/util/asn1.h"
 
 #ifndef PAM_WINBIND_CONFIG_FILE
@@ -225 +232 @@
         if (opt_challenge.length)
                 return opt_challenge;
-        
+
         chal = data_blob(NULL, 8);
 
@@ -244 +251 @@
                 return False;
         }
-        
+
         fstrcpy(user, p+1);
         fstrcpy(domain, domuser);
@@ -302 +309 @@
         int ctrl = 0;
         dictionary *d = NULL;
-        
+
         if (!opt_pam_winbind_conf || !*opt_pam_winbind_conf) {
                 opt_pam_winbind_conf = PAM_WINBIND_CONFIG_FILE;
@@ -308 +315 @@
 
         d = iniparser_load(CONST_DISCARD(char *, opt_pam_winbind_conf));
-        
+
         if (!d) {
                 return 0;
         }
-        
+
         if (iniparser_getboolean(d, CONST_DISCARD(char *, "global:krb5_auth"), false)) {
                 ctrl |= WINBIND_KRB5_AUTH;
@@ -318 +325 @@
 
         iniparser_freedict(d);
-        
+
         return ctrl;
 }
@@ -440 +447 @@
                 request.data.auth_crap.nt_resp_len = nt_response->length;
         }
-        
+
         result = winbindd_request_response(WINBINDD_PAM_AUTH_CRAP, &request, &response);
         SAFE_FREE(request.extra_data.data);
@@ -453 +460 @@
                 return nt_status;
         }
-        
+
         nt_status = (NT_STATUS(response.data.auth.nt_status));
         if (!NT_STATUS_IS_OK(nt_status)) {
@@ -535 +542 @@
                 request.data.chng_pswd_auth_crap.old_lm_hash_enc_len = old_lm_hash_enc.length;
         }
-        
+
         result = winbindd_request_response(WINBINDD_PAM_CHNG_PSWD_AUTH_CRAP, &request, &response);
 
@@ -548 +555 @@
                 return nt_status;
         }
-        
+
         nt_status = (NT_STATUS(response.data.auth.nt_status));
         if (!NT_STATUS_IS_OK(nt_status))
@@ -559 +566 @@
 
         winbindd_free_response(&response);
-        
+
     return nt_status;
 }
 
-static NTSTATUS winbind_pw_check(struct ntlmssp_state *ntlmssp_state, DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key) 
+static NTSTATUS winbind_pw_check(struct ntlmssp_state *ntlmssp_state, TALLOC_CTX *mem_ctx,
+                                 DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
 {
         static const char zeros[16] = { 0, };
@@ -573 +581 @@
 
         nt_status = contact_winbind_auth_crap(ntlmssp_state->user, ntlmssp_state->domain,
-                                              ntlmssp_state->workstation,
+                                              ntlmssp_state->client.netbios_name,
                                               &ntlmssp_state->chal,
                                               &ntlmssp_state->lm_resp,
@@ -583 +591 @@
         if (NT_STATUS_IS_OK(nt_status)) {
                 if (memcmp(lm_key, zeros, 8) != 0) {
-                        *lm_session_key = data_blob_talloc(ntlmssp_state, NULL, 16);
+                        *lm_session_key = data_blob_talloc(mem_ctx, NULL, 16);
                         memcpy(lm_session_key->data, lm_key, 8);
                         memset(lm_session_key->data+8, '\0', 8);
                 }
-                
+
                 if (memcmp(user_sess_key, zeros, 16) != 0) {
-                        *user_session_key = data_blob_talloc(ntlmssp_state, user_sess_key, 16);
-                }
-                ntlmssp_state->auth_context = talloc_strdup(ntlmssp_state,
-                                                            unix_name);
+                        *user_session_key = data_blob_talloc(mem_ctx, user_sess_key, 16);
+                }
+                ntlmssp_state->callback_private = talloc_strdup(ntlmssp_state,
+                                                                unix_name);
         } else {
                 DEBUG(NT_STATUS_EQUAL(nt_status, NT_STATUS_ACCESS_DENIED) ? 0 : 3, 
                       ("Login for user [%s]\\[%s]@[%s] failed due to [%s]\n", 
                        ntlmssp_state->domain, ntlmssp_state->user, 
-                       ntlmssp_state->workstation, 
+                       ntlmssp_state->client.netbios_name,
                        error_string ? error_string : "unknown error (NULL)"));
-                ntlmssp_state->auth_context = NULL;
+                ntlmssp_state->callback_private = NULL;
         }
 
@@ -607 +615 @@
 }
 
-static NTSTATUS local_pw_check(struct ntlmssp_state *ntlmssp_state, DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key) 
+static NTSTATUS local_pw_check(struct ntlmssp_state *ntlmssp_state, TALLOC_CTX *mem_ctx,
+                               DATA_BLOB *user_session_key, DATA_BLOB *lm_session_key)
 {
         NTSTATUS nt_status;
@@ -613 +622 @@
 
         nt_lm_owf_gen (opt_password, nt_pw.hash, lm_pw.hash);
-        
-        nt_status = ntlm_password_check(ntlmssp_state,
+
+        nt_status = ntlm_password_check(mem_ctx,
                                         true, true, 0,
                                         &ntlmssp_state->chal,
@@ -623 +632 @@
                                         ntlmssp_state->domain,
                                         &lm_pw, &nt_pw, user_session_key, lm_session_key);
-        
+
         if (NT_STATUS_IS_OK(nt_status)) {
-                ntlmssp_state->auth_context = talloc_asprintf(ntlmssp_state,
+                ntlmssp_state->callback_private = talloc_asprintf(ntlmssp_state,
                                                               "%s%c%s", ntlmssp_state->domain, 
                                                               *lp_winbind_separator(), 
@@ -631 +640 @@
         } else {
                 DEBUG(3, ("Login for user [%s]\\[%s]@[%s] failed due to [%s]\n", 
-                          ntlmssp_state->domain, ntlmssp_state->user, ntlmssp_state->workstation, 
+                          ntlmssp_state->domain, ntlmssp_state->user,
+                          ntlmssp_state->client.netbios_name,
                           nt_errstr(nt_status)));
-                ntlmssp_state->auth_context = NULL;
+                ntlmssp_state->callback_private = NULL;
         }
         return nt_status;
 }
 
-static NTSTATUS ntlm_auth_start_ntlmssp_client(NTLMSSP_STATE **client_ntlmssp_state) 
+static NTSTATUS ntlm_auth_start_ntlmssp_client(struct ntlmssp_state **client_ntlmssp_state)
 {
         NTSTATUS status;
@@ -647 +657 @@
         }
 
-        status = ntlmssp_client_start(client_ntlmssp_state);
+        status = ntlmssp_client_start(NULL,
+                                      global_myname(),
+                                      lp_workgroup(),
+                                      lp_client_ntlmv2_auth(),
+                                      client_ntlmssp_state);
 
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("Could not start NTLMSSP client: %s\n",
                           nt_errstr(status)));
-                ntlmssp_end(client_ntlmssp_state);
+                TALLOC_FREE(*client_ntlmssp_state);
                 return status;
         }
@@ -661 +675 @@
                 DEBUG(1, ("Could not set username: %s\n",
                           nt_errstr(status)));
-                ntlmssp_end(client_ntlmssp_state);
+                TALLOC_FREE(*client_ntlmssp_state);
                 return status;
         }
@@ -670 +684 @@
                 DEBUG(1, ("Could not set domain: %s\n",
                           nt_errstr(status)));
-                ntlmssp_end(client_ntlmssp_state);
+                TALLOC_FREE(*client_ntlmssp_state);
                 return status;
         }
@@ -676 +690 @@
         if (opt_password) {
                 status = ntlmssp_set_password(*client_ntlmssp_state, opt_password);
-        
+
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(1, ("Could not set password: %s\n",
                                   nt_errstr(status)));
-                        ntlmssp_end(client_ntlmssp_state);
+                        TALLOC_FREE(*client_ntlmssp_state);
                         return status;
                 }
@@ -688 +702 @@
 }
 
-static NTSTATUS ntlm_auth_start_ntlmssp_server(NTLMSSP_STATE **ntlmssp_state) 
-{
-        NTSTATUS status = ntlmssp_server_start(ntlmssp_state);
-        
+static NTSTATUS ntlm_auth_start_ntlmssp_server(struct ntlmssp_state **ntlmssp_state)
+{
+        NTSTATUS status;
+        const char *netbios_name;
+        const char *netbios_domain;
+        const char *dns_name;
+        char *dns_domain;
+        bool is_standalone = false;
+
+        if (opt_password) {
+                netbios_name = global_myname();
+                netbios_domain = lp_workgroup();
+        } else {
+                netbios_name = get_winbind_netbios_name();
+                netbios_domain = get_winbind_domain();
+        }
+        /* This should be a 'netbios domain -> DNS domain' mapping */
+        dns_domain = get_mydnsdomname(talloc_tos());
+        if (dns_domain) {
+                strlower_m(dns_domain);
+        }
+        dns_name = get_mydnsfullname();
+
+        status = ntlmssp_server_start(NULL,
+                                      is_standalone,
+                                      netbios_name,
+                                      netbios_domain,
+                                      dns_name,
+                                      dns_domain,
+                                      ntlmssp_state);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("Could not start NTLMSSP server: %s\n",
@@ -701 +741 @@
         if (opt_password) {
                 (*ntlmssp_state)->check_password = local_pw_check;
-                (*ntlmssp_state)->get_domain = lp_workgroup;
-                (*ntlmssp_state)->get_global_myname = global_myname;
         } else {
                 (*ntlmssp_state)->check_password = winbind_pw_check;
-                (*ntlmssp_state)->get_domain = get_winbind_domain;
-                (*ntlmssp_state)->get_global_myname = get_winbind_netbios_name;
         }
         return NT_STATUS_OK;
@@ -733 +769 @@
          * ntlm_ccache_auth, it will fail. So, we have to ask the trusted
          * domain's child for ccache_ntlm_auth. that is to say, we have to 
-         * set WBFALG_PAM_CONTACT_TRUSTDOM in request.flags.
+         * set WBFLAG_PAM_CONTACT_TRUSTDOM in request.flags.
          */
         ctrl = get_pam_winbind_config();
@@ -829 +865 @@
 
         if (strncmp(buf, "YR", 2) == 0) {
-                if (state->ntlmssp_state)
-                        ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
                 state->svr_state = SERVER_INITIAL;
         } else if (strncmp(buf, "KK", 2) == 0) {
@@ -896 +931 @@
                 DEBUG(0, ("NTLMSSP BH: %s\n", nt_errstr(nt_status)));
 
-                ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
         } else if (!NT_STATUS_IS_OK(nt_status)) {
                 *response = talloc_asprintf(mem_ctx, "NA %s",
@@ -904 +939 @@
                 *response = talloc_asprintf(
                         mem_ctx, "AF %s",
-                        (char *)state->ntlmssp_state->auth_context);
+                        (char *)state->ntlmssp_state->callback_private);
                 DEBUG(10, ("NTLMSSP OK!\n"));
 
@@ -1007 +1042 @@
 
         if (strncmp(buf, "YR", 2) == 0) {
-                if (state->ntlmssp_state)
-                        ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
                 state->cli_state = CLIENT_INITIAL;
         } else if (strncmp(buf, "TT", 2) == 0) {
@@ -1099 +1133 @@
                 DEBUG(10, ("NTLMSSP OK!\n"));
                 state->cli_state = CLIENT_FINISHED;
-                if (state->ntlmssp_state)
-                        ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
         } else {
                 x_fprintf(x_stdout, "BH %s\n", nt_errstr(nt_status));
                 DEBUG(0, ("NTLMSSP BH: %s\n", nt_errstr(nt_status)));
                 state->cli_state = CLIENT_ERROR;
-                if (state->ntlmssp_state)
-                        ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
         }
 
@@ -1117 +1149 @@
         char *user, *pass;      
         user=buf;
-        
+
         pass=(char *)memchr(buf,' ',length);
         if (!pass) {
@@ -1126 +1158 @@
         *pass='\0';
         pass++;
-        
+
         if (state->helper_mode == SQUID_2_5_BASIC) {
                 rfc1738_unescape(user);
                 rfc1738_unescape(pass);
         }
-        
+
         if (check_plaintext_auth(user, pass, False)) {
                 x_fprintf(x_stdout, "OK\n");
@@ -1197 +1229 @@
 }
 
-static bool _spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
+bool spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
 {
         bool ret;
@@ -1262 +1294 @@
 
         if (strncmp(buf, "YR", 2) == 0) {
-                if (state->ntlmssp_state)
-                        ntlmssp_end(&state->ntlmssp_state);
+                TALLOC_FREE(state->ntlmssp_state);
                 TALLOC_FREE(state->spnego_mech);
                 TALLOC_FREE(state->spnego_mech_oid);
@@ -1396 +1427 @@
                                                     "NTLMSSP challenge, but "
                                                     "already got one\n");
-                                ntlmssp_end(&state->ntlmssp_state);
+                                TALLOC_FREE(state->ntlmssp_state);
                                 return;
                         }
@@ -1473 +1504 @@
                 }
                 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
-                        ntlmssp_end(&state->ntlmssp_state);
+                        TALLOC_FREE(state->ntlmssp_state);
                 }
 #ifdef HAVE_KRB5
@@ -1480 +1511 @@
                 DATA_BLOB ap_rep;
                 DATA_BLOB session_key;
-                struct PAC_DATA *pac_data = NULL;
+                struct PAC_LOGON_INFO *logon_info = NULL;
                 DATA_BLOB ticket;
                 uint8_t tok_id[2];
 
-                if (!_spnego_parse_krb5_wrap(ctx, raw_in_token,
-                                             &ticket, tok_id)) {
+                if (!spnego_parse_krb5_wrap(ctx, raw_in_token,
+                                            &ticket, tok_id)) {
                         DEBUG(1, ("spnego_parse_krb5_wrap failed\n"));
                         x_fprintf(x_stdout, "BH spnego_parse_krb5_wrap failed\n");
@@ -1493 +1524 @@
                 status = ads_verify_ticket(ctx, lp_realm(), 0,
                                            &ticket,
-                                           &principal, &pac_data, &ap_rep,
+                                           &principal, &logon_info, &ap_rep,
                                            &session_key, True);
 
@@ -1515 +1546 @@
                         user = talloc_strdup(ctx, principal);
 
-                        if (pac_data) {
-                                struct PAC_LOGON_INFO *logon_info;
-                                logon_info = get_logon_info_from_pac(
-                                        pac_data);
-                                if (logon_info) {
-                                        netsamlogon_cache_store(
-                                                user,
-                                                &logon_info->info3);
-                                }
+                        if (logon_info) {
+                                netsamlogon_cache_store(
+                                        user, &logon_info->info3);
                         }
 
@@ -1587 +1612 @@
 }
 
-static NTLMSSP_STATE *client_ntlmssp_state = NULL;
+static struct ntlmssp_state *client_ntlmssp_state = NULL;
 
 static bool manage_client_ntlmssp_init(struct spnego_data spnego)
@@ -1638 +1663 @@
                 DEBUG(1, ("Expected OK or MORE_PROCESSING_REQUIRED, got: %s\n",
                           nt_errstr(status)));
-                ntlmssp_end(&client_ntlmssp_state);
+                TALLOC_FREE(client_ntlmssp_state);
                 return False;
         }
@@ -1671 +1696 @@
         if (spnego.negTokenTarg.negResult == SPNEGO_REJECT) {
                 x_fprintf(x_stdout, "NA\n");
-                ntlmssp_end(&client_ntlmssp_state);
+                TALLOC_FREE(client_ntlmssp_state);
                 return;
         }
@@ -1677 +1702 @@
         if (spnego.negTokenTarg.negResult == SPNEGO_ACCEPT_COMPLETED) {
                 x_fprintf(x_stdout, "AF\n");
-                ntlmssp_end(&client_ntlmssp_state);
+                TALLOC_FREE(client_ntlmssp_state);
                 return;
         }
@@ -1684 +1709 @@
                                        spnego.negTokenTarg.responseToken,
                                        &request);
-                
+
         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
                 DEBUG(1, ("Expected MORE_PROCESSING_REQUIRED from "
@@ -1692 +1717 @@
                                     "ntlmssp_client_update\n");
                 data_blob_free(&request);
-                ntlmssp_end(&client_ntlmssp_state);
+                TALLOC_FREE(client_ntlmssp_state);
                 return;
         }
@@ -1701 +1726 @@
         spnego.negTokenTarg.responseToken = request;
         spnego.negTokenTarg.mechListMIC = null_blob;
-        
+
         spnego_write_data(ctx, &to_server, &spnego);
         data_blob_free(&request);
@@ -1745 +1770 @@
         principal[spnego.negTokenInit.mechListMIC.length] = '\0';
 
-        retval = cli_krb5_get_ticket(principal, 0, &tkt, &session_key_krb5, 0, NULL, NULL, NULL);
-
+        retval = cli_krb5_get_ticket(ctx, principal, 0,
+                                          &tkt, &session_key_krb5,
+                                          0, NULL, NULL, NULL);
         if (retval) {
                 char *user = NULL;
@@ -1769 +1795 @@
                 }
 
-                retval = cli_krb5_get_ticket(principal, 0, &tkt, &session_key_krb5, 0, NULL, NULL, NULL);
-
+                retval = cli_krb5_get_ticket(ctx, principal, 0,
+                                                  &tkt, &session_key_krb5,
+                                                  0, NULL, NULL, NULL);
                 if (retval) {
                         DEBUG(10, ("Kinit suceeded, but getting a ticket failed: %s\n", error_message(retval)));
@@ -1855 +1882 @@
 
                 opt_password = SMB_STRNDUP((const char *)request.data, request.length);
-                
+
                 if (opt_password == NULL) {
                         DEBUG(1, ("Out of memory\n"));
@@ -1941 +1968 @@
                         }
 
-                        ntlmssp_end(&client_ntlmssp_state);
+                        TALLOC_FREE(client_ntlmssp_state);
                         goto out;
                 }
@@ -1983 +2010 @@
         static bool ntlm_server_1_user_session_key;
         static bool ntlm_server_1_lm_session_key;
-        
+
         if (strequal(buf, ".")) {
                 if (!full_username && !username) {      
@@ -2013 +2040 @@
                                 fstring fstr_user;
                                 fstring fstr_domain;
-                                
+
                                 if (!parse_ntlm_auth_domain_user(full_username, fstr_user, fstr_domain)) {
                                         /* username might be 'tainted', don't print into our new-line deleimianted stream */
@@ -2030 +2057 @@
                         if (ntlm_server_1_lm_session_key) 
                                 flags |= WBFLAG_PAM_LMKEY;
-                        
+
                         if (ntlm_server_1_user_session_key) 
                                 flags |= WBFLAG_PAM_USER_SESSION_KEY;
@@ -2099 +2126 @@
         if (!parameter) {
                 parameter = strstr_m(request, ": ");
-                
+
                 if (!parameter) {
                         DEBUG(0, ("Parameter not found!\n"));
@@ -2105 +2132 @@
                         return;
                 }
-                
+
                 parameter[0] ='\0';
                 parameter++;
@@ -2186 +2213 @@
                         new_nt_pswd = data_blob(NULL, 516);
                         old_nt_hash_enc = data_blob(NULL, 16);
-                        
+
                         /* Calculate the MD4 hash (NT compatible) of the
                          * password */
@@ -2194 +2221 @@
                         /* E_deshash returns false for 'long'
                            passwords (> 14 DOS chars).  
-                           
+
                            Therefore, don't send a buffer
                            encrypted with the truncated hash
@@ -2223 +2250 @@
                         encode_pw_buffer(new_nt_pswd.data, newpswd,
                                          STR_UNICODE);
-        
+
                         arcfour_crypt(new_nt_pswd.data, old_nt_hash, 516);
                         E_old_pw_hash(new_nt_hash, old_nt_hash,
                                       old_nt_hash_enc.data);
                 }
-                
+
                 if (!full_username && !username) {      
                         x_fprintf(x_stdout, "Error: No username supplied!\n");
@@ -2237 +2264 @@
                 } else {
                         char *error_string = NULL;
-                        
+
                         if (full_username && !username) {
                                 fstring fstr_user;
                                 fstring fstr_domain;
-                                
+
                                 if (!parse_ntlm_auth_domain_user(full_username,
                                                                  fstr_user,
@@ -2259 +2286 @@
                                         domain = smb_xstrdup(fstr_domain);
                                 }
-                                
+
                         }
 
@@ -2299 +2326 @@
         if (!parameter) {
                 parameter = strstr_m(request, ": ");
-                
+
                 if (!parameter) {
                         DEBUG(0, ("Parameter not found!\n"));
@@ -2305 +2332 @@
                         return;
                 }
-                
+
                 parameter[0] ='\0';
                 parameter++;
@@ -2581 +2608 @@
                 { "request-nt-key", 0, POPT_ARG_NONE, &request_user_session_key, OPT_USER_SESSION_KEY, "Retrieve User (NT) session key"},
                 { "use-cached-creds", 0, POPT_ARG_NONE, &use_cached_creds, OPT_USE_CACHED_CREDS, "Use cached credentials if no password is given"},
-                { "diagnostics", 0, POPT_ARG_NONE, &diagnostics, OPT_DIAGNOSTICS, "Perform diagnostics on the authentictaion chain"},
+                { "diagnostics", 0, POPT_ARG_NONE, &diagnostics,
+                  OPT_DIAGNOSTICS,
+                  "Perform diagnostics on the authentication chain"},
                 { "require-membership-of", 0, POPT_ARG_STRING, &require_membership_of, OPT_REQUIRE_MEMBERSHIP, "Require that a user be a member of this group (either name or SID) for authentication to succeed" },
                 { "pam-winbind-conf", 0, POPT_ARG_STRING, &opt_pam_winbind_conf, OPT_PAM_WINBIND_CONF, "Require that request must set WBFLAG_PAM_CONTACT_TRUSTDOM when krb5 auth is required" },
@@ -2592 +2621 @@
         load_case_tables();
 
-        dbf = x_stderr;
+        setup_logging("ntlm_auth", DEBUG_STDERR);
 
         /* Parse options */

vendor/current/source3/utils/ntlm_auth_diagnostics.c

@@ -25 +25 @@
 #include "utils/ntlm_auth.h"
 #include "../libcli/auth/libcli_auth.h"
+#include "nsswitch/winbind_client.h"
 
 #undef DBGC_CLASS

vendor/current/source3/utils/pdbedit.c

@@ -22 +22 @@
 
 #include "includes.h"
+#include "popt_common.h"
+#include "../librpc/gen_ndr/samr.h"
+#include "../libcli/security/security.h"
+#include "passdb.h"
 
 #define BIT_BACKEND     0x00000004
@@ -56 +60 @@
 #define MASK_USER_GOOD          0x60405FE0
 
-static int get_sid_from_cli_string(DOM_SID *sid, const char *str_sid)
+static int get_sid_from_cli_string(struct dom_sid *sid, const char *str_sid)
 {
         uint32_t rid;
@@ -69 +73 @@
                         return -1;
                 }
-                sid_copy(sid, get_global_sam_sid());
-                sid_append_rid(sid, rid);
+                sid_compose(sid, get_global_sam_sid(), rid);
         }
 
@@ -105 +108 @@
                 struct samu *user;
                 struct samu *account;
-                DOM_SID user_sid;
+                struct dom_sid user_sid;
 
                 DEBUG(4, ("Processing account %s\n", userentry.account_name));
@@ -203 +206 @@
 
         for (i=1; decode_account_policy_name(i) != NULL; i++) {
-                uint32 policy_value;
+                uint32_t policy_value;
                 if (!account_policy_get_default(i, &policy_value)) {
                         fprintf(stderr, "Can't get default account policy\n");
@@ -227 +230 @@
 
         for ( i=1; decode_account_policy_name(i) != NULL; i++ ) {
-                uint32 policy_value;
+                uint32_t policy_value;
                 NTSTATUS status;
 
@@ -263 +266 @@
         if (verbosity) {
                 char temp[44];
-                const uint8 *hours;
+                const uint8_t *hours;
 
                 printf ("Unix username:        %s\n", pdb_get_username(sam_pwent));
@@ -330 +333 @@
                        nt_passwd,
                        pdb_encode_acct_ctrl(pdb_get_acct_ctrl(sam_pwent),NEW_PW_FORMAT_SPACE_PADDED_LEN),
-                       (uint32)convert_time_t_to_uint32(pdb_get_pass_last_set_time(sam_pwent)));
+                       (uint32)convert_time_t_to_uint32_t(pdb_get_pass_last_set_time(sam_pwent)));
         } else {
                 uid = nametouid(pdb_get_username(sam_pwent));
@@ -378 +381 @@
         struct samu *sam_pwent;
         TALLOC_CTX *tosctx;
-        DOM_SID user_sid;
+        struct dom_sid user_sid;
         bool bret;
         int ret;
@@ -436 +439 @@
         struct samu *sam_pwent;
         TALLOC_CTX *tosctx;
-        DOM_SID user_sid;
+        struct dom_sid user_sid;
         NTSTATUS status;
         bool bret;
@@ -506 +509 @@
         uint32_t not_settable;
         uint32_t new_flags;
-        DOM_SID u_sid;
+        struct dom_sid u_sid;
         bool ret;
 
@@ -525 +528 @@
                 memset(hours_array, 0xff, hours_len);
 
-                pdb_set_hours(sam_pwent, hours_array, PDB_CHANGED);
+                pdb_set_hours(sam_pwent, hours_array, hours_len, PDB_CHANGED);
         }
 
@@ -594 +597 @@
                         }
 
-                        value = convert_uint32_to_time_t(num);
+                        value = convert_uint32_t_to_time_t(num);
                 }
 
@@ -620 +623 @@
         uint32_t not_settable;
         uint32_t new_flags;
-        DOM_SID m_sid;
+        struct dom_sid m_sid;
         char *name;
         int len;
@@ -711 +714 @@
         TALLOC_CTX *tosctx;
         NTSTATUS status;
-        DOM_SID u_sid;
+        struct dom_sid u_sid;
         int flags;
         int ret;
@@ -808 +811 @@
         TALLOC_CTX *tosctx;
         NTSTATUS status;
-        DOM_SID m_sid;
+        struct dom_sid m_sid;
         char *compatpwd;
         char *name;
@@ -1057 +1060 @@
         load_case_tables();
 
-        setup_logging("pdbedit", True);
+        setup_logging("pdbedit", DEBUG_STDOUT);
 
         pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
@@ -1134 +1137 @@
         /* account policy operations */
         if ((checkparms & BIT_ACCPOLICY) && !(checkparms & ~(BIT_ACCPOLICY + BIT_ACCPOLVAL))) {
-                uint32 value;
+                uint32_t value;
                 enum pdb_policy_type field = account_policy_name_to_typenum(account_policy);
                 if (field == 0) {

vendor/current/source3/utils/profiles.c

@@ -1 @@
-/* 
-   Samba Unix/Linux SMB client utility profiles.c 
-   
-   Copyright (C) Richard Sharpe, <rsharpe@richardsharpe.com>   2002 
-   Copyright (C) Jelmer Vernooij (conversion to popt)          2003 
-   Copyright (C) Gerald (Jerry) Carter                         2005 
+/*
+   Samba Unix/Linux SMB client utility profiles.c
+
+   Copyright (C) Richard Sharpe, <rsharpe@richardsharpe.com>   2002
+   Copyright (C) Jelmer Vernooij (conversion to popt)          2003
+   Copyright (C) Gerald (Jerry) Carter                         2005
 
    This program is free software; you can redistribute it and/or modify
@@ -10 +10 @@
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-                                  
+
 #include "includes.h"
-#include "regfio.h"
+#include "system/filesys.h"
+#include "popt_common.h"
+#include "registry/reg_objects.h"
+#include "registry/regfio.h"
+#include "../libcli/security/security.h"
 
 /* GLOBAL VARIABLES */
 
-DOM_SID old_sid, new_sid;
+struct dom_sid old_sid, new_sid;
 int change = 0, new_val = 0;
 int opt_verbose = False;
@@ -56 +60 @@
 ********************************************************************/
 
-static bool swap_sid_in_acl( SEC_DESC *sd, DOM_SID *s1, DOM_SID *s2 )
+static bool swap_sid_in_acl( struct security_descriptor *sd, struct dom_sid *s1, struct dom_sid *s2 )
 {
-        SEC_ACL *theacl;
+        struct security_acl *theacl;
         int i;
         bool update = False;
 
         verbose_output("  Owner SID: %s\n", sid_string_tos(sd->owner_sid));
-        if ( sid_equal( sd->owner_sid, s1 ) ) {
+        if ( dom_sid_equal( sd->owner_sid, s1 ) ) {
                 sid_copy( sd->owner_sid, s2 );
                 update = True;
-                verbose_output("  New Owner SID: %s\n", 
+                verbose_output("  New Owner SID: %s\n",
                         sid_string_tos(sd->owner_sid));
 
@@ -72 +76 @@
 
         verbose_output("  Group SID: %s\n", sid_string_tos(sd->group_sid));
-        if ( sid_equal( sd->group_sid, s1 ) ) {
+        if ( dom_sid_equal( sd->group_sid, s1 ) ) {
                 sid_copy( sd->group_sid, s2 );
                 update = True;
-                verbose_output("  New Group SID: %s\n", 
+                verbose_output("  New Group SID: %s\n",
                         sid_string_tos(sd->group_sid));
         }
@@ -82 +86 @@
         verbose_output("  DACL: %d entries:\n", theacl->num_aces);
         for ( i=0; i<theacl->num_aces; i++ ) {
-                verbose_output("    Trustee SID: %s\n", 
+                verbose_output("    Trustee SID: %s\n",
                         sid_string_tos(&theacl->aces[i].trustee));
-                if ( sid_equal( &theacl->aces[i].trustee, s1 ) ) {
+                if ( dom_sid_equal( &theacl->aces[i].trustee, s1 ) ) {
                         sid_copy( &theacl->aces[i].trustee, s2 );
                         update = True;
-                        verbose_output("    New Trustee SID: %s\n", 
+                        verbose_output("    New Trustee SID: %s\n",
                                 sid_string_tos(&theacl->aces[i].trustee));
                 }
@@ -96 +100 @@
         verbose_output("  SACL: %d entries: \n", theacl->num_aces);
         for ( i=0; i<theacl->num_aces; i++ ) {
-                verbose_output("    Trustee SID: %s\n", 
+                verbose_output("    Trustee SID: %s\n",
                         sid_string_tos(&theacl->aces[i].trustee));
-                if ( sid_equal( &theacl->aces[i].trustee, s1 ) ) {
+                if ( dom_sid_equal( &theacl->aces[i].trustee, s1 ) ) {
                         sid_copy( &theacl->aces[i].trustee, s2 );
                         update = True;
-                        verbose_output("    New Trustee SID: %s\n", 
+                        verbose_output("    New Trustee SID: %s\n",
                                 sid_string_tos(&theacl->aces[i].trustee));
                 }
@@ -117 +121 @@
 {
         REGF_NK_REC *key, *subkey;
-        SEC_DESC *new_sd;
+        struct security_descriptor *new_sd;
         struct regval_ctr *values;
         struct regsubkey_ctr *subkeys;
@@ -140 +144 @@
         }
 
-        if ( !(values = TALLOC_ZERO_P( subkeys, struct regval_ctr )) ) {
+        werr = regval_ctr_init(subkeys, &values);
+        if (!W_ERROR_IS_OK(werr)) {
                 TALLOC_FREE( subkeys );
                 DEBUG(0,("copy_registry_tree: talloc() failure!\n"));
@@ -150 +155 @@
         for ( i=0; i<nk->num_values; i++ ) {
                 regval_ctr_addvalue( values, nk->values[i].valuename, nk->values[i].type,
-                        (const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
+                        nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
         }
 
@@ -212 +217 @@
         /* setup logging options */
 
-        setup_logging( "profiles", True );
-        dbf = x_stderr;
-        x_setbuf( x_stderr, NULL );
+        setup_logging( "profiles", DEBUG_STDERR);
 
         pc = poptGetContext("profiles", argc, (const char **)argv, long_options,

vendor/current/source3/utils/sharesec.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "popt_common.h"
+#include "../libcli/security/security.h"
+#include "passdb/machine_sid.h"
 
 static TALLOC_CTX *ctx;
@@ -65 +68 @@
 ********************************************************************/
 
-static void print_ace(FILE *f, SEC_ACE *ace)
+static void print_ace(FILE *f, struct security_ace *ace)
 {
         const struct perm_value *v;
@@ -125 +128 @@
 ********************************************************************/
 
-static void sec_desc_print(FILE *f, SEC_DESC *sd)
+static void sec_desc_print(FILE *f, struct security_descriptor *sd)
 {
         uint32 i;
@@ -139 +142 @@
         /* Print aces */
         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
-                SEC_ACE *ace = &sd->dacl->aces[i];
+                struct security_ace *ace = &sd->dacl->aces[i];
                 fprintf(f, "ACL:");
                 print_ace(f, ace);
@@ -150 +153 @@
 ********************************************************************/
 
-static bool parse_ace(SEC_ACE *ace, const char *orig_str)
+static bool parse_ace(struct security_ace *ace, const char *orig_str)
 {
         char *p;
@@ -158 +161 @@
         unsigned int aflags = 0;
         unsigned int amask = 0;
-        DOM_SID sid;
+        struct dom_sid sid;
         uint32_t mask;
         const struct perm_value *v;
@@ -295 +298 @@
 ********************************************************************/
 
-static SEC_DESC* parse_acl_string(TALLOC_CTX *mem_ctx, const char *szACL, size_t *sd_size )
-{
-        SEC_DESC *sd = NULL;
-        SEC_ACE *ace;
-        SEC_ACL *theacl;
+static struct security_descriptor* parse_acl_string(TALLOC_CTX *mem_ctx, const char *szACL, size_t *sd_size )
+{
+        struct security_descriptor *sd = NULL;
+        struct security_ace *ace;
+        struct security_acl *theacl;
         int num_ace;
         const char *pacl;
@@ -310 +313 @@
         num_ace = count_chars( pacl, ',' ) + 1;
 
-        if ( !(ace = TALLOC_ZERO_ARRAY( mem_ctx, SEC_ACE, num_ace )) )
+        if ( !(ace = TALLOC_ZERO_ARRAY( mem_ctx, struct security_ace, num_ace )) )
                 return NULL;
 
@@ -330 +333 @@
                 return NULL;
 
-        sd = make_sec_desc( mem_ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
+        sd = make_sec_desc( mem_ctx, SD_REVISION, SEC_DESC_SELF_RELATIVE,
                 NULL, NULL, NULL, theacl, sd_size);
 
@@ -336 +339 @@
 }
 
-/* add an ACE to a list of ACEs in a SEC_ACL */
-static bool add_ace(TALLOC_CTX *mem_ctx, SEC_ACL **the_acl, SEC_ACE *ace)
-{
-        SEC_ACL *new_ace;
-        SEC_ACE *aces;
+/* add an ACE to a list of ACEs in a struct security_acl */
+static bool add_ace(TALLOC_CTX *mem_ctx, struct security_acl **the_acl, struct security_ace *ace)
+{
+        struct security_acl *new_ace;
+        struct security_ace *aces;
         if (! *the_acl) {
                 return (((*the_acl) = make_sec_acl(mem_ctx, 3, 1, ace)) != NULL);
         }
 
-        if (!(aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces))) {
-                return False;
-        }
-        memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(SEC_ACE));
-        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
+        if (!(aces = SMB_CALLOC_ARRAY(struct security_ace, 1+(*the_acl)->num_aces))) {
+                return False;
+        }
+        memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(struct
+        security_ace));
+        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(struct security_ace));
         new_ace = make_sec_acl(mem_ctx,(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
         SAFE_FREE(aces);
@@ -361 +365 @@
    allowed ACEs. */
 
-static int ace_compare(SEC_ACE *ace1, SEC_ACE *ace2)
+static int ace_compare(struct security_ace *ace1, struct security_ace *ace2)
 {
         if (sec_ace_equal(ace1, ace2))
@@ -369 +373 @@
                 return ace2->type - ace1->type;
 
-        if (sid_compare(&ace1->trustee, &ace2->trustee))
-                return sid_compare(&ace1->trustee, &ace2->trustee);
+        if (dom_sid_compare(&ace1->trustee, &ace2->trustee))
+                return dom_sid_compare(&ace1->trustee, &ace2->trustee);
 
         if (ace1->flags != ace2->flags)
@@ -381 +385 @@
                 return ace1->size - ace2->size;
 
-        return memcmp(ace1, ace2, sizeof(SEC_ACE));
-}
-
-static void sort_acl(SEC_ACL *the_acl)
+        return memcmp(ace1, ace2, sizeof(struct security_ace));
+}
+
+static void sort_acl(struct security_acl *the_acl)
 {
         uint32 i;
         if (!the_acl) return;
 
-        qsort(the_acl->aces, the_acl->num_aces, sizeof(the_acl->aces[0]), QSORT_CAST ace_compare);
+        TYPESAFE_QSORT(the_acl->aces, the_acl->num_aces, ace_compare);
 
         for (i=1;i<the_acl->num_aces;) {
@@ -407 +411 @@
 static int change_share_sec(TALLOC_CTX *mem_ctx, const char *sharename, char *the_acl, enum acl_mode mode)
 {
-        SEC_DESC *sd = NULL;
-        SEC_DESC *old = NULL;
+        struct security_descriptor *sd = NULL;
+        struct security_descriptor *old = NULL;
         size_t sd_size = 0;
         uint32 i, j;
@@ -458 +462 @@
 
                 for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
-                    if (sid_equal(&sd->dacl->aces[i].trustee,
+                    if (dom_sid_equal(&sd->dacl->aces[i].trustee,
                         &old->dacl->aces[j].trustee)) {
                         old->dacl->aces[j] = sd->dacl->aces[i];
@@ -541 +545 @@
 
         /* set default debug level to 1 regardless of what smb.conf sets */
-        setup_logging( "sharesec", True );
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
-        dbf = x_stderr;
-        x_setbuf( x_stderr, NULL );
+        setup_logging( "sharesec", DEBUG_STDERR);
+
+        load_case_tables();
+
+        lp_set_cmdline("log level", "1");
 
         pc = poptGetContext("sharesec", argc, argv, long_options, 0);
@@ -592 +597 @@
         setlinebuf(stdout);
 
-        load_case_tables();
-
-        lp_load( get_dyn_CONFIGFILE(), False, False, False, True );
+        lp_load_with_registry_shares( get_dyn_CONFIGFILE(), False, False, False,
+                                      True );
 
         /* check for initializing secrets.tdb first */
 
         if ( initialize_sid ) {
-                DOM_SID *sid = get_global_sam_sid();
+                struct dom_sid *sid = get_global_sam_sid();
 
                 if ( !sid ) {

vendor/current/source3/utils/smbcacls.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    ACL get/set utility
-   
+
    Copyright (C) Andrew Tridgell 2000
    Copyright (C) Tim Potter      2000
    Copyright (C) Jeremy Allison  2000
    Copyright (C) Jelmer Vernooij 2003
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -23 +23 @@
 
 #include "includes.h"
-
-extern bool AllowDebugChange;
+#include "popt_common.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_lsa.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "../libcli/security/security.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "passdb/machine_sid.h"
 
 static int test_args;
@@ -34 +40 @@
 static int numeric;
 
+static int sddl;
+
 enum acl_mode {SMB_ACL_SET, SMB_ACL_DELETE, SMB_ACL_MODIFY, SMB_ACL_ADD };
-enum chown_mode {REQUEST_NONE, REQUEST_CHOWN, REQUEST_CHGRP};
+enum chown_mode {REQUEST_NONE, REQUEST_CHOWN, REQUEST_CHGRP, REQUEST_INHERIT};
 enum exit_values {EXIT_OK, EXIT_FAILED, EXIT_PARSE_ERROR};
 
@@ -65 +73 @@
 
 static NTSTATUS cli_lsa_lookup_sid(struct cli_state *cli,
-                                   const DOM_SID *sid,
+                                   const struct dom_sid *sid,
                                    TALLOC_CTX *mem_ctx,
                                    enum lsa_SidType *type,
@@ -118 +126 @@
                                     const char *name,
                                     enum lsa_SidType *type,
-                                    DOM_SID *sid)
+                                    struct dom_sid *sid)
 {
         uint16 orig_cnum = cli->cnum;
@@ -125 +133 @@
         NTSTATUS status;
         TALLOC_CTX *frame = talloc_stackframe();
-        DOM_SID *sids;
+        struct dom_sid *sids;
         enum lsa_SidType *types;
 
@@ -164 +172 @@
 
 /* convert a SID to a string, either numeric or username/group */
-static void SidToString(struct cli_state *cli, fstring str, const DOM_SID *sid)
+static void SidToString(struct cli_state *cli, fstring str, const struct dom_sid *sid)
 {
         char *domain = NULL;
@@ -193 +201 @@
 
 /* convert a string to a SID, either numeric or username/group */
-static bool StringToSid(struct cli_state *cli, DOM_SID *sid, const char *str)
+static bool StringToSid(struct cli_state *cli, struct dom_sid *sid, const char *str)
 {
         enum lsa_SidType type;
 
-        if (strncmp(str, "S-", 2) == 0) {
-                return string_to_sid(sid, str);
+        if (string_to_sid(sid, str)) {
+                return true;
         }
 
@@ -265 +273 @@
 
 /* print an ACE on a FILE, using either numeric or ascii representation */
-static void print_ace(struct cli_state *cli, FILE *f, SEC_ACE *ace)
+static void print_ace(struct cli_state *cli, FILE *f, struct security_ace *ace)
 {
         const struct perm_value *v;
@@ -353 +361 @@
                 }
 
-                if (*p != '|' && *p != '\0') {
+                switch (*p) {
+                case '|':
+                        p++;
+                case '\0':
+                        continue;
+                default:
                         return false;
                 }
@@ -361 +374 @@
 
 /* parse an ACE in the same format as print_ace() */
-static bool parse_ace(struct cli_state *cli, SEC_ACE *ace,
+static bool parse_ace(struct cli_state *cli, struct security_ace *ace,
                       const char *orig_str)
 {
@@ -370 +383 @@
         unsigned int aflags = 0;
         unsigned int amask = 0;
-        DOM_SID sid;
+        struct dom_sid sid;
         uint32_t mask;
         const struct perm_value *v;
@@ -527 +540 @@
 }
 
-/* add an ACE to a list of ACEs in a SEC_ACL */
-static bool add_ace(SEC_ACL **the_acl, SEC_ACE *ace)
-{
-        SEC_ACL *new_ace;
-        SEC_ACE *aces;
+/* add an ACE to a list of ACEs in a struct security_acl */
+static bool add_ace(struct security_acl **the_acl, struct security_ace *ace)
+{
+        struct security_acl *new_ace;
+        struct security_ace *aces;
         if (! *the_acl) {
                 return (((*the_acl) = make_sec_acl(talloc_tos(), 3, 1, ace))
@@ -537 +550 @@
         }
 
-        if (!(aces = SMB_CALLOC_ARRAY(SEC_ACE, 1+(*the_acl)->num_aces))) {
+        if (!(aces = SMB_CALLOC_ARRAY(struct security_ace, 1+(*the_acl)->num_aces))) {
                 return False;
         }
-        memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(SEC_ACE));
-        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
+        memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(struct
+        security_ace));
+        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(struct security_ace));
         new_ace = make_sec_acl(talloc_tos(),(*the_acl)->revision,1+(*the_acl)->num_aces, aces);
         SAFE_FREE(aces);
@@ -549 +563 @@
 
 /* parse a ascii version of a security descriptor */
-static SEC_DESC *sec_desc_parse(TALLOC_CTX *ctx, struct cli_state *cli, char *str)
+static struct security_descriptor *sec_desc_parse(TALLOC_CTX *ctx, struct cli_state *cli, char *str)
 {
         const char *p = str;
         char *tok;
-        SEC_DESC *ret = NULL;
+        struct security_descriptor *ret = NULL;
         size_t sd_size;
-        DOM_SID *grp_sid=NULL, *owner_sid=NULL;
-        SEC_ACL *dacl=NULL;
+        struct dom_sid *grp_sid=NULL, *owner_sid=NULL;
+        struct security_acl *dacl=NULL;
         int revision=1;
 
@@ -570 +584 @@
                                 goto done;
                         }
-                        owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        owner_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!owner_sid ||
                             !StringToSid(cli, owner_sid, tok+6)) {
@@ -584 +598 @@
                                 goto done;
                         }
-                        grp_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        grp_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!grp_sid ||
                             !StringToSid(cli, grp_sid, tok+6)) {
@@ -594 +608 @@
 
                 if (strncmp(tok,"ACL:", 4) == 0) {
-                        SEC_ACE ace;
+                        struct security_ace ace;
                         if (!parse_ace(cli, &ace, tok+4)) {
                                 goto done;
@@ -621 +635 @@
 
 /* print a ascii version of a security descriptor on a FILE handle */
-static void sec_desc_print(struct cli_state *cli, FILE *f, SEC_DESC *sd)
+static void sec_desc_print(struct cli_state *cli, FILE *f, struct security_descriptor *sd)
 {
         fstring sidstr;
@@ -649 +663 @@
         /* Print aces */
         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
-                SEC_ACE *ace = &sd->dacl->aces[i];
+                struct security_ace *ace = &sd->dacl->aces[i];
                 fprintf(f, "ACL:");
                 print_ace(cli, f, ace);
@@ -657 +671 @@
 }
 
-/***************************************************** 
+/*****************************************************
+get fileinfo for filename
+*******************************************************/
+static uint16 get_fileinfo(struct cli_state *cli, const char *filename)
+{
+        uint16_t fnum = (uint16_t)-1;
+        uint16 mode = 0;
+        NTSTATUS status;
+
+        /* The desired access below is the only one I could find that works
+           with NT4, W2KP and Samba */
+
+        status = cli_ntcreate(cli, filename, 0, CREATE_ACCESS_READ,
+                              0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+                              FILE_OPEN, 0x0, 0x0, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Failed to open %s: %s\n", filename, nt_errstr(status));
+                return 0;
+        }
+
+        status = cli_qfileinfo_basic(cli, fnum, &mode, NULL, NULL, NULL,
+                                     NULL, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Failed to file info %s: %s\n", filename,
+                       nt_errstr(status));
+        }
+
+        cli_close(cli, fnum);
+
+        return mode;
+}
+
+/*****************************************************
+get sec desc for filename
+*******************************************************/
+static struct security_descriptor *get_secdesc(struct cli_state *cli, const char *filename)
+{
+        uint16_t fnum = (uint16_t)-1;
+        struct security_descriptor *sd;
+        NTSTATUS status;
+
+        /* The desired access below is the only one I could find that works
+           with NT4, W2KP and Samba */
+
+        status = cli_ntcreate(cli, filename, 0, CREATE_ACCESS_READ,
+                              0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+                              FILE_OPEN, 0x0, 0x0, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Failed to open %s: %s\n", filename, nt_errstr(status));
+                return NULL;
+        }
+
+        sd = cli_query_secdesc(cli, fnum, talloc_tos());
+
+        cli_close(cli, fnum);
+
+        if (!sd) {
+                printf("Failed to get security descriptor\n");
+                return NULL;
+        }
+        return sd;
+}
+
+/*****************************************************
+set sec desc for filename
+*******************************************************/
+static bool set_secdesc(struct cli_state *cli, const char *filename,
+                        struct security_descriptor *sd)
+{
+        uint16_t fnum = (uint16_t)-1;
+        bool result=true;
+        NTSTATUS status;
+
+        /* The desired access below is the only one I could find that works
+           with NT4, W2KP and Samba */
+
+        status = cli_ntcreate(cli, filename, 0,
+                              WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS,
+                              0, FILE_SHARE_READ|FILE_SHARE_WRITE,
+                              FILE_OPEN, 0x0, 0x0, &fnum);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Failed to open %s: %s\n", filename, nt_errstr(status));
+                return false;
+        }
+
+        status = cli_set_secdesc(cli, fnum, sd);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("ERROR: security description set failed: %s\n",
+                       nt_errstr(status));
+                result=false;
+        }
+
+        cli_close(cli, fnum);
+        return result;
+}
+
+/*****************************************************
 dump the acls for a file
 *******************************************************/
-static int cacl_dump(struct cli_state *cli, char *filename)
+static int cacl_dump(struct cli_state *cli, const char *filename)
 {
         int result = EXIT_FAILED;
-        uint16_t fnum = (uint16_t)-1;
-        SEC_DESC *sd;
-
-        if (test_args) 
+        struct security_descriptor *sd;
+
+        if (test_args)
                 return EXIT_OK;
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, filename, 0, CREATE_ACCESS_READ, 0,
-                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                printf("Failed to open %s: %s\n", filename, cli_errstr(cli));
-                goto done;
-        }
-
-        sd = cli_query_secdesc(cli, fnum, talloc_tos());
-
-        if (!sd) {
-                printf("ERROR: secdesc query failed: %s\n", cli_errstr(cli));
-                goto done;
-        }
-
-        sec_desc_print(cli, stdout, sd);
-
-        result = EXIT_OK;
-
-done:
-        if (fnum != (uint16_t)-1)
-                cli_close(cli, fnum);
+        sd = get_secdesc(cli, filename);
+
+        if (sd) {
+                if (sddl) {
+                        printf("%s\n", sddl_encode(talloc_tos(), sd,
+                                           get_global_sam_sid()));
+                } else {
+                        sec_desc_print(cli, stdout, sd);
+                }
+                result = EXIT_OK;
+        }
 
         return result;
@@ -701 +801 @@
                         const char *filename, const char *new_username)
 {
-        uint16_t fnum;
-        DOM_SID sid;
-        SEC_DESC *sd, *old;
+        struct dom_sid sid;
+        struct security_descriptor *sd, *old;
         size_t sd_size;
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, filename, 0, CREATE_ACCESS_READ, 0,
-                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                printf("Failed to open %s: %s\n", filename, cli_errstr(cli));
-                return EXIT_FAILED;
-        }
 
         if (!StringToSid(cli, &sid, new_username))
                 return EXIT_PARSE_ERROR;
 
-        old = cli_query_secdesc(cli, fnum, talloc_tos());
-
-        cli_close(cli, fnum);
+        old = get_secdesc(cli, filename);
 
         if (!old) {
-                printf("owner_set: Failed to query old descriptor\n");
                 return EXIT_FAILED;
         }
@@ -729 +819 @@
                            NULL, NULL, &sd_size);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, filename, 0, WRITE_OWNER_ACCESS, 0,
-                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                printf("Failed to open %s: %s\n", filename, cli_errstr(cli));
+        if (!set_secdesc(cli, filename, sd)) {
                 return EXIT_FAILED;
         }
-
-        if (!cli_set_secdesc(cli, fnum, sd)) {
-                printf("ERROR: secdesc set failed: %s\n", cli_errstr(cli));
-                cli_close(cli, fnum);
-                return EXIT_FAILED;
-        }
-
-        cli_close(cli, fnum);
 
         return EXIT_OK;
@@ -755 +835 @@
    Inherited ACEs unchanged" */
 
-static int ace_compare(SEC_ACE *ace1, SEC_ACE *ace2)
+static int ace_compare(struct security_ace *ace1, struct security_ace *ace2)
 {
         if (sec_ace_equal(ace1, ace2))
@@ -773 +853 @@
                 return ace2->type - ace1->type;
 
-        if (sid_compare(&ace1->trustee, &ace2->trustee))
-                return sid_compare(&ace1->trustee, &ace2->trustee);
+        if (dom_sid_compare(&ace1->trustee, &ace2->trustee))
+                return dom_sid_compare(&ace1->trustee, &ace2->trustee);
 
         if (ace1->flags != ace2->flags)
@@ -785 +865 @@
                 return ace1->size - ace2->size;
 
-        return memcmp(ace1, ace2, sizeof(SEC_ACE));
-}
-
-static void sort_acl(SEC_ACL *the_acl)
+        return memcmp(ace1, ace2, sizeof(struct security_ace));
+}
+
+static void sort_acl(struct security_acl *the_acl)
 {
         uint32 i;
         if (!the_acl) return;
 
-        qsort(the_acl->aces, the_acl->num_aces, sizeof(the_acl->aces[0]), QSORT_CAST ace_compare);
+        TYPESAFE_QSORT(the_acl->aces, the_acl->num_aces, ace_compare);
 
         for (i=1;i<the_acl->num_aces;) {
@@ -812 +892 @@
 *******************************************************/
 
-static int cacl_set(struct cli_state *cli, char *filename, 
+static int cacl_set(struct cli_state *cli, const char *filename,
                     char *the_acl, enum acl_mode mode)
 {
-        uint16_t fnum;
-        SEC_DESC *sd, *old;
+        struct security_descriptor *sd, *old;
         uint32 i, j;
         size_t sd_size;
         int result = EXIT_OK;
 
-        sd = sec_desc_parse(talloc_tos(), cli, the_acl);
+        if (sddl) {
+                sd = sddl_decode(talloc_tos(), the_acl, get_global_sam_sid());
+        } else {
+                sd = sec_desc_parse(talloc_tos(), cli, the_acl);
+        }
 
         if (!sd) return EXIT_PARSE_ERROR;
         if (test_args) return EXIT_OK;
 
-        /* The desired access below is the only one I could find that works
-           with NT4, W2KP and Samba */
-
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, filename, 0, CREATE_ACCESS_READ, 0,
-                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                printf("cacl_set failed to open %s: %s\n", filename, cli_errstr(cli));
+        old = get_secdesc(cli, filename);
+
+        if (!old) {
                 return EXIT_FAILED;
         }
-
-        old = cli_query_secdesc(cli, fnum, talloc_tos());
-
-        if (!old) {
-                printf("calc_set: Failed to query old descriptor\n");
-                return EXIT_FAILED;
-        }
-
-        cli_close(cli, fnum);
 
         /* the logic here is rather more complex than I would like */
@@ -876 +947 @@
 
                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
-                                if (sid_equal(&sd->dacl->aces[i].trustee,
+                                if (dom_sid_equal(&sd->dacl->aces[i].trustee,
                                               &old->dacl->aces[j].trustee)) {
                                         old->dacl->aces[j] = sd->dacl->aces[i];
@@ -929 +1000 @@
                            NULL, old->dacl, &sd_size);
 
-        if (!NT_STATUS_IS_OK(cli_ntcreate(cli, filename, 0, WRITE_DAC_ACCESS|WRITE_OWNER_ACCESS, 0,
-                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
-                printf("cacl_set failed to open %s: %s\n", filename, cli_errstr(cli));
+        if (!set_secdesc(cli, filename, sd)) {
+                result = EXIT_FAILED;
+        }
+
+        return result;
+}
+
+/*****************************************************
+set the inherit on a file
+*******************************************************/
+static int inherit(struct cli_state *cli, const char *filename,
+                   const char *type)
+{
+        struct security_descriptor *old,*sd;
+        uint32 oldattr;
+        size_t sd_size;
+        int result = EXIT_OK;
+
+        old = get_secdesc(cli, filename);
+
+        if (!old) {
                 return EXIT_FAILED;
         }
 
-        if (!cli_set_secdesc(cli, fnum, sd)) {
-                printf("ERROR: secdesc set failed: %s\n", cli_errstr(cli));
+        oldattr = get_fileinfo(cli,filename);
+
+        if (strcmp(type,"allow")==0) {
+                if ((old->type & SEC_DESC_DACL_PROTECTED) ==
+                    SEC_DESC_DACL_PROTECTED) {
+                        int i;
+                        char *parentname,*temp;
+                        struct security_descriptor *parent;
+                        temp = talloc_strdup(talloc_tos(), filename);
+
+                        old->type=old->type & (~SEC_DESC_DACL_PROTECTED);
+
+                        /* look at parent and copy in all its inheritable ACL's. */
+                        string_replace(temp, '\\', '/');
+                        if (!parent_dirname(talloc_tos(),temp,&parentname,NULL)) {
+                                return EXIT_FAILED;
+                        }
+                        string_replace(parentname, '/', '\\');
+                        parent = get_secdesc(cli,parentname);
+                        if (parent == NULL) {
+                                return EXIT_FAILED;
+                        }
+                        for (i=0;i<parent->dacl->num_aces;i++) {
+                                struct security_ace *ace=&parent->dacl->aces[i];
+                                /* Add inherited flag to all aces */
+                                ace->flags=ace->flags|
+                                           SEC_ACE_FLAG_INHERITED_ACE;
+                                if ((oldattr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
+                                        if ((ace->flags & SEC_ACE_FLAG_CONTAINER_INHERIT) ==
+                                            SEC_ACE_FLAG_CONTAINER_INHERIT) {
+                                                add_ace(&old->dacl, ace);
+                                        }
+                                } else {
+                                        if ((ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT) ==
+                                            SEC_ACE_FLAG_OBJECT_INHERIT) {
+                                                /* clear flags for files */
+                                                ace->flags=0;
+                                                add_ace(&old->dacl, ace);
+                                        }
+                                }
+                        }
+                } else {
+                        printf("Already set to inheritable permissions.\n");
+                        return EXIT_FAILED;
+                }
+        } else if (strcmp(type,"remove")==0) {
+                if ((old->type & SEC_DESC_DACL_PROTECTED) !=
+                    SEC_DESC_DACL_PROTECTED) {
+                        old->type=old->type | SEC_DESC_DACL_PROTECTED;
+
+                        /* remove all inherited ACL's. */
+                        if (old->dacl) {
+                                int i;
+                                struct security_acl *temp=old->dacl;
+                                old->dacl=make_sec_acl(talloc_tos(), 3, 0, NULL);
+                                for (i=temp->num_aces-1;i>=0;i--) {
+                                        struct security_ace *ace=&temp->aces[i];
+                                        /* Remove all ace with INHERITED flag set */
+                                        if ((ace->flags & SEC_ACE_FLAG_INHERITED_ACE) !=
+                                            SEC_ACE_FLAG_INHERITED_ACE) {
+                                                add_ace(&old->dacl,ace);
+                                        }
+                                }
+                        }
+                } else {
+                        printf("Already set to no inheritable permissions.\n");
+                        return EXIT_FAILED;
+                }
+        } else if (strcmp(type,"copy")==0) {
+                if ((old->type & SEC_DESC_DACL_PROTECTED) !=
+                    SEC_DESC_DACL_PROTECTED) {
+                        old->type=old->type | SEC_DESC_DACL_PROTECTED;
+
+                        /* convert all inherited ACL's to non inherated ACL's. */
+                        if (old->dacl) {
+                                int i;
+                                for (i=0;i<old->dacl->num_aces;i++) {
+                                        struct security_ace *ace=&old->dacl->aces[i];
+                                        /* Remove INHERITED FLAG from all aces */
+                                        ace->flags=ace->flags&(~SEC_ACE_FLAG_INHERITED_ACE);
+                                }
+                        }
+                } else {
+                        printf("Already set to no inheritable permissions.\n");
+                        return EXIT_FAILED;
+                }
+        }
+
+        /* Denied ACE entries must come before allowed ones */
+        sort_acl(old->dacl);
+
+        sd = make_sec_desc(talloc_tos(),old->revision, old->type,
+                           old->owner_sid, old->group_sid,
+                           NULL, old->dacl, &sd_size);
+
+        if (!set_secdesc(cli, filename, sd)) {
                 result = EXIT_FAILED;
         }
 
-        /* Clean up */
-
-        cli_close(cli, fnum);
-
         return result;
 }
-
 
 /*****************************************************
@@ -980 +1158 @@
                                 get_cmdline_auth_info_password(auth_info),
                                 flags,
-                                get_cmdline_auth_info_signing_state(auth_info),
-                                NULL);
+                                get_cmdline_auth_info_signing_state(auth_info));
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
@@ -1024 +1201 @@
                 { "chown", 'C', POPT_ARG_STRING, NULL, 'C', "Change ownership of a file", "USERNAME" },
                 { "chgrp", 'G', POPT_ARG_STRING, NULL, 'G', "Change group ownership of a file", "GROUPNAME" },
+                { "inherit", 'I', POPT_ARG_STRING, NULL, 'I', "Inherit allow|remove|copy" },
                 { "numeric", 0, POPT_ARG_NONE, &numeric, 1, "Don't resolve sids or masks to names" },
+                { "sddl", 0, POPT_ARG_NONE, &sddl, 1, "Output and input acls in sddl format" },
                 { "test-args", 't', POPT_ARG_NONE, &test_args, 1, "Test arguments"},
                 POPT_COMMON_SAMBA
@@ -1040 +1219 @@
         load_case_tables();
 
-
         /* set default debug level to 1 regardless of what smb.conf sets */
-        setup_logging( "smbcacls", True );
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
-        dbf = x_stderr;
-        x_setbuf( x_stderr, NULL );
-        AllowDebugChange = false;
+        setup_logging( "smbcacls", DEBUG_STDERR);
+        lp_set_cmdline("log level", "1");
 
         setlinebuf(stdout);
@@ -1094 +1269 @@
                         owner_username = poptGetOptArg(pc);
                         change_mode = REQUEST_CHGRP;
+                        break;
+
+                case 'I':
+                        owner_username = poptGetOptArg(pc);
+                        change_mode = REQUEST_INHERIT;
                         break;
                 }
@@ -1155 +1335 @@
         /* Perform requested action */
 
-        if (change_mode != REQUEST_NONE) {
+        if (change_mode == REQUEST_INHERIT) {
+                result = inherit(cli, filename, owner_username);
+        } else if (change_mode != REQUEST_NONE) {
                 result = owner_set(cli, change_mode, filename, owner_username);
         } else if (the_acl) {

vendor/current/source3/utils/smbcontrol.c

@@ -9 +9 @@
    Copyright (C) Simo Sorce 2002
    Copyright (C) James Peach 2006
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -25 +25 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
+#include "librpc/gen_ndr/spoolss.h"
+#include "nt_printing.h"
+#include "printing/notify.h"
+#include "libsmb/nmblib.h"
+#include "messages.h"
+#include "util_tdb.h"
 
 #if HAVE_LIBUNWIND_H
@@ -62 +70 @@
         DEBUG(10,("smbcontrol/send_message: broadcast message to "
                   "%d processes\n", n_sent));
-        
+
         return ret;
 }
@@ -110 +118 @@
                                 DATA_BLOB *data)
 {
-        printf("PID %u: %.*s", (unsigned int)procid_to_pid(&pid),
-               (int)data->length, (const char *)data->data);
+        char *pidstr;
+
+        pidstr = procid_str(talloc_tos(), &pid);
+        printf("PID %s: %.*s", pidstr, (int)data->length,
+               (const char *)data->data);
+        TALLOC_FREE(pidstr);
         num_replies++;
 }
@@ -123 +135 @@
                             DATA_BLOB *data)
 {
-        printf("%.*s", (int)data->length, (const char *)data->data);
+        printf("%*s", (int)data->length, (const char *)data->data);
         num_replies++;
 }
@@ -158 +170 @@
                             strlen(argv[1]) + 1);
 }
+
+
+static bool do_idmap(struct messaging_context *msg_ctx,
+                     const struct server_id pid,
+                     const int argc, const char **argv)
+{
+        static const char* usage = "Usage: "
+                "smbcontrol <dest> idmap <cmd> [arg]\n"
+                "\tcmd:\tflush [gid|uid]\n"
+                "\t\tdelete \"UID <uid>\"|\"GID <gid>\"|<sid>\n"
+                "\t\tkill \"UID <uid>\"|\"GID <gid>\"|<sid>\n";
+        const char* arg = NULL;
+        int arglen = 0;
+        int msg_type;
+
+        switch (argc) {
+        case 2:
+                break;
+        case 3:
+                arg = argv[2];
+                arglen = strlen(arg) + 1;
+                break;
+        default:
+                fprintf(stderr, "%s", usage);
+                return false;
+        }
+
+        if (strcmp(argv[1], "flush") == 0) {
+                msg_type = MSG_IDMAP_FLUSH;
+        }
+        else if (strcmp(argv[1], "delete") == 0) {
+                msg_type = MSG_IDMAP_DELETE;
+        }
+        else if (strcmp(argv[1], "kill") == 0) {
+                msg_type = MSG_IDMAP_KILL;
+        }
+        else if (strcmp(argv[1], "help") == 0) {
+                fprintf(stdout, "%s", usage);
+                return true;
+        }
+        else {
+                fprintf(stderr, "%s", usage);
+                return false;
+        }
+
+        return send_message(msg_ctx, pid, msg_type, arg, arglen);
+}
+
 
 #if defined(HAVE_LIBUNWIND_PTRACE) && defined(HAVE_LINUX_PTRACE)
@@ -260 +320 @@
 }
 
-static int stack_trace_connection(struct db_record *rec,
-                                  const struct connections_key *key,
+static int stack_trace_connection(const struct connections_key *key,
                                   const struct connections_data *crec,
                                   void *priv)
@@ -292 +351 @@
                 print_stack_trace(dest, &count);
         } else {
-                connections_forall(stack_trace_connection, &count);
+                connections_forall_read(stack_trace_connection, &count);
         }
 
@@ -477 +536 @@
                 break;
         }
-        
+
         printf("Profiling %s on pid %u\n",s,(unsigned int)procid_to_pid(&pid));
 }
@@ -573 +632 @@
                 fprintf(stderr, "\tprinter <printername> <comment|port|"
                         "driver> <value>\n");
-                
+
                 return False;
         }
@@ -586 +645 @@
                         return False;
                 }
-                
-                notify_printer_status_byname(argv[2], PRINTER_STATUS_PAUSED);
+
+                notify_printer_status_byname(messaging_event_context(msg_ctx),
+                                             msg_ctx, argv[2],
+                                             PRINTER_STATUS_PAUSED);
 
                 goto send;
@@ -598 +659 @@
                         return False;
                 }
-                
-                notify_printer_status_byname(argv[2], PRINTER_STATUS_OK);
+
+                notify_printer_status_byname(messaging_event_context(msg_ctx),
+                                             msg_ctx, argv[2],
+                                             PRINTER_STATUS_OK);
 
                 goto send;
@@ -615 +678 @@
 
                 notify_job_status_byname(
-                        argv[2], jobid, JOB_STATUS_PAUSED, 
+                        messaging_event_context(msg_ctx), msg_ctx,
+                        argv[2], jobid, JOB_STATUS_PAUSED,
                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
 
@@ -632 +696 @@
 
                 notify_job_status_byname(
+                        messaging_event_context(msg_ctx), msg_ctx,
                         argv[2], jobid, JOB_STATUS_QUEUED, 
                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
@@ -649 +714 @@
 
                 notify_job_status_byname(
+                        messaging_event_context(msg_ctx), msg_ctx,
                         argv[2], jobid, JOB_STATUS_DELETING,
                         SPOOLSS_NOTIFY_MSG_UNIX_JOBID);
-                
+
                 notify_job_status_byname(
+                        messaging_event_context(msg_ctx), msg_ctx,
                         argv[2], jobid, JOB_STATUS_DELETING|
                         JOB_STATUS_DELETED,
@@ -661 +728 @@
         } else if (strcmp(cmd, "printer") == 0) {
                 uint32 attribute;
-                
+
                 if (argc != 5) {
                         fprintf(stderr, "Usage: smbcontrol <dest> printnotify "
@@ -681 +748 @@
                 }
 
-                notify_printer_byname(argv[2], attribute,
+                notify_printer_byname(messaging_event_context(msg_ctx),
+                                      msg_ctx, argv[2], attribute,
                                       CONST_DISCARD(char *, argv[4]));
 
@@ -708 +776 @@
 
         return send_message(msg_ctx, pid, MSG_SMB_FORCE_TDIS, argv[1],
+                            strlen(argv[1]) + 1);
+}
+
+/* Tell winbindd an IP got dropped */
+
+static bool do_ip_dropped(struct messaging_context *msg_ctx,
+                          const struct server_id pid,
+                          const int argc, const char **argv)
+{
+        if (argc != 2) {
+                fprintf(stderr, "Usage: smbcontrol <dest> ip-dropped "
+                        "<ip-address>\n");
+                return False;
+        }
+
+        return send_message(msg_ctx, pid, MSG_WINBIND_IP_DROPPED, argv[1],
                             strlen(argv[1]) + 1);
 }
@@ -903 +987 @@
         tdb = tdb_open_log(cache_path("winbindd_cache.tdb"),
                                 WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
-                                TDB_DEFAULT /* TDB_CLEAR_IF_FIRST */, O_RDWR|O_CREAT, 0600);
+                                TDB_DEFAULT|TDB_INCOMPATIBLE_HASH /* TDB_CLEAR_IF_FIRST */,
+                                O_RDWR|O_CREAT, 0600);
 
         if (!tdb) {
@@ -935 +1020 @@
                 /* Check that the entry "WINBINDD_OFFLINE" still exists. */
                 d = tdb_fetch_bystring( tdb, "WINBINDD_OFFLINE" );
-        
+
                 if (!d.dptr || d.dsize != 4) {
                         SAFE_FREE(d.dptr);
@@ -955 +1040 @@
         struct server_id myid;
 
-        myid = pid_to_procid(sys_getpid());
+        myid = messaging_server_id(msg_ctx);
 
         if (argc != 1) {
@@ -987 +1072 @@
         struct server_id myid;
 
-        myid = pid_to_procid(sys_getpid());
+        myid = messaging_server_id(msg_ctx);
 
         if (argc != 1) {
@@ -1007 +1092 @@
         int buf_len = 0;
 
-        myid = pid_to_procid(sys_getpid());
+        myid = messaging_server_id(msg_ctx);
 
         if (argc < 1 || argc > 2) {
-                fprintf(stderr, "Usage: smbcontrol <dest> dump_domain_list "
+                fprintf(stderr, "Usage: smbcontrol <dest> dump-domain-list "
                         "<domain>\n");
                 return false;
@@ -1070 +1155 @@
                                       const int argc, const char **argv)
 {
-        struct server_id myid = pid_to_procid(sys_getpid());
+        struct server_id myid;
+
+        myid = messaging_server_id(msg_ctx);
 
         if (argc != 1) {
@@ -1166 +1253 @@
 } msg_types[] = {
         { "debug", do_debug, "Set debuglevel"  },
+        { "idmap", do_idmap, "Manipulate idmap cache" },
         { "force-election", do_election,
           "Force a browse election" },
@@ -1178 +1266 @@
         { "printnotify", do_printnotify, "Send a print notify message" },
         { "close-share", do_closeshare, "Forcibly disconnect a share" },
+        { "ip-dropped", do_ip_dropped, "Tell winbind that an IP got dropped" },
         { "lockretry", do_lockretry, "Force a blocking lock retry" },
         { "brl-revalidate", do_brl_revalidate, "Revalidate all brl entries" },
@@ -1226 +1315 @@
 /* Return the pid number for a string destination */
 
-static struct server_id parse_dest(const char *dest)
+static struct server_id parse_dest(struct messaging_context *msg,
+                                   const char *dest)
 {
         struct server_id result = {-1};
@@ -1240 +1330 @@
 
         if (strequal(dest, "self")) {
-                return pid_to_procid(sys_getpid());
+                return messaging_server_id(msg);
         }
 
@@ -1278 +1368 @@
         /* Check destination */
 
-        pid = parse_dest(dest);
+        pid = parse_dest(msg_ctx, dest);
         if (!procid_valid(&pid)) {
                 return False;
@@ -1343 +1433 @@
         load_case_tables();
 
-        setup_logging(argv[0],True);
-        
+        setup_logging(argv[0], DEBUG_STDOUT);
+
         /* Parse command line arguments using popt */
 
@@ -1387 +1477 @@
          * routines mostly return True==1 for success, but
          * shell needs 0. */ 
-        
+
         if (!(evt_ctx = tevent_context_init(NULL)) ||
-            !(msg_ctx = messaging_init(NULL, server_id_self(), evt_ctx))) {
+            !(msg_ctx = messaging_init(NULL, procid_self(), evt_ctx))) {
                 fprintf(stderr, "could not init messaging context\n");
                 TALLOC_FREE(frame);
                 exit(1);
         }
-        
+
         ret = !do_command(msg_ctx, argc, argv);
         TALLOC_FREE(frame);

vendor/current/source3/utils/smbcquotas.c

@@ -2 +2 @@
    Unix SMB/CIFS implementation.
    QUOTA get/set utility
-   
+
    Copyright (C) Andrew Tridgell                2000
    Copyright (C) Tim Potter                     2000
    Copyright (C) Jeremy Allison                 2000
    Copyright (C) Stefan (metze) Metzmacher      2003
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -23 +23 @@
 
 #include "includes.h"
+#include "popt_common.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_lsa.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "fake_file.h"
+#include "../libcli/security/security.h"
+#include "libsmb/libsmb.h"
 
 static char *server;
@@ -73 +80 @@
                 got_policy_hnd = True;
         }
-        
+
         return True;
 }
 
 /* convert a SID to a string, either numeric or username/group */
-static void SidToString(fstring str, DOM_SID *sid, bool _numeric)
+static void SidToString(fstring str, struct dom_sid *sid, bool _numeric)
 {
         char **domains = NULL;
@@ -103 +110 @@
                  domains[0], lp_winbind_separator(),
                  names[0]);
-        
 }
 
 /* convert a string to a SID, either numeric or username/group */
-static bool StringToSid(DOM_SID *sid, const char *str)
+static bool StringToSid(struct dom_sid *sid, const char *str)
 {
         enum lsa_SidType *types = NULL;
-        DOM_SID *sids = NULL;
+        struct dom_sid *sids = NULL;
         bool result = True;
 
-        if (strncmp(str, "S-", 2) == 0) {
-                return string_to_sid(sid, str);
+        if (string_to_sid(sid, str)) {
+                return true;
         }
 
@@ -224 +230 @@
 }
 
+
+static const char *quota_str_static(uint64_t val, bool special, bool _numeric)
+{
+        const char *result;
+
+        if (!_numeric&&special&&(val == SMB_NTQUOTAS_NO_LIMIT)) {
+                return "NO LIMIT";
+        }
+        result = talloc_asprintf(talloc_tos(), "%"PRIu64, val);
+        SMB_ASSERT(result != NULL);
+        return result;
+}
+
+static void dump_ntquota(SMB_NTQUOTA_STRUCT *qt, bool _verbose,
+                         bool _numeric,
+                         void (*_sidtostring)(fstring str,
+                                              struct dom_sid *sid,
+                                              bool _numeric))
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+
+        if (!qt) {
+                smb_panic("dump_ntquota() called with NULL pointer");
+        }
+
+        switch (qt->qtype) {
+        case SMB_USER_FS_QUOTA_TYPE:
+        {
+                d_printf("File System QUOTAS:\n");
+                d_printf("Limits:\n");
+                d_printf(" Default Soft Limit: %15s\n",
+                         quota_str_static(qt->softlim,True,_numeric));
+                d_printf(" Default Hard Limit: %15s\n",
+                         quota_str_static(qt->hardlim,True,_numeric));
+                d_printf("Quota Flags:\n");
+                d_printf(" Quotas Enabled: %s\n",
+                         ((qt->qflags&QUOTAS_ENABLED)
+                          ||(qt->qflags&QUOTAS_DENY_DISK))?"On":"Off");
+                d_printf(" Deny Disk:      %s\n",
+                         (qt->qflags&QUOTAS_DENY_DISK)?"On":"Off");
+                d_printf(" Log Soft Limit: %s\n",
+                         (qt->qflags&QUOTAS_LOG_THRESHOLD)?"On":"Off");
+                d_printf(" Log Hard Limit: %s\n",
+                         (qt->qflags&QUOTAS_LOG_LIMIT)?"On":"Off");
+        }
+        break;
+        case SMB_USER_QUOTA_TYPE:
+        {
+                fstring username_str = {0};
+
+                if (_sidtostring) {
+                        _sidtostring(username_str,&qt->sid,_numeric);
+                } else {
+                        sid_to_fstring(username_str, &qt->sid);
+                }
+
+                if (_verbose) {
+                        d_printf("Quotas for User: %s\n",username_str);
+                        d_printf("Used Space: %15s\n",
+                                 quota_str_static(qt->usedspace,False,
+                                                  _numeric));
+                        d_printf("Soft Limit: %15s\n",
+                                 quota_str_static(qt->softlim,True,
+                                                  _numeric));
+                        d_printf("Hard Limit: %15s\n",
+                                 quota_str_static(qt->hardlim,True,_numeric));
+                } else {
+                        d_printf("%-30s: ",username_str);
+                        d_printf("%15s/",quota_str_static(
+                                         qt->usedspace,False,_numeric));
+                        d_printf("%15s/",quota_str_static(
+                                         qt->softlim,True,_numeric));
+                        d_printf("%15s\n",quota_str_static(
+                                         qt->hardlim,True,_numeric));
+                }
+        }
+        break;
+        default:
+                d_printf("dump_ntquota() invalid qtype(%d)\n",qt->qtype);
+        }
+        TALLOC_FREE(frame);
+        return;
+}
+
+static void dump_ntquota_list(SMB_NTQUOTA_LIST **qtl, bool _verbose,
+                              bool _numeric,
+                              void (*_sidtostring)(fstring str,
+                                                   struct dom_sid *sid,
+                                                   bool _numeric))
+{
+        SMB_NTQUOTA_LIST *cur;
+
+        for (cur = *qtl;cur;cur = cur->next) {
+                if (cur->quotas)
+                        dump_ntquota(cur->quotas,_verbose,_numeric,
+                                     _sidtostring);
+        }
+}
+
 static int do_quota(struct cli_state *cli,
                 enum SMB_QUOTA_TYPE qtype,
@@ -234 +339 @@
         SMB_NTQUOTA_LIST *qtl = NULL;
         SMB_NTQUOTA_STRUCT qt;
+        NTSTATUS status;
+
         ZERO_STRUCT(qt);
 
-        if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
+        status = cli_get_fs_attr_info(cli, &fs_attrs);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("Failed to get the filesystem attributes %s.\n",
-                        cli_errstr(cli));
+                         nt_errstr(status));
                 return -1;
         }
@@ -247 +355 @@
         }
 
-        if (!NT_STATUS_IS_OK(cli_get_quota_handle(cli, &quota_fnum))) {
+        status = cli_get_quota_handle(cli, &quota_fnum);
+        if (!NT_STATUS_IS_OK(status)) {
                 d_printf("Quotas are not enabled on this share.\n");
                 d_printf("Failed to open %s  %s.\n",
-                        FAKE_FILE_NAME_QUOTA_WIN32,cli_errstr(cli));
+                         FAKE_FILE_NAME_QUOTA_WIN32,
+                         nt_errstr(status));
                 return -1;
         }
@@ -263 +373 @@
                         switch(cmd) {
                                 case QUOTA_GET:
-                                        if (!cli_get_user_quota(cli, quota_fnum, &qt)) {
+                                        status = cli_get_user_quota(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_user_quota %s\n",
-                                                         cli_errstr(cli),username_str);
+                                                         nt_errstr(status),
+                                                         username_str);
                                                 return -1;
                                         }
@@ -272 +385 @@
                                 case QUOTA_SETLIM:
                                         pqt->sid = qt.sid;
-                                        if (!cli_set_user_quota(cli, quota_fnum, pqt)) {
+                                        status = cli_set_user_quota(
+                                                cli, quota_fnum, pqt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_set_user_quota %s\n",
-                                                         cli_errstr(cli),username_str);
-                                                return -1;
-                                        }
-                                        if (!cli_get_user_quota(cli, quota_fnum, &qt)) {
+                                                         nt_errstr(status),
+                                                         username_str);
+                                                return -1;
+                                        }
+                                        status = cli_get_user_quota(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_user_quota %s\n",
-                                                         cli_errstr(cli),username_str);
+                                                         nt_errstr(status),
+                                                         username_str);
                                                 return -1;
                                         }
@@ -285 +404 @@
                                         break;
                                 case QUOTA_LIST:
-                                        if (!cli_list_user_quota(cli, quota_fnum, &qtl)) {
+                                        status = cli_list_user_quota(
+                                                cli, quota_fnum, &qtl);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_set_user_quota %s\n",
-                                                         cli_errstr(cli),username_str);
+                                                         nt_errstr(status),
+                                                         username_str);
                                                 return -1;
                                         }
@@ -301 +423 @@
                         switch(cmd) {
                                 case QUOTA_GET:
-                                        if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
+                                        status = cli_get_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_fs_quota_info\n",
-                                                         cli_errstr(cli));
+                                                         nt_errstr(status));
                                                 return -1;
                                         }
@@ -309 +433 @@
                                         break;
                                 case QUOTA_SETLIM:
-                                        if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
+                                        status = cli_get_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_fs_quota_info\n",
-                                                         cli_errstr(cli));
+                                                         nt_errstr(status));
                                                 return -1;
                                         }
                                         qt.softlim = pqt->softlim;
                                         qt.hardlim = pqt->hardlim;
-                                        if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) {
+                                        status = cli_set_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_set_fs_quota_info\n",
-                                                         cli_errstr(cli));
-                                                return -1;
-                                        }
-                                        if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
+                                                         nt_errstr(status));
+                                                return -1;
+                                        }
+                                        status = cli_get_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_fs_quota_info\n",
-                                                         cli_errstr(cli));
+                                                         nt_errstr(status));
                                                 return -1;
                                         }
@@ -329 +459 @@
                                         break;
                                 case QUOTA_SETFLAGS:
-                                        if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
+                                        status = cli_get_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_fs_quota_info\n",
-                                                         cli_errstr(cli));
+                                                         nt_errstr(status));
                                                 return -1;
                                         }
                                         qt.qflags = pqt->qflags;
-                                        if (!cli_set_fs_quota_info(cli, quota_fnum, &qt)) {
+                                        status = cli_set_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_set_fs_quota_info\n",
-                                                         cli_errstr(cli));
-                                                return -1;
-                                        }
-                                        if (!cli_get_fs_quota_info(cli, quota_fnum, &qt)) {
+                                                         nt_errstr(status));
+                                                return -1;
+                                        }
+                                        status = cli_get_fs_quota_info(
+                                                cli, quota_fnum, &qt);
+                                        if (!NT_STATUS_IS_OK(status)) {
                                                 d_printf("%s cli_get_fs_quota_info\n",
-                                                         cli_errstr(cli));
+                                                         nt_errstr(status));
                                                 return -1;
                                         }
@@ -395 +531 @@
                                             get_cmdline_auth_info_password(smbcquotas_auth_info),
                                             flags,
-                                            get_cmdline_auth_info_signing_state(smbcquotas_auth_info),
-                                            NULL);
+                                            get_cmdline_auth_info_signing_state(smbcquotas_auth_info));
         if (!NT_STATUS_IS_OK(nt_status)) {
                 DEBUG(0,("cli_full_connection failed! (%s)\n", nt_errstr(nt_status)));
@@ -460 +595 @@
 
         /* set default debug level to 1 regardless of what smb.conf sets */
-        setup_logging( "smbcquotas", True );
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 1;
-        dbf = x_stderr;
-        x_setbuf( x_stderr, NULL );
+        setup_logging( "smbcquotas", DEBUG_STDERR);
+        lp_set_cmdline("log level", "1");
 
         setlinebuf(stdout);
@@ -608 +741 @@
                         break;
                 default: 
-                        
                         result = EXIT_FAILED;
                         break;

vendor/current/source3/utils/smbfilter.c

@@ -3 +3 @@
    SMB filter/socket plugin
    Copyright (C) Andrew Tridgell 1999
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/select.h"
+#include "../lib/util/select.h"
+#include "libsmb/nmblib.h"
 
 #define SECURITY_MASK 0
@@ -44 +48 @@
         if (write(fd, ppacket, length) != length) {
                 fprintf(stderr,"Failed to write %s\n", fname);
+                close(fd);
                 return;
         }
@@ -190 +195 @@
 
         while (c != -1 || s != -1) {
-                fd_set fds;
-                int num;
-                
-                FD_ZERO(&fds);
-                if (s >= 0 && s < FD_SETSIZE) FD_SET(s, &fds);
-                if (c >= 0 && c < FD_SETSIZE) FD_SET(c, &fds);
-
-                num = sys_select_intr(MAX(s+1, c+1),&fds,NULL,NULL,NULL);
-                if (num <= 0) continue;
-                
-                if (c != -1 && FD_ISSET(c, &fds)) {
+                struct pollfd fds[2];
+                int num_fds, ret;
+
+                memset(fds, 0, sizeof(struct pollfd) * 2);
+                fds[0].fd = -1;
+                fds[1].fd = -1;
+                num_fds = 0;
+
+                if (s != -1) {
+                        fds[num_fds].fd = s;
+                        fds[num_fds].events = POLLIN|POLLHUP;
+                        num_fds += 1;
+                }
+                if (c != -1) {
+                        fds[num_fds].fd = c;
+                        fds[num_fds].events = POLLIN|POLLHUP;
+                        num_fds += 1;
+                }
+
+                ret = sys_poll_intr(fds, num_fds, -1);
+                if (ret <= 0) {
+                        continue;
+                }
+
+                /*
+                 * find c in fds and see if it's readable
+                 */
+                if ((c != -1) &&
+                    (((fds[0].fd == c)
+                      && (fds[0].revents & (POLLIN|POLLHUP|POLLERR))) ||
+                     ((fds[1].fd == c)
+                      && (fds[1].revents & (POLLIN|POLLHUP|POLLERR))))) {
                         size_t len;
                         if (!NT_STATUS_IS_OK(receive_smb_raw(
@@ -214 +240 @@
                         }                       
                 }
-                if (s != -1 && FD_ISSET(s, &fds)) {
+
+                /*
+                 * find s in fds and see if it's readable
+                 */
+                if ((s != -1) &&
+                    (((fds[0].fd == s)
+                      && (fds[0].revents & (POLLIN|POLLHUP|POLLERR))) ||
+                     ((fds[1].fd == s)
+                      && (fds[1].revents & (POLLIN|POLLHUP|POLLERR))))) {
                         size_t len;
                         if (!NT_STATUS_IS_OK(receive_smb_raw(
@@ -246 +280 @@
         zero_sockaddr(&my_ss);
         s = open_socket_in(SOCK_STREAM, 445, 0, &my_ss, True);
-        
+
         if (s == -1) {
                 d_printf("bind failed\n");
@@ -262 +296 @@
 
         while (1) {
-                fd_set fds;
-                int num;
+                int num, revents;
                 struct sockaddr_storage ss;
                 socklen_t in_addrlen = sizeof(ss);
-                
-                FD_ZERO(&fds);
-                if (s < 0 || s >= FD_SETSIZE) {
-                        break;
-                }
-                FD_SET(s, &fds);
-
-                num = sys_select_intr(s+1,&fds,NULL,NULL,NULL);
-                if (num > 0) {
+
+                num = poll_intr_one_fd(s, POLLIN|POLLHUP, -1, &revents);
+                if ((num > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
                         c = accept(s, (struct sockaddr *)&ss, &in_addrlen);
                         if (c != -1) {
@@ -298 +325 @@
         load_case_tables();
 
-        setup_logging(argv[0],True);
+        setup_logging(argv[0], DEBUG_STDOUT);
 
         configfile = get_dyn_CONFIGFILE();

vendor/current/source3/utils/smbget.c

@@ -8 +8 @@
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
 #include "libsmbclient.h"
 
@@ -50 +52 @@
 static int blocksize = SMB_DEFAULT_BLOCKSIZE;
 
-static int smb_download_file(const char *base, const char *name, int recursive, int resume, char *outfile);
+static int smb_download_file(const char *base, const char *name, int recursive,
+                             int resume, int toplevel, char *outfile);
 
 static int get_num_cols(void)
@@ -75 +78 @@
 static void human_readable(off_t s, char *buffer, int l)
 {
-        if(s > 1024 * 1024 * 1024) snprintf(buffer, l, "%.2fGB",
-                                            1.0 * s / (1024 * 1024 * 1024));
-        else if(s > 1024 * 1024) snprintf(buffer, l, "%.2fMB",
-                                          1.0 * s / (1024 * 1024));
-        else if(s > 1024) snprintf(buffer, l, "%.2fkB", 1.0 * s / 1024);
-        else snprintf(buffer, l, OFF_T_FORMAT"b", (OFF_T_FORMAT_CAST)s);
+        if (s > 1024 * 1024 * 1024) {
+                snprintf(buffer, l, "%.2fGB", 1.0 * s / (1024 * 1024 * 1024));
+        } else if (s > 1024 * 1024) {
+                snprintf(buffer, l, "%.2fMB", 1.0 * s / (1024 * 1024));
+        } else if (s > 1024) {
+                snprintf(buffer, l, "%.2fkB", 1.0 * s / 1024);
+        } else {
+                snprintf(buffer, l, OFF_T_FORMAT"b", (OFF_T_FORMAT_CAST)s);
+        }
 }
 
@@ -138 +144 @@
         dirhandle = smbc_opendir(path);
         if(dirhandle < 1) {
-                if(errno == ENOTDIR) return smb_download_file(base, name, 1, resume, NULL);
+                if (errno == ENOTDIR) {
+                        return smb_download_file(base, name, 1, resume,
+                                                 0, NULL);
+                }
                 fprintf(stderr, "Can't open directory %s: %s\n", path, strerror(errno));
                 return 1;
@@ -145 +154 @@
         while(*relname == '/')relname++;
         mkdir(relname, 0755);
-        
+
         tmpname = SMB_STRDUP(name);
 
@@ -168 +177 @@
 
                 case SMBC_FILE:
-                        ret = smb_download_file(base, newname, 1, resume, NULL);
+                        ret = smb_download_file(base, newname, 1, resume, 0,
+                                                NULL);
                         break;
 
@@ -182 +192 @@
                         if(!quiet)printf("Ignoring comms share %s\n", dirent->name);
                         break;
-                        
+
                 case SMBC_IPC_SHARE:
                         if(!quiet)printf("Ignoring ipc$ share %s\n", dirent->name);
@@ -201 +211 @@
                         return 1;
                 }
-                
+
                 if(chmod(relname, remotestat.st_mode) < 0) {
                         fprintf(stderr, "Unable to change mode of local dir %s to %o\n", relname,
@@ -250 +260 @@
                 return;
         }
-        
+
         if(columns) {
                 int required = strlen(name), available = columns - len - strlen("[] ");
@@ -269 +279 @@
 /* Return 1 on error, 0 on success. */
 
-static int smb_download_file(const char *base, const char *name, int recursive, int resume, char *outfile) {
+static int smb_download_file(const char *base, const char *name, int recursive,
+                             int resume, int toplevel, char *outfile)
+{
         int remotehandle, localhandle;
-        time_t start_time = time(NULL);
+        time_t start_time = time_mono(NULL);
         const char *newpath;
         char path[SMB_MAXPATHLEN];
@@ -280 +292 @@
 
         snprintf(path, SMB_MAXPATHLEN-1, "%s%s%s", base, (*base && *name && name[0] != '/' && base[strlen(base)-1] != '/')?"/":"", name);
-        
+
         remotehandle = smbc_open(path, O_RDONLY, 0755);
 
@@ -325 +337 @@
         } else newpath = name;
 
-        if(newpath[0] == '/')newpath++;
-        
+        if (!toplevel && (newpath[0] == '/')) {
+                newpath++;
+        }
+
         /* Open local file according to the mode */
         if(update) {
@@ -353 +367 @@
                         return 1;
                 }
-        
+
                 if (fstat(localhandle, &localstat) != 0) {
                         fprintf(stderr, "Can't fstat %s: %s\n", newpath, strerror(errno));
@@ -404 +418 @@
                                         (OFF_T_FORMAT_CAST)off1,
                                         (OFF_T_FORMAT_CAST)off2);
+                                smbc_close(remotehandle); close(localhandle);
                                 return 1;
                         }
@@ -435 +450 @@
 
         readbuf = (char *)SMB_MALLOC(blocksize);
+        if (!readbuf) {
+                return 1;
+        }
 
         /* Now, download all bytes from offset_download to the end */
@@ -459 +477 @@
                 if(dots)fputc('.', stderr);
                 else if(!quiet) {
-                        print_progress(newpath, start_time, time(NULL), start_offset, curpos, remotestat.st_size);
+                        print_progress(newpath, start_time, time_mono(NULL),
+                                        start_offset, curpos, remotestat.st_size);
                 }
         }
@@ -499 +518 @@
         human_readable(total_bytes, bs, sizeof(bs));
         if(!quiet)fprintf(stderr, "Downloaded %s in %lu seconds\n", bs,
-                (unsigned long)(time(NULL) - total_start_time));
+                (unsigned long)(time_mono(NULL) - total_start_time));
         exit(0);
 }
@@ -655 +674 @@
                         "require");
         }
-        
+
         columns = get_num_cols();
 
-        total_start_time = time(NULL);
+        total_start_time = time_mono(NULL);
 
         while ( (file = poptGetArg(pc)) ) {
                 if (!recursive) 
-                        ret = smb_download_file(file, "", recursive, resume, outputfile);
+                        ret = smb_download_file(file, "", recursive, resume,
+                                                1, outputfile);
                 else 
                         ret = smb_download_dir(file, "", resume);

vendor/current/source3/utils/smbpasswd.c

@@ -18 +18 @@
 
 #include "includes.h"
-
-extern bool AllowDebugChange;
+#include "system/passwd.h"
+#include "secrets.h"
+#include "../librpc/gen_ndr/samr.h"
+#include "../lib/util/util_pw.h"
+#include "passdb.h"
 
 /*
@@ -153 +156 @@
                         break;
                 case 'D':
-                        DEBUGLEVEL = atoi(optarg);
+                        lp_set_cmdline("log level", optarg);
                         break;
                 case 'U': {
@@ -341 +344 @@
         }
 
-        if (!user_name[0] && (pwd = getpwuid_alloc(talloc_autofree_context(), geteuid()))) {
+        if (!user_name[0] && (pwd = getpwuid_alloc(talloc_tos(), geteuid()))) {
                 fstrcpy(user_name, pwd->pw_name);
                 TALLOC_FREE(pwd);
@@ -506 +509 @@
 
         if (!user_name[0]) {
-                pwd = getpwuid_alloc(talloc_autofree_context(), getuid());
+                pwd = getpwuid_alloc(talloc_tos(), getuid());
                 if (pwd) {
                         fstrcpy(user_name,pwd->pw_name);
@@ -569 +572 @@
         int ret;
 
-        AllowDebugChange = False;
-
 #if defined(HAVE_SET_AUTH_PARAMETERS)
         set_auth_parameters(argc, argv);
@@ -583 +584 @@
         local_flags = process_options(argc, argv, local_flags);
 
-        setup_logging("smbpasswd", True);
+        setup_logging("smbpasswd", DEBUG_STDERR);
 
         /*

vendor/current/source3/utils/smbtree.c

@@ -21 +21 @@
 
 #include "includes.h"
-#include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "popt_common.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
 
 static int use_bcast;
@@ -158 +162 @@
         uint32_t resume_handle = 0;
         uint32_t total_entries = 0;
+        struct dcerpc_binding_handle *b;
 
         mem_ctx = talloc_new(NULL);
@@ -175 +180 @@
         }
 
+        b = pipe_hnd->binding_handle;
+
         ZERO_STRUCT(info_ctr);
         ZERO_STRUCT(ctr1);
@@ -181 +188 @@
         info_ctr.ctr.ctr1 = &ctr1;
 
-        status = rpccli_srvsvc_NetShareEnumAll(pipe_hnd, mem_ctx,
+        status = dcerpc_srvsvc_NetShareEnumAll(b, mem_ctx,
                                                pipe_hnd->desthost,
                                                &info_ctr,
@@ -291 +298 @@
         setlinebuf(stdout);
 
-        dbf = x_stderr;
-
-        setup_logging(argv[0],True);
+        setup_logging(argv[0], DEBUG_STDERR);
 
         auth_info = user_auth_info_init(frame);

vendor/current/source3/utils/status.c

@@ -32 +32 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
+#include "dbwrap.h"
+#include "../libcli/security/security.h"
+#include "session.h"
+#include "locking/proto.h"
+#include "messages.h"
 
 #define SMB_MAXPIDS             2048
@@ -233 +240 @@
 }
 
-static int traverse_fn1(struct db_record *rec,
-                        const struct connections_key *key,
+static int traverse_fn1(const struct connections_key *key,
                         const struct connections_data *crec,
                         void *state)
@@ -253 +259 @@
 }
 
-static int traverse_sessionid(struct db_record *db, void *state)
-{
-        struct sessionid sessionid;
+static int traverse_sessionid(const char *key, struct sessionid *session,
+                              void *private_data)
+{
         fstring uid_str, gid_str;
 
-        if (db->value.dsize != sizeof(sessionid))
+        if (!process_exists(session->pid)
+            || !Ucrit_checkUid(session->uid)) {
                 return 0;
-
-        memcpy(&sessionid, db->value.dptr, sizeof(sessionid));
-
-        if (!process_exists(sessionid.pid) || !Ucrit_checkUid(sessionid.uid)) {
-                return 0;
-        }
-
-        Ucrit_addPid( sessionid.pid );
-
-        fstr_sprintf(uid_str, "%u", (unsigned int)sessionid.uid);
-        fstr_sprintf(gid_str, "%u", (unsigned int)sessionid.gid);
+        }
+
+        Ucrit_addPid(session->pid);
+
+        fstr_sprintf(uid_str, "%u", (unsigned int)session->uid);
+        fstr_sprintf(gid_str, "%u", (unsigned int)session->gid);
 
         d_printf("%-7s   %-12s  %-12s  %-12s (%s)\n",
-                 procid_str_static(&sessionid.pid),
-                 numeric_only ? uid_str : uidtoname(sessionid.uid),
-                 numeric_only ? gid_str : gidtoname(sessionid.gid), 
-                 sessionid.remote_machine, sessionid.hostname);
+                 procid_str_static(&session->pid),
+                 numeric_only ? uid_str : uidtoname(session->uid),
+                 numeric_only ? gid_str : gidtoname(session->gid),
+                 session->remote_machine, session->hostname);
 
         return 0;
@@ -312 +314 @@
         load_case_tables();
 
-        setup_logging(argv[0],True);
-
-        dbf = x_stderr;
+        setup_logging(argv[0], DEBUG_STDERR);
 
         if (getuid() != geteuid()) {
@@ -413 +413 @@
 
         if ( show_processes ) {
-                struct db_context *db;
-                db = db_open(NULL, lock_path("sessionid.tdb"), 0,
-                             TDB_CLEAR_IF_FIRST, O_RDONLY, 0644);
-                if (!db) {
-                        d_printf("sessionid.tdb not initialised\n");
-                } else {
-                        d_printf("\nSamba version %s\n",samba_version_string());
-                        d_printf("PID     Username      Group         Machine                        \n");
-                        d_printf("-------------------------------------------------------------------\n");
-                        if (lp_security() == SEC_SHARE) {
-                                d_printf(" <processes do not show up in "
-                                    "anonymous mode>\n");
-                        }
-
-                        db->traverse_read(db, traverse_sessionid, NULL);
-                        TALLOC_FREE(db);
-                }
+                d_printf("\nSamba version %s\n",samba_version_string());
+                d_printf("PID     Username      Group         Machine                        \n");
+                d_printf("-------------------------------------------------------------------\n");
+                if (lp_security() == SEC_SHARE) {
+                        d_printf(" <processes do not show up in "
+                                 "anonymous mode>\n");
+                }
+
+                sessionid_traverse_read(traverse_sessionid, NULL);
 
                 if (processes_only) {
@@ -448 +440 @@
                 d_printf("-------------------------------------------------------\n");
 
-                connections_forall(traverse_fn1, NULL);
+                connections_forall_read(traverse_fn1, NULL);
 
                 d_printf("\n");
@@ -461 +453 @@
                 struct db_context *db;
                 db = db_open(NULL, lock_path("locking.tdb"), 0,
-                             TDB_CLEAR_IF_FIRST, O_RDONLY, 0);
+                             TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDONLY, 0);
 
                 if (!db) {

vendor/current/source3/utils/status_profile.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbprofile.h"
 
 bool status_profile_dump(bool be_verbose);
@@ -58 +59 @@
         d_printf("opendir_count:                  %u\n", profile_p->syscall_opendir_count);
         d_printf("opendir_time:                   %u\n", profile_p->syscall_opendir_time);
+        d_printf("fdopendir_count:                %u\n", profile_p->syscall_fdopendir_count);
+        d_printf("fdopendir_time:                 %u\n", profile_p->syscall_fdopendir_time);
         d_printf("readdir_count:                  %u\n", profile_p->syscall_readdir_count);
         d_printf("readdir_time:                   %u\n", profile_p->syscall_readdir_time);
@@ -82 +85 @@
         d_printf("pwrite_time:                    %u\n", profile_p->syscall_pwrite_time);
         d_printf("pwrite_bytes:                   %u\n", profile_p->syscall_pwrite_bytes);
-#ifdef WITH_SENDFILE
         d_printf("sendfile_count:                 %u\n", profile_p->syscall_sendfile_count);
         d_printf("sendfile_time:                  %u\n", profile_p->syscall_sendfile_time);
         d_printf("sendfile_bytes:                 %u\n", profile_p->syscall_sendfile_bytes);
-#endif
         d_printf("lseek_count:                    %u\n", profile_p->syscall_lseek_count);
         d_printf("lseek_time:                     %u\n", profile_p->syscall_lseek_time);
@@ -401 +402 @@
         d_printf("election_count:                 %u\n", profile_p->election_count);
         d_printf("election_time:                  %u\n", profile_p->election_time);
+        profile_separator("SMB2 Calls");
+        d_printf("smb2_negprot_count:             %u\n", profile_p->smb2_negprot_count);
+        d_printf("smb2_negprot_time:              %u\n", profile_p->smb2_negprot_time);
+        d_printf("smb2_sesssetup_count:           %u\n", profile_p->smb2_sesssetup_count);
+        d_printf("smb2_sesssetup_time:            %u\n", profile_p->smb2_sesssetup_time);
+        d_printf("smb2_logoff_count:              %u\n", profile_p->smb2_logoff_count);
+        d_printf("smb2_logoff_time:               %u\n", profile_p->smb2_logoff_time);
+        d_printf("smb2_tcon_count:                %u\n", profile_p->smb2_tcon_count);
+        d_printf("smb2_tcon_time:                 %u\n", profile_p->smb2_tcon_time);
+        d_printf("smb2_tdis_count:                %u\n", profile_p->smb2_tdis_count);
+        d_printf("smb2_tdis_time:                 %u\n", profile_p->smb2_tdis_time);
+        d_printf("smb2_create_count:              %u\n", profile_p->smb2_create_count);
+        d_printf("smb2_create_time:               %u\n", profile_p->smb2_create_time);
+        d_printf("smb2_close_count:               %u\n", profile_p->smb2_close_count);
+        d_printf("smb2_close_time:                %u\n", profile_p->smb2_close_time);
+        d_printf("smb2_flush_count:               %u\n", profile_p->smb2_flush_count);
+        d_printf("smb2_flush_time:                %u\n", profile_p->smb2_flush_time);
+        d_printf("smb2_read_count:                %u\n", profile_p->smb2_read_count);
+        d_printf("smb2_read_time:                 %u\n", profile_p->smb2_read_time);
+        d_printf("smb2_write_count:               %u\n", profile_p->smb2_write_count);
+        d_printf("smb2_write_time:                %u\n", profile_p->smb2_write_time);
+        d_printf("smb2_lock_count:                %u\n", profile_p->smb2_lock_count);
+        d_printf("smb2_lock_time:                 %u\n", profile_p->smb2_lock_time);
+        d_printf("smb2_ioctl_count:               %u\n", profile_p->smb2_ioctl_count);
+        d_printf("smb2_ioctl_time:                %u\n", profile_p->smb2_ioctl_time);
+        d_printf("smb2_cancel_count:              %u\n", profile_p->smb2_cancel_count);
+        d_printf("smb2_cancel_time:               %u\n", profile_p->smb2_cancel_time);
+        d_printf("smb2_keepalive_count:           %u\n", profile_p->smb2_keepalive_count);
+        d_printf("smb2_keepalive_time:            %u\n", profile_p->smb2_keepalive_time);
+        d_printf("smb2_find_count:                %u\n", profile_p->smb2_find_count);
+        d_printf("smb2_find_time:                 %u\n", profile_p->smb2_find_time);
+        d_printf("smb2_notify_count:              %u\n", profile_p->smb2_notify_count);
+        d_printf("smb2_notify_time:               %u\n", profile_p->smb2_notify_time);
+        d_printf("smb2_getinfo_count:             %u\n", profile_p->smb2_getinfo_count);
+        d_printf("smb2_getinfo_time:              %u\n", profile_p->smb2_getinfo_time);
+        d_printf("smb2_setinfo_count:             %u\n", profile_p->smb2_setinfo_count);
+        d_printf("smb2_setinfo_time:              %u\n", profile_p->smb2_setinfo_time);
+        d_printf("smb2_break_count:               %u\n", profile_p->smb2_break_count);
+        d_printf("smb2_break_time:                %u\n", profile_p->smb2_break_time);
+
 #else /* WITH_PROFILE */
+
         fprintf(stderr, "Profile data unavailable\n");
 #endif /* WITH_PROFILE */

vendor/current/source3/utils/testparm.c

@@ -33 +33 @@
 
 #include "includes.h"
-
-extern bool AllowDebugChange;
+#include "system/filesys.h"
+#include "popt_common.h"
 
 /*******************************************************************
@@ -78 +78 @@
         }
 
+        if (strequal(lp_workgroup(), global_myname())) {
+                fprintf(stderr, "WARNING: 'workgroup' and 'netbios name' " \
+                        "must differ.\n");
+                ret = 1;
+        }
+
         if (!directory_exist_stat(lp_lockdir(), &st)) {
                 fprintf(stderr, "ERROR: lock directory %s does not exist\n",
@@ -123 +129 @@
          */
 
-        if((lp_security() == SEC_SERVER || lp_security() >= SEC_DOMAIN) && !lp_passwordserver()) {
+        if((lp_security() == SEC_SERVER || lp_security() >= SEC_DOMAIN) && !*lp_passwordserver()) {
                 const char *sec_setting;
                 if(lp_security() == SEC_SERVER)
@@ -129 +135 @@
                 else if(lp_security() == SEC_DOMAIN)
                         sec_setting = "domain";
+                else if(lp_security() == SEC_ADS)
+                        sec_setting = "ads";
                 else
                         sec_setting = "";
 
-                fprintf(stderr, "ERROR: The setting 'security=%s' requires the 'password server' parameter be set \
-to a valid password server.\n", sec_setting );
-                ret = 1;
+                fprintf(stderr, "ERROR: The setting 'security=%s' requires the 'password server' parameter be set\n"
+                        "to the default value * or a valid password server.\n", sec_setting );
+                ret = 1;
+        }
+
+        if((lp_security() >= SEC_DOMAIN) && (strcmp(lp_passwordserver(), "*") != 0)) {
+                const char *sec_setting;
+                if(lp_security() == SEC_DOMAIN)
+                        sec_setting = "domain";
+                else if(lp_security() == SEC_ADS)
+                        sec_setting = "ads";
+                else
+                        sec_setting = "";
+
+                fprintf(stderr, "WARNING: The setting 'security=%s' should NOT be combined with the 'password server' parameter.\n"
+                        "(by default Samba will discover the correct DC to contact automatically).\n", sec_setting );
         }
 
@@ -320 +341 @@
         static char *parameter_name = NULL;
         static const char *section_name = NULL;
-        static char *new_local_machine = NULL;
         const char *cname;
         const char *caddr;
@@ -330 +350 @@
                 {"suppress-prompt", 's', POPT_ARG_VAL, &silent_mode, 1, "Suppress prompt for enter"},
                 {"verbose", 'v', POPT_ARG_NONE, &show_defaults, 1, "Show default options too"},
-                {"server", 'L',POPT_ARG_STRING, &new_local_machine, 0, "Set %%L macro to servername\n"},
                 {"skip-logic-checks", 'l', POPT_ARG_NONE, &skip_logic_checks, 1, "Skip the global checks"},
                 {"show-all-parameters", '\0', POPT_ARG_VAL, &show_all_parameters, True, "Show the parameters, type, possible values" },
@@ -337 +356 @@
                 POPT_COMMON_VERSION
                 POPT_COMMON_DEBUGLEVEL
+                POPT_COMMON_OPTION
                 POPT_TABLEEND
         };
@@ -348 +368 @@
          * not by smb.conf.
          */
-        DEBUGLEVEL_CLASS[DBGC_ALL] = 2;
+        lp_set_cmdline("log level", "2");
 
         pc = poptGetContext(NULL, argc, argv, long_options, 
@@ -361 +381 @@
         }
 
-        setup_logging(poptGetArg(pc), True);
+        setup_logging(poptGetArg(pc), DEBUG_STDERR);
 
         if (poptPeekArg(pc)) 
@@ -376 +396 @@
                 goto done;
         }
-
-        if (new_local_machine) {
-                set_local_machine_name(new_local_machine, True);
-        }
-
-        dbf = x_stderr;
-        /* Don't let the debuglevel be changed by smb.conf. */
-        AllowDebugChange = False;
 
         fprintf(stderr,"Load smb config files from %s\n",config_file);