Changeset 988 for vendor/current/source3/groupdb

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/groupdb

Files:

• mapping.c (modified) (21 diffs)
• mapping.h (modified) (1 diff)
• mapping_tdb.c (modified) (42 diffs)
• mapping_tdb.h (added)
• proto.h (deleted)

vendor/current/source3/groupdb/mapping.c

@@ -28 +28 @@
 #include "lib/winbind_util.h"
 #include <tdb.h>
+#include "groupdb/mapping_tdb.h"
 
 static const struct mapping_backend *backend;
@@ -51 +52 @@
 NTSTATUS add_initial_entry(gid_t gid, const char *sid, enum lsa_SidType sid_name_use, const char *nt_name, const char *comment)
 {
-        GROUP_MAP map;
+        NTSTATUS status;
+        GROUP_MAP *map;
 
         if(!init_group_mapping()) {
@@ -58 +60 @@
         }
 
-        map.gid=gid;
-        if (!string_to_sid(&map.sid, sid)) {
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        map->gid=gid;
+        if (!string_to_sid(&map->sid, sid)) {
                 DEBUG(0, ("string_to_sid failed: %s", sid));
-                return NT_STATUS_UNSUCCESSFUL;
-        }
-
-        map.sid_name_use=sid_name_use;
-        fstrcpy(map.nt_name, nt_name);
-        fstrcpy(map.comment, comment);
-
-        return pdb_add_group_mapping_entry(&map);
+                status = NT_STATUS_UNSUCCESSFUL;
+                goto done;
+        }
+
+        map->sid_name_use=sid_name_use;
+        map->nt_name = talloc_strdup(map, nt_name);
+        if (!map->nt_name) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        if (comment) {
+                map->comment = talloc_strdup(map, comment);
+        } else {
+                map->comment = talloc_strdup(map, "");
+        }
+        if (!map->comment) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        status = pdb_add_group_mapping_entry(map);
+
+done:
+        TALLOC_FREE(map);
+        return status;
 }
 
@@ -128 +153 @@
 
         if ( !ret ) {
-                uint32 rid;
+                uint32_t rid;
 
                 sid_peek_rid( &sid, &rid );
 
                 if ( rid == DOMAIN_RID_USERS ) {
-                        fstrcpy( map->nt_name, "None" );
-                        fstrcpy( map->comment, "Ordinary Users" );
+                        map->nt_name = talloc_strdup(map, "None");
+                        if (!map->nt_name) {
+                                return false;
+                        }
+                        map->comment = talloc_strdup(map, "Ordinary Users");
+                        if (!map->comment) {
+                                return false;
+                        }
                         sid_copy( &map->sid, &sid );
                         map->sid_name_use = SID_NAME_DOM_GRP;
@@ -183 +214 @@
         /* defer to scripts */
 
-        if ( *lp_addgroup_script() ) {
+        if ( *lp_add_group_script(talloc_tos()) ) {
                 TALLOC_CTX *ctx = talloc_tos();
 
                 add_script = talloc_strdup(ctx,
-                                        lp_addgroup_script());
+                                        lp_add_group_script(ctx));
                 if (!add_script) {
                         return -1;
@@ -239 +270 @@
         /* defer to scripts */
 
-        if ( *lp_delgroup_script() ) {
+        if ( *lp_delete_group_script(talloc_tos()) ) {
                 TALLOC_CTX *ctx = talloc_tos();
 
                 del_script = talloc_strdup(ctx,
-                                lp_delgroup_script());
+                                lp_delete_group_script(ctx));
                 if (!del_script) {
                         return -1;
@@ -274 +305 @@
         /* defer to scripts */
 
-        if ( *lp_setprimarygroup_script() ) {
+        if ( *lp_set_primary_group_script(talloc_tos()) ) {
                 TALLOC_CTX *ctx = talloc_tos();
 
                 add_script = talloc_strdup(ctx,
-                                lp_setprimarygroup_script());
+                                lp_set_primary_group_script(ctx));
                 if (!add_script) {
                         return -1;
@@ -316 +347 @@
         /* defer to scripts */
 
-        if ( *lp_addusertogroup_script() ) {
+        if ( *lp_add_user_to_group_script(talloc_tos()) ) {
                 TALLOC_CTX *ctx = talloc_tos();
 
                 add_script = talloc_strdup(ctx,
-                                lp_addusertogroup_script());
+                                lp_add_user_to_group_script(ctx));
                 if (!add_script) {
                         return -1;
@@ -356 +387 @@
         /* defer to scripts */
 
-        if ( *lp_deluserfromgroup_script() ) {
+        if ( *lp_delete_user_from_group_script(talloc_tos()) ) {
                 TALLOC_CTX *ctx = talloc_tos();
 
                 del_script = talloc_strdup(ctx,
-                                lp_deluserfromgroup_script());
+                                lp_delete_user_from_group_script(ctx));
                 if (!del_script) {
                         return -1;
@@ -453 +484 @@
 
 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
-                                           const struct dom_sid *sid, enum lsa_SidType sid_name_use,
-                                           GROUP_MAP **pp_rmap, size_t *p_num_entries,
-                                           bool unix_only)
+                                        const struct dom_sid *sid,
+                                        enum lsa_SidType sid_name_use,
+                                        GROUP_MAP ***pp_rmap,
+                                        size_t *p_num_entries,
+                                        bool unix_only)
 {
         if (!init_group_mapping()) {
@@ -466 +499 @@
 
 NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
-                                  const char *name, uint32 *rid)
+                                  const char *name, uint32_t *rid)
 {
         struct dom_sid sid;
         enum lsa_SidType type;
-        uint32 new_rid;
+        uint32_t new_rid;
         gid_t gid;
         bool exists;
-        GROUP_MAP map;
+        GROUP_MAP *map;
         TALLOC_CTX *mem_ctx;
         NTSTATUS status;
@@ -486 +519 @@
         exists = lookup_name(mem_ctx, name, LOOKUP_NAME_LOCAL,
                              NULL, NULL, &sid, &type);
-        TALLOC_FREE(mem_ctx);
 
         if (exists) {
-                return NT_STATUS_ALIAS_EXISTS;
+                status = NT_STATUS_ALIAS_EXISTS;
+                goto done;
         }
 
         if (!pdb_new_rid(&new_rid)) {
                 DEBUG(0, ("Could not allocate a RID.\n"));
-                return NT_STATUS_ACCESS_DENIED;
+                status = NT_STATUS_ACCESS_DENIED;
+                goto done;
         }
 
@@ -502 +536 @@
                 DEBUG(3, ("Could not get a gid out of winbind - "
                           "wasted a rid :-(\n"));
-                return NT_STATUS_ACCESS_DENIED;
+                status = NT_STATUS_ACCESS_DENIED;
+                goto done;
         }
 
@@ -508 +543 @@
                    name, (unsigned int)gid, (unsigned int)new_rid));
 
-        map.gid = gid;
-        sid_copy(&map.sid, &sid);
-        map.sid_name_use = SID_NAME_ALIAS;
-        fstrcpy(map.nt_name, name);
-        fstrcpy(map.comment, "");
-
-        status = pdb_add_group_mapping_entry(&map);
+        map = talloc_zero(mem_ctx, GROUP_MAP);
+        if (!map) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        map->gid = gid;
+        sid_copy(&map->sid, &sid);
+        map->sid_name_use = SID_NAME_ALIAS;
+        map->nt_name = talloc_strdup(map, name);
+        if (!map->nt_name) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        map->comment = talloc_strdup(map, "");
+        if (!map->comment) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        status = pdb_add_group_mapping_entry(map);
 
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0, ("Could not add group mapping entry for alias %s "
                           "(%s)\n", name, nt_errstr(status)));
-                return status;
+                goto done;
         }
 
         *rid = new_rid;
 
-        return NT_STATUS_OK;
+done:
+        TALLOC_FREE(mem_ctx);
+        return status;
 }
 
@@ -537 +588 @@
                                    struct acct_info *info)
 {
-        GROUP_MAP map;
-
-        if (!pdb_getgrsid(&map, *sid))
-                return NT_STATUS_NO_SUCH_ALIAS;
-
-        if ((map.sid_name_use != SID_NAME_ALIAS) &&
-            (map.sid_name_use != SID_NAME_WKN_GRP)) {
+        NTSTATUS status = NT_STATUS_OK;
+        GROUP_MAP *map;
+
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (!pdb_getgrsid(map, *sid)) {
+                status = NT_STATUS_NO_SUCH_ALIAS;
+                goto done;
+        }
+
+        if ((map->sid_name_use != SID_NAME_ALIAS) &&
+            (map->sid_name_use != SID_NAME_WKN_GRP)) {
                 DEBUG(2, ("%s is a %s, expected an alias\n",
                           sid_string_dbg(sid),
-                          sid_type_lookup(map.sid_name_use)));
-                return NT_STATUS_NO_SUCH_ALIAS;
-        }
-
-        fstrcpy(info->acct_name, map.nt_name);
-        fstrcpy(info->acct_desc, map.comment);
-        sid_peek_rid(&map.sid, &info->rid);
-        return NT_STATUS_OK;
+                          sid_type_lookup(map->sid_name_use)));
+                status = NT_STATUS_NO_SUCH_ALIAS;
+                goto done;
+        }
+
+        info->acct_name = talloc_move(info, &map->nt_name);
+        if (!info->acct_name) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        info->acct_desc = talloc_move(info, &map->comment);
+        if (!info->acct_desc) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        sid_peek_rid(&map->sid, &info->rid);
+
+done:
+        TALLOC_FREE(map);
+        return status;
 }
 
@@ -560 +631 @@
                                    struct acct_info *info)
 {
-        GROUP_MAP map;
-
-        if (!pdb_getgrsid(&map, *sid))
-                return NT_STATUS_NO_SUCH_ALIAS;
-
-        fstrcpy(map.nt_name, info->acct_name);
-        fstrcpy(map.comment, info->acct_desc);
-
-        return pdb_update_group_mapping_entry(&map);
+        NTSTATUS status = NT_STATUS_OK;
+        GROUP_MAP *map;
+
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (!pdb_getgrsid(map, *sid)) {
+                status = NT_STATUS_NO_SUCH_ALIAS;
+                goto done;
+        }
+
+        map->nt_name = talloc_strdup(map, info->acct_name);
+        if (!map->nt_name) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        map->comment = talloc_strdup(map, info->acct_desc);
+        if (!map->comment) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        status = pdb_update_group_mapping_entry(map);
+
+done:
+        TALLOC_FREE(map);
+        return status;
 }
 
@@ -608 +699 @@
                                        const struct dom_sid *members,
                                        size_t num_members,
-                                       uint32 **pp_alias_rids,
+                                       uint32_t **pp_alias_rids,
                                        size_t *p_num_alias_rids)
 {
@@ -636 +727 @@
         }
 
-        *pp_alias_rids = TALLOC_ARRAY(mem_ctx, uint32, num_alias_sids);
+        *pp_alias_rids = talloc_array(mem_ctx, uint32_t, num_alias_sids);
         if (*pp_alias_rids == NULL)
                 return NT_STATUS_NO_MEMORY;
@@ -700 +791 @@
 }
 
-/****************************************************************************
- These need to be redirected through pdb_interface.c
-****************************************************************************/
-bool pdb_get_dom_grp_info(const struct dom_sid *sid, struct acct_info *info)
-{
-        GROUP_MAP map;
-        bool res;
-
-        become_root();
-        res = get_domain_group_from_sid(*sid, &map);
-        unbecome_root();
-
-        if (!res)
-                return False;
-
-        fstrcpy(info->acct_name, map.nt_name);
-        fstrcpy(info->acct_desc, map.comment);
-        sid_peek_rid(sid, &info->rid);
-        return True;
-}
-
-bool pdb_set_dom_grp_info(const struct dom_sid *sid, const struct acct_info *info)
-{
-        GROUP_MAP map;
-
-        if (!get_domain_group_from_sid(*sid, &map))
-                return False;
-
-        fstrcpy(map.nt_name, info->acct_name);
-        fstrcpy(map.comment, info->acct_desc);
-
-        return NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map));
-}
-
-/********************************************************************
- Really just intended to be called by smbd
-********************************************************************/
-
-NTSTATUS pdb_create_builtin_alias(uint32 rid)
+/**
+* @brief Add a new group mapping
+*
+* @param[in] gid gid to use to store the mapping. If gid is 0,
+*                new gid will be allocated from winbind
+*
+* @return Normal NTSTATUS return
+*/
+NTSTATUS pdb_create_builtin_alias(uint32_t rid, gid_t gid)
 {
         struct dom_sid sid;
         enum lsa_SidType type;
-        gid_t gid;
-        GROUP_MAP map;
-        TALLOC_CTX *mem_ctx;
+        gid_t gidformap;
+        GROUP_MAP *map;
         NTSTATUS status;
         const char *name = NULL;
-        fstring groupname;
 
         DEBUG(10, ("Trying to create builtin alias %d\n", rid));
@@ -755 +814 @@
         }
 
-        if ( (mem_ctx = talloc_new(NULL)) == NULL ) {
+        /* use map as overall temp mem context */
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
                 return NT_STATUS_NO_MEMORY;
         }
 
-        if ( !lookup_sid(mem_ctx, &sid, NULL, &name, &type) ) {
-                TALLOC_FREE( mem_ctx );
-                return NT_STATUS_NO_SUCH_ALIAS;
-        }
-
-        /* validate RID so copy the name and move on */
-
-        fstrcpy( groupname, name );
-        TALLOC_FREE( mem_ctx );
-
-        if (!winbind_allocate_gid(&gid)) {
-                DEBUG(3, ("pdb_create_builtin_alias: Could not get a gid out of winbind\n"));
-                return NT_STATUS_ACCESS_DENIED;
-        }
-
-        DEBUG(10,("Creating alias %s with gid %u\n", groupname, (unsigned int)gid));
-
-        map.gid = gid;
-        sid_copy(&map.sid, &sid);
-        map.sid_name_use = SID_NAME_ALIAS;
-        fstrcpy(map.nt_name, groupname);
-        fstrcpy(map.comment, "");
-
-        status = pdb_add_group_mapping_entry(&map);
+        if (!lookup_sid(map, &sid, NULL, &name, &type)) {
+                status = NT_STATUS_NO_SUCH_ALIAS;
+                goto done;
+        }
+
+        if (gid == 0) {
+                if (!winbind_allocate_gid(&gidformap)) {
+                        DEBUG(3, ("pdb_create_builtin_alias: Could not get a "
+                                  "gid out of winbind\n"));
+                        status = NT_STATUS_ACCESS_DENIED;
+                        goto done;
+                }
+        } else {
+                gidformap = gid;
+        }
+
+        DEBUG(10, ("Creating alias %s with gid %u\n", name,
+                   (unsigned) gidformap));
+
+        map->gid = gidformap;
+        sid_copy(&map->sid, &sid);
+        map->sid_name_use = SID_NAME_ALIAS;
+        map->nt_name = talloc_strdup(map, name);
+        if (!map->nt_name) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        map->comment = talloc_strdup(map, "");
+        if (!map->comment) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        status = pdb_add_group_mapping_entry(map);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -789 +860 @@
         }
 
+done:
+        TALLOC_FREE(map);
         return status;
 }

vendor/current/source3/groupdb/mapping.h

@@ -46 +46 @@
         bool (*group_map_remove)(const struct dom_sid *sid);
         bool (*enum_group_mapping)(const struct dom_sid *domsid, enum lsa_SidType sid_name_use,
-                                   GROUP_MAP **pp_rmap,
+                                   GROUP_MAP ***pp_rmap,
                                    size_t *p_num_entries, bool unix_only);
         NTSTATUS (*one_alias_membership)(const struct dom_sid *member,

vendor/current/source3/groupdb/mapping_tdb.c

@@ -25 +25 @@
 #include "passdb.h"
 #include "groupdb/mapping.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
 #include "util_tdb.h"
 #include "../libcli/security/security.h"
+#include "groupdb/mapping_tdb.h"
 
 static struct db_context *db; /* used for driver files */
@@ -33 +35 @@
 static bool enum_group_mapping(const struct dom_sid *domsid,
                                enum lsa_SidType sid_name_use,
-                               GROUP_MAP **pp_rmap,
+                               GROUP_MAP ***pp_rmap,
                                size_t *p_num_entries,
                                bool unix_only);
@@ -45 +47 @@
 static bool init_group_mapping(void)
 {
-        const char *ldb_path;
+        char *tdb_path;
+        char *ldb_path;
 
         if (db != NULL) {
@@ -51 +54 @@
         }
 
-        db = db_open(NULL, state_path("group_mapping.tdb"), 0,
-                           TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+        tdb_path = state_path("group_mapping.tdb");
+        if (tdb_path == NULL) {
+                return false;
+        }
+        db = db_open(NULL, tdb_path, 0,
+                     TDB_DEFAULT, O_RDWR|O_CREAT, 0600,
+                     DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
         if (db == NULL) {
                 DEBUG(0, ("Failed to open group mapping database: %s\n",
                           strerror(errno)));
+                talloc_free(tdb_path);
                 return false;
         }
 
         ldb_path = state_path("group_mapping.ldb");
+        if (ldb_path == NULL) {
+                talloc_free(tdb_path);
+                return false;
+        }
         if (file_exist(ldb_path) && !mapping_switch(ldb_path)) {
-                unlink(state_path("group_mapping.tdb"));
+                unlink(tdb_path);
+                talloc_free(tdb_path);
+                talloc_free(ldb_path);
                 return false;
 
@@ -87 +102 @@
                 }
 
-                /* if its an unknown version we remove everthing in the db */
+                /* if its an unknown version we remove everything in the db */
 
                 if (vers_id != DATABASE_VERSION_V2) {
@@ -112 +127 @@
 #endif
         }
+        talloc_free(tdb_path);
+        talloc_free(ldb_path);
         return true;
 }
@@ -117 +134 @@
 static char *group_mapping_key(TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
 {
-        char *sidstr, *result;
-
-        sidstr = sid_string_talloc(talloc_tos(), sid);
-        if (sidstr == NULL) {
+        char sidstr[DOM_SID_STR_BUFLEN];
+        int len;
+
+        len = dom_sid_string_buf(sid, sidstr, sizeof(sidstr));
+        if (len >= sizeof(sidstr)) {
                 return NULL;
         }
 
-        result = talloc_asprintf(mem_ctx, "%s%s", GROUP_PREFIX, sidstr);
-
-        TALLOC_FREE(sidstr);
-        return result;
+        return talloc_asprintf(mem_ctx, "%s%s", GROUP_PREFIX, sidstr);
 }
 
@@ -146 +161 @@
                 map->gid, map->sid_name_use, map->nt_name, map->comment);
 
-        buf = TALLOC_ARRAY(key, char, len);
+        buf = talloc_array(key, char, len);
         if (!buf) {
                 TALLOC_FREE(key);
                 return false;
         }
-        len = tdb_pack((uint8 *)buf, len, "ddff", map->gid,
+        len = tdb_pack((uint8_t *)buf, len, "ddff", map->gid,
                        map->sid_name_use, map->nt_name, map->comment);
 
@@ -173 +188 @@
         char *key;
         int ret = 0;
+        NTSTATUS status;
+        fstring nt_name;
+        fstring comment;
 
         /* the key is the SID, retrieving is direct */
@@ -181 +199 @@
         }
 
-        dbuf = dbwrap_fetch_bystring(db, key, key);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch_bystring(db, key, key, &dbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 TALLOC_FREE(key);
                 return false;
@@ -189 +207 @@
         ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
                         &map->gid, &map->sid_name_use,
-                        &map->nt_name, &map->comment);
+                        &nt_name, &comment);
 
         TALLOC_FREE(key);
@@ -200 +218 @@
         sid_copy(&map->sid, &sid);
 
+        map->nt_name = talloc_strdup(map, nt_name);
+        if (!map->nt_name) {
+                return false;
+        }
+        map->comment = talloc_strdup(map, comment);
+        if (!map->comment) {
+                return false;
+        }
+
         return true;
 }
@@ -205 +232 @@
 static bool dbrec2map(const struct db_record *rec, GROUP_MAP *map)
 {
-        if ((rec->key.dsize < strlen(GROUP_PREFIX))
-            || (strncmp((char *)rec->key.dptr, GROUP_PREFIX,
+        TDB_DATA key = dbwrap_record_get_key(rec);
+        TDB_DATA value = dbwrap_record_get_value(rec);
+        int ret = 0;
+        fstring nt_name;
+        fstring comment;
+
+        if ((key.dsize < strlen(GROUP_PREFIX))
+            || (strncmp((char *)key.dptr, GROUP_PREFIX,
                         GROUP_PREFIX_LEN) != 0)) {
                 return False;
         }
 
-        if (!string_to_sid(&map->sid, (const char *)rec->key.dptr
+        if (!string_to_sid(&map->sid, (const char *)key.dptr
                            + GROUP_PREFIX_LEN)) {
                 return False;
         }
 
-        return tdb_unpack(rec->value.dptr, rec->value.dsize, "ddff",
-                          &map->gid, &map->sid_name_use, &map->nt_name,
-                          &map->comment) != -1;
+        ret = tdb_unpack(value.dptr, value.dsize, "ddff",
+                          &map->gid, &map->sid_name_use,
+                          &nt_name, &comment);
+
+        if (ret == -1) {
+                DEBUG(3, ("dbrec2map: tdb_unpack failure\n"));
+                return false;
+        }
+
+        map->nt_name = talloc_strdup(map, nt_name);
+        if (!map->nt_name) {
+                return false;
+        }
+        map->comment = talloc_strdup(map, comment);
+        if (!map->comment) {
+                return false;
+        }
+
+        return true;
 }
 
@@ -266 +315 @@
         state.map = map;
 
-        db->traverse_read(db, find_map, (void *)&state);
+        dbwrap_traverse_read(db, find_map, (void *)&state, NULL);
 
         return state.found;
@@ -283 +332 @@
         state.map = map;
 
-        db->traverse_read(db, find_map, (void *)&state);
+        dbwrap_traverse_read(db, find_map, (void *)&state, NULL);
 
         return state.found;
@@ -318 +367 @@
 
         size_t num_maps;
-        GROUP_MAP *maps;
+        GROUP_MAP **maps;
 };
 
@@ -324 +373 @@
 {
         struct enum_map_state *state = (struct enum_map_state *)private_data;
-        GROUP_MAP map;
-        GROUP_MAP *tmp;
-
-        if (!dbrec2map(rec, &map)) {
+        GROUP_MAP *map;
+        GROUP_MAP **tmp;
+
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
+                DEBUG(0, ("Unable to allocate group map!\n"));
+                return 1;
+        }
+
+        if (!dbrec2map(rec, map)) {
+                TALLOC_FREE(map);
                 return 0;
         }
         /* list only the type or everything if UNKNOWN */
         if (state->sid_name_use != SID_NAME_UNKNOWN
-            && state->sid_name_use != map.sid_name_use) {
+            && state->sid_name_use != map->sid_name_use) {
                 DEBUG(11,("enum_group_mapping: group %s is not of the "
-                          "requested type\n", map.nt_name));
+                          "requested type\n", map->nt_name));
+                TALLOC_FREE(map);
                 return 0;
         }
 
-        if ((state->unix_only == ENUM_ONLY_MAPPED) && (map.gid == -1)) {
+        if ((state->unix_only == ENUM_ONLY_MAPPED) && (map->gid == -1)) {
                 DEBUG(11,("enum_group_mapping: group %s is non mapped\n",
-                          map.nt_name));
+                          map->nt_name));
+                TALLOC_FREE(map);
                 return 0;
         }
 
         if ((state->domsid != NULL) &&
-            (dom_sid_compare_domain(state->domsid, &map.sid) != 0)) {
+            (dom_sid_compare_domain(state->domsid, &map->sid) != 0)) {
                 DEBUG(11,("enum_group_mapping: group %s is not in domain\n",
-                          sid_string_dbg(&map.sid)));
+                          sid_string_dbg(&map->sid)));
+                TALLOC_FREE(map);
                 return 0;
         }
 
-        if (!(tmp = SMB_REALLOC_ARRAY(state->maps, GROUP_MAP,
-                                      state->num_maps+1))) {
+        tmp = talloc_realloc(NULL, state->maps, GROUP_MAP *,
+                                        state->num_maps + 1);
+        if (!tmp) {
                 DEBUG(0,("enum_group_mapping: Unable to enlarge group "
                          "map!\n"));
+                TALLOC_FREE(map);
                 return 1;
         }
 
         state->maps = tmp;
-        state->maps[state->num_maps] = map;
+        state->maps[state->num_maps] = talloc_move(state->maps, &map);
         state->num_maps++;
         return 0;
@@ -366 +427 @@
 static bool enum_group_mapping(const struct dom_sid *domsid,
                                enum lsa_SidType sid_name_use,
-                               GROUP_MAP **pp_rmap,
+                               GROUP_MAP ***pp_rmap,
                                size_t *p_num_entries, bool unix_only)
 {
         struct enum_map_state state;
+        NTSTATUS status;
 
         state.domsid = domsid;
@@ -377 +439 @@
         state.maps = NULL;
 
-        if (db->traverse_read(db, collect_map, (void *)&state) < 0) {
+        status = dbwrap_traverse_read(db, collect_map, (void *)&state, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(state.maps);
                 return false;
         }
@@ -404 +468 @@
                  sid_to_fstring(tmp, member));
 
-        dbuf = dbwrap_fetch_bystring(db, frame, key);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch_bystring(db, frame, key, &dbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 TALLOC_FREE(frame);
                 return NT_STATUS_OK;
@@ -472 +536 @@
 static NTSTATUS add_aliasmem(const struct dom_sid *alias, const struct dom_sid *member)
 {
-        GROUP_MAP map;
+        GROUP_MAP *map;
         char *key;
         fstring string_sid;
@@ -478 +542 @@
         struct db_record *rec;
         NTSTATUS status;
-
-        if (!get_group_map_from_sid(*alias, &map))
+        TDB_DATA value;
+
+        map = talloc_zero(talloc_tos(), GROUP_MAP);
+        if (!map) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (!get_group_map_from_sid(*alias, map)) {
+                TALLOC_FREE(map);
                 return NT_STATUS_NO_SUCH_ALIAS;
-
-        if ( (map.sid_name_use != SID_NAME_ALIAS) &&
-             (map.sid_name_use != SID_NAME_WKN_GRP) )
+        }
+
+        if ((map->sid_name_use != SID_NAME_ALIAS) &&
+            (map->sid_name_use != SID_NAME_WKN_GRP)) {
+                TALLOC_FREE(map);
                 return NT_STATUS_NO_SUCH_ALIAS;
+        }
+
+        TALLOC_FREE(map);
 
         if (is_aliasmem(alias, member))
@@ -497 +573 @@
         }
 
-        if (db->transaction_start(db) != 0) {
+        if (dbwrap_transaction_start(db) != 0) {
                 DEBUG(0, ("transaction_start failed\n"));
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
 
-        rec = db->fetch_locked(db, key, string_term_tdb_data(key));
+        rec = dbwrap_fetch_locked(db, key, string_term_tdb_data(key));
 
         if (rec == NULL) {
@@ -511 +587 @@
         }
 
+        value = dbwrap_record_get_value(rec);
+
         sid_to_fstring(string_sid, alias);
 
-        if (rec->value.dptr != NULL) {
+        if (value.dptr != NULL) {
                 new_memberstring = talloc_asprintf(
-                        key, "%s %s", (char *)(rec->value.dptr), string_sid);
+                        key, "%s %s", (char *)(value.dptr), string_sid);
         } else {
                 new_memberstring = talloc_strdup(key, string_sid);
@@ -526 +604 @@
         }
 
-        status = rec->store(rec, string_term_tdb_data(new_memberstring), 0);
+        status = dbwrap_record_store(rec, string_term_tdb_data(new_memberstring), 0);
 
         TALLOC_FREE(key);
@@ -535 +613 @@
         }
 
-        if (db->transaction_commit(db) != 0) {
+        if (dbwrap_transaction_commit(db) != 0) {
                 DEBUG(0, ("transaction_commit failed\n"));
                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
@@ -544 +622 @@
 
  cancel:
-        if (db->transaction_cancel(db) != 0) {
+        if (dbwrap_transaction_cancel(db) != 0) {
                 smb_panic("transaction_cancel failed");
         }
@@ -564 +642 @@
         char *alias_string;
         TALLOC_CTX *frame;
-
-        if (strncmp((const char *)rec->key.dptr, MEMBEROF_PREFIX,
+        TDB_DATA key = dbwrap_record_get_key(rec);
+        TDB_DATA value = dbwrap_record_get_value(rec);
+
+        if (strncmp((const char *)key.dptr, MEMBEROF_PREFIX,
                     MEMBEROF_PREFIX_LEN) != 0)
                 return 0;
 
-        p = (const char *)rec->value.dptr;
+        p = (const char *)value.dptr;
 
         frame = talloc_stackframe();
@@ -588 +668 @@
                  * member. Add that. */
 
-                member_string = strchr((const char *)rec->key.dptr, '/');
+                member_string = strchr((const char *)key.dptr, '/');
 
                 /* Above we tested for MEMBEROF_PREFIX which includes the
@@ -617 +697 @@
                               struct dom_sid **sids, size_t *num)
 {
-        GROUP_MAP map;
+        GROUP_MAP *map;
         struct aliasmem_state state;
 
-        if (!get_group_map_from_sid(*alias, &map))
+        map = talloc_zero(talloc_tos(), GROUP_MAP);
+        if (!map) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        if (!get_group_map_from_sid(*alias, map)) {
+                TALLOC_FREE(map);
                 return NT_STATUS_NO_SUCH_ALIAS;
-
-        if ( (map.sid_name_use != SID_NAME_ALIAS) &&
-             (map.sid_name_use != SID_NAME_WKN_GRP) )
+        }
+
+        if ((map->sid_name_use != SID_NAME_ALIAS) &&
+            (map->sid_name_use != SID_NAME_WKN_GRP)) {
+                TALLOC_FREE(map);
                 return NT_STATUS_NO_SUCH_ALIAS;
+        }
+
+        TALLOC_FREE(map);
 
         *sids = NULL;
@@ -635 +726 @@
         state.mem_ctx = mem_ctx;
 
-        db->traverse_read(db, collect_aliasmem, &state);
+        dbwrap_traverse_read(db, collect_aliasmem, &state, NULL);
         return NT_STATUS_OK;
 }
@@ -649 +740 @@
         fstring sid_string;
 
-        if (db->transaction_start(db) != 0) {
+        if (dbwrap_transaction_start(db) != 0) {
                 DEBUG(0, ("transaction_start failed\n"));
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
@@ -724 +815 @@
         }
 
-        if (db->transaction_commit(db) != 0) {
+        if (dbwrap_transaction_commit(db) != 0) {
                 DEBUG(0, ("transaction_commit failed\n"));
                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
@@ -733 +824 @@
 
  cancel:
-        if (db->transaction_cancel(db) != 0) {
+        if (dbwrap_transaction_cancel(db) != 0) {
                 smb_panic("transaction_cancel failed");
         }
@@ -762 +853 @@
 {
         TALLOC_CTX *tmp_ctx = talloc_tos();
-        GROUP_MAP map;
+        GROUP_MAP *map = NULL;
         uint8_t *p;
         uint32_t format;
@@ -827 +918 @@
         }
 
-        ZERO_STRUCT(map);
+        map = talloc_zero(NULL, GROUP_MAP);
+        if (!map) {
+                errno = ENOMEM;
+                goto failed;
+        }
 
         for (i = 0; i < num_el; i++) {
@@ -850 +945 @@
 
                 num_vals = pull_uint32(p, 0);
-                if (StrCaseCmp(name, "member") == 0) {
+                if (strcasecmp_m(name, "member") == 0) {
                         num_mem = num_vals;
                         members = talloc_array(tmp_ctx, struct dom_sid, num_mem);
@@ -883 +978 @@
                         /* we ignore unknown or uninteresting attributes
                          * (objectclass, etc.) */
-                        if (StrCaseCmp(name, "gidNumber") == 0) {
-                                map.gid = strtoul(val, &q, 10);
+                        if (strcasecmp_m(name, "gidNumber") == 0) {
+                                map->gid = strtoul(val, &q, 10);
                                 if (*q) {
                                         errno = EIO;
                                         goto failed;
                                 }
-                        } else if (StrCaseCmp(name, "sid") == 0) {
-                                if (!string_to_sid(&map.sid, val)) {
+                        } else if (strcasecmp_m(name, "sid") == 0) {
+                                if (!string_to_sid(&map->sid, val)) {
                                         errno = EIO;
                                         goto failed;
                                 }
-                        } else if (StrCaseCmp(name, "sidNameUse") == 0) {
-                                map.sid_name_use = strtoul(val, &q, 10);
+                        } else if (strcasecmp_m(name, "sidNameUse") == 0) {
+                                map->sid_name_use = strtoul(val, &q, 10);
                                 if (*q) {
                                         errno = EIO;
                                         goto failed;
                                 }
-                        } else if (StrCaseCmp(name, "ntname") == 0) {
-                                strlcpy(map.nt_name, val,
-                                        sizeof(map.nt_name));
-                        } else if (StrCaseCmp(name, "comment") == 0) {
-                                strlcpy(map.comment, val,
-                                        sizeof(map.comment));
-                        } else if (StrCaseCmp(name, "member") == 0) {
+                        } else if (strcasecmp_m(name, "ntname") == 0) {
+                                map->nt_name = talloc_strdup(map, val);
+                                if (!map->nt_name) {
+                                        errno = ENOMEM;
+                                        goto failed;
+                                }
+                        } else if (strcasecmp_m(name, "comment") == 0) {
+                                map->comment = talloc_strdup(map, val);
+                                if (!map->comment) {
+                                        errno = ENOMEM;
+                                        goto failed;
+                                }
+                        } else if (strcasecmp_m(name, "member") == 0) {
                                 if (!string_to_sid(&members[j], val)) {
                                         errno = EIO;
@@ -919 +1020 @@
         }
 
-        if (!add_mapping_entry(&map, 0)) {
+        if (map->nt_name == NULL) {
+                errno = EIO;
+                goto failed;
+        }
+
+        if (map->comment == NULL) {
+                map->comment = talloc_strdup(map, "");
+        }
+        if (map->comment == NULL) {
+                errno = ENOMEM;
+                goto failed;
+        }
+
+        if (!add_mapping_entry(map, 0)) {
                 errno = EIO;
                 goto failed;
@@ -927 +1041 @@
                 for (j = 0; j < num_mem; j++) {
                         NTSTATUS status;
-                        status = add_aliasmem(&map.sid, &members[j]);
+                        status = add_aliasmem(&map->sid, &members[j]);
                         if (!NT_STATUS_IS_OK(status)) {
                                 errno = EIO;
@@ -940 +1054 @@
         }
 
+        TALLOC_FREE(map);
         return 0;
 
 failed:
+        TALLOC_FREE(map);
         return -1;
 }
@@ -961 +1077 @@
          * conversion */
         ret = tdb_traverse(ltdb, convert_ldb_record, NULL);
-        if (ret == -1) goto failed;
+        if (ret < 0) goto failed;
 
         if (ltdb) {