****************************************************************************/
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,
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;
}
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"));
uint32 new_rid;
gid_t gid;
bool exists;
- GROUP_MAP map;
+ GROUP_MAP *map;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
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);
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,
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,
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));
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;
}
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);
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);
char *key;
int ret = 0;
NTSTATUS status;
+ fstring nt_name;
+ fstring comment;
/* the key is the SID, retrieving is direct */
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);
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;
}
{
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,
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 {
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;
status = dbwrap_traverse_read(db, collect_map, (void *)&state, NULL);
if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(state.maps);
return false;
}
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;
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;
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;
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;
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;
/* 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;
TALLOC_FREE(name);
}
- if (!add_mapping_entry(&map, 0)) {
+ if (!add_mapping_entry(map, 0)) {
errno = EIO;
goto failed;
}
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;
remaining));
}
+ TALLOC_FREE(map);
return 0;
failed:
+ TALLOC_FREE(map);
return -1;
}
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,
gid_t gid;
struct dom_sid sid;
enum lsa_SidType sid_name_use;
- fstring nt_name;
- fstring comment;
+ char *nt_name;
+ char *comment;
} GROUP_MAP;
#include "groupdb/proto.h"
NTSTATUS (*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,
+ GROUP_MAP ***pp_rmap, size_t *p_num_entries,
bool unix_only);
NTSTATUS (*enum_group_members)(struct pdb_methods *methods,
struct dom_sid member_sid;
struct samu *member = NULL;
const char *member_dn = NULL;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
uint32_t rid;
bool is_unix_member = false;
break;
}
- if (!get_domain_group_from_sid(group_sid, &map)) {
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return -1;
+ }
+
+ if (!get_domain_group_from_sid(group_sid, map)) {
DEBUG(0, ("Could not find global group %s\n",
sid_string_dbg(&group_sid)));
//return NT_STATUS_NO_SUCH_GROUP;
+ TALLOC_FREE(map);
return -1;
}
- if (!(grp = getgrgid(map.gid))) {
- DEBUG(0, ("Could not find unix group %lu\n", (unsigned long)map.gid));
+ if (!(grp = getgrgid(map->gid))) {
+ DEBUG(0, ("Could not find unix group %lu\n",
+ (unsigned long)map->gid));
//return NT_STATUS_NO_SUCH_GROUP;
+ TALLOC_FREE(map);
return -1;
}
+ TALLOC_FREE(map);
+
DEBUG(0,("Group members of %s: ", grp->gr_name));
if ( !(member = samu_new(talloc_tos())) ) {
NTSTATUS status;
fstring account;
struct samu *sam_account=NULL;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
struct dom_sid user_sid;
struct dom_sid group_sid;
group_sid = *pdb_get_group_sid(sam_account);
- if (!pdb_getgrsid(&map, group_sid)) {
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!pdb_getgrsid(map, group_sid)) {
DEBUG(0, ("Primary group of %s has no mapping!\n",
pdb_get_username(sam_account)));
} else {
- if (map.gid != passwd->pw_gid) {
- if (!(grp = getgrgid(map.gid))) {
+ if (map->gid != passwd->pw_gid) {
+ if (!(grp = getgrgid(map->gid))) {
DEBUG(0, ("Could not find unix group %lu for user %s (group SID=%s)\n",
- (unsigned long)map.gid, pdb_get_username(sam_account),
+ (unsigned long)map->gid, pdb_get_username(sam_account),
sid_string_dbg(&group_sid)));
} else {
smb_set_primary_group(grp->gr_name, pdb_get_username(sam_account));
}
}
+ TALLOC_FREE(map);
+
if ( !passwd ) {
DEBUG(1, ("No unix user for this account (%s), cannot adjust mappings\n",
pdb_get_username(sam_account)));
{
struct drsuapi_DsReplicaObjectListItemEx *cur = obj->cur;
NTSTATUS status;
- fstring name;
- fstring comment;
struct group *grp = NULL;
struct dom_sid group_sid;
uint32_t rid = 0;
struct dom_sid *dom_sid = NULL;
fstring sid_string;
- GROUP_MAP map;
+ GROUP_MAP *map;
bool insert = true;
const char *sAMAccountName;
return status;
}
- fstrcpy(name, sAMAccountName);
- fstrcpy(comment, description);
-
dom_sid_split_rid(mem_ctx, &group_sid, &dom_sid, &rid);
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (map == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
+ map->nt_name = talloc_strdup(map, sAMAccountName);
+ if (map->nt_name == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
+ if (description) {
+ map->comment = talloc_strdup(map, description);
+ } else {
+ map->comment = talloc_strdup(map, "");
+ }
+ if (map->comment == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+
sid_to_fstring(sid_string, &group_sid);
DEBUG(0,("Creating alias[%s] - %s members[%u]\n",
- name, sid_string, num_members));
+ map->nt_name, sid_string, num_members));
status = dssync_insert_obj(pctx, pctx->aliases, obj);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ goto done;
}
- if (pdb_getgrsid(&map, group_sid)) {
- if ( map.gid != -1 )
- grp = getgrgid(map.gid);
+ if (pdb_getgrsid(map, group_sid)) {
+ if (map->gid != -1) {
+ grp = getgrgid(map->gid);
+ }
insert = false;
}
gid_t gid;
/* No group found from mapping, find it from its name. */
- if ((grp = getgrnam(name)) == NULL) {
+ if ((grp = getgrnam(map->nt_name)) == NULL) {
/* No appropriate group found, create one */
- DEBUG(0,("Creating unix group: '%s'\n", name));
+ DEBUG(0, ("Creating unix group: '%s'\n",
+ map->nt_name));
- if (smb_create_group(name, &gid) != 0)
- return NT_STATUS_ACCESS_DENIED;
+ if (smb_create_group(map->nt_name, &gid) != 0) {
+ status = NT_STATUS_ACCESS_DENIED;
+ goto done;
+ }
- if ((grp = getgrgid(gid)) == NULL)
- return NT_STATUS_ACCESS_DENIED;
+ if ((grp = getgrgid(gid)) == NULL) {
+ status = NT_STATUS_ACCESS_DENIED;
+ goto done;
+ }
}
}
- map.gid = grp->gr_gid;
- map.sid = group_sid;
+ map->gid = grp->gr_gid;
+ map->sid = group_sid;
if (dom_sid_equal(dom_sid, &global_sid_Builtin)) {
/*
*
* map.sid_name_use = SID_NAME_WKN_GRP;
*/
- map.sid_name_use = SID_NAME_ALIAS;
+ map->sid_name_use = SID_NAME_ALIAS;
} else {
- map.sid_name_use = SID_NAME_ALIAS;
+ map->sid_name_use = SID_NAME_ALIAS;
}
- strlcpy(map.nt_name, name, sizeof(map.nt_name));
- if (description) {
- strlcpy(map.comment, comment, sizeof(map.comment));
+ if (insert) {
+ pdb_add_group_mapping_entry(map);
} else {
- strlcpy(map.comment, "", sizeof(map.comment));
+ pdb_update_group_mapping_entry(map);
}
- if (insert)
- pdb_add_group_mapping_entry(&map);
- else
- pdb_update_group_mapping_entry(&map);
-
for (i=0; i < num_members; i++) {
struct dssync_passdb_mem *mem;
true /* active */,
&members[i], &mem);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ goto done;
}
}
- return NT_STATUS_OK;
+ status = NT_STATUS_OK;
+
+done:
+ TALLOC_FREE(map);
+ return status;
}
/****************************************************************
{
struct drsuapi_DsReplicaObjectListItemEx *cur = obj->cur;
NTSTATUS status;
- fstring name;
- fstring comment;
struct group *grp = NULL;
struct dom_sid group_sid;
fstring sid_string;
- GROUP_MAP map;
+ GROUP_MAP *map;
bool insert = true;
const char *sAMAccountName;
return status;
}
- fstrcpy(name, sAMAccountName);
- fstrcpy(comment, description);
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ map->nt_name = talloc_strdup(map, sAMAccountName);
+ if (!map->nt_name) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
+ if (description) {
+ map->comment = talloc_strdup(map, description);
+ } else {
+ map->comment = talloc_strdup(map, "");
+ }
+ if (!map->comment) {
+ status = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
sid_to_fstring(sid_string, &group_sid);
DEBUG(0,("Creating group[%s] - %s members [%u]\n",
- name, sid_string, num_members));
+ map->nt_name, sid_string, num_members));
status = dssync_insert_obj(pctx, pctx->groups, obj);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ goto done;
}
- if (pdb_getgrsid(&map, group_sid)) {
- if ( map.gid != -1 )
- grp = getgrgid(map.gid);
+ if (pdb_getgrsid(map, group_sid)) {
+ if (map->gid != -1) {
+ grp = getgrgid(map->gid);
+ }
insert = false;
}
gid_t gid;
/* No group found from mapping, find it from its name. */
- if ((grp = getgrnam(name)) == NULL) {
+ if ((grp = getgrnam(map->nt_name)) == NULL) {
/* No appropriate group found, create one */
- DEBUG(0,("Creating unix group: '%s'\n", name));
+ DEBUG(0, ("Creating unix group: '%s'\n",
+ map->nt_name));
- if (smb_create_group(name, &gid) != 0)
- return NT_STATUS_ACCESS_DENIED;
+ if (smb_create_group(map->nt_name, &gid) != 0) {
+ status = NT_STATUS_ACCESS_DENIED;
+ goto done;
+ }
- if ((grp = getgrnam(name)) == NULL)
- return NT_STATUS_ACCESS_DENIED;
+ if ((grp = getgrnam(map->nt_name)) == NULL) {
+ status = NT_STATUS_ACCESS_DENIED;
+ goto done;
+ }
}
}
- map.gid = grp->gr_gid;
- map.sid = group_sid;
- map.sid_name_use = SID_NAME_DOM_GRP;
- strlcpy(map.nt_name, name, sizeof(map.nt_name));
- if (description) {
- strlcpy(map.comment, comment, sizeof(map.comment));
+ map->gid = grp->gr_gid;
+ map->sid = group_sid;
+ map->sid_name_use = SID_NAME_DOM_GRP;
+
+ if (insert) {
+ pdb_add_group_mapping_entry(map);
} else {
- strlcpy(map.comment, "", sizeof(map.comment));
+ pdb_update_group_mapping_entry(map);
}
- if (insert)
- pdb_add_group_mapping_entry(&map);
- else
- pdb_update_group_mapping_entry(&map);
-
for (i=0; i < num_members; i++) {
struct dssync_passdb_mem *mem;
true /* active */,
&members[i], &mem);
if (!NT_STATUS_IS_OK(status)) {
- return status;
+ goto done;
}
}
- return NT_STATUS_OK;
+ status = NT_STATUS_OK;
+
+done:
+ TALLOC_FREE(map);
+ return status;
}
/****************************************************************
NTSTATUS nt_ret = NT_STATUS_UNSUCCESSFUL;
fstring account;
struct samu *sam_account=NULL;
- GROUP_MAP map;
+ GROUP_MAP *map = NULL;
struct group *grp;
struct dom_sid user_sid;
struct dom_sid group_sid;
group_sid = *pdb_get_group_sid(sam_account);
- if (!pdb_getgrsid(&map, group_sid)) {
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!pdb_getgrsid(map, group_sid)) {
DEBUG(0, ("Primary group of %s has no mapping!\n",
pdb_get_username(sam_account)));
} else {
- if (map.gid != passwd->pw_gid) {
- if (!(grp = getgrgid(map.gid))) {
+ if (map->gid != passwd->pw_gid) {
+ if (!(grp = getgrgid(map->gid))) {
DEBUG(0, ("Could not find unix group %lu for user %s (group SID=%s)\n",
- (unsigned long)map.gid, pdb_get_username(sam_account), sid_string_tos(&group_sid)));
+ (unsigned long)map->gid, pdb_get_username(sam_account), sid_string_tos(&group_sid)));
} else {
smb_set_primary_group(grp->gr_name, pdb_get_username(sam_account));
}
done:
TALLOC_FREE(sam_account);
+ TALLOC_FREE(map);
return nt_ret;
}
uint32_t rid,
struct netr_DELTA_GROUP *r)
{
- fstring name;
- fstring comment;
struct group *grp = NULL;
struct dom_sid group_sid;
fstring sid_string;
- GROUP_MAP map;
+ GROUP_MAP *map;
bool insert = true;
- fstrcpy(name, r->group_name.string);
- fstrcpy(comment, r->description.string);
-
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
/* add the group to the mapping table */
sid_compose(&group_sid, get_global_sam_sid(), rid);
sid_to_fstring(sid_string, &group_sid);
- if (pdb_getgrsid(&map, group_sid)) {
- if ( map.gid != -1 )
- grp = getgrgid(map.gid);
+ if (pdb_getgrsid(map, group_sid)) {
+ if (map->gid != -1) {
+ grp = getgrgid(map->gid);
+ }
insert = false;
}
+ map->nt_name = talloc_strdup(map, r->group_name.string);
+ if (!map->nt_name) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ map->comment = talloc_strdup(map, r->description.string);
+ if (!map->comment) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
if (grp == NULL) {
gid_t gid;
/* No group found from mapping, find it from its name. */
- if ((grp = getgrnam(name)) == NULL) {
+ if ((grp = getgrnam(map->nt_name)) == NULL) {
/* No appropriate group found, create one */
- d_printf("Creating unix group: '%s'\n", name);
+ d_printf("Creating unix group: '%s'\n", map->nt_name);
- if (smb_create_group(name, &gid) != 0)
+ if (smb_create_group(map->nt_name, &gid) != 0)
return NT_STATUS_ACCESS_DENIED;
- if ((grp = getgrnam(name)) == NULL)
+ if ((grp = getgrnam(map->nt_name)) == NULL)
return NT_STATUS_ACCESS_DENIED;
}
}
- map.gid = grp->gr_gid;
- map.sid = group_sid;
- map.sid_name_use = SID_NAME_DOM_GRP;
- strlcpy(map.nt_name, name, sizeof(map.nt_name));
- if (r->description.string) {
- strlcpy(map.comment, comment, sizeof(map.comment));
+ map->gid = grp->gr_gid;
+ map->sid = group_sid;
+ map->sid_name_use = SID_NAME_DOM_GRP;
+
+ if (insert) {
+ pdb_add_group_mapping_entry(map);
} else {
- strlcpy(map.comment, "", sizeof(map.comment));
+ pdb_update_group_mapping_entry(map);
}
- if (insert)
- pdb_add_group_mapping_entry(&map);
- else
- pdb_update_group_mapping_entry(&map);
-
+ TALLOC_FREE(map);
return NT_STATUS_OK;
}
char **nt_members = NULL;
char **unix_members;
struct dom_sid group_sid;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
if (r->num_rids == 0) {
sid_compose(&group_sid, get_global_sam_sid(), rid);
- if (!get_domain_group_from_sid(group_sid, &map)) {
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!get_domain_group_from_sid(group_sid, map)) {
DEBUG(0, ("Could not find global group %d\n", rid));
+ TALLOC_FREE(map);
return NT_STATUS_NO_SUCH_GROUP;
}
- if (!(grp = getgrgid(map.gid))) {
- DEBUG(0, ("Could not find unix group %lu\n", (unsigned long)map.gid));
+ if (!(grp = getgrgid(map->gid))) {
+ DEBUG(0, ("Could not find unix group %lu\n",
+ (unsigned long)map->gid));
+ TALLOC_FREE(map);
return NT_STATUS_NO_SUCH_GROUP;
}
+ TALLOC_FREE(map);
+
d_printf("Group members of %s: ", grp->gr_name);
if (r->num_rids) {
struct netr_DELTA_ALIAS *r,
const struct dom_sid *dom_sid)
{
- fstring name;
- fstring comment;
struct group *grp = NULL;
struct dom_sid alias_sid;
fstring sid_string;
- GROUP_MAP map;
+ GROUP_MAP *map;
bool insert = true;
- fstrcpy(name, r->alias_name.string);
- fstrcpy(comment, r->description.string);
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
/* Find out whether the group is already mapped */
sid_compose(&alias_sid, dom_sid, rid);
sid_to_fstring(sid_string, &alias_sid);
- if (pdb_getgrsid(&map, alias_sid)) {
- grp = getgrgid(map.gid);
+ if (pdb_getgrsid(map, alias_sid)) {
+ grp = getgrgid(map->gid);
insert = false;
}
+ map->nt_name = talloc_strdup(map, r->alias_name.string);
+ if (!map->nt_name) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ map->comment = talloc_strdup(map, r->description.string);
+ if (!map->comment) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
if (grp == NULL) {
gid_t gid;
/* No group found from mapping, find it from its name. */
- if ((grp = getgrnam(name)) == NULL) {
+ if ((grp = getgrnam(map->nt_name)) == NULL) {
/* No appropriate group found, create one */
- d_printf("Creating unix group: '%s'\n", name);
- if (smb_create_group(name, &gid) != 0)
+ d_printf("Creating unix group: '%s'\n", map->nt_name);
+ if (smb_create_group(map->nt_name, &gid) != 0)
return NT_STATUS_ACCESS_DENIED;
if ((grp = getgrgid(gid)) == NULL)
return NT_STATUS_ACCESS_DENIED;
}
}
- map.gid = grp->gr_gid;
- map.sid = alias_sid;
+ map->gid = grp->gr_gid;
+ map->sid = alias_sid;
- if (dom_sid_equal(dom_sid, &global_sid_Builtin))
- map.sid_name_use = SID_NAME_WKN_GRP;
- else
- map.sid_name_use = SID_NAME_ALIAS;
-
- strlcpy(map.nt_name, name, sizeof(map.nt_name));
- strlcpy(map.comment, comment, sizeof(map.comment));
+ if (dom_sid_equal(dom_sid, &global_sid_Builtin)) {
+ map->sid_name_use = SID_NAME_WKN_GRP;
+ } else {
+ map->sid_name_use = SID_NAME_ALIAS;
+ }
- if (insert)
- pdb_add_group_mapping_entry(&map);
- else
- pdb_update_group_mapping_entry(&map);
+ if (insert) {
+ pdb_add_group_mapping_entry(map);
+ } else {
+ pdb_update_group_mapping_entry(map);
+ }
+ TALLOC_FREE(map);
return NT_STATUS_OK;
}
static bool legacy_sid_to_gid(const struct dom_sid *psid, gid_t *pgid)
{
- GROUP_MAP map;
+ GROUP_MAP *map;
union unid_t id;
enum lsa_SidType type;
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return false;
+ }
+
if ((sid_check_is_in_builtin(psid) ||
sid_check_is_in_wellknown_domain(psid))) {
bool ret;
become_root();
- ret = pdb_getgrsid(&map, *psid);
+ ret = pdb_getgrsid(map, *psid);
unbecome_root();
if (ret) {
- *pgid = map.gid;
+ *pgid = map->gid;
goto done;
}
DEBUG(10,("LEGACY: mapping failed for sid %s\n",
store_gid_sid_cache(psid, *pgid);
+ TALLOC_FREE(map);
return true;
}
bool lookup_global_sam_name(const char *name, int flags, uint32_t *rid,
enum lsa_SidType *type)
{
- GROUP_MAP map;
+ GROUP_MAP *map;
bool ret;
/* Windows treats "MACHINE\None" as a special name for
* Maybe it is a group ?
*/
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return false;
+ }
+
become_root();
- ret = pdb_getgrnam(&map, name);
+ ret = pdb_getgrnam(map, name);
unbecome_root();
if (!ret) {
+ TALLOC_FREE(map);
return False;
}
/* BUILTIN groups are looked up elsewhere */
- if (!sid_check_is_in_our_domain(&map.sid)) {
+ if (!sid_check_is_in_our_domain(&map->sid)) {
DEBUG(10, ("Found group %s (%s) not in our domain -- "
- "ignoring.", name, sid_string_dbg(&map.sid)));
+ "ignoring.", name, sid_string_dbg(&map->sid)));
+ TALLOC_FREE(map);
return False;
}
/* yes it's a mapped group */
- sid_peek_rid(&map.sid, rid);
- *type = map.sid_name_use;
+ sid_peek_rid(&map->sid, rid);
+ *type = map->sid_name_use;
+ TALLOC_FREE(map);
return True;
}
if (str == NULL) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- fstrcpy(map->nt_name, str);
- TALLOC_FREE(str);
+ map->nt_name = talloc_move(map, &str);
str = tldap_talloc_single_attribute(group[0], "description",
talloc_tos());
if (str != NULL) {
- fstrcpy(map->comment, str);
- TALLOC_FREE(str);
+ map->comment = talloc_move(map, &str);
} else {
- map->comment[0] = '\0';
+ map->comment = talloc_strdup(map, "");
}
if (pmsg != NULL) {
char *filter;
struct tldap_message *existing;
char *dn;
- GROUP_MAP existing_map;
+ GROUP_MAP *existing_map;
int rc, num_mods = 0;
bool ret;
NTSTATUS status;
if (filter == NULL) {
return NT_STATUS_NO_MEMORY;
}
- status = pdb_ads_getgrfilter(m, &existing_map, filter,
+
+ existing_map = talloc_zero(talloc_tos(), GROUP_MAP);
+ if (!existing_map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ status = pdb_ads_getgrfilter(m, existing_map, filter,
talloc_tos(), &existing);
+ TALLOC_FREE(existing_map);
TALLOC_FREE(filter);
if (!tldap_entry_dn(existing, &dn)) {
static NTSTATUS pdb_ads_enum_group_mapping(struct pdb_methods *m,
const struct dom_sid *sid,
enum lsa_SidType sid_name_use,
- GROUP_MAP **pp_rmap,
+ GROUP_MAP ***pp_rmap,
size_t *p_num_entries,
bool unix_only)
{
uint32_t rid)
{
struct dom_sid group_sid;
- GROUP_MAP map;
+ GROUP_MAP *map;
NTSTATUS status;
struct group *grp;
const char *grp_name;
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* coverity */
- map.gid = (gid_t) -1;
+ map->gid = (gid_t) -1;
sid_compose(&group_sid, get_global_sam_sid(), rid);
- if (!get_domain_group_from_sid(group_sid, &map)) {
+ if (!get_domain_group_from_sid(group_sid, map)) {
DEBUG(10, ("Could not find group for rid %d\n", rid));
return NT_STATUS_NO_SUCH_GROUP;
}
/* We need the group name for the smb_delete_group later on */
- if (map.gid == (gid_t)-1) {
+ if (map->gid == (gid_t)-1) {
return NT_STATUS_NO_SUCH_GROUP;
}
- grp = getgrgid(map.gid);
+ grp = getgrgid(map->gid);
if (grp == NULL) {
return NT_STATUS_NO_SUCH_GROUP;
}
+ TALLOC_FREE(map);
+
/* Copy the name, no idea what pdb_delete_group_mapping_entry does.. */
grp_name = talloc_strdup(mem_ctx, grp->gr_name);
return pdb->delete_group_mapping_entry(pdb, sid);
}
-bool pdb_enum_group_mapping(const struct dom_sid *sid, enum lsa_SidType sid_name_use, GROUP_MAP **pp_rmap,
- size_t *p_num_entries, bool unix_only)
+bool pdb_enum_group_mapping(const struct dom_sid *sid,
+ enum lsa_SidType sid_name_use,
+ GROUP_MAP ***pp_rmap,
+ size_t *p_num_entries,
+ bool unix_only)
{
struct pdb_methods *pdb = pdb_get_methods();
return NT_STATUS_IS_OK(pdb-> enum_group_mapping(pdb, sid, sid_name_use,
{
struct dom_sid group_sid, member_sid;
struct samu *account = NULL;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
struct passwd *pwd;
const char *group_name;
uid_t uid;
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* coverity */
- map.gid = (gid_t) -1;
+ map->gid = (gid_t) -1;
sid_compose(&group_sid, get_global_sam_sid(), group_rid);
sid_compose(&member_sid, get_global_sam_sid(), member_rid);
- if (!get_domain_group_from_sid(group_sid, &map) ||
- (map.gid == (gid_t)-1) ||
- ((grp = getgrgid(map.gid)) == NULL)) {
+ if (!get_domain_group_from_sid(group_sid, map) ||
+ (map->gid == (gid_t)-1) ||
+ ((grp = getgrgid(map->gid)) == NULL)) {
return NT_STATUS_NO_SUCH_GROUP;
}
+ TALLOC_FREE(map);
+
group_name = talloc_strdup(mem_ctx, grp->gr_name);
if (group_name == NULL) {
return NT_STATUS_NO_MEMORY;
{
struct dom_sid group_sid, member_sid;
struct samu *account = NULL;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
struct passwd *pwd;
const char *group_name;
uid_t uid;
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
sid_compose(&group_sid, get_global_sam_sid(), group_rid);
sid_compose(&member_sid, get_global_sam_sid(), member_rid);
- if (!get_domain_group_from_sid(group_sid, &map) ||
- (map.gid == (gid_t)-1) ||
- ((grp = getgrgid(map.gid)) == NULL)) {
+ if (!get_domain_group_from_sid(group_sid, map) ||
+ (map->gid == (gid_t)-1) ||
+ ((grp = getgrgid(map->gid)) == NULL)) {
return NT_STATUS_NO_SUCH_GROUP;
}
+ TALLOC_FREE(map);
+
group_name = talloc_strdup(mem_ctx, grp->gr_name);
if (group_name == NULL) {
return NT_STATUS_NO_MEMORY;
static bool pdb_default_gid_to_sid(struct pdb_methods *methods, gid_t gid,
struct dom_sid *sid)
{
- GROUP_MAP map;
+ GROUP_MAP *map;
- if (!NT_STATUS_IS_OK(methods->getgrgid(methods, &map, gid))) {
- return False;
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return false;
}
- sid_copy(sid, &map.sid);
- return True;
+ if (!NT_STATUS_IS_OK(methods->getgrgid(methods, map, gid))) {
+ TALLOC_FREE(map);
+ return false;
+ }
+
+ sid_copy(sid, &map->sid);
+ TALLOC_FREE(map);
+ return true;
}
static bool pdb_default_sid_to_id(struct pdb_methods *methods,
if (sid_check_is_in_builtin(sid) ||
sid_check_is_in_wellknown_domain(sid)) {
/* Here we only have aliases */
- GROUP_MAP map;
- if (!NT_STATUS_IS_OK(methods->getgrsid(methods, &map, *sid))) {
+ GROUP_MAP *map;
+
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ ret = false;
+ goto done;
+ }
+
+ if (!NT_STATUS_IS_OK(methods->getgrsid(methods, map, *sid))) {
DEBUG(10, ("Could not find map for sid %s\n",
sid_string_dbg(sid)));
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(10, ("Map for sid %s is a %s, expected an "
"alias\n", sid_string_dbg(sid),
- sid_type_lookup(map.sid_name_use)));
+ sid_type_lookup(map->sid_name_use)));
goto done;
}
- id->gid = map.gid;
+ id->gid = map->gid;
*type = SID_NAME_ALIAS;
ret = True;
goto done;
union unid_t *unix_id)
{
struct samu *sam_account = NULL;
- GROUP_MAP map;
+ GROUP_MAP *map = NULL;
bool ret;
struct dom_sid sid;
return False;
}
+ map = talloc_zero(mem_ctx, GROUP_MAP);
+ if (!map) {
+ return false;
+ }
+
/* BEING ROOT BLOCK */
become_root();
- if (pdb_getsampwsid(sam_account, &sid)) {
+ ret = pdb_getsampwsid(sam_account, &sid);
+ if (!ret) {
+ TALLOC_FREE(sam_account);
+ ret = pdb_getgrsid(map, sid);
+ }
+ unbecome_root();
+ /* END BECOME_ROOT BLOCK */
+
+ if (sam_account || !ret) {
+ TALLOC_FREE(map);
+ }
+
+ if (sam_account) {
struct passwd *pw;
- unbecome_root(); /* -----> EXIT BECOME_ROOT() */
*name = talloc_strdup(mem_ctx, pdb_get_username(sam_account));
if (!*name) {
TALLOC_FREE(sam_account);
unix_id->uid = pw->pw_uid;
TALLOC_FREE(pw);
return True;
- }
- TALLOC_FREE(sam_account);
- ret = pdb_getgrsid(&map, sid);
- unbecome_root();
- /* END BECOME_ROOT BLOCK */
+ } else if (map && (map->gid != (gid_t)-1)) {
- /* do not resolve SIDs to a name unless there is a valid
- gid associated with it */
+ /* do not resolve SIDs to a name unless there is a valid
+ gid associated with it */
- if ( ret && (map.gid != (gid_t)-1) ) {
- *name = talloc_strdup(mem_ctx, map.nt_name);
- *psid_name_use = map.sid_name_use;
+ *name = talloc_steal(mem_ctx, map->nt_name);
+ *psid_name_use = map->sid_name_use;
if ( unix_id ) {
- unix_id->gid = map.gid;
+ unix_id->gid = map->gid;
}
+ TALLOC_FREE(map);
return True;
}
+ TALLOC_FREE(map);
+
/* Windows will always map RID 513 to something. On a non-domain
controller, this gets mapped to SERVER\None. */
}
struct group_search {
- GROUP_MAP *groups;
+ GROUP_MAP **groups;
size_t num_groups, current_group;
};
{
struct group_search *state = (struct group_search *)s->private_data;
uint32_t rid;
- GROUP_MAP *map = &state->groups[state->current_group];
+ GROUP_MAP *map;
if (state->current_group == state->num_groups)
return False;
+ map = state->groups[state->current_group];
+
sid_peek_rid(&map->sid, &rid);
fill_displayentry(s, rid, 0, map->nt_name, NULL, map->comment, entry);
{
struct group_search *state =
(struct group_search *)search->private_data;
- SAFE_FREE(state->groups);
+ TALLOC_FREE(state->groups);
}
static bool pdb_search_grouptype(struct pdb_methods *methods,
{
struct group_search *state;
- state = talloc(search, struct group_search);
+ state = talloc_zero(search, struct group_search);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
return False;
return false;
}
}
- fstrcpy(map->nt_name, temp);
+ map->nt_name = talloc_strdup(map, temp);
+ if (!map->nt_name) {
+ TALLOC_FREE(ctx);
+ return false;
+ }
TALLOC_FREE(temp);
temp = smbldap_talloc_single_attribute(
return false;
}
}
- fstrcpy(map->comment, temp);
+ map->comment = talloc_strdup(map, temp);
+ if (!map->comment) {
+ TALLOC_FREE(ctx);
+ return false;
+ }
if (lp_parm_bool(-1, "ldapsam", "trusted", false)) {
store_gid_sid_cache(&map->sid, map->gid);
static NTSTATUS ldapsam_enum_group_mapping(struct pdb_methods *methods,
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)
{
- GROUP_MAP map = { 0, };
+ GROUP_MAP *map = NULL;
size_t entries = 0;
*p_num_entries = 0;
- *pp_rmap = NULL;
+ **pp_rmap = NULL;
if (!NT_STATUS_IS_OK(ldapsam_setsamgrent(methods, False))) {
DEBUG(0, ("ldapsam_enum_group_mapping: Unable to open "
return NT_STATUS_ACCESS_DENIED;
}
- while (NT_STATUS_IS_OK(ldapsam_getsamgrent(methods, &map))) {
+ while (true) {
+
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!NT_STATUS_IS_OK(ldapsam_getsamgrent(methods, map))) {
+ TALLOC_FREE(map);
+ break;
+ }
+
if (sid_name_use != SID_NAME_UNKNOWN &&
- sid_name_use != map.sid_name_use) {
+ sid_name_use != map->sid_name_use) {
DEBUG(11,("ldapsam_enum_group_mapping: group %s is "
- "not of the requested type\n", map.nt_name));
+ "not of the requested type\n",
+ map->nt_name));
continue;
}
- if (unix_only==ENUM_ONLY_MAPPED && map.gid==-1) {
+ if (unix_only == ENUM_ONLY_MAPPED && map->gid == -1) {
DEBUG(11,("ldapsam_enum_group_mapping: group %s is "
- "non mapped\n", map.nt_name));
+ "non mapped\n", map->nt_name));
continue;
}
- (*pp_rmap)=SMB_REALLOC_ARRAY((*pp_rmap), GROUP_MAP, entries+1);
+ *pp_rmap = talloc_realloc(NULL, *pp_rmap,
+ GROUP_MAP *, entries + 1);
if (!(*pp_rmap)) {
DEBUG(0,("ldapsam_enum_group_mapping: Unable to "
"enlarge group map!\n"));
return NT_STATUS_UNSUCCESSFUL;
}
- (*pp_rmap)[entries] = map;
+ (*pp_rmap)[entries] = talloc_move((*pp_rmap), &map);
entries += 1;
-
}
+
ldapsam_endsamgrent(methods);
*p_num_entries = entries;
talloc_free(tmp_ctx);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- fstrcpy(map->nt_name, str);
+ map->nt_name = talloc_strdup(map, str);
+ if (!map->nt_name) {
+ talloc_free(tmp_ctx);
+ return NT_STATUS_NO_MEMORY;
+ }
str = ldb_msg_find_attr_as_string(msg, "description",
NULL);
if (str != NULL) {
- fstrcpy(map->comment, str);
+ map->comment = talloc_strdup(map, str);
} else {
- map->comment[0] = '\0';
+ map->comment = talloc_strdup(map, "");
+ }
+ if (!map->comment) {
+ talloc_free(tmp_ctx);
+ return NT_STATUS_NO_MEMORY;
}
talloc_free(tmp_ctx);
static NTSTATUS pdb_samba4_enum_group_mapping(struct pdb_methods *m,
const struct dom_sid *sid,
enum lsa_SidType sid_name_use,
- GROUP_MAP **pp_rmap,
+ GROUP_MAP ***pp_rmap,
size_t *p_num_entries,
bool unix_only)
{
static bool _make_group_map(struct pdb_methods *methods, const char *domain, const char *name, enum lsa_SidType name_type, gid_t gid, struct dom_sid *sid, GROUP_MAP *map)
{
- snprintf(map->nt_name, sizeof(map->nt_name), "%s%c%s",
+ map->nt_name = talloc_asprintf(map, "%s%c%s",
domain, *lp_winbind_separator(), name);
+ if (!map->nt_name) {
+ return false;
+ }
map->sid_name_use = name_type;
map->sid = *sid;
map->gid = gid;
static NTSTATUS pdb_wbc_sam_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,
+ GROUP_MAP ***pp_rmap, size_t *p_num_entries,
bool unix_only)
{
return NT_STATUS_NOT_IMPLEMENTED;
NTSTATUS pdb_add_group_mapping_entry(GROUP_MAP *map);
NTSTATUS pdb_update_group_mapping_entry(GROUP_MAP *map);
NTSTATUS pdb_delete_group_mapping_entry(struct dom_sid sid);
-bool pdb_enum_group_mapping(const struct dom_sid *sid, enum lsa_SidType sid_name_use, GROUP_MAP **pp_rmap,
- size_t *p_num_entries, bool unix_only);
+bool pdb_enum_group_mapping(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_enum_group_members(TALLOC_CTX *mem_ctx,
const struct dom_sid *sid,
uint32_t **pp_member_rids,
int unix_only = 0;
PyObject *py_domain_sid;
struct dom_sid *domain_sid = NULL;
- GROUP_MAP *gmap, *group_map;
+ GROUP_MAP **gmap, *group_map;
size_t num_entries;
PyObject *py_gmap_list, *py_group_map;
int i;
py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
if (py_group_map) {
group_map = pytalloc_get_ptr(py_group_map);
- *group_map = gmap[i];
+ *group_map = *gmap[i];
+ talloc_steal(group_map, gmap[i]->nt_name);
+ talloc_steal(group_map, gmap[i]->comment);
PyList_Append(py_gmap_list, py_group_map);
}
}
- free(gmap);
+ talloc_free(gmap);
talloc_free(tframe);
return py_gmap_list;
struct lsa_SetSystemAccessAccount *r)
{
struct lsa_info *info=NULL;
- GROUP_MAP map;
+ NTSTATUS status;
+ GROUP_MAP *map;
/* find the connection policy handle. */
if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
return NT_STATUS_ACCESS_DENIED;
}
- if (!pdb_getgrsid(&map, info->sid))
+ map = talloc_zero(p->mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if (!pdb_getgrsid(map, info->sid)) {
+ TALLOC_FREE(map);
return NT_STATUS_NO_SUCH_GROUP;
+ }
- return pdb_update_group_mapping_entry(&map);
+ status = pdb_update_group_mapping_entry(map);
+ TALLOC_FREE(map);
+ return status;
}
/***************************************************************************
{
struct samr_group_info *ginfo;
NTSTATUS status;
- GROUP_MAP map;
+ GROUP_MAP *map;
union samr_GroupInfo *info = NULL;
bool ret;
uint32_t attributes = SE_GROUP_MANDATORY |
return status;
}
+ map = talloc_zero(p->mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
become_root();
- ret = get_domain_group_from_sid(ginfo->sid, &map);
+ ret = get_domain_group_from_sid(ginfo->sid, map);
unbecome_root();
if (!ret)
return NT_STATUS_INVALID_HANDLE;
- /* FIXME: map contains fstrings */
- group_name = talloc_strdup(r, map.nt_name);
- group_description = talloc_strdup(r, map.comment);
+ group_name = talloc_move(r, &map->nt_name);
+ group_description = talloc_move(r, &map->comment);
+
+ TALLOC_FREE(map);
info = talloc_zero(p->mem_ctx, union samr_GroupInfo);
if (!info) {
struct samr_SetGroupInfo *r)
{
struct samr_group_info *ginfo;
- GROUP_MAP map;
+ GROUP_MAP *map;
NTSTATUS status;
bool ret;
return status;
}
+ map = talloc_zero(p->mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
become_root();
- ret = get_domain_group_from_sid(ginfo->sid, &map);
+ ret = get_domain_group_from_sid(ginfo->sid, map);
unbecome_root();
if (!ret)
return NT_STATUS_NO_SUCH_GROUP;
switch (r->in.level) {
case 2:
- fstrcpy(map.nt_name, r->in.info->name.string);
+ map->nt_name = talloc_strdup(map,
+ r->in.info->name.string);
+ if (!map->nt_name) {
+ return NT_STATUS_NO_MEMORY;
+ }
break;
case 3:
break;
case 4:
- fstrcpy(map.comment, r->in.info->description.string);
+ map->comment = talloc_strdup(map,
+ r->in.info->description.string);
+ if (!map->comment) {
+ return NT_STATUS_NO_MEMORY;
+ }
break;
default:
return NT_STATUS_INVALID_INFO_CLASS;
/******** BEGIN SeAddUsers BLOCK *********/
become_root();
- status = pdb_update_group_mapping_entry(&map);
+ status = pdb_update_group_mapping_entry(map);
unbecome_root();
/******** End SeAddUsers BLOCK *********/
+ TALLOC_FREE(map);
+
if (NT_STATUS_IS_OK(status)) {
force_flush_samr_cache(&ginfo->sid);
}
{
struct dom_sid info_sid;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct samr_domain_info *dinfo;
struct samr_group_info *ginfo;
struct security_descriptor *psd = NULL;
DEBUG(10, ("_samr_OpenGroup:Opening SID: %s\n",
sid_string_dbg(&info_sid)));
+ map = talloc_zero(p->mem_ctx, GROUP_MAP);
+ if (!map) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* check if that group really exists */
become_root();
- ret = get_domain_group_from_sid(info_sid, &map);
+ ret = get_domain_group_from_sid(info_sid, map);
unbecome_root();
if (!ret)
return NT_STATUS_NO_SUCH_GROUP;
+ TALLOC_FREE(map);
+
ginfo = policy_handle_create(p, r->out.group_handle,
acc_granted,
struct samr_group_info, &status);
**********************************************************/
static bool get_sid_from_input(struct dom_sid *sid, char *input)
{
- GROUP_MAP map;
+ GROUP_MAP *map;
+
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return false;
+ }
if (strncasecmp_m( input, "S-", 2)) {
/* Perhaps its the NT group name? */
- if (!pdb_getgrnam(&map, input)) {
+ if (!pdb_getgrnam(map, input)) {
printf(_("NT Group %s doesn't exist in mapping DB\n"),
input);
+ TALLOC_FREE(map);
return false;
} else {
- *sid = map.sid;
+ *sid = map->sid;
}
} else {
if (!string_to_sid(sid, input)) {
printf(_("converting sid %s from a string failed!\n"),
input);
+ TALLOC_FREE(map);
return false;
}
}
+ TALLOC_FREE(map);
return true;
}
/* list a single group is given a name */
if ( ntgroup[0] || sid_string[0] ) {
struct dom_sid sid;
- GROUP_MAP map;
+ GROUP_MAP *map;
if ( sid_string[0] )
strlcpy(ntgroup, sid_string, sizeof(ntgroup));
return -1;
}
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return -1;
+ }
+
/* Get the current mapping from the database */
- if(!pdb_getgrsid(&map, sid)) {
+ if(!pdb_getgrsid(map, sid)) {
d_fprintf(stderr,
_("Failure to local group SID in the "
"database\n"));
+ TALLOC_FREE(map);
return -1;
}
- print_map_entry(&map, long_list );
+ print_map_entry(map, long_list );
+ TALLOC_FREE(map);
}
else {
- GROUP_MAP *map=NULL;
+ GROUP_MAP **maps = NULL;
+ bool ok = false;
/* enumerate all group mappings */
- if (!pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN, &map, &entries, ENUM_ALL_MAPPED))
+ ok = pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN,
+ &maps, &entries,
+ ENUM_ALL_MAPPED);
+ if (!ok) {
return -1;
+ }
for (i=0; i<entries; i++) {
- print_map_entry(&map[i], long_list);
+ print_map_entry(maps[i], long_list);
}
- SAFE_FREE(map);
+ TALLOC_FREE(maps);
}
return 0;
uint32 rid = 0;
gid_t gid;
int i;
- GROUP_MAP map;
+ GROUP_MAP *map;
const char *name_type;
const char add_usage_str[] = N_("net groupmap add "
"[ntgroup=<string>] "
"[comment=<string>]");
- ZERO_STRUCT(map);
-
- /* Default is domain group. */
- map.sid_name_use = SID_NAME_DOM_GRP;
name_type = "domain group";
if (c->display_usage) {
return -1;
}
- {
- if (pdb_getgrgid(&map, gid)) {
- d_printf(_("Unix group %s already mapped to SID %s\n"),
- unixgrp, sid_string_tos(&map.sid));
- return -1;
- }
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return -1;
}
+ /* Default is domain group. */
+ map->sid_name_use = SID_NAME_DOM_GRP;
+ if (pdb_getgrgid(map, gid)) {
+ d_printf(_("Unix group %s already mapped to SID %s\n"),
+ unixgrp, sid_string_tos(&map->sid));
+ TALLOC_FREE(map);
+ return -1;
+ }
+ TALLOC_FREE(map);
if ( (rid == 0) && (string_sid[0] == '\0') ) {
d_printf(_("No rid or sid specified, choosing a RID\n"));
static int net_groupmap_modify(struct net_context *c, int argc, const char **argv)
{
struct dom_sid sid;
- GROUP_MAP map;
+ GROUP_MAP *map = NULL;
fstring ntcomment = "";
fstring type = "";
fstring ntgroup = "";
}
}
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ return -1;
+ }
+
/* Get the current mapping from the database */
- if(!pdb_getgrsid(&map, sid)) {
+ if(!pdb_getgrsid(map, sid)) {
d_fprintf(stderr,
_("Failed to find local group SID in the database\n"));
+ TALLOC_FREE(map);
return -1;
}
*/
if (sid_type == SID_NAME_UNKNOWN) {
d_fprintf(stderr, _("Can't map to an unknown group type.\n"));
+ TALLOC_FREE(map);
return -1;
}
- if (map.sid_name_use == SID_NAME_WKN_GRP) {
+ if (map->sid_name_use == SID_NAME_WKN_GRP) {
d_fprintf(stderr,
_("You can only change between domain and local "
"groups.\n"));
+ TALLOC_FREE(map);
return -1;
}
- map.sid_name_use=sid_type;
+ map->sid_name_use = sid_type;
/* Change comment if new one */
- if ( ntcomment[0] )
- strlcpy(map.comment, ntcomment, sizeof(map.comment));
+ if (ntcomment[0]) {
+ map->comment = talloc_strdup(map, ntcomment);
+ if (!map->comment) {
+ d_fprintf(stderr, _("Out of memory!\n"));
+ return -1;
+ }
+ }
- if ( ntgroup[0] )
- strlcpy(map.nt_name, ntgroup, sizeof(map.nt_name));
+ if (ntgroup[0]) {
+ map->nt_name = talloc_strdup(map, ntgroup);
+ if (!map->nt_name) {
+ d_fprintf(stderr, _("Out of memory!\n"));
+ return -1;
+ }
+ }
if ( unixgrp[0] ) {
gid = nametogid( unixgrp );
d_fprintf(stderr, _("Unable to lookup UNIX group %s. "
"Make sure the group exists.\n"),
unixgrp);
+ TALLOC_FREE(map);
return -1;
}
- map.gid = gid;
+ map->gid = gid;
}
- if ( !NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map)) ) {
+ if (!NT_STATUS_IS_OK(pdb_update_group_mapping_entry(map))) {
d_fprintf(stderr, _("Could not update group database\n"));
+ TALLOC_FREE(map);
return -1;
}
- d_printf(_("Updated mapping entry for %s\n"), map.nt_name);
+ d_printf(_("Updated mapping entry for %s\n"), map->nt_name);
+ TALLOC_FREE(map);
return 0;
}
{
const char *ntgroup = NULL;
struct group *grp = NULL;
- GROUP_MAP map;
+ GROUP_MAP *map;
bool have_map = false;
if ((argc < 1) || (argc > 2) || c->display_usage) {
}
}
- have_map = pdb_getgrnam(&map, ntgroup);
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ d_printf(_("Out of memory!\n"));
+ return -1;
+ }
+
+ have_map = pdb_getgrnam(map, ntgroup);
if (!have_map) {
struct dom_sid sid;
have_map = ( (strncmp(ntgroup, "S-", 2) == 0) &&
string_to_sid(&sid, ntgroup) &&
- pdb_getgrsid(&map, sid) );
+ pdb_getgrsid(map, sid) );
}
if (!have_map) {
d_fprintf(stderr,
_("Could not find group mapping for %s\n"),
ntgroup);
+ TALLOC_FREE(map);
return -1;
}
- map.gid = grp->gr_gid;
+ map->gid = grp->gr_gid;
if (c->opt_rid == 0) {
if ( pdb_capabilities() & PDB_CAP_STORE_RIDS ) {
if ( !pdb_new_rid((uint32*)&c->opt_rid) ) {
d_fprintf( stderr,
_("Could not allocate new RID\n"));
+ TALLOC_FREE(map);
return -1;
}
} else {
- c->opt_rid = algorithmic_pdb_gid_to_group_rid(map.gid);
+ c->opt_rid = algorithmic_pdb_gid_to_group_rid(map->gid);
}
}
- sid_compose(&map.sid, get_global_sam_sid(), c->opt_rid);
+ sid_compose(&map->sid, get_global_sam_sid(), c->opt_rid);
- map.sid_name_use = SID_NAME_DOM_GRP;
- fstrcpy(map.nt_name, ntgroup);
- fstrcpy(map.comment, "");
+ map->sid_name_use = SID_NAME_DOM_GRP;
+ map->nt_name = talloc_strdup(map, ntgroup);
+ map->comment = talloc_strdup(map, "");
+ if (!map->nt_name || !map->comment) {
+ d_printf(_("Out of memory!\n"));
+ TALLOC_FREE(map);
+ return -1;
+ }
- if (!NT_STATUS_IS_OK(pdb_add_group_mapping_entry(&map))) {
+ if (!NT_STATUS_IS_OK(pdb_add_group_mapping_entry(map))) {
d_fprintf(stderr,
_("Could not add mapping entry for %s\n"),
ntgroup);
+ TALLOC_FREE(map);
return -1;
}
}
/* Now we have a mapping entry, update that stuff */
if ( c->opt_localgroup || c->opt_domaingroup ) {
- if (map.sid_name_use == SID_NAME_WKN_GRP) {
+ if (map->sid_name_use == SID_NAME_WKN_GRP) {
d_fprintf(stderr,
_("Can't change type of the BUILTIN "
"group %s\n"),
- map.nt_name);
+ map->nt_name);
+ TALLOC_FREE(map);
return -1;
}
}
if (c->opt_localgroup)
- map.sid_name_use = SID_NAME_ALIAS;
+ map->sid_name_use = SID_NAME_ALIAS;
if (c->opt_domaingroup)
- map.sid_name_use = SID_NAME_DOM_GRP;
+ map->sid_name_use = SID_NAME_DOM_GRP;
/* The case (opt_domaingroup && opt_localgroup) was tested for above */
if ((c->opt_comment != NULL) && (strlen(c->opt_comment) > 0)) {
- fstrcpy(map.comment, c->opt_comment);
+ map->comment = talloc_strdup(map, c->opt_comment);
+ if (!map->comment) {
+ d_printf(_("Out of memory!\n"));
+ TALLOC_FREE(map);
+ return -1;
+ }
}
if ((c->opt_newntname != NULL) && (strlen(c->opt_newntname) > 0)) {
- fstrcpy(map.nt_name, c->opt_newntname);
+ map->nt_name = talloc_strdup(map, c->opt_newntname);
+ if (!map->nt_name) {
+ d_printf(_("Out of memory!\n"));
+ TALLOC_FREE(map);
+ return -1;
+ }
}
if (grp != NULL)
- map.gid = grp->gr_gid;
+ map->gid = grp->gr_gid;
- if (!NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map))) {
+ if (!NT_STATUS_IS_OK(pdb_update_group_mapping_entry(map))) {
d_fprintf(stderr, _("Could not update group mapping for %s\n"),
ntgroup);
+ TALLOC_FREE(map);
return -1;
}
+ TALLOC_FREE(map);
return 0;
}
static int net_groupmap_cleanup(struct net_context *c, int argc, const char **argv)
{
- GROUP_MAP *map = NULL;
+ GROUP_MAP **maps = NULL;
size_t i, entries;
if (c->display_usage) {
return 0;
}
- if (!pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN, &map, &entries,
+ if (!pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN, &maps, &entries,
ENUM_ALL_MAPPED)) {
d_fprintf(stderr, _("Could not list group mappings\n"));
return -1;
for (i=0; i<entries; i++) {
- if (map[i].gid == -1)
- printf(_("Group %s is not mapped\n"), map[i].nt_name);
+ if (maps[i]->gid == -1)
+ printf(_("Group %s is not mapped\n"),
+ maps[i]->nt_name);
- if (!sid_check_is_in_our_domain(&map[i].sid)) {
+ if (!sid_check_is_in_our_domain(&maps[i]->sid)) {
printf(_("Deleting mapping for NT Group %s, sid %s\n"),
- map[i].nt_name,
- sid_string_tos(&map[i].sid));
- pdb_delete_group_mapping_entry(map[i].sid);
+ maps[i]->nt_name,
+ sid_string_tos(&maps[i]->sid));
+ pdb_delete_group_mapping_entry(maps[i]->sid);
}
}
- SAFE_FREE(map);
-
+ TALLOC_FREE(maps);
return 0;
}
static int net_sam_set_comment(struct net_context *c, int argc,
const char **argv)
{
- GROUP_MAP map;
+ GROUP_MAP *map;
struct dom_sid sid;
enum lsa_SidType type;
const char *dom, *name;
return -1;
}
- if (!pdb_getgrsid(&map, sid)) {
+ map = talloc_zero(talloc_tos(), GROUP_MAP);
+ if (!map) {
+ d_fprintf(stderr, _("Out of memory!\n"));
+ return -1;
+ }
+
+ if (!pdb_getgrsid(map, sid)) {
d_fprintf(stderr, _("Could not load group %s\n"), argv[0]);
return -1;
}
- fstrcpy(map.comment, argv[1]);
+ map->comment = talloc_strdup(map, argv[1]);
+ if (!map->comment) {
+ d_fprintf(stderr, _("Out of memory!\n"));
+ return -1;
+ }
- status = pdb_update_group_mapping_entry(&map);
+ status = pdb_update_group_mapping_entry(map);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, _("Updating group mapping entry failed with "
d_printf("Updated comment of group %s\\%s to %s\n", dom, name,
argv[1]);
+ TALLOC_FREE(map);
return 0;
}
* Map a unix group to a domain group
*/
-static NTSTATUS map_unix_group(const struct group *grp, GROUP_MAP *pmap)
+static NTSTATUS map_unix_group(const struct group *grp, GROUP_MAP *map)
{
- NTSTATUS status;
- GROUP_MAP map;
- const char *grpname, *dom, *name;
+ const char *dom, *name;
uint32 rid;
- if (pdb_getgrgid(&map, grp->gr_gid)) {
+ if (pdb_getgrgid(map, grp->gr_gid)) {
return NT_STATUS_GROUP_EXISTS;
}
- map.gid = grp->gr_gid;
- grpname = grp->gr_name;
+ map->gid = grp->gr_gid;
- if (lookup_name(talloc_tos(), grpname, LOOKUP_NAME_LOCAL,
+ if (lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
&dom, &name, NULL, NULL)) {
- const char *tmp = talloc_asprintf(
- talloc_tos(), "Unix Group %s", grp->gr_name);
+ map->nt_name = talloc_asprintf(map, "Unix Group %s",
+ grp->gr_name);
DEBUG(5, ("%s exists as %s\\%s, retrying as \"%s\"\n",
- grpname, dom, name, tmp));
- grpname = tmp;
+ grp->gr_name, dom, name, map->nt_name));
}
- if (lookup_name(talloc_tos(), grpname, LOOKUP_NAME_LOCAL,
+ if (lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
NULL, NULL, NULL, NULL)) {
DEBUG(3, ("\"%s\" exists, can't map it\n", grp->gr_name));
return NT_STATUS_GROUP_EXISTS;
}
- fstrcpy(map.nt_name, grpname);
-
if (pdb_capabilities() & PDB_CAP_STORE_RIDS) {
if (!pdb_new_rid(&rid)) {
DEBUG(3, ("Could not get a new RID for %s\n",
rid = algorithmic_pdb_gid_to_group_rid( grp->gr_gid );
}
- sid_compose(&map.sid, get_global_sam_sid(), rid);
- map.sid_name_use = SID_NAME_DOM_GRP;
- fstrcpy(map.comment, talloc_asprintf(talloc_tos(), "Unix Group %s",
- grp->gr_name));
+ sid_compose(&map->sid, get_global_sam_sid(), rid);
+ map->sid_name_use = SID_NAME_DOM_GRP;
+ map->comment = talloc_asprintf(map, "Unix Group %s", grp->gr_name);
- status = pdb_add_group_mapping_entry(&map);
- if (NT_STATUS_IS_OK(status)) {
- *pmap = map;
- }
- return status;
+ return pdb_add_group_mapping_entry(map);
}
static int net_sam_mapunixgroup(struct net_context *c, int argc, const char **argv)
{
NTSTATUS status;
- GROUP_MAP map;
+ GROUP_MAP *map;
struct group *grp;
if (argc != 1 || c->display_usage) {
return -1;
}
- status = map_unix_group(grp, &map);
+ map = talloc_zero(talloc_tos(), GROUP_MAP);
+ if (!map) {
+ d_fprintf(stderr, _("Out of memory!\n"));
+ return -1;
+ }
+
+ status = map_unix_group(grp, map);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, _("Mapping group %s failed with %s\n"),
}
d_printf(_("Mapped unix group %s to SID %s\n"), argv[0],
- sid_string_tos(&map.sid));
+ sid_string_tos(&map->sid));
+ TALLOC_FREE(map);
return 0;
}
* Remove a group mapping
*/
-static NTSTATUS unmap_unix_group(const struct group *grp, GROUP_MAP *pmap)
+static NTSTATUS unmap_unix_group(const struct group *grp)
{
- GROUP_MAP map;
- const char *grpname;
struct dom_sid dom_sid;
- map.gid = grp->gr_gid;
- grpname = grp->gr_name;
-
- if (!lookup_name(talloc_tos(), grpname, LOOKUP_NAME_LOCAL,
+ if (!lookup_name(talloc_tos(), grp->gr_name, LOOKUP_NAME_LOCAL,
NULL, NULL, NULL, NULL)) {
DEBUG(3, ("\"%s\" does not exist, can't unmap it\n", grp->gr_name));
return NT_STATUS_NO_SUCH_GROUP;
}
- fstrcpy(map.nt_name, grpname);
-
- if (!pdb_gid_to_sid(map.gid, &dom_sid)) {
+ if (!pdb_gid_to_sid(grp->gr_gid, &dom_sid)) {
return NT_STATUS_UNSUCCESSFUL;
}
static int net_sam_unmapunixgroup(struct net_context *c, int argc, const char **argv)
{
NTSTATUS status;
- GROUP_MAP map;
struct group *grp;
if (argc != 1 || c->display_usage) {
return -1;
}
- status = unmap_unix_group(grp, &map);
+ status = unmap_unix_group(grp);
if (!NT_STATUS_IS_OK(status)) {
d_fprintf(stderr, _("Unmapping group %s failed with %s.\n"),
char *ldap_uri = NULL;
char *p;
struct smbldap_state *ls;
- GROUP_MAP gmap;
+ GROUP_MAP *gmap = NULL;
struct dom_sid gsid;
gid_t domusers_gid = -1;
gid_t domadmins_gid = -1;
sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_USERS);
- if (!pdb_getgrsid(&gmap, gsid)) {
+ gmap = talloc_zero(tc, GROUP_MAP);
+ if (!gmap) {
+ d_printf(_("Out of memory!\n"));
+ goto failed;
+ }
+
+ if (!pdb_getgrsid(gmap, gsid)) {
LDAPMod **mods = NULL;
char *dn;
char *uname;
}
if (is_ipa) {
- if (!pdb_getgrsid(&gmap, gsid)) {
+ if (!pdb_getgrsid(gmap, gsid)) {
d_fprintf(stderr, _("Failed to read just "
"created domain group.\n"));
goto failed;
} else {
- domusers_gid = gmap.gid;
+ domusers_gid = gmap->gid;
}
}
} else {
- domusers_gid = gmap.gid;
+ domusers_gid = gmap->gid;
d_printf(_("found!\n"));
}
sid_compose(&gsid, get_global_sam_sid(), DOMAIN_RID_ADMINS);
- if (!pdb_getgrsid(&gmap, gsid)) {
+ if (!pdb_getgrsid(gmap, gsid)) {
LDAPMod **mods = NULL;
char *dn;
char *uname;
}
if (is_ipa) {
- if (!pdb_getgrsid(&gmap, gsid)) {
+ if (!pdb_getgrsid(gmap, gsid)) {
d_fprintf(stderr, _("Failed to read just "
"created domain group.\n"));
goto failed;
} else {
- domadmins_gid = gmap.gid;
+ domadmins_gid = gmap->gid;
}
}
} else {
- domadmins_gid = gmap.gid;
+ domadmins_gid = gmap->gid;
d_printf(_("found!\n"));
}
goto done;
}
- if (!pdb_getgrgid(&gmap, pwd->pw_gid)) {
+ if (!pdb_getgrgid(gmap, pwd->pw_gid)) {
LDAPMod **mods = NULL;
char *dn;
char *uname;
static int export_groups (struct pdb_methods *in, struct pdb_methods *out)
{
- GROUP_MAP *maps = NULL;
+ GROUP_MAP **maps = NULL;
size_t i, entries = 0;
NTSTATUS status;
}
for (i=0; i<entries; i++) {
- out->add_group_mapping_entry(out, &(maps[i]));
+ out->add_group_mapping_entry(out, maps[i]);
}
- SAFE_FREE( maps );
+ TALLOC_FREE(maps);
return 0;
}
git.samba.org / obnox / samba / samba-obnox.git / commitdiff