first public release of samba4 code

(This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)

1 files changed, 562 insertions, 0 deletions

diff --git a/source4/sam/gumm_tdb.c b/source4/sam/gumm_tdb.c
new file mode 100644
index 0000000000..52eaab9e17
--- /dev/null
+++ b/source4/sam/gumm_tdb.c
@@ -0,0 +1,562 @@
+/*
+ * Unix SMB/CIFS implementation. 
+ * SMB parameters and setup
+ * Copyright (C) Andrew Tridgell 1992-1998
+ * Copyright (C) Simo Sorce 2000-2002
+ * Copyright (C) Gerald Carter 2000
+ * Copyright (C) Jeremy Allison 2001
+ * Copyright (C) Andrew Bartlett 2002
+ * 
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 675
+ * Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+#include "gums.h"
+#include "tdbsam2.h"
+#include "tdbsam2_parse_info.h"
+
+static int tdbgumm_debug_level = DBGC_ALL;
+#undef DBGC_CLASS
+#define DBGC_CLASS tdbgumm_debug_level
+
+#define TDBSAM_VERSION		"20021215"
+#define TDB_FILE_NAME		"tdbsam2.tdb"
+#define DOMAINPREFIX		"DOMAIN_"
+#define OBJECTPREFIX		"OBJECT_"
+#define SIDPREFIX		"SID_"
+#define PRIVILEGEPREFIX		"PRIV_"
+
+#define TDB_FORMAT_STRING	"ddB"
+
+union tdbsam2_data {
+	struct tdbsam2_domain_data *domain;
+	struct tdbsam2_user_data *user;
+	struct tdbsam2_group_data *group;
+};
+
+struct tdbsam2_object {
+	uint32 type;
+	union tdbsam2_data data;
+};
+
+static TDB_CONTEXT *tdbsam2_db;
+
+#define TALLOC_CHECK(ptr, err, label) do { if ((ptr) == NULL) { DEBUG(0, ("%s: Out of memory!\n", __FUNCTION__)); err = NT_STATUS_NO_MEMORY; goto label; } } while(0)
+#define SET_OR_FAIL(func, label) do { if (NT_STATUS_IS_ERR(func)) { DEBUG(0, ("%s: Setting gums object data failed!\n", __FUNCTION__)); goto label; } } while(0)
+
+static NTSTATUS init_tdbsam2_object_from_buffer(struct tdbsam2_object *object, TALLOC_CTX *mem_ctx, char *buffer, int size) {
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS tdbsam2_opentdb(void) {
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS tdbsam2_get_object_by_name(struct tdbsam2_object *obj, TALLOC_CTX *mem_ctx, const char* name) {
+
+	NTSTATUS ret;
+	TDB_DATA data, key;
+	fstring keystr;
+	fstring objname;
+
+	if (!obj || !mem_ctx || !name)
+		return NT_STATUS_INVALID_PARAMETER;
+
+	if (tdbsam2_db == NULL) {
+		if (NT_STATUS_IS_ERR(ret = tdbsam2_opentdb())) {
+			goto done;
+		}
+	}
+
+	unix_strlower(name, -1, objname, sizeof(objname));
+
+	slprintf(keystr, sizeof(keystr)-1, "%s%s", OBJECTPREFIX, objname);
+	key.dptr = keystr;
+	key.dsize = strlen(keystr) + 1;
+
+	data = tdb_fetch(tdbsam2_db, key);
+	if (!data.dptr) {
+		DEBUG(5, ("get_domain_sid: Error fetching database, domain entry not found!\n"));
+		DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam2_db)));
+		DEBUGADD(5, (" Key: %s\n", keystr));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	if (NT_STATUS_IS_ERR(init_tdbsam2_object_from_buffer(obj, mem_ctx, data.dptr, data.dsize))) {
+		SAFE_FREE(data.dptr);
+		DEBUG(0, ("get_domain_sid: Error fetching database, malformed entry!\n"));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+	SAFE_FREE(data.dptr);
+
+	ret = NT_STATUS_OK;
+
+done:
+	return ret;
+}
+
+
+static NTSTATUS tdbsam2_store(struct tdbsam2_object *object) {
+
+	NTSTATUS ret;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS tdbsam2_get_next_sid(TALLOC_CTX *mem_ctx, DOM_SID *sid) {
+
+	NTSTATUS ret;
+
+	return NT_STATUS_OK;
+}
+
+static NTSTATUS tdbsam2_user_data_to_gums_object(GUMS_OBJECT **object, struct tdbsam2_user_data *userdata, uint32 type) {
+
+	NTSTATUS ret;
+
+	if (!object || !userdata) {
+		DEBUG(0, ("tdbsam2_user_data_to_gums_object: no NULL pointers are accepted here!\n"));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	/* userdata->xcounter */
+	/* userdata->sec_desc */
+
+	SET_OR_FAIL(gums_set_object_sid(*object, userdata->user_sid), error);
+	SET_OR_FAIL(gums_set_object_name(*object, userdata->name), error);
+
+	SET_OR_FAIL(gums_set_user_pri_group(*object, userdata->group_sid), error);
+
+	if (userdata->description)
+		SET_OR_FAIL(gums_set_object_description(*object, userdata->description), error);
+
+	if (userdata->full_name)
+		SET_OR_FAIL(gums_set_user_fullname(*object, userdata->full_name), error);
+	
+	if (userdata->home_dir)
+		SET_OR_FAIL(gums_set_user_homedir(*object, userdata->home_dir), error);
+
+	if (userdata->dir_drive)
+		SET_OR_FAIL(gums_set_user_dir_drive(*object, userdata->dir_drive), error);
+
+	if (userdata->logon_script)
+		SET_OR_FAIL(gums_set_user_logon_script(*object, userdata->logon_script), error);
+	
+	if (userdata->profile_path) 
+		SET_OR_FAIL(gums_set_user_profile_path(*object, userdata->profile_path), error);
+
+	if (userdata->workstations)
+		SET_OR_FAIL(gums_set_user_workstations(*object, userdata->workstations), error);
+
+	if (userdata->unknown_str)
+		SET_OR_FAIL(gums_set_user_unknown_str(*object, userdata->unknown_str), error);
+
+	if (userdata->munged_dial)
+		SET_OR_FAIL(gums_set_user_munged_dial(*object, userdata->munged_dial), error);
+
+	SET_OR_FAIL(gums_set_user_logon_divs(*object, userdata->logon_divs), error);
+	SET_OR_FAIL(gums_set_user_hours_len(*object, userdata->hours_len), error);
+
+	if (userdata->hours)
+		SET_OR_FAIL(gums_set_user_hours(*object, userdata->hours), error);
+
+	SET_OR_FAIL(gums_set_user_unknown_3(*object, userdata->unknown_3), error);
+	SET_OR_FAIL(gums_set_user_unknown_5(*object, userdata->unknown_5), error);
+	SET_OR_FAIL(gums_set_user_unknown_6(*object, userdata->unknown_6), error);
+
+	SET_OR_FAIL(gums_set_user_logon_time(*object, userdata->logon_time), error);
+	SET_OR_FAIL(gums_set_user_logoff_time(*object, userdata->logoff_time), error);
+	SET_OR_FAIL(gums_set_user_kickoff_time(*object, userdata->kickoff_time), error);
+	SET_OR_FAIL(gums_set_user_pass_last_set_time(*object, userdata->pass_last_set_time), error);
+	SET_OR_FAIL(gums_set_user_pass_can_change_time(*object, userdata->pass_can_change_time), error);
+	SET_OR_FAIL(gums_set_user_pass_must_change_time(*object, userdata->pass_must_change_time), error);
+
+	ret = NT_STATUS_OK;
+	return ret;
+	
+error:
+	talloc_destroy((*object)->mem_ctx);
+	*object = NULL;
+	return ret;
+}
+
+static NTSTATUS tdbsam2_group_data_to_gums_object(GUMS_OBJECT **object, struct tdbsam2_group_data *groupdata, uint32 type) {
+
+	NTSTATUS ret;
+
+	if (!object || !groupdata) {
+		DEBUG(0, ("tdbsam2_group_data_to_gums_object: no NULL pointers are accepted here!\n"));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	/* groupdata->xcounter */
+	/* groupdata->sec_desc */
+
+	SET_OR_FAIL(gums_set_object_sid(*object, groupdata->group_sid), error);
+	SET_OR_FAIL(gums_set_object_name(*object, groupdata->name), error);
+
+	if (groupdata->description)
+		SET_OR_FAIL(gums_set_object_description(*object, groupdata->description), error);
+
+	if (groupdata->count)
+		SET_OR_FAIL(gums_set_group_members(*object, groupdata->count, groupdata->members), error);
+
+	ret = NT_STATUS_OK;
+	return ret;
+	
+error:
+	talloc_destroy((*object)->mem_ctx);
+	*object = NULL;
+	return ret;
+}
+
+static NTSTATUS tdbsam2_domain_data_to_gums_object(GUMS_OBJECT **object, struct tdbsam2_domain_data *domdata, uint32 type) {
+
+	NTSTATUS ret;
+
+	if (!object || !domdata) {
+		DEBUG(0, ("tdbsam2_domain_data_to_gums_object: no NULL pointers are accepted here!\n"));
+		return NT_STATUS_UNSUCCESSFUL;
+	}
+
+	/* domdata->xcounter */
+	/* domdata->sec_desc */
+
+	SET_OR_FAIL(gums_set_object_sid(*object, domdata->dom_sid), error);
+	SET_OR_FAIL(gums_set_object_name(*object, domdata->name), error);
+
+	if (domdata->description)
+		SET_OR_FAIL(gums_set_object_description(*object, domdata->description), error);
+
+	ret = NT_STATUS_OK;
+	return ret;
+	
+error:
+	talloc_destroy((*object)->mem_ctx);
+	*object = NULL;
+	return ret;
+}
+
+static NTSTATUS tdbsam2_data_to_gums_object(GUMS_OBJECT **object, struct tdbsam2_object *data) {
+
+	NTSTATUS ret;
+
+	if (!object || !data) {
+		DEBUG(0, ("tdbsam2_user_data_to_gums_object: no NULL structure pointers are accepted here!\n"));
+		ret = NT_STATUS_INVALID_PARAMETER;
+		goto done;
+	}
+
+	ret = gums_create_object(object, data->type);
+	if (NT_STATUS_IS_ERR(ret)) {
+		DEBUG(5, ("tdbsam2_user_data_to_gums_object: error creating gums object!\n"));
+		goto done;
+	}
+
+	switch (data->type) {
+		case GUMS_OBJ_DOMAIN:
+			ret = tdbsam2_domain_data_to_gums_object(object, data->data.domain, data->type);
+			break;
+
+		case GUMS_OBJ_NORMAL_USER:
+			ret = tdbsam2_user_data_to_gums_object(object, data->data.user, data->type);
+			break;
+
+		case GUMS_OBJ_GROUP:
+		case GUMS_OBJ_ALIAS:
+			ret = tdbsam2_group_data_to_gums_object(object, data->data.group, data->type);
+			break;
+
+		default:
+			ret = NT_STATUS_UNSUCCESSFUL;
+	}
+
+done:
+	return ret;
+}
+
+
+
+
+
+/* GUMM object functions */
+
+static NTSTATUS get_domain_sid(DOM_SID *sid, const char* name) {
+
+	NTSTATUS ret;
+	struct tdbsam2_object obj;
+	TALLOC_CTX *mem_ctx;
+	TDB_DATA data, key;
+	fstring keystr;
+	fstring domname;
+
+	if (!sid || !name)
+		return NT_STATUS_INVALID_PARAMETER;
+
+	mem_ctx = talloc_init("get_domain_sid");
+	if (!mem_ctx) {
+		DEBUG(0, ("tdbsam2_new_object: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	if (tdbsam2_db == NULL) {
+		if (NT_STATUS_IS_ERR(ret = tdbsam2_opentdb())) {
+			goto done;
+		}
+	}
+
+	unix_strlower(name, -1, domname, sizeof(domname));
+
+	slprintf(keystr, sizeof(keystr)-1, "%s%s", DOMAINPREFIX, domname);
+	key.dptr = keystr;
+	key.dsize = strlen(keystr) + 1;
+
+	data = tdb_fetch(tdbsam2_db, key);
+	if (!data.dptr) {
+		DEBUG(5, ("get_domain_sid: Error fetching database, domain entry not found!\n"));
+		DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam2_db)));
+		DEBUGADD(5, (" Key: %s\n", keystr));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	if (NT_STATUS_IS_ERR(init_tdbsam2_object_from_buffer(&obj, mem_ctx, data.dptr, data.dsize))) {
+		SAFE_FREE(data.dptr);
+		DEBUG(0, ("get_domain_sid: Error fetching database, malformed entry!\n"));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+	SAFE_FREE(data.dptr);
+
+	if (obj.type != GUMS_OBJ_DOMAIN) {
+		DEBUG(5, ("get_domain_sid: Requested object is not a domain!\n"));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	sid_copy(sid, obj.data.domain->dom_sid);
+
+	ret = NT_STATUS_OK;
+
+done:
+	if (mem_ctx) talloc_destroy(mem_ctx);
+	return ret;
+}
+
+	NTSTATUS (*set_domain_sid) (const DOM_SID *sid, const char *name);
+
+	NTSTATUS (*get_sequence_number) (void);
+
+
+static NTSTATUS tdbsam2_new_object(DOM_SID **sid, const char *name, const int obj_type) {
+
+	NTSTATUS ret;
+	struct tdbsam2_object obj;
+	TALLOC_CTX *mem_ctx;
+
+	if (!sid || !name) {
+		DEBUG(0, ("tdbsam2_new_object: no NULL pointers are accepted here!\n"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	mem_ctx = talloc_init("tdbsam2_new_object");
+	if (!mem_ctx) {
+		DEBUG(0, ("tdbsam2_new_object: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	switch (obj_type) {
+		case GUMS_OBJ_NORMAL_USER:
+			obj.data.user = (struct tdbsam2_user_data *)talloc_zero(mem_ctx, sizeof(struct tdbsam2_user_data));
+			TALLOC_CHECK(obj.data.user, ret, done);
+
+			/*obj.data.user->sec_desc*/
+
+			tdbsam2_get_next_sid(mem_ctx, obj.data.user->user_sid);
+			TALLOC_CHECK(obj.data.user->user_sid, ret, done);
+
+			obj.data.user->name = talloc_strdup(mem_ctx, name);
+			TALLOC_CHECK(obj.data.user, ret, done);
+
+			break;
+
+		case GUMS_OBJ_GROUP:
+		case GUMS_OBJ_ALIAS:
+			obj.data.group = (struct tdbsam2_group_data *)talloc_zero(mem_ctx, sizeof(struct tdbsam2_group_data));
+			TALLOC_CHECK(obj.data.group, ret, done);
+
+			/*obj.data.user->sec_desc*/
+
+			tdbsam2_get_next_sid(mem_ctx, obj.data.group->group_sid);
+			TALLOC_CHECK(obj.data.group->group_sid, ret, done);
+
+			obj.data.group->name = talloc_strdup(mem_ctx, name);
+			TALLOC_CHECK(obj.data.group, ret, done);
+
+			break;
+
+		case GUMS_OBJ_DOMAIN:
+			/* TODO: SHOULD WE ALLOW TO CREATE NEW DOMAINS ? */
+
+		default:
+			ret = NT_STATUS_UNSUCCESSFUL;
+			goto done;
+	}
+
+	ret = tdbsam2_store(&obj);
+
+done:
+	talloc_destroy(mem_ctx);
+	return ret;
+}
+
+static NTSTATUS tdbsam2_delete_object(const DOM_SID *sid) {
+
+	NTSTATUS ret;
+	struct tdbsam2_object obj;
+	TALLOC_CTX *mem_ctx;
+	TDB_DATA data, key;
+	fstring keystr;
+	fstring sidstr;
+	char *obj_name = NULL;
+	int obj_type, obj_version, len;
+
+	if (!sid) {
+		DEBUG(0, ("tdbsam2_new_object: no NULL pointers are accepted here!\n"));
+		return NT_STATUS_INVALID_PARAMETER;
+	}
+
+	mem_ctx = talloc_init("tdbsam2_delete_object");
+	if (!mem_ctx) {
+		DEBUG(0, ("tdbsam2_new_object: Out of memory!\n"));
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	if (tdbsam2_db == NULL) {
+		if (NT_STATUS_IS_ERR(ret = tdbsam2_opentdb())) {
+			goto done;
+		}
+	}
+
+	sid_to_string(sidstr, sid);
+
+	slprintf(keystr, sizeof(keystr)-1, "%s%s", SIDPREFIX, sidstr);
+	key.dptr = keystr;
+	key.dsize = strlen(keystr) + 1;
+
+	data = tdb_fetch(tdbsam2_db, key);
+	if (!data.dptr) {
+		DEBUG(5, ("get_domain_sid: Error fetching database, SID entry not found!\n"));
+		DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam2_db)));
+		DEBUGADD(5, (" Key: %s\n", keystr));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	len = tdb_unpack(data.dptr, data.dsize, TDB_FORMAT_STRING,
+		&obj_version,
+		&obj_type,
+		&obj_name);
+
+	if (len == -1) {
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}
+
+	if (tdb_delete(tdbsam2_db, key) != TDB_SUCCESS) {
+		DEBUG(5, ("tdbsam2_object_delete: Error deleting object!\n"));
+		DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam2_db)));
+		DEBUGADD(5, (" Key: %s\n", keystr));
+		ret = NT_STATUS_UNSUCCESSFUL;
+		goto done;
+	}	
+
+	switch (obj_type) {
+		case GUMS_OBJ_NORMAL_USER:
+		case GUMS_OBJ_GROUP:
+		case GUMS_OBJ_ALIAS:
+			
+			slprintf(keystr, sizeof(keystr)-1, "%s%s", OBJECTPREFIX, obj_name);
+			key.dptr = keystr;
+			key.dsize = strlen(keystr) + 1;
+
+			if (tdb_delete(tdbsam2_db, key) != TDB_SUCCESS) {
+				DEBUG(5, ("tdbsam2_object_delete: Error deleting object!\n"));
+				DEBUGADD(5, (" Error: %s\n", tdb_errorstr(tdbsam2_db)));
+				DEBUGADD(5, (" Key: %s\n", keystr));
+				ret = NT_STATUS_UNSUCCESSFUL;
+				goto done;
+			}
+			break;
+
+		case GUMS_OBJ_DOMAIN:
+			/* TODO: SHOULD WE ALLOW TO DELETE DOMAINS ? */
+
+		default:
+			ret = NT_STATUS_UNSUCCESSFUL;
+			goto done;
+	}
+
+done:
+	SAFE_FREE(obj_name);
+	talloc_destroy(mem_ctx);
+	return ret;
+}
+
+	NTSTATUS (*get_object_from_sid) (GUMS_OBJECT **object, const DOM_SID *sid, const int obj_type);
+	NTSTATUS (*get_sid_from_name) (GUMS_OBJECT **object, const char *name);
+	/* This function is used to get the list of all objects changed since b_time, it is
+	   used to support PDC<->BDC synchronization */
+	NTSTATUS (*get_updated_objects) (GUMS_OBJECT **objects, const NTTIME base_time);
+
+	NTSTATUS (*enumerate_objects_start) (void *handle, const DOM_SID *sid, const int obj_type);
+	NTSTATUS (*enumerate_objects_get_next) (GUMS_OBJECT **object, void *handle);
+	NTSTATUS (*enumerate_objects_stop) (void *handle);
+
+	/* This function MUST be used ONLY by PDC<->BDC replication code or recovery tools.
+	   Never use this function to update an object in the database, use set_object_values() */
+	NTSTATUS (*set_object) (const GUMS_OBJECT *object);
+
+	/* set object values function */
+	NTSTATUS (*set_object_values) (DOM_SID *sid, uint32 count, GUMS_DATA_SET *data_set);
+
+	/* Group related functions */
+	NTSTATUS (*add_memberss_to_group) (const DOM_SID *group, const DOM_SID **members);
+	NTSTATUS (*delete_members_from_group) (const DOM_SID *group, const DOM_SID **members);
+	NTSTATUS (*enumerate_group_members) (DOM_SID **members, const DOM_SID *sid, const int type);
+
+	NTSTATUS (*get_sid_groups) (DOM_SID **groups, const DOM_SID *sid);
+
+	NTSTATUS (*lock_sid) (const DOM_SID *sid);
+	NTSTATUS (*unlock_sid) (const DOM_SID *sid);
+
+	/* privileges related functions */
+
+	NTSTATUS (*add_members_to_privilege) (const LUID_ATTR *priv, const DOM_SID **members);
+	NTSTATUS (*delete_members_from_privilege) (const LUID_ATTR *priv, const DOM_SID **members);
+	NTSTATUS (*enumerate_privilege_members) (DOM_SID **members, const LUID_ATTR *priv);
+	NTSTATUS (*get_sid_privileges) (DOM_SID **privs, const DOM_SID *sid);
+	/* warning!: set_privilege will overwrite a prior existing privilege if such exist */
+	NTSTATUS (*set_privilege) (GUMS_PRIVILEGE *priv);
+
+
+int gumm_init(GUMS_FUNCTIONS **storage) {
+
+	return 0;
+}