*/
#include "includes.h"
+#include "system/filesys.h"
+#include "passdb.h"
#include "groupdb/mapping.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 */
-static bool enum_group_mapping(const 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 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 struct dom_sid *sid);
+
+static bool mapping_switch(const char *ldb_path);
+
/****************************************************************************
Open the group mapping tdb.
****************************************************************************/
static bool init_group_mapping(void)
{
+ const char *ldb_path;
+
if (db != NULL) {
return true;
}
db = db_open(NULL, state_path("group_mapping.tdb"), 0,
- TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+ TDB_DEFAULT, O_RDWR|O_CREAT, 0600,
+ DBWRAP_LOCK_ORDER_1);
if (db == NULL) {
DEBUG(0, ("Failed to open group mapping database: %s\n",
strerror(errno)));
return false;
}
-#if 0
- /*
- * This code was designed to handle a group mapping version
- * upgrade. mapping_tdb is not active by default anymore, so ignore
- * this here.
- */
- {
+ ldb_path = state_path("group_mapping.ldb");
+ if (file_exist(ldb_path) && !mapping_switch(ldb_path)) {
+ unlink(state_path("group_mapping.tdb"));
+ return false;
+
+ } else {
+ /* handle upgrade from old versions of the database */
+#if 0 /* -- Needs conversion to dbwrap -- */
const char *vstring = "INFO/version";
int32 vers_id;
GROUP_MAP *map_table = NULL;
SAFE_FREE( map_table );
}
- }
#endif
-
+ }
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;
len = tdb_pack(NULL, 0, "ddff",
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;
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;
int ret = 0;
+ NTSTATUS status;
+ fstring nt_name;
+ fstring comment;
/* the key is the SID, retrieving is direct */
return false;
}
- 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;
}
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;
}
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;
}
struct find_map_state {
state.gid = gid;
state.map = map;
- db->traverse_read(db, find_map, (void *)&state);
+ dbwrap_traverse_read(db, find_map, (void *)&state, NULL);
return state.found;
}
state.name = name;
state.map = map;
- db->traverse_read(db, find_map, (void *)&state);
+ dbwrap_traverse_read(db, find_map, (void *)&state, NULL);
return state.found;
}
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;
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;
- if (!dbrec2map(rec, &map)) {
+ 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) &&
- (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 DOM_SID *domsid,
+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;
state.sid_name_use = sid_name_use;
state.num_maps = 0;
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;
}
/* 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;
slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX,
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;
}
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;
+ GROUP_MAP *map;
char *key;
fstring string_sid;
char *new_memberstring;
struct db_record *rec;
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;
return NT_STATUS_NO_MEMORY;
}
- 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) {
DEBUG(10, ("fetch_lock failed\n"));
goto cancel;
}
+ 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);
}
goto cancel;
}
- 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);
goto cancel;
}
- if (db->transaction_commit(db) != 0) {
+ if (dbwrap_transaction_commit(db) != 0) {
DEBUG(0, ("transaction_commit failed\n"));
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
return status;
return NT_STATUS_OK;
cancel:
- if (db->transaction_cancel(db) != 0) {
+ if (dbwrap_transaction_cancel(db) != 0) {
smb_panic("transaction_cancel failed");
}
}
struct aliasmem_state {
- const DOM_SID *alias;
- DOM_SID **sids;
+ TALLOC_CTX *mem_ctx;
+ const struct dom_sid *alias;
+ struct dom_sid **sids;
size_t *num;
};
const char *p;
char *alias_string;
TALLOC_CTX *frame;
+ TDB_DATA key = dbwrap_record_get_key(rec);
+ TDB_DATA value = dbwrap_record_get_value(rec);
- if (strncmp((const char *)rec->key.dptr, MEMBEROF_PREFIX,
+ 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();
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
* list currently scanned. The key represents the alias
* 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
* slash. */
if (!string_to_sid(&member, member_string))
continue;
- if (!NT_STATUS_IS_OK(add_sid_to_array(NULL, &member,
+ 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, 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;
+ 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;
state.alias = alias;
state.sids = sids;
state.num = num;
+ state.mem_ctx = mem_ctx;
- db->traverse_read(db, collect_aliasmem, &state);
+ dbwrap_traverse_read(db, collect_aliasmem, &state, NULL);
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;
char *key;
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;
}
}
for (i=0; i<num; i++) {
- if (sid_compare(&sids[i], alias) == 0) {
+ if (dom_sid_compare(&sids[i], alias) == 0) {
found = True;
break;
}
goto cancel;
}
- if (db->transaction_commit(db) != 0) {
+ if (dbwrap_transaction_commit(db) != 0) {
DEBUG(0, ("transaction_commit failed\n"));
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
return status;
return NT_STATUS_OK;
cancel:
- if (db->transaction_cancel(db) != 0) {
+ if (dbwrap_transaction_cancel(db) != 0) {
smb_panic("transaction_cancel failed");
}
return status;
}
+
+/* -- ldb->tdb switching code -------------------------------------------- */
+
+/* change this if the data format ever changes */
+#define LTDB_PACKING_FORMAT 0x26011967
+
+/* old packing formats (not supported for now,
+ * it was never used for group mapping AFAIK) */
+#define LTDB_PACKING_FORMAT_NODN 0x26011966
+
+static unsigned int pull_uint32(uint8_t *p, int ofs)
+{
+ p += ofs;
+ return p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
+}
+
+/*
+ unpack a ldb message from a linear buffer in TDB_DATA
+*/
+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 = NULL;
+ uint8_t *p;
+ uint32_t format;
+ uint32_t num_el;
+ unsigned int remaining;
+ unsigned int i, j;
+ size_t len;
+ char *name;
+ char *val;
+ char *q;
+ uint32_t num_mem = 0;
+ struct dom_sid *members = NULL;
+
+ p = (uint8_t *)data.dptr;
+ if (data.dsize < 8) {
+ errno = EIO;
+ goto failed;
+ }
+
+ format = pull_uint32(p, 0);
+ num_el = pull_uint32(p, 4);
+ p += 8;
+
+ remaining = data.dsize - 8;
+
+ switch (format) {
+ case LTDB_PACKING_FORMAT:
+ len = strnlen((char *)p, remaining);
+ if (len == remaining) {
+ errno = EIO;
+ goto failed;
+ }
+
+ if (*p == '@') {
+ /* ignore special LDB attributes */
+ return 0;
+ }
+
+ if (strncmp((char *)p, "rid=", 4)) {
+ /* unknown entry, ignore */
+ DEBUG(3, ("Found unknown entry in group mapping "
+ "database named [%s]\n", (char *)p));
+ return 0;
+ }
+
+ remaining -= len + 1;
+ p += len + 1;
+ break;
+
+ case LTDB_PACKING_FORMAT_NODN:
+ default:
+ errno = EIO;
+ goto failed;
+ }
+
+ if (num_el == 0) {
+ /* bad entry, ignore */
+ return 0;
+ }
+
+ if (num_el > remaining / 6) {
+ errno = EIO;
+ goto failed;
+ }
+
+ map = talloc_zero(NULL, GROUP_MAP);
+ if (!map) {
+ errno = ENOMEM;
+ goto failed;
+ }
+
+ for (i = 0; i < num_el; i++) {
+ uint32_t num_vals;
+
+ if (remaining < 10) {
+ errno = EIO;
+ goto failed;
+ }
+ len = strnlen((char *)p, remaining - 6);
+ if (len == remaining - 6) {
+ errno = EIO;
+ goto failed;
+ }
+ name = talloc_strndup(tmp_ctx, (char *)p, len);
+ if (name == NULL) {
+ errno = ENOMEM;
+ goto failed;
+ }
+ remaining -= len + 1;
+ p += len + 1;
+
+ num_vals = pull_uint32(p, 0);
+ if (strcasecmp_m(name, "member") == 0) {
+ num_mem = num_vals;
+ members = talloc_array(tmp_ctx, struct dom_sid, num_mem);
+ if (members == NULL) {
+ errno = ENOMEM;
+ goto failed;
+ }
+ } else if (num_vals != 1) {
+ errno = EIO;
+ goto failed;
+ }
+
+ p += 4;
+ remaining -= 4;
+
+ for (j = 0; j < num_vals; j++) {
+ len = pull_uint32(p, 0);
+ if (len > remaining-5) {
+ errno = EIO;
+ goto failed;
+ }
+
+ val = talloc_strndup(tmp_ctx, (char *)(p + 4), len);
+ if (val == NULL) {
+ errno = ENOMEM;
+ goto failed;
+ }
+
+ remaining -= len+4+1;
+ p += len+4+1;
+
+ /* we ignore unknown or uninteresting attributes
+ * (objectclass, etc.) */
+ if (strcasecmp_m(name, "gidNumber") == 0) {
+ 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)) {
+ errno = EIO;
+ goto failed;
+ }
+ } else if (strcasecmp_m(name, "sidNameUse") == 0) {
+ map->sid_name_use = strtoul(val, &q, 10);
+ if (*q) {
+ errno = EIO;
+ goto failed;
+ }
+ } 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;
+ goto failed;
+ }
+ }
+
+ TALLOC_FREE(val);
+ }
+
+ TALLOC_FREE(name);
+ }
+
+ 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;
+ }
+
+ if (num_mem) {
+ for (j = 0; j < num_mem; j++) {
+ NTSTATUS status;
+ status = add_aliasmem(&map->sid, &members[j]);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = EIO;
+ goto failed;
+ }
+ }
+ }
+
+ if (remaining != 0) {
+ DEBUG(0, ("Errror: %d bytes unread in ltdb_unpack_data\n",
+ remaining));
+ }
+
+ TALLOC_FREE(map);
+ return 0;
+
+failed:
+ TALLOC_FREE(map);
+ return -1;
+}
+
+static bool mapping_switch(const char *ldb_path)
+{
+ TDB_CONTEXT *ltdb;
+ TALLOC_CTX *frame;
+ char *new_path;
+ int ret;
+
+ frame = talloc_stackframe();
+
+ ltdb = tdb_open_log(ldb_path, 0, TDB_DEFAULT, O_RDONLY, 0600);
+ if (ltdb == NULL) goto failed;
+
+ /* ldb is just a very fancy tdb, read out raw data and perform
+ * conversion */
+ ret = tdb_traverse(ltdb, convert_ldb_record, NULL);
+ if (ret < 0) goto failed;
+
+ if (ltdb) {
+ tdb_close(ltdb);
+ ltdb = NULL;
+ }
+
+ /* now rename the old db out of the way */
+ new_path = state_path("group_mapping.ldb.replaced");
+ if (!new_path) {
+ goto failed;
+ }
+ if (rename(ldb_path, new_path) != 0) {
+ DEBUG(0,("Failed to rename old group mapping database\n"));
+ goto failed;
+ }
+ TALLOC_FREE(frame);
+ return True;
+
+failed:
+ DEBUG(0, ("Failed to switch to tdb group mapping database\n"));
+ if (ltdb) tdb_close(ltdb);
+ TALLOC_FREE(frame);
+ return False;
+}
+
static const struct mapping_backend tdb_backend = {
.add_mapping_entry = add_mapping_entry,
.get_group_map_from_sid = get_group_map_from_sid,