*/
#include "includes.h"
+#include "system/filesys.h"
#include "groupdb/mapping.h"
+#include "dbwrap.h"
+#include "../libcli/security/security.h"
static struct db_context *db; /* used for driver files */
-static bool enum_group_mapping(const DOM_SID *domsid,
+static bool enum_group_mapping(const struct dom_sid *domsid,
enum lsa_SidType sid_name_use,
GROUP_MAP **pp_rmap,
size_t *p_num_entries,
bool unix_only);
-static bool group_map_remove(const DOM_SID *sid);
+static bool group_map_remove(const struct dom_sid *sid);
static bool mapping_switch(const char *ldb_path);
return true;
}
-static char *group_mapping_key(TALLOC_CTX *mem_ctx, const DOM_SID *sid)
+static char *group_mapping_key(TALLOC_CTX *mem_ctx, const struct dom_sid *sid)
{
char *sidstr, *result;
Return the sid and the type of the unix group.
****************************************************************************/
-static bool get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map)
+static bool get_group_map_from_sid(struct dom_sid sid, GROUP_MAP *map)
{
TDB_DATA dbuf;
char *key;
Remove a group mapping entry.
****************************************************************************/
-static bool group_map_remove(const DOM_SID *sid)
+static bool group_map_remove(const struct dom_sid *sid)
{
char *key;
NTSTATUS status;
****************************************************************************/
struct enum_map_state {
- const DOM_SID *domsid;
+ const struct dom_sid *domsid;
enum lsa_SidType sid_name_use;
bool unix_only;
}
if ((state->domsid != NULL) &&
- (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)));
return 0;
return 0;
}
-static bool enum_group_mapping(const DOM_SID *domsid,
+static bool enum_group_mapping(const struct dom_sid *domsid,
enum lsa_SidType sid_name_use,
GROUP_MAP **pp_rmap,
size_t *p_num_entries, bool unix_only)
/* This operation happens on session setup, so it should better be fast. We
* store a list of aliases a SID is member of hanging off MEMBEROF/SID. */
-static NTSTATUS one_alias_membership(const DOM_SID *member,
- DOM_SID **sids, size_t *num)
+static NTSTATUS one_alias_membership(const struct dom_sid *member,
+ struct dom_sid **sids, size_t *num)
{
fstring tmp;
fstring key;
p = (const char *)dbuf.dptr;
while (next_token_talloc(frame, &p, &string_sid, " ")) {
- DOM_SID alias;
+ struct dom_sid alias;
+ uint32_t num_sids;
if (!string_to_sid(&alias, string_sid))
continue;
- status= add_sid_to_array_unique(NULL, &alias, sids, num);
+ num_sids = *num;
+ status= add_sid_to_array_unique(NULL, &alias, sids, &num_sids);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
+ *num = num_sids;
}
done:
return status;
}
-static NTSTATUS alias_memberships(const DOM_SID *members, size_t num_members,
- DOM_SID **sids, size_t *num)
+static NTSTATUS alias_memberships(const struct dom_sid *members, size_t num_members,
+ struct dom_sid **sids, size_t *num)
{
size_t i;
return NT_STATUS_OK;
}
-static bool is_aliasmem(const DOM_SID *alias, const DOM_SID *member)
+static bool is_aliasmem(const struct dom_sid *alias, const struct dom_sid *member)
{
- DOM_SID *sids;
- size_t i, num;
+ struct dom_sid *sids;
+ size_t i;
+ size_t num;
/* This feels the wrong way round, but the on-disk data structure
* dictates it this way. */
return False;
for (i=0; i<num; i++) {
- if (sid_compare(alias, &sids[i]) == 0) {
+ if (dom_sid_compare(alias, &sids[i]) == 0) {
TALLOC_FREE(sids);
return True;
}
}
-static NTSTATUS add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
+static NTSTATUS add_aliasmem(const struct dom_sid *alias, const struct dom_sid *member)
{
GROUP_MAP map;
char *key;
struct aliasmem_state {
TALLOC_CTX *mem_ctx;
- const DOM_SID *alias;
- DOM_SID **sids;
+ const struct dom_sid *alias;
+ struct dom_sid **sids;
size_t *num;
};
frame = talloc_stackframe();
while (next_token_talloc(frame, &p, &alias_string, " ")) {
- DOM_SID alias, member;
+ struct dom_sid alias, member;
const char *member_string;
+ uint32_t num_sids;
if (!string_to_sid(&alias, alias_string))
continue;
- if (sid_compare(state->alias, &alias) != 0)
+ if (dom_sid_compare(state->alias, &alias) != 0)
continue;
/* Ok, we found the alias we're looking for in the membership
if (!string_to_sid(&member, member_string))
continue;
+ num_sids = *state->num;
if (!NT_STATUS_IS_OK(add_sid_to_array(state->mem_ctx, &member,
state->sids,
- state->num)))
+ &num_sids)))
{
/* talloc fail. */
break;
}
+ *state->num = num_sids;
}
TALLOC_FREE(frame);
return 0;
}
-static NTSTATUS enum_aliasmem(const DOM_SID *alias, TALLOC_CTX *mem_ctx,
- DOM_SID **sids, size_t *num)
+static NTSTATUS enum_aliasmem(const struct dom_sid *alias, TALLOC_CTX *mem_ctx,
+ struct dom_sid **sids, size_t *num)
{
GROUP_MAP map;
struct aliasmem_state state;
return NT_STATUS_OK;
}
-static NTSTATUS del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
+static NTSTATUS del_aliasmem(const struct dom_sid *alias, const struct dom_sid *member)
{
NTSTATUS status;
- DOM_SID *sids;
+ struct dom_sid *sids;
size_t i, num;
bool found = False;
char *member_string;
}
for (i=0; i<num; i++) {
- if (sid_compare(&sids[i], alias) == 0) {
+ if (dom_sid_compare(&sids[i], alias) == 0) {
found = True;
break;
}
char *val;
char *q;
uint32_t num_mem = 0;
- DOM_SID *members;
+ struct dom_sid *members = NULL;
p = (uint8_t *)data.dptr;
if (data.dsize < 8) {
num_vals = pull_uint32(p, 0);
if (StrCaseCmp(name, "member") == 0) {
num_mem = num_vals;
- members = talloc_array(tmp_ctx, DOM_SID, num_mem);
+ members = talloc_array(tmp_ctx, struct dom_sid, num_mem);
if (members == NULL) {
errno = ENOMEM;
goto failed;
static bool mapping_switch(const char *ldb_path)
{
- static TALLOC_CTX *ltdb;
+ TDB_CONTEXT *ltdb;
TALLOC_CTX *frame;
char *new_path;
int ret;
return True;
failed:
- DEBUG(0,("Failed to swith to tdb group mapping database\n"));
+ DEBUG(0, ("Failed to switch to tdb group mapping database\n"));
if (ltdb) tdb_close(ltdb);
TALLOC_FREE(frame);
return False;