Changeset 745 for trunk/server/source3/lib

trunk/server

Property svn:mergeinfo changed
/vendor/current merged: 581,587,591,594,597,600,615,618,740

trunk/server/source3/lib/access.c

-              r599
+              r745
 #include "includes.h"
+#include "memcache.h"
+#include "interfaces.h"
 #define NAME_INDEX 0
 …
+        }
+        return same_net((struct sockaddr *)&ss_host, (struct sockaddr *)&ss_tok, (struct sockaddr *)&ss_mask);
+        return same_net((struct sockaddr *)(void *)&ss_host,
+                        (struct sockaddr *)(void *)&ss_tok,
+                        (struct sockaddr *)(void *)&ss_mask);
+}
 …
         ret = allow_access_internal(deny_list, allow_list, nc_cname, nc_caddr);
+        DEBUG(ret ? 3 : 0,
+              ("%s connection from %s (%s)\n",
+               ret ? "Allowed" : "Denied", nc_cname, nc_caddr));
         SAFE_FREE(nc_cname);
         SAFE_FREE(nc_caddr);
         return ret;
+}
-/* return true if the char* contains ip addrs only.  Used to avoid
-name lookup calls */
-static bool only_ipaddrs_in_list(const char **list)
+{
-        bool only_ip = true;
-        if (!list) {
-                return true;
+        }
-        for (; *list ; list++) {
-                /* factor out the special strings */
-                if (strequal(*list, "ALL") || strequal(*list, "FAIL") ||
-                    strequal(*list, "EXCEPT")) {
-                        continue;
+                }
-                if (!is_ipaddress(*list)) {
-                        /*
-                         * If we failed, make sure that it was not because
-                         * the token was a network/netmask pair. Only
-                         * network/netmask pairs have a '/' in them.
-                         */
-                        if ((strchr_m(*list, '/')) == NULL) {
-                                only_ip = false;
-                                DEBUG(3,("only_ipaddrs_in_list: list has "
-                                        "non-ip address (%s)\n",
-                                        *list));
-                                break;
+                        }
+                }
+        }
-        return only_ip;
+}
-/* return true if access should be allowed to a service for a socket */
-bool check_access(int sock, const char **allow_list, const char **deny_list)
+{
-        bool ret = false;
-        bool only_ip = false;
-        if ((!deny_list || *deny_list==0) && (!allow_list || *allow_list==0))
-                ret = true;
-        if (!ret) {
-                char addr[INET6_ADDRSTRLEN];
-                /* Bypass name resolution calls if the lists
-                 * only contain IP addrs */
-                if (only_ipaddrs_in_list(allow_list) &&
-                                only_ipaddrs_in_list(deny_list)) {
-                        only_ip = true;
-                        DEBUG (3, ("check_access: no hostnames "
-                                "in host allow/deny list.\n"));
-                        ret = allow_access(deny_list,
-                                        allow_list,
-                                        "",
-                                        get_peer_addr(sock,addr,sizeof(addr)));
-                } else {
-                        DEBUG (3, ("check_access: hostnames in "
-                                "host allow/deny list.\n"));
-                        ret = allow_access(deny_list,
-                                        allow_list,
-                                        get_peer_name(sock,true),
-                                        get_peer_addr(sock,addr,sizeof(addr)));
+                }
-                if (ret) {
-                        DEBUG(2,("Allowed connection from %s (%s)\n",
-                                 only_ip ? "" : get_peer_name(sock,true),
-                                 get_peer_addr(sock,addr,sizeof(addr))));
-                } else {
-                        DEBUG(0,("Denied connection from %s (%s)\n",
-                                 only_ip ? "" : get_peer_name(sock,true),
-                                 get_peer_addr(sock,addr,sizeof(addr))));
+                }
+        }
-        return(ret);
+}

trunk/server/source3/lib/adt_tree.c

-              r414
+              r745
 #include "adt_tree.h"
+struct tree_node {
+        struct tree_node        *parent;
+        struct tree_node        **children;
+        int                     num_children;
+        char                    *key;
+        void                    *data_p;
+};
+struct sorted_tree {
+        struct tree_node *root;
+};
 /**************************************************************************
 …
+{
         char *p;
         *new_path = *base = NULL;
         if ( !path )
                 return False;
         *base = path;
         p = strchr( path, '/' );
+        p = strchr( path, '\\' );
         if ( p ) {
                 *p = '\0';
                 *new_path = p+1;
+        }
         return True;
+}
+/**************************************************************************
+ Initialize the tree's root.  The cmp_fn is a callback function used
+ for comparision of two children
+ *************************************************************************/
+ SORTED_TREE* pathtree_init( void *data_p, int (cmp_fn)(void*, void*) )
+{
+        SORTED_TREE *tree = NULL;
+        if ( !(tree = TALLOC_ZERO_P(NULL, SORTED_TREE)) )
+                return NULL;
+        tree->compare = cmp_fn;
+        if ( !(tree->root = TALLOC_ZERO_P(tree, TREE_NODE)) ) {
+/**************************************************************************
+ Initialize the tree's root.
+ *************************************************************************/
+struct sorted_tree *pathtree_init(void *data_p)
+{
+        struct sorted_tree *tree = NULL;
+        tree = talloc_zero(NULL, struct sorted_tree);
+        if (tree == NULL) {
+                return NULL;
+        }
+        tree->root = talloc_zero(tree, struct tree_node);
+        if (tree->root == NULL) {
                 TALLOC_FREE( tree );
                 return NULL;
+        }
         tree->root->data_p = data_p;
         return tree;
+}
 …
  *************************************************************************/
+static TREE_NODE* pathtree_birth_child( TREE_NODE *node, char* key )
+{
+        TREE_NODE *infant = NULL;
+        TREE_NODE **siblings;
+static struct tree_node *pathtree_birth_child(struct tree_node *node,
+                                              char* key )
+{
+        struct tree_node *infant = NULL;
+        struct tree_node **siblings;
         int i;
+        if ( !(infant = TALLOC_ZERO_P( node, TREE_NODE)) )
+                return NULL;
+        infant = talloc_zero(node, struct tree_node);
+        if (infant == NULL) {
+                return NULL;
+        }
         infant->key = talloc_strdup( infant, key );
         infant->parent = node;
+        siblings = TALLOC_REALLOC_ARRAY( node, node->children, TREE_NODE *, node->num_children+1 );
+        siblings = talloc_realloc(node, node->children, struct tree_node *,
+                                  node->num_children+1);
         if ( siblings )
                 node->children = siblings;
         node->num_children++;
         /* first child */
         if ( node->num_children == 1 ) {
                 DEBUG(11,("pathtree_birth_child: First child of node [%s]! [%s]\n",
 …
                  * from left to right
                  */
                 for ( i = node->num_children-1; i>=1; i-- )
+                {
                         DEBUG(11,("pathtree_birth_child: Looking for crib; infant -> [%s], child -> [%s]\n",
                                 infant->key, node->children[i-1]->key));
                         /* the strings should never match assuming that we
                            have called pathtree_find_child() first */
                         if ( StrCaseCmp( infant->key, node->children[i-1]->key ) > 0 ) {
                                 DEBUG(11,("pathtree_birth_child: storing infant in i == [%d]\n",
 …
                                 break;
+                        }
                         /* bump everything towards the end on slot */
                         node->children[i] = node->children[i-1];
+                }
                 DEBUG(11,("pathtree_birth_child: Exiting loop (i == [%d])\n", i ));
                 /* if we haven't found the correct slot yet, the child
                    will be first in the list */
                 if ( i == 0 )
                         node->children[0] = infant;
 …
  *************************************************************************/
+static TREE_NODE* pathtree_find_child( TREE_NODE *node, char* key )
+{
+        TREE_NODE *next = NULL;
+static struct tree_node *pathtree_find_child(struct tree_node *node,
+                                             char *key )
+{
+        struct tree_node *next = NULL;
         int i, result;
         if ( !node ) {
                 DEBUG(0,("pathtree_find_child: NULL node passed into function!\n"));
                 return NULL;
+        }
         if ( !key ) {
                 DEBUG(0,("pathtree_find_child: NULL key string passed into function!\n"));
                 return NULL;
+        }
         for ( i=0; i<node->num_children; i++ )
+        {
                 DEBUG(11,("pathtree_find_child: child key => [%s]\n",
                         node->children[i]->key));
                 result = StrCaseCmp( node->children[i]->key, key );
                 if ( result == 0 )
                         next = node->children[i];
                 /* if result > 0 then we've gone to far because
                    the list of children is sorted by key name
                    If result == 0, then we have a match         */
                 if ( result > 0 )
                         break;
 …
         DEBUG(11,("pathtree_find_child: %s [%s]\n",
                 next ? "Found" : "Did not find", key ));
         return next;
+}
 …
  *************************************************************************/
  WERROR pathtree_add( SORTED_TREE *tree, const char *path, void *data_p )
+WERROR pathtree_add(struct sorted_tree *tree, const char *path, void *data_p)
+{
         char *str, *base, *path2;
         TREE_NODE *current, *next;
+        struct tree_node *current, *next;
         WERROR ret = WERR_OK;
         DEBUG(8,("pathtree_add: Enter\n"));
         if ( !path || *path != '/' ) {
+        if ( !path || *path != '\\' ) {
                 DEBUG(0,("pathtree_add: Attempt to add a node with a bad path [%s]\n",
                         path ? path : "NULL" ));
                 return WERR_INVALID_PARAM;
+        }
         if ( !tree ) {
                 DEBUG(0,("pathtree_add: Attempt to add a node to an uninitialized tree!\n"));
                 return WERR_INVALID_PARAM;
+        }
         /* move past the first '/' */
+        /* move past the first '\\' */
         path++;
         path2 = SMB_STRDUP( path );
 …
                 return WERR_NOMEM;
+        }
         /*
 …
          * The path should be of the form /<key1>/<key2>/...
          */
         base = path2;
         str  = path2;
         current = tree->root;
         do {
                 /* break off the remaining part of the path */
                 str = strchr( str, '/' );
+                str = strchr( str, '\\' );
                 if ( str )
                         *str = '\0';
                 /* iterate to the next child--birth it if necessary */
                 next = pathtree_find_child( current, base );
                 if ( !next ) {
 …
+                }
                 current = next;
                 /* setup the next part of the path */
                 base = str;
                 if ( base ) {
                         *base = '/';
+                        *base = '\\';
                         base++;
                         str = base;
+                }
         } while ( base != NULL );
         current->data_p = data_p;
         DEBUG(10,("pathtree_add: Successfully added node [%s] to tree\n",
                 path ));
 …
 /**************************************************************************
  Recursive routine to print out all children of a TREE_NODE
+ Recursive routine to print out all children of a struct tree_node
  *************************************************************************/
 static void pathtree_print_children(TALLOC_CTX *ctx,
                                 TREE_NODE *node,
+                                struct tree_node *node,
                                 int debug,
                                 const char *path )
 …
  *************************************************************************/
  void pathtree_print_keys( SORTED_TREE *tree, int debug )
+void pathtree_print_keys(struct sorted_tree *tree, int debug )
+{
         int i;
 …
  *************************************************************************/
  void* pathtree_find( SORTED_TREE *tree, char *key )
+void* pathtree_find(struct sorted_tree *tree, char *key )
+{
         char *keystr, *base = NULL, *str = NULL, *p;
         TREE_NODE *current;
+        struct tree_node *current;
         void *result = NULL;
         DEBUG(10,("pathtree_find: Enter [%s]\n", key ? key : "NULL" ));
         /* sanity checks first */
         if ( !key ) {
                 DEBUG(0,("pathtree_find: Attempt to search tree using NULL search string!\n"));
                 return NULL;
+        }
         if ( !tree ) {
                 DEBUG(0,("pathtree_find: Attempt to search an uninitialized tree using string [%s]!\n",
 …
                 return NULL;
+        }
         if ( !tree->root )
                 return NULL;
         /* make a copy to play with */
         if ( *key == '/' )
+        if ( *key == '\\' )
                 keystr = SMB_STRDUP( key+1 );
         else
                 keystr = SMB_STRDUP( key );
         if ( !keystr ) {
                 DEBUG(0,("pathtree_find: strdup() failed on string [%s]!?!?!\n", key));
 …
         /* start breaking the path apart */
         p = keystr;
         current = tree->root;
         if ( tree->root->data_p )
                 result = tree->root->data_p;
         do
+        {
 …
                 trim_tree_keypath( p, &base, &str );
                 DEBUG(11,("pathtree_find: [loop] base => [%s], new_path => [%s]\n",
                         base ? base : "",
 …
                 /* iterate to the next child */
                 current = pathtree_find_child( current, base );
                 /*
                  * the idea is that the data_p for a parent should
 …
                  * overridden farther down
                  */
                 if ( current && current->data_p )
                         result = current->data_p;
 …
                 p = str;
         } while ( str && current );
         /* result should be the data_p from the lowest match node in the tree */
         if ( result )
                 DEBUG(11,("pathtree_find: Found data_p!\n"));
         SAFE_FREE( keystr );
         DEBUG(10,("pathtree_find: Exit\n"));
         return result;
+}

trunk/server/source3/lib/afs.c

-              r414
+              r745
 #define NO_ASN1_TYPEDEFS 1
+#include "secrets.h"
+#include "passdb.h"
+#include "auth.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
 #include <afs/param.h>
 #include <afs/stds.h>
 …
         bool result;
         char *ticket_str = NULL;
         const DOM_SID *user_sid;
+        const struct dom_sid *user_sid;
         TALLOC_CTX *ctx = talloc_tos();
 …
         afs_username = talloc_sub_advanced(ctx,
+                                SNUM(conn), conn->server_info->unix_name,
+                                conn->connectpath, conn->server_info->utok.gid,
+                                conn->server_info->sanitized_username,
+                                pdb_get_domain(conn->server_info->sam_account),
+                                lp_servicename(SNUM(conn)),
+                                conn->session_info->unix_name,
+                                conn->connectpath, conn->session_info->utok.gid,
+                                conn->session_info->sanitized_username,
+                                conn->session_info->info3->base.domain.string,
                                 afs_username);
         if (!afs_username) {
 …
+        }
         user_sid = &conn->server_info->ptok->user_sids[0];
+        user_sid = &conn->session_info->security_token->sids[0];
         afs_username = talloc_string_sub(talloc_tos(),
                                         afs_username,

trunk/server/source3/lib/afs_settoken.c

-              r414
+              r745
 #define NO_ASN1_TYPEDEFS 1
+#include "system/filesys.h"
 #include <afs/param.h>
 #include <afs/stds.h>
 …
                 return False;
         if (geteuid() != 0)
+        if (geteuid() != sec_initial_uid())
                 ct.ViceId = getuid();

trunk/server/source3/lib/audit.c

r414	r745
19	19
20	20	#include "includes.h"
	21	#include "../librpc/gen_ndr/lsa.h"
21	22
22	23	static const struct audit_category_tab {

trunk/server/source3/lib/bitmap.c

-              r414
+              r745
 /****************************************************************************
-allocate a bitmap of the specified size
-****************************************************************************/
-struct bitmap *bitmap_allocate(int n)
+{
-        struct bitmap *bm;
-        bm = SMB_MALLOC_P(struct bitmap);
-        if (!bm) return NULL;
-        bm->n = n;
-        bm->b = SMB_MALLOC_ARRAY(uint32, (n+31)/32);
-        if (!bm->b) {
-                SAFE_FREE(bm);
-                return NULL;
+        }
-        memset(bm->b, 0, sizeof(uint32)*((n+31)/32));
-        return bm;
+}
-/****************************************************************************
-free a bitmap.
-****************************************************************************/
-void bitmap_free(struct bitmap *bm)
+{
-        if (!bm)
-                return;
-        SAFE_FREE(bm->b);
-        SAFE_FREE(bm);
+}
-/****************************************************************************
 talloc a bitmap
 ****************************************************************************/
 …
         struct bitmap *bm;
-        if (!mem_ctx) return NULL;
         bm = TALLOC_P(mem_ctx, struct bitmap);
 …
         bm->n = n;
         bm->b = TALLOC_ARRAY(mem_ctx, uint32, (n+31)/32);
+        bm->b = TALLOC_ZERO_ARRAY(bm, uint32, (n+31)/32);
         if (!bm->b) {
+                TALLOC_FREE(bm);
                 return NULL;
+        }
-        memset(bm->b, 0, sizeof(uint32)*((n+31)/32));
         return bm;
+}

trunk/server/source3/lib/charcnv.c

-              r599
+              r745
-static smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
 static bool conv_silent; /* Should we do a debug if the conversion fails ? */
 static bool initialized;
-/**
- * Return the name of a charset to give to iconv().
- **/
-static const char *charset_name(charset_t ch)
+{
-        const char *ret;
-        switch (ch) {
-        case CH_UTF16LE:
-                ret = "UTF-16LE";
-                break;
-        case CH_UTF16BE:
-                ret = "UTF-16BE";
-                break;
-        case CH_UNIX:
-                ret = lp_unix_charset();
-                break;
-        case CH_DOS:
-                ret = lp_dos_charset();
-                break;
-        case CH_DISPLAY:
-                ret = lp_display_charset();
-                break;
-        case CH_UTF8:
-                ret = "UTF8";
-                break;
-        default:
-                ret = NULL;
+        }
-#if defined(HAVE_NL_LANGINFO) && defined(CODESET)
-        if (ret && !strcmp(ret, "LOCALE")) {
-                const char *ln = NULL;
-#ifdef HAVE_SETLOCALE
-                setlocale(LC_ALL, "");
-#endif
-                ln = nl_langinfo(CODESET);
-                if (ln) {
-                        /* Check whether the charset name is supported
-                           by iconv */
-                        smb_iconv_t handle = smb_iconv_open(ln,"UCS-2LE");
-                        if (handle == (smb_iconv_t) -1) {
-                                DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
-                                ln = NULL;
-                        } else {
-                                DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
-                                smb_iconv_close(handle);
+                        }
+                }
-                ret = ln;
+        }
-#endif
-        if (!ret || !*ret) ret = "ASCII";
-        return ret;
+}
 void lazy_initialize_conv(void)
+{
         if (!initialized) {
                 load_case_tables();
+                load_case_tables_library();
                 init_iconv();
                 initialized = true;
 …
 void gfree_charcnv(void)
+{
+        int c1, c2;
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        if ( conv_handles[c1][c2] ) {
+                                smb_iconv_close( conv_handles[c1][c2] );
+                                conv_handles[c1][c2] = 0;
+                        }
+                }
+        }
+        TALLOC_FREE(global_iconv_convenience);
         initialized = false;
+}
 …
 void init_iconv(void)
+{
+        int c1, c2;
+        bool did_reload = False;
+        /* so that charset_name() works we need to get the UNIX<->UCS2 going
+           first */
+        if (!conv_handles[CH_UNIX][CH_UTF16LE])
+                conv_handles[CH_UNIX][CH_UTF16LE] = smb_iconv_open(charset_name(CH_UTF16LE), "ASCII");
+        if (!conv_handles[CH_UTF16LE][CH_UNIX])
+                conv_handles[CH_UTF16LE][CH_UNIX] = smb_iconv_open("ASCII", charset_name(CH_UTF16LE));
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        const char *n1 = charset_name((charset_t)c1);
+                        const char *n2 = charset_name((charset_t)c2);
+                        if (conv_handles[c1][c2] &&
+                            strcmp(n1, conv_handles[c1][c2]->from_name) == 0 &&
+                            strcmp(n2, conv_handles[c1][c2]->to_name) == 0)
+                                continue;
+                        did_reload = True;
+                        if (conv_handles[c1][c2])
+                                smb_iconv_close(conv_handles[c1][c2]);
+                        conv_handles[c1][c2] = smb_iconv_open(n2,n1);
+                        if (conv_handles[c1][c2] == (smb_iconv_t)-1) {
+                                DEBUG(0,("init_iconv: Conversion from %s to %s not supported\n",
+                                         charset_name((charset_t)c1), charset_name((charset_t)c2)));
+                                if (c1 != CH_UTF16LE && c1 != CH_UTF16BE) {
+                                        n1 = "ASCII";
+                                }
+                                if (c2 != CH_UTF16LE && c2 != CH_UTF16BE) {
+                                        n2 = "ASCII";
+                                }
+                                DEBUG(0,("init_iconv: Attempting to replace with conversion from %s to %s\n",
+                                        n1, n2 ));
+                                conv_handles[c1][c2] = smb_iconv_open(n2,n1);
+                                if (!conv_handles[c1][c2]) {
+                                        DEBUG(0,("init_iconv: Conversion from %s to %s failed", n1, n2));
+                                        smb_panic("init_iconv: conv_handle initialization failed");
+                                }
+                        }
+                }
+        }
+        if (did_reload) {
+                /* XXX: Does this really get called every time the dos
+                 * codepage changes? */
+                /* XXX: Is the did_reload test too strict? */
+                conv_silent = True;
+                init_valid_table();
+                conv_silent = False;
+        }
+        global_iconv_convenience = smb_iconv_convenience_reinit(NULL, lp_dos_charset(),
+                                                                lp_unix_charset(), lp_display_charset(),
+                                                                true, global_iconv_convenience);
+}
 …
         char* outbuf = (char*)dest;
         smb_iconv_t descriptor;
+        struct smb_iconv_convenience *ic;
         lazy_initialize_conv();
         descriptor = conv_handles[from][to];
+        ic = get_iconv_convenience();
+        descriptor = get_conv_handle(ic, from, to);
         if (srclen == (size_t)-1) {
 …
                                         if (from == CH_UNIX) {
                                                 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
                                                         charset_name(from), charset_name(to),
+                                                         charset_name(ic, from), charset_name(ic, to),
                                                         (unsigned int)srclen, (unsigned int)destlen, (const char *)src));
                                         } else {
                                                 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
                                                         charset_name(from), charset_name(to),
+                                                         charset_name(ic, from), charset_name(ic, to),
                                                         (unsigned int)srclen, (unsigned int)destlen));
+                                        }
 …
         smb_iconv_t descriptor;
         void **dest = (void **)dst;
+        struct smb_iconv_convenience *ic;
         *dest = NULL;
 …
         lazy_initialize_conv();
         descriptor = conv_handles[from][to];
+        ic = get_iconv_convenience();
+        descriptor = get_conv_handle(ic, from, to);
         if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
 …
+}
-/*
-  Return the unicode codepoint for the next multi-byte CH_UNIX character
-  in the string. The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
-  Also return the number of bytes consumed (which tells the caller
-  how many bytes to skip to get to the next CH_UNIX character).
-  Return INVALID_CODEPOINT if the next character cannot be converted.
-*/
-codepoint_t next_codepoint(const char *str, size_t *size)
+{
-        /* It cannot occupy more than 4 bytes in UTF16 format */
-        uint8_t buf[4];
-        smb_iconv_t descriptor;
-        size_t ilen_orig;
-        size_t ilen;
-        size_t olen;
-        char *outbuf;
-        if ((str[0] & 0x80) == 0) {
-                *size = 1;
-                return (codepoint_t)str[0];
+        }
-        /* We assume that no multi-byte character can take
-           more than 5 bytes. This is OK as we only
-           support codepoints up to 1M */
-        ilen_orig = strnlen(str, 5);
-        ilen = ilen_orig;
-        lazy_initialize_conv();
-        descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
-        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
-                *size = 1;
-                return INVALID_CODEPOINT;
+        }
-        /* This looks a little strange, but it is needed to cope
-           with codepoints above 64k which are encoded as per RFC2781. */
-        olen = 2;
-        outbuf = (char *)buf;
-        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
-        if (olen == 2) {
-                /* We failed to convert to a 2 byte character.
-                   See if we can convert to a 4 UTF16-LE byte char encoding.
-                */
-                olen = 4;
-                outbuf = (char *)buf;
-                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
-                if (olen == 4) {
-                        /* We didn't convert any bytes */
-                        *size = 1;
-                        return INVALID_CODEPOINT;
+                }
-                olen = 4 - olen;
-        } else {
-                olen = 2 - olen;
+        }
-        *size = ilen_orig - ilen;
-        if (olen == 2) {
-                /* 2 byte, UTF16-LE encoded value. */
-                return (codepoint_t)SVAL(buf, 0);
+        }
-        if (olen == 4) {
-                /* Decode a 4 byte UTF16-LE character manually.
-                   See RFC2871 for the encoding machanism.
-                */
-                codepoint_t w1 = SVAL(buf,0) & ~0xD800;
-                codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
-                return (codepoint_t)0x10000 +
-                                (w1 << 10) + w2;
+        }
-        /* no other length is valid */
-        return INVALID_CODEPOINT;
+}
-/*
-  push a single codepoint into a CH_UNIX string the target string must
-  be able to hold the full character, which is guaranteed if it is at
-  least 5 bytes in size. The caller may pass less than 5 bytes if they
-  are sure the character will fit (for example, you can assume that
-  uppercase/lowercase of a character will not add more than 1 byte)
-  return the number of bytes occupied by the CH_UNIX character, or
-  -1 on failure
-*/
-_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
-        smb_iconv_t descriptor;
-        uint8_t buf[4];
-        size_t ilen, olen;
-        const char *inbuf;
-        if (c < 128) {
-                *str = c;
-                return 1;
+        }
-        lazy_initialize_conv();
-        descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
-        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
-                return -1;
+        }
-        if (c < 0x10000) {
-                ilen = 2;
-                olen = 5;
-                inbuf = (char *)buf;
-                SSVAL(buf, 0, c);
-                smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-                if (ilen != 0) {
-                        return -1;
+                }
-                return 5 - olen;
+        }
-        c -= 0x10000;
-        buf[0] = (c>>10) & 0xFF;
-        buf[1] = (c>>18) | 0xd8;
-        buf[2] = c & 0xFF;
-        buf[3] = ((c>>8) & 0x3) | 0xdc;
-        ilen = 4;
-        olen = 5;
-        inbuf = (char *)buf;
-        smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-        if (ilen != 0) {
-                return -1;
+        }
-        return 5 - olen;
+}

trunk/server/source3/lib/conn_tdb.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/globals.h"
+#include "dbwrap.h"
 static struct db_context *connections_db_ctx(bool rw)
+{
         static struct db_context *db_ctx;
+        int open_flags;
         if (db_ctx != NULL) {
 …
+        }
+        if (rw) {
+                db_ctx = db_open(NULL, lock_path("connections.tdb"), 0,
+                                 TDB_CLEAR_IF_FIRST|TDB_DEFAULT,
+                                 O_RDWR | O_CREAT, 0644);
+        }
+        else {
+                db_ctx = db_open(NULL, lock_path("connections.tdb"), 0,
+                                 TDB_CLEAR_IF_FIRST|TDB_DEFAULT, O_RDONLY, 0);
+        }
+        open_flags = rw ? (O_RDWR|O_CREAT) : O_RDONLY;
+        db_ctx = db_open(NULL, lock_path("connections.tdb"), 0,
+                         TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH|TDB_DEFAULT, open_flags, 0644);
         return db_ctx;
+}
 struct db_record *connections_fetch_record(TALLOC_CTX *mem_ctx,
                                            TDB_DATA key)
+static struct db_record *connections_fetch_record(TALLOC_CTX *mem_ctx,
+                                                  TDB_DATA key)
+{
         struct db_context *ctx = connections_db_ctx(True);
 …
         ZERO_STRUCT(ckey);
         ckey.pid = procid_self();
         ckey.cnum = conn ? conn->cnum : -1;
+        ckey.pid = sconn_server_id(conn->sconn);
+        ckey.cnum = conn->cnum;
         strlcpy(ckey.name, name, sizeof(ckey.name));
 …
                        void *private_data)
+{
+        struct db_context *ctx;
         struct conn_traverse_state state;
+        ctx = connections_db_ctx(true);
+        if (ctx == NULL) {
+                return -1;
+        }
         state.fn = fn;
         state.private_data = private_data;
+        return connections_traverse(conn_traverse_fn, (void *)&state);
+        return ctx->traverse(ctx, conn_traverse_fn, (void *)&state);
+}
+struct conn_traverse_read_state {
+        int (*fn)(const struct connections_key *key,
+                  const struct connections_data *data,
+                  void *private_data);
+        void *private_data;
+};
+static int connections_forall_read_fn(struct db_record *rec,
+                                      void *private_data)
+{
+        struct conn_traverse_read_state *state =
+                (struct conn_traverse_read_state *)private_data;
+        if ((rec->key.dsize != sizeof(struct connections_key))
+            || (rec->value.dsize != sizeof(struct connections_data))) {
+                return 0;
+        }
+        return state->fn((const struct connections_key *)rec->key.dptr,
+                         (const struct connections_data *)rec->value.dptr,
+                         state->private_data);
+}
+int connections_forall_read(int (*fn)(const struct connections_key *key,
+                                      const struct connections_data *data,
+                                      void *private_data),
+                            void *private_data)
+{
+        struct db_context *ctx;
+        struct conn_traverse_read_state state;
+        ctx = connections_db_ctx(false);
+        if (ctx == NULL) {
+                return -1;
+        }
+        state.fn = fn;
+        state.private_data = private_data;
+        return ctx->traverse_read(ctx, connections_forall_read_fn,
+                                  (void *)&state);
+}

trunk/server/source3/lib/ctdbd_conn.c

-              r429
+              r745
 #include "includes.h"
+#include "util_tdb.h"
 #ifdef CLUSTER_SUPPORT
+#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_messaging.h"
+#include "ctdbd_conn.h"
+#include "packet.h"
+#include "messages.h"
 /* paths to these include files come from --with-ctdb= in configure */
 …
            so that someone else can take over without getting sharing
            violations */
         _exit(0);
+        _exit(1);
+}
 …
+}
+/*
+ * Are we active (i.e. not banned or stopped?)
+ */
+static bool ctdbd_working(struct ctdbd_connection *conn, uint32_t vnn)
+{
+        int32_t cstatus=-1;
+        NTSTATUS status;
+        TDB_DATA outdata;
+        struct ctdb_node_map *m;
+        uint32_t failure_flags;
+        bool ret = false;
+        int i;
+        status = ctdbd_control(conn, CTDB_CURRENT_NODE,
+                               CTDB_CONTROL_GET_NODEMAP, 0, 0,
+                               tdb_null, talloc_tos(), &outdata, &cstatus);
+        if (!NT_STATUS_IS_OK(status)) {
+                cluster_fatal("ctdbd_control failed\n");
+        }
+        if ((cstatus != 0) || (outdata.dptr == NULL)) {
+                DEBUG(2, ("Received invalid ctdb data\n"));
+                return false;
+        }
+        m = (struct ctdb_node_map *)outdata.dptr;
+        for (i=0; i<m->num; i++) {
+                if (vnn == m->nodes[i].pnn) {
+                        break;
+                }
+        }
+        if (i == m->num) {
+                DEBUG(2, ("Did not find ourselves (node %d) in nodemap\n",
+                          (int)vnn));
+                goto fail;
+        }
+        failure_flags = NODE_FLAGS_BANNED | NODE_FLAGS_DISCONNECTED
+                | NODE_FLAGS_PERMANENTLY_DISABLED | NODE_FLAGS_STOPPED;
+        if ((m->nodes[i].flags & failure_flags) != 0) {
+                DEBUG(2, ("Node has status %x, not active\n",
+                          (int)m->nodes[i].flags));
+                goto fail;
+        }
+        ret = true;
+fail:
+        TALLOC_FREE(outdata.dptr);
+        return ret;
+}
 uint32 ctdbd_vnn(const struct ctdbd_connection *conn)
+{
 …
         strncpy(addr.sun_path, sockname, sizeof(addr.sun_path));
         if (sys_connect(fd, (struct sockaddr *)&addr) == -1) {
+        if (sys_connect(fd, (struct sockaddr *)(void *)&addr) == -1) {
                 DEBUG(1, ("connect(%s) failed: %s\n", sockname,
                           strerror(errno)));
 …
         ndr_err = ndr_pull_struct_blob(
                 &blob, result, NULL, result,
+                &blob, result, result,
                 (ndr_pull_flags_fn_t)ndr_pull_messaging_rec);
 …
 static NTSTATUS ctdb_packet_fd_read_sync(struct packet_context *ctx)
+{
+        struct timeval timeout;
+        struct timeval *ptimeout;
+        timeout = timeval_set(lp_ctdb_timeout(), 0);
+        ptimeout = (timeout.tv_sec != 0) ? &timeout : NULL;
+        return packet_fd_read_sync(ctx, ptimeout);
+        int timeout = lp_ctdb_timeout();
+        if (timeout == 0) {
+                timeout = -1;
+        }
+        return packet_fd_read_sync(ctx, timeout);
+}
 …
                                   ? "cluster reconfigure" : "SAMBA_NOTIFY"));
+                        messaging_send(conn->msg_ctx, procid_self(),
+                        messaging_send(conn->msg_ctx,
+                                       messaging_server_id(conn->msg_ctx),
                                        MSG_SMB_BRL_VALIDATE, &data_blob_null);
+                        messaging_send(conn->msg_ctx, procid_self(),
+                        messaging_send(conn->msg_ctx,
+                                       messaging_server_id(conn->msg_ctx),
                                        MSG_DBWRAP_G_LOCK_RETRY,
                                        &data_blob_null);
 …
+                }
+                if (!(msg_state = TALLOC_P(talloc_autofree_context(), struct deferred_msg_state))) {
+                msg_state = TALLOC_P(NULL, struct deferred_msg_state);
+                if (msg_state == NULL) {
                         DEBUG(0, ("talloc failed\n"));
                         TALLOC_FREE(hdr);
 …
  */
 NTSTATUS ctdbd_init_connection(TALLOC_CTX *mem_ctx,
                                struct ctdbd_connection **pconn)
+static NTSTATUS ctdbd_init_connection(TALLOC_CTX *mem_ctx,
+                                      struct ctdbd_connection **pconn)
+{
         struct ctdbd_connection *conn;
 …
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("get_cluster_vnn failed: %s\n", nt_errstr(status)));
+                goto fail;
+        }
+        if (!ctdbd_working(conn, conn->our_vnn)) {
+                DEBUG(2, ("Node is not working, can not connect\n"));
+                status = NT_STATUS_INTERNAL_DB_ERROR;
                 goto fail;
+        }
 …
                  * clean the brl database
                  */
+                messaging_send(conn->msg_ctx, procid_self(),
+                messaging_send(conn->msg_ctx,
+                               messaging_server_id(conn->msg_ctx),
                                MSG_SMB_BRL_VALIDATE, &data_blob_null);
+                messaging_send(conn->msg_ctx, procid_self(),
+                messaging_send(conn->msg_ctx,
+                               messaging_server_id(conn->msg_ctx),
                                MSG_DBWRAP_G_LOCK_RETRY,
                                &data_blob_null);
 …
         ndr_err = ndr_push_struct_blob(
                 &blob, mem_ctx, NULL, msg,
+                &blob, mem_ctx, msg,
                 (ndr_push_flags_fn_t)ndr_push_messaging_rec);
 …
         req.srvid            = srvid;
         req.datalen          = data.dsize;
+        req.flags            = flags;
         DEBUG(10, ("ctdbd_control: Sending ctdb packet\n"));
 …
         if (flags & CTDB_CTRL_FLAG_NOREPLY) {
                 TALLOC_FREE(new_conn);
+                if (cstatus) {
+                        *cstatus = 0;
+                }
                 return NT_STATUS_OK;
+        }
 …
                                ? CTDB_CONTROL_DB_ATTACH_PERSISTENT
                                : CTDB_CONTROL_DB_ATTACH,
 , 0, data, NULL, &data, &cstatus);
+                               tdb_flags, 0, data, NULL, &data, &cstatus);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, (__location__ " ctdb_control for db_attach "
 …
         switch (client.ss_family) {
         case AF_INET:
                 p4.dest = *(struct sockaddr_in *)&server;
                 p4.src = *(struct sockaddr_in *)&client;
+                p4.dest = *(struct sockaddr_in *)(void *)&server;
+                p4.src = *(struct sockaddr_in *)(void *)&client;
                 data.dptr = (uint8_t *)&p4;
                 data.dsize = sizeof(p4);
 …
 #ifdef HAVE_STRUCT_CTDB_CONTROL_TCP_ADDR
         case AF_INET6:
                 p.dest.ip6 = *(struct sockaddr_in6 *)&server;
                 p.src.ip6 = *(struct sockaddr_in6 *)&client;
+                p.dest.ip6 = *(struct sockaddr_in6 *)(void *)&server;
+                p.src.ip6 = *(struct sockaddr_in6 *)(void *)&client;
                 data.dptr = (uint8_t *)&p;
                 data.dsize = sizeof(p);
 …
         conn->release_ip_handler = release_ip_handler;
+        /*
+         * store the IP address of the server socket for later
+         * comparison in release_ip()
+         */
+        conn->release_ip_priv = private_data;
         /*
 …
+}
-#else
-NTSTATUS ctdbd_init_connection(TALLOC_CTX *mem_ctx,
-                               struct ctdbd_connection **pconn)
+{
-        return NT_STATUS_NOT_IMPLEMENTED;
+}
 #endif

trunk/server/source3/lib/dbwrap.c

-              r414
+              r745
 #include "includes.h"
+#include "dbwrap.h"
+#include "util_tdb.h"
 #ifdef CLUSTER_SUPPORT
 #include "ctdb_private.h"
 …
 #ifdef CLUSTER_SUPPORT
         const char *sockname = lp_ctdbd_socket();
+#endif
+#ifdef CLUSTER_SUPPORT
         if(!sockname || !*sockname) {
                 sockname = CTDB_PATH;

trunk/server/source3/lib/dbwrap_ctdb.c

-              r429
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "lib/util/tdb_wrap.h"
+#include "util_tdb.h"
 #ifdef CLUSTER_SUPPORT
 #include "ctdb.h"
 …
 #include "ctdbd_conn.h"
 #include "g_lock.h"
+#include "messages.h"
 struct db_ctdb_transaction_handle {
 …
         struct db_ctdb_ctx *ctdb_ctx;
         struct ctdb_ltdb_header header;
+        struct timeval lock_time;
 };
 …
+}
+/**
+ * Fetch a record from a persistent database
+ * without record locking and without an active transaction.
+ *
+ * This just fetches from the local database copy.
+ * Since the databases are kept in syc cluster-wide,
+ * there is no point in doing a ctdb call to fetch the
+ * record from the lmaster. It does even harm since migration
+ * of records bump their RSN and hence render the persistent
+ * database inconsistent.
+ */
+static int db_ctdb_fetch_persistent(struct db_ctdb_ctx *db,
+                                    TALLOC_CTX *mem_ctx,
+                                    TDB_DATA key, TDB_DATA *data)
+{
+        NTSTATUS status;
+        status = db_ctdb_ltdb_fetch(db, key, NULL, mem_ctx, data);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+                *data = tdb_null;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return -1;
+        }
+        return 0;
+}
 static NTSTATUS db_ctdb_store_transaction(struct db_record *rec, TDB_DATA data, int flag);
 …
+#ifdef HAVE_CTDB_CONTROL_SCHEDULE_FOR_DELETION_DECL
+static NTSTATUS db_ctdb_send_schedule_for_deletion(struct db_record *rec)
+{
+        NTSTATUS status;
+        struct ctdb_control_schedule_for_deletion *dd;
+        TDB_DATA indata;
+        int cstatus;
+        struct db_ctdb_rec *crec = talloc_get_type_abort(
+                rec->private_data, struct db_ctdb_rec);
+        indata.dsize = offsetof(struct ctdb_control_schedule_for_deletion, key) + rec->key.dsize;
+        indata.dptr = talloc_zero_array(crec, uint8_t, indata.dsize);
+        if (indata.dptr == NULL) {
+                DEBUG(0, (__location__ " talloc failed!\n"));
+                return NT_STATUS_NO_MEMORY;
+        }
+        dd = (struct ctdb_control_schedule_for_deletion *)(void *)indata.dptr;
+        dd->db_id = crec->ctdb_ctx->db_id;
+        dd->hdr = crec->header;
+        dd->keylen = rec->key.dsize;
+        memcpy(dd->key, rec->key.dptr, rec->key.dsize);
+        status = ctdbd_control_local(messaging_ctdbd_connection(),
+                                     CTDB_CONTROL_SCHEDULE_FOR_DELETION,
+                                     crec->ctdb_ctx->db_id,
+                                     CTDB_CTRL_FLAG_NOREPLY, /* flags */
+                                     indata,
+                                     NULL, /* outdata */
+                                     NULL, /* errmsg */
+                                     &cstatus);
+        talloc_free(indata.dptr);
+        if (!NT_STATUS_IS_OK(status) || cstatus != 0) {
+                DEBUG(1, (__location__ " Error sending local control "
+                          "SCHEDULE_FOR_DELETION: %s, cstatus = %d\n",
+                          nt_errstr(status), cstatus));
+                if (NT_STATUS_IS_OK(status)) {
+                        status = NT_STATUS_UNSUCCESSFUL;
+                }
+        }
+        return status;
+}
+#endif
 static NTSTATUS db_ctdb_delete(struct db_record *rec)
+{
         TDB_DATA data;
+        NTSTATUS status;
         /*
 …
         ZERO_STRUCT(data);
+        return db_ctdb_store(rec, data, 0);
+        status = db_ctdb_store(rec, data, 0);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+#ifdef HAVE_CTDB_CONTROL_SCHEDULE_FOR_DELETION_DECL
+        status = db_ctdb_send_schedule_for_deletion(rec);
+#endif
+        return status;
+}
 …
         struct db_ctdb_rec *crec = talloc_get_type_abort(
                 data->private_data, struct db_ctdb_rec);
+        int threshold;
         DEBUG(10, (DEBUGLEVEL > 10
 …
                 DEBUG(0, ("tdb_chainunlock failed\n"));
                 return -1;
+        }
+        threshold = lp_ctdb_locktime_warn_threshold();
+        if (threshold != 0) {
+                double timediff = timeval_elapsed(&crec->lock_time);
+                if ((timediff * 1000) > threshold) {
+                        DEBUG(0, ("Held tdb lock %f seconds\n", timediff));
+                }
+        }
 …
                            get_my_vnn()));
+                status = ctdbd_migrate(messaging_ctdbd_connection(),ctx->db_id, key);
+                status = ctdbd_migrate(messaging_ctdbd_connection(), ctx->db_id,
+                                       key);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(5, ("ctdb_migrate failed: %s\n",
 …
                           migrate_attempts));
+        }
+        GetTimeOfDay(&crec->lock_time);
         memcpy(&crec->header, ctdb_data.dptr, sizeof(crec->header));
 …
         if (ctx->transaction) {
                 return db_ctdb_transaction_fetch(ctx, mem_ctx, key, data);
+        }
+        if (db->persistent) {
+                return db_ctdb_fetch_persistent(ctx, mem_ctx, key, data);
+        }
 …
         if ((ctdb_data.dptr != NULL) &&
             (ctdb_data.dsize >= sizeof(struct ctdb_ltdb_header)) &&
             (db->persistent ||
              ((struct ctdb_ltdb_header *)ctdb_data.dptr)->dmaster == get_my_vnn())) {
+            ((struct ctdb_ltdb_header *)ctdb_data.dptr)->dmaster == get_my_vnn())
+        {
                 /* we are the dmaster - avoid the ctdb protocol op */
 …
         /* we weren't able to get it locally - ask ctdb to fetch it for us */
+        status = ctdbd_fetch(messaging_ctdbd_connection(),ctx->db_id, key, mem_ctx, data);
+        status = ctdbd_fetch(messaging_ctdbd_connection(), ctx->db_id, key,
+                             mem_ctx, data);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(5, ("ctdbd_fetch failed: %s\n", nt_errstr(status)));
 …
         conn = messaging_ctdbd_connection();
+        if (conn == NULL) {
+                DEBUG(1, ("Could not connect to ctdb\n"));
+                TALLOC_FREE(result);
+                return NULL;
+        }
         if (!NT_STATUS_IS_OK(ctdbd_db_attach(conn, name, &db_ctdb->db_id, tdb_flags))) {

trunk/server/source3/lib/dbwrap_rbt.c

r414	r745
19	19
20	20	#include "includes.h"
	21	#include "dbwrap.h"
21	22	#include "../lib/util/rbtree.h"
22	23

trunk/server/source3/lib/dbwrap_tdb.c

r414	r745
19	19
20	20	#include "includes.h"
	21	#include "dbwrap.h"
	22	#include "lib/util/tdb_wrap.h"
21	23
22	24	struct db_tdb_ctx {

trunk/server/source3/lib/dbwrap_util.c

-              r414
+              r745
 #include "includes.h"
+#include "dbwrap.h"
+#include "util_tdb.h"
 int32_t dbwrap_fetch_int32(struct db_context *db, const char *keystr)
 …
+{
         struct db_record *rec;
         uint32 val = -1;
+        uint32_t val = (uint32_t)-1;
         uint32_t v_store;
         NTSTATUS ret;
 …
+}
+struct dbwrap_trans_traverse_action_ctx {
+        int (*f)(struct db_record* rec, void* private_data);
+        void* private_data;
+};
+static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data)
+{
+        struct dbwrap_trans_traverse_action_ctx* ctx =
+                (struct dbwrap_trans_traverse_action_ctx*)private_data;
+        int ret = db->traverse(db, ctx->f, ctx->private_data);
+        return (ret == -1) ? NT_STATUS_INTERNAL_DB_CORRUPTION : NT_STATUS_OK;
+}
+NTSTATUS dbwrap_trans_traverse(struct db_context *db,
+                               int (*f)(struct db_record*, void*),
+                               void *private_data)
+{
+        struct dbwrap_trans_traverse_action_ctx ctx = {
+                .f = f,
+                .private_data = private_data,
+        };
+        return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
+}
+NTSTATUS dbwrap_traverse(struct db_context *db,
+                         int (*f)(struct db_record*, void*),
+                         void *private_data)
+{
+        int ret = db->traverse(db, f, private_data);
+        return (ret == -1) ? NT_STATUS_INTERNAL_DB_CORRUPTION : NT_STATUS_OK;
+}
 NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
+{

trunk/server/source3/lib/dmallocmsg.c

r414	r745
18	18
19	19	#include "includes.h"
	20	#include "messages.h"
20	21
21	22	/**

trunk/server/source3/lib/dprintf.c

r414	r745
30	30
31	31	#include "includes.h"
	32	#include "intl/lang_tdb.h"
32	33
33	34	int d_vfprintf(FILE f, const char format, va_list ap)

trunk/server/source3/lib/dummysmbd.c

r414	r745
24	24	#include "includes.h"
25	25
26		int get_client_fd(void)
27		{
28		return -1;
29		}
30
31		int find_service(fstring service)
	26	int find_service(TALLOC_CTX ctx, const char service_in, char **p_service_out)
32	27	{
33	28	return -1;
…	…
39	34	}
40	35
41		void cancel_pending_lock_requests_by_fid(files_struct fsp, struct byte_range_lock br_lck)
	36	void cancel_pending_lock_requests_by_fid(files_struct *fsp,
	37	struct byte_range_lock *br_lck,
	38	enum file_close_type close_type)
42	39	{
43	40	}
44	41
45		void send_stat_cache_delete_message(const char *name)
	42	void send_stat_cache_delete_message(struct messaging_context *msg_ctx,
	43	const char *name)
46	44	{
47	45	}
…	…
59	57
60	58	struct event_context *smbd_event_context(void)
61		{
62		~~return NULL;~~
63		}
64
65		~~struct messaging_context *smbd_messaging_context(void)~~
66	59	{
67	60	return NULL;

trunk/server/source3/lib/errmap_unix.c

-              r414
+              r745
         { ECANCELED, ERRDOS, ERRbadfid, NT_STATUS_CANCELLED},
 #endif
+#ifdef ENOTSUP
+        { ENOTSUP, ERRSRV, ERRnosupport, NT_STATUS_NOT_SUPPORTED},
+#endif
         { 0, 0, 0, NT_STATUS_OK }
 };
 …
         /* Default return */
         return NT_STATUS_ACCESS_DENIED;
+}
+/* Convert a Unix error code to a WERROR. */
+WERROR unix_to_werror(int unix_error)
+{
+        return ntstatus_to_werror(map_nt_error_from_unix(unix_error));
+}

trunk/server/source3/lib/eventlog/eventlog.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "lib/eventlog/eventlog.h"
+#include "../libcli/security/security.h"
+#include "util_tdb.h"
 /* maintain a list of open eventlog tdbs with reference counts */
 …
 char *elog_tdbname(TALLOC_CTX *ctx, const char *name )
+{
+        char *path = talloc_asprintf(ctx, "%s/%s.tdb",
+                        state_path("eventlog"),
+                        name);
+        char *path;
+        char *file;
+        char *tdbname;
+        path = talloc_strdup(ctx, state_path("eventlog"));
         if (!path) {
                 return NULL;
+        }
+        strlower_m(path);
+        return path;
+        file = talloc_asprintf_strlower_m(path, "%s.tdb", name);
+        if (!file) {
+                talloc_free(path);
+                return NULL;
+        }
+        tdbname = talloc_asprintf(path, "%s/%s", state_path("eventlog"), file);
+        if (!tdbname) {
+                talloc_free(path);
+                return NULL;
+        }
+        return tdbname;
+}
 …
         blob = data_blob_const(data.dptr, data.dsize);
         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, r,
+        ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, r,
                            (ndr_pull_flags_fn_t)ndr_pull_eventlog_Record_tdb);
 …
+        }
         r->Length = r->Length2 = ndr_size_EVENTLOGRECORD(r, NULL, 0);
+        r->Length = r->Length2 = ndr_size_EVENTLOGRECORD(r, 0);
         return r;
 …
         r->record_number = tdb_fetch_int32(tdb, EVT_NEXT_RECORD);
         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, r,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, r,
                       (ndr_push_flags_fn_t)ndr_push_eventlog_Record_tdb);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
+                }
                 if (len > 0) {
                         e->UserSid = *string_sid_talloc(mem_ctx, sid_str);
+                        string_to_sid(&e->UserSid, sid_str);
+                }
+        }
 …
+                }
                 endoffset += ndr_size_EVENTLOGRECORD(&e, NULL, 0);
+                endoffset += ndr_size_EVENTLOGRECORD(&e, 0);
                 ADD_TO_ARRAY(mem_ctx, struct EVENTLOGRECORD, e, &evt.records, &num_records);
 …
+        }
         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &evt,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &evt,
                    (ndr_push_flags_fn_t)ndr_push_EVENTLOG_EVT_FILE);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {

trunk/server/source3/lib/events.c

-              r596
+              r745
 #include "includes.h"
+#include <tevent_internal.h>
+void event_fd_set_writeable(struct tevent_fd *fde)
+{
+        TEVENT_FD_WRITEABLE(fde);
+}
+void event_fd_set_not_writeable(struct tevent_fd *fde)
+{
+        TEVENT_FD_NOT_WRITEABLE(fde);
+}
+void event_fd_set_readable(struct tevent_fd *fde)
+{
+        TEVENT_FD_READABLE(fde);
+}
+void event_fd_set_not_readable(struct tevent_fd *fde)
+{
+        TEVENT_FD_NOT_READABLE(fde);
+}
+/*
+ * Return if there's something in the queue
+ */
+bool event_add_to_select_args(struct tevent_context *ev,
+                              const struct timeval *now,
+                              fd_set *read_fds, fd_set *write_fds,
+                              struct timeval *timeout, int *maxfd)
+#include "lib/tevent/tevent_internal.h"
+#include "../lib/util/select.h"
+#include "system/select.h"
+struct tevent_poll_private {
+        /*
+         * Index from file descriptor into the pollfd array
+         */
+        int *pollfd_idx;
+        /*
+         * Cache for s3_event_loop_once to avoid reallocs
+         */
+        struct pollfd *pfds;
+};
+static struct tevent_poll_private *tevent_get_poll_private(
+        struct tevent_context *ev)
+{
+        struct tevent_poll_private *state;
+        state = (struct tevent_poll_private *)ev->additional_data;
+        if (state == NULL) {
+                state = TALLOC_ZERO_P(ev, struct tevent_poll_private);
+                ev->additional_data = (void *)state;
+                if (state == NULL) {
+                        DEBUG(10, ("talloc failed\n"));
+                }
+        }
+        return state;
+}
+static void count_fds(struct tevent_context *ev,
+                      int *pnum_fds, int *pmax_fd)
+{
         struct tevent_fd *fde;
+        struct timeval diff;
+        bool ret = false;
+        int num_fds = 0;
+        int max_fd = 0;
+        for (fde = ev->fd_events; fde != NULL; fde = fde->next) {
+                if (fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) {
+                        num_fds += 1;
+                        if (fde->fd > max_fd) {
+                                max_fd = fde->fd;
+                        }
+                }
+        }
+        *pnum_fds = num_fds;
+        *pmax_fd = max_fd;
+}
+bool event_add_to_poll_args(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+                            struct pollfd **pfds, int *pnum_pfds,
+                            int *ptimeout)
+{
+        struct tevent_poll_private *state;
+        struct tevent_fd *fde;
+        int i, num_fds, max_fd, num_pollfds, idx_len;
+        struct pollfd *fds;
+        struct timeval now, diff;
+        int timeout;
+        state = tevent_get_poll_private(ev);
+        if (state == NULL) {
+                return false;
+        }
+        count_fds(ev, &num_fds, &max_fd);
+        idx_len = max_fd+1;
+        if (talloc_array_length(state->pollfd_idx) < idx_len) {
+                state->pollfd_idx = TALLOC_REALLOC_ARRAY(
+                        state, state->pollfd_idx, int, idx_len);
+                if (state->pollfd_idx == NULL) {
+                        DEBUG(10, ("talloc_realloc failed\n"));
+                        return false;
+                }
+        }
+        fds = *pfds;
+        num_pollfds = *pnum_pfds;
+        /*
+         * The +1 is for the sys_poll calling convention. It expects
+         * an array 1 longer for the signal pipe
+         */
+        if (talloc_array_length(fds) < num_pollfds + num_fds + 1) {
+                fds = TALLOC_REALLOC_ARRAY(mem_ctx, fds, struct pollfd,
+                                           num_pollfds + num_fds + 1);
+                if (fds == NULL) {
+                        DEBUG(10, ("talloc_realloc failed\n"));
+                        return false;
+                }
+        }
+        memset(&fds[num_pollfds], 0, sizeof(struct pollfd) * num_fds);
+        /*
+         * This needs tuning. We need to cope with multiple fde's for a file
+         * descriptor. The problem is that we need to re-use pollfd_idx across
+         * calls for efficiency. One way would be a direct bitmask that might
+         * be initialized quicker, but our bitmap_init implementation is
+         * pretty heavy-weight as well.
+         */
+        for (i=0; i<idx_len; i++) {
+                state->pollfd_idx[i] = -1;
+        }
         for (fde = ev->fd_events; fde; fde = fde->next) {
+                if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
+                        /* We ignore here, as it shouldn't be
+                           possible to add an invalid fde->fd
+                           but we don't want FD_SET to see an
+                           invalid fd. */
+                struct pollfd *pfd;
+                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
                         continue;
+                }
+                if (state->pollfd_idx[fde->fd] == -1) {
+                        /*
+                         * We haven't seen this fd yet. Allocate a new pollfd.
+                         */
+                        state->pollfd_idx[fde->fd] = num_pollfds;
+                        pfd = &fds[num_pollfds];
+                        num_pollfds += 1;
+                } else {
+                        /*
+                         * We have already seen this fd. OR in the flags.
+                         */
+                        pfd = &fds[state->pollfd_idx[fde->fd]];
+                }
+                pfd->fd = fde->fd;
                 if (fde->flags & EVENT_FD_READ) {
+                        FD_SET(fde->fd, read_fds);
+                        ret = true;
+                        pfd->events |= (POLLIN|POLLHUP);
+                }
                 if (fde->flags & EVENT_FD_WRITE) {
+                        FD_SET(fde->fd, write_fds);
+                        ret = true;
+                }
+                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
+                    && (fde->fd > *maxfd)) {
+                        *maxfd = fde->fd;
+                }
+        }
+                        pfd->events |= POLLOUT;
+                }
+        }
+        *pfds = fds;
+        *pnum_pfds = num_pollfds;
         if (ev->immediate_events != NULL) {
+                *timeout = timeval_zero();
+                return true;
+        }
+                *ptimeout = 0;
+                return true;
+        }
         if (ev->timer_events == NULL) {
+                return ret;
+        }
+        diff = timeval_until(now, &ev->timer_events->next_event);
+        *timeout = timeval_min(timeout, &diff);
+                *ptimeout = MIN(*ptimeout, INT_MAX);
+                return true;
+        }
+        now = timeval_current();
+        diff = timeval_until(&now, &ev->timer_events->next_event);
+        timeout = timeval_to_msec(diff);
+        if (timeout < *ptimeout) {
+                *ptimeout = timeout;
+        }
         return true;
+}
+bool run_events(struct tevent_context *ev,
+                int selrtn, fd_set *read_fds, fd_set *write_fds)
+{
+bool run_events_poll(struct tevent_context *ev, int pollrtn,
+                     struct pollfd *pfds, int num_pfds)
+{
+        struct tevent_poll_private *state;
+        int *pollfd_idx;
         struct tevent_fd *fde;
         struct timeval now;
 …
+        }
         if (selrtn <= 0) {
+        if (pollrtn <= 0) {
                 /*
                  * No fd ready
 …
+        }
+        state = (struct tevent_poll_private *)ev->additional_data;
+        pollfd_idx = state->pollfd_idx;
         for (fde = ev->fd_events; fde; fde = fde->next) {
+                struct pollfd *pfd;
                 uint16 flags = 0;
+                if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
+                if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
+                if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE)) == 0) {
+                        continue;
+                }
+                if (pollfd_idx[fde->fd] >= num_pfds) {
+                        DEBUG(1, ("internal error: pollfd_idx[fde->fd] (%d) "
+                                  ">= num_pfds (%d)\n", pollfd_idx[fde->fd],
+                                  num_pfds));
+                        return false;
+                }
+                pfd = &pfds[pollfd_idx[fde->fd]];
+                if (pfd->fd != fde->fd) {
+                        DEBUG(1, ("internal error: pfd->fd (%d) "
+                                  "!= fde->fd (%d)\n", pollfd_idx[fde->fd],
+                                  num_pfds));
+                        return false;
+                }
+                if (pfd->revents & (POLLHUP|POLLERR)) {
+                        /* If we only wait for EVENT_FD_WRITE, we
+                           should not tell the event handler about it,
+                           and remove the writable flag, as we only
+                           report errors when waiting for read events
+                           to match the select behavior. */
+                        if (!(fde->flags & EVENT_FD_READ)) {
+                                EVENT_FD_NOT_WRITEABLE(fde);
+                                continue;
+                        }
+                        flags |= EVENT_FD_READ;
+                }
+                if (pfd->revents & POLLIN) {
+                        flags |= EVENT_FD_READ;
+                }
+                if (pfd->revents & POLLOUT) {
+                        flags |= EVENT_FD_WRITE;
+                }
                 if (flags & fde->flags) {
                         DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd *);
+                        DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
                         fde->handler(ev, fde, flags, fde->private_data);
                         return true;
 …
         return false;
+}
 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
 …
 static int s3_event_loop_once(struct tevent_context *ev, const char *location)
+{
         struct timeval now, to;
         fd_set r_fds, w_fds;
         int maxfd = 0;
+        struct tevent_poll_private *state;
+        int timeout;
+        int num_pfds;
         int ret;
+        FD_ZERO(&r_fds);
+        FD_ZERO(&w_fds);
+        to.tv_sec = 9999;       /* Max timeout */
+        to.tv_usec = 0;
+        if (run_events(ev, 0, NULL, NULL)) {
+        timeout = INT_MAX;
+        state = tevent_get_poll_private(ev);
+        if (state == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        if (run_events_poll(ev, 0, NULL, 0)) {
                 return 0;
+        }
         GetTimeOfDay(&now);
         if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
+        num_pfds = 0;
+        if (!event_add_to_poll_args(ev, state,
+                                    &state->pfds, &num_pfds, &timeout)) {
                 return -1;
+        }
+        ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
+        ret = sys_poll(state->pfds, num_pfds, timeout);
         if (ret == -1 && errno != EINTR) {
                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
                              "sys_select() failed: %d:%s\n",
+                             "poll() failed: %d:%s\n",
                              errno, strerror(errno));
                 return -1;
+        }
         run_events(ev, ret, &r_fds, &w_fds);
+        run_events_poll(ev, ret, state->pfds, num_pfds);
         return 0;
+}
-void event_context_reinit(struct tevent_context *ev)
+{
-        tevent_common_context_destructor(ev);
-        return;
+}

trunk/server/source3/lib/fault.c

-              r454
+              r745
 #include "includes.h"
+#include "system/filesys.h"
 #ifdef HAVE_SYS_SYSCTL_H
 …
 #ifndef __OS2__ /* don't use the built in signal capture stuff - prefer native handling of errors */
 #ifdef SIGSEGV
                 CatchSignal(SIGSEGV,SIGNAL_CAST SIG_DFL);
+                CatchSignal(SIGSEGV, SIG_DFL);
 #endif
 #ifdef SIGBUS
                 CatchSignal(SIGBUS,SIGNAL_CAST SIG_DFL);
+                CatchSignal(SIGBUS, SIG_DFL);
 #endif
 #ifdef SIGABRT
                 CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL);
+                CatchSignal(SIGABRT, SIG_DFL);
 #endif
 #endif
 …
 #ifndef __OS2__ /* don't use the built in signal capture stuff - prefer native handling of errors */
 #ifdef SIGSEGV
         CatchSignal(SIGSEGV,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGSEGV, sig_fault);
 #endif
 #ifdef SIGBUS
         CatchSignal(SIGBUS,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGBUS, sig_fault);
 #endif
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGABRT, sig_fault);
 #endif
 #endif
 …
 #endif
+#if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
+/**
+ * Get the Linux corepath.
+ *
+ * On Linux the contents of /proc/sys/kernel/core_pattern indicates the
+ * location of the core path.
+ */
+static char *get_linux_corepath(void)
+{
+        char *end;
+        int fd;
+        char *result;
+        fd = open("/proc/sys/kernel/core_pattern", O_RDONLY, 0);
+        if (fd == -1) {
+                return NULL;
+        }
+        result = afdgets(fd, NULL, 0);
+        close(fd);
+        if (result == NULL) {
+                return NULL;
+        }
+        if (result[0] != '/') {
+                /*
+                 * No absolute path, use the default (cwd)
+                 */
+                TALLOC_FREE(result);
+                return NULL;
+        }
+        /* Strip off the common filename expansion */
+        end = strrchr_m(result, '/');
+        if ((end != result) /* this would be the only / */
+            && (end != NULL)) {
+                *end = '\0';
+        }
+        return result;
+}
+#endif
 /**
  * Try getting system-specific corepath if one exists.
 …
+{
 #if (defined(FREEBSD) && defined(HAVE_SYSCTLBYNAME))
-        /* @todo: Add support for the linux corepath. */
         char *tmp_corepath = NULL;
         tmp_corepath = get_freebsd_corepath();
+        /* If this has been set correctly, we're done. */
+        if (tmp_corepath) {
+                return tmp_corepath;
+        }
+#endif
+#if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
+        char *tmp_corepath = NULL;
+        tmp_corepath = get_linux_corepath();
         /* If this has been set correctly, we're done. */
 …
 #endif
-#if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
-        /* On Linux we lose the ability to dump core when we change our user
-         * ID. We know how to dump core safely, so let's make sure we have our
-         * dumpable flag set.
-         */
-        prctl(PR_SET_DUMPABLE, 1);
-#endif
         /* FIXME: if we have a core-plus-pid facility, configurably set
          * this up here.
 …
          * file to the corepath.  There must not be an unbecome_root() before
          * we call abort(). */
         if (geteuid() != 0) {
+        if (geteuid() != sec_initial_uid()) {
                 become_root();
+        }
 …
         dbgflush();
+#if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
+        /* On Linux we lose the ability to dump core when we change our user
+         * ID. We know how to dump core safely, so let's make sure we have our
+         * dumpable flag set.
+         */
+        prctl(PR_SET_DUMPABLE, 1);
+#endif
         /* Ensure we don't have a signal handler for abort. */
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL);
+        CatchSignal(SIGABRT, SIG_DFL);
 #endif

trunk/server/source3/lib/fncall.c

-              r414
+              r745
 #include "includes.h"
+#include "../lib/util/tevent_unix.h"
 #if WITH_PTHREADPOOL
 #include "pthreadpool.h"
+#include "lib/pthreadpool/pthreadpool.h"
 struct fncall_state {
 …
         talloc_set_destructor(ctx, fncall_context_destructor);
         ctx->sig_fd = pthreadpool_sig_fd(ctx->pool);
+        ctx->sig_fd = pthreadpool_signal_fd(ctx->pool);
         if (ctx->sig_fd == -1) {
                 TALLOC_FREE(ctx);

trunk/server/source3/lib/g_lock.c

-              r593
+              r745
 #include "includes.h"
+#include "system/filesys.h"
 #include "g_lock.h"
+#include "util_tdb.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/select.h"
+#include "system/select.h"
+#include "messages.h"
 static NTSTATUS g_lock_force_unlock(struct g_lock_ctx *ctx, const char *name,
 …
         result->db = db_open(result, lock_path("g_lock.tdb"), 0,
                              TDB_CLEAR_IF_FIRST, O_RDWR|O_CREAT, 0700);
+                             TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDWR|O_CREAT, 0700);
         if (result->db == NULL) {
                 DEBUG(1, ("g_lock_init: Could not open g_lock.tdb"));
 …
+        }
         self = procid_self();
+        self = messaging_server_id(ctx->msg);
         our_index = -1;
 …
         while (true) {
+#ifdef CLUSTER_SUPPORT
+                fd_set _r_fds;
+#endif
+                fd_set *r_fds = NULL;
+                int max_fd = 0;
+                struct pollfd *pollfds;
+                int num_pollfds;
+                int saved_errno;
                 int ret;
                 struct timeval timeout_remaining, select_timeout;
 …
                  */
+                /*
+                 * We allocate 2 entries here. One is needed anyway for
+                 * sys_poll and in the clustering case we might have to add
+                 * the ctdb fd. This avoids the realloc then.
+                 */
+                pollfds = TALLOC_ARRAY(talloc_tos(), struct pollfd, 2);
+                if (pollfds == NULL) {
+                        status = NT_STATUS_NO_MEMORY;
+                        break;
+                }
+                num_pollfds = 0;
 #ifdef CLUSTER_SUPPORT
                 if (lp_clustering()) {
+                        struct ctdbd_connection *conn = messaging_ctdbd_connection();
+                        r_fds = &_r_fds;
+                        FD_ZERO(r_fds);
+                        max_fd = ctdbd_conn_get_fd(conn);
+                        if (max_fd >= 0 && max_fd < FD_SETSIZE) {
+                                FD_SET(max_fd, r_fds);
+                        }
+                        struct ctdbd_connection *conn;
+                        conn = messaging_ctdbd_connection();
+                        pollfds[0].fd = ctdbd_conn_get_fd(conn);
+                        pollfds[0].events = POLLIN|POLLHUP;
+                        num_pollfds += 1;
+                }
 #endif
 …
                                              &timeout_remaining);
+                ret = sys_select(max_fd + 1, r_fds, NULL, NULL,
+                                 &select_timeout);
+                ret = sys_poll(pollfds, num_pollfds,
+                               timeval_to_msec(select_timeout));
+                /*
+                 * We're not *really interested in the actual flags. We just
+                 * need to retry this whole thing.
+                 */
+                saved_errno = errno;
+                TALLOC_FREE(pollfds);
+                errno = saved_errno;
                 if (ret == -1) {
                         if (errno != EINTR) {
 …
         NTSTATUS status;
         status = g_lock_force_unlock(ctx, name, procid_self());
+        status = g_lock_force_unlock(ctx, name, messaging_server_id(ctx->msg));
 #ifdef CLUSTER_SUPPORT
 …
                             struct tevent_context **pev,
                             struct messaging_context **pmsg,
+                            const struct server_id self,
                             struct g_lock_ctx **pg_ctx)
+{
 …
                 goto fail;
+        }
         msg = messaging_init(mem_ctx, procid_self(), ev);
+        msg = messaging_init(mem_ctx, self, ev);
         if (msg == NULL) {
                 d_fprintf(stderr, "ERROR: could not init messaging context\n");
 …
 NTSTATUS g_lock_do(const char *name, enum g_lock_type lock_type,
                    struct timeval timeout,
+                   struct timeval timeout, const struct server_id self,
                    void (*fn)(void *private_data), void *private_data)
+{
 …
         NTSTATUS status;
         if (!g_lock_init_all(talloc_tos(), &ev, &msg, &g_ctx)) {
+        if (!g_lock_init_all(talloc_tos(), &ev, &msg, self, &g_ctx)) {
                 status = NT_STATUS_ACCESS_DENIED;
                 goto done;

trunk/server/source3/lib/gencache.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/glob.h"
+#include "util_tdb.h"
 #undef  DBGC_CLASS
 …
 again:
         cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT, open_flags, 0644);
+        cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
         if (cache) {
                 int ret;
 …
                         DEBUG(0, ("gencache_init: tdb_check(%s) failed - retry after CLEAR_IF_FIRST\n",
                                   cache_fname));
                         cache = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST, open_flags, 0644);
+                        cache = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
                         if (cache) {
                                 tdb_close(cache);
 …
         if (!cache && (errno == EACCES)) {
                 open_flags = O_RDONLY;
                 cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT, open_flags,
+                cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags,
 );
                 if (cache) {
 …
         DEBUG(5, ("Opening cache file at %s\n", cache_fname));
         cache_notrans = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST,
+        cache_notrans = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
                                      open_flags, 0644);
         if (cache_notrans == NULL) {
 …
         char *endptr;
+        if (val == NULL) {
+                return false;
+        }
         res = strtol(val, &endptr, 10);
 …
+        }
         return true;
+}
+struct gencache_parse_state {
+        void (*parser)(time_t timeout, DATA_BLOB blob, void *private_data);
+        void *private_data;
+};
+static int gencache_parse_fn(TDB_DATA key, TDB_DATA data, void *private_data)
+{
+        struct gencache_parse_state *state;
+        DATA_BLOB blob;
+        time_t t;
+        char *endptr;
+        bool ret;
+        if (data.dptr == NULL) {
+                return -1;
+        }
+        ret = gencache_pull_timeout((char *)data.dptr, &t, &endptr);
+        if (!ret) {
+                return -1;
+        }
+        state = (struct gencache_parse_state *)private_data;
+        blob = data_blob_const(
+                endptr+1, data.dsize - PTR_DIFF(endptr+1, data.dptr));
+        state->parser(t, blob, state->private_data);
+        return 0;
+}
+bool gencache_parse(const char *keystr,
+                    void (*parser)(time_t timeout, DATA_BLOB blob,
+                                   void *private_data),
+                    void *private_data)
+{
+        struct gencache_parse_state state;
+        TDB_DATA key;
+        int ret;
+        if (keystr == NULL) {
+                return false;
+        }
+        if (tdb_data_cmp(string_term_tdb_data(keystr),
+                         last_stabilize_key()) == 0) {
+                return false;
+        }
+        if (!gencache_init()) {
+                return false;
+        }
+        key = string_term_tdb_data(keystr);
+        state.parser = parser;
+        state.private_data = private_data;
+        ret = tdb_parse_record(cache_notrans, key, gencache_parse_fn, &state);
+        if (ret != -1) {
+                return true;
+        }
+        ret = tdb_parse_record(cache, key, gencache_parse_fn, &state);
+        return (ret != -1);
+}
+struct gencache_get_data_blob_state {
+        DATA_BLOB *blob;
+        time_t timeout;
+        bool result;
+};
+static void gencache_get_data_blob_parser(time_t timeout, DATA_BLOB blob,
+                                          void *private_data)
+{
+        struct gencache_get_data_blob_state *state =
+                (struct gencache_get_data_blob_state *)private_data;
+        if (timeout == 0) {
+                state->result = false;
+                return;
+        }
+        state->timeout = timeout;
+        if (state->blob == NULL) {
+                state->result = true;
+                return;
+        }
+        *state->blob = data_blob(blob.data, blob.length);
+        if (state->blob->data == NULL) {
+                state->result = false;
+                return;
+        }
+        state->result = true;
+}
 …
                             time_t *timeout, bool *was_expired)
+{
+        TDB_DATA databuf;
+        time_t t;
+        char *endptr;
+        struct gencache_get_data_blob_state state;
         bool expired = false;
+        if (keystr == NULL) {
+        state.result = false;
+        state.blob = blob;
+        if (!gencache_parse(keystr, gencache_get_data_blob_parser, &state)) {
                 goto fail;
+        }
+        if (tdb_data_cmp(string_term_tdb_data(keystr),
+                         last_stabilize_key()) == 0) {
+                DEBUG(10, ("Can't get %s as a key\n", keystr));
+        if (!state.result) {
                 goto fail;
+        }
+        if (!gencache_init()) {
+                goto fail;
+        }
+        databuf = tdb_fetch_bystring(cache_notrans, keystr);
+        if (databuf.dptr == NULL) {
+                databuf = tdb_fetch_bystring(cache, keystr);
+        }
+        if (databuf.dptr == NULL) {
+                DEBUG(10, ("Cache entry with key = %s couldn't be found \n",
+                           keystr));
+                goto fail;
+        }
+        if (!gencache_pull_timeout((char *)databuf.dptr, &t, &endptr)) {
+                SAFE_FREE(databuf.dptr);
+                goto fail;
+        }
+        DEBUG(10, ("Returning %s cache entry: key = %s, value = %s, "
+                   "timeout = %s", t > time(NULL) ? "valid" :
+                   "expired", keystr, endptr+1, ctime(&t)));
+        if (t == 0) {
+                /* Deleted */
+                SAFE_FREE(databuf.dptr);
+                goto fail;
+        }
+        if (t <= time(NULL)) {
+        if (state.timeout <= time(NULL)) {
                 /*
                  * We're expired, delete the entry. We can't use gencache_del
 …
                  */
                 gencache_set(keystr, "", 0);
-                SAFE_FREE(databuf.dptr);
                 expired = true;
                 goto fail;
+        }
-        if (blob != NULL) {
-                *blob = data_blob(
-                        endptr+1,
-                        databuf.dsize - PTR_DIFF(endptr+1, databuf.dptr));
-                if (blob->data == NULL) {
-                        SAFE_FREE(databuf.dptr);
-                        DEBUG(0, ("memdup failed\n"));
-                        goto fail;
+                }
+        }
-        SAFE_FREE(databuf.dptr);
         if (timeout) {
                 *timeout = t;
+                *timeout = state.timeout;
+        }
 …
         if (was_expired != NULL) {
                 *was_expired = expired;
+        }
+        if (state.result && state.blob) {
+                data_blob_free(state.blob);
+        }
         return false;
 …
+        }
         res = tdb_transaction_start(cache);
+        res = tdb_transaction_start_nonblock(cache);
         if (res == -1) {
+                if (tdb_error(cache) == TDB_ERR_NOLOCK) {
+                        /*
+                         * Someone else already does the stabilize,
+                         * this does not have to be done twice
+                         */
+                        return true;
+                }
                 DEBUG(10, ("Could not start transaction on gencache.tdb: "
                            "%s\n", tdb_errorstr(cache)));
 …
+}
+/**
+ * Iterate through all entries which key matches to specified pattern
+ *
+ * @param fn pointer to the function that will be supplied with each single
+ *        matching cache entry (key, value and timeout) as an arguments
+ * @param data void pointer to an arbitrary data that is passed directly to the fn
+ *        function on each call
+ * @param keystr_pattern pattern the existing entries' keys are matched to
+ *
+ **/
+struct gencache_iterate_state {
+        void (*fn)(const char *key, const char *value, time_t timeout,
+                   void *priv);
+struct gencache_iterate_blobs_state {
+        void (*fn)(const char *key, DATA_BLOB value,
+                   time_t timeout, void *private_data);
         const char *pattern;
         void *priv;
+        void *private_data;
         bool in_persistent;
 };
 static int gencache_iterate_fn(struct tdb_context *tdb, TDB_DATA key,
                                TDB_DATA value, void *priv)
+{
         struct gencache_iterate_state *state =
                 (struct gencache_iterate_state *)priv;
+static int gencache_iterate_blobs_fn(struct tdb_context *tdb, TDB_DATA key,
+                                     TDB_DATA data, void *priv)
+{
+        struct gencache_iterate_blobs_state *state =
+                (struct gencache_iterate_blobs_state *)priv;
         char *keystr;
         char *free_key = NULL;
-        char *valstr;
-        char *free_val = NULL;
-        unsigned long u;
         time_t timeout;
         char *timeout_endp;
+        char *endptr;
         if (tdb_data_cmp(key, last_stabilize_key()) == 0) {
                 return 0;
+        }
         if (state->in_persistent && tdb_exists(cache_notrans, key)) {
                 return 0;
 …
+        }
         if ((value.dptr == NULL) || (value.dsize <= TIMEOUT_LEN)) {
+        if (!gencache_pull_timeout((char *)data.dptr, &timeout, &endptr)) {
                 goto done;
+        }
+        endptr += 1;
         if (fnmatch(state->pattern, keystr, 0) != 0) {
 …
+        }
+        if (value.dptr[value.dsize-1] == '\0') {
+                valstr = (char *)value.dptr;
+        DEBUG(10, ("Calling function with arguments (key=%s, timeout=%s)\n",
+                   keystr, ctime(&timeout)));
+        state->fn(keystr,
+                  data_blob_const(endptr,
+                                  data.dsize - PTR_DIFF(endptr, data.dptr)),
+                  timeout, state->private_data);
+ done:
+        SAFE_FREE(free_key);
+        return 0;
+}
+void gencache_iterate_blobs(void (*fn)(const char *key, DATA_BLOB value,
+                                       time_t timeout, void *private_data),
+                            void *private_data, const char *pattern)
+{
+        struct gencache_iterate_blobs_state state;
+        if ((fn == NULL) || (pattern == NULL) || !gencache_init()) {
+                return;
+        }
+        DEBUG(5, ("Searching cache keys with pattern %s\n", pattern));
+        state.fn = fn;
+        state.pattern = pattern;
+        state.private_data = private_data;
+        state.in_persistent = false;
+        tdb_traverse(cache_notrans, gencache_iterate_blobs_fn, &state);
+        state.in_persistent = true;
+        tdb_traverse(cache, gencache_iterate_blobs_fn, &state);
+}
+/**
+ * Iterate through all entries which key matches to specified pattern
+ *
+ * @param fn pointer to the function that will be supplied with each single
+ *        matching cache entry (key, value and timeout) as an arguments
+ * @param data void pointer to an arbitrary data that is passed directly to the fn
+ *        function on each call
+ * @param keystr_pattern pattern the existing entries' keys are matched to
+ *
+ **/
+struct gencache_iterate_state {
+        void (*fn)(const char *key, const char *value, time_t timeout,
+                   void *priv);
+        void *private_data;
+};
+static void gencache_iterate_fn(const char *key, DATA_BLOB value,
+                                time_t timeout, void *private_data)
+{
+        struct gencache_iterate_state *state =
+                (struct gencache_iterate_state *)private_data;
+        char *valstr;
+        char *free_val = NULL;
+        if (value.data[value.length-1] == '\0') {
+                valstr = (char *)value.data;
         } else {
                 /* ensure 0-termination */
                 valstr = SMB_STRNDUP((char *)value.dptr, value.dsize);
+                valstr = SMB_STRNDUP((char *)value.data, value.length);
                 free_val = valstr;
+        }
-        u = strtoul(valstr, &timeout_endp, 10);
-        if ((*timeout_endp != '/') || ((timeout_endp-valstr) != TIMEOUT_LEN)) {
-                goto done;
+        }
-        timeout = u;
-        timeout_endp += 1;
         DEBUG(10, ("Calling function with arguments "
                    "(key = %s, value = %s, timeout = %s)\n",
+                   keystr, timeout_endp, ctime(&timeout)));
+        state->fn(keystr, timeout_endp, timeout, state->priv);
+ done:
+        SAFE_FREE(free_key);
+                   key, valstr, ctime(&timeout)));
+        state->fn(key, valstr, timeout, state->private_data);
         SAFE_FREE(free_val);
+        return 0;
+}
 void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
                       void* data, const char* keystr_pattern)
+}
+void gencache_iterate(void (*fn)(const char *key, const char *value,
+                                 time_t timeout, void *dptr),
+                      void *private_data, const char *pattern)
+{
         struct gencache_iterate_state state;
         if ((fn == NULL) || (keystr_pattern == NULL)) {
+        if (fn == NULL) {
                 return;
+        }
-        if (!gencache_init()) return;
-        DEBUG(5, ("Searching cache keys with pattern %s\n", keystr_pattern));
         state.fn = fn;
+        state.pattern = keystr_pattern;
+        state.priv = data;
+        state.in_persistent = false;
+        tdb_traverse(cache_notrans, gencache_iterate_fn, &state);
+        state.in_persistent = true;
+        tdb_traverse(cache, gencache_iterate_fn, &state);
+}
+        state.private_data = private_data;
+        gencache_iterate_blobs(gencache_iterate_fn, &state, pattern);
+}

trunk/server/source3/lib/idmap_cache.c

-              r414
+              r745
 #include "includes.h"
+#include "idmap_cache.h"
+#include "../libcli/security/security.h"
 /**
 …
+        }
+}
+static char* key_xid2sid_str(TALLOC_CTX* mem_ctx, char t, const char* id) {
+        return talloc_asprintf(mem_ctx, "IDMAP/%cID2SID/%s", t, id);
+}
+static char* key_xid2sid(TALLOC_CTX* mem_ctx, char t, int id) {
+        char str[32];
+        snprintf(str, sizeof(str), "%d", id);
+        return key_xid2sid_str(mem_ctx, t, str);
+}
+static char* key_sid2xid_str(TALLOC_CTX* mem_ctx, char t, const char* sid) {
+        return talloc_asprintf(mem_ctx, "IDMAP/SID2%cID/%s", t, sid);
+}
+/* static char* key_sid2xid(TALLOC_CTX* mem_ctx, char t, const struct dom_sid* sid) */
+/* { */
+/*      char* sid_str = sid_string_talloc(mem_ctx, sid); */
+/*      char* key = key_sid2xid_str(mem_ctx, t, sid_str); */
+/*      talloc_free(sid_str); */
+/*      return key; */
+/* } */
+static bool idmap_cache_del_xid(char t, int xid)
+{
+        TALLOC_CTX* mem_ctx = talloc_stackframe();
+        const char* key = key_xid2sid(mem_ctx, t, xid);
+        char* sid_str = NULL;
+        time_t timeout;
+        bool ret = true;
+        if (!gencache_get(key, &sid_str, &timeout)) {
+                DEBUG(3, ("no entry: %s\n", key));
+                ret = false;
+                goto done;
+        }
+        if (sid_str[0] != '-') {
+                const char* sid_key = key_sid2xid_str(mem_ctx, t, sid_str);
+                if (!gencache_del(sid_key)) {
+                        DEBUG(2, ("failed to delete: %s\n", sid_key));
+                        ret = false;
+                } else {
+                        DEBUG(5, ("delete: %s\n", sid_key));
+                }
+        }
+        if (!gencache_del(key)) {
+                DEBUG(1, ("failed to delete: %s\n", key));
+                ret = false;
+        } else {
+                DEBUG(5, ("delete: %s\n", key));
+        }
+done:
+        talloc_free(mem_ctx);
+        return ret;
+}
+bool idmap_cache_del_uid(uid_t uid) {
+        return idmap_cache_del_xid('U', uid);
+}
+bool idmap_cache_del_gid(gid_t gid) {
+        return idmap_cache_del_xid('G', gid);
+}
+static bool idmap_cache_del_sid2xid(TALLOC_CTX* mem_ctx, char t, const char* sid)
+{
+        const char* sid_key = key_sid2xid_str(mem_ctx, t, sid);
+        char* xid_str;
+        time_t timeout;
+        bool ret = true;
+        if (!gencache_get(sid_key, &xid_str, &timeout)) {
+                ret = false;
+                goto done;
+        }
+        if (atoi(xid_str) != -1) {
+                const char* xid_key = key_xid2sid_str(mem_ctx, t, xid_str);
+                if (!gencache_del(xid_key)) {
+                        DEBUG(2, ("failed to delete: %s\n", xid_key));
+                        ret = false;
+                } else {
+                        DEBUG(5, ("delete: %s\n", xid_key));
+                }
+        }
+        if (!gencache_del(sid_key)) {
+                DEBUG(2, ("failed to delete: %s\n", sid_key));
+                ret = false;
+        } else {
+                DEBUG(5, ("delete: %s\n", sid_key));
+        }
+done:
+        return ret;
+}
+bool idmap_cache_del_sid(const struct dom_sid *sid)
+{
+        TALLOC_CTX* mem_ctx = talloc_stackframe();
+        const char* sid_str = sid_string_talloc(mem_ctx, sid);
+        bool ret = true;
+        if (!idmap_cache_del_sid2xid(mem_ctx, 'U', sid_str) &&
+            !idmap_cache_del_sid2xid(mem_ctx, 'G', sid_str))
+        {
+                DEBUG(3, ("no entry: %s\n", key_xid2sid_str(mem_ctx, '?', sid_str)));
+                ret = false;
+        }
+        talloc_free(mem_ctx);
+        return ret;
+}

trunk/server/source3/lib/interface.c

r414	r745
20	20
21	21	#include "includes.h"
	22	#include "interfaces.h"
22	23
23	24	static struct iface_struct *probed_ifaces;

trunk/server/source3/lib/interfaces.c

-              r414
+              r745
 #include "includes.h"
+#include "interfaces.h"
 /****************************************************************************
 …
         /* now we need to remove duplicates */
         qsort(ifaces, total, sizeof(ifaces[0]), QSORT_CAST iface_comp);
+        TYPESAFE_QSORT(ifaces, total, iface_comp);
         for (i=1;i<total;) {

trunk/server/source3/lib/ldap_debug_handler.c

r414	r745
19	19
20	20	#include "includes.h"
	21	#include "smb_ldap.h"
21	22
22	23	#if defined(HAVE_LDAP) && defined(HAVE_LBER_LOG_PRINT_FN)

trunk/server/source3/lib/memcache.c

-              r414
+              r745
 struct memcache {
         struct memcache_element *mru, *lru;
+        struct memcache_element *mru;
         struct rb_root tree;
         size_t size;
 …
         if (cache->size != 0) {
-                /*
-                 * Do LRU promotion only when we will ever shrink
-                 */
-                if (e == cache->lru) {
-                        cache->lru = e->prev;
+                }
                 DLIST_PROMOTE(cache->mru, e);
-                if (cache->mru == NULL) {
-                        cache->mru = e;
+                }
+        }
 …
         rb_erase(&e->rb_node, &cache->tree);
-        if (e == cache->lru) {
-                cache->lru = e->prev;
+        }
         DLIST_REMOVE(cache->mru, e);
 …
+        }
         while ((cache->size > cache->max_size) && (cache->lru != NULL)) {
                 memcache_delete_element(cache, cache->lru);
+        while ((cache->size > cache->max_size) && DLIST_TAIL(cache->mru)) {
+                memcache_delete_element(cache, DLIST_TAIL(cache->mru));
+        }
+}
 …
         DLIST_ADD(cache->mru, e);
-        if (cache->lru == NULL) {
-                cache->lru = e;
+        }
         cache->size += element_size;
 …
+        }
-        if (node == NULL) {
-                return;
+        }
         /*
          * Then, find the leftmost element with number n

trunk/server/source3/lib/messages.c

-              r414
+              r745
 #include "includes.h"
+#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_messaging.h"
+#include "dbwrap.h"
+#include "serverid.h"
+#include "messages.h"
 struct messaging_callback {
 …
 ****************************************************************************/
+static int traverse_fn(struct db_record *rec,
+                       const struct connections_key *ckey,
+                       const struct connections_data *crec,
+                       void *state)
+static int traverse_fn(struct db_record *rec, const struct server_id *id,
+                       uint32_t msg_flags, void *state)
+{
         struct msg_all *msg_all = (struct msg_all *)state;
         NTSTATUS status;
+        if (crec->cnum != -1)
+        /* Don't send if the receiver hasn't registered an interest. */
+        if((msg_flags & msg_all->msg_flag) == 0) {
                 return 0;
+        /* Don't send if the receiver hasn't registered an interest. */
+        if(!(crec->bcast_msg_flags & msg_all->msg_flag))
+                return 0;
+        }
         /* If the msg send fails because the pid was not found (i.e. smbd died),
          * the msg has already been deleted from the messages.tdb.*/
+        status = messaging_send_buf(msg_all->msg_ctx,
+                                    crec->pid, msg_all->msg_type,
+        status = messaging_send_buf(msg_all->msg_ctx, *id, msg_all->msg_type,
                                     (uint8 *)msg_all->buf, msg_all->len);
 …
                 /* If the pid was not found delete the entry from connections.tdb */
+                DEBUG(2,("pid %s doesn't exist - deleting connections %d [%s]\n",
+                         procid_str_static(&crec->pid), crec->cnum,
+                         crec->servicename));
+                DEBUG(2, ("pid %s doesn't exist\n", procid_str_static(id)));
                 rec->delete_rec(rec);
 …
         msg_all.msg_ctx = msg_ctx;
         connections_forall(traverse_fn, &msg_all);
+        serverid_traverse(traverse_fn, &msg_all);
         if (n_sent)
                 *n_sent = msg_all.n_sent;
 …
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("messaging_tdb_init failed: %s\n",
+                DEBUG(2, ("messaging_tdb_init failed: %s\n",
                           nt_errstr(status)));
                 TALLOC_FREE(ctx);
 …
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(1, ("messaging_ctdb_init failed: %s\n",
+                        DEBUG(2, ("messaging_ctdb_init failed: %s\n",
                                   nt_errstr(status)));
                         TALLOC_FREE(ctx);
 …
+                }
+        }
+        ctx->id.vnn = get_my_vnn();
 #endif
 …
+}
+struct server_id messaging_server_id(const struct messaging_context *msg_ctx)
+{
+        return msg_ctx->id;
+}
 /*
  * re-init after a fork
  */
+NTSTATUS messaging_reinit(struct messaging_context *msg_ctx)
+NTSTATUS messaging_reinit(struct messaging_context *msg_ctx,
+                          struct server_id id)
+{
         NTSTATUS status;
         TALLOC_FREE(msg_ctx->local);
+        msg_ctx->id = id;
         status = messaging_tdb_init(msg_ctx, msg_ctx, &msg_ctx->local);
 …
 /*
   Dispatch one messsaging_rec
+  Dispatch one messaging_rec
 */
 void messaging_dispatch_rec(struct messaging_context *msg_ctx,

trunk/server/source3/lib/messages_ctdbd.c

-              r414
+              r745
 #include "includes.h"
+#include "messages.h"
+#include "util_tdb.h"
 #ifdef CLUSTER_SUPPORT
-#include "librpc/gen_ndr/messaging.h"
 #include "ctdb.h"
 #include "ctdb_private.h"
 …
         msg.msg_type    = msg_type;
         msg.dest        = pid;
         msg.src         = procid_self();
+        msg.src         = msg_ctx->id;
         msg.buf         = *data;

trunk/server/source3/lib/messages_local.c

-              r414
+              r745
    Samba internal messaging functions
    Copyright (C) 2007 by Volker Lendecke
    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/>.
 …
   @{
   @file messages.c
   @brief  Module for internal messaging between Samba daemons.
 …
 #include "includes.h"
+#include "librpc/gen_ndr/messaging.h"
+#include "librpc/gen_ndr/ndr_messaging.h"
+#include "system/filesys.h"
+#include "messages.h"
+#include "lib/util/tdb_wrap.h"
 struct messaging_tdb_context {
 …
         ctx->tdb = tdb_wrap_open(ctx, lock_path("messages.tdb"), 0,
                                  TDB_CLEAR_IF_FIRST|TDB_DEFAULT|TDB_VOLATILE,
+                                 TDB_CLEAR_IF_FIRST|TDB_DEFAULT|TDB_VOLATILE|TDB_INCOMPATIBLE_HASH,
                                  O_RDWR|O_CREAT,0600);
         if (!ctx->tdb) {
                 NTSTATUS status = map_nt_error_from_unix(errno);
                 DEBUG(0, ("ERROR: Failed to initialise messages database: "
+                DEBUG(2, ("ERROR: Failed to initialise messages database: "
                           "%s\n", strerror(errno)));
                 TALLOC_FREE(result);
 …
+}
+bool messaging_tdb_parent_init(TALLOC_CTX *mem_ctx)
+{
+        struct tdb_wrap *db;
+        /*
+         * Open the tdb in the parent process (smbd) so that our
+         * CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
+         * work.
+         */
+        db = tdb_wrap_open(mem_ctx, lock_path("messages.tdb"), 0,
+                           TDB_CLEAR_IF_FIRST|TDB_DEFAULT|TDB_VOLATILE|TDB_INCOMPATIBLE_HASH,
+                           O_RDWR|O_CREAT,0600);
+        if (db == NULL) {
+                DEBUG(1, ("could not open messaging.tdb: %s\n",
+                          strerror(errno)));
+                return false;
+        }
+        return true;
+}
 /*******************************************************************
  Form a static tdb key from a pid.
 …
         SMB_ASSERT(key != NULL);
         kbuf.dptr = (uint8 *)key;
         kbuf.dsize = strlen(key)+1;
 …
         ndr_err = ndr_pull_struct_blob(
                 &blob, result, NULL, result,
+                &blob, result, result,
                 (ndr_pull_flags_fn_t)ndr_pull_messaging_array);
 …
+        }
+        ndr_err = ndr_push_struct_blob(
+                &blob, mem_ctx, NULL, array,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, array,
                 (ndr_push_flags_fn_t)ndr_push_messaging_array);
 …
         rec[msg_array->num_messages].msg_type = msg_type & MSG_TYPE_MASK;
         rec[msg_array->num_messages].dest = pid;
         rec[msg_array->num_messages].src = procid_self();
+        rec[msg_array->num_messages].src = msg_ctx->id;
         rec[msg_array->num_messages].buf = *data;
 …
                 goto done;
+        }
         status = message_notify(pid);
 …
 /****************************************************************************
  Retrieve all messages for the current process.
+ Retrieve all messages for a process.
 ****************************************************************************/
 static NTSTATUS retrieve_all_messages(TDB_CONTEXT *msg_tdb,
+                                      struct server_id id,
                                       TALLOC_CTX *mem_ctx,
                                       struct messaging_array **presult)
+{
         struct messaging_array *result;
         TDB_DATA key = message_key_pid(mem_ctx, procid_self());
+        TDB_DATA key = message_key_pid(mem_ctx, id);
         NTSTATUS status;
 …
                    ctx->received_messages));
         status = retrieve_all_messages(tdb->tdb, NULL, &msg_array);
+        status = retrieve_all_messages(tdb->tdb, msg_ctx->id, NULL, &msg_array);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("message_dispatch: failed to retrieve messages: %s\n",

trunk/server/source3/lib/ms_fnmatch.c

r414	r745
235	235	int gen_fnmatch(const char pattern, const char string)
236	236	{
237		return ms_fnmatch(pattern, string, ~~PROTOCOL_NT1~~, False);
238		}
	237	return ms_fnmatch(pattern, string, true, False);
	238	}

trunk/server/source3/lib/netapi/cm.c

-              r590
+              r745
 #include "includes.h"
+#include "popt_common.h"
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
+#include "libsmb/libsmb.h"
+#include "rpc_client/cli_pipe.h"
 /********************************************************************
 …
         return WERR_OK;
+}
+/********************************************************************
+********************************************************************/
+WERROR libnetapi_get_binding_handle(struct libnetapi_ctx *ctx,
+                                    const char *server_name,
+                                    const struct ndr_syntax_id *interface,
+                                    struct dcerpc_binding_handle **binding_handle)
+{
+        struct rpc_pipe_client *pipe_cli;
+        WERROR result;
+        *binding_handle = NULL;
+        result = libnetapi_open_pipe(ctx, server_name, interface, &pipe_cli);
+        if (!W_ERROR_IS_OK(result)) {
+                return result;
+        }
+        *binding_handle = pipe_cli->binding_handle;
+        return WERR_OK;
+}

trunk/server/source3/lib/netapi/examples/netdomjoin-gui/netdomjoin-gui.c

r480	r745
479	479	p = strchr(newname, '.');
480	480	if (p) {
481		*p = ~~NULL~~;
	481	*p = '\0';
482	482	}
483	483

trunk/server/source3/lib/netapi/examples/netlogon/nltest.c

-              r414
+              r745
 enum {
+        OPT_DBFLAG = 1,
+        OPT_SERVER = 1,
+        OPT_DBFLAG,
         OPT_SC_QUERY,
         OPT_SC_RESET,
         OPT_SC_VERIFY,
+        OPT_SC_CHANGE_PWD
+        OPT_SC_CHANGE_PWD,
+        OPT_DSGETDC,
+        OPT_PDC,
+        OPT_DS,
+        OPT_DSP,
+        OPT_GC,
+        OPT_KDC,
+        OPT_TIMESERV,
+        OPT_GTIMESERV,
+        OPT_WS,
+        OPT_NETBIOS,
+        OPT_DNS,
+        OPT_IP,
+        OPT_FORCE,
+        OPT_WRITABLE,
+        OPT_AVOIDSELF,
+        OPT_LDAPONLY,
+        OPT_BACKG,
+        OPT_DS_6,
+        OPT_TRY_NEXT_CLOSEST_SITE,
+        OPT_SITE,
+        OPT_ACCOUNT,
+        OPT_RET_DNS,
+        OPT_RET_NETBIOS,
+        OPT_DSREGDNS
 };
 …
 ****************************************************************/
 static void print_result(uint32_t level,
                          uint8_t *buffer)
+static void print_netlogon_info_result(uint32_t level,
+                                       uint8_t *buffer)
+{
         struct NETLOGON_INFO_1 *i1 = NULL;
 …
 ****************************************************************/
+static void print_dc_info_flags(uint32_t flags)
+{
+        if (flags & DS_PDC_FLAG)
+                printf("PDC ");
+        if (flags & DS_GC_FLAG)
+                printf("GC ");
+        if (flags & DS_DS_FLAG)
+                printf("DS ");
+        if (flags & DS_LDAP_FLAG)
+                printf("LDAP ");
+        if (flags & DS_KDC_FLAG)
+                printf("KDC ");
+        if (flags & DS_TIMESERV_FLAG)
+                printf("TIMESERV ");
+        if (flags & DS_GOOD_TIMESERV_FLAG)
+                printf("GTIMESERV ");
+        if (flags & DS_WRITABLE_FLAG)
+                printf("WRITABLE ");
+        if (flags & DS_DNS_FOREST_FLAG)
+                printf("DNS_FOREST ");
+        if (flags & DS_CLOSEST_FLAG)
+                printf("CLOSE_SITE ");
+        if (flags & DS_FULL_SECRET_DOMAIN_6_FLAG)
+                printf("FULL_SECRET ");
+        /* "WS" */
+        printf("\n");
+}
+/****************************************************************
+****************************************************************/
+static void print_dc_info(struct DOMAIN_CONTROLLER_INFO *dc_info)
+{
+        if (dc_info->flags) {
+                printf("           DC: %s\n", dc_info->domain_controller_name);
+                printf("      Address: %s\n", dc_info->domain_controller_address);
+/*              printf("     Dom Guid: %s\n", X(domain_guid)); */
+                printf("     Dom Name: %s\n", dc_info->domain_name);
+                printf("  Forest Name: %s\n", dc_info->dns_forest_name);
+                printf(" Dc Site Name: %s\n", dc_info->dc_site_name);
+                printf("Our Site Name: %s\n", dc_info->client_site_name);
+                printf("        Flags: ");
+                print_dc_info_flags(dc_info->flags);
+        } else {
+                printf("           DC: %s\n", dc_info->domain_controller_name);
+                printf("      Address: %s\n", dc_info->domain_controller_address);
+                printf("     Dom Name: %s\n", dc_info->domain_name);
+        }
+}
+/****************************************************************
+****************************************************************/
 int main(int argc, const char **argv)
+{
 …
         NET_API_STATUS status;
         struct libnetapi_ctx *ctx = NULL;
         const char *server_name = NULL;
+        char *opt_server = NULL;
         char *opt_domain = NULL;
         int opt_dbflag = 0;
+        uint32_t query_level;
+        int opt_pdc = 0;
+        int opt_ds = 0;
+        int opt_dsp = 0;
+        int opt_gc = 0;
+        int opt_kdc = 0;
+        int opt_timeserv = 0;
+        int opt_gtimeserv = 0;
+        int opt_ws = 0;
+        int opt_netbios = 0;
+        int opt_dns = 0;
+        int opt_ip = 0;
+        int opt_force = 0;
+        int opt_writable = 0;
+        int opt_avoidself = 0;
+        int opt_ldaponly = 0;
+        int opt_backg = 0;
+        int opt_ds_6 = 0;
+        int opt_try_next_closest_site = 0;
+        char *opt_site = NULL;
+        char *opt_account = NULL;
+        int opt_ret_dns = 0;
+        int opt_ret_netbios = 0;
+        int opt_dsregdns = 0;
+        uint32_t query_level = 0;
         uint8_t *buffer = NULL;
+        uint32_t flags = 0;
+        struct DOMAIN_CONTROLLER_INFO *dc_info = NULL;
         poptContext pc;
         struct poptOption long_options[] = {
                 POPT_AUTOHELP
+                {"server", 0, POPT_ARG_STRING, &opt_server, OPT_SERVER, "Servername", "SERVER"},
                 {"dbflag", 0, POPT_ARG_INT,   &opt_dbflag, OPT_DBFLAG, "New Debug Flag", "HEXFLAGS"},
                 {"sc_query", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_QUERY, "Query secure channel for domain on server", "DOMAIN"},
 …
                 {"sc_verify", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_VERIFY, "Verify secure channel for domain on server", "DOMAIN"},
                 {"sc_change_pwd", 0, POPT_ARG_STRING,   &opt_domain, OPT_SC_CHANGE_PWD, "Change a secure channel password for domain on server", "DOMAIN"},
+                {"dsgetdc", 0, POPT_ARG_STRING, &opt_domain, OPT_DSGETDC, "Call DsGetDcName", "DOMAIN"},
+                {"pdc", 0, POPT_ARG_NONE, &opt_pdc, OPT_PDC, NULL},
+                {"ds", 0, POPT_ARG_NONE, &opt_ds, OPT_DS, NULL},
+                {"dsp", 0, POPT_ARG_NONE, &opt_dsp, OPT_DSP, NULL},
+                {"gc", 0, POPT_ARG_NONE, &opt_gc, OPT_GC, NULL},
+                {"kdc", 0, POPT_ARG_NONE, &opt_kdc, OPT_KDC, NULL},
+                {"timeserv", 0, POPT_ARG_NONE, &opt_timeserv, OPT_TIMESERV, NULL},
+                {"gtimeserv", 0, POPT_ARG_NONE, &opt_gtimeserv, OPT_GTIMESERV, NULL},
+                {"ws", 0, POPT_ARG_NONE, &opt_ws, OPT_WS, NULL},
+                {"netbios", 0, POPT_ARG_NONE, &opt_netbios, OPT_NETBIOS, NULL},
+                {"dns", 0, POPT_ARG_NONE, &opt_dns, OPT_DNS, NULL},
+                {"ip", 0, POPT_ARG_NONE, &opt_ip, OPT_IP, NULL},
+                {"force", 0, POPT_ARG_NONE, &opt_force, OPT_FORCE, NULL},
+                {"writable", 0, POPT_ARG_NONE, &opt_writable, OPT_WRITABLE, NULL},
+                {"avoidself", 0, POPT_ARG_NONE, &opt_avoidself, OPT_AVOIDSELF, NULL},
+                {"ldaponly", 0, POPT_ARG_NONE, &opt_ldaponly, OPT_LDAPONLY, NULL},
+                {"backg", 0, POPT_ARG_NONE, &opt_backg, OPT_BACKG, NULL},
+                {"ds_6", 0, POPT_ARG_NONE, &opt_ds_6, OPT_DS_6, NULL},
+                {"try_next_closest_site", 0, POPT_ARG_NONE, &opt_try_next_closest_site, OPT_TRY_NEXT_CLOSEST_SITE, NULL},
+                {"site", 0, POPT_ARG_STRING, &opt_site, OPT_SITE, "SITE"},
+                {"account", 0, POPT_ARG_STRING, &opt_account, OPT_ACCOUNT, "ACCOUNT"},
+                {"ret_dns", 0, POPT_ARG_NONE, &opt_ret_dns, OPT_RET_DNS, NULL},
+                {"ret_netbios", 0, POPT_ARG_NONE, &opt_ret_netbios, OPT_RET_NETBIOS, NULL},
+                {"dsregdns", 0, POPT_ARG_NONE, &opt_dsregdns, OPT_DSREGDNS, "Force registration of all DC-specific DNS records"},
                 POPT_COMMON_LIBNETAPI_EXAMPLES
                 POPT_TABLEEND
 …
         pc = poptGetContext("nltest", argc, argv, long_options, 0);
         poptSetOtherOptionHelp(pc, "server_name");
+        poptSetOtherOptionHelp(pc, "<options>");
         while((opt = poptGetNextOpt(pc)) != -1) {
+        }
-        if (!poptPeekArg(pc)) {
-                poptPrintHelp(pc, stderr, 0);
-                goto done;
+        }
-        server_name = poptGetArg(pc);
         if (argc == 1) {
 …
+        }
-        if (!server_name || poptGetArg(pc)) {
-                poptPrintHelp(pc, stderr, 0);
-                goto done;
+        }
-        if ((server_name[0] == '/' && server_name[1] == '/') ||
-            (server_name[0] == '\\' && server_name[1] ==  '\\')) {
-                server_name += 2;
+        }
         poptResetContext(pc);
 …
                 switch (opt) {
+                case OPT_SERVER:
+                        if ((opt_server[0] == '/' && opt_server[1] == '/') ||
+                            (opt_server[0] == '\\' && opt_server[1] ==  '\\')) {
+                                opt_server += 2;
+                        }
+                        break;
                 case OPT_DBFLAG:
                         query_level = 1;
                         status = I_NetLogonControl2(server_name,
+                        status = I_NetLogonControl2(opt_server,
                                                     NETLOGON_CONTROL_SET_DBFLAG,
                                                     query_level,
 …
                                 goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
                         break;
                 case OPT_SC_QUERY:
                         query_level = 2;
                         status = I_NetLogonControl2(server_name,
+                        status = I_NetLogonControl2(opt_server,
                                                     NETLOGON_CONTROL_TC_QUERY,
                                                     query_level,
 …
                                 goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
                         break;
                 case OPT_SC_VERIFY:
                         query_level = 2;
                         status = I_NetLogonControl2(server_name,
+                        status = I_NetLogonControl2(opt_server,
                                                     NETLOGON_CONTROL_TC_VERIFY,
                                                     query_level,
 …
                                 goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
                         break;
                 case OPT_SC_RESET:
                         query_level = 2;
                         status = I_NetLogonControl2(server_name,
+                        status = I_NetLogonControl2(opt_server,
                                                     NETLOGON_CONTROL_REDISCOVER,
                                                     query_level,
 …
                                 goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
                         break;
                 case OPT_SC_CHANGE_PWD:
                         query_level = 1;
                         status = I_NetLogonControl2(server_name,
+                        status = I_NetLogonControl2(opt_server,
                                                     NETLOGON_CONTROL_CHANGE_PASSWORD,
                                                     query_level,
 …
                                 goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
+                        break;
+                case OPT_DSREGDNS:
+                        query_level = 1;
+                        status = I_NetLogonControl2(opt_server,
+                                                    NETLOGON_CONTROL_FORCE_DNS_REG,
+                                                    query_level,
+                                                    NULL,
+                                                    &buffer);
+                        if (status != 0) {
+                                fprintf(stderr, "I_NetlogonControl failed: Status = %d 0x%x %s\n",
+                                        status, status,
+                                        libnetapi_get_error_string(ctx, status));
+                                goto done;
+                        }
+                        print_netlogon_info_result(query_level, buffer);
+                        break;
+                case OPT_DSGETDC:
+                        if (opt_pdc)
+                                flags |= DS_PDC_REQUIRED;
+                        if (opt_ds)
+                                flags |= DS_DIRECTORY_SERVICE_REQUIRED;
+                        if (opt_dsp)
+                                flags |= DS_DIRECTORY_SERVICE_PREFERRED;
+                        if (opt_kdc)
+                                flags |= DS_KDC_REQUIRED;
+                        if (opt_timeserv)
+                                flags |= DS_TIMESERV_REQUIRED;
+                        if (opt_gtimeserv)
+                                flags |= DS_GOOD_TIMESERV_PREFERRED;
+                        if (opt_ws)
+                                flags |= DS_WEB_SERVICE_REQUIRED;
+                        if (opt_netbios)
+                                flags |= DS_IS_FLAT_NAME;
+                        if (opt_dns)
+                                flags |= DS_IS_DNS_NAME;
+                        if (opt_ip)
+                                flags |= DS_IP_REQUIRED;
+                        if (opt_force)
+                                flags |= DS_FORCE_REDISCOVERY;
+                        if (opt_writable)
+                                flags |= DS_WRITABLE_REQUIRED;
+                        if (opt_avoidself)
+                                flags |= DS_AVOID_SELF;
+                        if (opt_ldaponly)
+                                flags |= DS_ONLY_LDAP_NEEDED;
+                        if (opt_backg)
+                                flags |= DS_BACKGROUND_ONLY;
+                        if (opt_ds_6)
+                                flags |= DS_DIRECTORY_SERVICE_6_REQUIRED;
+                        if (opt_try_next_closest_site)
+                                flags |= DS_TRY_NEXTCLOSEST_SITE;
+                        if (opt_ret_dns)
+                                flags |= DS_RETURN_DNS_NAME;
+                        if (opt_ret_netbios)
+                                flags |= DS_RETURN_FLAT_NAME;
+                        status = DsGetDcName(opt_server,
+                                             opt_domain,
+                                             NULL, /* domain_guid */
+                                             opt_site,
+                                             flags,
+                                             &dc_info);
+                        if (status != 0) {
+                                fprintf(stderr, "DsGetDcName failed: Status = %d 0x%x %s\n",
+                                        status, status,
+                                        libnetapi_get_error_string(ctx, status));
+                                goto done;
+                        }
+                        print_dc_info(dc_info);
                         break;
                 default:
+                        poptPrintHelp(pc, stderr, 0);
+                        goto done;
+                        continue;
+                }
+        }
-        print_result(query_level, buffer);
         printf("The command completed successfully\n");

trunk/server/source3/lib/netapi/file.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
 #include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
 /****************************************************************
 …
         WERROR werr;
         NTSTATUS status;
         struct rpc_pipe_client *pipe_cli = NULL;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetFileClose(pipe_cli, talloc_tos(),
+        struct dcerpc_binding_handle *b;
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_srvsvc_NetFileClose(b, talloc_tos(),
                                             r->in.server_name,
                                             r->in.fileid,
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union srvsvc_NetFileInfo info;
         uint32_t num_entries = 0;
+        struct dcerpc_binding_handle *b;
         if (!r->out.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetFileGetInfo(pipe_cli, talloc_tos(),
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_srvsvc_NetFileGetInfo(b, talloc_tos(),
                                               r->in.server_name,
                                               r->in.fileid,
 …
                                               &info,
                                               &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         struct srvsvc_NetFileInfoCtr info_ctr;
         struct srvsvc_NetFileCtr2 ctr2;
 …
         uint32_t num_entries = 0;
         uint32_t i;
+        struct dcerpc_binding_handle *b;
         if (!r->out.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
+        }
         status = rpccli_srvsvc_NetFileEnum(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetFileEnum(b, talloc_tos(),
                                            r->in.server_name,
                                            r->in.base_path,
 …
                                            r->out.resume_handle,
                                            &werr);
+        if (NT_STATUS_IS_ERR(status)) {
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr) && !W_ERROR_EQUAL(werr, WERR_MORE_DATA)) {
                 goto done;
+        }

trunk/server/source3/lib/netapi/getdc.c

-              r596
+              r745
 #include "includes.h"
+#include "../librpc/gen_ndr/ndr_netlogon_c.h"
 #include "librpc/gen_ndr/libnetapi.h"
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
-#include "libnet/libnet.h"
-#include "../librpc/gen_ndr/cli_netlogon.h"
 /********************************************************************
 …
                       struct NetGetDCName *r)
+{
-        struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
         WERROR werr;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_netlogon.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_netlogon.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_netr_GetDcName(pipe_cli, talloc_tos(),
+        status = dcerpc_netr_GetDcName(b, talloc_tos(),
                                        r->in.server_name,
                                        r->in.domain_name,
 …
                          struct NetGetAnyDCName *r)
+{
-        struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
         WERROR werr;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_netlogon.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_netlogon.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_netr_GetAnyDCName(pipe_cli, talloc_tos(),
+        status = dcerpc_netr_GetAnyDCName(b, talloc_tos(),
                                           r->in.server_name,
                                           r->in.domain_name,
 …
                                           &werr);
         if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
                 goto done;
+        }
 …
+{
         NTSTATUS status;
+        struct libnetapi_private_ctx *priv;
+        priv = talloc_get_type_abort(ctx->private_data,
+                struct libnetapi_private_ctx);
         status = dsgetdcname(ctx,
                              NULL,
+                             priv->msg_ctx,
                              r->in.domain_name,
                              r->in.domain_guid,
 …
         WERROR werr;
         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
         struct rpc_pipe_client *pipe_cli = NULL;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_netlogon.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_netlogon.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
+        status = rpccli_netr_DsRGetDCName(pipe_cli,
+        status = dcerpc_netr_DsRGetDCNameEx(b,
+                                            ctx,
+                                            r->in.server_name,
+                                            r->in.domain_name,
+                                            r->in.domain_guid,
+                                            r->in.site_name,
+                                            r->in.flags,
+                                            (struct netr_DsRGetDCNameInfo **)r->out.dc_info,
+                                            &werr);
+        if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_netr_DsRGetDCName(b,
                                           ctx,
                                           r->in.server_name,

trunk/server/source3/lib/netapi/group.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "../librpc/gen_ndr/cli_samr.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/security.h"
 /****************************************************************
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
 …
         struct dom_sid2 *domain_sid = NULL;
         uint32_t rid = 0;
+        struct dcerpc_binding_handle *b = NULL;
         struct GROUP_INFO_0 *info0 = NULL;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_CreateDomainGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_CreateDomainGroup(b, talloc_tos(),
                                                &domain_handle,
                                                &lsa_group_name,
 …
                                                SAMR_GROUP_ACCESS_SET_INFO,
                                                &group_handle,
+                                               &rid);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                               &rid,
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
                                                 info1->grpi1_comment);
                                 status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                                status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                                   &group_handle,
                                                                   GROUPINFODESCRIPTION,
+                                                                  &info);
+                                                                  &info,
+                                                                  &result);
+                        }
                         break;
 …
                                                 info2->grpi2_comment);
                                 status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                                status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                                   &group_handle,
                                                                   GROUPINFODESCRIPTION,
+                                                                  &info);
+                                                                  &info,
+                                                                  &result);
                                 if (!NT_STATUS_IS_OK(status)) {
                                         werr = ntstatus_to_werror(status);
                                         goto failed;
+                                }
+                                if (!NT_STATUS_IS_OK(result)) {
+                                        werr = ntstatus_to_werror(result);
+                                        goto failed;
+                                }
+                        }
                         if (info2->grpi2_attributes != 0) {
                                 info.attributes.attributes = info2->grpi2_attributes;
                                 status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                                status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                                   &group_handle,
                                                                   GROUPINFOATTRIBUTES,
+                                                                  &info);
+                                                                  &info,
+                                                                  &result);
+                        }
 …
                                                 info3->grpi3_comment);
                                 status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                                status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                                   &group_handle,
                                                                   GROUPINFODESCRIPTION,
+                                                                  &info);
+                                                                  &info,
+                                                                  &result);
                                 if (!NT_STATUS_IS_OK(status)) {
                                         werr = ntstatus_to_werror(status);
                                         goto failed;
+                                }
+                                if (!NT_STATUS_IS_OK(result)) {
+                                        werr = ntstatus_to_werror(result);
+                                        goto failed;
+                                }
+                        }
                         if (info3->grpi3_attributes != 0) {
                                 info.attributes.attributes = info3->grpi3_attributes;
                                 status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                                status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                                   &group_handle,
                                                                   GROUPINFOATTRIBUTES,
+                                                                  &info);
+                                                                  &info,
+                                                                  &result);
+                        }
                         break;
 …
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto failed;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto failed;
+        }
 …
  failed:
         rpccli_samr_DeleteDomainGroup(pipe_cli, talloc_tos(),
                                       &group_handle);
+        dcerpc_samr_DeleteDomainGroup(b, talloc_tos(),
+                                      &group_handle, &result);
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
 …
         struct dom_sid2 *domain_sid = NULL;
         int i = 0;
+        struct dcerpc_binding_handle *b = NULL;
         struct samr_Ids rids;
         struct samr_Ids types;
         union samr_GroupInfo *info = NULL;
         struct samr_RidTypeArray *rid_array = NULL;
+        struct samr_RidAttrArray *rid_array = NULL;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_group_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_group_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SEC_STD_DELETE |
 …
                                        SAMR_GROUP_ACCESS_LOOKUP_INFO,
                                        rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_QueryGroupInfo(b, talloc_tos(),
                                             &group_handle,
                                             GROUPINFOATTRIBUTES,
+                                            &info);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
 #endif
         status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryGroupMember(b, talloc_tos(),
                                               &group_handle,
+                                              &rid_array);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                              &rid_array,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         struct samr_Ids member_types;
         status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupRids(b, talloc_tos(),
                                         &domain_handle,
                                         rid_array->count,
                                         rid_array->rids,
                                         &names,
+                                        &member_types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                        &member_types,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         for (i=0; i < rid_array->count; i++) {
                 status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_DeleteGroupMember(b, talloc_tos(),
                                                        &group_handle,
+                                                       rid_array->rids[i]);
+                                                       rid_array->rids[i],
+                                                       &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+        }
+        status = rpccli_samr_DeleteDomainGroup(pipe_cli, talloc_tos(),
+                                               &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
+        status = dcerpc_samr_DeleteDomainGroup(b, talloc_tos(),
+                                               &group_handle,
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
         struct lsa_String lsa_group_name;
         struct dom_sid2 *domain_sid = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         struct samr_Ids rids;
 …
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
                                           SAMR_ACCESS_ENUM_DOMAINS |
 …
         init_lsa_String(&lsa_group_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_group_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_SET_INFO |
                                        SAMR_GROUP_ACCESS_LOOKUP_INFO,
                                        rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
                         g0 = (struct GROUP_INFO_0 *)r->in.buffer;
                         init_lsa_String(&info.name, g0->grpi0_name);
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFONAME,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 case 1:
                         g1 = (struct GROUP_INFO_1 *)r->in.buffer;
                         init_lsa_String(&info.description, g1->grpi1_comment);
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFODESCRIPTION,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 case 2:
                         g2 = (struct GROUP_INFO_2 *)r->in.buffer;
                         init_lsa_String(&info.description, g2->grpi2_comment);
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFODESCRIPTION,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         if (!NT_STATUS_IS_OK(status)) {
                                 werr = ntstatus_to_werror(status);
                                 goto done;
+                        }
+                        if (!NT_STATUS_IS_OK(result)) {
+                                werr = ntstatus_to_werror(result);
+                                goto done;
+                        }
                         info.attributes.attributes = g2->grpi2_attributes;
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFOATTRIBUTES,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 case 3:
                         g3 = (struct GROUP_INFO_3 *)r->in.buffer;
                         init_lsa_String(&info.description, g3->grpi3_comment);
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFODESCRIPTION,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         if (!NT_STATUS_IS_OK(status)) {
                                 werr = ntstatus_to_werror(status);
                                 goto done;
+                        }
+                        if (!NT_STATUS_IS_OK(result)) {
+                                werr = ntstatus_to_werror(result);
+                                goto done;
+                        }
                         info.attributes.attributes = g3->grpi3_attributes;
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFOATTRIBUTES,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 case 1002:
                         g1002 = (struct GROUP_INFO_1002 *)r->in.buffer;
                         init_lsa_String(&info.description, g1002->grpi1002_comment);
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFODESCRIPTION,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 case 1005:
                         g1005 = (struct GROUP_INFO_1005 *)r->in.buffer;
                         info.attributes.attributes = g1005->grpi1005_attributes;
                         status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetGroupInfo(b, talloc_tos(),
                                                           &group_handle,
                                                           GROUPINFOATTRIBUTES,
+                                                          &info);
+                                                          &info,
+                                                          &result);
                         break;
                 default:
 …
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         werr = WERR_OK;
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
                         info3.grpi3_comment     = info->description.string;
                         info3.grpi3_attributes  = info->attributes;
                         info3.grpi3_group_sid   = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
+                        info3.grpi3_group_sid   = (struct domsid *)dom_sid_dup(mem_ctx, &sid);
                         *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info3, sizeof(info3));
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
         struct lsa_String lsa_group_name;
         struct dom_sid2 *domain_sid = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         struct samr_Ids rids;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_group_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_group_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_LOOKUP_INFO,
                                        rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_QueryGroupInfo(b, talloc_tos(),
                                             &group_handle,
                                             GROUPINFOALL2,
+                                            &info);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
+                status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
+                                            &info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (NT_STATUS_EQUAL(result, NT_STATUS_INVALID_INFO_CLASS)) {
+                status = dcerpc_samr_QueryGroupInfo(b, talloc_tos(),
                                                     &group_handle,
                                                     GROUPINFOALL,
+                                                    &info);
+                                                    &info,
+                                                    &result);
                 group_info_all = true;
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        goto done;
+                }
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
         struct lsa_String lsa_group_name, lsa_user_name;
         struct dom_sid2 *domain_sid = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         struct samr_Ids rids;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_group_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_group_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 werr = WERR_GROUPNOTFOUND;
                 goto done;
 …
+        }
         status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_ADD_MEMBER,
                                        rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         init_lsa_String(&lsa_user_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_user_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 werr = WERR_USER_NOT_FOUND;
                 goto done;
 …
+        }
         status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_AddGroupMember(b, talloc_tos(),
                                             &group_handle,
                                             rids.ids[0],
+); /* why ? */
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+, /* why ? */
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, group_handle;
         struct lsa_String lsa_group_name, lsa_user_name;
         struct dom_sid2 *domain_sid = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         struct samr_Ids rids;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_group_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_group_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 werr = WERR_GROUPNOTFOUND;
                 goto done;
 …
+        }
         status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_REMOVE_MEMBER,
                                        rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         init_lsa_String(&lsa_user_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_user_name,
                                          &rids,
+                                         &types);
+        if (!NT_STATUS_IS_OK(status)) {
+                                         &types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
                 werr = WERR_USER_NOT_FOUND;
                 goto done;
 …
+        }
         status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_DeleteGroupMember(b, talloc_tos(),
                                                &group_handle,
+                                               rids.ids[0]);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                               rids.ids[0],
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
                 g3[i].grpi3_comment = talloc_strdup(mem_ctx,
                         groups->entries[i].description.string);
                 g3[i].grpi3_group_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
+                g3[i].grpi3_group_sid = (struct domsid *)dom_sid_dup(mem_ctx, &sid);
                 g3[i].grpi3_attributes = groups->entries[i].acct_flags;
                 W_ERROR_HAVE_NO_MEMORY(g3[i].grpi3_name);
 …
         union samr_DispInfo info;
         union samr_DomainInfo *domain_info = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         uint32_t total_size = 0;
         uint32_t returned_size = 0;
+        NTSTATUS result = NT_STATUS_OK;
         NTSTATUS status = NT_STATUS_OK;
         WERROR werr, tmp_werr;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryDomainInfo(b, talloc_tos(),
                                              &domain_handle,
 ,
+                                             &domain_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                             &domain_info,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
+        status = dcerpc_samr_QueryDisplayInfo2(b,
                                                ctx,
                                                &domain_handle,
 …
                                                &total_size,
                                                &returned_size,
+                                               &info);
+        werr = ntstatus_to_werror(status);
+        if (NT_STATUS_IS_ERR(status)) {
+                                               &info,
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        werr = ntstatus_to_werror(result);
+        if (NT_STATUS_IS_ERR(result)) {
                 goto done;
+        }
 …
  done:
         /* if last query */
         if (NT_STATUS_IS_OK(status) ||
             NT_STATUS_IS_ERR(status)) {
+        if (NT_STATUS_IS_OK(result) ||
+            NT_STATUS_IS_ERR(result)) {
                 if (ctx->disable_policy_handle_cache) {
 …
         struct dom_sid2 *domain_sid = NULL;
         struct samr_Ids group_rids, name_types;
         struct samr_RidTypeArray *rid_array = NULL;
+        struct samr_RidAttrArray *rid_array = NULL;
         struct lsa_Strings names;
         struct samr_Ids member_types;
+        struct dcerpc_binding_handle *b = NULL;
         int i;
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &group_rids,
+                                         &name_types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+                                         &name_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_GET_MEMBERS,
                                        group_rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_QueryGroupMember(b, talloc_tos(),
                                               &group_handle,
+                                              &rid_array);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
+                                              &rid_array,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_LookupRids(b, talloc_tos(),
                                         &domain_handle,
                                         rid_array->count,
                                         rid_array->rids,
                                         &names,
+                                        &member_types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                        &member_types,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
         struct samr_Ids user_rids, name_types;
         struct samr_Ids group_rids, group_types;
         struct samr_RidTypeArray *rid_array = NULL;
+        struct samr_RidAttrArray *rid_array = NULL;
         struct lsa_String *lsa_names = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         uint32_t *add_rids = NULL;
 …
         uint32_t *member_rids = NULL;
-        size_t num_member_rids = 0;
         struct GROUP_USERS_INFO_0 *i0 = NULL;
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, r->in.group_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &group_rids,
+                                         &group_types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+                                         &group_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                        &domain_handle,
                                        SAMR_GROUP_ACCESS_GET_MEMBERS |
 …
                                        SAMR_GROUP_ACCESS_LOOKUP_INFO,
                                        group_rids.ids[0],
+                                       &group_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
+                                       &group_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_QueryGroupInfo(b, talloc_tos(),
                                             &group_handle,
                                             GROUPINFOATTRIBUTES,
+                                            &group_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                            &group_info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
                                          r->in.num_entries,
                                          lsa_names,
                                          &user_rids,
+                                         &name_types);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                         &name_types,
+                                         &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
         member_rids = user_rids.ids;
+        num_member_rids = user_rids.count;
+        status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryGroupMember(b, talloc_tos(),
                                               &group_handle,
+                                              &rid_array);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                                              &rid_array,
+                                              &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         for (i=0; i < num_add_rids; i++) {
                 status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_AddGroupMember(b, talloc_tos(),
                                                     &group_handle,
                                                     add_rids[i],
+/* ? */);
+/* ? */,
+                                                    &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
 …
         for (i=0; i < num_del_rids; i++) {
                 status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_DeleteGroupMember(b, talloc_tos(),
                                                        &group_handle,
+                                                       del_rids[i]);
+                                                       del_rids[i],
+                                                       &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }

trunk/server/source3/lib/netapi/joindomain.c

-              r596
+              r745
 #include "includes.h"
+#include "ads.h"
 #include "librpc/gen_ndr/libnetapi.h"
+#include "libcli/auth/libcli_auth.h"
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "libnet/libnet.h"
+#include "libcli/auth/libcli_auth.h"
+#include "../librpc/gen_ndr/cli_wkssvc.h"
+#include "librpc/gen_ndr/libnet_join.h"
+#include "libnet/libnet_join.h"
+#include "../librpc/gen_ndr/ndr_wkssvc_c.h"
+#include "rpc_client/cli_pipe.h"
+#include "secrets.h"
 /****************************************************************
 …
+{
         struct libnet_JoinCtx *j = NULL;
+        WERROR werr;
+        struct libnetapi_private_ctx *priv;
+        WERROR werr;
+        priv = talloc_get_type_abort(mem_ctx->private_data,
+                struct libnetapi_private_ctx);
         if (!r->in.domain) {
 …
                                  DS_WRITABLE_REQUIRED |
                                  DS_RETURN_DNS_NAME;
                 status = dsgetdcname(mem_ctx, NULL, r->in.domain,
+                status = dsgetdcname(mem_ctx, priv->msg_ctx, r->in.domain,
                                      NULL, NULL, flags, &info);
                 if (!NT_STATUS_IS_OK(status)) {
 …
         WERROR werr;
         unsigned int old_timeout = 0;
+        struct dcerpc_binding_handle *b;
+        DATA_BLOB session_key;
         werr = libnetapi_open_pipe(ctx, r->in.server,
 …
+        }
+        if (r->in.password) {
+        b = pipe_cli->binding_handle;
+        if (r->in.password) {
+                status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        goto done;
+                }
                 encode_wkssvc_join_password_buffer(ctx,
                                                    r->in.password,
                                                    &pipe_cli->auth->user_session_key,
+                                                   &session_key,
                                                    &encrypted_password);
+        }
 …
         old_timeout = rpccli_set_timeout(pipe_cli, 600000);
         status = rpccli_wkssvc_NetrJoinDomain2(pipe_cli, talloc_tos(),
+        status = dcerpc_wkssvc_NetrJoinDomain2(b, talloc_tos(),
                                                r->in.server,
                                                r->in.domain,
 …
         const char *domain = NULL;
         WERROR werr;
+        struct libnetapi_private_ctx *priv;
+        priv = talloc_get_type_abort(mem_ctx->private_data,
+                struct libnetapi_private_ctx);
         if (!secrets_fetch_domain_sid(lp_workgroup(), &domain_sid)) {
 …
                                  DS_WRITABLE_REQUIRED |
                                  DS_RETURN_DNS_NAME;
                 status = dsgetdcname(mem_ctx, NULL, domain,
+                status = dsgetdcname(mem_ctx, priv->msg_ctx, domain,
                                      NULL, NULL, flags, &info);
                 if (!NT_STATUS_IS_OK(status)) {
 …
         WERROR werr;
         unsigned int old_timeout = 0;
+        struct dcerpc_binding_handle *b;
+        DATA_BLOB session_key;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 …
+        }
+        if (r->in.password) {
+        b = pipe_cli->binding_handle;
+        if (r->in.password) {
+                status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        goto done;
+                }
                 encode_wkssvc_join_password_buffer(ctx,
                                                    r->in.password,
                                                    &pipe_cli->auth->user_session_key,
+                                                   &session_key,
                                                    &encrypted_password);
+        }
 …
         old_timeout = rpccli_set_timeout(pipe_cli, 60000);
         status = rpccli_wkssvc_NetrUnjoinDomain2(pipe_cli, talloc_tos(),
+        status = dcerpc_wkssvc_NetrUnjoinDomain2(b, talloc_tos(),
                                                  r->in.server_name,
                                                  r->in.account,
 …
         WERROR werr;
         const char *buffer = NULL;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 …
+        }
+        status = rpccli_wkssvc_NetrGetJoinInformation(pipe_cli, talloc_tos(),
+        b = pipe_cli->binding_handle;
+        status = dcerpc_wkssvc_NetrGetJoinInformation(b, talloc_tos(),
                                                       r->in.server_name,
                                                       &buffer,
 …
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
 …
                            struct NetGetJoinableOUs *r)
+{
 #ifdef WITH_ADS
+#ifdef HAVE_ADS
         NTSTATUS status;
         ADS_STATUS ads_status;
 …
         uint32_t flags = DS_DIRECTORY_SERVICE_REQUIRED |
                          DS_RETURN_DNS_NAME;
+        status = dsgetdcname(ctx, NULL, r->in.domain,
+        struct libnetapi_private_ctx *priv;
+        priv = talloc_get_type_abort(ctx->private_data,
+                struct libnetapi_private_ctx);
+        status = dsgetdcname(ctx, priv->msg_ctx, r->in.domain,
                              NULL, NULL, flags, &info);
         if (!NT_STATUS_IS_OK(status)) {
 …
         NTSTATUS status;
         WERROR werr;
+        struct dcerpc_binding_handle *b;
+        DATA_BLOB session_key;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 …
+        }
+        if (r->in.password) {
+        b = pipe_cli->binding_handle;
+        if (r->in.password) {
+                status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        goto done;
+                }
                 encode_wkssvc_join_password_buffer(ctx,
                                                    r->in.password,
                                                    &pipe_cli->auth->user_session_key,
+                                                   &session_key,
                                                    &encrypted_password);
+        }
         status = rpccli_wkssvc_NetrGetJoinableOus2(pipe_cli, talloc_tos(),
+        status = dcerpc_wkssvc_NetrGetJoinableOus2(b, talloc_tos(),
                                                    r->in.server_name,
                                                    r->in.domain,
 …
         NTSTATUS status;
         WERROR werr;
+        struct dcerpc_binding_handle *b;
+        DATA_BLOB session_key;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
 …
+        }
+        if (r->in.password) {
+        b = pipe_cli->binding_handle;
+        if (r->in.password) {
+                status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        werr = ntstatus_to_werror(status);
+                        goto done;
+                }
                 encode_wkssvc_join_password_buffer(ctx,
                                                    r->in.password,
                                                    &pipe_cli->auth->user_session_key,
+                                                   &session_key,
                                                    &encrypted_password);
+        }
         status = rpccli_wkssvc_NetrRenameMachineInDomain2(pipe_cli, talloc_tos(),
+        status = dcerpc_wkssvc_NetrRenameMachineInDomain2(b, talloc_tos(),
                                                           r->in.server_name,
                                                           r->in.new_machine_name,

trunk/server/source3/lib/netapi/libnetapi.c

-              r596
+              r745
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+        return (NET_API_STATUS)r.out.result;
+}
 …
         TALLOC_FREE(frame);
         return r.out.result;
+}
+        return (NET_API_STATUS)r.out.result;
+}

trunk/server/source3/lib/netapi/libnetapi.h

-              r414
+              r745
+/*
+ *  Unix SMB/CIFS implementation.
+ *  NetApi Support
+ *  Copyright (C) Guenther Deschner 2007-2008
+ *
+ *  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/>.
+ */
 #ifndef __LIBNETAPI_LIBNETAPI__
 #define __LIBNETAPI_LIBNETAPI__

trunk/server/source3/lib/netapi/localgroup.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "../librpc/gen_ndr/cli_samr.h"
+#include "../librpc/gen_ndr/cli_lsa.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_samr_c.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"
 static NTSTATUS libnetapi_samr_lookup_and_open_alias(TALLOC_CTX *mem_ctx,
 …
                                                      struct policy_handle *alias_handle)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         struct lsa_String lsa_account_name;
         struct samr_Ids user_rids, name_types;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         init_lsa_String(&lsa_account_name, group_name);
         status = rpccli_samr_LookupNames(pipe_cli, mem_ctx,
+        status = dcerpc_samr_LookupNames(b, mem_ctx,
                                          domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                return result;
+        }
 …
+        }
+        return rpccli_samr_OpenAlias(pipe_cli, mem_ctx,
+                                     domain_handle,
+                                     access_rights,
+                                     user_rids.ids[0],
+                                     alias_handle);
+        status = dcerpc_samr_OpenAlias(b, mem_ctx,
+                                       domain_handle,
+                                       access_rights,
+                                       user_rids.ids[0],
+                                       alias_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        return result;
+}
 …
                                                     union samr_AliasInfo **alias_info)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         struct policy_handle alias_handle;
         union samr_AliasInfo *_alias_info = NULL;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         ZERO_STRUCT(alias_handle);
         status = rpccli_samr_OpenAlias(pipe_cli, mem_ctx,
+        status = dcerpc_samr_OpenAlias(b, mem_ctx,
                                        handle,
                                        access_rights,
                                        rid,
+                                       &alias_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = rpccli_samr_QueryAliasInfo(pipe_cli, mem_ctx,
+                                       &alias_handle,
+                                       &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+        status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
                                             &alias_handle,
                                             level,
+                                            &_alias_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                                            &_alias_info,
+                                            &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, mem_ctx, &alias_handle);
+                dcerpc_samr_Close(b, mem_ctx, &alias_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct lsa_String lsa_account_name;
 …
         struct dom_sid2 *domain_sid = NULL;
         uint32_t rid;
+        struct dcerpc_binding_handle *b = NULL;
         struct LOCALGROUP_INFO_0 *info0 = NULL;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, alias_name);
         status = rpccli_samr_CreateDomAlias(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_CreateDomAlias(b, talloc_tos(),
                                             &domain_handle,
                                             &lsa_account_name,
 …
                                             SAMR_ALIAS_ACCESS_SET_INFO,
                                             &alias_handle,
+                                            &rid);
+                                            &rid,
+                                            &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         if (r->in.level == 1 && info1->lgrpi1_comment) {
 …
                 init_lsa_String(&alias_info.description, info1->lgrpi1_comment);
                 status = rpccli_samr_SetAliasInfo(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_SetAliasInfo(b, talloc_tos(),
                                                   &alias_handle,
                                                   ALIASINFODESCRIPTION,
+                                                  &alias_info);
+                                                  &alias_info,
+                                                  &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &alias_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, builtin_handle, alias_handle;
         struct dom_sid2 *domain_sid = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         if (!r->in.group_name) {
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
  delete_alias:
+        status = rpccli_samr_DeleteDomAlias(pipe_cli, talloc_tos(),
+                                            &alias_handle);
+        status = dcerpc_samr_DeleteDomAlias(b, talloc_tos(),
+                                            &alias_handle,
+                                            &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &alias_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, builtin_handle, alias_handle;
 …
         union samr_AliasInfo *alias_info = NULL;
         uint32_t entries_read = 0;
+        struct dcerpc_binding_handle *b = NULL;
         if (!r->in.group_name) {
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
  query_alias:
         status = rpccli_samr_QueryAliasInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryAliasInfo(b, talloc_tos(),
                                             &alias_handle,
                                             ALIASINFOALL,
+                                            &alias_info);
+                                            &alias_info,
+                                            &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &alias_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct lsa_String lsa_account_name;
 …
         enum samr_AliasInfoEnum alias_level = 0;
         union samr_AliasInfo *alias_info = NULL;
+        struct dcerpc_binding_handle *b = NULL;
         if (!r->in.group_name) {
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_SetAliasInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_SetAliasInfo(b, talloc_tos(),
                                           &alias_handle,
                                           alias_level,
+                                          alias_info);
+                                          alias_info,
+                                          &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &alias_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, builtin_handle, alias_handle;
 …
         struct samr_SamArray *builtin_sam_array = NULL;
         int i;
+        struct dcerpc_binding_handle *b = NULL;
         if (!r->out.buffer) {
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryDomainInfo(b, talloc_tos(),
                                              &builtin_handle,
 ,
+                                             &builtin_info);
+                                             &builtin_info,
+                                             &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_QueryDomainInfo(b, talloc_tos(),
                                              &domain_handle,
 ,
+                                             &domain_info);
+                                             &domain_info,
+                                             &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_EnumDomainAliases(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_EnumDomainAliases(b, talloc_tos(),
                                                &builtin_handle,
                                                r->in.resume_handle,
                                                &builtin_sam_array,
                                                r->in.prefmaxlen,
+                                               &entries_read);
+                                               &entries_read,
+                                               &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_EnumDomainAliases(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_EnumDomainAliases(b, talloc_tos(),
                                                &domain_handle,
                                                r->in.resume_handle,
                                                &domain_sam_array,
                                                r->in.prefmaxlen,
+                                               &entries_read);
+                                               &entries_read,
+                                               &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
                                             struct dom_sid *sid)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         struct policy_handle lsa_handle;
+        struct dcerpc_binding_handle *b = lsa_pipe->binding_handle;
         struct lsa_RefDomainList *domains = NULL;
 …
         status = rpccli_lsa_open_policy2(lsa_pipe, mem_ctx,
                                          false,
                                          STD_RIGHT_READ_CONTROL_ACCESS |
+                                         SEC_STD_READ_CONTROL |
                                          LSA_POLICY_VIEW_LOCAL_INFORMATION |
                                          LSA_POLICY_LOOKUP_NAMES,
 …
         NT_STATUS_NOT_OK_RETURN(status);
         status = rpccli_lsa_LookupNames3(lsa_pipe, mem_ctx,
+        status = dcerpc_lsa_LookupNames3(b, mem_ctx,
                                          &lsa_handle,
                                          num_names,
 …
                                          LSA_LOOKUP_NAMES_ALL, /* sure ? */
                                          &count,
+, 0);
+, 0,
+                                         &result);
         NT_STATUS_NOT_OK_RETURN(status);
+        NT_STATUS_NOT_OK_RETURN(result);
         if (count != 1 || sids.count != 1) {
 …
         struct rpc_pipe_client *pipe_cli = NULL;
         struct rpc_pipe_client *lsa_pipe = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct lsa_String lsa_account_name;
 …
         struct dom_sid *add_sids = NULL;
         struct dom_sid *del_sids = NULL;
+        size_t num_add_sids = 0;
+        size_t num_del_sids = 0;
+        uint32_t num_add_sids = 0;
+        uint32_t num_del_sids = 0;
+        struct dcerpc_binding_handle *b = NULL;
         if ((!add && !del && !set) || (add && del && set)) {
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
 …
                 struct lsa_SidArray current_sids;
                 status = rpccli_samr_GetMembersInAlias(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_GetMembersInAlias(b, talloc_tos(),
                                                        &alias_handle,
+                                                       &current_sids);
+                                                       &current_sids,
+                                                       &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
                 /* add list */
 …
                         bool already_member = false;
                         for (k=0; k < current_sids.num_sids; k++) {
                                 if (sid_equal(&member_sids[i],
+                                if (dom_sid_equal(&member_sids[i],
                                               current_sids.sids[k].sid)) {
                                         already_member = true;
 …
                         bool keep_member = false;
                         for (i=0; i < r->in.total_entries; i++) {
                                 if (sid_equal(&member_sids[i],
+                                if (dom_sid_equal(&member_sids[i],
                                               current_sids.sids[k].sid)) {
                                         keep_member = true;
 …
         for (i=0; i < num_add_sids; i++) {
                 status = rpccli_samr_AddAliasMember(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_AddAliasMember(b, talloc_tos(),
                                                     &alias_handle,
+                                                    &add_sids[i]);
+                                                    &add_sids[i],
+                                                    &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
 …
         for (i=0; i < num_del_sids; i++) {
                 status = rpccli_samr_DeleteAliasMember(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_DeleteAliasMember(b, talloc_tos(),
                                                        &alias_handle,
+                                                       &del_sids[i]);
+                                                       &del_sids[i],
+                                                       &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
 …
  done:
         if (is_valid_policy_hnd(&alias_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
+        if (b && is_valid_policy_hnd(&alias_handle)) {
+                dcerpc_samr_Close(b, talloc_tos(), &alias_handle, &result);
+        }

trunk/server/source3/lib/netapi/netapi.c

-              r414
+              r745
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
+extern bool AllowDebugChange;
+#include "secrets.h"
+#include "krb5_env.h"
 struct libnetapi_ctx *stat_ctx = NULL;
 …
 /****************************************************************
+Create a libnetapi context, for use in non-Samba applications.  This
+loads the smb.conf file and sets the debug level to 0, so that
+applications are not flooded with debug logs at level 10, when they
+were not expecting it.
 ****************************************************************/
 NET_API_STATUS libnetapi_init(struct libnetapi_ctx **context)
+{
-        NET_API_STATUS status;
-        struct libnetapi_ctx *ctx = NULL;
-        char *krb5_cc_env = NULL;
         if (stat_ctx && libnetapi_initialized) {
                 *context = stat_ctx;
 …
         frame = talloc_stackframe();
+        ctx = talloc_zero(frame, struct libnetapi_ctx);
+        if (!ctx) {
+                TALLOC_FREE(frame);
+                return W_ERROR_V(WERR_NOMEM);
+        }
+        if (!DEBUGLEVEL) {
+                DEBUGLEVEL = 0;
+        }
+        /* prevent setup_logging() from closing x_stderr... */
+        dbf = 0;
+        setup_logging("libnetapi", true);
+        dbf = x_stderr;
+        x_setbuf(x_stderr, NULL);
+        AllowDebugChange = false;
+        load_case_tables();
+        /* Case tables must be loaded before any string comparisons occour */
+        load_case_tables_library();
+        /* When libnetapi is invoked from an application, it does not
+         * want to be swamped with level 10 debug messages, even if
+         * this has been set for the server in smb.conf */
+        lp_set_cmdline("log level", "0");
+        setup_logging("libnetapi", DEBUG_STDERR);
         if (!lp_load(get_dyn_CONFIGFILE(), true, false, false, false)) {
 …
+        }
-        AllowDebugChange = true;
         init_names();
         load_interfaces();
         reopen_logs();
+        BlockSignals(True, SIGPIPE);
+        return libnetapi_net_init(context);
+}
+/****************************************************************
+Create a libnetapi context, for use inside the 'net' binary.
+As we know net has already loaded the smb.conf file, and set the debug
+level etc, this avoids doing so again (which causes trouble with -d on
+the command line).
+****************************************************************/
+NET_API_STATUS libnetapi_net_init(struct libnetapi_ctx **context)
+{
+        NET_API_STATUS status;
+        struct libnetapi_ctx *ctx = NULL;
+        char *krb5_cc_env = NULL;
+        frame = talloc_stackframe();
+        ctx = talloc_zero(frame, struct libnetapi_ctx);
+        if (!ctx) {
+                TALLOC_FREE(frame);
+                return W_ERROR_V(WERR_NOMEM);
+        }
         BlockSignals(True, SIGPIPE);
 …
 /****************************************************************
+ Return the static libnetapi context
 ****************************************************************/
 …
 /****************************************************************
+ Free the static libnetapi context
 ****************************************************************/
 …
 /****************************************************************
+ Override the current log level for libnetapi
 ****************************************************************/
 …
                                         const char *debuglevel)
+{
-        AllowDebugChange = true;
         ctx->debuglevel = talloc_strdup(ctx, debuglevel);
         if (!debug_parse_levels(debuglevel)) {
+        if (!lp_set_cmdline("log level", debuglevel)) {
                 return W_ERROR_V(WERR_GENERAL_FAILURE);
+        }

trunk/server/source3/lib/netapi/netapi.h

-              r414
+              r745
 };
+#define DS_PDC_FLAG ( 0x00000001 )
+#define DS_GC_FLAG ( 0x00000004 )
+#define DS_LDAP_FLAG ( 0x00000008 )
+#define DS_DS_FLAG ( 0x00000010 )
+#define DS_KDC_FLAG ( 0x00000020 )
+#define DS_TIMESERV_FLAG ( 0x00000040 )
+#define DS_CLOSEST_FLAG ( 0x00000080 )
+#define DS_WRITABLE_FLAG ( 0x00000100 )
+#define DS_GOOD_TIMESERV_FLAG ( 0x00000200 )
+#define DS_NDNC_FLAG ( 0x00000400 )
+#define DS_SELECT_SECRET_DOMAIN_6_FLAG ( 0x00000800 )
+#define DS_FULL_SECRET_DOMAIN_6_FLAG ( 0x00001000 )
+#define DS_DNS_CONTROLLER_FLAG ( 0x20000000 )
+#define DS_DNS_DOMAIN_FLAG ( 0x40000000 )
+#define DS_DNS_FOREST_FLAG ( 0x80000000 )
 #endif /* _HEADER_libnetapi */
 …
 #define NETLOGON_CONTROL_BREAKPOINT ( 0x0000FFFF )
+#define DS_FORCE_REDISCOVERY ( 0x00000001 )
+#define DS_DIRECTORY_SERVICE_REQUIRED ( 0x00000010 )
+#define DS_DIRECTORY_SERVICE_PREFERRED ( 0x00000020 )
+#define DS_GC_SERVER_REQUIRED ( 0x00000040 )
+#define DS_PDC_REQUIRED ( 0x00000080 )
+#define DS_BACKGROUND_ONLY ( 0x00000100 )
+#define DS_IP_REQUIRED ( 0x00000200 )
+#define DS_KDC_REQUIRED ( 0x00000400 )
+#define DS_TIMESERV_REQUIRED ( 0x00000800 )
+#define DS_WRITABLE_REQUIRED ( 0x00001000 )
+#define DS_GOOD_TIMESERV_PREFERRED ( 0x00002000 )
+#define DS_AVOID_SELF ( 0x00004000 )
+#define DS_ONLY_LDAP_NEEDED ( 0x00008000 )
+#define DS_IS_FLAT_NAME ( 0x00010000 )
+#define DS_IS_DNS_NAME ( 0x00020000 )
+#define DS_TRY_NEXTCLOSEST_SITE ( 0x00040000 )
+#define DS_DIRECTORY_SERVICE_6_REQUIRED ( 0x00080000 )
+#define DS_WEB_SERVICE_REQUIRED ( 0x00100000 )
+#define DS_RETURN_DNS_NAME ( 0x40000000 )
+#define DS_RETURN_FLAT_NAME ( 0x80000000 )
 #endif /* _HEADER_netlogon */

trunk/server/source3/lib/netapi/netapi_private.h

-              r590
+              r745
 #define __LIB_NETAPI_PRIVATE_H__
+#include "lib/netapi/netapi_net.h"
 #define LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, fn) \
         DEBUG(10,("redirecting call %s to localhost\n", #fn)); \
 …
         } \
         return fn ## _r(ctx, r);
+struct dcerpc_binding_handle;
 struct libnetapi_private_ctx {
 …
         struct client_ipc_connection *ipc_connections;
+        struct messaging_context *msg_ctx;
 };
 …
                            const struct ndr_syntax_id *interface,
                            struct rpc_pipe_client **presult);
+WERROR libnetapi_get_binding_handle(struct libnetapi_ctx *ctx,
+                                    const char *server_name,
+                                    const struct ndr_syntax_id *interface,
+                                    struct dcerpc_binding_handle **binding_handle);
 WERROR libnetapi_samr_open_domain(struct libnetapi_ctx *mem_ctx,
                                   struct rpc_pipe_client *pipe_cli,

trunk/server/source3/lib/netapi/netlogon.c

-              r596
+              r745
 #include "includes.h"
+#include "../librpc/gen_ndr/ndr_netlogon_c.h"
 #include "librpc/gen_ndr/libnetapi.h"
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
-#include "../librpc/gen_ndr/cli_netlogon.h"
 static WERROR construct_data(enum netr_LogonControlCode function_code,
 …
                 data_out->debug_level = atoi((const char *)data_in);
                 break;
+        case NETLOGON_CONTROL_FORCE_DNS_REG:
+                ZERO_STRUCTP(data_out);
+                break;
         default:
                 return WERR_INVALID_PARAM;
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union netr_CONTROL_QUERY_INFORMATION query;
+        werr = libnetapi_open_pipe(ctx, r->in.server_name,
+                                   &ndr_table_netlogon.syntax_id,
+                                   &pipe_cli);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = rpccli_netr_LogonControl(pipe_cli, talloc_tos(),
+        struct dcerpc_binding_handle *b;
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_netlogon.syntax_id,
+                                            &b);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_netr_LogonControl(b, talloc_tos(),
                                           r->in.server_name,
                                           r->in.function_code,
 …
                 goto done;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
         werr = construct_buffer(ctx, r->in.query_level, &query,
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union netr_CONTROL_DATA_INFORMATION data;
         union netr_CONTROL_QUERY_INFORMATION query;
+        struct dcerpc_binding_handle *b;
         werr = construct_data(r->in.function_code, r->in.data, &data);
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_netlogon.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_netlogon.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
         case NETLOGON_CONTROL_TC_VERIFY:
         case NETLOGON_CONTROL_SET_DBFLAG:
+                status = rpccli_netr_LogonControl2Ex(pipe_cli, talloc_tos(),
+        case NETLOGON_CONTROL_FORCE_DNS_REG:
+                status = dcerpc_netr_LogonControl2Ex(b, talloc_tos(),
                                                      r->in.server_name,
                                                      r->in.function_code,
 …
                 break;
         default:
                 status = rpccli_netr_LogonControl2(pipe_cli, talloc_tos(),
+                status = dcerpc_netr_LogonControl2(b, talloc_tos(),
                                                    r->in.server_name,
                                                    r->in.function_code,
 …
+        }
-        if (!W_ERROR_IS_OK(werr)) {
-                goto done;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
 …
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
         werr = construct_buffer(ctx, r->in.query_level, &query,
                                 r->out.buffer);

trunk/server/source3/lib/netapi/samr.c

-              r414
+              r745
 #include "lib/netapi/netapi.h"
 #include "lib/netapi/netapi_private.h"
+#include "../librpc/gen_ndr/cli_samr.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "rpc_client/cli_samr.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/security.h"
 /****************************************************************
 …
                                   struct dom_sid2 **domain_sid)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct libnetapi_private_ctx *priv;
 …
         bool domain_found = true;
         int i;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         priv = talloc_get_type_abort(mem_ctx->private_data,
 …
         if (!is_valid_policy_hnd(connect_handle)) {
+                status = rpccli_try_samr_connects(pipe_cli, mem_ctx,
+                status = dcerpc_try_samr_connects(pipe_cli->binding_handle, mem_ctx,
+                                                  pipe_cli->srv_name_slash,
                                                   connect_mask,
+                                                  connect_handle);
+                                                  connect_handle,
+                                                  &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+        }
+        status = rpccli_samr_EnumDomains(pipe_cli, mem_ctx,
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
+        status = dcerpc_samr_EnumDomains(b, mem_ctx,
                                          connect_handle,
                                          &resume_handle,
                                          &sam,
 xffffffff,
+                                         &num_entries);
+                                         &num_entries,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         for (i=0; i<num_entries; i++) {
 …
         init_lsa_String(&lsa_domain_name, domain_name);
         status = rpccli_samr_LookupDomain(pipe_cli, mem_ctx,
+        status = dcerpc_samr_LookupDomain(b, mem_ctx,
                                           connect_handle,
                                           &lsa_domain_name,
+                                          domain_sid);
+                                          domain_sid,
+                                          &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenDomain(pipe_cli, mem_ctx,
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         connect_handle,
                                         domain_mask,
                                         *domain_sid,
+                                        domain_handle);
+                                        domain_handle,
+                                        &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
                                           struct policy_handle *builtin_handle)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct libnetapi_private_ctx *priv;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         priv = talloc_get_type_abort(mem_ctx->private_data,
 …
         if (!is_valid_policy_hnd(connect_handle)) {
+                status = rpccli_try_samr_connects(pipe_cli, mem_ctx,
+                status = dcerpc_try_samr_connects(pipe_cli->binding_handle, mem_ctx,
+                                                  pipe_cli->srv_name_slash,
                                                   connect_mask,
+                                                  connect_handle);
+                                                  connect_handle,
+                                                  &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+        }
+        status = rpccli_samr_OpenDomain(pipe_cli, mem_ctx,
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+        }
+        status = dcerpc_samr_OpenDomain(b, mem_ctx,
                                         connect_handle,
                                         builtin_mask,
+                                        CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
+                                        builtin_handle);
+                                        CONST_DISCARD(struct dom_sid *, &global_sid_Builtin),
+                                        builtin_handle,
+                                        &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         priv->samr.cli                  = pipe_cli;
 …
+{
         struct libnetapi_private_ctx *priv;
+        struct dcerpc_binding_handle *b;
+        NTSTATUS result;
         if (!is_valid_policy_hnd(handle)) {
 …
                 struct libnetapi_private_ctx);
+        if (!policy_hnd_equal(handle, &priv->samr.domain_handle)) {
+                return;
+        }
+        rpccli_samr_Close(priv->samr.cli, ctx, handle);
+        if (!policy_handle_equal(handle, &priv->samr.domain_handle)) {
+                return;
+        }
+        b = priv->samr.cli->binding_handle;
+        dcerpc_samr_Close(b, ctx, handle, &result);
         ZERO_STRUCT(priv->samr.domain_handle);
 …
+{
         struct libnetapi_private_ctx *priv;
+        struct dcerpc_binding_handle *b;
+        NTSTATUS result;
         if (!is_valid_policy_hnd(handle)) {
 …
                 struct libnetapi_private_ctx);
+        if (!policy_hnd_equal(handle, &priv->samr.builtin_handle)) {
+                return;
+        }
+        rpccli_samr_Close(priv->samr.cli, ctx, handle);
+        if (!policy_handle_equal(handle, &priv->samr.builtin_handle)) {
+                return;
+        }
+        b = priv->samr.cli->binding_handle;
+        dcerpc_samr_Close(b, ctx, handle, &result);
         ZERO_STRUCT(priv->samr.builtin_handle);
 …
+{
         struct libnetapi_private_ctx *priv;
+        struct dcerpc_binding_handle *b;
+        NTSTATUS result;
         if (!is_valid_policy_hnd(handle)) {
 …
                 struct libnetapi_private_ctx);
+        if (!policy_hnd_equal(handle, &priv->samr.connect_handle)) {
+                return;
+        }
+        rpccli_samr_Close(priv->samr.cli, ctx, handle);
+        if (!policy_handle_equal(handle, &priv->samr.connect_handle)) {
+                return;
+        }
+        b = priv->samr.cli->binding_handle;
+        dcerpc_samr_Close(b, ctx, handle, &result);
         ZERO_STRUCT(priv->samr.connect_handle);

trunk/server/source3/lib/netapi/serverinfo.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "libnet/libnet.h"
+#include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
+#include "lib/smbconf/smbconf.h"
+#include "lib/smbconf/smbconf_reg.h"
 /****************************************************************
 …
                           struct NetServerGetInfo *r)
+{
-        struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
         WERROR werr;
         union srvsvc_NetSrvInfo info;
+        struct dcerpc_binding_handle *b;
         if (!r->out.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetSrvGetInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetSrvGetInfo(b, talloc_tos(),
                                              r->in.server_name,
                                              r->in.level,
 …
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
         status = map_server_info_to_SERVER_INFO_buffer(ctx, r->in.level, &info,
                                                        r->out.buffer);
 …
                                       struct NetServerSetInfo *r)
+{
+        WERROR werr;
+        WERROR werr = WERR_OK;
+        sbcErr err;
         struct smbconf_ctx *conf_ctx;
         struct srvsvc_NetSrvInfo1005 *info1005;
 …
+        }
+        werr = smbconf_init_reg(ctx, &conf_ctx, NULL);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        werr = smbconf_set_global_parameter(conf_ctx, "server string",
+        err = smbconf_init_reg(ctx, &conf_ctx, NULL);
+        if (!SBC_ERROR_IS_OK(err)) {
+                libnetapi_set_error_string(ctx,
+                        "Could not initialize backend: %s",
+                        sbcErrorString(err));
+                werr = WERR_NO_SUCH_SERVICE;
+                goto done;
+        }
+        err = smbconf_set_global_parameter(conf_ctx, "server string",
                                             info1005->comment);
+        if (!SBC_ERROR_IS_OK(err)) {
+                libnetapi_set_error_string(ctx,
+                        "Could not set global parameter: %s",
+                        sbcErrorString(err));
+                werr = WERR_NO_SUCH_SERVICE;
+                goto done;
+        }
  done:
 …
                           struct NetServerSetInfo *r)
+{
-        struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
         WERROR werr;
         union srvsvc_NetSrvInfo info;
+        werr = libnetapi_open_pipe(ctx, r->in.server_name,
+                                   &ndr_table_srvsvc.syntax_id,
+                                   &pipe_cli);
+        struct dcerpc_binding_handle *b;
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
+        }
         status = rpccli_srvsvc_NetSrvSetInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetSrvSetInfo(b, talloc_tos(),
                                              r->in.server_name,
                                              r->in.level,
 …
                       struct NetRemoteTOD *r)
+{
-        struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
         WERROR werr;
         struct srvsvc_NetRemoteTODInfo *info = NULL;
+        werr = libnetapi_open_pipe(ctx, r->in.server_name,
+                                   &ndr_table_srvsvc.syntax_id,
+                                   &pipe_cli);
+        struct dcerpc_binding_handle *b;
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetRemoteTOD(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetRemoteTOD(b, talloc_tos(),
                                             r->in.server_name,
                                             &info,
 …
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
         *r->out.buffer = (uint8_t *)talloc_memdup(ctx, info,
                           sizeof(struct srvsvc_NetRemoteTODInfo));

trunk/server/source3/lib/netapi/share.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
 #include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
 /****************************************************************
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union srvsvc_NetShareInfo info;
+        struct dcerpc_binding_handle *b;
         if (!r->in.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
+        }
         status = rpccli_srvsvc_NetShareAdd(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetShareAdd(b, talloc_tos(),
                                            r->in.server_name,
                                            r->in.level,
 …
                                            r->out.parm_err,
                                            &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
         WERROR werr;
         NTSTATUS status;
         struct rpc_pipe_client *pipe_cli = NULL;
+        struct dcerpc_binding_handle *b;
         if (!r->in.net_name) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetShareDel(pipe_cli, talloc_tos(),
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_srvsvc_NetShareDel(b, talloc_tos(),
                                            r->in.server_name,
                                            r->in.net_name,
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         struct srvsvc_NetShareInfoCtr info_ctr;
         struct srvsvc_NetShareCtr0 ctr0;
 …
         struct srvsvc_NetShareCtr2 ctr2;
         uint32_t i;
+        struct dcerpc_binding_handle *b;
         if (!r->out.buffer) {
 …
         ZERO_STRUCT(info_ctr);
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
+        }
         status = rpccli_srvsvc_NetShareEnumAll(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetShareEnumAll(b, talloc_tos(),
                                                r->in.server_name,
                                                &info_ctr,
 …
                                                r->out.resume_handle,
                                                &werr);
+        if (NT_STATUS_IS_ERR(status)) {
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(werr) && !W_ERROR_EQUAL(werr, WERR_MORE_DATA)) {
                 goto done;
+        }
 …
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
+                        goto done;
+                }
+        }
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union srvsvc_NetShareInfo info;
         uint32_t num_entries = 0;
+        struct dcerpc_binding_handle *b;
         if (!r->in.net_name || !r->out.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_srvsvc_NetShareGetInfo(pipe_cli, talloc_tos(),
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        status = dcerpc_srvsvc_NetShareGetInfo(b, talloc_tos(),
                                                r->in.server_name,
                                                r->in.net_name,
 …
                                                &info,
                                                &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         if (!W_ERROR_IS_OK(werr)) {
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         union srvsvc_NetShareInfo info;
+        struct dcerpc_binding_handle *b;
         if (!r->in.buffer) {
 …
+        }
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_srvsvc.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_srvsvc.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
+        }
         status = rpccli_srvsvc_NetShareSetInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_srvsvc_NetShareSetInfo(b, talloc_tos(),
                                                r->in.server_name,
                                                r->in.net_name,
 …
                                                r->out.parm_err,
                                                &werr);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;

trunk/server/source3/lib/netapi/shutdown.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "../librpc/gen_ndr/cli_initshutdown.h"
+#include "../librpc/gen_ndr/ndr_initshutdown_c.h"
+#include "rpc_client/init_lsa.h"
 /****************************************************************
 …
         WERROR werr;
         NTSTATUS status;
-        struct rpc_pipe_client *pipe_cli = NULL;
         struct lsa_StringLarge message;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_initshutdown.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_initshutdown.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
 …
         init_lsa_StringLarge(&message, r->in.message);
         status = rpccli_initshutdown_Init(pipe_cli, talloc_tos(),
+        status = dcerpc_initshutdown_Init(b, talloc_tos(),
                                           NULL,
                                           &message,
 …
         WERROR werr;
         NTSTATUS status;
         struct rpc_pipe_client *pipe_cli = NULL;
+        struct dcerpc_binding_handle *b;
         werr = libnetapi_open_pipe(ctx, r->in.server_name,
                                    &ndr_table_initshutdown.syntax_id,
                                    &pipe_cli);
+        werr = libnetapi_get_binding_handle(ctx, r->in.server_name,
+                                            &ndr_table_initshutdown.syntax_id,
+                                            &b);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         status = rpccli_initshutdown_Abort(pipe_cli, talloc_tos(),
+        status = dcerpc_initshutdown_Abort(b, talloc_tos(),
                                            NULL,
                                            &werr);

trunk/server/source3/lib/netapi/sid.c

r414	r745
21	21
22	22	#include "lib/netapi/netapi.h"
	23	#include "../libcli/security/security.h"
23	24
24	25	/****************************************************************

trunk/server/source3/lib/netapi/user.c

-              r596
+              r745
 #include "lib/netapi/netapi_private.h"
 #include "lib/netapi/libnetapi.h"
+#include "../librpc/gen_ndr/cli_samr.h"
+#include "../librpc/gen_ndr/ndr_samr_c.h"
+#include "rpc_client/init_samr.h"
+#include "../libds/common/flags.h"
+#include "rpc_client/init_lsa.h"
+#include "../libcli/security/security.h"
+#include "../libds/common/flag_mapping.h"
+#include "rpc_client/cli_pipe.h"
 /****************************************************************
 …
         info21->lm_owf_password         = zero_parameters;
         info21->nt_owf_password         = zero_parameters;
         info21->unknown3.string         = NULL;
+        info21->private_data.string     = NULL;
         info21->buf_count               = 0;
         info21->buffer                  = NULL;
 …
         info21->nt_password_set         = 0;
         info21->password_expired        = infoX->usriX_password_expired;
         info21->unknown4                = 0;
+        info21->private_data_sensitive  = 0;
+}
 …
         union samr_UserInfo user_info;
         struct samr_UserInfo21 info21;
+        NTSTATUS status;
+        NTSTATUS status, result;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         if (!uX) {
 …
                                           &user_info.info25.password);
                 status = rpccli_samr_SetUserInfo2(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_SetUserInfo2(b, talloc_tos(),
                                                   user_handle,
 ,
                                                   &user_info);
                 if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
+                                                  &user_info,
+                                                  &result);
+                if (NT_STATUS_EQUAL(status, NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE)) {
                         user_info.info23.info = info21;
 …
                                                 &user_info.info23.password);
                         status = rpccli_samr_SetUserInfo2(pipe_cli, talloc_tos(),
+                        status = dcerpc_samr_SetUserInfo2(b, talloc_tos(),
                                                           user_handle,
 ,
+                                                          &user_info);
+                                                          &user_info,
+                                                          &result);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return status;
+                        }
+                }
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
         } else {
 …
                 user_info.info21 = info21;
                 status = rpccli_samr_SetUserInfo(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_SetUserInfo(b, talloc_tos(),
                                                  user_handle,
 ,
+                                                 &user_info);
+        }
+        return status;
+                                                 &user_info,
+                                                 &result);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+        }
+        return result;
+}
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, domain_handle, user_handle;
 …
         uint32_t rid = 0;
         struct USER_INFO_X uX;
+        struct dcerpc_binding_handle *b = NULL;
+        DATA_BLOB session_key;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
 …
         init_lsa_String(&lsa_account_name, uX.usriX_name);
         status = rpccli_samr_CreateUser2(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_CreateUser2(b, talloc_tos(),
                                          &domain_handle,
                                          &lsa_account_name,
 …
                                          &user_handle,
                                          &access_granted,
+                                         &rid);
+                                         &rid,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_QueryUserInfo(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_QueryUserInfo(b, talloc_tos(),
                                            &user_handle,
 ,
+                                           &user_info);
+                                           &user_info,
+                                           &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_GetUserPwInfo(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_GetUserPwInfo(b, talloc_tos(),
                                            &user_handle,
+                                           &pw_info);
+                                           &pw_info,
+                                           &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         uX.usriX_flags |= ACB_NORMAL;
         status = set_user_info_USER_INFO_X(ctx, pipe_cli,
                                            &pipe_cli->auth->user_session_key,
+                                           &session_key,
                                            &user_handle,
                                            &uX);
 …
  failed:
+        rpccli_samr_DeleteUser(pipe_cli, talloc_tos(),
+                               &user_handle);
+        dcerpc_samr_DeleteUser(b, talloc_tos(),
+                               &user_handle,
+                               &result);
  done:
         if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
+        if (is_valid_policy_hnd(&user_handle) && b) {
+                dcerpc_samr_Close(b, talloc_tos(), &user_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
         struct policy_handle connect_handle, builtin_handle, domain_handle, user_handle;
 …
         struct dom_sid2 *domain_sid = NULL;
         struct dom_sid2 user_sid;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_OpenDomain(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_OpenDomain(b, talloc_tos(),
                                         &connect_handle,
                                         SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
+                                        CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
+                                        &builtin_handle);
+                                        CONST_DISCARD(struct dom_sid *, &global_sid_Builtin),
+                                        &builtin_handle,
+                                        &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenUser(b, talloc_tos(),
                                       &domain_handle,
                                       SEC_STD_DELETE,
                                       user_rids.ids[0],
+                                      &user_handle);
+                                      &user_handle,
+                                      &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
         status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_RemoveMemberFromForeignDomain(b, talloc_tos(),
                                                            &builtin_handle,
+                                                           &user_sid);
+                                                           &user_sid,
+                                                           &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_DeleteUser(pipe_cli, talloc_tos(),
+                                        &user_handle);
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_DeleteUser(b, talloc_tos(),
+                                        &user_handle,
+                                        &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&user_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &user_handle, &result);
+        }
 …
                                            uint32_t *auth_flag_p)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         struct policy_handle user_handle;
 …
                                SAMR_USER_ACCESS_GET_ATTRIBUTES |
                                SAMR_USER_ACCESS_GET_NAME_ETC;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         ZERO_STRUCT(user_handle);
 …
+        }
         status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
+        status = dcerpc_samr_OpenUser(b, mem_ctx,
                                       domain_handle,
                                       access_mask,
                                       rid,
+                                      &user_handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
+                                      &user_handle,
+                                      &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
                                            &user_handle,
 ,
+                                           &user_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
+                                           &user_info,
+                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
+        status = dcerpc_samr_QuerySecurity(b, mem_ctx,
                                            &user_handle,
                                            SECINFO_DACL,
+                                           sec_desc);
+        if (!NT_STATUS_IS_OK(status)) {
+                                           sec_desc,
+                                           &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
                 goto done;
+        }
 …
                 struct dom_sid sid;
                 status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
+                status = dcerpc_samr_GetGroupsForUser(b, mem_ctx,
                                                       &user_handle,
+                                                      &rid_array);
+                                                      &rid_array,
+                                                      &result);
                 if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
                         goto done;
+                }
 …
                 for (i=0; i<rid_array->count; i++) {
                         sid_compose(&sid, domain_sid, rid_array->rids[i].rid);
                         sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
+                        sid_array.sids[i].sid = dom_sid_dup(mem_ctx, &sid);
                         NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
+                }
                 sid_compose(&sid, domain_sid, rid);
                 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
+                sid_array.sids[i].sid = dom_sid_dup(mem_ctx, &sid);
                 NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
                 status = rpccli_samr_GetAliasMembership(pipe_cli, mem_ctx,
+                status = dcerpc_samr_GetAliasMembership(b, mem_ctx,
                                                         builtin_handle,
                                                         &sid_array,
+                                                        &alias_rids);
+                                                        &alias_rids,
+                                                        &result);
                 if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        status = result;
                         goto done;
+                }
 …
  done:
         if (is_valid_policy_hnd(&user_handle)) {
                 rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
+                dcerpc_samr_Close(b, mem_ctx, &user_handle, &result);
+        }
 …
                 return NT_STATUS_NO_MEMORY;
+        }
         i->usri4_user_sid       = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
+        i->usri4_user_sid       = (struct domsid *)dom_sid_dup(mem_ctx, &sid);
         i->usri4_primary_group_id = i21->primary_gid;
         i->usri4_profile        = talloc_strdup(mem_ctx, i21->profile_path.string);
 …
                 return NT_STATUS_NO_MEMORY;
+        }
         i->usri23_user_sid      = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
+        i->usri23_user_sid      = (struct domsid *)dom_sid_dup(mem_ctx, &sid);
         return NT_STATUS_OK;
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
                                                   SAMR_ACCESS_ENUM_DOMAINS |
 …
+        }
         status = rpccli_samr_EnumDomainUsers(pipe_cli,
+        status = dcerpc_samr_EnumDomainUsers(b,
                                              ctx,
                                              &domain_handle,
 …
                                              &sam,
                                              r->in.prefmaxlen,
+                                             &entries_read);
+        werr = ntstatus_to_werror(status);
+        if (NT_STATUS_IS_ERR(status)) {
+                                             &entries_read,
+                                             &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        werr = ntstatus_to_werror(result);
+        if (NT_STATUS_IS_ERR(result)) {
                 goto done;
+        }
 …
  done:
         /* if last query */
         if (NT_STATUS_IS_OK(status) ||
             NT_STATUS_IS_ERR(status)) {
+        if (NT_STATUS_IS_OK(result) ||
+            NT_STATUS_IS_ERR(result)) {
                 if (ctx->disable_policy_handle_cache) {
 …
         struct policy_handle domain_handle;
         union samr_DispInfo info;
+        struct dcerpc_binding_handle *b = NULL;
         uint32_t total_size = 0;
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
         WERROR werr_tmp;
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
+        }
         status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
+        status = dcerpc_samr_QueryDisplayInfo2(b,
                                                ctx,
                                                &domain_handle,
 …
                                                &total_size,
                                                &returned_size,
+                                               &info);
+        werr = ntstatus_to_werror(status);
+        if (NT_STATUS_IS_ERR(status)) {
+                                               &info,
+                                               &result);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        werr = ntstatus_to_werror(result);
+        if (NT_STATUS_IS_ERR(result)) {
                 goto done;
+        }
 …
  done:
         /* if last query */
         if (NT_STATUS_IS_OK(status) ||
             NT_STATUS_IS_ERR(status)) {
+        if (NT_STATUS_IS_OK(result) ||
+            NT_STATUS_IS_ERR(result)) {
                 if (ctx->disable_policy_handle_cache) {
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
 …
         struct samr_Ids user_rids, name_types;
         uint32_t num_entries = 0;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
                                           SAMR_ACCESS_ENUM_DOMAINS |
 …
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
  done:
         if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
+        if (is_valid_policy_hnd(&user_handle) && b) {
+                dcerpc_samr_Close(b, talloc_tos(), &user_handle, &result);
+        }
 …
+{
         struct rpc_pipe_client *pipe_cli = NULL;
         NTSTATUS status;
+        NTSTATUS status, result;
         WERROR werr;
 …
         struct USER_INFO_X uX;
+        struct dcerpc_binding_handle *b = NULL;
+        DATA_BLOB session_key;
         ZERO_STRUCT(connect_handle);
 …
                         break;
                 case 3:
                         user_mask = STD_RIGHT_READ_CONTROL_ACCESS |
                                     STD_RIGHT_WRITE_DAC_ACCESS |
+                        user_mask = SEC_STD_READ_CONTROL |
+                                    SEC_STD_WRITE_DAC |
                                     SAMR_USER_ACCESS_GET_GROUPS |
                                     SAMR_USER_ACCESS_SET_PASSWORD |
 …
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
                                           SAMR_ACCESS_ENUM_DOMAINS |
 …
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenUser(b, talloc_tos(),
                                       &domain_handle,
                                       user_mask,
                                       user_rids.ids[0],
+                                      &user_handle);
+                                      &user_handle,
+                                      &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
         status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
 …
+        }
+        status = cli_get_session_key(talloc_tos(), pipe_cli, &session_key);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = ntstatus_to_werror(status);
+                goto done;
+        }
         status = set_user_info_USER_INFO_X(ctx, pipe_cli,
                                            &pipe_cli->auth->user_session_key,
+                                           &session_key,
                                            &user_handle,
                                            &uX);
 …
  done:
         if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
+        if (is_valid_policy_hnd(&user_handle) && b) {
+                dcerpc_samr_Close(b, talloc_tos(), &user_handle, &result);
+        }
 …
                                            struct samr_DomInfo12 *info12)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         union samr_DomainInfo *dom_info = NULL;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         if (info1) {
                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                                      domain_handle,
 ,
+                                                     &dom_info);
+                                                     &dom_info,
+                                                     &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info1 = dom_info->info1;
 …
         if (info3) {
                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                                      domain_handle,
 ,
+                                                     &dom_info);
+                                                     &dom_info,
+                                                     &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info3 = dom_info->info3;
 …
         if (info5) {
                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                                      domain_handle,
 ,
+                                                     &dom_info);
+                                                     &dom_info,
+                                                     &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info5 = dom_info->info5;
 …
         if (info6) {
                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                                      domain_handle,
 ,
+                                                     &dom_info);
+                                                     &dom_info,
+                                                     &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info6 = dom_info->info6;
 …
         if (info7) {
                 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
                                                      domain_handle,
 ,
+                                                     &dom_info);
+                                                     &dom_info,
+                                                     &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info7 = dom_info->info7;
 …
         if (info12) {
                 status = rpccli_samr_QueryDomainInfo2(pipe_cli, mem_ctx,
+                status = dcerpc_samr_QueryDomainInfo2(b, mem_ctx,
                                                       domain_handle,
 ,
+                                                      &dom_info);
+                                                      &dom_info,
+                                                      &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
                 *info12 = dom_info->info12;
 …
                 talloc_strdup(mem_ctx, dom_info5.domain_name.string);
         info2->usrmod2_domain_id =
                 (struct domsid *)sid_dup_talloc(mem_ctx, domain_sid);
+                (struct domsid *)dom_sid_dup(mem_ctx, domain_sid);
         NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_name);
 …
                                          struct samr_DomInfo12 *info12)
+{
         NTSTATUS status;
+        NTSTATUS status, result;
         union samr_DomainInfo dom_info;
+        struct dcerpc_binding_handle *b = pipe_cli->binding_handle;
         if (info1) {
 …
                 dom_info.info1 = *info1;
                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    domain_handle,
 ,
+                                                   &dom_info);
+                                                   &dom_info,
+                                                   &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
+        }
 …
                 dom_info.info3 = *info3;
                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    domain_handle,
 ,
+                                                   &dom_info);
+                                                   &dom_info,
+                                                   &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
+        }
 …
                 dom_info.info12 = *info12;
                 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
+                status = dcerpc_samr_SetDomainInfo(b, mem_ctx,
                                                    domain_handle,
 ,
+                                                   &dom_info);
+                                                   &dom_info,
+                                                   &result);
                 NT_STATUS_NOT_OK_RETURN(status);
+                NT_STATUS_NOT_OK_RETURN(result);
+        }
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenUser(b, talloc_tos(),
                                       &domain_handle,
                                       SAMR_USER_ACCESS_GET_GROUPS,
                                       user_rids.ids[0],
+                                      &user_handle);
+                                      &user_handle,
+                                      &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_GetGroupsForUser(b, talloc_tos(),
                                               &user_handle,
+                                              &rid_array);
+                                              &rid_array,
+                                              &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupRids(b, talloc_tos(),
                                         &domain_handle,
                                         rid_array->count,
                                         rids,
                                         &names,
                                         &types);
         if (!NT_STATUS_IS_OK(status) &&
             !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
+                                        &types,
+                                        &result);
+        if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result) &&
+            !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenUser(b, talloc_tos(),
                                       &domain_handle,
                                       SAMR_USER_ACCESS_GET_GROUPS,
                                       user_rids.ids[0],
+                                      &user_handle);
+                                      &user_handle,
+                                      &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
                                          r->in.num_entries,
                                          lsa_names,
                                          &group_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         num_member_rids = group_rids.count;
         status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_GetGroupsForUser(b, talloc_tos(),
                                               &user_handle,
+                                              &rid_array);
+                                              &rid_array,
+                                              &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
         for (i=0; i < num_add_rids; i++) {
                 status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                                &domain_handle,
                                                SAMR_GROUP_ACCESS_ADD_MEMBER,
                                                add_rids[i],
+                                               &group_handle);
+                                               &group_handle,
+                                               &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+                status = dcerpc_samr_AddGroupMember(b, talloc_tos(),
                                                     &group_handle,
                                                     user_rids.ids[0],
+/* ? */);
+/* ? */,
+                                                    &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
                 if (is_valid_policy_hnd(&group_handle)) {
                         rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                        dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+                }
+        }
 …
         for (i=0; i < num_del_rids; i++) {
                 status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
+                status = dcerpc_samr_OpenGroup(b, talloc_tos(),
                                                &domain_handle,
                                                SAMR_GROUP_ACCESS_REMOVE_MEMBER,
                                                del_rids[i],
+                                               &group_handle);
+                                               &group_handle,
+                                               &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
+                status = dcerpc_samr_DeleteGroupMember(b, talloc_tos(),
                                                        &group_handle,
+                                                       user_rids.ids[0]);
+                                                       user_rids.ids[0],
+                                                       &result);
                 if (!NT_STATUS_IS_OK(status)) {
                         werr = ntstatus_to_werror(status);
                         goto done;
+                }
+                if (!NT_STATUS_IS_OK(result)) {
+                        werr = ntstatus_to_werror(result);
+                        goto done;
+                }
                 if (is_valid_policy_hnd(&group_handle)) {
                         rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                        dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+                }
+        }
 …
  done:
         if (is_valid_policy_hnd(&group_handle)) {
                 rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
+                dcerpc_samr_Close(b, talloc_tos(), &group_handle, &result);
+        }
 …
         NTSTATUS status = NT_STATUS_OK;
+        NTSTATUS result = NT_STATUS_OK;
         WERROR werr;
+        struct dcerpc_binding_handle *b = NULL;
         ZERO_STRUCT(connect_handle);
 …
                 goto done;
+        }
+        b = pipe_cli->binding_handle;
         werr = libnetapi_samr_open_domain(ctx, pipe_cli,
 …
         init_lsa_String(&lsa_account_name, r->in.user_name);
         status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupNames(b, talloc_tos(),
                                          &domain_handle,
 ,
                                          &lsa_account_name,
                                          &user_rids,
+                                         &name_types);
+                                         &name_types,
+                                         &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_OpenUser(b, talloc_tos(),
                                       &domain_handle,
                                       SAMR_USER_ACCESS_GET_GROUPS,
                                       user_rids.ids[0],
+                                      &user_handle);
+                                      &user_handle,
+                                      &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
                 goto done;
+        }
+        status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
+                goto done;
+        }
+        status = dcerpc_samr_GetGroupsForUser(b, talloc_tos(),
                                               &user_handle,
+                                              &rid_array);
+                                              &rid_array,
+                                              &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         sid_array.sids[0].sid = sid_dup_talloc(ctx, &user_sid);
+        sid_array.sids[0].sid = dom_sid_dup(ctx, &user_sid);
         if (!sid_array.sids[0].sid) {
                 werr = WERR_NOMEM;
 …
+                }
                 sid_array.sids[i+1].sid = sid_dup_talloc(ctx, &sid);
+                sid_array.sids[i+1].sid = dom_sid_dup(ctx, &sid);
                 if (!sid_array.sids[i+1].sid) {
                         werr = WERR_NOMEM;
 …
+        }
         status = rpccli_samr_GetAliasMembership(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_GetAliasMembership(b, talloc_tos(),
                                                 &domain_handle,
                                                 &sid_array,
+                                                &domain_rids);
+                                                &domain_rids,
+                                                &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_GetAliasMembership(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_GetAliasMembership(b, talloc_tos(),
                                                 &builtin_handle,
                                                 &sid_array,
+                                                &builtin_rids);
+                                                &builtin_rids,
+                                                &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }
 …
+        }
         status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
+        status = dcerpc_samr_LookupRids(b, talloc_tos(),
                                         &builtin_handle,
                                         num_rids,
                                         rids,
                                         &names,
+                                        &types);
+                                        &types,
+                                        &result);
         if (!NT_STATUS_IS_OK(status)) {
                 werr = ntstatus_to_werror(status);
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(result)) {
+                werr = ntstatus_to_werror(result);
                 goto done;
+        }

trunk/server/source3/lib/os2helper.c

r698	r745
60	60	#include "../lib/util/attr.h"
61	61	#include "../lib/util/xfile.h"
62		#include "debug.h"
	62	#include "../lib/util/debug.h"
63	63	#else
64	64

trunk/server/source3/lib/packet.c

-              r593
+              r745
    Packet handling
    Copyright (C) Volker Lendecke 2007
    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/>.
 …
 #include "includes.h"
+#include "../lib/util/select.h"
+#include "system/filesys.h"
+#include "system/select.h"
+#include "packet.h"
 struct packet_context {
 …
+}
+NTSTATUS packet_fd_read_sync(struct packet_context *ctx,
+                             struct timeval *timeout)
+{
+        int res;
+        fd_set r_fds;
+        if (ctx->fd < 0 || ctx->fd >= FD_SETSIZE) {
+                errno = EBADF;
+                return map_nt_error_from_unix(errno);
+        }
+        FD_ZERO(&r_fds);
+        FD_SET(ctx->fd, &r_fds);
+        res = sys_select(ctx->fd+1, &r_fds, NULL, NULL, timeout);
+NTSTATUS packet_fd_read_sync(struct packet_context *ctx, int timeout)
+{
+        int res, revents;
+        res = poll_one_fd(ctx->fd, POLLIN|POLLHUP, timeout, &revents);
         if (res == 0) {
                 DEBUG(10, ("select timed out\n"));
+                DEBUG(10, ("poll timed out\n"));
                 return NT_STATUS_IO_TIMEOUT;
+        }
         if (res == -1) {
+                DEBUG(10, ("select returned %s\n", strerror(errno)));
+                return map_nt_error_from_unix(errno);
+                DEBUG(10, ("poll returned %s\n", strerror(errno)));
+                return map_nt_error_from_unix(errno);
+        }
+        if ((revents & (POLLIN|POLLHUP|POLLERR)) == 0) {
+                DEBUG(10, ("socket not readable\n"));
+                return NT_STATUS_IO_TIMEOUT;
+        }

trunk/server/source3/lib/pidfile.c

-              r454
+              r745
 #include "includes.h"
+#include "system/filesys.h"
 #ifndef O_NONBLOCK
 …
         /* Add a suffix to the program name if this is a process with a
          * none default configuration file name. */
         /* On OS/2, CONFIGFILE will always be different to dyn_CONFIGFILE
            as dyn_CONFIGFILE dynamically looks up the system ETC directory */
 #ifndef __OS2__
         if (strcmp( CONFIGFILE, get_dyn_CONFIGFILE()) == 0) {
                 name = SMB_STRDUP(program_name);
 …
                 exit(1);
+        }
         /* Leave pid file open & locked for the duration... */
         SAFE_FREE(name);
 #ifdef __OS2__ // If we leave the file open & locked on OS/2 - we can't read it, so close the fd
         close(fd);
+#else
+        /* set the close on exec so that we don't leak the fd */
+        fcntl(fd, F_SETFD, FD_CLOEXEC);
 #endif
+}

trunk/server/source3/lib/popt_common.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "popt_common.h"
 /* Handle command line options:
 …
  */
+extern bool AllowDebugChange;
+enum {OPT_OPTION=1};
 extern bool override_logfile;
 …
         switch(opt->val) {
+        case OPT_OPTION:
+                if (!lp_set_option(arg)) {
+                        fprintf(stderr, "Error setting option '%s'\n", arg);
+                        exit(1);
+                }
+                break;
         case 'd':
                 if (arg) {
+                        debug_parse_levels(arg);
+                        AllowDebugChange = False;
+                        lp_set_cmdline("log level", arg);
+                }
                 break;
 …
         { "log-basename", 'l', POPT_ARG_STRING, NULL, 'l', "Base name for log files", "LOGFILEBASE" },
         { "version", 'V', POPT_ARG_NONE, NULL, 'V', "Print version" },
+        { "option",         0, POPT_ARG_STRING, NULL, OPT_OPTION, "Set smb.conf option from command line", "name=value" },
         POPT_TABLEEND
 };
 …
 };
+struct poptOption popt_common_option[] = {
+        { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_POST, (void *)popt_common_callback },
+        { "option",         0, POPT_ARG_STRING, NULL, OPT_OPTION, "Set smb.conf option from command line", "name=value" },
+        POPT_TABLEEND
+};
 /* Handle command line options:

trunk/server/source3/lib/privileges.c

-              r414
+              r745
 #include "includes.h"
+#include "lib/privileges.h"
+#include "dbwrap.h"
+#include "libcli/security/privileges_private.h"
+#include "../libcli/security/security.h"
+#include "passdb.h"
 #define PRIVPREFIX              "PRIV_"
 typedef struct {
         size_t count;
         DOM_SID *list;
+        uint32_t count;
+        struct dom_sid *list;
 } SID_LIST;
 typedef struct {
         TALLOC_CTX *mem_ctx;
         SE_PRIV privilege;
+        uint64_t privilege;
         SID_LIST sids;
 } PRIV_SID_LIST;
+static bool get_privileges( const DOM_SID *sid, SE_PRIV *mask )
+/*
+  interpret an old style SE_PRIV structure
+ */
+static uint64_t map_old_SE_PRIV(unsigned char *dptr)
+{
+        uint32_t *old_masks = (uint32_t *)dptr;
+        /*
+         * the old privileges code only ever used up to 0x800, except
+         * for a special case of 'SE_ALL_PRIVS' which was 0xFFFFFFFF
+         */
+        if (old_masks[0] == 0xFFFFFFFF) {
+                /* they set all privileges */
+                return SE_ALL_PRIVS;
+        }
+        /* the old code used the machine byte order, but we don't know
+         * the byte order of the machine that wrote it. However we can
+         * tell what byte order it was by taking advantage of the fact
+         * that it only ever use up to 0x800
+         */
+        if (dptr[0] || dptr[1]) {
+                /* it was little endian */
+                return IVAL(dptr, 0);
+        }
+        /* it was either zero or big-endian */
+        return RIVAL(dptr, 0);
+}
+static bool get_privileges( const struct dom_sid *sid, uint64_t *mask )
+{
         struct db_context *db = get_account_pol_db();
 …
         if ( !data.dptr ) {
                 DEBUG(3, ("get_privileges: No privileges assigned to SID "
+                DEBUG(4, ("get_privileges: No privileges assigned to SID "
                           "[%s]\n", sid_string_dbg(sid)));
                 return False;
+        }
+        SMB_ASSERT( data.dsize == sizeof( SE_PRIV ) );
+        se_priv_copy( mask, (SE_PRIV*)data.dptr );
+        if (data.dsize == 4*4) {
+                /* it's an old style SE_PRIV structure. */
+                *mask = map_old_SE_PRIV(data.dptr);
+        } else {
+                if (data.dsize != sizeof( uint64_t ) ) {
+                        DEBUG(3, ("get_privileges: Invalid privileges record assigned to SID "
+                                  "[%s]\n", sid_string_dbg(sid)));
+                        return False;
+                }
+                *mask = BVAL(data.dptr, 0);
+        }
         TALLOC_FREE(data.dptr);
 …
 ****************************************************************************/
 static bool set_privileges( const DOM_SID *sid, SE_PRIV *mask )
+static bool set_privileges( const struct dom_sid *sid, uint64_t mask )
+{
         struct db_context *db = get_account_pol_db();
+        uint8_t privbuf[8];
         fstring tmp, keystr;
         TDB_DATA data;
 …
         fstr_sprintf(keystr, "%s%s", PRIVPREFIX, sid_to_fstring(tmp, sid));
+        /* no packing.  static size structure, just write it out */
+        data.dptr  = (uint8 *)mask;
+        data.dsize = sizeof(SE_PRIV);
+        /* This writes the 64 bit bitmask out in little endian format */
+        SBVAL(privbuf,0,mask);
+        data.dptr  = privbuf;
+        data.dsize = sizeof(privbuf);
         return NT_STATUS_IS_OK(dbwrap_store_bystring(db, keystr, data,
 …
 *********************************************************************/
 bool get_privileges_for_sids(SE_PRIV *privileges, DOM_SID *slist, int scount)
+{
         SE_PRIV mask;
+bool get_privileges_for_sids(uint64_t *privileges, struct dom_sid *slist, int scount)
+{
+        uint64_t mask;
         int i;
         bool found = False;
         se_priv_copy( privileges, &se_priv_none );
+        *privileges = 0;
         for ( i=0; i<scount; i++ ) {
 …
                 DEBUG(5,("get_privileges_for_sids: sid = %s\nPrivilege "
                          "set:\n", sid_string_dbg(&slist[i])));
                 dump_se_priv( DBGC_ALL, 5, &mask );
                 se_priv_add( privileges, &mask );
+                         "set: 0x%llx\n", sid_string_dbg(&slist[i]),
+                         (unsigned long long)mask));
+                *privileges |= mask;
                 found = True;
+        }
 …
+}
+NTSTATUS get_privileges_for_sid_as_set(TALLOC_CTX *mem_ctx, PRIVILEGE_SET **privileges, struct dom_sid *sid)
+{
+        uint64_t mask;
+        if (!get_privileges(sid, &mask)) {
+                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+        }
+        *privileges = talloc_zero(mem_ctx, PRIVILEGE_SET);
+        if (!*privileges) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        if (!se_priv_to_privilege_set(*privileges, mask)) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        return NT_STATUS_OK;
+}
 /*********************************************************************
 …
         PRIV_SID_LIST *priv = (PRIV_SID_LIST *)state;
         int  prefixlen = strlen(PRIVPREFIX);
         DOM_SID sid;
+        struct dom_sid sid;
         fstring sid_string;
-        /* easy check first */
-        if (rec->value.dsize != sizeof(SE_PRIV) )
-                return 0;
         /* check we have a PRIV_+SID entry */
 …
         /* check to see if we are looking for a particular privilege */
+        if ( !se_priv_equal(&priv->privilege, &se_priv_none) ) {
+                SE_PRIV mask;
+                se_priv_copy( &mask, (SE_PRIV*)rec->value.dptr );
+        fstrcpy( sid_string, (char *)&(rec->key.dptr[strlen(PRIVPREFIX)]) );
+        if (priv->privilege != 0) {
+                uint64_t mask;
+                if (rec->value.dsize == 4*4) {
+                        mask = map_old_SE_PRIV(rec->value.dptr);
+                } else {
+                        if (rec->value.dsize != sizeof( uint64_t ) ) {
+                                DEBUG(3, ("get_privileges: Invalid privileges record assigned to SID "
+                                          "[%s]\n", sid_string));
+                                return 0;
+                        }
+                        mask = BVAL(rec->value.dptr, 0);
+                }
                 /* if the SID does not have the specified privilege
                    then just return */
                 if ( !is_privilege_assigned( &mask, &priv->privilege) )
+                if ((mask & priv->privilege) == 0) {
                         return 0;
+        }
+        fstrcpy( sid_string, (char *)&(rec->key.dptr[strlen(PRIVPREFIX)]) );
+                }
+        }
         /* this is a last ditch safety check to preventing returning
 …
 *********************************************************************/
 NTSTATUS privilege_enumerate_accounts(DOM_SID **sids, int *num_sids)
+NTSTATUS privilege_enumerate_accounts(struct dom_sid **sids, int *num_sids)
+{
         struct db_context *db = get_account_pol_db();
 …
         ZERO_STRUCT(priv);
-        se_priv_copy( &priv.privilege, &se_priv_none );
         db->traverse_read(db, priv_traverse_fn, &priv);
 …
 *********************************************************************/
 NTSTATUS privilege_enum_sids(const SE_PRIV *mask, TALLOC_CTX *mem_ctx,
                              DOM_SID **sids, int *num_sids)
+NTSTATUS privilege_enum_sids(enum sec_privilege privilege, TALLOC_CTX *mem_ctx,
+                             struct dom_sid **sids, int *num_sids)
+{
         struct db_context *db = get_account_pol_db();
 …
         ZERO_STRUCT(priv);
         se_priv_copy(&priv.privilege, mask);
+        priv.privilege = sec_privilege_mask(privilege);
         priv.mem_ctx = mem_ctx;
 …
 ****************************************************************************/
 bool grant_privilege(const DOM_SID *sid, const SE_PRIV *priv_mask)
+{
         SE_PRIV old_mask, new_mask;
+static bool grant_privilege_bitmap(const struct dom_sid *sid, const uint64_t priv_mask)
+{
+        uint64_t old_mask, new_mask;
         ZERO_STRUCT( old_mask );
 …
         if ( get_privileges( sid, &old_mask ) )
                 se_priv_copy( &new_mask, &old_mask );
+                new_mask = old_mask;
         else
                 se_priv_copy( &new_mask, &se_priv_none );
         se_priv_add( &new_mask, priv_mask );
+                new_mask = 0;
+        new_mask |= priv_mask;
         DEBUG(10,("grant_privilege: %s\n", sid_string_dbg(sid)));
+        DEBUGADD( 10, ("original privilege mask:\n"));
+        dump_se_priv( DBGC_ALL, 10, &old_mask );
+        DEBUGADD( 10, ("new privilege mask:\n"));
+        dump_se_priv( DBGC_ALL, 10, &new_mask );
+        return set_privileges( sid, &new_mask );
+        DEBUGADD( 10, ("original privilege mask: 0x%llx\n", (unsigned long long)new_mask));
+        DEBUGADD( 10, ("new privilege mask:      0x%llx\n", (unsigned long long)new_mask));
+        return set_privileges( sid, new_mask );
+}
 …
 *********************************************************************/
 bool grant_privilege_by_name(DOM_SID *sid, const char *name)
+{
         SE_PRIV mask;
+bool grant_privilege_by_name(const struct dom_sid *sid, const char *name)
+{
+        uint64_t mask;
         if (! se_priv_from_name(name, &mask)) {
 …
+        }
+        return grant_privilege( sid, &mask );
+        return grant_privilege_bitmap( sid, mask );
+}
+/***************************************************************************
+ Grant a privilege set (list of LUID values) from a sid
+****************************************************************************/
+bool grant_privilege_set(const struct dom_sid *sid, struct lsa_PrivilegeSet *set)
+{
+        uint64_t privilege_mask;
+        if (!privilege_set_to_se_priv(&privilege_mask, set)) {
+                return false;
+        }
+        return grant_privilege_bitmap(sid, privilege_mask);
+}
 …
 ****************************************************************************/
 bool revoke_privilege(const DOM_SID *sid, const SE_PRIV *priv_mask)
+{
         SE_PRIV mask;
+static bool revoke_privilege_bitmap(const struct dom_sid *sid, const uint64_t priv_mask)
+{
+        uint64_t mask;
         /* if the user has no privileges, then we can't revoke any */
 …
         DEBUG(10,("revoke_privilege: %s\n", sid_string_dbg(sid)));
+        DEBUGADD( 10, ("original privilege mask:\n"));
+        dump_se_priv( DBGC_ALL, 10, &mask );
+        se_priv_remove( &mask, priv_mask );
+        DEBUGADD( 10, ("new privilege mask:\n"));
+        dump_se_priv( DBGC_ALL, 10, &mask );
+        return set_privileges( sid, &mask );
+        DEBUGADD( 10, ("original privilege mask: 0x%llx\n", (unsigned long long)mask));
+        mask &= ~priv_mask;
+        DEBUGADD( 10, ("new privilege mask:      0x%llx\n", (unsigned long long)mask));
+        return set_privileges( sid, mask );
+}
+/***************************************************************************
+ Remove a privilege set (list of LUID values) from a sid
+****************************************************************************/
+bool revoke_privilege_set(const struct dom_sid *sid, struct lsa_PrivilegeSet *set)
+{
+        uint64_t privilege_mask;
+        if (!privilege_set_to_se_priv(&privilege_mask, set)) {
+                return false;
+        }
+        return revoke_privilege_bitmap(sid, privilege_mask);
+}
 …
 *********************************************************************/
 bool revoke_all_privileges( DOM_SID *sid )
+{
         return revoke_privilege( sid, &se_priv_all );
+bool revoke_all_privileges( const struct dom_sid *sid )
+{
+        return revoke_privilege_bitmap( sid, SE_ALL_PRIVS);
+}
 …
 *********************************************************************/
 bool revoke_privilege_by_name(DOM_SID *sid, const char *name)
+{
         SE_PRIV mask;
+bool revoke_privilege_by_name(const struct dom_sid *sid, const char *name)
+{
+        uint64_t mask;
         if (! se_priv_from_name(name, &mask)) {
 …
+        }
         return revoke_privilege(sid, &mask);
+        return revoke_privilege_bitmap(sid, mask);
+}
 …
 ****************************************************************************/
 NTSTATUS privilege_create_account(const DOM_SID *sid )
+{
         return ( grant_privilege(sid, &se_priv_none) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL);
+NTSTATUS privilege_create_account(const struct dom_sid *sid )
+{
+        return ( grant_privilege_bitmap(sid, 0) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL);
+}
 …
+}
-/****************************************************************************
- initialise a privilege list and set the talloc context
- ****************************************************************************/
-NTSTATUS privilege_set_init(PRIVILEGE_SET *priv_set)
+{
-        TALLOC_CTX *mem_ctx;
-        ZERO_STRUCTP( priv_set );
-        mem_ctx = talloc_init("privilege set");
-        if ( !mem_ctx ) {
-                DEBUG(0,("privilege_set_init: failed to initialize talloc ctx!\n"));
-                return NT_STATUS_NO_MEMORY;
+        }
-        priv_set->mem_ctx = mem_ctx;
-        return NT_STATUS_OK;
+}
-/****************************************************************************
-  initialise a privilege list and with someone else's talloc context
-****************************************************************************/
-NTSTATUS privilege_set_init_by_ctx(TALLOC_CTX *mem_ctx, PRIVILEGE_SET *priv_set)
+{
-        ZERO_STRUCTP( priv_set );
-        priv_set->mem_ctx = mem_ctx;
-        priv_set->ext_ctx = True;
-        return NT_STATUS_OK;
+}
-/****************************************************************************
- Free all memory used by a PRIVILEGE_SET
-****************************************************************************/
-void privilege_set_free(PRIVILEGE_SET *priv_set)
+{
-        if ( !priv_set )
-                return;
-        if ( !( priv_set->ext_ctx ) )
-                talloc_destroy( priv_set->mem_ctx );
-        ZERO_STRUCTP( priv_set );
+}
-/****************************************************************************
- duplicate alloc luid_attr
- ****************************************************************************/
-NTSTATUS dup_luid_attr(TALLOC_CTX *mem_ctx, LUID_ATTR **new_la, LUID_ATTR *old_la, int count)
+{
-        int i;
-        if ( !old_la )
-                return NT_STATUS_OK;
-        if (count) {
-                *new_la = TALLOC_ARRAY(mem_ctx, LUID_ATTR, count);
-                if ( !*new_la ) {
-                        DEBUG(0,("dup_luid_attr: failed to alloc new LUID_ATTR array [%d]\n", count));
-                        return NT_STATUS_NO_MEMORY;
+                }
-        } else {
-                *new_la = NULL;
+        }
-        for (i=0; i<count; i++) {
-                (*new_la)[i].luid.high = old_la[i].luid.high;
-                (*new_la)[i].luid.low = old_la[i].luid.low;
-                (*new_la)[i].attr = old_la[i].attr;
+        }
-        return NT_STATUS_OK;
+}
 /*******************************************************************
 *******************************************************************/
 bool is_privileged_sid( const DOM_SID *sid )
+{
         SE_PRIV mask;
+bool is_privileged_sid( const struct dom_sid *sid )
+{
+        uint64_t mask;
         return get_privileges( sid, &mask );
 …
 *******************************************************************/
+bool grant_all_privileges( const DOM_SID *sid )
+{
+        SE_PRIV mask;
+        if (!se_priv_put_all_privileges(&mask)) {
+                return False;
+        }
+        return grant_privilege( sid, &mask );
+}
+bool grant_all_privileges( const struct dom_sid *sid )
+{
+        uint64_t mask;
+        se_priv_put_all_privileges(&mask);
+        return grant_privilege_bitmap( sid, mask );
+}

trunk/server/source3/lib/pthreadpool/pthreadpool.c

-              r741
+              r745
 #include "pthreadpool.h"
 #include "lib/util/dlinklist.h"
+#ifdef __OS2__
+#define pipe(A) os2_pipe(A)
+#endif
 struct pthreadpool_job {

trunk/server/source3/lib/recvfile.c

r664	r745
25	25
26	26	#include "includes.h"
	27	#include "system/filesys.h"
27	28	#ifdef __OS2__
28	29	#define pipe(A) os2_pipe(A)

trunk/server/source3/lib/secdesc.c

-              r414
+              r745
 #include "includes.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "../libcli/security/security.h"
+#define ALL_SECURITY_INFORMATION (SECINFO_OWNER|SECINFO_GROUP|\
+                                        SECINFO_DACL|SECINFO_SACL|\
+                                        SECINFO_UNPROTECTED_SACL|\
+                                        SECINFO_UNPROTECTED_DACL|\
+                                        SECINFO_PROTECTED_SACL|\
+                                        SECINFO_PROTECTED_DACL)
 /* Map generic permissions to file object specific permissions */
 …
 ********************************************************************/
 uint32_t get_sec_info(const SEC_DESC *sd)
+uint32_t get_sec_info(const struct security_descriptor *sd)
+{
         uint32_t sec_info = ALL_SECURITY_INFORMATION;
 …
         if (sd->owner_sid == NULL) {
                 sec_info &= ~OWNER_SECURITY_INFORMATION;
+                sec_info &= ~SECINFO_OWNER;
+        }
         if (sd->group_sid == NULL) {
                 sec_info &= ~GROUP_SECURITY_INFORMATION;
+                sec_info &= ~SECINFO_GROUP;
+        }
         if (sd->sacl == NULL) {
                 sec_info &= ~SACL_SECURITY_INFORMATION;
+                sec_info &= ~SECINFO_SACL;
+        }
         if (sd->dacl == NULL) {
                 sec_info &= ~DACL_SECURITY_INFORMATION;
+                sec_info &= ~SECINFO_DACL;
+        }
 …
 ********************************************************************/
 SEC_DESC_BUF *sec_desc_merge(TALLOC_CTX *ctx, SEC_DESC_BUF *new_sdb, SEC_DESC_BUF *old_sdb)
+{
         DOM_SID *owner_sid, *group_sid;
         SEC_DESC_BUF *return_sdb;
         SEC_ACL *dacl, *sacl;
         SEC_DESC *psd = NULL;
+struct sec_desc_buf *sec_desc_merge_buf(TALLOC_CTX *ctx, struct sec_desc_buf *new_sdb, struct sec_desc_buf *old_sdb)
+{
+        struct dom_sid *owner_sid, *group_sid;
+        struct sec_desc_buf *return_sdb;
+        struct security_acl *dacl, *sacl;
+        struct security_descriptor *psd = NULL;
         uint16 secdesc_type;
         size_t secdesc_size;
 …
+}
+/*******************************************************************
+ Creates a SEC_DESC structure
+********************************************************************/
+SEC_DESC *make_sec_desc(TALLOC_CTX *ctx,
+struct security_descriptor *sec_desc_merge(TALLOC_CTX *ctx, struct security_descriptor *new_sdb, struct security_descriptor *old_sdb)
+{
+        struct dom_sid *owner_sid, *group_sid;
+        struct security_acl *dacl, *sacl;
+        struct security_descriptor *psd = NULL;
+        uint16 secdesc_type;
+        size_t secdesc_size;
+        /* Copy over owner and group sids.  There seems to be no flag for
+           this so just check the pointer values. */
+        owner_sid = new_sdb->owner_sid ? new_sdb->owner_sid :
+                old_sdb->owner_sid;
+        group_sid = new_sdb->group_sid ? new_sdb->group_sid :
+                old_sdb->group_sid;
+        secdesc_type = new_sdb->type;
+        /* Ignore changes to the system ACL.  This has the effect of making
+           changes through the security tab audit button not sticking.
+           Perhaps in future Samba could implement these settings somehow. */
+        sacl = NULL;
+        secdesc_type &= ~SEC_DESC_SACL_PRESENT;
+        /* Copy across discretionary ACL */
+        if (secdesc_type & SEC_DESC_DACL_PRESENT) {
+                dacl = new_sdb->dacl;
+        } else {
+                dacl = old_sdb->dacl;
+        }
+        /* Create new security descriptor from bits */
+        psd = make_sec_desc(ctx, new_sdb->revision, secdesc_type,
+                            owner_sid, group_sid, sacl, dacl, &secdesc_size);
+        return psd;
+}
+/*******************************************************************
+ Creates a struct security_descriptor structure
+********************************************************************/
+#define  SEC_DESC_HEADER_SIZE (2 * sizeof(uint16) + 4 * sizeof(uint32))
+struct security_descriptor *make_sec_desc(TALLOC_CTX *ctx,
                         enum security_descriptor_revision revision,
                         uint16 type,
                         const DOM_SID *owner_sid, const DOM_SID *grp_sid,
                         SEC_ACL *sacl, SEC_ACL *dacl, size_t *sd_size)
+{
         SEC_DESC *dst;
+                        const struct dom_sid *owner_sid, const struct dom_sid *grp_sid,
+                        struct security_acl *sacl, struct security_acl *dacl, size_t *sd_size)
+{
+        struct security_descriptor *dst;
         uint32 offset     = 0;
         *sd_size = 0;
         if(( dst = TALLOC_ZERO_P(ctx, SEC_DESC)) == NULL)
+        if(( dst = TALLOC_ZERO_P(ctx, struct security_descriptor)) == NULL)
                 return NULL;
 …
         dst->dacl      = NULL;
         if(owner_sid && ((dst->owner_sid = sid_dup_talloc(dst,owner_sid)) == NULL))
+        if(owner_sid && ((dst->owner_sid = dom_sid_dup(dst,owner_sid)) == NULL))
                 goto error_exit;
         if(grp_sid && ((dst->group_sid = sid_dup_talloc(dst,grp_sid)) == NULL))
+        if(grp_sid && ((dst->group_sid = dom_sid_dup(dst,grp_sid)) == NULL))
                 goto error_exit;
 …
         if (dst->owner_sid != NULL) {
                 offset += ndr_size_dom_sid(dst->owner_sid, NULL, 0);
+                offset += ndr_size_dom_sid(dst->owner_sid, 0);
+        }
         if (dst->group_sid != NULL) {
                 offset += ndr_size_dom_sid(dst->group_sid, NULL, 0);
+                offset += ndr_size_dom_sid(dst->group_sid, 0);
+        }
 …
 /*******************************************************************
  Duplicate a SEC_DESC structure.
 ********************************************************************/
 SEC_DESC *dup_sec_desc(TALLOC_CTX *ctx, const SEC_DESC *src)
+ Duplicate a struct security_descriptor structure.
+********************************************************************/
+struct security_descriptor *dup_sec_desc(TALLOC_CTX *ctx, const struct security_descriptor *src)
+{
         size_t dummy;
 …
         ndr_err = ndr_push_struct_blob(
                 &blob, mem_ctx, NULL, secdesc,
+                &blob, mem_ctx, secdesc,
                 (ndr_push_flags_fn_t)ndr_push_security_descriptor);
 …
                 DEBUG(0, ("ndr_push_security_descriptor failed: %s\n",
                           ndr_errstr(ndr_err)));
                 return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
+        }
 …
         ndr_err = ndr_push_struct_blob(
                 &blob, mem_ctx, NULL, secdesc_buf,
+                &blob, mem_ctx, secdesc_buf,
                 (ndr_push_flags_fn_t)ndr_push_sec_desc_buf);
 …
                 DEBUG(0, ("ndr_push_sec_desc_buf failed: %s\n",
                           ndr_errstr(ndr_err)));
                 return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
+        }
 …
         blob = data_blob_const(data, len);
+        ndr_err = ndr_pull_struct_blob(
+                &blob, result, NULL, result,
+        ndr_err = ndr_pull_struct_blob(&blob, result, result,
                 (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
 …
                           ndr_errstr(ndr_err)));
                 TALLOC_FREE(result);
                 return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
+        }
 …
         blob = data_blob_const(data, len);
+        ndr_err = ndr_pull_struct_blob(
+                &blob, result, NULL, result,
+        ndr_err = ndr_pull_struct_blob(&blob, result, result,
                 (ndr_pull_flags_fn_t)ndr_pull_sec_desc_buf);
 …
                           ndr_errstr(ndr_err)));
                 TALLOC_FREE(result);
                 return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
+        }
 …
 /*******************************************************************
  Creates a SEC_DESC structure with typical defaults.
 ********************************************************************/
 SEC_DESC *make_standard_sec_desc(TALLOC_CTX *ctx, const DOM_SID *owner_sid, const DOM_SID *grp_sid,
                                  SEC_ACL *dacl, size_t *sd_size)
+ Creates a struct security_descriptor structure with typical defaults.
+********************************************************************/
+struct security_descriptor *make_standard_sec_desc(TALLOC_CTX *ctx, const struct dom_sid *owner_sid, const struct dom_sid *grp_sid,
+                                 struct security_acl *dacl, size_t *sd_size)
+{
         return make_sec_desc(ctx, SECURITY_DESCRIPTOR_REVISION_1,
 …
 /*******************************************************************
  Creates a SEC_DESC_BUF structure.
 ********************************************************************/
 SEC_DESC_BUF *make_sec_desc_buf(TALLOC_CTX *ctx, size_t len, SEC_DESC *sec_desc)
+{
         SEC_DESC_BUF *dst;
         if((dst = TALLOC_ZERO_P(ctx, SEC_DESC_BUF)) == NULL)
+ Creates a struct sec_desc_buf structure.
+********************************************************************/
+struct sec_desc_buf *make_sec_desc_buf(TALLOC_CTX *ctx, size_t len, struct security_descriptor *sec_desc)
+{
+        struct sec_desc_buf *dst;
+        if((dst = TALLOC_ZERO_P(ctx, struct sec_desc_buf)) == NULL)
                 return NULL;
 …
 /*******************************************************************
  Duplicates a SEC_DESC_BUF structure.
 ********************************************************************/
 SEC_DESC_BUF *dup_sec_desc_buf(TALLOC_CTX *ctx, SEC_DESC_BUF *src)
+ Duplicates a struct sec_desc_buf structure.
+********************************************************************/
+struct sec_desc_buf *dup_sec_desc_buf(TALLOC_CTX *ctx, struct sec_desc_buf *src)
+{
         if(src == NULL)
 …
 /*******************************************************************
  Add a new SID with its permissions to SEC_DESC.
 ********************************************************************/
 NTSTATUS sec_desc_add_sid(TALLOC_CTX *ctx, SEC_DESC **psd, DOM_SID *sid, uint32 mask, size_t *sd_size)
+{
         SEC_DESC *sd   = 0;
         SEC_ACL  *dacl = 0;
         SEC_ACE  *ace  = 0;
+ Add a new SID with its permissions to struct security_descriptor.
+********************************************************************/
+NTSTATUS sec_desc_add_sid(TALLOC_CTX *ctx, struct security_descriptor **psd, const struct dom_sid *sid, uint32 mask, size_t *sd_size)
+{
+        struct security_descriptor *sd   = 0;
+        struct security_acl  *dacl = 0;
+        struct security_ace  *ace  = 0;
         NTSTATUS  status;
 …
 /*******************************************************************
  Modify a SID's permissions in a SEC_DESC.
 ********************************************************************/
 NTSTATUS sec_desc_mod_sid(SEC_DESC *sd, DOM_SID *sid, uint32 mask)
+ Modify a SID's permissions in a struct security_descriptor.
+********************************************************************/
+NTSTATUS sec_desc_mod_sid(struct security_descriptor *sd, struct dom_sid *sid, uint32 mask)
+{
         NTSTATUS status;
 …
 /*******************************************************************
  Delete a SID from a SEC_DESC.
 ********************************************************************/
 NTSTATUS sec_desc_del_sid(TALLOC_CTX *ctx, SEC_DESC **psd, DOM_SID *sid, size_t *sd_size)
+{
         SEC_DESC *sd   = 0;
         SEC_ACL  *dacl = 0;
         SEC_ACE  *ace  = 0;
+ Delete a SID from a struct security_descriptor.
+********************************************************************/
+NTSTATUS sec_desc_del_sid(TALLOC_CTX *ctx, struct security_descriptor **psd, struct dom_sid *sid, size_t *sd_size)
+{
+        struct security_descriptor *sd   = 0;
+        struct security_acl  *dacl = 0;
+        struct security_ace  *ace  = 0;
         NTSTATUS  status;
 …
 /*
  * Determine if an ACE is inheritable
+ * Determine if an struct security_ace is inheritable
  */
 static bool is_inheritable_ace(const SEC_ACE *ace,
+static bool is_inheritable_ace(const struct security_ace *ace,
                                 bool container)
+{
 …
  */
 bool sd_has_inheritable_components(const SEC_DESC *parent_ctr, bool container)
+bool sd_has_inheritable_components(const struct security_descriptor *parent_ctr, bool container)
+{
         unsigned int i;
         const SEC_ACL *the_acl = parent_ctr->dacl;
+        const struct security_acl *the_acl = parent_ctr->dacl;
         for (i = 0; i < the_acl->num_aces; i++) {
                 const SEC_ACE *ace = &the_acl->aces[i];
+                const struct security_ace *ace = &the_acl->aces[i];
                 if (is_inheritable_ace(ace, container)) {
 …
 NTSTATUS se_create_child_secdesc(TALLOC_CTX *ctx,
                                         SEC_DESC **ppsd,
+                                        struct security_descriptor **ppsd,
                                         size_t *psize,
                                         const SEC_DESC *parent_ctr,
                                         const DOM_SID *owner_sid,
                                         const DOM_SID *group_sid,
+                                        const struct security_descriptor *parent_ctr,
+                                        const struct dom_sid *owner_sid,
+                                        const struct dom_sid *group_sid,
                                         bool container)
+{
         SEC_ACL *new_dacl = NULL, *the_acl = NULL;
         SEC_ACE *new_ace_list = NULL;
+        struct security_acl *new_dacl = NULL, *the_acl = NULL;
+        struct security_ace *new_ace_list = NULL;
         unsigned int new_ace_list_ndx = 0, i;
 …
+                }
                 if (!(new_ace_list = TALLOC_ARRAY(ctx, SEC_ACE,
+                if (!(new_ace_list = TALLOC_ARRAY(ctx, struct security_ace,
 *the_acl->num_aces))) {
                         return NT_STATUS_NO_MEMORY;
 …
         for (i = 0; i < the_acl->num_aces; i++) {
                 const SEC_ACE *ace = &the_acl->aces[i];
                 SEC_ACE *new_ace = &new_ace_list[new_ace_list_ndx];
                 const DOM_SID *ptrustee = &ace->trustee;
                 const DOM_SID *creator = NULL;
+                const struct security_ace *ace = &the_acl->aces[i];
+                struct security_ace *new_ace = &new_ace_list[new_ace_list_ndx];
+                const struct dom_sid *ptrustee = &ace->trustee;
+                const struct dom_sid *creator = NULL;
                 uint8 new_flags = ace->flags;
 …
                 /* The CREATOR sids are special when inherited */
                 if (sid_equal(ptrustee, &global_sid_Creator_Owner)) {
+                if (dom_sid_equal(ptrustee, &global_sid_Creator_Owner)) {
                         creator = &global_sid_Creator_Owner;
                         ptrustee = owner_sid;
                 } else if (sid_equal(ptrustee, &global_sid_Creator_Group)) {
+                } else if (dom_sid_equal(ptrustee, &global_sid_Creator_Group)) {
                         creator = &global_sid_Creator_Group;
                         ptrustee = group_sid;
 …
 NTSTATUS se_create_child_secdesc_buf(TALLOC_CTX *ctx,
                                         SEC_DESC_BUF **ppsdb,
                                         const SEC_DESC *parent_ctr,
+                                        struct sec_desc_buf **ppsdb,
+                                        const struct security_descriptor *parent_ctr,
                                         bool container)
+{
         NTSTATUS status;
         size_t size = 0;
         SEC_DESC *sd = NULL;
+        struct security_descriptor *sd = NULL;
         *ppsdb = NULL;

trunk/server/source3/lib/sendfile.c

-              r414
+              r745
                         nwritten = sendfile(tofd, fromfd, &offset, total);
 #endif
+                } while (nwritten == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
                 if (nwritten == -1) {
                         if (errno == ENOSYS || errno == EINVAL) {
 …
                 do {
                         nwritten = sendfile(tofd, fromfd, &small_offset, small_total);
+                } while (nwritten == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
                 if (nwritten == -1) {
                         if (errno == ENOSYS || errno == EINVAL) {
 …
                         nwritten = sendfilev(tofd, vec, sfvcnt, &xferred);
 #endif
+                if (nwritten == -1 && errno == EINTR) {
+#if defined(EWOULDBLOCK)
+                if  (nwritten == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) {
+#else
+                if (nwritten == -1 && (errno == EINTR || errno == EAGAIN)) {
+#endif
                         if (xferred == 0)
                                 continue; /* Nothing written yet. */
 …
                         nwritten = sendfile(tofd, fromfd, offset, total, &hdtrl[0], 0);
 #endif
+                } while (nwritten == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+                } while (nwritten == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
                 if (nwritten == -1)
                         return -1;
 …
                 do {
                         ret = sendfile(fromfd, tofd, offset, total, &hdr, &nwritten, 0);
+                } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+                } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+                } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
                 if (ret == -1)
                         return -1;
 …
                 do {
                         ret = send_file(&tofd, &hdtrl, 0);
+                } while ( (ret == 1) || (ret == -1 && errno == EINTR) );
+#if defined(EWOULDBLOCK)
+                } while ((ret == 1) || (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)));
+#else
+                } while ((ret == 1) || (ret == -1 && (errno == EINTR || errno == EAGAIN)));
+#endif
                 if ( ret == -1 )
                         return -1;

trunk/server/source3/lib/server_mutex.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "lib/util/tdb_wrap.h"
+#include "util_tdb.h"
 /* For reasons known only to MS, many of their NT/Win2k versions

trunk/server/source3/lib/sharesec.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "../libcli/security/security.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "dbwrap.h"
+#include "util_tdb.h"
 /*******************************************************************
 …
 #define SHARE_DATABASE_VERSION_V1 1
 #define SHARE_DATABASE_VERSION_V2 2 /* version id in little endian. */
+#define SHARE_DATABASE_VERSION_V3 3 /* canonicalized sharenames as lower case */
+#define SHARE_SECURITY_DB_KEY_PREFIX_STR "SECDESC/"
 /* Map generic permissions to file object specific permissions */
 …
+}
+/*****************************************************
+ Looking for keys of the form: SHARE_SECURITY_DB_KEY_PREFIX_STR + "non lower case str".
+ If we find one re-write it into a canonical case form.
+*****************************************************/
+static int upgrade_v2_to_v3(struct db_record *rec, void *priv)
+{
+        size_t prefix_len = strlen(SHARE_SECURITY_DB_KEY_PREFIX_STR);
+        const char *servicename = NULL;
+        char *c_servicename = NULL;
+        char *newkey = NULL;
+        bool *p_upgrade_ok = (bool *)priv;
+        NTSTATUS status;
+        /* Is there space for a one character sharename ? */
+        if (rec->key.dsize <= prefix_len+2) {
+                return 0;
+        }
+        /* Does it start with the share key prefix ? */
+        if (memcmp(rec->key.dptr, SHARE_SECURITY_DB_KEY_PREFIX_STR,
+                        prefix_len) != 0) {
+                return 0;
+        }
+        /* Is it a null terminated string as a key ? */
+        if (rec->key.dptr[rec->key.dsize-1] != '\0') {
+                return 0;
+        }
+        /* Bytes after the prefix are the sharename string. */
+        servicename = (char *)&rec->key.dptr[prefix_len];
+        c_servicename = canonicalize_servicename(talloc_tos(), servicename);
+        if (!c_servicename) {
+                smb_panic("out of memory upgrading share security db from v2 -> v3");
+        }
+        if (strcmp(servicename, c_servicename) == 0) {
+                /* Old and new names match. No canonicalization needed. */
+                TALLOC_FREE(c_servicename);
+                return 0;
+        }
+        /* Oops. Need to canonicalize name, delete old then store new. */
+        status = rec->delete_rec(rec);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("upgrade_v2_to_v3: Failed to delete secdesc for "
+                          "%s: %s\n", rec->key.dptr, nt_errstr(status)));
+                TALLOC_FREE(c_servicename);
+                *p_upgrade_ok = false;
+                return -1;
+        } else {
+                DEBUG(10, ("upgrade_v2_to_v3: deleted secdesc for "
+                          "%s\n", rec->key.dptr ));
+        }
+        if (!(newkey = talloc_asprintf(talloc_tos(),
+                        SHARE_SECURITY_DB_KEY_PREFIX_STR "%s",
+                        c_servicename))) {
+                smb_panic("out of memory upgrading share security db from v2 -> v3");
+        }
+        status = dbwrap_store(share_db,
+                                string_term_tdb_data(newkey),
+                                rec->value,
+                                TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("upgrade_v2_to_v3: Failed to store secdesc for "
+                          "%s: %s\n", c_servicename, nt_errstr(status)));
+                TALLOC_FREE(c_servicename);
+                TALLOC_FREE(newkey);
+                *p_upgrade_ok = false;
+                return -1;
+        } else {
+                DEBUG(10, ("upgrade_v2_to_v3: stored secdesc for "
+                          "%s\n", newkey ));
+        }
+        TALLOC_FREE(newkey);
+        TALLOC_FREE(c_servicename);
+        return 0;
+}
 bool share_info_db_init(void)
+{
         const char *vstring = "INFO/version";
         int32 vers_id;
+        int ret;
+        bool upgrade_ok = true;
         if (share_db != NULL) {
 …
         vers_id = dbwrap_fetch_int32(share_db, vstring);
         if (vers_id == SHARE_DATABASE_VERSION_V2) {
+        if (vers_id == SHARE_DATABASE_VERSION_V3) {
                 return true;
+        }
 …
         vers_id = dbwrap_fetch_int32(share_db, vstring);
         if (vers_id == SHARE_DATABASE_VERSION_V2) {
+        if (vers_id == SHARE_DATABASE_VERSION_V3) {
                 /*
                  * Race condition
 …
+        }
+        /* Move to at least V2. */
         /* Cope with byte-reversed older versions of the db. */
         if ((vers_id == SHARE_DATABASE_VERSION_V1) || (IREV(vers_id) == SHARE_DATABASE_VERSION_V1)) {
 …
         if (vers_id != SHARE_DATABASE_VERSION_V2) {
-                int ret;
                 ret = share_db->traverse(share_db, delete_fn, NULL);
                 if (ret < 0) {
 …
+        }
+        /* Finally upgrade to version 3, with canonicalized sharenames. */
+        ret = share_db->traverse(share_db, upgrade_v2_to_v3, &upgrade_ok);
+        if (ret < 0 || upgrade_ok == false) {
+                DEBUG(0, ("traverse failed\n"));
+                goto cancel;
+        }
+        if (dbwrap_store_int32(share_db, vstring,
+                               SHARE_DATABASE_VERSION_V3) != 0) {
+                DEBUG(0, ("dbwrap_store_int32 failed\n"));
+                goto cancel;
+        }
         if (share_db->transaction_commit(share_db) != 0) {
                 DEBUG(0, ("transaction_commit failed\n"));
 …
  ********************************************************************/
 SEC_DESC *get_share_security_default( TALLOC_CTX *ctx, size_t *psize, uint32 def_access)
+struct security_descriptor *get_share_security_default( TALLOC_CTX *ctx, size_t *psize, uint32 def_access)
+{
         uint32_t sa;
         SEC_ACE ace;
         SEC_ACL *psa = NULL;
         SEC_DESC *psd = NULL;
+        struct security_ace ace;
+        struct security_acl *psa = NULL;
+        struct security_descriptor *psd = NULL;
         uint32 spec_access = def_access;
 …
  ********************************************************************/
 SEC_DESC *get_share_security( TALLOC_CTX *ctx, const char *servicename,
+struct security_descriptor *get_share_security( TALLOC_CTX *ctx, const char *servicename,
                               size_t *psize)
+{
         char *key;
         SEC_DESC *psd = NULL;
+        struct security_descriptor *psd = NULL;
         TDB_DATA data;
+        char *c_servicename = canonicalize_servicename(talloc_tos(), servicename);
         NTSTATUS status;
+        if (!c_servicename) {
+                return NULL;
+        }
         if (!share_info_db_init()) {
+                TALLOC_FREE(c_servicename);
                 return NULL;
+        }
+        if (!(key = talloc_asprintf(ctx, "SECDESC/%s", servicename))) {
+        if (!(key = talloc_asprintf(ctx, SHARE_SECURITY_DB_KEY_PREFIX_STR "%s", c_servicename))) {
+                TALLOC_FREE(c_servicename);
                 DEBUG(0, ("talloc_asprintf failed\n"));
                 return NULL;
+        }
+        TALLOC_FREE(c_servicename);
         data = dbwrap_fetch_bystring(share_db, talloc_tos(), key);
 …
                 DEBUG(0, ("unmarshall_sec_desc failed: %s\n",
                           nt_errstr(status)));
+                return NULL;
+        }
+        if (psd)
+                *psize = ndr_size_security_descriptor(psd, NULL, 0);
+                return get_share_security_default(ctx, psize,
+                                                  GENERIC_ALL_ACCESS);
+        }
+        if (psd) {
+                *psize = ndr_size_security_descriptor(psd, 0);
+        } else {
+                return get_share_security_default(ctx, psize,
+                                                  GENERIC_ALL_ACCESS);
+        }
         return psd;
 …
  ********************************************************************/
 bool set_share_security(const char *share_name, SEC_DESC *psd)
+{
         TALLOC_CTX *frame;
+bool set_share_security(const char *share_name, struct security_descriptor *psd)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
         char *key;
         bool ret = False;
         TDB_DATA blob;
         NTSTATUS status;
+        char *c_share_name = canonicalize_servicename(frame, share_name);
+        if (!c_share_name) {
+                goto out;
+        }
         if (!share_info_db_init()) {
+                return False;
+        }
+        frame = talloc_stackframe();
+                goto out;
+        }
         status = marshall_sec_desc(frame, psd, &blob.dptr, &blob.dsize);
 …
+        }
         if (!(key = talloc_asprintf(frame, "SECDESC/%s", share_name))) {
+        if (!(key = talloc_asprintf(frame, SHARE_SECURITY_DB_KEY_PREFIX_STR "%s", c_share_name))) {
                 DEBUG(0, ("talloc_asprintf failed\n"));
                 goto out;
 …
         char *key;
         NTSTATUS status;
+        char *c_servicename = canonicalize_servicename(talloc_tos(), servicename);
+        if (!c_servicename) {
+                return NULL;
+        }
         if (!share_info_db_init()) {
+                TALLOC_FREE(c_servicename);
                 return False;
+        }
+        if (!(key = talloc_asprintf(talloc_tos(), "SECDESC/%s",
+                                    servicename))) {
+        if (!(key = talloc_asprintf(talloc_tos(), SHARE_SECURITY_DB_KEY_PREFIX_STR "%s",
+                                    c_servicename))) {
+                TALLOC_FREE(c_servicename);
                 return False;
+        }
 …
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("delete_share_security: Failed to delete entry for "
+                          "share %s: %s\n", servicename, nt_errstr(status)));
+                          "share %s: %s\n", c_servicename, nt_errstr(status)));
+                TALLOC_FREE(c_servicename);
                 return False;
+        }
+        TALLOC_FREE(c_servicename);
         return True;
+}
 …
 ********************************************************************/
+bool share_access_check(const NT_USER_TOKEN *token, const char *sharename,
+                        uint32 desired_access)
+bool share_access_check(const struct security_token *token,
+                        const char *sharename,
+                        uint32 desired_access,
+                        uint32_t *pgranted)
+{
         uint32 granted;
         NTSTATUS status;
         SEC_DESC *psd = NULL;
+        struct security_descriptor *psd = NULL;
         size_t sd_size;
 …
         TALLOC_FREE(psd);
+        if (pgranted != NULL) {
+                *pgranted = granted;
+        }
         return NT_STATUS_IS_OK(status);
 …
 ***************************************************************************/
 bool parse_usershare_acl(TALLOC_CTX *ctx, const char *acl_str, SEC_DESC **ppsd)
+bool parse_usershare_acl(TALLOC_CTX *ctx, const char *acl_str, struct security_descriptor **ppsd)
+{
         size_t s_size = 0;
         const char *pacl = acl_str;
         int num_aces = 0;
         SEC_ACE *ace_list = NULL;
         SEC_ACL *psa = NULL;
         SEC_DESC *psd = NULL;
+        struct security_ace *ace_list = NULL;
+        struct security_acl *psa = NULL;
+        struct security_descriptor *psd = NULL;
         size_t sd_size = 0;
         int i;
 …
         /* If the acl string is blank return "Everyone:R" */
         if (!*acl_str) {
                 SEC_DESC *default_psd = get_share_security_default(ctx, &s_size, GENERIC_READ_ACCESS);
+                struct security_descriptor *default_psd = get_share_security_default(ctx, &s_size, GENERIC_READ_ACCESS);
                 if (!default_psd) {
                         return False;
 …
         num_aces += count_chars(pacl,',');
         ace_list = TALLOC_ARRAY(ctx, SEC_ACE, num_aces);
+        ace_list = TALLOC_ARRAY(ctx, struct security_ace, num_aces);
         if (!ace_list) {
                 return False;
 …
                 uint32 g_access;
                 uint32 s_access;
                 DOM_SID sid;
+                struct dom_sid sid;
                 char *sidstr;
                 enum security_ace_type type = SEC_ACE_TYPE_ACCESS_ALLOWED;

trunk/server/source3/lib/smbconf/smbconf_init.c

-              r414
+              r745
 #include "lib/smbconf/smbconf_txt.h"
 #include "lib/smbconf/smbconf_reg.h"
+#include "lib/smbconf/smbconf_init.h"
 /**
 …
  * -  "txt" or "file"
  */
 WERROR smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
+sbcErr smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
                     const char *source)
+{
         WERROR werr;
+        sbcErr err;
         char *backend = NULL;
         char *path = NULL;
 …
         if (conf_ctx == NULL) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
         if ((source == NULL) || (*source == '\0')) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
         backend = talloc_strdup(tmp_ctx, source);
         if (backend == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
 …
         if (strequal(backend, "registry") || strequal(backend, "reg")) {
                 werr = smbconf_init_reg(mem_ctx, conf_ctx, path);
+                err = smbconf_init_reg(mem_ctx, conf_ctx, path);
         } else if (strequal(backend, "file") || strequal(backend, "txt")) {
                 werr = smbconf_init_txt(mem_ctx, conf_ctx, path);
+                err = smbconf_init_txt(mem_ctx, conf_ctx, path);
         } else if (sep == NULL) {
                 /*
 …
                  * string as a path argument.
                  */
                 werr = smbconf_init_txt(mem_ctx, conf_ctx, backend);
+                err = smbconf_init_txt(mem_ctx, conf_ctx, backend);
         } else {
                 /*
 …
                  * 'include = /path/to/file.%T'
                  */
                 werr = smbconf_init_txt(mem_ctx, conf_ctx, source);
+                err = smbconf_init_txt(mem_ctx, conf_ctx, source);
+        }
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}

trunk/server/source3/lib/smbconf/smbconf_init.h

r414	r745
27	27	* takes source string in the form of "backend:path"
28	28	*/
29		~~WERROR~~ smbconf_init(TALLOC_CTX mem_ctx, struct smbconf_ctx *conf_ctx,
	29	sbcErr smbconf_init(TALLOC_CTX mem_ctx, struct smbconf_ctx *conf_ctx,
30	30	const char *source);
31	31

trunk/server/source3/lib/smbconf/smbconf_reg.c

-              r414
+              r745
 #include "includes.h"
 #include "lib/smbconf/smbconf_private.h"
+#include "registry.h"
+#include "registry/reg_api.h"
+#include "registry/reg_backend_db.h"
+#include "registry/reg_util_token.h"
+#include "registry/reg_api_util.h"
+#include "registry/reg_init_smbconf.h"
+#include "lib/smbconf/smbconf_init.h"
+#include "lib/smbconf/smbconf_reg.h"
+#include "../libcli/registry/util_reg.h"
 #define INCLUDES_VALNAME "includes"
 …
  * Open a subkey of the base key (i.e a service)
  */
 static WERROR smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
+static sbcErr smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
                                            struct smbconf_ctx *ctx,
                                            const char *servicename,
 …
         if (servicename == NULL) {
                 *key = rpd(ctx)->base_key;
                 return WERR_OK;
+                return SBC_ERR_OK;
+        }
         werr = reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
                            desired_access, key);
         if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
+                werr = WERR_NO_SUCH_SERVICE;
+        }
+        return werr;
+                return SBC_ERR_NO_SUCH_SERVICE;
+        }
+        if (!W_ERROR_IS_OK(werr)) {
+                return SBC_ERR_NOMEM;
+        }
+        return SBC_ERR_OK;
+}
 …
  * create a subkey of the base key (i.e. a service...)
  */
 static WERROR smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
+static sbcErr smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
                                              struct smbconf_ctx *ctx,
                                              const char * subkeyname,
                                              struct registry_key **newkey)
+{
+        WERROR werr = WERR_OK;
+        WERROR werr;
+        sbcErr err = SBC_ERR_OK;
         TALLOC_CTX *create_ctx;
         enum winreg_CreateAction action = REG_ACTION_NONE;
 …
         if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
                 DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
                 werr = WERR_FILE_EXISTS;
+                err = SBC_ERR_FILE_EXISTS;
+        }
         if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(5, ("Error creating key %s: %s\n",
                          subkeyname, win_errstr(werr)));
+                err = SBC_ERR_UNKNOWN_FAILURE;
+        }
         talloc_free(create_ctx);
         return werr;
+        return err;
+}
 …
  * add a value to a key.
  */
 static WERROR smbconf_reg_set_value(struct registry_key *key,
+static sbcErr smbconf_reg_set_value(struct registry_key *key,
                                     const char *valname,
                                     const char *valstr)
 …
         struct registry_value val;
         WERROR werr = WERR_OK;
+        sbcErr err;
         char *subkeyname;
         const char *canon_valname;
 …
                                   "parameter '%s'\n", valstr, valname));
+                }
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
                 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
                           canon_valname));
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
                 DEBUG(5, ("Invalid registry key '%s' given as "
                           "smbconf section.\n", key->key->name));
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
                           "service definition ('%s').\n", canon_valname,
                           subkeyname));
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
         val.type = REG_SZ;
+        val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
+        val.v.sz.len = strlen(canon_valstr) + 1;
+        if (!push_reg_sz(talloc_tos(), &val.data, canon_valstr)) {
+                err = SBC_ERR_NOMEM;
+                goto done;
+        }
         werr = reg_setvalue(key, canon_valname, &val);
 …
                           "key '%s': %s\n",
                           canon_valname, key->key->name, win_errstr(werr)));
+        }
+done:
+        return werr;
+}
+static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
+                err = SBC_ERR_NOMEM;
+                goto done;
+        }
+        err = SBC_ERR_OK;
+done:
+        return err;
+}
+static sbcErr smbconf_reg_set_multi_sz_value(struct registry_key *key,
                                              const char *valname,
                                              const uint32_t num_strings,
 …
+{
         WERROR werr;
+        sbcErr err = SBC_ERR_OK;
         struct registry_value *value;
         uint32_t count;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
+        const char **array;
         if (strings == NULL) {
+                werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
+                goto done;
+        }
+        array = talloc_zero_array(tmp_ctx, const char *, num_strings + 1);
+        if (array == NULL) {
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
         value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
+        if (value == NULL) {
+                err = SBC_ERR_NOMEM;
+                goto done;
+        }
         value->type = REG_MULTI_SZ;
+        value->v.multi_sz.num_strings = num_strings;
+        value->v.multi_sz.strings = TALLOC_ARRAY(tmp_ctx, char *, num_strings);
+        if (value->v.multi_sz.strings == NULL) {
+                werr = WERR_NOMEM;
+                goto done;
+        }
         for (count = 0; count < num_strings; count++) {
+                value->v.multi_sz.strings[count] =
+                        talloc_strdup(value->v.multi_sz.strings,
+                                      strings[count]);
+                if (value->v.multi_sz.strings[count] == NULL) {
+                        werr = WERR_NOMEM;
+                        goto done;
+                }
+                array[count] = talloc_strdup(value, strings[count]);
+                if (array[count] == NULL) {
+                        err = SBC_ERR_NOMEM;
+                        goto done;
+                }
+        }
+        if (!push_reg_multi_sz(value, &value->data, array)) {
+                err = SBC_ERR_NOMEM;
+                goto done;
+        }
 …
                 DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
                           valname, key->key->name, win_errstr(werr)));
+                err = SBC_ERR_ACCESS_DENIED;
+        }
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
         switch (value->type) {
         case REG_DWORD:
+                result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
+                if (value->data.length >= 4) {
+                        uint32_t v = IVAL(value->data.data, 0);
+                        result = talloc_asprintf(mem_ctx, "%d", v);
+                }
                 break;
         case REG_SZ:
+        case REG_EXPAND_SZ:
+                result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
+        case REG_EXPAND_SZ: {
+                const char *s;
+                if (!pull_reg_sz(mem_ctx, &value->data, &s)) {
+                        break;
+                }
+                result = talloc_strdup(mem_ctx, s);
                 break;
+        }
         case REG_MULTI_SZ: {
                 uint32 j;
+                for (j = 0; j < value->v.multi_sz.num_strings; j++) {
+                const char **a = NULL;
+                if (!pull_reg_multi_sz(mem_ctx, &value->data, &a)) {
+                        break;
+                }
+                for (j = 0; a[j] != NULL; j++) {
                         result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
                                                  result ? result : "" ,
                                                  value->v.multi_sz.strings[j]);
+                                                 a[j]);
                         if (result == NULL) {
                                 break;
 …
         case REG_BINARY:
                 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
                                          (int)value->v.binary.length);
+                                         (int)value->data.length);
                 break;
         default:
 …
+}
 static WERROR smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
+static sbcErr smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
                                                 struct registry_key *key,
                                                 uint32_t *num_includes,
 …
+{
         WERROR werr;
+        sbcErr err;
         uint32_t count;
         struct registry_value *value = NULL;
         char **tmp_includes = NULL;
+        const char **array = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
 …
                 *num_includes = 0;
                 *includes = NULL;
                 werr = WERR_OK;
+                err = SBC_ERR_OK;
                 goto done;
+        }
 …
         werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
         if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_ACCESS_DENIED;
                 goto done;
+        }
 …
         if (value->type != REG_MULTI_SZ) {
                 /* wrong type -- ignore */
+                goto done;
+        }
+        for (count = 0; count < value->v.multi_sz.num_strings; count++)
+        {
+                werr = smbconf_add_string_to_array(tmp_ctx,
+                err = SBC_ERR_OK;
+                goto done;
+        }
+        if (!pull_reg_multi_sz(tmp_ctx, &value->data, &array)) {
+                err = SBC_ERR_NOMEM;
+                goto done;
+        }
+        for (count = 0; array[count] != NULL; count++) {
+                err = smbconf_add_string_to_array(tmp_ctx,
                                         &tmp_includes,
                                         count,
                                         value->v.multi_sz.strings[count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                                        array[count]);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
                 *includes = talloc_move(mem_ctx, &tmp_includes);
                 if (*includes == NULL) {
                         werr = WERR_NOMEM;
+                        err = SBC_ERR_NOMEM;
                         goto done;
+                }
 …
+        }
+        err = SBC_ERR_OK;
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
  * and a list of value strings (ordered)
  */
 static WERROR smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
+static sbcErr smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
                                      struct registry_key *key,
                                      uint32_t *num_values,
 …
         TALLOC_CTX *tmp_ctx = NULL;
         WERROR werr = WERR_OK;
+        sbcErr err;
         uint32_t count;
         struct registry_value *valvalue = NULL;
 …
             (value_strings == NULL))
+        {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
+                }
                 werr = smbconf_add_string_to_array(tmp_ctx,
                                                    &tmp_valnames,
                                                    tmp_num_values, valname);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_add_string_to_array(tmp_ctx,
+                                                  &tmp_valnames,
+                                                  tmp_num_values, valname);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
                 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
                                                    tmp_num_values, valstring);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
+                                                  tmp_num_values, valstring);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
+        }
         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
         /* now add the includes at the end */
         werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
+        err = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
                                                  &includes);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        if (!SBC_ERROR_IS_OK(err)) {
+                goto done;
+        }
         for (count = 0; count < num_includes; count++) {
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
                                                    tmp_num_values, "include");
                 if (!W_ERROR_IS_OK(werr)) {
                         goto done;
+                }
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
                                                    tmp_num_values,
                                                    includes[count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
+                                                  tmp_num_values, "include");
+                if (!SBC_ERROR_IS_OK(err)) {
+                        goto done;
+                }
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
+                                                  tmp_num_values,
+                                                  includes[count]);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
  * delete all values from a key
  */
+static WERROR smbconf_reg_delete_values(struct registry_key *key)
+{
+        WERROR werr;
+static sbcErr smbconf_reg_delete_values(struct registry_key *key)
+{
+        WERROR werr;
+        sbcErr err;
         char *valname;
         struct registry_value *valvalue;
 …
                 werr = reg_deletevalue(key, valname);
                 if (!W_ERROR_IS_OK(werr)) {
+                        err = SBC_ERR_ACCESS_DENIED;
                         goto done;
+                }
 …
                           key->key->name,
                           win_errstr(werr)));
+                goto done;
+        }
+        werr = WERR_OK;
+                err = SBC_ERR_ACCESS_DENIED;
+                goto done;
+        }
+        err = SBC_ERR_OK;
 done:
         talloc_free(mem_ctx);
         return werr;
+        return err;
+}
 …
  * initialize the registry smbconf backend
  */
 static WERROR smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
+static sbcErr smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
+{
         WERROR werr = WERR_OK;
+        struct nt_user_token *token;
+        sbcErr err;
+        struct security_token *token;
         if (path == NULL) {
 …
         ctx->path = talloc_strdup(ctx, path);
         if (ctx->path == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
 …
         if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(1, ("Error creating admin token\n"));
+                err = SBC_ERR_UNKNOWN_FAILURE;
                 goto done;
+        }
 …
         werr = registry_init_smbconf(path);
         if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+        werr = ctx->ops->open_conf(ctx);
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_BADFILE;
+                goto done;
+        }
+        err = ctx->ops->open_conf(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 DEBUG(1, ("Error opening the registry.\n"));
                 goto done;
 …
                              token, &rpd(ctx)->base_key);
         if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+done:
+        return werr;
+                err = SBC_ERR_UNKNOWN_FAILURE;
+                goto done;
+        }
+done:
+        return err;
+}
 …
+}
 static WERROR smbconf_reg_open(struct smbconf_ctx *ctx)
+static sbcErr smbconf_reg_open(struct smbconf_ctx *ctx)
+{
         WERROR werr;
         if (rpd(ctx)->open) {
                 return WERR_OK;
+                return SBC_ERR_OK;
+        }
         werr = regdb_open();
+        if (W_ERROR_IS_OK(werr)) {
+                rpd(ctx)->open = true;
+        }
+        return werr;
+        if (!W_ERROR_IS_OK(werr)) {
+                return SBC_ERR_BADFILE;
+        }
+        rpd(ctx)->open = true;
+        return SBC_ERR_OK;
+}
 …
+        }
         if (!W_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
+        if (!SBC_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
                 return;
+        }
 …
  * Drop the whole configuration (restarting empty) - registry version
  */
 static WERROR smbconf_reg_drop(struct smbconf_ctx *ctx)
+static sbcErr smbconf_reg_drop(struct smbconf_ctx *ctx)
+{
         char *path, *p;
         WERROR werr = WERR_OK;
+        sbcErr err = SBC_ERR_OK;
         struct registry_key *parent_key = NULL;
         struct registry_key *new_key = NULL;
         TALLOC_CTX* mem_ctx = talloc_stackframe();
         enum winreg_CreateAction action;
         struct nt_user_token *token;
+        struct security_token *token;
         werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
         if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(1, ("Error creating admin token\n"));
+                err = SBC_ERR_UNKNOWN_FAILURE;
                 goto done;
+        }
 …
         path = talloc_strdup(mem_ctx, ctx->path);
         if (path == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
         p = strrchr(path, '\\');
+        if (p == NULL) {
+                err = SBC_ERR_INVALID_PARAM;
+                goto done;
+        }
         *p = '\0';
         werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
                              &parent_key);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
         if (!W_ERROR_IS_OK(werr)) {
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_IO_FAILURE;
+                goto done;
+        }
+        werr = reg_deletekey_recursive(parent_key, p+1);
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_IO_FAILURE;
                 goto done;
+        }
 …
         werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
                              &new_key, &action);
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_IO_FAILURE;
+                goto done;
+        }
 done:
         talloc_free(mem_ctx);
         return werr;
+        return err;
+}
 …
  * registry version.
  */
 static WERROR smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
                                           TALLOC_CTX *mem_ctx,
                                           uint32_t *num_shares,
 …
         uint32_t added_count = 0;
         TALLOC_CTX *tmp_ctx = NULL;
+        WERROR werr = WERR_OK;
+        WERROR werr;
+        sbcErr err = SBC_ERR_OK;
         char *subkey_name = NULL;
         char **tmp_share_names = NULL;
         if ((num_shares == NULL) || (share_names == NULL)) {
+                werr = WERR_INVALID_PARAM;
+                goto done;
+                return SBC_ERR_INVALID_PARAM;
+        }
 …
         if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
 , NULL);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
         /* make sure "global" is always listed first */
         if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
                                                    added_count, GLOBAL_NAME);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+                                                  added_count, GLOBAL_NAME);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
+                }
                 werr = smbconf_add_string_to_array(tmp_ctx,
+                err = smbconf_add_string_to_array(tmp_ctx,
                                                    &tmp_share_names,
                                                    added_count,
                                                    subkey_name);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
+        }
         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+                goto done;
+        }
+        werr = WERR_OK;
+                err = SBC_ERR_NO_MORE_ITEMS;
+                goto done;
+        }
+        err = SBC_ERR_OK;
         *num_shares = added_count;
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
+{
         bool ret = false;
         WERROR werr = WERR_OK;
+        sbcErr err;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
         struct registry_key *key = NULL;
         werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
                                             REG_KEY_READ, &key);
         if (W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
+                                           REG_KEY_READ, &key);
+        if (SBC_ERROR_IS_OK(err)) {
                 ret = true;
+        }
 …
  * Add a service if it does not already exist - registry version
  */
 static WERROR smbconf_reg_create_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_create_share(struct smbconf_ctx *ctx,
                                        const char *servicename)
+{
         WERROR werr;
+        sbcErr err;
         struct registry_key *key = NULL;
         if (servicename == NULL) {
                 return WERR_OK;
+        }
         werr = smbconf_reg_create_service_key(talloc_tos(), ctx,
                                               servicename, &key);
+                return SBC_ERR_OK;
+        }
+        err = smbconf_reg_create_service_key(talloc_tos(), ctx,
+                                             servicename, &key);
         talloc_free(key);
         return werr;
+        return err;
+}
 …
  * get a definition of a share (service) from configuration.
  */
 static WERROR smbconf_reg_get_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_get_share(struct smbconf_ctx *ctx,
                                     TALLOC_CTX *mem_ctx,
                                     const char *servicename,
                                     struct smbconf_service **service)
+{
         WERROR werr = WERR_OK;
+        sbcErr err;
         struct registry_key *key = NULL;
         struct smbconf_service *tmp_service = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
                                             REG_KEY_READ, &key);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
+                                           REG_KEY_READ, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
 …
         tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
         if (tmp_service == NULL) {
                 werr =  WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
 …
                 tmp_service->name = talloc_strdup(tmp_service, servicename);
                 if (tmp_service->name == NULL) {
+                        werr = WERR_NOMEM;
+                        goto done;
+                }
+        }
+        werr = smbconf_reg_get_values(tmp_service, key,
+                                      &(tmp_service->num_params),
+                                      &(tmp_service->param_names),
+                                      &(tmp_service->param_values));
+        if (W_ERROR_IS_OK(werr)) {
+                        err = SBC_ERR_NOMEM;
+                        goto done;
+                }
+        }
+        err = smbconf_reg_get_values(tmp_service, key,
+                                     &(tmp_service->num_params),
+                                     &(tmp_service->param_names),
+                                     &(tmp_service->param_values));
+        if (SBC_ERROR_IS_OK(err)) {
                 *service = talloc_move(mem_ctx, &tmp_service);
+        }
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
  * delete a service from configuration
  */
 static WERROR smbconf_reg_delete_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_delete_share(struct smbconf_ctx *ctx,
                                        const char *servicename)
+{
+        WERROR werr = WERR_OK;
+        WERROR werr;
+        sbcErr err = SBC_ERR_OK;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
         if (servicename != NULL) {
+                werr = reg_deletekey_recursive(mem_ctx, rpd(ctx)->base_key,
+                                               servicename);
+                werr = reg_deletekey_recursive(rpd(ctx)->base_key, servicename);
+                if (!W_ERROR_IS_OK(werr)) {
+                        err = SBC_ERR_ACCESS_DENIED;
+                }
         } else {
                 werr = smbconf_reg_delete_values(rpd(ctx)->base_key);
+                err = smbconf_reg_delete_values(rpd(ctx)->base_key);
+        }
         talloc_free(mem_ctx);
         return werr;
+        return err;
+}
 …
  * set a configuration parameter to the value provided.
  */
 static WERROR smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
                                         const char *service,
                                         const char *param,
                                         const char *valstr)
+{
         WERROR werr;
+        sbcErr err;
         struct registry_key *key = NULL;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
                                             REG_KEY_WRITE, &key);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         werr = smbconf_reg_set_value(key, param, valstr);
+        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
+                                           REG_KEY_WRITE, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
+                goto done;
+        }
+        err = smbconf_reg_set_value(key, param, valstr);
 done:
         talloc_free(mem_ctx);
         return werr;
+        return err;
+}
 …
  * get the value of a configuration parameter as a string
  */
 static WERROR smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
                                         TALLOC_CTX *mem_ctx,
                                         const char *service,
 …
+{
         WERROR werr = WERR_OK;
+        sbcErr err;
         struct registry_key *key = NULL;
         struct registry_value *value = NULL;
         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
                                             REG_KEY_READ, &key);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
+                                           REG_KEY_READ, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
         if (!smbconf_reg_valname_valid(param)) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
         if (!smbconf_value_exists(key, param)) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
         werr = reg_queryvalue(mem_ctx, key, param, &value);
         if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
         *valstr = smbconf_format_registry_value(mem_ctx, value);
         if (*valstr == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
+        }
 …
         talloc_free(key);
         talloc_free(value);
         return werr;
+        return err;
+}
 …
  * delete a parameter from configuration
  */
 static WERROR smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
                                            const char *service,
                                            const char *param)
+{
         struct registry_key *key = NULL;
+        WERROR werr = WERR_OK;
+        WERROR werr;
+        sbcErr err;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
                                             REG_KEY_ALL, &key);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
+                                           REG_KEY_ALL, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
         if (!smbconf_reg_valname_valid(param)) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
         if (!smbconf_value_exists(key, param)) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_OK;
                 goto done;
+        }
         werr = reg_deletevalue(key, param);
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_ACCESS_DENIED;
+        }
 done:
         talloc_free(mem_ctx);
         return werr;
+}
 static WERROR smbconf_reg_get_includes(struct smbconf_ctx *ctx,
+        return err;
+}
+static sbcErr smbconf_reg_get_includes(struct smbconf_ctx *ctx,
                                        TALLOC_CTX *mem_ctx,
                                        const char *service,
 …
                                        char ***includes)
+{
         WERROR werr;
+        sbcErr err;
         struct registry_key *key = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
                                             REG_KEY_READ, &key);
         if (!W_ERROR_IS_OK(werr)) {
                 goto done;
+        }
         werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
+        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+                                           REG_KEY_READ, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
+                goto done;
+        }
+        err = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
                                                  includes);
+        if (!SBC_ERROR_IS_OK(err)) {
+                goto done;
+        }
 done:
         talloc_free(tmp_ctx);
         return werr;
+}
 static WERROR smbconf_reg_set_includes(struct smbconf_ctx *ctx,
+        return err;
+}
+static sbcErr smbconf_reg_set_includes(struct smbconf_ctx *ctx,
                                        const char *service,
                                        uint32_t num_includes,
 …
+{
         WERROR werr = WERR_OK;
+        sbcErr err;
         struct registry_key *key = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
                                             REG_KEY_ALL, &key);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+                                           REG_KEY_ALL, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
 …
         if (num_includes == 0) {
                 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
+                        err = SBC_ERR_OK;
                         goto done;
+                }
                 werr = reg_deletevalue(key, INCLUDES_VALNAME);
+                if (!W_ERROR_IS_OK(werr)) {
+                        err = SBC_ERR_ACCESS_DENIED;
+                        goto done;
+                }
         } else {
                 werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
+                err = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
                                                       num_includes, includes);
+        }
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+}
 static WERROR smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
+        return err;
+}
+static sbcErr smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
                                           const char *service)
+{
+        WERROR werr = WERR_OK;
+        WERROR werr;
+        sbcErr err;
         struct registry_key *key = NULL;
         TALLOC_CTX *tmp_ctx = talloc_stackframe();
         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
                                             REG_KEY_ALL, &key);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+                                           REG_KEY_ALL, &key);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
         if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
+                err = SBC_ERR_OK;
                 goto done;
+        }
         werr = reg_deletevalue(key, INCLUDES_VALNAME);
+        if (!W_ERROR_IS_OK(werr)) {
+                err = SBC_ERR_ACCESS_DENIED;
+                goto done;
+        }
+        err = SBC_ERR_OK;
 done:
         talloc_free(tmp_ctx);
+        return werr;
+}
+static WERROR smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
+{
+        return regdb_transaction_start();
+}
+static WERROR smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
+{
+        return regdb_transaction_commit();
+}
+static WERROR smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
+{
+        return regdb_transaction_cancel();
+        return err;
+}
+static sbcErr smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
+{
+        WERROR werr;
+        werr = regdb_transaction_start();
+        if (!W_ERROR_IS_OK(werr)) {
+                return SBC_ERR_IO_FAILURE;
+        }
+        return SBC_ERR_OK;
+}
+static sbcErr smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
+{
+        WERROR werr;
+        werr = regdb_transaction_commit();
+        if (!W_ERROR_IS_OK(werr)) {
+                return SBC_ERR_IO_FAILURE;
+        }
+        return SBC_ERR_OK;
+}
+static sbcErr smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
+{
+        WERROR werr;
+        werr = regdb_transaction_cancel();
+        if (!W_ERROR_IS_OK(werr)) {
+                return SBC_ERR_IO_FAILURE;
+        }
+        return SBC_ERR_OK;
+}
 …
  * the only function that is exported from this module
  */
 WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
+sbcErr smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
                         const char *path)
+{

trunk/server/source3/lib/smbconf/smbconf_reg.h

r414	r745
27	27	*/
28	28
29		~~WERROR~~ smbconf_init_reg(TALLOC_CTX mem_ctx, struct smbconf_ctx *conf_ctx,
	29	sbcErr smbconf_init_reg(TALLOC_CTX mem_ctx, struct smbconf_ctx *conf_ctx,
30	30	const char *path);
31	31

trunk/server/source3/lib/smbconf/testsuite.c

-              r414
+              r745
 #include "includes.h"
+#include "popt_common.h"
+#include "lib/smbconf/smbconf.h"
+#include "lib/smbconf/smbconf_init.h"
+#include "lib/smbconf/smbconf_reg.h"
+#include "lib/smbconf/smbconf_txt.h"
 static void print_strings(const char *prefix,
 …
 static bool test_get_includes(struct smbconf_ctx *ctx)
+{
         WERROR werr;
+        sbcErr err;
         bool ret = false;
         uint32_t num_includes = 0;
 …
         printf("TEST: get_includes\n");
         werr = smbconf_get_global_includes(ctx, mem_ctx,
                                            &num_includes, &includes);
         if (!W_ERROR_IS_OK(werr)) {
                 printf("FAIL: get_includes - %s\n", win_errstr(werr));
+        err = smbconf_get_global_includes(ctx, mem_ctx,
+                                          &num_includes, &includes);
+        if (!SBC_ERROR_IS_OK(err)) {
+                printf("FAIL: get_includes - %s\n", sbcErrorString(err));
                 goto done;
+        }
 …
 static bool test_set_get_includes(struct smbconf_ctx *ctx)
+{
         WERROR werr;
+        sbcErr err;
         uint32_t count;
         bool ret = false;
 …
         printf("TEST: set_get_includes\n");
         werr = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: get_set_includes (setting includes) - %s\n",
                        win_errstr(werr));
                 goto done;
+        }
         werr = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
                                            &get_includes);
         if (!W_ERROR_IS_OK(werr)) {
+                       sbcErrorString(err));
+                goto done;
+        }
+        err = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
+                                          &get_includes);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: get_set_includes (getting includes) - %s\n",
                        win_errstr(werr));
+                       sbcErrorString(err));
                 goto done;
+        }
 …
 static bool test_delete_includes(struct smbconf_ctx *ctx)
+{
         WERROR werr;
+        sbcErr err;
         bool ret = false;
         const char *set_includes[] = {
 …
         printf("TEST: delete_includes\n");
         werr = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: delete_includes (setting includes) - %s\n",
                        win_errstr(werr));
                 goto done;
+        }
         werr = smbconf_delete_global_includes(ctx);
         if (!W_ERROR_IS_OK(werr)) {
+                       sbcErrorString(err));
+                goto done;
+        }
+        err = smbconf_delete_global_includes(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: delete_includes (deleting includes) - %s\n",
                        win_errstr(werr));
                 goto done;
+        }
         werr = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
                                            &get_includes);
         if (!W_ERROR_IS_OK(werr)) {
+                       sbcErrorString(err));
+                goto done;
+        }
+        err = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
+                                          &get_includes);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: delete_includes (getting includes) - %s\n",
                        win_errstr(werr));
+                       sbcErrorString(err));
                 goto done;
+        }
 …
+        }
         werr = smbconf_delete_global_includes(ctx);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_delete_global_includes(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 printf("FAIL: delete_includes (delete empty includes) - "
                        "%s\n", win_errstr(werr));
+                       "%s\n", sbcErrorString(err));
                 goto done;
+        }
 …
 static bool torture_smbconf_txt(void)
+{
         WERROR werr;
+        sbcErr err;
         bool ret = true;
         const char *filename = "/tmp/smb.conf.smbconf_testsuite";
 …
         printf("TEST: init\n");
         werr = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
         if (!W_ERROR_IS_OK(werr)) {
                 printf("FAIL: text backend failed: %s\n", win_errstr(werr));
+        err = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
+        if (!SBC_ERROR_IS_OK(err)) {
+                printf("FAIL: text backend failed: %s\n", sbcErrorString(err));
                 ret = false;
                 goto done;
 …
 static bool torture_smbconf_reg(void)
+{
         WERROR werr;
+        sbcErr err;
         bool ret = true;
         struct smbconf_ctx *conf_ctx = NULL;
 …
         printf("TEST: init\n");
         werr = smbconf_init_reg(mem_ctx, &conf_ctx, NULL);
         if (!W_ERROR_IS_OK(werr)) {
                 printf("FAIL: init failed: %s\n", win_errstr(werr));
+        err = smbconf_init_reg(mem_ctx, &conf_ctx, NULL);
+        if (!SBC_ERROR_IS_OK(err)) {
+                printf("FAIL: init failed: %s\n", sbcErrorString(err));
                 ret = false;
                 goto done;
 …
         load_case_tables();
         dbf = x_stderr;
+        setup_logging(argv[0], DEBUG_STDERR);
         /* parse options */

trunk/server/source3/lib/smbldap.c

-              r620
+              r745
 #include "includes.h"
 #include "smbldap.h"
+#ifndef LDAP_OPT_SUCCESS
+#define LDAP_OPT_SUCCESS 0
+#endif
+#include "secrets.h"
+#include "../libcli/security/security.h"
 /* Try not to hit the up or down server forever */
 …
  ***********************************************************************/
  void smbldap_set_mod (LDAPMod *** modlist, int modop, const char *attribute, const char *value)
+static void smbldap_set_mod_internal(LDAPMod *** modlist, int modop, const char *attribute, const char *value, const DATA_BLOB *blob)
+{
         LDAPMod **mods;
 …
+        }
+        if (value != NULL) {
+        if (blob && (modop & LDAP_MOD_BVALUES)) {
+                j = 0;
+                if (mods[i]->mod_bvalues != NULL) {
+                        for (; mods[i]->mod_bvalues[j] != NULL; j++);
+                }
+                mods[i]->mod_bvalues = SMB_REALLOC_ARRAY(mods[i]->mod_bvalues, struct berval *, j + 2);
+                if (mods[i]->mod_bvalues == NULL) {
+                        smb_panic("smbldap_set_mod: out of memory!");
+                        /* notreached. */
+                }
+                mods[i]->mod_bvalues[j] = SMB_MALLOC_P(struct berval);
+                SMB_ASSERT(mods[i]->mod_bvalues[j] != NULL);
+                mods[i]->mod_bvalues[j]->bv_val = (char *)memdup(blob->data, blob->length);
+                SMB_ASSERT(mods[i]->mod_bvalues[j]->bv_val != NULL);
+                mods[i]->mod_bvalues[j]->bv_len = blob->length;
+                mods[i]->mod_bvalues[j + 1] = NULL;
+        } else if (value != NULL) {
                 char *utf8_value = NULL;
                 size_t converted_size;
 …
+        }
         *modlist = mods;
+}
+ void smbldap_set_mod (LDAPMod *** modlist, int modop, const char *attribute, const char *value)
+{
+        smbldap_set_mod_internal(modlist, modop, attribute, value, NULL);
+}
+ void smbldap_set_mod_blob(LDAPMod *** modlist, int modop, const char *attribute, const DATA_BLOB *value)
+{
+        smbldap_set_mod_internal(modlist, modop | LDAP_MOD_BVALUES, attribute, NULL, value);
+}
 …
 *********************************************************************/
+ void smbldap_make_mod(LDAP *ldap_struct, LDAPMessage *existing,
+                      LDAPMod ***mods,
+                      const char *attribute, const char *newval)
+static void smbldap_make_mod_internal(LDAP *ldap_struct, LDAPMessage *existing,
+                                      LDAPMod ***mods,
+                                      const char *attribute, int op,
+                                      const char *newval,
+                                      const DATA_BLOB *newblob)
+{
         char oldval[2048]; /* current largest allowed value is mungeddial */
         bool existed;
+        DATA_BLOB oldblob = data_blob_null;
         if (attribute == NULL) {
 …
         if (existing != NULL) {
+                existed = smbldap_get_single_attribute(ldap_struct, existing, attribute, oldval, sizeof(oldval));
+                if (op & LDAP_MOD_BVALUES) {
+                        existed = smbldap_talloc_single_blob(talloc_tos(), ldap_struct, existing, attribute, &oldblob);
+                } else {
+                        existed = smbldap_get_single_attribute(ldap_struct, existing, attribute, oldval, sizeof(oldval));
+                }
         } else {
                 existed = False;
 …
+        }
-        /* all of our string attributes are case insensitive */
-        if (existed && newval && (StrCaseCmp(oldval, newval) == 0)) {
-                /* Believe it or not, but LDAP will deny a delete and
-                   an add at the same time if the values are the
-                   same... */
-                DEBUG(10,("smbldap_make_mod: attribute |%s| not changed.\n", attribute));
-                return;
+        }
         if (existed) {
+                bool equal = false;
+                if (op & LDAP_MOD_BVALUES) {
+                        equal = (newblob && (data_blob_cmp(&oldblob, newblob) == 0));
+                } else {
+                        /* all of our string attributes are case insensitive */
+                        equal = (newval && (StrCaseCmp(oldval, newval) == 0));
+                }
+                if (equal) {
+                        /* Believe it or not, but LDAP will deny a delete and
+                           an add at the same time if the values are the
+                           same... */
+                        DEBUG(10,("smbldap_make_mod: attribute |%s| not changed.\n", attribute));
+                        return;
+                }
                 /* There has been no value before, so don't delete it.
                  * Here's a possible race: We might end up with
 …
                  * you could add new value */
+                DEBUG(10,("smbldap_make_mod: deleting attribute |%s| values |%s|\n", attribute, oldval));
+                smbldap_set_mod(mods, LDAP_MOD_DELETE, attribute, oldval);
+                if (op & LDAP_MOD_BVALUES) {
+                        DEBUG(10,("smbldap_make_mod: deleting attribute |%s| blob\n", attribute));
+                        smbldap_set_mod_blob(mods, LDAP_MOD_DELETE, attribute, &oldblob);
+                } else {
+                        DEBUG(10,("smbldap_make_mod: deleting attribute |%s| values |%s|\n", attribute, oldval));
+                        smbldap_set_mod(mods, LDAP_MOD_DELETE, attribute, oldval);
+                }
+        }
 …
            the old value, should it exist. */
+        if ((newval != NULL) && (strlen(newval) > 0)) {
+                DEBUG(10,("smbldap_make_mod: adding attribute |%s| value |%s|\n", attribute, newval));
+                smbldap_set_mod(mods, LDAP_MOD_ADD, attribute, newval);
+        }
+        if (op & LDAP_MOD_BVALUES) {
+                if (newblob && newblob->length) {
+                        DEBUG(10,("smbldap_make_mod: adding attribute |%s| blob\n", attribute));
+                        smbldap_set_mod_blob(mods, LDAP_MOD_ADD, attribute, newblob);
+                }
+        } else {
+                if ((newval != NULL) && (strlen(newval) > 0)) {
+                        DEBUG(10,("smbldap_make_mod: adding attribute |%s| value |%s|\n", attribute, newval));
+                        smbldap_set_mod(mods, LDAP_MOD_ADD, attribute, newval);
+                }
+        }
+}
+ void smbldap_make_mod(LDAP *ldap_struct, LDAPMessage *existing,
+                      LDAPMod ***mods,
+                      const char *attribute, const char *newval)
+{
+        smbldap_make_mod_internal(ldap_struct, existing, mods, attribute,
+, newval, NULL);
+}
+ void smbldap_make_mod_blob(LDAP *ldap_struct, LDAPMessage *existing,
+                            LDAPMod ***mods,
+                            const char *attribute, const DATA_BLOB *newblob)
+{
+        smbldap_make_mod_internal(ldap_struct, existing, mods, attribute,
+                                  LDAP_MOD_BVALUES, NULL, newblob);
+}
 …
 *******************************************************************/
 int smb_ldap_setup_conn(LDAP **ldap_struct, const char *uri)
+static int smb_ldap_setup_conn(LDAP **ldap_struct, const char *uri)
+{
         int rc;
 …
  *******************************************************************/
+int smb_ldap_upgrade_conn(LDAP *ldap_struct, int *new_version)
+static int smb_ldap_upgrade_conn(LDAP *ldap_struct, int *new_version)
+{
         int version;
 …
+{
         struct smbldap_state *ldap_state = arg;
+        struct timespec ts;
         /** @TODO Should we be doing something to check what servers we rebind to?
 …
+        }
+        GetTimeOfDay(&ldap_state->last_rebind);
+        clock_gettime_mono(&ts);
+        ldap_state->last_rebind = convert_timespec_to_timeval(ts);
         return 0;
 …
                 (struct smbldap_state *)arg;
         int rc;
+        struct timespec ts;
         int version;
 …
                                 "setting last_rebind timestamp "
                                 "(req: 0x%02x)\n", (unsigned int)request));
+                        GetTimeOfDay(&ldap_state->last_rebind);
+                        clock_gettime_mono(&ts);
+                        ldap_state->last_rebind = convert_timespec_to_timeval(ts);
                         break;
                 default:
 …
 static void smbldap_idle_fn(struct event_context *event_ctx,
                             struct timed_event *te,
                             struct timeval now,
+                            struct timeval now_abs,
                             void *private_data);
 …
         SMB_ASSERT(ldap_state);
         if ((ldap_state->ldap_struct != NULL) && ((ldap_state->last_ping + SMBLDAP_DONT_PING_TIME) < time(NULL))) {
+        if ((ldap_state->ldap_struct != NULL) && ((ldap_state->last_ping + SMBLDAP_DONT_PING_TIME) < time_mono(NULL))) {
 #ifdef HAVE_UNIXSOCKET
 …
                         ldap_state->last_ping = (time_t)0;
                 } else {
                         ldap_state->last_ping = time(NULL);
+                        ldap_state->last_ping = time_mono(NULL);
+                }
+        }
 …
         ldap_state->last_ping = time(NULL);
+        ldap_state->last_ping = time_mono(NULL);
         ldap_state->pid = sys_getpid();
 …
                             int *attempts, time_t endtime)
+{
         time_t now = time(NULL);
+        time_t now = time_mono(NULL);
         int open_rc = LDAP_SERVER_DOWN;
 …
         int             attempts = 0;
         char           *utf8_filter;
         time_t          endtime = time(NULL)+lp_ldap_timeout();
+        time_t          endtime = time_mono(NULL)+lp_ldap_timeout();
         struct          timeval timeout;
         size_t          converted_size;
 …
         if (ldap_state->last_rebind.tv_sec > 0) {
                 struct timeval  tval;
+                struct timespec ts;
                 int64_t tdiff = 0;
                 int             sleep_time = 0;
                 ZERO_STRUCT(tval);
                 GetTimeOfDay(&tval);
+                clock_gettime_mono(&ts);
+                tval = convert_timespec_to_timeval(ts);
                 tdiff = usec_time_diff(&tval, &ldap_state->last_rebind);
 …
         got_alarm = 0;
         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
+        CatchSignal(SIGALRM, gotalarm_sig);
         alarm(lp_ldap_timeout());
         /* End setup timeout. */
 …
         /* Teardown timeout. */
         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
+        CatchSignal(SIGALRM, SIG_IGN);
         alarm(0);
 …
         int             attempts = 0;
         char           *utf8_dn;
         time_t          endtime = time(NULL)+lp_ldap_timeout();
+        time_t          endtime = time_mono(NULL)+lp_ldap_timeout();
         size_t          converted_size;
 …
         int             attempts = 0;
         char           *utf8_dn;
         time_t          endtime = time(NULL)+lp_ldap_timeout();
+        time_t          endtime = time_mono(NULL)+lp_ldap_timeout();
         size_t          converted_size;
 …
         int             attempts = 0;
         char           *utf8_dn;
         time_t          endtime = time(NULL)+lp_ldap_timeout();
+        time_t          endtime = time_mono(NULL)+lp_ldap_timeout();
         size_t          converted_size;
 …
         int             rc = LDAP_SERVER_DOWN;
         int             attempts = 0;
         time_t          endtime = time(NULL)+lp_ldap_timeout();
+        time_t          endtime = time_mono(NULL)+lp_ldap_timeout();
         if (!ldap_state)
 …
 static void smbldap_idle_fn(struct event_context *event_ctx,
                             struct timed_event *te,
                             struct timeval now,
+                            struct timeval now_abs,
                             void *private_data)
+{
 …
+        }
         if ((state->last_use+SMBLDAP_IDLE_TIME) > now.tv_sec) {
+        if ((state->last_use+SMBLDAP_IDLE_TIME) > time_mono(NULL)) {
                 DEBUG(10,("ldap connection not idle...\n"));
+                /* this needs to be made monotonic clock aware inside tevent: */
                 state->idle_event = event_add_timed(
                         event_ctx, state,
                         timeval_add(&now, SMBLDAP_IDLE_TIME, 0),
+                        timeval_add(&now_abs, SMBLDAP_IDLE_TIME, 0),
                         smbldap_idle_fn,
                         private_data);

trunk/server/source3/lib/smbldap_util.c

r414	r745
25	25	#include "includes.h"
26	26	#include "smbldap.h"
	27	#include "passdb.h"
27	28
28	29	/**********************************************************************

trunk/server/source3/lib/substitute.c

-              r414
+              r745
    Copyright (C) Andrew Tridgell 1992-2000
    Copyright (C) Gerald Carter   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/>.
 …
 #include "includes.h"
+#include "system/passwd.h"
+#include "secrets.h"
+#include "auth.h"
+static char *alloc_sub_basic(const char *smb_name, const char *domain_name,
+                             const char *str);
 userdom_struct current_user_info;
 …
         static bool already_perm = false;
         char *tmp_local_machine = NULL;
-        char addr[INET6_ADDRSTRLEN];
         size_t len;
+        if (already_perm) {
+                return true;
+        }
         tmp_local_machine = SMB_STRDUP(local_name);
 …
+        }
         trim_char(tmp_local_machine,' ',' ');
-        /*
-         * Windows NT/2k uses "*SMBSERVER" and XP uses "*SMBSERV"
-         * arrggg!!!
-         */
-        if (strequal(tmp_local_machine, "*SMBSERVER") ||
-                        strequal(tmp_local_machine, "*SMBSERV") )  {
-                SAFE_FREE(local_machine);
-                local_machine = SMB_STRDUP(client_socket_addr(get_client_fd(),
-                                        addr, sizeof(addr)) );
-                SAFE_FREE(tmp_local_machine);
-                return local_machine ? true : false;
+        }
-        if (already_perm) {
-                return true;
+        }
         SAFE_FREE(local_machine);
 …
                 smb_user_name[len-1] = '$';
+        }
+}
+static char sub_peeraddr[INET6_ADDRSTRLEN];
+static const char *sub_peername = "";
+static char sub_sockaddr[INET6_ADDRSTRLEN];
+void sub_set_socket_ids(const char *peeraddr, const char *peername,
+                        const char *sockaddr)
+{
+        const char *addr = peeraddr;
+        if (strnequal(addr, "::ffff:", 7)) {
+                addr += 7;
+        }
+        strlcpy(sub_peeraddr, addr, sizeof(sub_peeraddr));
+        sub_peername = SMB_STRDUP(peername);
+        if (sub_peername == NULL) {
+                sub_peername = sub_peeraddr;
+        }
+        /*
+         * Shouldn't we do the ::ffff: cancellation here as well? The
+         * original code in alloc_sub_basic() did not do it, so I'm
+         * leaving it out here as well for compatibility.
+         */
+        strlcpy(sub_sockaddr, sockaddr, sizeof(sub_sockaddr));
+}
 …
         r = p + 3;
         copylen = q - r;
         /* reserve space for use later add %$() chars */
         if ( (envname = (char *)SMB_MALLOC(copylen + 1 + 4)) == NULL ) {
                 return NULL;
+        }
         strncpy(envname,r,copylen);
         envname[copylen] = '\0';
 …
         r = realloc_string_sub(str, envname, envval);
         SAFE_FREE(envname);
         return r;
+}
 …
 static char *longvar_domainsid( void )
+{
         DOM_SID sid;
+        struct dom_sid sid;
         fstring tmp;
         char *sid_string;
         if ( !secrets_fetch_domain_sid( lp_workgroup(), &sid ) ) {
                 return NULL;
+        }
         sid_string = SMB_STRDUP( sid_to_fstring( tmp, &sid ) );
         if ( !sid_string ) {
                 DEBUG(0,("longvar_domainsid: failed to dup SID string!\n"));
+        }
         return sid_string;
+}
 …
+{
         int i;
         DEBUG(7,("get_longvar_val: expanding variable [%s]\n", varname));
         for ( i=0; longvar_table[i].name; i++ ) {
                 if ( strequal( longvar_table[i].name, varname ) ) {
 …
+                }
+        }
         return NULL;
+}
 …
+{
         char *s;
         if ( (s = alloc_sub_basic( smb_name, domain_name, str )) != NULL ) {
                 strncpy( str, s, len );
+        }
         SAFE_FREE( s );
+}
 …
+{
         char *a, *t;
         if ( (a = alloc_sub_basic(smb_name, domain_name, str)) == NULL ) {
                 return NULL;
 …
 ****************************************************************************/
 char *alloc_sub_basic(const char *smb_name, const char *domain_name,
                       const char *str)
+static char *alloc_sub_basic(const char *smb_name, const char *domain_name,
+                             const char *str)
+{
         char *b, *p, *s, *r, *a_string;
         fstring pidstr, vnnstr;
-        char addr[INET6_ADDRSTRLEN];
         const char *local_machine_name = get_local_machine_name();
         TALLOC_CTX *tmp_ctx = NULL;
         /* workaround to prevent a crash while looking at bug #687 */
         if (!str) {
                 DEBUG(0,("alloc_sub_basic: NULL source string!  This should not happen\n"));
                 return NULL;
+        }
         a_string = SMB_STRDUP(str);
         if (a_string == NULL) {
 …
                         break;
                 case 'I' : {
+                        int offset = 0;
+                        client_addr(get_client_fd(), addr, sizeof(addr));
+                        if (strnequal(addr,"::ffff:",7)) {
+                                offset = 7;
+                        }
+                        a_string = realloc_string_sub(a_string, "%I",
+                                                      addr + offset);
+                        a_string = realloc_string_sub(
+                                a_string, "%I",
+                                sub_peeraddr[0] ? sub_peeraddr : "0.0.0.0");
                         break;
+                }
                 case 'i':
+                        a_string = realloc_string_sub( a_string, "%i",
+                                        client_socket_addr(get_client_fd(), addr, sizeof(addr)) );
+                        a_string = realloc_string_sub(
+                                a_string, "%i",
+                                sub_sockaddr[0] ? sub_sockaddr : "0.0.0.0");
                         break;
                 case 'L' :
 …
                         break;
                 case 'M' :
+                        a_string = realloc_string_sub(a_string, "%M", client_name(get_client_fd()));
+                        a_string = realloc_string_sub(a_string, "%M",
+                                                      sub_peername);
                         break;
                 case 'R' :
 …
                 goto done;
+        }
         for (b = s = a_string; (p = strchr_m(s, '%')); s = a_string + (p - b)) {
                 b = a_string;
                 switch (*(p+1)) {
                 case 'U' :
 …
                 return NULL;
+        }
         for (b = s = a_string; (p = strchr_m(s, '%')); s = a_string + (p - b)) {
                 b = a_string;
                 switch (*(p+1)) {
                 case 'N' :
 …
                         a_string = realloc_string_sub(a_string, "%u", user);
                         break;
                         /* Patch from jkf@soton.ac.uk Left the %N (NIS
                          * server name) in standard_sub_basic as it is
 …
                                                       automount_path(servicename));
                         break;
                 default:
                         break;
 …
         return talloc_sub_advanced(ctx,
                                 lp_servicename(SNUM(conn)),
                                 conn->server_info->unix_name,
+                                conn->session_info->unix_name,
                                 conn->connectpath,
                                 conn->server_info->utok.gid,
+                                conn->session_info->utok.gid,
                                 get_smb_user_name(),
                                 "",

trunk/server/source3/lib/sysacls.c

-              r414
+              r745
 #include "includes.h"
+#include "system/passwd.h"
+#if defined(HAVE_POSIX_ACLS)
+#include "modules/vfs_posixacl.h"
+#endif
+#if defined(HAVE_TRU64_ACLS)
+#include "modules/vfs_tru64acl.h"
+#endif
+#if defined(HAVE_SOLARIS_ACLS) || defined(HAVE_UNIXWARE_ACLS)
+#include "modules/vfs_solarisacl.h"
+#endif
+#if defined(HAVE_HPUX_ACLS)
+#include "modules/vfs_hpuxacl.h"
+#endif
+#if defined(HAVE_IRIX_ACLS)
+#include "modules/vfs_irixacl.h"
+#endif
 #undef  DBGC_CLASS

trunk/server/source3/lib/sysquotas.c

-              r414
+              r745
         {"xfs", sys_get_xfs_quota,      sys_set_xfs_quota},
 #endif /* HAVE_XFS_QUOTAS */
+#ifdef HAVE_NFS_QUOTAS
+        {"nfs", sys_get_nfs_quota,      sys_set_nfs_quota},
+#endif /* HAVE_NFS_QUOTAS */
         {NULL,  NULL,                   NULL}
 };
 …
                         DEBUG (3, ("Parsed output of get_quota, ...\n"));
-#ifdef LARGE_SMB_OFF_T
                         DEBUGADD (5,(
                                 "qflags:%u curblocks:%llu softlimit:%llu hardlimit:%llu\n"
 …
                                 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
                                 (long long unsigned)dp->bsize));
-#else /* LARGE_SMB_OFF_T */
-                        DEBUGADD (5,(
-                                "qflags:%u curblocks:%lu softlimit:%lu hardlimit:%lu\n"
-                                "curinodes:%lu isoftlimit:%lu ihardlimit:%lu bsize:%lu\n",
-                                dp->qflags,(long unsigned)dp->curblocks,
-                                (long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
-                                (long unsigned)dp->curinodes,
-                                (long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
-                                (long unsigned)dp->bsize));
-#endif /* LARGE_SMB_OFF_T */
                         return 0;
+                }
 …
+                }
-#ifdef LARGE_SMB_OFF_T
                 if (asprintf(&syscmd,
                         "%s \"%s\" %d %d "
 …
                         return -1;
+                }
-#else /* LARGE_SMB_OFF_T */
-                if (asprintf(&syscmd,
-                        "%s \"%s\" %d %d "
-                        "%u %lu %lu "
-                        "%lu %lu %lu ",
-                        set_quota_command, path, qtype, _id, dp->qflags,
-                        (long unsigned)dp->softlimit,(long unsigned)dp->hardlimit,
-                        (long unsigned)dp->isoftlimit,(long unsigned)dp->ihardlimit,
-                        (long unsigned)dp->bsize) < 0) {
-                        return -1;
+                }
-#endif /* LARGE_SMB_OFF_T */
                 DEBUG (3, ("get_quota: Running command %s\n", syscmd));

trunk/server/source3/lib/system.c

-              r590
+              r745
 #include "includes.h"
+#include "system/syslog.h"
+#include "system/capability.h"
+#include "system/passwd.h"
+#include "system/filesys.h"
 #ifdef HAVE_SYS_PRCTL_H
 #include <sys/prctl.h>
+#endif
+#ifdef __OS2__
+#define pipe(A) os2_pipe(A)
 #endif
 …
         do {
                 ret = read(fd, buf, count);
+        } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
         return ret;
+}
 …
         do {
                 ret = write(fd, buf, count);
+        } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
         return ret;
+}
 …
         do {
                 ret = writev(fd, iov, iovcnt);
+        } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
         return ret;
+}
 …
 /*******************************************************************
 A send wrapper that will deal with EINTR.
+A send wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
 ********************************************************************/
 …
         do {
                 ret = send(s, msg, len, flags);
+        } while (ret == -1 && errno == EINTR);
+        return ret;
+}
+/*******************************************************************
+A sendto wrapper that will deal with EINTR.
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
+        return ret;
+}
+/*******************************************************************
+A sendto wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
 ********************************************************************/
 …
         do {
                 ret = sendto(s, msg, len, flags, to, tolen);
+        } while (ret == -1 && errno == EINTR);
+        return ret;
+}
+/*******************************************************************
+A recv wrapper that will deal with EINTR.
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
+        return ret;
+}
+/*******************************************************************
+A recv wrapper that will deal with EINTR or EAGAIN or EWOULDBLOCK.
 ********************************************************************/
 …
         do {
                 ret = recv(fd, buf, count, flags);
+        } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
         return ret;
+}
 …
         do {
                 ret = recvfrom(s, buf, len, flags, from, fromlen);
+        } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+        } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
         return ret;
+}
 …
 #elif defined(HAVE_POSIX_FALLOCATE) && !defined(HAVE_BROKEN_POSIX_FALLOCATE)
         return posix_fallocate(fd, offset, len);
+#elif defined(F_RESVSP64)
+        /* this handles XFS on IRIX */
+        struct flock64 fl;
+        SMB_OFF_T new_len = offset + len;
+        int ret;
+        struct stat64 sbuf;
+        /* unlikely to get a too large file on a 64bit system but ... */
+        if (new_len < 0)
+                return EFBIG;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = offset;
+        fl.l_len = len;
+        ret=fcntl(fd, F_RESVSP64, &fl);
+        if (ret != 0)
+                return errno;
+        /* Make sure the file gets enlarged after we allocated space: */
+        fstat64(fd, &sbuf);
+        if (new_len > sbuf.st_size)
+                ftruncate64(fd, new_len);
+        return 0;
 #else
         return ENOSYS;
+#endif
+}
+/*******************************************************************
+ An fallocate() function that matches the semantics of the Linux one.
+********************************************************************/
+#ifdef HAVE_LINUX_FALLOC_H
+#include <linux/falloc.h>
+#endif
+int sys_fallocate(int fd, enum vfs_fallocate_mode mode, SMB_OFF_T offset, SMB_OFF_T len)
+{
+#if defined(HAVE_LINUX_FALLOCATE64) || defined(HAVE_LINUX_FALLOCATE)
+        int lmode;
+        switch (mode) {
+        case VFS_FALLOCATE_EXTEND_SIZE:
+                lmode = 0;
+                break;
+        case VFS_FALLOCATE_KEEP_SIZE:
+                lmode = FALLOC_FL_KEEP_SIZE;
+                break;
+        default:
+                errno = EINVAL;
+                return -1;
+        }
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_LINUX_FALLOCATE64)
+        return fallocate64(fd, lmode, offset, len);
+#elif defined(HAVE_LINUX_FALLOCATE)
+        return fallocate(fd, lmode, offset, len);
+#endif
+#else
+        /* TODO - plumb in fallocate from other filesysetms like VXFS etc. JRA. */
+        errno = ENOSYS;
+        return -1;
 #endif
+}
 …
+}
+#if HAVE_KERNEL_SHARE_MODES
+#ifndef LOCK_MAND
+#define LOCK_MAND       32      /* This is a mandatory flock */
+#define LOCK_READ       64      /* ... Which allows concurrent read operations */
+#define LOCK_WRITE      128     /* ... Which allows concurrent write operations */
+#define LOCK_RW         192     /* ... Which allows concurrent read & write ops */
+#endif
+#endif
 /*******************************************************************
 …
 #else
         return opendir(name);
+#endif
+}
+/*******************************************************************
+ An fdopendir wrapper that will deal with 64 bit filesizes.
+ Ugly hack - we need dirfd for this to work correctly in the
+ calling code.. JRA.
+********************************************************************/
+SMB_STRUCT_DIR *sys_fdopendir(int fd)
+{
+#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_FDOPENDIR64) && defined(HAVE_DIRFD)
+        return fdopendir64(fd);
+#elif defined(HAVE_FDOPENDIR) && defined(HAVE_DIRFD)
+        return fdopendir(fd);
+#else
+        errno = ENOSYS;
+        return NULL;
 #endif
+}
 …
+}
+#ifndef NGROUPS_MAX
+#define NGROUPS_MAX 32 /* Guess... */
+#endif
 /**************************************************************************
  Returns equivalent to NGROUPS_MAX - using sysconf if needed.
 …
 #if defined(HAVE_BROKEN_GETGROUPS)
+#ifdef HAVE_BROKEN_GETGROUPS
+#define GID_T int
+#else
+#define GID_T gid_t
+#endif
 static int sys_broken_getgroups(int setlen, gid_t *gidset)
+{
 …
 /**************************************************************************
- Wrappers for setpwent(), getpwent() and endpwent()
-****************************************************************************/
-void sys_setpwent(void)
+{
-        setpwent();
+}
-struct passwd *sys_getpwent(void)
+{
-        return getpwent();
+}
-void sys_endpwent(void)
+{
-        endpwent();
+}
-/**************************************************************************
- Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
-****************************************************************************/
-struct passwd *sys_getpwnam(const char *name)
+{
-        return getpwnam(name);
+}
-struct passwd *sys_getpwuid(uid_t uid)
+{
-        return getpwuid(uid);
+}
-struct group *sys_getgrnam(const char *name)
+{
-        return getgrnam(name);
+}
-struct group *sys_getgrgid(gid_t gid)
+{
-        return getgrgid(gid);
+}
-/**************************************************************************
  Extract a command into an arg list.
 ****************************************************************************/
 …
         SAFE_FREE(entry);
         SAFE_FREE(argl);
+        TALLOC_FREE(argl);
         close(pipe_fds[0]);
         close(pipe_fds[1]);
 …
+                }
                 /* Shift results back, so we can prepend prefixes */
                 buf = memmove(list + len, list, list_size);
+                buf = (char *)memmove(list + len, list, list_size);
                 for(i = 0; i < list_size; i += len + 1) {
 …
+}
 #endif /* WITH_AIO */
-int sys_getpeereid( int s, uid_t *uid)
+{
-#if defined(HAVE_PEERCRED)
-        struct ucred cred;
-        socklen_t cred_len = sizeof(struct ucred);
-        int ret;
-        ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
-        if (ret != 0) {
-                return -1;
+        }
-        if (cred_len != sizeof(struct ucred)) {
-                errno = EINVAL;
-                return -1;
+        }
-        *uid = cred.uid;
-        return 0;
-#else
-        errno = ENOSYS;
-        return -1;
-#endif
+}
-int sys_getnameinfo(const struct sockaddr *psa,
-                        socklen_t salen,
-                        char *host,
-                        size_t hostlen,
-                        char *service,
-                        size_t servlen,
-                        int flags)
+{
-        /*
-         * For Solaris we must make sure salen is the
-         * correct length for the incoming sa_family.
-         */
-        if (salen == sizeof(struct sockaddr_storage)) {
-                salen = sizeof(struct sockaddr_in);
-#if defined(HAVE_IPV6)
-                if (psa->sa_family == AF_INET6) {
-                        salen = sizeof(struct sockaddr_in6);
+                }
-#endif
+        }
-        return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
+}
-int sys_connect(int fd, const struct sockaddr * addr)
+{
-        socklen_t salen = -1;
-        if (addr->sa_family == AF_INET) {
-            salen = sizeof(struct sockaddr_in);
-        } else if (addr->sa_family == AF_UNIX) {
-            salen = sizeof(struct sockaddr_un);
+        }
-#if defined(HAVE_IPV6)
-        else if (addr->sa_family == AF_INET6) {
-            salen = sizeof(struct sockaddr_in6);
+        }
-#endif
-        return connect(fd, addr, salen);
+}

trunk/server/source3/lib/system_smbd.c

-              r599
+              r745
 #include "includes.h"
+#include "system/passwd.h"
+#include "nsswitch/winbind_client.h"
 #ifndef HAVE_GETGROUPLIST
 …
+        }
         if (initgroups(user, gid) != 0) {
+        if (initgroups(user, gid) == -1) {
                 DEBUG(0, ("getgrouplist_internals: initgroups() failed!\n"));
                 SAFE_FREE(gids_saved);
 …
 bool getgroups_unix_user(TALLOC_CTX *mem_ctx, const char *user,
                          gid_t primary_gid,
                          gid_t **ret_groups, size_t *p_ngroups)
+{
         size_t ngrp;
+                         gid_t **ret_groups, uint32_t *p_ngroups)
+{
+        uint32_t ngrp;
         int max_grp;
         gid_t *temp_groups;

trunk/server/source3/lib/talloc_dict.c

-              r414
+              r745
 #include "includes.h"
+#include "dbwrap.h"
+#include "talloc_dict.h"
+#include "util_tdb.h"
 struct talloc_dict {

trunk/server/source3/lib/tallocmsg.c

-              r414
+              r745
    samba -- Unix SMB/CIFS implementation.
    Copyright (C) 2001, 2002 by Martin Pool
    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/>.
 …
 #include "includes.h"
+#include "messages.h"
 /**
 …
+        }
+        if (strcmp(name, "char") == 0) {
+                /*
+                 * Print out the first 50 bytes of the string
+                 */
+                sprintf_append(state->mem_ctx, &state->s, &state->len,
+                               &state->buflen,
+                               "%*s%-30s contains %6lu bytes in %3lu blocks "
+                               "(ref %d): %*s\n", depth*4, "",
+                               name,
+                               (unsigned long)talloc_total_size(ptr),
+                               (unsigned long)talloc_total_blocks(ptr),
+                               talloc_reference_count(ptr),
+                               MIN(50, talloc_get_size(ptr)),
+                               (char *)ptr);
+                return;
+        }
         sprintf_append(state->mem_ctx, &state->s, &state->len, &state->buflen,
                        "%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n",
 …
         SMB_ASSERT(msg_type == MSG_REQ_POOL_USAGE);
         DEBUG(2,("Got POOL_USAGE\n"));
 …
                 return;
+        }
         messaging_send_buf(msg_ctx, src, MSG_POOL_USAGE,
                            (uint8 *)state.s, strlen(state.s)+1);

trunk/server/source3/lib/tdb_validate.c

-              r590
+              r745
  */
+#include "includes.h"
+#include "system/filesys.h"
+#include "util_tdb.h"
 #include "tdb_validate.h"
-#include "includes.h"
 /*
 …
         tmp_path = talloc_asprintf(ctx, "%s%s", dst_path, ".tmp");
+        if (!tmp_path) {
+                DEBUG(3, ("talloc fail\n"));
+                goto done;
+        }
         unlink(tmp_path);
         dst_tdb = tdb_open_log(tmp_path,
 …
         dst_path = talloc_asprintf(ctx, "%s%s", path, suffix);
+        if (dst_path == NULL) {
+                DEBUG(3, ("error out of memory\n"));
+                return ret;
+        }
         ret = (rename(path, dst_path) != 0);
 …
                 char *rotate_path = talloc_asprintf(ctx, "%s%s", dst_path,
                                                     rotate_suffix);
+                if (rotate_path == NULL) {
+                        DEBUG(10, ("talloc fail\n"));
+                        return -1;
+                }
                 DEBUG(10, ("backup of %s failed due to lack of space\n",
                            src_path));
 …
         tdb_path_backup = talloc_asprintf(ctx, "%s%s", tdb_path, backup_suffix);
+        if (!tdb_path_backup) {
+                DEBUG(0, ("tdb_validate_and_backup: out of memory\n"));
+                goto done;
+        }
         ret = tdb_validate_open(tdb_path, validate_fn);

trunk/server/source3/lib/tdb_validate.h

r414	r745
24	24
25	25	#include "lib/replace/replace.h"
26		#include ~~"tdb.h"~~
	26	#include <tdb.h>
27	27
28	28	/**

trunk/server/source3/lib/time.c

-              r480
+              r745
 #endif
-/*******************************************************************
-  create a 16 bit dos packed date
-********************************************************************/
-static uint16_t make_dos_date1(struct tm *t)
+{
-        uint16_t ret=0;
-        ret = (((unsigned int)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
-        ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
-        return ret;
+}
-/*******************************************************************
-  create a 16 bit dos packed time
-********************************************************************/
-static uint16_t make_dos_time1(struct tm *t)
+{
-        uint16_t ret=0;
-        ret = ((((unsigned int)t->tm_min >> 3)&0x7) | (((unsigned int)t->tm_hour) << 3));
-        ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
-        return ret;
+}
-/*******************************************************************
-  create a 32 bit dos packed date/time from some parameters
-  This takes a GMT time and returns a packed localtime structure
-********************************************************************/
-static uint32_t make_dos_date(time_t unixdate, int zone_offset)
+{
-        struct tm *t;
-        uint32_t ret=0;
-        if (unixdate == 0) {
-                return 0;
+        }
-        unixdate -= zone_offset;
-        t = gmtime(&unixdate);
-        if (!t) {
-                return 0xFFFFFFFF;
+        }
-        ret = make_dos_date1(t);
-        ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
-        return ret;
+}
 /**
 …
 **************************************************************/
 uint32_t convert_time_t_to_uint32(time_t t)
+uint32_t convert_time_t_to_uint32_t(time_t t)
+{
 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
 …
+}
 time_t convert_uint32_to_time_t(uint32_t u)
+time_t convert_uint32_t_to_time_t(uint32_t u)
+{
 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
 …
+}
-/****************************************************************************
- Return the date and time as a string
-****************************************************************************/
-char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires)
+{
-        fstring TimeBuf;
-        time_t t;
-        struct tm *tm;
-        t = (time_t)tp->tv_sec;
-        tm = localtime(&t);
-        if (!tm) {
-                if (hires) {
-                        slprintf(TimeBuf,
-                                 sizeof(TimeBuf)-1,
-                                 "%ld.%06ld seconds since the Epoch",
-                                 (long)tp->tv_sec,
-                                 (long)tp->tv_usec);
-                } else {
-                        slprintf(TimeBuf,
-                                 sizeof(TimeBuf)-1,
-                                 "%ld seconds since the Epoch",
-                                 (long)t);
+                }
-        } else {
-#ifdef HAVE_STRFTIME
-                if (hires) {
-                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
-                        slprintf(TimeBuf+strlen(TimeBuf),
-                                 sizeof(TimeBuf)-1 - strlen(TimeBuf),
-                                 ".%06ld",
-                                 (long)tp->tv_usec);
-                } else {
-                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+                }
-#else
-                if (hires) {
-                        const char *asct = asctime(tm);
-                        slprintf(TimeBuf,
-                                 sizeof(TimeBuf)-1,
-                                 "%s.%06ld",
-                                 asct ? asct : "unknown",
-                                 (long)tp->tv_usec);
-                } else {
-                        const char *asct = asctime(tm);
-                        fstrcpy(TimeBuf, asct ? asct : "unknown");
+                }
-#endif
+        }
-        return talloc_strdup(ctx, TimeBuf);
+}
-char *current_timestring(TALLOC_CTX *ctx, bool hires)
+{
-        struct timeval tv;
-        GetTimeOfDay(&tv);
-        return timeval_string(ctx, &tv, hires);
+}
-/*******************************************************************
- Put a dos date into a buffer (time/date format).
- This takes GMT time and puts local time in the buffer.
-********************************************************************/
-static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
+{
-        uint32_t x = make_dos_date(unixdate, zone_offset);
-        SIVAL(buf,offset,x);
+}
-/*******************************************************************
- Put a dos date into a buffer (date/time format).
- This takes GMT time and puts local time in the buffer.
-********************************************************************/
-static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
+{
-        uint32_t x = make_dos_date(unixdate, zone_offset);
-        x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
-        SIVAL(buf,offset,x);
+}
-/*******************************************************************
- Put a dos 32 bit "unix like" date into a buffer. This routine takes
- GMT and converts it to LOCAL time before putting it (most SMBs assume
- localtime for this sort of date)
-********************************************************************/
-static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
+{
-        if (!null_mtime(unixdate)) {
-                unixdate -= zone_offset;
+        }
-        SIVAL(buf,offset,unixdate);
+}
 /***************************************************************************
  Server versions of the above functions.
 …
 void srv_put_dos_date(char *buf,int offset,time_t unixdate)
+{
         put_dos_date(buf, offset, unixdate, server_zone_offset);
+        push_dos_date((uint8_t *)buf, offset, unixdate, server_zone_offset);
+}
 void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
+{
         put_dos_date2(buf, offset, unixdate, server_zone_offset);
+        push_dos_date2((uint8_t *)buf, offset, unixdate, server_zone_offset);
+}
 void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
+{
         put_dos_date3(buf, offset, unixdate, server_zone_offset);
+        push_dos_date3((uint8_t *)buf, offset, unixdate, server_zone_offset);
+}
 …
 ********************************************************************/
 static time_t make_unix_date(const void *date_ptr, int zone_offset)
+time_t make_unix_date(const void *date_ptr, int zone_offset)
+{
         uint32_t dos_date=0;
 …
+{
         time_t t = (time_t)IVAL(date_ptr,0);
         if (!null_mtime(t)) {
+        if (!null_time(t)) {
                 t += zone_offset;
+        }
 …
 struct timespec timespec_current(void)
+{
-        struct timeval tv;
         struct timespec ts;
+        GetTimeOfDay(&tv);
+        ts.tv_sec = tv.tv_sec;
+        ts.tv_nsec = tv.tv_usec * 1000;
+        clock_gettime(CLOCK_REALTIME, &ts);
         return ts;
+}
 …
         struct timeval tv = convert_timespec_to_timeval(*ts);
         *ts = convert_timeval_to_timespec(tv);
+        while (ts->tv_nsec > 1000000000) {
+                ts->tv_sec += 1;
+                ts->tv_nsec -= 1000000000;
+        }
+}
 …
+}
-/***************************************************************************
- Client versions of the above functions.
-***************************************************************************/
-void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
-        put_dos_date(buf, offset, unixdate, cli->serverzone);
+}
-void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
-        put_dos_date2(buf, offset, unixdate, cli->serverzone);
+}
-void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
-        put_dos_date3(buf, offset, unixdate, cli->serverzone);
+}
-time_t cli_make_unix_date(struct cli_state *cli, const void *date_ptr)
+{
-        return make_unix_date(date_ptr, cli->serverzone);
+}
-time_t cli_make_unix_date2(struct cli_state *cli, const void *date_ptr)
+{
-        return make_unix_date2(date_ptr, cli->serverzone);
+}
-time_t cli_make_unix_date3(struct cli_state *cli, const void *date_ptr)
+{
-        return make_unix_date3(date_ptr, cli->serverzone);
+}
-/****************************************************************************
- Check if two NTTIMEs are the same.
-****************************************************************************/
-bool nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
+{
-        return (*nt1 == *nt2);
+}
 /*******************************************************************
  Re-read the smb serverzone value.
 …
+}
+/**
+ * @brief Get the startup time of the server.
+ *
+ * @param[out] ret_time A pointer to a timveal structure to set the startup
+ *                      time.
+ */
+void get_startup_time(struct timeval *ret_time)
+{
+        ret_time->tv_sec = start_time_hires.tv_sec;
+        ret_time->tv_usec = start_time_hires.tv_usec;
+}
 /****************************************************************************
  Convert a NTTIME structure to a time_t.
 …
 /****************************************************************************
- Check if it's a null mtime.
-****************************************************************************/
-bool null_mtime(time_t mtime)
+{
-        if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
-                return true;
-        return false;
+}
-/****************************************************************************
  Utility function that always returns a const string even if localtime
  and asctime fail.

trunk/server/source3/lib/tldap.c

-              r414
+              r745
 #include "includes.h"
+#include "tldap.h"
+#include "../lib/util/asn1.h"
+#include "../lib/tsocket/tsocket.h"
+#include "../lib/util/tevent_unix.h"
+static int tldap_simple_recv(struct tevent_req *req);
 bool tevent_req_is_ldap_error(struct tevent_req *req, int *perr)
 …
+        }
         state->iov.iov_base = blob.data;
+        state->iov.iov_base = (void *)blob.data;
         state->iov.iov_len = blob.length;
 …
         /*
          * We're the first ones, add the read_ldap request that waits for the
+         * We're the first one, add the read_ldap request that waits for the
          * answer from the server
          */
 …
         struct tevent_req *req;
         struct tldap_msg_state *state;
-        struct tevent_context *ev;
         struct asn1_data *data;
         uint8_t *inbuf;
 …
         state->data = talloc_move(state, &data);
-        ev = state->ev;
         talloc_set_destructor(req, NULL);
         tldap_msg_unset_pending(req);
 …
+{
         char *result = talloc_array(mem_ctx, char, blob.length+1);
+        if (result == NULL) {
+                return NULL;
+        }
         memcpy(result, blob.data, blob.length);
         result[blob.length] = '\0';
 …
 static bool asn1_read_OctetString_talloc(TALLOC_CTX *mem_ctx,
                                          struct asn1_data *data,
                                          char **result)
+                                         char **presult)
+{
         DATA_BLOB string;
+        char *result;
         if (!asn1_read_OctetString(data, mem_ctx, &string))
                 return false;
+        *result = blob2string_talloc(mem_ctx, string);
+        result = blob2string_talloc(mem_ctx, string);
         data_blob_free(&string);
+        if (result == NULL) {
+                return false;
+        }
+        *presult = result;
         return true;
+}
 …
 int tldap_sasl_bind_recv(struct tevent_req *req)
+{
+        int err;
+        if (tevent_req_is_ldap_error(req, &err)) {
+                return err;
+        }
+        return TLDAP_SUCCESS;
+        return tldap_simple_recv(req);
+}
 …
 /*****************************************************************************/
+/*
+ * This piece has a dependency on ldb, the ldb_parse_tree() function is used.
+ * In case we want to separate out tldap, we need to copy or rewrite it.
+/* can't use isalpha() as only a strict set is valid for LDAP */
+static bool tldap_is_alpha(char c)
+{
+        return (((c >= 'a') && (c <= 'z')) || \
+                ((c >= 'A') && (c <= 'Z')));
+}
+static bool tldap_is_adh(char c)
+{
+        return tldap_is_alpha(c) || isdigit(c) || (c == '-');
+}
+#define TLDAP_FILTER_AND  ASN1_CONTEXT(0)
+#define TLDAP_FILTER_OR   ASN1_CONTEXT(1)
+#define TLDAP_FILTER_NOT  ASN1_CONTEXT(2)
+#define TLDAP_FILTER_EQ   ASN1_CONTEXT(3)
+#define TLDAP_FILTER_SUB  ASN1_CONTEXT(4)
+#define TLDAP_FILTER_LE   ASN1_CONTEXT(5)
+#define TLDAP_FILTER_GE   ASN1_CONTEXT(6)
+#define TLDAP_FILTER_PRES ASN1_CONTEXT_SIMPLE(7)
+#define TLDAP_FILTER_APX  ASN1_CONTEXT(8)
+#define TLDAP_FILTER_EXT  ASN1_CONTEXT(9)
+#define TLDAP_SUB_INI ASN1_CONTEXT_SIMPLE(0)
+#define TLDAP_SUB_ANY ASN1_CONTEXT_SIMPLE(1)
+#define TLDAP_SUB_FIN ASN1_CONTEXT_SIMPLE(2)
+/* oid's should be numerical only in theory,
+ * but apparently some broken servers may have alphanum aliases instead.
+ * Do like openldap libraries and allow alphanum aliases for oids, but
+ * do not allow Tagging options in that case.
  */
+#include "lib/ldb/include/ldb.h"
+#include "lib/ldb/include/ldb_errors.h"
+static bool ldap_push_filter(struct asn1_data *data,
+                             struct ldb_parse_tree *tree)
+{
+static bool tldap_is_attrdesc(const char *s, int len, bool no_tagopts)
+{
+        bool is_oid = false;
+        bool dot = false;
         int i;
+        switch (tree->operation) {
+        case LDB_OP_AND:
+        case LDB_OP_OR:
+                asn1_push_tag(data,
+                              ASN1_CONTEXT(tree->operation==LDB_OP_AND?0:1));
+                for (i=0; i<tree->u.list.num_elements; i++) {
+                        if (!ldap_push_filter(data,
+                                              tree->u.list.elements[i])) {
+        /* first char has stricter rules */
+        if (isdigit(*s)) {
+                is_oid = true;
+        } else if (!tldap_is_alpha(*s)) {
+                /* bad first char */
+                return false;
+        }
+        for (i = 1; i < len; i++) {
+                if (is_oid) {
+                        if (isdigit(s[i])) {
+                                dot = false;
+                                continue;
+                        }
+                        if (s[i] == '.') {
+                                if (dot) {
+                                        /* malformed */
+                                        return false;
+                                }
+                                dot = true;
+                                continue;
+                        }
+                } else {
+                        if (tldap_is_adh(s[i])) {
+                                continue;
+                        }
+                }
+                if (s[i] == ';') {
+                        if (no_tagopts) {
+                                /* no tagging options */
                                 return false;
+                        }
+                        if (dot) {
+                                /* malformed */
+                                return false;
+                        }
+                        if ((i + 1) == len) {
+                                /* malformed */
+                                return false;
+                        }
+                        is_oid = false;
+                        continue;
+                }
+        }
+        if (dot) {
+                /* malformed */
+                return false;
+        }
+        return true;
+}
+/* this function copies the value until the closing parenthesis is found. */
+static char *tldap_get_val(TALLOC_CTX *memctx,
+                           const char *value, const char **_s)
+{
+        const char *s = value;
+        /* find terminator */
+        while (*s) {
+                s = strchr(s, ')');
+                if (s && (*(s - 1) == '\\')) {
+                        continue;
+                }
+                break;
+        }
+        if (!s || !(*s == ')')) {
+                /* malformed filter */
+                return NULL;
+        }
+        *_s = s;
+        return talloc_strndup(memctx, value, s - value);
+}
+static int tldap_hex2char(const char *x)
+{
+        if (isxdigit(x[0]) && isxdigit(x[1])) {
+                const char h1 = x[0], h2 = x[1];
+                int c = 0;
+                if (h1 >= 'a') c = h1 - (int)'a' + 10;
+                else if (h1 >= 'A') c = h1 - (int)'A' + 10;
+                else if (h1 >= '0') c = h1 - (int)'0';
+                c = c << 4;
+                if (h2 >= 'a') c += h2 - (int)'a' + 10;
+                else if (h2 >= 'A') c += h2 - (int)'A' + 10;
+                else if (h2 >= '0') c += h2 - (int)'0';
+                return c;
+        }
+        return -1;
+}
+static bool tldap_find_first_star(const char *val, const char **star)
+{
+        const char *s;
+        for (s = val; *s; s++) {
+                switch (*s) {
+                case '\\':
+                        if (isxdigit(s[1]) && isxdigit(s[2])) {
+                                s += 2;
+                                break;
+                        }
+                        /* not hex based escape, check older syntax */
+                        switch (s[1]) {
+                        case '(':
+                        case ')':
+                        case '*':
+                        case '\\':
+                                s++;
+                                break;
+                        default:
+                                /* invalid escape sequence */
+                                return false;
+                        }
+                        break;
+                case ')':
+                        /* end of val, nothing found */
+                        *star = s;
+                        return true;
+                case '*':
+                        *star = s;
+                        return true;
+                }
+        }
+        /* string ended without closing parenthesis, filter is malformed */
+        return false;
+}
+static bool tldap_unescape_inplace(char *value, size_t *val_len)
+{
+        int c, i, p;
+        for (i = 0,p = 0; i < *val_len; i++) {
+                switch (value[i]) {
+                case '(':
+                case ')':
+                case '*':
+                        /* these must be escaped */
+                        return false;
+                case '\\':
+                        if (!value[i + 1]) {
+                                /* invalid EOL */
+                                return false;
+                        }
+                        i++;
+                        c = tldap_hex2char(&value[i]);
+                        if (c >= 0 && c < 256) {
+                                value[p] = c;
+                                i++;
+                                p++;
+                                break;
+                        }
+                        switch (value[i]) {
+                        case '(':
+                        case ')':
+                        case '*':
+                        case '\\':
+                                value[p] = value[i];
+                                p++;
+                        default:
+                                /* invalid */
+                                return false;
+                        }
+                        break;
+                default:
+                        value[p] = value[i];
+                        p++;
+                }
+        }
+        value[p] = '\0';
+        *val_len = p;
+        return true;
+}
+static bool tldap_push_filter_basic(struct tldap_context *ld,
+                                    struct asn1_data *data,
+                                    const char **_s);
+static bool tldap_push_filter_substring(struct tldap_context *ld,
+                                        struct asn1_data *data,
+                                        const char *val,
+                                        const char **_s);
+static bool tldap_push_filter_int(struct tldap_context *ld,
+                                  struct asn1_data *data,
+                                  const char **_s)
+{
+        const char *s = *_s;
+        bool ret;
+        if (*s != '(') {
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Incomplete or malformed filter\n");
+                return false;
+        }
+        s++;
+        /* we are right after a parenthesis,
+         * find out what op we have at hand */
+        switch (*s) {
+        case '&':
+                tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: AND\n");
+                asn1_push_tag(data, TLDAP_FILTER_AND);
+                s++;
+                break;
+        case '|':
+                tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: OR\n");
+                asn1_push_tag(data, TLDAP_FILTER_OR);
+                s++;
+                break;
+        case '!':
+                tldap_debug(ld, TLDAP_DEBUG_TRACE, "Filter op: NOT\n");
+                asn1_push_tag(data, TLDAP_FILTER_NOT);
+                s++;
+                ret = tldap_push_filter_int(ld, data, &s);
+                if (!ret) {
+                        return false;
+                }
                 asn1_pop_tag(data);
+                break;
+        case LDB_OP_NOT:
+                asn1_push_tag(data, ASN1_CONTEXT(2));
+                if (!ldap_push_filter(data, tree->u.isnot.child)) {
+                goto done;
+        case '(':
+        case ')':
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Invalid parenthesis '%c'\n", *s);
+                return false;
+        case '\0':
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Invalid filter termination\n");
+                return false;
+        default:
+                ret = tldap_push_filter_basic(ld, data, &s);
+                if (!ret) {
                         return false;
+                }
+                goto done;
+        }
+        /* only and/or filters get here.
+         * go through the list of filters */
+        if (*s == ')') {
+                /* RFC 4526: empty and/or */
                 asn1_pop_tag(data);
+                break;
+        case LDB_OP_EQUALITY:
+                /* equality test */
+                asn1_push_tag(data, ASN1_CONTEXT(3));
+                asn1_write_OctetString(data, tree->u.equality.attr,
+                                      strlen(tree->u.equality.attr));
+                asn1_write_OctetString(data, tree->u.equality.value.data,
+                                      tree->u.equality.value.length);
+                asn1_pop_tag(data);
+                break;
+        case LDB_OP_SUBSTRING:
+                /*
+                  SubstringFilter ::= SEQUENCE {
+                          type            AttributeDescription,
+                          -- at least one must be present
+                          substrings      SEQUENCE OF CHOICE {
+                                  initial [0] LDAPString,
+                                  any     [1] LDAPString,
+                                  final   [2] LDAPString } }
+                */
+                asn1_push_tag(data, ASN1_CONTEXT(4));
+                asn1_write_OctetString(data, tree->u.substring.attr,
+                                       strlen(tree->u.substring.attr));
+                asn1_push_tag(data, ASN1_SEQUENCE(0));
+                i = 0;
+                if (!tree->u.substring.start_with_wildcard) {
+                        asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0));
+                        asn1_write_DATA_BLOB_LDAPString(
+                                data, tree->u.substring.chunks[i]);
+                goto done;
+        }
+        while (*s) {
+                ret = tldap_push_filter_int(ld, data, &s);
+                if (!ret) {
+                        return false;
+                }
+                if (*s == ')') {
+                        /* end of list, return */
                         asn1_pop_tag(data);
+                        i++;
+                }
+                while (tree->u.substring.chunks[i]) {
+                        int ctx;
+                        if ((!tree->u.substring.chunks[i + 1]) &&
+                            (tree->u.substring.end_with_wildcard == 0)) {
+                                ctx = 2;
+                        break;
+                }
+        }
+done:
+        if (*s != ')') {
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Incomplete or malformed filter\n");
+                return false;
+        }
+        s++;
+        if (data->has_error) {
+                return false;
+        }
+        *_s = s;
+        return true;
+}
+static bool tldap_push_filter_basic(struct tldap_context *ld,
+                                    struct asn1_data *data,
+                                    const char **_s)
+{
+        TALLOC_CTX *tmpctx = talloc_tos();
+        const char *s = *_s;
+        const char *e;
+        const char *eq;
+        const char *val;
+        const char *type;
+        const char *dn;
+        const char *rule;
+        const char *star;
+        size_t type_len = 0;
+        char *uval;
+        size_t uval_len;
+        bool write_octect = true;
+        bool ret;
+        eq = strchr(s, '=');
+        if (!eq) {
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Invalid filter, missing equal sign\n");
+                return false;
+        }
+        val = eq + 1;
+        e = eq - 1;
+        switch (*e) {
+        case '<':
+                asn1_push_tag(data, TLDAP_FILTER_LE);
+                break;
+        case '>':
+                asn1_push_tag(data, TLDAP_FILTER_GE);
+                break;
+        case '~':
+                asn1_push_tag(data, TLDAP_FILTER_APX);
+                break;
+        case ':':
+                asn1_push_tag(data, TLDAP_FILTER_EXT);
+                write_octect = false;
+                type = NULL;
+                dn = NULL;
+                rule = NULL;
+                if (*s == ':') { /* [:dn]:rule:= value */
+                        if (s == e) {
+                                /* malformed filter */
+                                return false;
+                        }
+                        dn = s;
+                } else { /* type[:dn][:rule]:= value */
+                        type = s;
+                        dn = strchr(s, ':');
+                        type_len = dn - type;
+                        if (dn == e) { /* type:= value */
+                                dn = NULL;
+                        }
+                }
+                if (dn) {
+                        dn++;
+                        rule = strchr(dn, ':');
+                        if ((rule == dn + 1) || rule + 1 == e) {
+                                /* malformed filter, contains "::" */
+                                return false;
+                        }
+                        if (StrnCaseCmp(dn, "dn:", 3) != 0) {
+                                if (rule == e) {
+                                        rule = dn;
+                                        dn = NULL;
+                                } else {
+                                        /* malformed filter. With two
+                                         * optionals, the first must be "dn"
+                                         */
+                                        return false;
+                                }
                         } else {
+                                ctx = 1;
+                                if (rule == e) {
+                                        rule = NULL;
+                                } else {
+                                        rule++;
+                                }
+                        }
+                        asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(ctx));
+                        asn1_write_DATA_BLOB_LDAPString(
+                                data, tree->u.substring.chunks[i]);
+                        asn1_pop_tag(data);
+                        i++;
+                }
+                asn1_pop_tag(data);
+                asn1_pop_tag(data);
+                break;
+        case LDB_OP_GREATER:
+                /* greaterOrEqual test */
+                asn1_push_tag(data, ASN1_CONTEXT(5));
+                asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr));
+                asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length);
+                asn1_pop_tag(data);
+                break;
+        case LDB_OP_LESS:
+                /* lessOrEqual test */
+                asn1_push_tag(data, ASN1_CONTEXT(6));
+                asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr));
+                asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length);
+                asn1_pop_tag(data);
+                break;
+        case LDB_OP_PRESENT:
+                /* present test */
+                asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(7));
+                asn1_write_LDAPString(data, tree->u.present.attr);
+                asn1_pop_tag(data);
+                return !data->has_error;
+        case LDB_OP_APPROX:
+                /* approx test */
+                asn1_push_tag(data, ASN1_CONTEXT(8));
+                asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr));
+                asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length);
+                asn1_pop_tag(data);
+                break;
+        case LDB_OP_EXTENDED:
+                }
+                if (!type && !dn && !rule) {
+                        /* malformed filter, there must be at least one */
+                        return false;
+                }
                 /*
                   MatchingRuleAssertion ::= SEQUENCE {
                   matchingRule    [1] MatchingRuleID OPTIONAL,
                   type            [2] AttributeDescription OPTIONAL,
+                  type      [2] AttributeDescription OPTIONAL,
                   matchValue      [3] AssertionValue,
                   dnAttributes    [4] BOOLEAN DEFAULT FALSE
+                  }
                 */
+                asn1_push_tag(data, ASN1_CONTEXT(9));
+                if (tree->u.extended.rule_id) {
+                /* check and add rule */
+                if (rule) {
+                        ret = tldap_is_attrdesc(rule, e - rule, true);
+                        if (!ret) {
+                                return false;
+                        }
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1));
                         asn1_write_LDAPString(data, tree->u.extended.rule_id);
+                        asn1_write(data, rule, e - rule);
                         asn1_pop_tag(data);
+                }
+                if (tree->u.extended.attr) {
+                /* check and add type */
+                if (type) {
+                        ret = tldap_is_attrdesc(type, type_len, false);
+                        if (!ret) {
+                                return false;
+                        }
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(2));
                         asn1_write_LDAPString(data, tree->u.extended.attr);
+                        asn1_write(data, type, type_len);
                         asn1_pop_tag(data);
+                }
+                uval = tldap_get_val(tmpctx, val, _s);
+                if (!uval) {
+                        return false;
+                }
+                uval_len = *_s - val;
+                ret = tldap_unescape_inplace(uval, &uval_len);
+                if (!ret) {
+                        return false;
+                }
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(3));
                 asn1_write_DATA_BLOB_LDAPString(data, &tree->u.extended.value);
+                asn1_write(data, uval, uval_len);
                 asn1_pop_tag(data);
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(4));
                 asn1_write_uint8(data, tree->u.extended.dnAttributes);
+                asn1_write_uint8(data, dn?1:0);
                 asn1_pop_tag(data);
+                break;
+        default:
+                e = eq;
+                ret = tldap_is_attrdesc(s, e - s, false);
+                if (!ret) {
+                        return false;
+                }
+                if (strncmp(val, "*)", 2) == 0) {
+                        /* presence */
+                        asn1_push_tag(data, TLDAP_FILTER_PRES);
+                        asn1_write(data, s, e - s);
+                        *_s = val + 1;
+                        write_octect = false;
+                        break;
+                }
+                ret = tldap_find_first_star(val, &star);
+                if (!ret) {
+                        return false;
+                }
+                if (*star == '*') {
+                        /* substring */
+                        asn1_push_tag(data, TLDAP_FILTER_SUB);
+                        asn1_write_OctetString(data, s, e - s);
+                        ret = tldap_push_filter_substring(ld, data, val, &s);
+                        if (!ret) {
+                                return false;
+                        }
+                        *_s = s;
+                        write_octect = false;
+                        break;
+                }
+                /* if nothing else, then it is just equality */
+                asn1_push_tag(data, TLDAP_FILTER_EQ);
+                write_octect = true;
+                break;
+        }
+        if (write_octect) {
+                uval = tldap_get_val(tmpctx, val, _s);
+                if (!uval) {
+                        return false;
+                }
+                uval_len = *_s - val;
+                ret = tldap_unescape_inplace(uval, &uval_len);
+                if (!ret) {
+                        return false;
+                }
+                asn1_write_OctetString(data, s, e - s);
+                asn1_write_OctetString(data, uval, uval_len);
+        }
+        if (data->has_error) {
+                return false;
+        }
+        asn1_pop_tag(data);
+        return true;
+}
+static bool tldap_push_filter_substring(struct tldap_context *ld,
+                                        struct asn1_data *data,
+                                        const char *val,
+                                        const char **_s)
+{
+        TALLOC_CTX *tmpctx = talloc_tos();
+        bool initial = true;
+        const char *star;
+        char *chunk;
+        size_t chunk_len;
+        bool ret;
+        /*
+          SubstringFilter ::= SEQUENCE {
+                  type      AttributeDescription,
+                  -- at least one must be present
+                  substrings      SEQUENCE OF CHOICE {
+                          initial [0] LDAPString,
+                          any     [1] LDAPString,
+                          final   [2] LDAPString } }
+        */
+        asn1_push_tag(data, ASN1_SEQUENCE(0));
+        do {
+                ret = tldap_find_first_star(val, &star);
+                if (!ret) {
+                        return false;
+                }
+                chunk_len = star - val;
+                switch (*star) {
+                case '*':
+                        if (!initial && chunk_len == 0) {
+                                /* found '**', which is illegal */
+                                return false;
+                        }
+                        break;
+                case ')':
+                        if (initial) {
+                                /* no stars ?? */
+                                return false;
+                        }
+                        /* we are done */
+                        break;
+                default:
+                        /* ?? */
+                        return false;
+                }
+                if (initial && chunk_len == 0) {
+                        val = star + 1;
+                        initial = false;
+                        continue;
+                }
+                chunk = talloc_strndup(tmpctx, val, chunk_len);
+                if (!chunk) {
+                        return false;
+                }
+                ret = tldap_unescape_inplace(chunk, &chunk_len);
+                if (!ret) {
+                        return false;
+                }
+                switch (*star) {
+                case '*':
+                        if (initial) {
+                                asn1_push_tag(data, TLDAP_SUB_INI);
+                                initial = false;
+                        } else {
+                                asn1_push_tag(data, TLDAP_SUB_ANY);
+                        }
+                        break;
+                case ')':
+                        asn1_push_tag(data, TLDAP_SUB_FIN);
+                        break;
+                default:
+                        /* ?? */
+                        return false;
+                }
+                asn1_write(data, chunk, chunk_len);
                 asn1_pop_tag(data);
+                break;
+        default:
+                val = star + 1;
+        } while (*star == '*');
+        *_s = star;
+        /* end of sequence */
+        asn1_pop_tag(data);
+        return true;
+}
+/* NOTE: although openldap libraries allow for spaces in some places, mosly
+ * around parenthesis, we do not allow any spaces (except in values of
+ * course) as I couldn't fine any place in RFC 4512 or RFC 4515 where
+ * leading or trailing spaces where allowed.
+ */
+static bool tldap_push_filter(struct tldap_context *ld,
+                              struct asn1_data *data,
+                              const char *filter)
+{
+        const char *s = filter;
+        bool ret;
+        ret = tldap_push_filter_int(ld, data, &s);
+        if (ret && *s) {
+                tldap_debug(ld, TLDAP_DEBUG_ERROR,
+                            "Incomplete or malformed filter\n");
                 return false;
+        }
-        return !data->has_error;
+}
-static bool tldap_push_filter(struct asn1_data *data, const char *filter)
+{
-        struct ldb_parse_tree *tree;
-        bool ret;
-        tree = ldb_parse_tree(talloc_tos(), filter);
-        if (tree == NULL) {
-                return false;
+        }
-        ret = ldap_push_filter(data, tree);
-        TALLOC_FREE(tree);
         return ret;
+}
 …
         asn1_write_BOOLEAN(state->out, attrsonly);
         if (!tldap_push_filter(state->out, filter)) {
+        if (!tldap_push_filter(ld, state->out, filter)) {
                 goto encoding_error;
+        }
 …
         tevent_req_set_callback(req, tldap_search_cb, &state);
+        if (!tevent_req_is_in_progress(req)) {
+                /* an error happend before sending */
+                if (tevent_req_is_ldap_error(req, &state.rc)) {
+                        goto fail;
+                }
+        }
         while (tevent_req_is_in_progress(req)
                && (state.rc == TLDAP_SUCCESS)) {
 …
+}
+bool tldap_entry_attributes(struct tldap_message *msg, int *num_attributes,
+                            struct tldap_attribute **attributes)
+bool tldap_entry_attributes(struct tldap_message *msg,
+                            struct tldap_attribute **attributes,
+                            int *num_attributes)
+{
         if ((msg->dn == NULL) && (!tldap_parse_search_entry(msg))) {
 …
 int tldap_add(struct tldap_context *ld, const char *dn,
               int num_attributes, struct tldap_mod *attributes,
+              struct tldap_mod *attributes, int num_attributes,
               struct tldap_control *sctrls, int num_sctrls,
               struct tldap_control *cctrls, int num_cctrls)
 …
                                      struct tldap_context *ld,
                                      const char *dn,
                                      int num_mods, struct tldap_mod *mods,
+                                     struct tldap_mod *mods, int num_mods,
                                      struct tldap_control *sctrls,
                                      int num_sctrls,
 …
 int tldap_modify(struct tldap_context *ld, const char *dn,
                  int num_mods, struct tldap_mod *mods,
+                 struct tldap_mod *mods, int num_mods,
                  struct tldap_control *sctrls, int num_sctrls,
                  struct tldap_control *cctrls, int num_cctrls)
 …
+        }
         req = tldap_modify_send(frame, ev, ld, dn, num_mods, mods,
+        req = tldap_modify_send(frame, ev, ld, dn, mods, num_mods,
                                 sctrls, num_sctrls, cctrls, num_cctrls);
         if (req == NULL) {
 …
                 *sctrls = NULL;
                 *num_sctrls = 0;
+                return;
+        }
         *sctrls = msg->res_sctrls;

trunk/server/source3/lib/tldap_util.c

-              r414
+              r745
 #include "includes.h"
+#include "tldap.h"
+#include "tldap_util.h"
+#include "../libcli/security/security.h"
+#include "../lib/util/asn1.h"
+#include "../librpc/ndr/libndr.h"
 bool tldap_entry_values(struct tldap_message *msg, const char *attribute,
                         int *num_values, DATA_BLOB **values)
+                        DATA_BLOB **values, int *num_values)
+{
         struct tldap_attribute *attributes;
         int i, num_attributes;
         if (!tldap_entry_attributes(msg, &num_attributes, &attributes)) {
+        if (!tldap_entry_attributes(msg, &attributes, &num_attributes)) {
                 return false;
+        }
 …
                 return NULL;
+        }
         if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
+        if (!tldap_entry_values(msg, attribute, &values, &num_values)) {
                 return NULL;
+        }
 …
 static bool tldap_add_blob_vals(TALLOC_CTX *mem_ctx, struct tldap_mod *mod,
                                 int num_newvals, DATA_BLOB *newvals)
+                                DATA_BLOB *newvals, int num_newvals)
+{
         int num_values = talloc_array_length(mod->values);
 …
+}
+bool tldap_add_mod_blobs(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
+bool tldap_add_mod_blobs(TALLOC_CTX *mem_ctx,
+                         struct tldap_mod **pmods, int *pnum_mods,
                          int mod_op, const char *attrib,
                          int num_newvals, DATA_BLOB *newvals)
+                         DATA_BLOB *newvals, int num_newvals)
+{
         struct tldap_mod new_mod;
 …
+        }
         num_mods = talloc_array_length(mods);
+        num_mods = *pnum_mods;
         for (i=0; i<num_mods; i++) {
 …
         if ((num_newvals != 0)
             && !tldap_add_blob_vals(mods, mod, num_newvals, newvals)) {
                 return false;
+        }
         if (i == num_mods) {
+            && !tldap_add_blob_vals(mods, mod, newvals, num_newvals)) {
+                return false;
+        }
+        if ((i == num_mods) && (talloc_array_length(mods) < num_mods + 1)) {
                 mods = talloc_realloc(talloc_tos(), mods, struct tldap_mod,
                                       num_mods+1);
 …
         *pmods = mods;
+        *pnum_mods += 1;
         return true;
+}
+bool tldap_add_mod_str(TALLOC_CTX *mem_ctx, struct tldap_mod **pmods,
+bool tldap_add_mod_str(TALLOC_CTX *mem_ctx,
+                       struct tldap_mod **pmods, int *pnum_mods,
                        int mod_op, const char *attrib, const char *str)
+{
 …
+        }
+        ret = tldap_add_mod_blobs(mem_ctx, pmods, mod_op, attrib, 1, &utf8);
+        ret = tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods, mod_op, attrib,
+                                  &utf8, 1);
         TALLOC_FREE(utf8.data);
         return ret;
 …
 static bool tldap_make_mod_blob_int(struct tldap_message *existing,
                                     TALLOC_CTX *mem_ctx,
                                     int *pnum_mods, struct tldap_mod **pmods,
+                                    struct tldap_mod **pmods, int *pnum_mods,
                                     const char *attrib, DATA_BLOB newval,
                                     int (*comparison)(const DATA_BLOB *d1,
 …
         if ((existing != NULL)
             && tldap_entry_values(existing, attrib, &num_values, &values)) {
+            && tldap_entry_values(existing, attrib, &values, &num_values)) {
                 if (num_values > 1) {
 …
                    an add at the same time if the values are the
                    same... */
                 DEBUG(10,("smbldap_make_mod_blob: attribute |%s| not "
+                DEBUG(10,("tldap_make_mod_blob_int: attribute |%s| not "
                           "changed.\n", attrib));
                 return true;
 …
                  * then you could add new value */
                 DEBUG(10, ("smbldap_make_mod_blob: deleting attribute |%s|\n",
+                DEBUG(10, ("tldap_make_mod_blob_int: deleting attribute |%s|\n",
                            attrib));
+                if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_DELETE,
+                                         attrib, 1, &oldval)) {
+                if (!tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods,
+                                         TLDAP_MOD_DELETE,
+                                         attrib, &oldval, 1)) {
                         return false;
+                }
 …
         if (newval.data != NULL) {
                 DEBUG(10, ("smbldap_make_mod: adding attribute |%s| value len "
+                DEBUG(10, ("tldap_make_mod_blob_int: adding attribute |%s| value len "
                            "%d\n", attrib, (int)newval.length));
+                if (!tldap_add_mod_blobs(mem_ctx, pmods, TLDAP_MOD_ADD,
+                                         attrib, 1, &newval)) {
+                if (!tldap_add_mod_blobs(mem_ctx, pmods, pnum_mods,
+                                         TLDAP_MOD_ADD,
+                                         attrib, &newval, 1)) {
                         return false;
+                }
+        }
-        *pnum_mods = talloc_array_length(*pmods);
         return true;
+}
 bool tldap_make_mod_blob(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
                          int *pnum_mods, struct tldap_mod **pmods,
+                         struct tldap_mod **pmods, int *pnum_mods,
                          const char *attrib, DATA_BLOB newval)
+{
         return tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
+        return tldap_make_mod_blob_int(existing, mem_ctx, pmods, pnum_mods,
                                        attrib, newval, data_blob_cmp);
+}
 …
 bool tldap_make_mod_fmt(struct tldap_message *existing, TALLOC_CTX *mem_ctx,
                         int *pnum_mods, struct tldap_mod **pmods,
+                        struct tldap_mod **pmods, int *pnum_mods,
                         const char *attrib, const char *fmt, ...)
+{
 …
                 blob.data = CONST_DISCARD(uint8_t *, newval);
+        }
         ret = tldap_make_mod_blob_int(existing, mem_ctx, pnum_mods, pmods,
+        ret = tldap_make_mod_blob_int(existing, mem_ctx, pmods, pnum_mods,
                                       attrib, blob, compare_utf8_blobs);
         TALLOC_FREE(newval);
 …
         char *res;
+        ld_error = tldap_msg_diagnosticmessage(tldap_ctx_lastmsg(ld));
+        if (ld != NULL) {
+                ld_error = tldap_msg_diagnosticmessage(tldap_ctx_lastmsg(ld));
+        }
         res = talloc_asprintf(mem_ctx, "LDAP error %d (%s), %s", rc,
                               tldap_err2string(rc),
 …
         DATA_BLOB *values;
         if (!tldap_entry_values(msg, attribute, &num_values, &values)) {
+        if (!tldap_entry_values(msg, attribute, &values, &num_values)) {
                 return false;
+        }

trunk/server/source3/lib/username.c

-              r414
+              r745
    Copyright (C) Andrew Tridgell 1992-1998
    Copyright (C) Jeremy Allison 1997-2001.
+   Copyright (C) Andrew Bartlett 2002
    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/>.
 …
 #include "includes.h"
+#include "system/passwd.h"
+#include "memcache.h"
+#include "../lib/util/util_pw.h"
 /* internal functions */
 …
                                                  int N);
+static struct passwd *getpwnam_alloc_cached(TALLOC_CTX *mem_ctx, const char *name)
+{
+        struct passwd *pw, *for_cache;
+        pw = (struct passwd *)memcache_lookup_talloc(
+                NULL, GETPWNAM_CACHE, data_blob_string_const_null(name));
+        if (pw != NULL) {
+                return tcopy_passwd(mem_ctx, pw);
+        }
+        pw = sys_getpwnam(name);
+        if (pw == NULL) {
+                return NULL;
+        }
+        for_cache = tcopy_passwd(talloc_tos(), pw);
+        if (for_cache == NULL) {
+                return NULL;
+        }
+        memcache_add_talloc(NULL, GETPWNAM_CACHE,
+                        data_blob_string_const_null(name), &for_cache);
+        return tcopy_passwd(mem_ctx, pw);
+}
+/****************************************************************************
+ Flush all cached passwd structs.
+****************************************************************************/
+void flush_pwnam_cache(void)
+{
+        memcache_flush(NULL, GETPWNAM_CACHE);
+}
 /****************************************************************************
  Get a users home directory.
 …
         strlower_m(user2);
         DEBUG(5,("Trying _Get_Pwnam(), username as lowercase is %s\n",user2));
         ret = getpwnam_alloc(mem_ctx, user2);
+        ret = getpwnam_alloc_cached(mem_ctx, user2);
         if(ret)
                 goto done;
 …
                 DEBUG(5,("Trying _Get_Pwnam(), username as given is %s\n",
                          user));
                 ret = getpwnam_alloc(mem_ctx, user);
+                ret = getpwnam_alloc_cached(mem_ctx, user);
                 if(ret)
                         goto done;
 …
                 DEBUG(5,("Trying _Get_Pwnam(), username as uppercase is %s\n",
                          user2));
                 ret = getpwnam_alloc(mem_ctx, user2);
+                ret = getpwnam_alloc_cached(mem_ctx, user2);
                 if(ret)
                         goto done;
 …
         DEBUG(5,("Checking combinations of %d uppercase letters in %s\n",
                  lp_usernamelevel(), user2));
         ret = uname_string_combinations(user2, mem_ctx, getpwnam_alloc,
+        ret = uname_string_combinations(user2, mem_ctx, getpwnam_alloc_cached,
                                         lp_usernamelevel());
 …
+{
         fstring user2;
-        struct passwd *ret;
         if ( *user == '\0' ) {
 …
         DEBUG(5,("Finding user %s\n", user));
+        ret = Get_Pwnam_internals(mem_ctx, user, user2);
+        return ret;
+        return Get_Pwnam_internals(mem_ctx, user, user2);
+}
 …
         for (i=offset;i<(len-(N-1));i++) {
                 char c = s[i];
                 if (!islower_ascii((int)c))
+                if (!islower_m((int)c))
                         continue;
                 s[i] = toupper_ascii(c);
+                s[i] = toupper_m(c);
                 ret = uname_string_combinations2(s, mem_ctx, i+1, fn, N-1);
                 if(ret)

trunk/server/source3/lib/util.c

-              r599
+              r745
    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/passwd.h"
+#include "system/filesys.h"
+#include "util_tdb.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/util_pw.h"
+#include "messages.h"
 extern char *global_clobber_region_function;
 …
 ***********************************************************************/
-static char *smb_myname;
-static char *smb_myworkgroup;
 static char *smb_scope;
 static int smb_num_netbios_names;
 static char **smb_my_netbios_names;
-/***********************************************************************
- Allocate and set myname. Ensure upper case.
-***********************************************************************/
-bool set_global_myname(const char *myname)
+{
-        SAFE_FREE(smb_myname);
-        smb_myname = SMB_STRDUP(myname);
-        if (!smb_myname)
-                return False;
-        strupper_m(smb_myname);
-        return True;
+}
-const char *global_myname(void)
+{
-        return smb_myname;
+}
-/***********************************************************************
- Allocate and set myworkgroup. Ensure upper case.
-***********************************************************************/
-bool set_global_myworkgroup(const char *myworkgroup)
+{
-        SAFE_FREE(smb_myworkgroup);
-        smb_myworkgroup = SMB_STRDUP(myworkgroup);
-        if (!smb_myworkgroup)
-                return False;
-        strupper_m(smb_myworkgroup);
-        return True;
+}
-const char *lp_workgroup(void)
+{
-        return smb_myworkgroup;
+}
 /***********************************************************************
 …
 void gfree_names(void)
+{
+        SAFE_FREE( smb_myname );
+        SAFE_FREE( smb_myworkgroup );
+        gfree_netbios_names();
         SAFE_FREE( smb_scope );
         free_netbios_names_array();
 …
         if (global_myname() == NULL || *global_myname() == '\0') {
                 if (!set_global_myname(myhostname())) {
                         DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
+                        DEBUG( 0, ( "init_names: malloc fail.\n" ) );
                         return False;
+                }
 …
         if (!set_netbios_aliases(lp_netbios_aliases())) {
                 DEBUG( 0, ( "init_structs: malloc fail.\n" ) );
+                DEBUG( 0, ( "init_names: malloc fail.\n" ) );
                 return False;
+        }
 …
         return( True );
+}
-/**************************************************************************n
-  Code to cope with username/password auth options from the commandline.
-  Used mainly in client tools.
-****************************************************************************/
-struct user_auth_info *user_auth_info_init(TALLOC_CTX *mem_ctx)
+{
-        struct user_auth_info *result;
-        result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
-        if (result == NULL) {
-                return NULL;
+        }
-        result->signing_state = Undefined;
-        return result;
+}
-const char *get_cmdline_auth_info_username(const struct user_auth_info *auth_info)
+{
-        if (!auth_info->username) {
-                return "";
+        }
-        return auth_info->username;
+}
-void set_cmdline_auth_info_username(struct user_auth_info *auth_info,
-                                    const char *username)
+{
-        TALLOC_FREE(auth_info->username);
-        auth_info->username = talloc_strdup(auth_info, username);
-        if (!auth_info->username) {
-                exit(ENOMEM);
+        }
+}
-const char *get_cmdline_auth_info_domain(const struct user_auth_info *auth_info)
+{
-        if (!auth_info->domain) {
-                return "";
+        }
-        return auth_info->domain;
+}
-void set_cmdline_auth_info_domain(struct user_auth_info *auth_info,
-                                  const char *domain)
+{
-        TALLOC_FREE(auth_info->domain);
-        auth_info->domain = talloc_strdup(auth_info, domain);
-        if (!auth_info->domain) {
-                exit(ENOMEM);
+        }
+}
-const char *get_cmdline_auth_info_password(const struct user_auth_info *auth_info)
+{
-        if (!auth_info->password) {
-                return "";
+        }
-        return auth_info->password;
+}
-void set_cmdline_auth_info_password(struct user_auth_info *auth_info,
-                                    const char *password)
+{
-        TALLOC_FREE(auth_info->password);
-        if (password == NULL) {
-                password = "";
+        }
-        auth_info->password = talloc_strdup(auth_info, password);
-        if (!auth_info->password) {
-                exit(ENOMEM);
+        }
-        auth_info->got_pass = true;
+}
-bool set_cmdline_auth_info_signing_state(struct user_auth_info *auth_info,
-                                         const char *arg)
+{
-        auth_info->signing_state = -1;
-        if (strequal(arg, "off") || strequal(arg, "no") ||
-                        strequal(arg, "false")) {
-                auth_info->signing_state = false;
-        } else if (strequal(arg, "on") || strequal(arg, "yes") ||
-                        strequal(arg, "true") || strequal(arg, "auto")) {
-                auth_info->signing_state = true;
-        } else if (strequal(arg, "force") || strequal(arg, "required") ||
-                        strequal(arg, "forced")) {
-                auth_info->signing_state = Required;
-        } else {
-                return false;
+        }
-        return true;
+}
-int get_cmdline_auth_info_signing_state(const struct user_auth_info *auth_info)
+{
-        return auth_info->signing_state;
+}
-void set_cmdline_auth_info_use_ccache(struct user_auth_info *auth_info, bool b)
+{
-        auth_info->use_ccache = b;
+}
-bool get_cmdline_auth_info_use_ccache(const struct user_auth_info *auth_info)
+{
-        return auth_info->use_ccache;
+}
-void set_cmdline_auth_info_use_kerberos(struct user_auth_info *auth_info,
-                                        bool b)
+{
-        auth_info->use_kerberos = b;
+}
-bool get_cmdline_auth_info_use_kerberos(const struct user_auth_info *auth_info)
+{
-        return auth_info->use_kerberos;
+}
-void set_cmdline_auth_info_fallback_after_kerberos(struct user_auth_info *auth_info,
-                                        bool b)
+{
-        auth_info->fallback_after_kerberos = b;
+}
-bool get_cmdline_auth_info_fallback_after_kerberos(const struct user_auth_info *auth_info)
+{
-        return auth_info->fallback_after_kerberos;
+}
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_use_krb5_ticket(struct user_auth_info *auth_info)
+{
-        auth_info->use_kerberos = true;
-        auth_info->got_pass = true;
+}
-/* This should only be used by lib/popt_common.c JRA */
-void set_cmdline_auth_info_smb_encrypt(struct user_auth_info *auth_info)
+{
-        auth_info->smb_encrypt = true;
+}
-void set_cmdline_auth_info_use_machine_account(struct user_auth_info *auth_info)
+{
-        auth_info->use_machine_account = true;
+}
-bool get_cmdline_auth_info_got_pass(const struct user_auth_info *auth_info)
+{
-        return auth_info->got_pass;
+}
-bool get_cmdline_auth_info_smb_encrypt(const struct user_auth_info *auth_info)
+{
-        return auth_info->smb_encrypt;
+}
-bool get_cmdline_auth_info_use_machine_account(const struct user_auth_info *auth_info)
+{
-        return auth_info->use_machine_account;
+}
-struct user_auth_info *get_cmdline_auth_info_copy(TALLOC_CTX *mem_ctx,
-                                                  const struct user_auth_info *src)
+{
-        struct user_auth_info *result;
-        result = user_auth_info_init(mem_ctx);
-        if (result == NULL) {
-                return NULL;
+        }
-        *result = *src;
-        result->username = talloc_strdup(
-                result, get_cmdline_auth_info_username(src));
-        result->password = talloc_strdup(
-                result, get_cmdline_auth_info_password(src));
-        if ((result->username == NULL) || (result->password == NULL)) {
-                TALLOC_FREE(result);
-                return NULL;
+        }
-        return result;
+}
-bool set_cmdline_auth_info_machine_account_creds(struct user_auth_info *auth_info)
+{
-        char *pass = NULL;
-        char *account = NULL;
-        if (!get_cmdline_auth_info_use_machine_account(auth_info)) {
-                return false;
+        }
-        if (!secrets_init()) {
-                d_printf("ERROR: Unable to open secrets database\n");
-                return false;
+        }
-        if (asprintf(&account, "%s$@%s", global_myname(), lp_realm()) < 0) {
-                return false;
+        }
-        pass = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
-        if (!pass) {
-                d_printf("ERROR: Unable to fetch machine password for "
-                        "%s in domain %s\n",
-                        account, lp_workgroup());
-                SAFE_FREE(account);
-                return false;
+        }
-        set_cmdline_auth_info_username(auth_info, account);
-        set_cmdline_auth_info_password(auth_info, pass);
-        SAFE_FREE(account);
-        SAFE_FREE(pass);
-        return true;
+}
-/****************************************************************************
- Ensure we have a password if one not given.
-****************************************************************************/
-void set_cmdline_auth_info_getpass(struct user_auth_info *auth_info)
+{
-        char *label = NULL;
-        char *pass;
-        TALLOC_CTX *frame;
-        if (get_cmdline_auth_info_got_pass(auth_info) ||
-                        get_cmdline_auth_info_use_kerberos(auth_info)) {
-                /* Already got one... */
-                return;
+        }
-        frame = talloc_stackframe();
-        label = talloc_asprintf(frame, "Enter %s's password: ",
-                        get_cmdline_auth_info_username(auth_info));
-        pass = getpass(label);
-        if (pass) {
-                set_cmdline_auth_info_password(auth_info, pass);
+        }
-        TALLOC_FREE(frame);
+}
 …
         attrstr[0] = 0;
         if (mode & aVOLID) fstrcat(attrstr,"V");
         if (mode & aDIR) fstrcat(attrstr,"D");
         if (mode & aARCH) fstrcat(attrstr,"A");
         if (mode & aHIDDEN) fstrcat(attrstr,"H");
         if (mode & aSYSTEM) fstrcat(attrstr,"S");
         if (mode & aRONLY) fstrcat(attrstr,"R");
+        if (mode & FILE_ATTRIBUTE_VOLUME) fstrcat(attrstr,"V");
+        if (mode & FILE_ATTRIBUTE_DIRECTORY) fstrcat(attrstr,"D");
+        if (mode & FILE_ATTRIBUTE_ARCHIVE) fstrcat(attrstr,"A");
+        if (mode & FILE_ATTRIBUTE_HIDDEN) fstrcat(attrstr,"H");
+        if (mode & FILE_ATTRIBUTE_SYSTEM) fstrcat(attrstr,"S");
+        if (mode & FILE_ATTRIBUTE_READONLY) fstrcat(attrstr,"R");
         return talloc_strdup(talloc_tos(), attrstr);
 …
         if (!DEBUGLVL(5))
                 return;
         DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
                         smb_len(buf),
 …
                 DEBUGADD(5,("smb_vwv[%2d]=%5d (0x%X)\n",i,
                         SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
         bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
 …
+}
-/*******************************************************************
- Sleep for a specified number of milliseconds.
-********************************************************************/
-void smb_msleep(unsigned int t)
+{
-#if defined(HAVE_NANOSLEEP)
-        struct timespec tval;
-        int ret;
-        tval.tv_sec = t/1000;
-        tval.tv_nsec = 1000000*(t%1000);
-        do {
-                errno = 0;
-                ret = nanosleep(&tval, &tval);
-        } while (ret < 0 && errno == EINTR && (tval.tv_sec > 0 || tval.tv_nsec > 0));
-#else
-        unsigned int tdiff=0;
-        struct timeval tval,t1,t2;
-        fd_set fds;
-        GetTimeOfDay(&t1);
-        t2 = t1;
-        while (tdiff < t) {
-                tval.tv_sec = (t-tdiff)/1000;
-                tval.tv_usec = 1000*((t-tdiff)%1000);
-                /* Never wait for more than 1 sec. */
-                if (tval.tv_sec > 1) {
-                        tval.tv_sec = 1;
-                        tval.tv_usec = 0;
+                }
-                FD_ZERO(&fds);
-                errno = 0;
-                sys_select_intr(0,&fds,NULL,NULL,&tval);
-                GetTimeOfDay(&t2);
-                if (t2.tv_sec < t1.tv_sec) {
-                        /* Someone adjusted time... */
-                        t1 = t2;
+                }
-                tdiff = TvalDiff(&t1,&t2);
+        }
-#endif
+}
 NTSTATUS reinit_after_fork(struct messaging_context *msg_ctx,
+                       struct event_context *ev_ctx,
+                       bool parent_longlived)
+                           struct event_context *ev_ctx,
+                           struct server_id id,
+                           bool parent_longlived)
+{
         NTSTATUS status = NT_STATUS_OK;
 …
+        }
         if (ev_ctx) {
                 event_context_reinit(ev_ctx);
+        if (ev_ctx && tevent_re_initialise(ev_ctx) != 0) {
+                smb_panic(__location__ ": Failed to re-initialise event context");
+        }
 …
                  * fork
                  */
                 status = messaging_reinit(msg_ctx);
+                status = messaging_reinit(msg_ctx, id);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0,("messaging_reinit() failed: %s\n",
 …
  done:
         return status;
+}
-/****************************************************************************
- Put up a yes/no prompt.
-****************************************************************************/
-bool yesno(const char *p)
+{
-        char ans[20];
-        printf("%s",p);
-        if (!fgets(ans,sizeof(ans)-1,stdin))
-                return(False);
-        if (*ans == 'y' || *ans == 'Y')
-                return(True);
-        return(False);
+}
 …
         if (strequal(str,"CORE+"))
                 return(PROTOCOL_COREPLUS);
         DEBUG(0,("Unrecognised protocol level %s\n",str));
         return(def);
+}
 …
 #ifdef CLUSTER_SUPPORT
         return ctdbd_process_exists(messaging_ctdbd_connection(), pid.vnn,
                                     pid.pid);
+        return ctdbd_process_exists(messaging_ctdbd_connection(),
+                                    pid.vnn, pid.pid);
 #else
         return False;
 …
         uid_t u;
         pass = Get_Pwnam_alloc(talloc_autofree_context(), name);
+        pass = Get_Pwnam_alloc(talloc_tos(), name);
         if (pass) {
                 u = pass->pw_uid;
 …
         DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
                   (unsigned long)backtrace_size));
         if (backtrace_strings) {
                 int i;
 …
         if (!p)
                 return(NULL);
         ptr = (SMB_STRUCT_DIRENT *)sys_readdir(p);
         if (!ptr)
 …
  if possible.
 ********************************************************************/
 void set_namearray(name_compare_entry **ppname_array, const char *namelist)
+{
 …
                 i++;
+        }
         (*ppname_array)[i].name = NULL;
 …
         *pcount = lock.l_len;
         *ppid = lock.l_pid;
         DEBUG(3,("fcntl_getlock: fd %d is returned info %d pid %u\n",
                         fd, (int)lock.l_type, (unsigned int)lock.l_pid));
 …
                 remote_arch_str = "CIFSFS";
                 break;
+        case RA_OSX:
+                remote_arch_str = "OSX";
+                break;
         default:
                 ra_type = RA_UNKNOWN;
 …
+{
         TDB_DATA key = string_tdb_data(s);
         return jenkins_hash(&key);
+        return tdb_jenkins_hash(&key);
+}
 …
         static char *ret;
         if (ret == NULL) {
+                /* This is cached forever so
+                 * use talloc_autofree_context() ctx. */
+                ret = get_myname(talloc_autofree_context());
+                ret = get_myname(NULL);
+        }
         return ret;
 …
         char *p;
         ptrdiff_t len;
         p = strrchr_m(dir, '/'); /* Find final '/', if any */
 …
 bool mask_match(const char *string, const char *pattern, bool is_case_sensitive)
+{
         if (strcmp(string,"..") == 0)
+        if (ISDOTDOT(string))
                 string = ".";
         if (strcmp(pattern,".") == 0)
+        if (ISDOT(pattern))
                 return False;
         return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
+}
 …
 bool mask_match_search(const char *string, const char *pattern, bool is_case_sensitive)
+{
         if (strcmp(string,"..") == 0)
+        if (ISDOTDOT(string))
                 string = ".";
         if (strcmp(pattern,".") == 0)
+        if (ISDOT(pattern))
                 return False;
         return ms_fnmatch(pattern, string, True, is_case_sensitive) == 0;
+}
 …
+}
+static uint64_t my_unique_id = 0;
+void set_my_unique_id(uint64_t unique_id)
+{
+        my_unique_id = unique_id;
+}
 struct server_id pid_to_procid(pid_t pid)
+{
         struct server_id result;
         result.pid = pid;
+#ifdef CLUSTER_SUPPORT
+        result.unique_id = my_unique_id;
         result.vnn = my_vnn;
-#endif
         return result;
+}
 …
+{
         return pid_to_procid(sys_getpid());
+}
-struct server_id server_id_self(void)
+{
-        return procid_self();
+}
 …
         if (p1->pid != p2->pid)
                 return False;
-#ifdef CLUSTER_SUPPORT
         if (p1->vnn != p2->vnn)
                 return False;
-#endif
         return True;
+}
 …
         if (pid->pid != sys_getpid())
                 return False;
-#ifdef CLUSTER_SUPPORT
         if (pid->vnn != my_vnn)
                 return False;
-#endif
         return True;
+}
 …
         struct server_id result;
         int pid;
-#ifdef CLUSTER_SUPPORT
         unsigned int vnn;
         if (sscanf(pid_string, "%u:%d", &vnn, &pid) == 2) {
 …
                 result.pid = -1;
+        }
-#else
-        if (sscanf(pid_string, "%d", &pid) != 1) {
-                result.pid = -1;
-        } else {
-                result.pid = pid;
+        }
-#endif
         /* Assigning to result.pid may have overflowed
            Map negative pid to -1: i.e. error */
 …
                 result.pid = -1;
+        }
+        result.unique_id = 0;
         return result;
+}
 …
 char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
+{
-#ifdef CLUSTER_SUPPORT
         if (pid->vnn == NONCLUSTER_VNN) {
                 return talloc_asprintf(mem_ctx,
 …
                                         (int)pid->pid);
+        }
-#else
-        return talloc_asprintf(mem_ctx,
-                        "%d",
-                        (int)pid->pid);
-#endif
+}
 …
 bool procid_is_local(const struct server_id *pid)
+{
-#ifdef CLUSTER_SUPPORT
         return pid->vnn == my_vnn;
-#else
-        return True;
-#endif
+}
-int this_is_smp(void)
+{
-#if defined(HAVE_SYSCONF)
-#if defined(SYSCONF_SC_NPROC_ONLN)
-        return (sysconf(_SC_NPROC_ONLN) > 1) ? 1 : 0;
-#elif defined(SYSCONF_SC_NPROCESSORS_ONLN)
-        return (sysconf(_SC_NPROCESSORS_ONLN) > 1) ? 1 : 0;
-#else
-        return 0;
-#endif
-#else
-        return 0;
-#endif
+}
 …
 #endif
-bool is_valid_policy_hnd(const struct policy_handle *hnd)
+{
-        struct policy_handle tmp;
-        ZERO_STRUCT(tmp);
-        return (memcmp(&tmp, hnd, sizeof(tmp)) != 0);
+}
-bool policy_hnd_equal(const struct policy_handle *hnd1,
-                      const struct policy_handle *hnd2)
+{
-        if (!hnd1 || !hnd2) {
-                return false;
+        }
-        return (memcmp(hnd1, hnd2, sizeof(*hnd1)) == 0);
+}
 /****************************************************************
  strip off leading '\\' from a hostname
 …
         return ret;
+}
+bool any_nt_status_not_ok(NTSTATUS err1, NTSTATUS err2, NTSTATUS *result)
+{
+        if (!NT_STATUS_IS_OK(err1)) {
+                *result = err1;
+                return true;
+        }
+        if (!NT_STATUS_IS_OK(err2)) {
+                *result = err2;
+                return true;
+        }
+        return false;
+}
+int timeval_to_msec(struct timeval t)
+{
+        return t.tv_sec * 1000 + (t.tv_usec+999) / 1000;
+}
+/*******************************************************************
+ Check a given DOS pathname is valid for a share.
+********************************************************************/
+char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
+{
+        char *ptr = NULL;
+        if (!dos_pathname) {
+                return NULL;
+        }
+        ptr = talloc_strdup(ctx, dos_pathname);
+        if (!ptr) {
+                return NULL;
+        }
+        /* Convert any '\' paths to '/' */
+        unix_format(ptr);
+        ptr = unix_clean_name(ctx, ptr);
+        if (!ptr) {
+                return NULL;
+        }
+        /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
+        if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
+                ptr += 2;
+        /* Only absolute paths allowed. */
+        if (*ptr != '/')
+                return NULL;
+        return ptr;
+}

trunk/server/source3/lib/util_nscd.c

-              r414
+              r745
 #include "includes.h"
+#ifdef HAVE_LIBNSCD
+#include <libnscd.h>
+#endif
 static void smb_nscd_flush_cache(const char *service)
+{

trunk/server/source3/lib/util_nttoken.c

-              r414
+              r745
 #include "includes.h"
+#include "../libcli/security/security.h"
 /****************************************************************************
 …
 ****************************************************************************/
 NT_USER_TOKEN *dup_nt_token(TALLOC_CTX *mem_ctx, const NT_USER_TOKEN *ptoken)
+struct security_token *dup_nt_token(TALLOC_CTX *mem_ctx, const struct security_token *ptoken)
+{
         NT_USER_TOKEN *token;
+        struct security_token *token;
         if (!ptoken)
                 return NULL;
         token = TALLOC_ZERO_P(mem_ctx, NT_USER_TOKEN);
+        token = TALLOC_ZERO_P(mem_ctx, struct security_token);
         if (token == NULL) {
                 DEBUG(0, ("talloc failed\n"));
 …
+        }
         if (ptoken->user_sids && ptoken->num_sids) {
                 token->user_sids = (DOM_SID *)talloc_memdup(
                         token, ptoken->user_sids, sizeof(DOM_SID) * ptoken->num_sids );
+        if (ptoken->sids && ptoken->num_sids) {
+                token->sids = (struct dom_sid *)talloc_memdup(
+                        token, ptoken->sids, sizeof(struct dom_sid) * ptoken->num_sids );
                 if (token->user_sids == NULL) {
+                if (token->sids == NULL) {
                         DEBUG(0, ("talloc_memdup failed\n"));
                         TALLOC_FREE(token);
 …
+        }
+        /* copy the privileges; don't consider failure to be critical here */
+        if ( !se_priv_copy( &token->privileges, &ptoken->privileges ) ) {
+                DEBUG(0,("dup_nt_token: Failure to copy SE_PRIV!.  "
+                         "Continuing with 0 privileges assigned.\n"));
+        }
+        token->privilege_mask = ptoken->privilege_mask;
+        token->rights_mask = ptoken->rights_mask;
         return token;
 …
 NTSTATUS merge_nt_token(TALLOC_CTX *mem_ctx,
                         const struct nt_user_token *token_1,
                         const struct nt_user_token *token_2,
                         struct nt_user_token **token_out)
+                        const struct security_token *token_1,
+                        const struct security_token *token_2,
+                        struct security_token **token_out)
+{
         struct nt_user_token *token = NULL;
+        struct security_token *token = NULL;
         NTSTATUS status;
         int i;
 …
+        }
         token = TALLOC_ZERO_P(mem_ctx, struct nt_user_token);
+        token = TALLOC_ZERO_P(mem_ctx, struct security_token);
         NT_STATUS_HAVE_NO_MEMORY(token);
         for (i=0; i < token_1->num_sids; i++) {
                 status = add_sid_to_array_unique(mem_ctx,
                                                  &token_1->user_sids[i],
                                                  &token->user_sids,
+                                                 &token_1->sids[i],
+                                                 &token->sids,
                                                  &token->num_sids);
                 if (!NT_STATUS_IS_OK(status)) {
 …
         for (i=0; i < token_2->num_sids; i++) {
                 status = add_sid_to_array_unique(mem_ctx,
                                                  &token_2->user_sids[i],
                                                  &token->user_sids,
+                                                 &token_2->sids[i],
+                                                 &token->sids,
                                                  &token->num_sids);
                 if (!NT_STATUS_IS_OK(status)) {
 …
+        }
+        se_priv_add(&token->privileges, &token_1->privileges);
+        se_priv_add(&token->privileges, &token_2->privileges);
+        token->privilege_mask |= token_1->privilege_mask;
+        token->privilege_mask |= token_2->privilege_mask;
+        token->rights_mask |= token_1->rights_mask;
+        token->rights_mask |= token_2->rights_mask;
         *token_out = token;
 …
 /*******************************************************************
  Check if this ACE has a SID in common with the token.
+ Check if this struct security_ace has a SID in common with the token.
 ********************************************************************/
 bool token_sid_in_ace(const NT_USER_TOKEN *token, const struct security_ace *ace)
+bool token_sid_in_ace(const struct security_token *token, const struct security_ace *ace)
+{
         size_t i;
         for (i = 0; i < token->num_sids; i++) {
                 if (sid_equal(&ace->trustee, &token->user_sids[i]))
+                if (dom_sid_equal(&ace->trustee, &token->sids[i]))
                         return true;
+        }

trunk/server/source3/lib/util_sid.c

-              r583
+              r745
    Copyright (C) Simo Sorce                     2002
    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
    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/>.
 …
 #include "includes.h"
+/*
+ * Some useful sids, more well known sids can be found at
+ * http://support.microsoft.com/kb/243330/EN-US/
+ */
+const DOM_SID global_sid_World_Domain =               /* Everyone domain */
+{ 1, 0, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_World =                      /* Everyone */
+{ 1, 1, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Creator_Owner_Domain =       /* Creator Owner domain */
+{ 1, 0, {0,0,0,0,0,3}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_NT_Authority =                 /* NT Authority */
+{ 1, 0, {0,0,0,0,0,5}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_System =                       /* System */
+{ 1, 1, {0,0,0,0,0,5}, {18,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_NULL =                         /* NULL sid */
+{ 1, 1, {0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Authenticated_Users =  /* All authenticated rids */
+{ 1, 1, {0,0,0,0,0,5}, {11,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+#if 0
+/* for documentation */
+const DOM_SID global_sid_Restriced =                    /* Restriced Code */
+{ 1, 1, {0,0,0,0,0,5}, {12,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+#endif
+const DOM_SID global_sid_Network =                      /* Network rids */
+{ 1, 1, {0,0,0,0,0,5}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Creator_Owner =                /* Creator Owner */
+{ 1, 1, {0,0,0,0,0,3}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Creator_Group =                /* Creator Group */
+{ 1, 1, {0,0,0,0,0,3}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Anonymous =                    /* Anonymous login */
+{ 1, 1, {0,0,0,0,0,5}, {7,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin =                      /* Local well-known domain */
+{ 1, 1, {0,0,0,0,0,5}, {32,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Administrators =       /* Builtin administrators */
+{ 1, 2, {0,0,0,0,0,5}, {32,544,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Users =                /* Builtin users */
+{ 1, 2, {0,0,0,0,0,5}, {32,545,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Guests =               /* Builtin guest users */
+{ 1, 2, {0,0,0,0,0,5}, {32,546,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Power_Users =  /* Builtin power users */
+{ 1, 2, {0,0,0,0,0,5}, {32,547,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Account_Operators =    /* Builtin account operators */
+{ 1, 2, {0,0,0,0,0,5}, {32,548,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Server_Operators =     /* Builtin server operators */
+{ 1, 2, {0,0,0,0,0,5}, {32,549,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Print_Operators =      /* Builtin print operators */
+{ 1, 2, {0,0,0,0,0,5}, {32,550,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Backup_Operators =     /* Builtin backup operators */
+{ 1, 2, {0,0,0,0,0,5}, {32,551,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_Replicator =           /* Builtin replicator */
+{ 1, 2, {0,0,0,0,0,5}, {32,552,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Builtin_PreWin2kAccess =       /* Builtin pre win2k access */
+{ 1, 2, {0,0,0,0,0,5}, {32,554,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Unix_Users =                   /* Unmapped Unix users */
+{ 1, 1, {0,0,0,0,0,22}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const DOM_SID global_sid_Unix_Groups =                  /* Unmapped Unix groups */
+{ 1, 1, {0,0,0,0,0,22}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+/* Unused, left here for documentary purposes */
+#if 0
+#define SECURITY_NULL_SID_AUTHORITY    0
+#define SECURITY_WORLD_SID_AUTHORITY   1
+#define SECURITY_LOCAL_SID_AUTHORITY   2
+#define SECURITY_CREATOR_SID_AUTHORITY 3
+#define SECURITY_NT_AUTHORITY          5
+#endif
+/*
+ * An NT compatible anonymous token.
+ */
+static DOM_SID anon_sid_array[3] =
+{ { 1, 1, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}},
+  { 1, 1, {0,0,0,0,0,5}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}},
+  { 1, 1, {0,0,0,0,0,5}, {7,0,0,0,0,0,0,0,0,0,0,0,0,0,0}} };
+NT_USER_TOKEN anonymous_token = { 3, anon_sid_array, SE_NONE };
+static DOM_SID system_sid_array[1] =
+{ { 1, 1, {0,0,0,0,0,5}, {18,0,0,0,0,0,0,0,0,0,0,0,0,0,0}} };
+NT_USER_TOKEN system_token = { 1, system_sid_array, SE_ALL_PRIVS };
+/****************************************************************************
+ Lookup string names for SID types.
+****************************************************************************/
+static const struct {
+        enum lsa_SidType sid_type;
+        const char *string;
+} sid_name_type[] = {
+        {SID_NAME_USER, "User"},
+        {SID_NAME_DOM_GRP, "Domain Group"},
+        {SID_NAME_DOMAIN, "Domain"},
+        {SID_NAME_ALIAS, "Local Group"},
+        {SID_NAME_WKN_GRP, "Well-known Group"},
+        {SID_NAME_DELETED, "Deleted Account"},
+        {SID_NAME_INVALID, "Invalid Account"},
+        {SID_NAME_UNKNOWN, "UNKNOWN"},
+        {SID_NAME_COMPUTER, "Computer"},
+        {(enum lsa_SidType)0, NULL}
+};
+const char *sid_type_lookup(uint32 sid_type)
+{
+        int i = 0;
+        /* Look through list */
+        while(sid_name_type[i].sid_type != 0) {
+                if (sid_name_type[i].sid_type == sid_type)
+                        return sid_name_type[i].string;
+                i++;
+        }
+        /* Default return */
+        return "SID *TYPE* is INVALID";
+}
+/**************************************************************************
+ Create the SYSTEM token.
+***************************************************************************/
+NT_USER_TOKEN *get_system_token(void)
+{
+        return &system_token;
+}
+/******************************************************************
+ get the default domain/netbios name to be used when dealing
+ with our passdb list of accounts
+******************************************************************/
+const char *get_global_sam_name(void)
+{
+        if ((lp_server_role() == ROLE_DOMAIN_PDC) || (lp_server_role() == ROLE_DOMAIN_BDC)) {
+                return lp_workgroup();
+        }
+        return global_myname();
+}
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "../librpc/gen_ndr/netlogon.h"
+#include "../libcli/security/security.h"
 /*****************************************************************
 …
 *****************************************************************/
+char *sid_to_fstring(fstring sidstr_out, const DOM_SID *sid)
+{
+        char *str = sid_string_talloc(talloc_tos(), sid);
+        fstrcpy(sidstr_out, str);
+        TALLOC_FREE(str);
+char *sid_to_fstring(fstring sidstr_out, const struct dom_sid *sid)
+{
+        dom_sid_string_buf(sid, sidstr_out, sizeof(fstring));
         return sidstr_out;
+}
 /*****************************************************************
+ Essentially a renamed dom_sid_string from librpc/ndr with a
+ panic if it didn't work
+ This introduces a dependency on librpc/ndr/sid.o which can easily
+ be turned around if necessary
+*****************************************************************/
+char *sid_string_talloc(TALLOC_CTX *mem_ctx, const DOM_SID *sid)
+ Essentially a renamed dom_sid_string from
+ ../libcli/security/dom_sid.c with a panic if it didn't work.
+*****************************************************************/
+char *sid_string_talloc(TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
+{
         char *result = dom_sid_string(mem_ctx, sid);
 …
 *****************************************************************/
 char *sid_string_dbg(const DOM_SID *sid)
+char *sid_string_dbg(const struct dom_sid *sid)
+{
         return sid_string_talloc(talloc_tos(), sid);
 …
 *****************************************************************/
 char *sid_string_tos(const DOM_SID *sid)
+char *sid_string_tos(const struct dom_sid *sid)
+{
         return sid_string_talloc(talloc_tos(), sid);
+}
-/*****************************************************************
- Convert a string to a SID. Returns True on success, False on fail.
-*****************************************************************/
-bool string_to_sid(DOM_SID *sidout, const char *sidstr)
+{
-        const char *p;
-        char *q;
-        /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
-        uint32 conv;
-        if ((sidstr[0] != 'S' && sidstr[0] != 's') || sidstr[1] != '-') {
-                DEBUG(3,("string_to_sid: Sid %s does not start with 'S-'.\n", sidstr));
-                return False;
+        }
-        ZERO_STRUCTP(sidout);
-        /* Get the revision number. */
-        p = sidstr + 2;
-        conv = (uint32) strtoul(p, &q, 10);
-        if (!q || (*q != '-')) {
-                DEBUG(3,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
-                return False;
+        }
-        sidout->sid_rev_num = (uint8) conv;
-        q++;
-        /* get identauth */
-        conv = (uint32) strtoul(q, &q, 10);
-        if (!q || (*q != '-')) {
-                DEBUG(0,("string_to_sid: Sid %s is not in a valid format.\n", sidstr));
-                return False;
+        }
-        /* identauth in decimal should be <  2^32 */
-        /* NOTE - the conv value is in big-endian format. */
-        sidout->id_auth[0] = 0;
-        sidout->id_auth[1] = 0;
-        sidout->id_auth[2] = (conv & 0xff000000) >> 24;
-        sidout->id_auth[3] = (conv & 0x00ff0000) >> 16;
-        sidout->id_auth[4] = (conv & 0x0000ff00) >> 8;
-        sidout->id_auth[5] = (conv & 0x000000ff);
-        q++;
-        sidout->num_auths = 0;
-        for(conv = (uint32) strtoul(q, &q, 10);
-            q && (*q =='-' || *q =='\0') && (sidout->num_auths < MAXSUBAUTHS);
-            conv = (uint32) strtoul(q, &q, 10)) {
-                sid_append_rid(sidout, conv);
-                if (*q == '\0')
-                        break;
-                q++;
+        }
-        return True;
+}
-DOM_SID *string_sid_talloc(TALLOC_CTX *mem_ctx, const char *sidstr)
+{
-        DOM_SID *result = TALLOC_P(mem_ctx, DOM_SID);
-        if (result == NULL)
-                return NULL;
-        if (!string_to_sid(result, sidstr))
-                return NULL;
-        return result;
+}
-/*****************************************************************
- Add a rid to the end of a sid
-*****************************************************************/
-bool sid_append_rid(DOM_SID *sid, uint32 rid)
+{
-        if (sid->num_auths < MAXSUBAUTHS) {
-                sid->sub_auths[sid->num_auths++] = rid;
-                return True;
+        }
-        return False;
+}
-bool sid_compose(DOM_SID *dst, const DOM_SID *domain_sid, uint32 rid)
+{
-        sid_copy(dst, domain_sid);
-        return sid_append_rid(dst, rid);
+}
-/*****************************************************************
- Removes the last rid from the end of a sid
-*****************************************************************/
-bool sid_split_rid(DOM_SID *sid, uint32 *rid)
+{
-        if (sid->num_auths > 0) {
-                sid->num_auths--;
-                *rid = sid->sub_auths[sid->num_auths];
-                return True;
+        }
-        return False;
+}
-/*****************************************************************
- Return the last rid from the end of a sid
-*****************************************************************/
-bool sid_peek_rid(const DOM_SID *sid, uint32 *rid)
+{
-        if (!sid || !rid)
-                return False;
-        if (sid->num_auths > 0) {
-                *rid = sid->sub_auths[sid->num_auths - 1];
-                return True;
+        }
-        return False;
+}
-/*****************************************************************
- Return the last rid from the end of a sid
- and check the sid against the exp_dom_sid
-*****************************************************************/
-bool sid_peek_check_rid(const DOM_SID *exp_dom_sid, const DOM_SID *sid, uint32 *rid)
+{
-        if (!exp_dom_sid || !sid || !rid)
-                return False;
-        if (sid->num_auths != (exp_dom_sid->num_auths+1)) {
-                return False;
+        }
-        if (sid_compare_domain(exp_dom_sid, sid)!=0){
-                *rid=(-1);
-                return False;
+        }
-        return sid_peek_rid(sid, rid);
+}
-/*****************************************************************
- Copies a sid
-*****************************************************************/
-void sid_copy(DOM_SID *dst, const DOM_SID *src)
+{
-        int i;
-        ZERO_STRUCTP(dst);
-        dst->sid_rev_num = src->sid_rev_num;
-        dst->num_auths = src->num_auths;
-        memcpy(&dst->id_auth[0], &src->id_auth[0], sizeof(src->id_auth));
-        for (i = 0; i < src->num_auths; i++)
-                dst->sub_auths[i] = src->sub_auths[i];
+}
 …
 *****************************************************************/
 bool sid_linearize(char *outbuf, size_t len, const DOM_SID *sid)
+bool sid_linearize(char *outbuf, size_t len, const struct dom_sid *sid)
+{
         size_t i;
         if (len < ndr_size_dom_sid(sid, NULL, 0))
+        if (len < ndr_size_dom_sid(sid, 0))
                 return False;
 …
 /*****************************************************************
- Parse a on-the-wire SID to a DOM_SID.
-*****************************************************************/
-bool sid_parse(const char *inbuf, size_t len, DOM_SID *sid)
+{
-        int i;
-        if (len < 8)
-                return False;
-        ZERO_STRUCTP(sid);
-        sid->sid_rev_num = CVAL(inbuf, 0);
-        sid->num_auths = CVAL(inbuf, 1);
-        if (sid->num_auths > MAXSUBAUTHS) {
-                return false;
+        }
-        memcpy(sid->id_auth, inbuf+2, 6);
-        if (len < 8 + sid->num_auths*4)
-                return False;
-        for (i=0;i<sid->num_auths;i++)
-                sid->sub_auths[i] = IVAL(inbuf, 8+i*4);
-        return True;
+}
-/*****************************************************************
- Compare the auth portion of two sids.
-*****************************************************************/
-static int sid_compare_auth(const DOM_SID *sid1, const DOM_SID *sid2)
+{
-        int i;
-        if (sid1 == sid2)
-                return 0;
-        if (!sid1)
-                return -1;
-        if (!sid2)
-                return 1;
-        if (sid1->sid_rev_num != sid2->sid_rev_num)
-                return sid1->sid_rev_num - sid2->sid_rev_num;
-        for (i = 0; i < 6; i++)
-                if (sid1->id_auth[i] != sid2->id_auth[i])
-                        return sid1->id_auth[i] - sid2->id_auth[i];
-        return 0;
+}
-/*****************************************************************
- Compare two sids.
-*****************************************************************/
-int sid_compare(const DOM_SID *sid1, const DOM_SID *sid2)
+{
-        int i;
-        if (sid1 == sid2)
-                return 0;
-        if (!sid1)
-                return -1;
-        if (!sid2)
-                return 1;
-        /* Compare most likely different rids, first: i.e start at end */
-        if (sid1->num_auths != sid2->num_auths)
-                return sid1->num_auths - sid2->num_auths;
-        for (i = sid1->num_auths-1; i >= 0; --i)
-                if (sid1->sub_auths[i] != sid2->sub_auths[i])
-                        return sid1->sub_auths[i] - sid2->sub_auths[i];
-        return sid_compare_auth(sid1, sid2);
+}
-/*****************************************************************
- See if 2 SIDs are in the same domain
- this just compares the leading sub-auths
-*****************************************************************/
-int sid_compare_domain(const DOM_SID *sid1, const DOM_SID *sid2)
+{
-        int n, i;
-        n = MIN(sid1->num_auths, sid2->num_auths);
-        for (i = n-1; i >= 0; --i)
-                if (sid1->sub_auths[i] != sid2->sub_auths[i])
-                        return sid1->sub_auths[i] - sid2->sub_auths[i];
-        return sid_compare_auth(sid1, sid2);
+}
-/*****************************************************************
- Compare two sids.
-*****************************************************************/
-bool sid_equal(const DOM_SID *sid1, const DOM_SID *sid2)
+{
-        return sid_compare(sid1, sid2) == 0;
+}
-/*****************************************************************
  Returns true if SID is internal (and non-mappable).
 *****************************************************************/
+bool non_mappable_sid(DOM_SID *sid)
+{
+        DOM_SID dom;
+        uint32 rid;
+bool non_mappable_sid(struct dom_sid *sid)
+{
+        struct dom_sid dom;
         sid_copy(&dom, sid);
         sid_split_rid(&dom, &rid);
         if (sid_equal(&dom, &global_sid_Builtin))
+        sid_split_rid(&dom, NULL);
+        if (dom_sid_equal(&dom, &global_sid_Builtin))
                 return True;
         if (sid_equal(&dom, &global_sid_NT_Authority))
+        if (dom_sid_equal(&dom, &global_sid_NT_Authority))
                 return True;
 …
 /*****************************************************************
  Return the binary string representation of a DOM_SID.
+ Return the binary string representation of a struct dom_sid.
  Caller must free.
 *****************************************************************/
+char *sid_binstring(TALLOC_CTX *mem_ctx, const DOM_SID *sid)
+{
+        uint8_t *buf;
+        char *s;
+        int len = ndr_size_dom_sid(sid, NULL, 0);
+        buf = talloc_array(mem_ctx, uint8_t, len);
+        if (!buf) {
+                return NULL;
+        }
+        sid_linearize((char *)buf, len, sid);
+        s = binary_string_rfc2254(mem_ctx, buf, len);
+        TALLOC_FREE(buf);
+        return s;
+}
+/*****************************************************************
+ Return the binary string representation of a DOM_SID.
+ Caller must free.
+*****************************************************************/
+char *sid_binstring_hex(const DOM_SID *sid)
+char *sid_binstring_hex(const struct dom_sid *sid)
+{
         char *buf, *s;
         int len = ndr_size_dom_sid(sid, NULL, 0);
+        int len = ndr_size_dom_sid(sid, 0);
         buf = (char *)SMB_MALLOC(len);
         if (!buf)
                 return NULL;
         sid_linearize(buf, len, sid);
         s = binary_string(buf, len);
+        hex_encode((const unsigned char *)buf, len, &s);
         free(buf);
         return s;
+}
-/*******************************************************************
- Tallocs a duplicate SID.
-********************************************************************/
-DOM_SID *sid_dup_talloc(TALLOC_CTX *ctx, const DOM_SID *src)
+{
-        DOM_SID *dst;
-        if(!src)
-                return NULL;
-        if((dst = TALLOC_ZERO_P(ctx, DOM_SID)) != NULL) {
-                sid_copy( dst, src);
+        }
-        return dst;
+}
-/********************************************************************
- Add SID to an array SIDs
-********************************************************************/
-NTSTATUS add_sid_to_array(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
-                          DOM_SID **sids, size_t *num)
+{
-        *sids = TALLOC_REALLOC_ARRAY(mem_ctx, *sids, DOM_SID,
-                                             (*num)+1);
-        if (*sids == NULL) {
-                *num = 0;
-                return NT_STATUS_NO_MEMORY;
+        }
-        sid_copy(&((*sids)[*num]), sid);
-        *num += 1;
-        return NT_STATUS_OK;
+}
-/********************************************************************
- Add SID to an array SIDs ensuring that it is not already there
-********************************************************************/
-NTSTATUS add_sid_to_array_unique(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
-                                 DOM_SID **sids, size_t *num_sids)
+{
-        size_t i;
-        for (i=0; i<(*num_sids); i++) {
-                if (sid_compare(sid, &(*sids)[i]) == 0)
-                        return NT_STATUS_OK;
+        }
-        return add_sid_to_array(mem_ctx, sid, sids, num_sids);
+}
-/********************************************************************
- Remove SID from an array
-********************************************************************/
-void del_sid_from_array(const DOM_SID *sid, DOM_SID **sids, size_t *num)
+{
-        DOM_SID *sid_list = *sids;
-        size_t i;
-        for ( i=0; i<*num; i++ ) {
-                /* if we find the SID, then decrement the count
-                   and break out of the loop */
-                if ( sid_equal(sid, &sid_list[i]) ) {
-                        *num -= 1;
-                        break;
+                }
+        }
-        /* This loop will copy the remainder of the array
-           if i < num of sids ni the array */
-        for ( ; i<*num; i++ )
-                sid_copy( &sid_list[i], &sid_list[i+1] );
-        return;
+}
-bool add_rid_to_array_unique(TALLOC_CTX *mem_ctx,
-                                    uint32 rid, uint32 **pp_rids, size_t *p_num)
+{
-        size_t i;
-        for (i=0; i<*p_num; i++) {
-                if ((*pp_rids)[i] == rid)
-                        return True;
+        }
-        *pp_rids = TALLOC_REALLOC_ARRAY(mem_ctx, *pp_rids, uint32, *p_num+1);
-        if (*pp_rids == NULL) {
-                *p_num = 0;
-                return False;
+        }
-        (*pp_rids)[*p_num] = rid;
-        *p_num += 1;
-        return True;
+}
-bool is_null_sid(const DOM_SID *sid)
+{
-        static const DOM_SID null_sid = {0};
-        return sid_equal(sid, &null_sid);
+}
-bool is_sid_in_token(const NT_USER_TOKEN *token, const DOM_SID *sid)
+{
-        int i;
-        for (i=0; i<token->num_sids; i++) {
-                if (sid_compare(sid, &token->user_sids[i]) == 0)
-                        return true;
+        }
-        return false;
+}
 NTSTATUS sid_array_from_info3(TALLOC_CTX *mem_ctx,
                               const struct netr_SamInfo3 *info3,
                               DOM_SID **user_sids,
                               size_t *num_user_sids,
+                              struct dom_sid **user_sids,
+                              uint32_t *num_user_sids,
                               bool include_user_group_rid,
                               bool skip_ressource_groups)
+{
         NTSTATUS status;
         DOM_SID sid;
         DOM_SID *sid_array = NULL;
         size_t num_sids = 0;
+        struct dom_sid sid;
+        struct dom_sid *sid_array = NULL;
+        uint32_t num_sids = 0;
         int i;

trunk/server/source3/lib/util_sock.c

-              r599
+              r745
 #include "includes.h"
+/****************************************************************************
+ Get a port number in host byte order from a sockaddr_storage.
+****************************************************************************/
+uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
+{
+        uint16_t port = 0;
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                /* IPv6 */
+                const struct sockaddr_in6 *sa6 =
+                        (const struct sockaddr_in6 *)pss;
+                port = ntohs(sa6->sin6_port);
+#endif
+        } else {
+                const struct sockaddr_in *sa =
+                        (const struct sockaddr_in *)pss;
+                port = ntohs(sa->sin_port);
+        }
+        return port;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+static char *print_sockaddr_len(char *dest,
+                        size_t destlen,
+                        const struct sockaddr *psa,
+                        socklen_t psalen)
+{
+        if (destlen > 0) {
+                dest[0] = '\0';
+        }
+        (void)sys_getnameinfo(psa,
+                        psalen,
+                        dest, destlen,
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        return dest;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_sockaddr(char *dest,
+                        size_t destlen,
+                        const struct sockaddr_storage *psa)
+{
+        return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
+                        sizeof(struct sockaddr_storage));
+}
+/****************************************************************************
+ Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_canonical_sockaddr(TALLOC_CTX *ctx,
+                        const struct sockaddr_storage *pss)
+{
+        char addr[INET6_ADDRSTRLEN];
+        char *dest = NULL;
+        int ret;
+        /* Linux getnameinfo() man pages says port is unitialized if
+           service name is NULL. */
+        ret = sys_getnameinfo((const struct sockaddr *)pss,
+                        sizeof(struct sockaddr_storage),
+                        addr, sizeof(addr),
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        if (ret != 0) {
+                return NULL;
+        }
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                dest = talloc_asprintf(ctx, "[%s]", addr);
+#else
+                return NULL;
+#endif
+        } else {
+                dest = talloc_asprintf(ctx, "%s", addr);
+        }
+        return dest;
+}
+/****************************************************************************
+ Return the string of an IP address (IPv4 or IPv6).
+****************************************************************************/
+static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        /* Ok, returning a hard coded IPv4 address
+         * is bogus, but it's just as bogus as a
+         * zero IPv6 address. No good choice here.
+         */
+        strlcpy(addr_buf, "0.0.0.0", addr_len);
+        if (fd == -1) {
+                return addr_buf;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                DEBUG(0,("getsockname failed. Error was %s\n",
+                        strerror(errno) ));
+                return addr_buf;
+        }
+        return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
+}
+/****************************************************************************
+ Return the port number we've bound to on a socket.
+****************************************************************************/
+int get_socket_port(int fd)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        if (fd == -1) {
+                return -1;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                DEBUG(0,("getpeername failed. Error was %s\n",
+                        strerror(errno) ));
+                return -1;
+        }
+#if defined(HAVE_IPV6)
+        if (sa.ss_family == AF_INET6) {
+                return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
+        }
+#endif
+        if (sa.ss_family == AF_INET) {
+                return ntohs(((struct sockaddr_in *)&sa)->sin_port);
+        }
+        return -1;
+}
+#include "system/filesys.h"
+#include "memcache.h"
+#include "../lib/async_req/async_sock.h"
+#include "../lib/util/select.h"
+#include "interfaces.h"
+#include "../lib/util/tevent_unix.h"
+#include "../lib/util/tevent_ntstatus.h"
 const char *client_name(int fd)
 …
+{
         return get_peer_addr(fd,addr,addrlen);
+}
-const char *client_socket_addr(int fd, char *addr, size_t addr_len)
+{
-        return get_socket_addr(fd, addr, addr_len);
+}
 …
 #ifdef TCP_QUICKACK
   {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
+#endif
+#ifdef TCP_KEEPALIVE_THRESHOLD
+  {"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
+#endif
+#ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
+  {"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
 #endif
   {NULL,0,0,0,0}};
 …
                                   size_t *size_ret)
+{
+        fd_set fds;
+        int selrtn;
+        int pollrtn;
         ssize_t readret;
         size_t nread = 0;
-        struct timeval timeout;
-        char addr[INET6_ADDRSTRLEN];
-        int save_errno;
         /* just checking .... */
 …
                         if (readret == -1) {
+                                save_errno = errno;
+                                if (fd == get_client_fd()) {
+                                        /* Try and give an error message
+                                         * saying what client failed. */
+                                        DEBUG(0,("read_fd_with_timeout: "
+                                                "client %s read error = %s.\n",
+                                                get_peer_addr(fd,addr,sizeof(addr)),
+                                                strerror(save_errno) ));
+                                } else {
+                                        DEBUG(0,("read_fd_with_timeout: "
+                                                "read error = %s.\n",
+                                                strerror(save_errno) ));
+                                }
+                                return map_nt_error_from_unix(save_errno);
+                                return map_nt_error_from_unix(errno);
+                        }
                         nread += readret;
 …
            select always returns true on disk files */
-        /* Set initial timeout */
-        timeout.tv_sec = (time_t)(time_out / 1000);
-        timeout.tv_usec = (long)(1000 * (time_out % 1000));
         for (nread=0; nread < mincnt; ) {
+                if (fd < 0 || fd >= FD_SETSIZE) {
+                        errno = EBADF;
+                        return map_nt_error_from_unix(EBADF);
+                }
+                FD_ZERO(&fds);
+                FD_SET(fd,&fds);
+                selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
+                int revents;
+                pollrtn = poll_intr_one_fd(fd, POLLIN|POLLHUP, time_out,
+                                           &revents);
                 /* Check if error */
+                if (selrtn == -1) {
+                        save_errno = errno;
+                        /* something is wrong. Maybe the socket is dead? */
+                        if (fd == get_client_fd()) {
+                                /* Try and give an error message saying
+                                 * what client failed. */
+                                DEBUG(0,("read_fd_with_timeout: timeout "
+                                "read for client %s. select error = %s.\n",
+                                get_peer_addr(fd,addr,sizeof(addr)),
+                                strerror(save_errno) ));
+                        } else {
+                                DEBUG(0,("read_fd_with_timeout: timeout "
+                                "read. select error = %s.\n",
+                                strerror(save_errno) ));
+                        }
+                        return map_nt_error_from_unix(save_errno);
+                if (pollrtn == -1) {
+                        return map_nt_error_from_unix(errno);
+                }
                 /* Did we timeout ? */
+                if (selrtn == 0) {
+                if ((pollrtn == 0) ||
+                    ((revents & (POLLIN|POLLHUP|POLLERR)) == 0)) {
                         DEBUG(10,("read_fd_with_timeout: timeout read. "
                                 "select timed out.\n"));
 …
                 if (readret == -1) {
-                        save_errno = errno;
-                        /* the descriptor is probably dead */
-                        if (fd == get_client_fd()) {
-                                /* Try and give an error message
-                                 * saying what client failed. */
-                                DEBUG(0,("read_fd_with_timeout: timeout "
-                                        "read to client %s. read error = %s.\n",
-                                        get_peer_addr(fd,addr,sizeof(addr)),
-                                        strerror(save_errno) ));
-                        } else {
-                                DEBUG(0,("read_fd_with_timeout: timeout "
-                                        "read. read error = %s.\n",
-                                        strerror(save_errno) ));
+                        }
                         return map_nt_error_from_unix(errno);
+                }
 …
 ssize_t write_data(int fd, const char *buffer, size_t N)
+{
-        ssize_t ret;
         struct iovec iov;
         iov.iov_base = CONST_DISCARD(void *, buffer);
         iov.iov_len = N;
+        ret = write_data_iov(fd, &iov, 1);
+        if (ret >= 0) {
+                return ret;
+        }
+        if (fd == get_client_fd()) {
+                char addr[INET6_ADDRSTRLEN];
+                /*
+                 * Try and give an error message saying what client failed.
+                 */
+                DEBUG(0, ("write_data: write failure in writing to client %s. "
+                          "Error %s\n", get_peer_addr(fd,addr,sizeof(addr)),
+                          strerror(errno)));
+        } else {
+                DEBUG(0,("write_data: write failure. Error = %s\n",
+                         strerror(errno) ));
+        }
+        return -1;
+        return write_data_iov(fd, &iov, 1);
+}
 …
         DEBUG(10,("got smb length of %lu\n",(unsigned long)(*len)));
-        return NT_STATUS_OK;
+}
-/****************************************************************************
- Read 4 bytes of a smb packet and return the smb length of the packet.
- Store the result in the buffer. This version of the function will
- never return a session keepalive (length of zero).
- Timeout is in milliseconds.
-****************************************************************************/
-NTSTATUS read_smb_length(int fd, char *inbuf, unsigned int timeout,
-                         size_t *len)
+{
-        uint8_t msgtype = SMBkeepalive;
-        while (msgtype == SMBkeepalive) {
-                NTSTATUS status;
-                status = read_smb_length_return_keepalive(fd, inbuf, timeout,
-                                                          len);
-                if (!NT_STATUS_IS_OK(status)) {
-                        return status;
+                }
-                msgtype = CVAL(inbuf, 0);
+        }
-        DEBUG(10,("read_smb_length: got smb length of %lu\n",
-                  (unsigned long)len));
         return NT_STATUS_OK;
 …
         if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("receive_smb_raw: %s!\n", nt_errstr(status)));
+                DEBUG(0, ("read_fd_with_timeout failed, read "
+                          "error = %s.\n", nt_errstr(status)));
                 return status;
+        }
 …
                 if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("read_fd_with_timeout failed, read error = "
+                                  "%s.\n", nt_errstr(status)));
                         return status;
+                }
 …
+        }
+#ifdef HAVE_IPV6
+        /*
+         * As IPV6_V6ONLY is the default on some systems,
+         * we better try to be consistent and always use it.
+         *
+         * This also avoids using IPv4 via AF_INET6 sockets
+         * and makes sure %I never resolves to a '::ffff:192.168.0.1'
+         * string.
+         */
+        if (sock.ss_family == AF_INET6) {
+                int val = 1;
+                int ret;
+                ret = setsockopt(res, IPPROTO_IPV6, IPV6_V6ONLY,
+                                 (const void *)&val, sizeof(val));
+                if (ret == -1) {
+                        if(DEBUGLVL(0)) {
+                                dbgtext("open_socket_in(): IPV6_ONLY failed: ");
+                                dbgtext("%s\n", strerror(errno));
+                        }
+                        close(res);
+                        return -1;
+                }
+        }
+#endif
         /* now we've got a socket - we need to bind it */
         if (bind(res, (struct sockaddr *)&sock, slen) == -1 ) {
 …
+}
+/**
+* @brief open a socket
+*
+* @param pss a struct sockaddr_storage defining the address to connect to
+* @param port to connect to
+* @param timeout in MILLISECONDS
+* @param pfd file descriptor returned
+*
+* @return NTSTATUS code
+*/
 NTSTATUS open_socket_out(const struct sockaddr_storage *pss, uint16_t port,
                          int timeout, int *pfd)
 …
+}
-/*******************************************************************
- Create an outgoing TCP socket to the first addr that connects.
- This is for simultaneous connection attempts to port 445 and 139 of a host
- or for simultatneous connection attempts to multiple DCs at once.  We return
- a socket fd of the first successful connection.
- @param[in] addrs list of Internet addresses and ports to connect to
- @param[in] num_addrs number of address/port pairs in the addrs list
- @param[in] timeout time after which we stop waiting for a socket connection
-            to succeed, given in milliseconds
- @param[out] fd_index the entry in addrs which we successfully connected to
- @param[out] fd fd of the open and connected socket
- @return true on a successful connection, false if all connection attempts
-         failed or we timed out
-*******************************************************************/
-bool open_any_socket_out(struct sockaddr_storage *addrs, int num_addrs,
-                         int timeout, int *fd_index, int *fd)
+{
-        int i, resulting_index, res;
-        int *sockets;
-        bool good_connect;
-        fd_set r_fds, wr_fds;
-        struct timeval tv;
-        int maxfd;
-        int connect_loop = 10000; /* 10 milliseconds */
-        timeout *= 1000;        /* convert to microseconds */
-        sockets = SMB_MALLOC_ARRAY(int, num_addrs);
-        if (sockets == NULL)
-                return false;
-        resulting_index = -1;
-        for (i=0; i<num_addrs; i++)
-                sockets[i] = -1;
-        for (i=0; i<num_addrs; i++) {
-                sockets[i] = socket(addrs[i].ss_family, SOCK_STREAM, 0);
-                if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE)
-                        goto done;
-                set_blocking(sockets[i], false);
+        }
- connect_again:
-        good_connect = false;
-        for (i=0; i<num_addrs; i++) {
-                const struct sockaddr * a =
-                    (const struct sockaddr *)&(addrs[i]);
-                if (sockets[i] == -1)
-                        continue;
-                if (sys_connect(sockets[i], a) == 0) {
-                        /* Rather unlikely as we are non-blocking, but it
-                         * might actually happen. */
-                        resulting_index = i;
-                        goto done;
+                }
-                if (errno == EINPROGRESS || errno == EALREADY ||
-#ifdef EISCONN
-                        errno == EISCONN ||
-#endif
-                    errno == EAGAIN || errno == EINTR) {
-                        /* These are the error messages that something is
-                           progressing. */
-                        good_connect = true;
-                } else if (errno != 0) {
-                        /* There was a direct error */
-                        close(sockets[i]);
-                        sockets[i] = -1;
+                }
+        }
-        if (!good_connect) {
-                /* All of the connect's resulted in real error conditions */
-                goto done;
+        }
-        /* Lets see if any of the connect attempts succeeded */
-        maxfd = 0;
-        FD_ZERO(&wr_fds);
-        FD_ZERO(&r_fds);
-        for (i=0; i<num_addrs; i++) {
-                if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE) {
-                        /* This cannot happen - ignore if so. */
-                        continue;
+                }
-                FD_SET(sockets[i], &wr_fds);
-                FD_SET(sockets[i], &r_fds);
-                if (sockets[i]>maxfd)
-                        maxfd = sockets[i];
+        }
-        tv.tv_sec = 0;
-        tv.tv_usec = connect_loop;
-        res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
-        if (res < 0)
-                goto done;
-        if (res == 0)
-                goto next_round;
-        for (i=0; i<num_addrs; i++) {
-                if (sockets[i] < 0 || sockets[i] >= FD_SETSIZE) {
-                        /* This cannot happen - ignore if so. */
-                        continue;
+                }
-                /* Stevens, Network Programming says that if there's a
-                 * successful connect, the socket is only writable. Upon an
-                 * error, it's both readable and writable. */
-                if (FD_ISSET(sockets[i], &r_fds) &&
-                    FD_ISSET(sockets[i], &wr_fds)) {
-                        /* readable and writable, so it's an error */
-                        close(sockets[i]);
-                        sockets[i] = -1;
-                        continue;
+                }
-                if (!FD_ISSET(sockets[i], &r_fds) &&
-                    FD_ISSET(sockets[i], &wr_fds)) {
-                        /* Only writable, so it's connected */
-                        resulting_index = i;
-                        goto done;
+                }
+        }
- next_round:
-        timeout -= connect_loop;
-        if (timeout <= 0)
-                goto done;
-        connect_loop *= 1.5;
-        if (connect_loop > timeout)
-                connect_loop = timeout;
-        goto connect_again;
- done:
-        for (i=0; i<num_addrs; i++) {
-                if (i == resulting_index)
-                        continue;
-                if (sockets[i] >= 0)
-                        close(sockets[i]);
+        }
-        if (resulting_index >= 0) {
-                *fd_index = resulting_index;
-                *fd = sockets[*fd_index];
-                set_blocking(*fd, true);
+        }
-        free(sockets);
-        return (resulting_index >= 0);
+}
 /****************************************************************************
  Open a connected UDP socket to host on port
 …
         if (getpeername(fd, (struct sockaddr *)pss, plength) < 0) {
+                DEBUG(0,("getpeername failed. Error was %s\n",
+                                        strerror(errno) ));
+                int level = (errno == ENOTCONN) ? 2 : 0;
+                DEBUG(level, ("getpeername failed. Error was %s\n",
+                               strerror(errno)));
                 return addr_buf;
+        }
 …
 #ifdef __OS2__
         if (asprintf(&path, "\\socket\\samba\\%s\\%s", socket_dir, socket_name) == -1) {
 #else
+#else
         if (asprintf(&path, "%s/%s", socket_dir, socket_name) == -1) {
 #endif
 …
+        }
         if (is_zero_addr((struct sockaddr *)&ss) ||
+        if (is_zero_addr(&ss) ||
                 is_loopback_addr((struct sockaddr *)&ss)) {
                 return false;
 …
+        }
+        /* Maybe its an IP address? */
+        if (is_ipaddress(servername)) {
+                return is_my_ipaddr(servername);
+        }
         /* Handle possible CNAME records - convert to an IP addr. list. */
         if (!is_ipaddress(servername)) {
+        {
                 /* Use DNS to resolve the name, check all addresses. */
                 struct addrinfo *p = NULL;
 …
+        }
-        /* Maybe its an IP address? */
-        if (is_ipaddress(servername)) {
-                return is_my_ipaddr(servername);
+        }
         /* No match */
         return false;
 …
         return state->ret;
+}
+int poll_one_fd(int fd, int events, int timeout, int *revents)
+{
+        struct pollfd *fds;
+        int ret;
+        int saved_errno;
+        fds = TALLOC_ZERO_ARRAY(talloc_tos(), struct pollfd, 2);
+        if (fds == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        fds[0].fd = fd;
+        fds[0].events = events;
+        ret = sys_poll(fds, 1, timeout);
+        /*
+         * Assign whatever poll did, even in the ret<=0 case.
+         */
+        *revents = fds[0].revents;
+        saved_errno = errno;
+        TALLOC_FREE(fds);
+        errno = saved_errno;
+        return ret;
+}
+int poll_intr_one_fd(int fd, int events, int timeout, int *revents)
+{
+        struct pollfd pfd;
+        int ret;
+        pfd.fd = fd;
+        pfd.events = events;
+        ret = sys_poll_intr(&pfd, 1, timeout);
+        if (ret <= 0) {
+                *revents = 0;
+                return ret;
+        }
+        *revents = pfd.revents;
+        return 1;
+}

trunk/server/source3/lib/util_str.c

-              r599
+              r745
                 while (isspace((int)*psz2))
                         psz2++;
                 if (toupper_ascii(*psz1) != toupper_ascii(*psz2) ||
+                if (toupper_m(*psz1) != toupper_m(*psz2) ||
                                 *psz1 == '\0' || *psz2 == '\0')
                         break;
 …
                 for (i=0;i<li;i++) {
                         switch (insert[i]) {
-                        case '`':
-                        case '"':
-                        case '\'':
-                        case ';':
                         case '$':
                                 /* allow a trailing $
 …
                                         break;
+                                }
+                        case '`':
+                        case '"':
+                        case '\'':
+                        case ';':
                         case '%':
                         case '\r':
 …
         for (i=0;i<li;i++) {
                 switch (in[i]) {
-                        case '`':
-                        case '"':
-                        case '\'':
-                        case ';':
                         case '$':
                                 /* allow a trailing $
 …
                                         break;
+                                }
+                        case '`':
+                        case '"':
+                        case '\'':
+                        case ';':
                         case '%':
                         case '\r':
 …
         for (i=0;i<li;i++) {
                 switch (in[i]) {
-                        case '`':
-                        case '"':
-                        case '\'':
-                        case ';':
                         case '$':
                                 /* allow a trailing $
 …
                                         break;
+                                }
+                        case '`':
+                        case '"':
+                        case '\'':
+                        case ';':
                         case '%':
                         case '\r':
 …
         while (*s && !(((unsigned char)s[0]) & 0x80)) {
                 *s = tolower_ascii((unsigned char)*s);
+                *s = tolower_m((unsigned char)*s);
                 s++;
+        }
 …
  * Calculate the number of units (8 or 16-bit, depending on the
  * destination charset), that would be needed to convert the input
  * string which is expected to be in in CH_UNIX encoding to the
+ * string which is expected to be in in src_charset encoding to the
  * destination charset (which should be a unicode charset).
  */
+size_t strlen_m_ext(const char *s, const charset_t dst_charset)
+size_t strlen_m_ext(const char *s, const charset_t src_charset,
+                    const charset_t dst_charset)
+{
         size_t count = 0;
 …
         while (*s) {
                 size_t c_size;
                 codepoint_t c = next_codepoint(s, &c_size);
+                codepoint_t c = next_codepoint_ext(s, src_charset, &c_size);
                 s += c_size;
                 switch(dst_charset) {
+                switch (dst_charset) {
                 case CH_UTF16LE:
                 case CH_UTF16BE:
 …
+}
+size_t strlen_m_ext_term(const char *s, const charset_t dst_charset)
+size_t strlen_m_ext_term(const char *s, const charset_t src_charset,
+                         const charset_t dst_charset)
+{
         if (!s) {
                 return 0;
+        }
+        return strlen_m_ext(s, dst_charset) + 1;
+}
+/**
+ Count the number of UCS2 characters in a string. Normally this will
+ be the same as the number of bytes in a string for single byte strings,
+ but will be different for multibyte.
+**/
+        return strlen_m_ext(s, src_charset, dst_charset) + 1;
+}
+/**
+ * Calculate the number of 16-bit units that would bee needed to convert
+ * the input string which is expected to be in CH_UNIX encoding to UTF16.
+ *
+ * This will be the same as the number of bytes in a string for single
+ * byte strings, but will be different for multibyte.
+ */
 size_t strlen_m(const char *s)
+{
         return strlen_m_ext(s, CH_UTF16LE);
+        return strlen_m_ext(s, CH_UNIX, CH_UTF16LE);
+}
 …
         return len+1;
+}
-/**
- Return a RFC2254 binary string representation of a buffer.
- Used in LDAP filters.
- Caller must free.
-**/
-char *binary_string_rfc2254(TALLOC_CTX *mem_ctx, const uint8_t *buf, int len)
+{
-        char *s;
-        int i, j;
-        const char *hex = "0123456789ABCDEF";
-        s = talloc_array(mem_ctx, char, len * 3 + 1);
-        if (s == NULL) {
-                return NULL;
+        }
-        for (j=i=0;i<len;i++) {
-                s[j] = '\\';
-                s[j+1] = hex[((unsigned char)buf[i]) >> 4];
-                s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
-                j += 3;
+        }
-        s[j] = 0;
-        return s;
+}
-char *binary_string(char *buf, int len)
+{
-        char *s;
-        int i, j;
-        const char *hex = "0123456789ABCDEF";
-        s = (char *)SMB_MALLOC(len * 2 + 1);
-        if (!s)
-                return NULL;
-        for (j=i=0;i<len;i++) {
-                s[j]   = hex[((unsigned char)buf[i]) >> 4];
-                s[j+1] = hex[((unsigned char)buf[i]) & 0xF];
-                j += 2;
+        }
-        s[j] = 0;
-        return s;
+}
 …
+{
         uint64_t val = -1;
+        uint64_t val = (uint64_t)-1;
         const char *p = nptr;
 …
 SMB_OFF_T conv_str_size(const char * str)
+{
+        SMB_OFF_T lval_orig;
         SMB_OFF_T lval;
         char * end;
 …
 #ifdef HAVE_STRTOULL
         if (sizeof(SMB_OFF_T) == 8) {
             lval = strtoull(str, &end, 10 /* base */);
+                lval = strtoull(str, &end, 10 /* base */);
         } else {
             lval = strtoul(str, &end, 10 /* base */);
+                lval = strtoul(str, &end, 10 /* base */);
+        }
 #else
 …
+        }
+        if (*end) {
+                SMB_OFF_T lval_orig = lval;
+                if (strwicmp(end, "K") == 0) {
+                        lval *= (SMB_OFF_T)1024;
+                } else if (strwicmp(end, "M") == 0) {
+                        lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
+                } else if (strwicmp(end, "G") == 0) {
+                        lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                                (SMB_OFF_T)1024);
+                } else if (strwicmp(end, "T") == 0) {
+                        lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                                (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
+                } else if (strwicmp(end, "P") == 0) {
+                        lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                                (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                                (SMB_OFF_T)1024);
+                } else {
+                        return 0;
+                }
+                /* Primitive attempt to detect wrapping on platforms with
+                 * 4-byte SMB_OFF_T. It's better to let the caller handle
+                 * a failure than some random number.
+                 */
+                if (lval_orig <= lval) {
+                        return 0;
+                }
+        }
+        if (*end == '\0') {
+                return lval;
+        }
+        lval_orig = lval;
+        if (strwicmp(end, "K") == 0) {
+                lval *= (SMB_OFF_T)1024;
+        } else if (strwicmp(end, "M") == 0) {
+                lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
+        } else if (strwicmp(end, "G") == 0) {
+                lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                         (SMB_OFF_T)1024);
+        } else if (strwicmp(end, "T") == 0) {
+                lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                         (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
+        } else if (strwicmp(end, "P") == 0) {
+                lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                         (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
+                         (SMB_OFF_T)1024);
+        } else {
+                return 0;
+        }
+        /*
+         * Primitive attempt to detect wrapping on platforms with
+         * 4-byte SMB_OFF_T. It's better to let the caller handle a
+         * failure than some random number.
+         */
+        if (lval_orig <= lval) {
+                return 0;
+        }
         return lval;
 …
         if (*left == NULL) {
                 *left = (char *)SMB_MALLOC(new_len);
+                if (*left == NULL) {
+                        return;
+                }
                 *left[0] = '\0';
         } else {
 …
+{
         int i;
+        if (!name) {
+                return false;
+        }
         for ( i=0; i<max_len && name[i]; i++ ) {
 …
         return list;
+}
+char *sanitize_username(TALLOC_CTX *mem_ctx, const char *username)
+{
+        fstring tmp;
+        alpha_strcpy(tmp, username, ". _-$", sizeof(tmp));
+        return talloc_strdup(mem_ctx, tmp);
+}

trunk/server/source3/lib/util_tdb.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "util_tdb.h"
 #undef malloc
 #undef realloc
 …
 ****************************************************************/
 static void gotalarm_sig(void)
+static void gotalarm_sig(int signum)
+{
         gotalarm = 1;
 …
         if (timeout) {
                 CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
+                CatchSignal(SIGALRM, gotalarm_sig);
                 tdb_setalarm_sigptr(tdb, &gotalarm);
                 alarm(timeout);
 …
                 alarm(0);
                 tdb_setalarm_sigptr(tdb, NULL);
                 CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
+                CatchSignal(SIGALRM, SIG_IGN);
                 if (gotalarm && (ret == -1)) {
                         DEBUG(0,("tdb_chainlock_with_timeout_internal: alarm (%u) timed out for key %s in tdb %s\n",
 …
+}
-/*
- Log tdb messages via DEBUG().
-*/
-static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level,
-                         const char *format, ...) PRINTF_ATTRIBUTE(3,4);
-static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level,
-                         const char *format, ...)
+{
-        va_list ap;
-        char *ptr = NULL;
-        int debuglevel = 0;
-        int ret;
-        switch (level) {
-        case TDB_DEBUG_FATAL:
-                debuglevel = 0;
-                break;
-        case TDB_DEBUG_ERROR:
-                debuglevel = 1;
-                break;
-        case TDB_DEBUG_WARNING:
-                debuglevel = 2;
-                break;
-        case TDB_DEBUG_TRACE:
-                debuglevel = 5;
-                break;
-        default:
-                debuglevel = 0;
+        }
-        va_start(ap, format);
-        ret = vasprintf(&ptr, format, ap);
-        va_end(ap);
-        if (ret != -1) {
-                const char *name = tdb_name(tdb);
-                DEBUG(debuglevel, ("tdb(%s): %s", name ? name : "unnamed", ptr));
-                free(ptr);
+        }
+}
-static struct tdb_wrap *tdb_list;
-/* destroy the last connection to a tdb */
-static int tdb_wrap_destructor(struct tdb_wrap *w)
+{
-        tdb_close(w->tdb);
-        DLIST_REMOVE(tdb_list, w);
-        return 0;
+}
-/*
-  wrapped connection to a tdb database
-  to close just talloc_free() the tdb_wrap pointer
- */
-struct tdb_wrap *tdb_wrap_open(TALLOC_CTX *mem_ctx,
-                               const char *name, int hash_size, int tdb_flags,
-                               int open_flags, mode_t mode)
+{
-        struct tdb_wrap *w;
-        struct tdb_logging_context log_ctx;
-        log_ctx.log_fn = tdb_wrap_log;
-        if (!lp_use_mmap())
-                tdb_flags |= TDB_NOMMAP;
-        for (w=tdb_list;w;w=w->next) {
-                if (strcmp(name, w->name) == 0) {
-                        /*
-                         * Yes, talloc_reference is exactly what we want
-                         * here. Otherwise we would have to implement our own
-                         * reference counting.
-                         */
-                        return talloc_reference(mem_ctx, w);
+                }
+        }
-        w = talloc(mem_ctx, struct tdb_wrap);
-        if (w == NULL) {
-                return NULL;
+        }
-        if (!(w->name = talloc_strdup(w, name))) {
-                talloc_free(w);
-                return NULL;
+        }
-        if ((hash_size == 0) && (name != NULL)) {
-                const char *base = strrchr_m(name, '/');
-                if (base != NULL) {
-                        base += 1;
+                }
-                else {
-                        base = name;
+                }
-                hash_size = lp_parm_int(-1, "tdb_hashsize", base, 0);
+        }
-        w->tdb = tdb_open_ex(name, hash_size, tdb_flags,
-                             open_flags, mode, &log_ctx, NULL);
-        if (w->tdb == NULL) {
-                talloc_free(w);
-                return NULL;
+        }
-        talloc_set_destructor(w, tdb_wrap_destructor);
-        DLIST_ADD(tdb_list, w);
-        return w;
+}
 NTSTATUS map_nt_error_from_tdb(enum TDB_ERROR err)
+{
+        struct { enum TDB_ERROR err; NTSTATUS status; } map[] =
+                { { TDB_SUCCESS,        NT_STATUS_OK },
+                  { TDB_ERR_CORRUPT,    NT_STATUS_INTERNAL_DB_CORRUPTION },
+                  { TDB_ERR_IO,         NT_STATUS_UNEXPECTED_IO_ERROR },
+                  { TDB_ERR_OOM,        NT_STATUS_NO_MEMORY },
+                  { TDB_ERR_EXISTS,     NT_STATUS_OBJECT_NAME_COLLISION },
+                  /*
+                   * TDB_ERR_LOCK is very broad, we could for example
+                   * distinguish between fcntl locks and invalid lock
+                   * sequences. So NT_STATUS_FILE_LOCK_CONFLICT is a
+                   * compromise.
+                   */
+                  { TDB_ERR_LOCK,       NT_STATUS_FILE_LOCK_CONFLICT },
+                  /*
+                   * The next two ones in the enum are not actually used
+                   */
+                  { TDB_ERR_NOLOCK,     NT_STATUS_FILE_LOCK_CONFLICT },
+                  { TDB_ERR_LOCK_TIMEOUT, NT_STATUS_FILE_LOCK_CONFLICT },
+                  { TDB_ERR_NOEXIST,    NT_STATUS_NOT_FOUND },
+                  { TDB_ERR_EINVAL,     NT_STATUS_INVALID_PARAMETER },
+                  { TDB_ERR_RDONLY,     NT_STATUS_ACCESS_DENIED }
+                };
+        int i;
+        for (i=0; i < sizeof(map) / sizeof(map[0]); i++) {
+                if (err == map[i].err) {
+                        return map[i].status;
+                }
+        }
+        return NT_STATUS_INTERNAL_ERROR;
+        NTSTATUS result = NT_STATUS_INTERNAL_ERROR;
+        switch (err) {
+        case TDB_SUCCESS:
+                result = NT_STATUS_OK;
+                break;
+        case TDB_ERR_CORRUPT:
+                result = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                break;
+        case TDB_ERR_IO:
+                result = NT_STATUS_UNEXPECTED_IO_ERROR;
+                break;
+        case TDB_ERR_OOM:
+                result = NT_STATUS_NO_MEMORY;
+                break;
+        case TDB_ERR_EXISTS:
+                result = NT_STATUS_OBJECT_NAME_COLLISION;
+                break;
+        case TDB_ERR_LOCK:
+                /*
+                 * TDB_ERR_LOCK is very broad, we could for example
+                 * distinguish between fcntl locks and invalid lock
+                 * sequences. So NT_STATUS_FILE_LOCK_CONFLICT is a
+                 * compromise.
+                 */
+                result = NT_STATUS_FILE_LOCK_CONFLICT;
+                break;
+        case TDB_ERR_NOLOCK:
+        case TDB_ERR_LOCK_TIMEOUT:
+                /*
+                 * These two ones in the enum are not actually used
+                 */
+                result = NT_STATUS_FILE_LOCK_CONFLICT;
+                break;
+        case TDB_ERR_NOEXIST:
+                result = NT_STATUS_NOT_FOUND;
+                break;
+        case TDB_ERR_EINVAL:
+                result = NT_STATUS_INVALID_PARAMETER;
+                break;
+        case TDB_ERR_RDONLY:
+                result = NT_STATUS_ACCESS_DENIED;
+                break;
+        case TDB_ERR_NESTING:
+                result = NT_STATUS_INTERNAL_ERROR;
+                break;
+        };
+        return result;
+}

trunk/server/source3/lib/util_transfer_file.c

r414	r745
22	22
23	23	#include <includes.h>
	24	#include "transfer_file.h"
24	25
25	26	/****************************************************************************

trunk/server/source3/lib/util_tsock.c

-              r414
+              r745
 #include "includes.h"
+#include "../lib/tsocket/tsocket.h"
+#include "../lib/util/tevent_unix.h"
 struct tstream_read_packet_state {
 …
                 return tevent_req_post(req, ev);
+        }
         state->iov.iov_base = state->buf;
+        state->iov.iov_base = (void *)state->buf;
         state->iov.iov_len = initial;
 …
         state->buf = tmp;
         state->iov.iov_base = state->buf + total;
+        state->iov.iov_base = (void *)(state->buf + total);
         state->iov.iov_len = more;

trunk/server/source3/lib/util_unistr.c

-              r414
+              r745
 #include "includes.h"
-#ifndef MAXUNI
-#define MAXUNI 1024
-#endif
 /* these 3 tables define the unicode case handling.  They are loaded
    at startup either via mmap() or read() from the lib directory */
-static smb_ucs2_t *upcase_table;
-static smb_ucs2_t *lowcase_table;
 static uint8 *valid_table;
-static bool upcase_table_use_unmap;
-static bool lowcase_table_use_unmap;
-static bool valid_table_use_unmap;
 static bool initialized;
 …
 void gfree_case_tables(void)
+{
-        if ( upcase_table ) {
-                if ( upcase_table_use_unmap )
-                        unmap_file(upcase_table, 0x20000);
-                else
-                        SAFE_FREE(upcase_table);
+        }
-        if ( lowcase_table ) {
-                if ( lowcase_table_use_unmap )
-                        unmap_file(lowcase_table, 0x20000);
-                else
-                        SAFE_FREE(lowcase_table);
+        }
         if ( valid_table ) {
+                if ( valid_table_use_unmap )
+                        unmap_file(valid_table, 0x10000);
+                else
+                        SAFE_FREE(valid_table);
+                unmap_file(valid_table, 0x10000);
+                valid_table = NULL;
+        }
         initialized = false;
+}
-/**
- * Load or generate the case handling tables.
+ *
- * The case tables are defined in UCS2 and don't depend on any
- * configured parameters, so they never need to be reloaded.
- **/
-void load_case_tables(void)
+{
-        char *old_locale = NULL, *saved_locale = NULL;
-        int i;
-        TALLOC_CTX *frame = NULL;
-        if (initialized) {
-                return;
+        }
-        initialized = true;
-        frame = talloc_stackframe();
-        upcase_table = (smb_ucs2_t *)map_file(data_path("upcase.dat"),
-x20000);
-        upcase_table_use_unmap = ( upcase_table != NULL );
-        lowcase_table = (smb_ucs2_t *)map_file(data_path("lowcase.dat"),
-x20000);
-        lowcase_table_use_unmap = ( lowcase_table != NULL );
-#ifdef HAVE_SETLOCALE
-        /* Get the name of the current locale.  */
-        old_locale = setlocale(LC_ALL, NULL);
-        if (old_locale) {
-                /* Save it as it is in static storage. */
-                saved_locale = SMB_STRDUP(old_locale);
+        }
-        /* We set back the locale to C to get ASCII-compatible toupper/lower functions. */
-        setlocale(LC_ALL, "C");
-#endif
-        /* we would like Samba to limp along even if these tables are
-           not available */
-        if (!upcase_table) {
-                DEBUG(1,("creating lame upcase table\n"));
-                upcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
-                for (i=0;i<0x10000;i++) {
-                        smb_ucs2_t v;
-                        SSVAL(&v, 0, i);
-                        upcase_table[v] = i;
+                }
-                for (i=0;i<256;i++) {
-                        smb_ucs2_t v;
-                        SSVAL(&v, 0, UCS2_CHAR(i));
-                        upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
+                }
+        }
-        if (!lowcase_table) {
-                DEBUG(1,("creating lame lowcase table\n"));
-                lowcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
-                for (i=0;i<0x10000;i++) {
-                        smb_ucs2_t v;
-                        SSVAL(&v, 0, i);
-                        lowcase_table[v] = i;
+                }
-                for (i=0;i<256;i++) {
-                        smb_ucs2_t v;
-                        SSVAL(&v, 0, UCS2_CHAR(i));
-                        lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
+                }
+        }
-#ifdef HAVE_SETLOCALE
-        /* Restore the old locale. */
-        if (saved_locale) {
-                setlocale (LC_ALL, saved_locale);
-                SAFE_FREE(saved_locale);
+        }
-#endif
-        TALLOC_FREE(frame);
+}
-static int check_dos_char_slowly(smb_ucs2_t c)
+{
-        char buf[10];
-        smb_ucs2_t c2 = 0;
-        int len1, len2;
-        len1 = convert_string(CH_UTF16LE, CH_DOS, &c, 2, buf, sizeof(buf),False);
-        if (len1 == 0) {
-                return 0;
+        }
-        len2 = convert_string(CH_DOS, CH_UTF16LE, buf, len1, &c2, 2,False);
-        if (len2 != 2) {
-                return 0;
+        }
-        return (c == c2);
+}
 …
  **/
+void init_valid_table(void)
+{
+        static int mapped_file;
+        int i;
+        const char *allowed = ".!#$%&'()_-@^`~";
+        uint8 *valid_file;
+        if (mapped_file) {
+                /* Can't unmap files, so stick with what we have */
+static void init_valid_table(void)
+{
+        if (valid_table) {
                 return;
+        }
+        valid_file = (uint8 *)map_file(data_path("valid.dat"), 0x10000);
+        if (valid_file) {
+                valid_table = valid_file;
+                mapped_file = 1;
+                valid_table_use_unmap = True;
+        valid_table = (uint8 *)map_file(data_path("valid.dat"), 0x10000);
+        if (!valid_table) {
+                smb_panic("Could not load valid.dat file required for mangle method=hash");
                 return;
+        }
-        /* Otherwise, we're using a dynamically created valid_table.
-         * It might need to be regenerated if the code page changed.
-         * We know that we're not using a mapped file, so we can
-         * free() the old one. */
-        SAFE_FREE(valid_table);
-        /* use free rather than unmap */
-        valid_table_use_unmap = False;
-        DEBUG(2,("creating default valid table\n"));
-        valid_table = (uint8 *)SMB_MALLOC(0x10000);
-        SMB_ASSERT(valid_table != NULL);
-        for (i=0;i<128;i++) {
-                valid_table[i] = isalnum(i) || strchr(allowed,i);
+        }
-        lazy_initialize_conv();
-        for (;i<0x10000;i++) {
-                smb_ucs2_t c;
-                SSVAL(&c, 0, i);
-                valid_table[i] = check_dos_char_slowly(c);
+        }
+}
 …
+}
-/*******************************************************************
- Skip past a unicode string, but not more than len. Always move
- past a terminating zero if found.
-********************************************************************/
-char *skip_unibuf(char *src, size_t len)
+{
-        char *srcend = src + len;
-        while (src < srcend && SVAL(src,0)) {
-                src += 2;
+        }
-        if(!SVAL(src,0)) {
-                src += 2;
+        }
-        return src;
+}
 /* Converts a string from internal samba format to unicode
 …
 /*******************************************************************
- Convert a wchar to upper case.
-********************************************************************/
-smb_ucs2_t toupper_w(smb_ucs2_t val)
+{
-        return upcase_table[SVAL(&val,0)];
+}
-/*******************************************************************
- Convert a wchar to lower case.
-********************************************************************/
-smb_ucs2_t tolower_w( smb_ucs2_t val )
+{
-        return lowcase_table[SVAL(&val,0)];
+}
-/*******************************************************************
- Determine if a character is lowercase.
-********************************************************************/
-bool islower_w(smb_ucs2_t c)
+{
-        return upcase_table[SVAL(&c,0)] != c;
+}
-/*******************************************************************
- Determine if a character is uppercase.
-********************************************************************/
-bool isupper_w(smb_ucs2_t c)
+{
-        return lowcase_table[SVAL(&c,0)] != c;
+}
-/*******************************************************************
  Determine if a character is valid in a 8.3 name.
 ********************************************************************/
 …
 bool isvalid83_w(smb_ucs2_t c)
+{
+        init_valid_table();
         return valid_table[SVAL(&c,0)] != 0;
+}
 …
  Convert a string to lower case.
  return True if any char is converted
+ This is unsafe for any string involving a UTF16 character
 ********************************************************************/
 …
  Convert a string to upper case.
  return True if any char is converted
+ This is unsafe for any string involving a UTF16 character
 ********************************************************************/
 …
+}
+/*************************************************************
+ ascii only toupper - saves the need for smbd to be in C locale.
+*************************************************************/
+int toupper_ascii(int c)
+{
+        smb_ucs2_t uc = toupper_w(UCS2_CHAR(c));
+        return UCS2_TO_CHAR(uc);
+}
+/*************************************************************
+ ascii only tolower - saves the need for smbd to be in C locale.
+*************************************************************/
+int tolower_ascii(int c)
+{
+        smb_ucs2_t uc = tolower_w(UCS2_CHAR(c));
+        return UCS2_TO_CHAR(uc);
+}
+/*************************************************************
+ ascii only isupper - saves the need for smbd to be in C locale.
+*************************************************************/
+int isupper_ascii(int c)
+{
+        return isupper_w(UCS2_CHAR(c));
+}
+/*************************************************************
+ ascii only islower - saves the need for smbd to be in C locale.
+*************************************************************/
+int islower_ascii(int c)
+{
+        return islower_w(UCS2_CHAR(c));
+}
+smb_ucs2_t toupper_w(smb_ucs2_t v)
+{
+        smb_ucs2_t ret;
+        /* LE to native. */
+        codepoint_t cp = SVAL(&v,0);
+        cp = toupper_m(cp);
+        /* native to LE. */
+        SSVAL(&ret,0,cp);
+        return ret;
+}
+bool isupper_w(smb_ucs2_t v)
+{
+        codepoint_t cp = SVAL(&v,0);
+        return isupper_m(cp);
+}
+smb_ucs2_t tolower_w(smb_ucs2_t v)
+{
+        smb_ucs2_t ret;
+        /* LE to native. */
+        codepoint_t cp = SVAL(&v,0);
+        cp = tolower_m(cp);
+        /* native to LE. */
+        SSVAL(&ret,0,cp);
+        return ret;
+}
+bool islower_w(smb_ucs2_t v)
+{
+        codepoint_t cp = SVAL(&v,0);
+        return islower_m(cp);
+}

trunk/server/source3/lib/winbind_util.c

-              r414
+              r745
 #include "includes.h"
+#include "../libcli/security/security.h"
+#include "../lib/util/util_pw.h"
+#include "nsswitch/libwbclient/wbclient.h"
 #if defined(WITH_WINBIND)
 #include "nsswitch/libwbclient/wbclient.h"
+#include "lib/winbind_util.h"
 struct passwd * winbind_getpwnam(const char * name)
 …
+}
 struct passwd * winbind_getpwsid(const DOM_SID *sid)
+struct passwd * winbind_getpwsid(const struct dom_sid *sid)
+{
         wbcErr result;
 …
 /* Call winbindd to convert a name to a sid */
 bool winbind_lookup_name(const char *dom_name, const char *name, DOM_SID *sid,
+bool winbind_lookup_name(const char *dom_name, const char *name, struct dom_sid *sid,
                          enum lsa_SidType *name_type)
+{
 …
                 return false;
         memcpy(sid, &dom_sid, sizeof(DOM_SID));
+        memcpy(sid, &dom_sid, sizeof(struct dom_sid));
         *name_type = (enum lsa_SidType)type;
 …
 /* Call winbindd to convert sid to name */
 bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
+bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
                         const char **domain, const char **name,
                         enum lsa_SidType *name_type)
 …
 /* Call winbindd to convert SID to uid */
 bool winbind_sid_to_uid(uid_t *puid, const DOM_SID *sid)
+bool winbind_sid_to_uid(uid_t *puid, const struct dom_sid *sid)
+{
         struct wbcDomainSid dom_sid;
 …
 /* Call winbindd to convert uid to sid */
 bool winbind_uid_to_sid(DOM_SID *sid, uid_t uid)
+bool winbind_uid_to_sid(struct dom_sid *sid, uid_t uid)
+{
         struct wbcDomainSid dom_sid;
 …
         result = wbcUidToSid(uid, &dom_sid);
         if (result == WBC_ERR_SUCCESS) {
                 memcpy(sid, &dom_sid, sizeof(DOM_SID));
+                memcpy(sid, &dom_sid, sizeof(struct dom_sid));
         } else {
                 sid_copy(sid, &global_sid_NULL);
 …
 /* Call winbindd to convert SID to gid */
 bool winbind_sid_to_gid(gid_t *pgid, const DOM_SID *sid)
+bool winbind_sid_to_gid(gid_t *pgid, const struct dom_sid *sid)
+{
         struct wbcDomainSid dom_sid;
 …
 /* Call winbindd to convert gid to sid */
 bool winbind_gid_to_sid(DOM_SID *sid, gid_t gid)
+bool winbind_gid_to_sid(struct dom_sid *sid, gid_t gid)
+{
         struct wbcDomainSid dom_sid;
 …
         result = wbcGidToSid(gid, &dom_sid);
         if (result == WBC_ERR_SUCCESS) {
                 memcpy(sid, &dom_sid, sizeof(DOM_SID));
+                memcpy(sid, &dom_sid, sizeof(struct dom_sid));
         } else {
                 sid_copy(sid, &global_sid_NULL);
 …
 bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
                          const DOM_SID *domain_sid,
+                         const struct dom_sid *domain_sid,
                          int num_rids, uint32 *rids,
                          const char **domain_name,
 …
 bool winbind_get_sid_aliases(TALLOC_CTX *mem_ctx,
                              const DOM_SID *dom_sid,
                              const DOM_SID *members,
+                             const struct dom_sid *dom_sid,
+                             const struct dom_sid *members,
                              size_t num_members,
                              uint32_t **pp_alias_rids,
 …
+}
 struct passwd * winbind_getpwsid(const DOM_SID *sid)
+struct passwd * winbind_getpwsid(const struct dom_sid *sid)
+{
         return NULL;
+}
 bool winbind_lookup_name(const char *dom_name, const char *name, DOM_SID *sid,
+bool winbind_lookup_name(const char *dom_name, const char *name, struct dom_sid *sid,
                          enum lsa_SidType *name_type)
+{
 …
 /* Call winbindd to convert sid to name */
 bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
+bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
                         const char **domain, const char **name,
                         enum lsa_SidType *name_type)
 …
 /* Call winbindd to convert SID to uid */
 bool winbind_sid_to_uid(uid_t *puid, const DOM_SID *sid)
+bool winbind_sid_to_uid(uid_t *puid, const struct dom_sid *sid)
+{
         return false;
 …
 /* Call winbindd to convert uid to sid */
 bool winbind_uid_to_sid(DOM_SID *sid, uid_t uid)
+bool winbind_uid_to_sid(struct dom_sid *sid, uid_t uid)
+{
         return false;
 …
 /* Call winbindd to convert SID to gid */
 bool winbind_sid_to_gid(gid_t *pgid, const DOM_SID *sid)
+bool winbind_sid_to_gid(gid_t *pgid, const struct dom_sid *sid)
+{
         return false;
 …
 /* Call winbindd to convert gid to sid */
 bool winbind_gid_to_sid(DOM_SID *sid, gid_t gid)
+bool winbind_gid_to_sid(struct dom_sid *sid, gid_t gid)
+{
         return false;
 …
 bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
                          const DOM_SID *domain_sid,
+                         const struct dom_sid *domain_sid,
                          int num_rids, uint32 *rids,
                          const char **domain_name,
 …
 bool winbind_get_sid_aliases(TALLOC_CTX *mem_ctx,
                              const DOM_SID *dom_sid,
                              const DOM_SID *members,
+                             const struct dom_sid *dom_sid,
+                             const struct dom_sid *members,
                              size_t num_members,
                              uint32_t **pp_alias_rids,

Context Navigation

Legend:

Download in other formats: