s3-group-mapping: Remove fstrings from GROUP_MAP.

Signed-off-by: Andreas Schneider <asn@samba.org>

Autobuild-User: Günther Deschner <gd@samba.org>
Autobuild-Date: Wed Oct 12 19:28:12 CEST 2011 on sn-devel-104

4 files changed, 276 insertions, 107 deletions

diff --git a/source3/groupdb/mapping.c b/source3/groupdb/mapping.c
index 907d40fe2af..2c0fea0cb98 100644
--- a/source3/groupdb/mapping.c
+++ b/source3/groupdb/mapping.c
@@ -51,24 +51,48 @@ initialise first time the mapping list
 ****************************************************************************/
 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()) {
 		DEBUG(0,("failed to initialize group mapping\n"));
 		return NT_STATUS_UNSUCCESSFUL;
 	}
 
-	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;
+		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;
 	}
 
-	map.sid_name_use=sid_name_use;
-	fstrcpy(map.nt_name, nt_name);
-	fstrcpy(map.comment, comment);
+	status = pdb_add_group_mapping_entry(map);
 
-	return pdb_add_group_mapping_entry(&map);
+done:
+	TALLOC_FREE(map);
+	return status;
 }
 
 static NTSTATUS alias_memberships(const struct dom_sid *members, size_t num_members,
@@ -133,8 +157,14 @@ bool get_domain_group_from_sid(struct dom_sid sid, GROUP_MAP *map)
 		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;
 			map->gid = (gid_t)-1;
@@ -453,9 +483,11 @@ NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
 }
 
 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()) {
 		DEBUG(0,("failed to initialize group mapping\n"));
@@ -473,7 +505,7 @@ NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
 	uint32 new_rid;
 	gid_t gid;
 	bool exists;
-	GROUP_MAP map;
+	GROUP_MAP *map;
 	TALLOC_CTX *mem_ctx;
 	NTSTATUS status;
 
@@ -486,15 +518,16 @@ NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
 
 	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;
 	}
 
 	sid_compose(&sid, get_global_sam_sid(), new_rid);
@@ -502,29 +535,46 @@ NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
 	if (!winbind_allocate_gid(&gid)) {
 		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;
 	}
 
 	DEBUG(10, ("Creating alias %s with gid %u and rid %u\n",
 		   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, "");
+	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);
+	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;
 }
 
 NTSTATUS pdb_default_delete_alias(struct pdb_methods *methods,
@@ -537,44 +587,78 @@ NTSTATUS pdb_default_get_aliasinfo(struct pdb_methods *methods,
 				   const struct dom_sid *sid,
 				   struct acct_info *info)
 {
-	GROUP_MAP map;
+	NTSTATUS status = NT_STATUS_OK;
+	GROUP_MAP *map;
 
-	if (!pdb_getgrsid(&map, *sid))
-		return NT_STATUS_NO_SUCH_ALIAS;
+	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)) {
+	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;
+			  sid_type_lookup(map->sid_name_use)));
+		status = NT_STATUS_NO_SUCH_ALIAS;
+		goto done;
 	}
 
-	info->acct_name = talloc_strdup(info, map.nt_name);
+	info->acct_name = talloc_move(info, &map->nt_name);
 	if (!info->acct_name) {
-		return NT_STATUS_NO_MEMORY;
+		status = NT_STATUS_NO_MEMORY;
+		goto done;
 	}
-	info->acct_desc = talloc_strdup(info, map.comment);
+	info->acct_desc = talloc_move(info, &map->comment);
 	if (!info->acct_desc) {
-		return NT_STATUS_NO_MEMORY;
+		status = NT_STATUS_NO_MEMORY;
+		goto done;
 	}
-	sid_peek_rid(&map.sid, &info->rid);
-	return NT_STATUS_OK;
+	sid_peek_rid(&map->sid, &info->rid);
+
+done:
+	TALLOC_FREE(map);
+	return status;
 }
 
 NTSTATUS pdb_default_set_aliasinfo(struct pdb_methods *methods,
 				   const struct dom_sid *sid,
 				   struct acct_info *info)
 {
-	GROUP_MAP map;
+	NTSTATUS status = NT_STATUS_OK;
+	GROUP_MAP *map;
 
-	if (!pdb_getgrsid(&map, *sid))
-		return NT_STATUS_NO_SUCH_ALIAS;
+	map = talloc_zero(NULL, GROUP_MAP);
+	if (!map) {
+		return NT_STATUS_NO_MEMORY;
+	}
 
-	fstrcpy(map.nt_name, info->acct_name);
-	fstrcpy(map.comment, info->acct_desc);
+	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);
 
-	return pdb_update_group_mapping_entry(&map);
+done:
+	TALLOC_FREE(map);
+	return status;
 }
 
 NTSTATUS pdb_default_add_aliasmem(struct pdb_methods *methods,
@@ -715,11 +799,9 @@ NTSTATUS pdb_create_builtin_alias(uint32 rid)
 	struct dom_sid sid;
 	enum lsa_SidType type;
 	gid_t gid;
-	GROUP_MAP map;
-	TALLOC_CTX *mem_ctx;
+	GROUP_MAP *map;
 	NTSTATUS status;
 	const char *name = NULL;
-	fstring groupname;
 
 	DEBUG(10, ("Trying to create builtin alias %d\n", rid));
 
@@ -727,40 +809,48 @@ NTSTATUS pdb_create_builtin_alias(uint32 rid)
 		return NT_STATUS_NO_SUCH_ALIAS;
 	}
 
-	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;
+	if (!lookup_sid(map, &sid, NULL, &name, &type)) {
+		status = NT_STATUS_NO_SUCH_ALIAS;
+		goto done;
 	}
 
-	/* 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;
+		status = NT_STATUS_ACCESS_DENIED;
+		goto done;
 	}
 
-	DEBUG(10,("Creating alias %s with gid %u\n", groupname, (unsigned int)gid));
+	DEBUG(10, ("Creating alias %s with gid %u\n", name, (unsigned)gid));
 
-	map.gid = gid;
-	sid_copy(&map.sid, &sid);
-	map.sid_name_use = SID_NAME_ALIAS;
-	strlcpy(map.nt_name, groupname, sizeof(map.nt_name));
-	strlcpy(map.comment, "", sizeof(map.comment));
+	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);
+	status = pdb_add_group_mapping_entry(map);
 
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("pdb_create_builtin_alias: Could not add group mapping entry for alias %d "
 			  "(%s)\n", rid, nt_errstr(status)));
 	}
 
+done:
+	TALLOC_FREE(map);
 	return status;
 }
 
diff --git a/source3/groupdb/mapping.h b/source3/groupdb/mapping.h
index 045721d67e6..bb6cc02ed86 100644
--- a/source3/groupdb/mapping.h
+++ b/source3/groupdb/mapping.h
@@ -45,7 +45,7 @@ struct mapping_backend {
 	bool (*get_group_map_from_ntname)(const char *name, GROUP_MAP *map);
 	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,
 					 struct dom_sid **sids, size_t *num);
diff --git a/source3/groupdb/mapping_tdb.c b/source3/groupdb/mapping_tdb.c
index 0c4b2fa4059..394a2f0b223 100644
--- a/source3/groupdb/mapping_tdb.c
+++ b/source3/groupdb/mapping_tdb.c
@@ -34,7 +34,7 @@ static struct db_context *db; /* used for driver files */
 
 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);
 static bool group_map_remove(const struct dom_sid *sid);
@@ -175,6 +175,8 @@ static bool get_group_map_from_sid(struct dom_sid sid, GROUP_MAP *map)
 	char *key;
 	int ret = 0;
 	NTSTATUS status;
+	fstring nt_name;
+	fstring comment;
 
 	/* the key is the SID, retrieving is direct */
 
@@ -191,7 +193,7 @@ static bool get_group_map_from_sid(struct dom_sid sid, GROUP_MAP *map)
 
 	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);
 
@@ -202,6 +204,15 @@ static bool get_group_map_from_sid(struct dom_sid sid, GROUP_MAP *map)
 
 	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;
 }
 
@@ -209,6 +220,9 @@ static bool dbrec2map(const struct db_record *rec, GROUP_MAP *map)
 {
 	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,
@@ -221,9 +235,25 @@ static bool dbrec2map(const struct db_record *rec, GROUP_MAP *map)
 		return False;
 	}
 
-	return tdb_unpack(value.dptr, 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;
 }
 
 struct find_map_state {
@@ -323,55 +353,67 @@ struct enum_map_state {
 	bool unix_only;
 
 	size_t num_maps;
-	GROUP_MAP *maps;
+	GROUP_MAP **maps;
 };
 
 static int collect_map(struct db_record *rec, void *private_data)
 {
 	struct enum_map_state *state = (struct enum_map_state *)private_data;
-	GROUP_MAP map;
-	GROUP_MAP *tmp;
+	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)) {
+	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;
 }
 
 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;
@@ -385,6 +427,7 @@ static bool enum_group_mapping(const struct dom_sid *domsid,
 
 	status = dbwrap_traverse_read(db, collect_map, (void *)&state, NULL);
 	if (!NT_STATUS_IS_OK(status)) {
+		TALLOC_FREE(state.maps);
 		return false;
 	}
 
@@ -479,7 +522,7 @@ static bool is_aliasmem(const struct dom_sid *alias, const struct dom_sid *membe
 
 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;
 	char *new_memberstring;
@@ -487,12 +530,23 @@ static NTSTATUS add_aliasmem(const struct dom_sid *alias, const struct dom_sid *
 	NTSTATUS status;
 	TDB_DATA value;
 
-	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);
 
 	if (is_aliasmem(alias, member))
 		return NT_STATUS_MEMBER_IN_ALIAS;
@@ -629,15 +683,26 @@ static int collect_aliasmem(struct db_record *rec, void *priv)
 static NTSTATUS enum_aliasmem(const struct dom_sid *alias, TALLOC_CTX *mem_ctx,
 			      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;
 	*num = 0;
@@ -774,7 +839,7 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 			      TDB_DATA data, void *ptr)
 {
 	TALLOC_CTX *tmp_ctx = talloc_tos();
-	GROUP_MAP map;
+	GROUP_MAP *map = NULL;
 	uint8_t *p;
 	uint32_t format;
 	uint32_t num_el;
@@ -839,7 +904,11 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 		goto failed;
 	}
 
-	ZERO_STRUCT(map);
+	map = talloc_zero(NULL, GROUP_MAP);
+	if (!map) {
+		errno = ENOMEM;
+		goto failed;
+	}
 
 	for (i = 0; i < num_el; i++) {
 		uint32_t num_vals;
@@ -896,28 +965,34 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 			/* we ignore unknown or uninteresting attributes
 			 * (objectclass, etc.) */
 			if (strcasecmp_m(name, "gidNumber") == 0) {
-				map.gid = strtoul(val, &q, 10);
+				map->gid = strtoul(val, &q, 10);
 				if (*q) {
 					errno = EIO;
 					goto failed;
 				}
 			} else if (strcasecmp_m(name, "sid") == 0) {
-				if (!string_to_sid(&map.sid, val)) {
+				if (!string_to_sid(&map->sid, val)) {
 					errno = EIO;
 					goto failed;
 				}
 			} else if (strcasecmp_m(name, "sidNameUse") == 0) {
-				map.sid_name_use = strtoul(val, &q, 10);
+				map->sid_name_use = strtoul(val, &q, 10);
 				if (*q) {
 					errno = EIO;
 					goto failed;
 				}
 			} else if (strcasecmp_m(name, "ntname") == 0) {
-				strlcpy(map.nt_name, val,
-					sizeof(map.nt_name));
+				map->nt_name = talloc_strdup(map, val);
+				if (!map->nt_name) {
+					errno = ENOMEM;
+					goto failed;
+				}
 			} else if (strcasecmp_m(name, "comment") == 0) {
-				strlcpy(map.comment, val,
-					sizeof(map.comment));
+				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;
@@ -931,7 +1006,7 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 		TALLOC_FREE(name);
 	}
 
-	if (!add_mapping_entry(&map, 0)) {
+	if (!add_mapping_entry(map, 0)) {
 		errno = EIO;
 		goto failed;
 	}
@@ -939,7 +1014,7 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 	if (num_mem) {
 		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;
 				goto failed;
@@ -952,9 +1027,11 @@ static int convert_ldb_record(TDB_CONTEXT *ltdb, TDB_DATA key,
 			  remaining));
 	}
 
+	TALLOC_FREE(map);
 	return 0;
 
 failed:
+	TALLOC_FREE(map);
 	return -1;
 }
 
diff --git a/source3/groupdb/proto.h b/source3/groupdb/proto.h
index ddcdf7a3b9b..75d5c3963da 100644
--- a/source3/groupdb/proto.h
+++ b/source3/groupdb/proto.h
@@ -46,9 +46,11 @@ NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
 						   struct dom_sid sid);
 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);
 NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
 				  const char *name, uint32 *rid);
 NTSTATUS pdb_default_delete_alias(struct pdb_methods *methods,