1 files changed, 140 insertions, 474 deletions

diff --git a/source4/lib/samba3/secrets.c b/source4/lib/samba3/secrets.c
index ab19f166ee..4aacffda34 100644
--- a/source4/lib/samba3/secrets.c
+++ b/source4/lib/samba3/secrets.c
@@ -24,52 +24,13 @@
 /* the Samba secrets database stores any generated, private information
    such as the local SID and machine trust password */
 
-#define SECRETS_DOMAIN_SID "SECRETS/SID"
-#define SECRETS_DOMAIN_GUID "SECRETS/DOMGUID"
-#define SECRETS_LDAP_BIND_PW "SECRETS/LDAP_BIND_PW"
-#define SECRETS_MACHINE_ACCT_PASS "SECRETS/$MACHINE.ACC"
-#define SECRETS_DOMTRUST_ACCT_PASS "SECRETS/$DOMTRUST.ACC"
-#define SECRETS_MACHINE_PASSWORD "SECRETS/MACHINE_PASSWORD"
-#define SECRETS_MACHINE_LAST_CHANGE_TIME "SECRETS/MACHINE_LAST_CHANGE_TIME"
-#define SECRETS_MACHINE_SEC_CHANNEL_TYPE "SECRETS/MACHINE_SEC_CHANNEL_TYPE"
-#define SECRETS_AFS_KEYFILE "SECRETS/AFS_KEYFILE"
-#define SECRETS_AUTH_USER      "SECRETS/AUTH_USER"
-#define SECRETS_AUTH_DOMAIN      "SECRETS/AUTH_DOMAIN"
-#define SECRETS_AUTH_PASSWORD  "SECRETS/AUTH_PASSWORD"
-
-
 #include "includes.h"
 #include "tdb.h"
+#include "lib/samba3/samba3.h"
 #include "system/filesys.h"
 #include "librpc/gen_ndr/ndr_security.h"
 #include "lib/tdb/include/tdbutil.h"
 
-/* structure for storing machine account password
-   (ie. when samba server is member of a domain */
-struct machine_acct_pass {
-	uint8_t hash[16];
-	time_t mod_time;
-};
-
-#define SECRETS_AFS_MAXKEYS 8
-
-struct afs_key {
-	uint32_t kvno;
-	char key[8];
-};
-
-/*
- * storage structure for trusted domain
- */
-typedef struct trusted_dom_pass {
-	size_t uni_name_len;
-	const char *uni_name[32]; /* unicode domain name */
-	size_t pass_len;
-	const char *pass;		/* trust relationship's password */
-	time_t mod_time;
-	struct dom_sid domain_sid;	/* remote domain's sid */
-} TRUSTED_DOM_PASS;
-
 /**
  * Unpack SID into a pointer
  *
@@ -99,492 +60,197 @@ static size_t tdb_sid_unpack(TDB_CONTEXT *tdb, char* pack_buf, int bufsize, stru
 	return len;
 }
 
-/**
- * Unpack TRUSTED_DOM_PASS passed by pointer
- *
- * @param pack_buf pointer to buffer with packed representation
- * @param bufsize size of the buffer
- * @param pass pointer to trusted domain password to be filled with unpacked data
- *
- * @return size of structure unpacked from buffer
- **/
-static size_t tdb_trusted_dom_pass_unpack(TDB_CONTEXT *tdb, char* pack_buf, int bufsize, TRUSTED_DOM_PASS* pass)
+static struct samba3_domainsecrets *secrets_find_domain(TALLOC_CTX *ctx, struct samba3_secrets *db, const char *key)
 {
-	int idx, len = 0;
-	
-	if (!pack_buf || !pass) return -1;
+	int i;
 
-	/* unpack unicode domain name and plaintext password */
-	len += tdb_unpack(tdb, pack_buf, bufsize - len, "d", &pass->uni_name_len);
-	
-	for (idx = 0; idx < 32; idx++)
-		len +=  tdb_unpack(tdb, pack_buf + len, bufsize - len, "w", &pass->uni_name[idx]);
+	for (i = 0; i < db->domain_count; i++) 
+	{
+		if (!StrCaseCmp(db->domains[i].name, key)) 
+			return &db->domains[i];
+	}
 
-	len += tdb_unpack(tdb, pack_buf + len, bufsize - len, "dPd", &pass->pass_len, &pass->pass,
-	                  &pass->mod_time);
-	
-	/* unpack domain sid */
-	len += tdb_sid_unpack(tdb, pack_buf + len, bufsize - len, &pass->domain_sid);
+	db->domains = talloc_realloc(ctx, db->domains, struct samba3_domainsecrets, db->domain_count+1);
+	ZERO_STRUCT(db->domains[db->domain_count]);
+	db->domains[db->domain_count].name = talloc_strdup(ctx, key); 
+
+	db->domain_count++;
 	
-	return len;	
+	return &db->domains[db->domain_count-1];
 }
 
-
-static TDB_CONTEXT *secrets_open(const char *fname)
+static NTSTATUS ipc_password (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	TDB_CONTEXT *tdb = tdb_open(fname, 0, TDB_DEFAULT, O_RDONLY, 0600);
-
-	if (!tdb) {
-		DEBUG(0,("Failed to open %s\n", fname));
-		return NULL;
-	}
-
-	return tdb;
+	cli_credentials_set_password(db->ipc_cred, vbuf.dptr, CRED_SPECIFIED);
+	return NT_STATUS_OK;
 }
 
-static BOOL secrets_fetch_domain_sid(TDB_CONTEXT *tdb, const char *domain, struct dom_sid *sid)
+static NTSTATUS ipc_username (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	struct dom_sid *dyn_sid;
-	TDB_DATA val;
-	char *key;
-	size_t size;
-
-	asprintf(&key, "%s/%s", SECRETS_DOMAIN_SID, domain);
-	strupper_m(key);
+	cli_credentials_set_username(db->ipc_cred, vbuf.dptr, CRED_SPECIFIED);
+	return NT_STATUS_OK;
+}
 	
-	val = tdb_fetch_bystring(tdb, key);
-	/* FIXME: Convert val to dyn_sid */
-	SAFE_FREE(key);
-
-	if (dyn_sid == NULL)
-		return False;
-
-	if (size != sizeof(struct dom_sid))
-	{ 
-		SAFE_FREE(dyn_sid);
-		return False;
-	}
-
-	*sid = *dyn_sid;
-	SAFE_FREE(dyn_sid);
-	return True;
+static NTSTATUS ipc_domain (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
+{
+	cli_credentials_set_domain(db->ipc_cred, vbuf.dptr, CRED_SPECIFIED);
+	return NT_STATUS_OK;
 }
 
-static BOOL secrets_fetch_domain_guid(TDB_CONTEXT *tdb, const char *domain, struct GUID *guid)
+static NTSTATUS domain_sid (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	struct GUID *dyn_guid;
-	char *key;
-	TDB_DATA val;
-	size_t size;
-
-	asprintf(&key, "%s/%s", SECRETS_DOMAIN_GUID, domain);
-	strupper_m(key);
-	val = tdb_fetch_bystring(tdb, key);
-
-	dyn_guid = (struct GUID *)val.dptr;
-
-	if (!dyn_guid) {
-		return False;
-	}
-
-	if (val.dsize != sizeof(struct GUID))
-	{ 
-		DEBUG(1,("GUID size %d is wrong!\n", (int)size));
-		SAFE_FREE(dyn_guid);
-		return False;
-	}
-
-	*guid = *dyn_guid;
-	SAFE_FREE(dyn_guid);
-	return True;
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
+	domainsec->sid.sub_auths = talloc_array(ctx, uint32_t, 15);
+	tdb_sid_unpack(tdb, vbuf.dptr, vbuf.dsize, &domainsec->sid);
+	return NT_STATUS_OK;
 }
 
-/**
- * Form a key for fetching the machine trust account password
- *
- * @param domain domain name
- *
- * @return stored password's key
- **/
-static char *trust_keystr(const char *domain)
+static NTSTATUS domain_guid (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	char *keystr;
-
-	asprintf(&keystr, "%s/%s", SECRETS_MACHINE_ACCT_PASS, domain);
-	strupper_m(keystr);
-
-	return keystr;
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
+	memcpy(&domainsec->guid, vbuf.dptr, vbuf.dsize);
+	return NT_STATUS_OK;
 }
 
-/**
- * Form a key for fetching a trusted domain password
- *
- * @param domain trusted domain name
- *
- * @return stored password's key
- **/
-static char *trustdom_keystr(const char *domain)
+static NTSTATUS ldap_bind_pw (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	char *keystr;
-
-	asprintf(&keystr, "%s/%s", SECRETS_DOMTRUST_ACCT_PASS, domain);
-	strupper_m(keystr);
-		
-	return keystr;
+	struct samba3_ldappw pw;
+	pw.dn = talloc_strdup(ctx, key);
+	pw.password = talloc_strdup(ctx, vbuf.dptr);
+
+	db->ldappws = talloc_realloc(ctx, db->ldappws, struct samba3_ldappw, db->ldappw_count+1);
+	db->ldappws[db->ldappw_count] = pw;
+	db->ldappw_count++;
+	return NT_STATUS_OK;
 }
 
-/************************************************************************
- Routine to get the trust account password for a domain.
- The user of this function must have locked the trust password file using
- the above secrets_lock_trust_account_password().
-************************************************************************/
-
-static BOOL secrets_fetch_trust_account_password(TDB_CONTEXT *tdb, 
-					  const char *domain, uint8_t ret_pwd[16],
-					  time_t *pass_last_set_time,
-					  uint32_t *channel)
+static NTSTATUS afs_keyfile (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	struct machine_acct_pass *pass;
-	char *plaintext;
-	TDB_DATA val;
-
-	plaintext = secrets_fetch_machine_password(tdb, domain, pass_last_set_time, 
-						   channel);
-	if (plaintext) {
-		DEBUG(4,("Using cleartext machine password\n"));
-		E_md4hash(plaintext, ret_pwd);
-		SAFE_FREE(plaintext);
-		return True;
-	}
-	
-	val = tdb_fetch_bystring(tdb, trust_keystr(domain));
-	if (!val.dptr) {
-		DEBUG(5, ("tdb_fetch_bystring failed!\n"));
-		return False;
-	}
-	
-	if (val.dsize != sizeof(*pass)) {
-		DEBUG(0, ("secrets were of incorrect size!\n"));
-		return False;
-	}
-
-	pass = (struct machine_acct_pass *)val.dptr;
+	struct samba3_afs_keyfile keyfile;
+	memcpy(&keyfile, vbuf.dptr, vbuf.dsize);
+	keyfile.cell = talloc_strdup(ctx, key);
 
-	if (pass_last_set_time) *pass_last_set_time = pass->mod_time;
-	memcpy(ret_pwd, pass->hash, 16);
-
-	return True;
+	db->afs_keyfiles = talloc_realloc(ctx, db->afs_keyfiles, struct samba3_afs_keyfile, db->afs_keyfile_count+1);
+	db->afs_keyfiles[db->afs_keyfile_count] = keyfile;
+	db->afs_keyfile_count++;
+	
+	return NT_STATUS_OK;
 }
 
-/************************************************************************
- Routine to get account password to trusted domain
-************************************************************************/
-
-static BOOL secrets_fetch_trusted_domain_password(TDB_CONTEXT *tdb, const char *domain, char** pwd, struct dom_sid **sid, time_t *pass_last_set_time)
+static NTSTATUS machine_sec_channel_type (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	struct trusted_dom_pass pass;
-	
-	/* unpacking structures */
-	int pass_len = 0;
-	TDB_DATA val;
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
 
-	ZERO_STRUCT(pass);
-
-	/* fetching trusted domain password structure */
-	val = tdb_fetch_bystring(tdb, trustdom_keystr(domain));
-	if (!val.dptr) {
-		DEBUG(5, ("secrets_fetch failed!\n"));
-		return False;
-	}
-
-	/* unpack trusted domain password */
-	pass_len = tdb_trusted_dom_pass_unpack(val.dptr, val.dsize, &pass);
-
-	if (pass_len != val.dsize) {
-		DEBUG(5, ("Invalid secrets size. Unpacked data doesn't match trusted_dom_pass structure.\n"));
-		return False;
-	}
-			
-	/* the trust's password */	
-	if (pwd) {
-		*pwd = strdup(pass.pass);
-		if (!*pwd) {
-			return False;
-		}
-	}
-
-	/* last change time */
-	if (pass_last_set_time) *pass_last_set_time = pass.mod_time;
-
-	/* domain sid */
-	
-	*sid = dom_sid_dup(tdb, &pass.domain_sid);
-		
-	return True;
+	domainsec->sec_channel_type = IVAL(vbuf.dptr, 0);
+	return NT_STATUS_OK;
 }
 
-/************************************************************************
- Routine to fetch the plaintext machine account password for a realm
-the password is assumed to be a null terminated ascii string
-************************************************************************/
-static char *secrets_fetch_machine_password(TDB_CONTEXT *tdb, const char *domain, 
-				     time_t *pass_last_set_time,
-				     uint32_t *channel)
+static NTSTATUS machine_last_change_time (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	char *key = NULL;
-	char *ret;
-	TDB_DATA val;
-	asprintf(&key, "%s/%s", SECRETS_MACHINE_PASSWORD, domain);
-	strupper_m(key);
-	val = tdb_fetch_bystring(tdb, key);
-	SAFE_FREE(key);
-	
-	if (pass_last_set_time) {
-		asprintf(&key, "%s/%s", SECRETS_MACHINE_LAST_CHANGE_TIME, domain);
-		strupper_m(key);
-		tdb_fetch_uint32(tdb, key, (uint32_t *)pass_last_set_time);
-		SAFE_FREE(key);
-	}
-	
-	if (channel) {
-		asprintf(&key, "%s/%s", SECRETS_MACHINE_SEC_CHANNEL_TYPE, domain);
-		strupper_m(key);
-		tdb_fetch_uint32(tdb, key, channel);
-		SAFE_FREE(key);
-	}
-	
-	return ret;
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
+	domainsec->last_change_time = IVAL(vbuf.dptr, 0);
+	return NT_STATUS_OK;
 }
 
-/*******************************************************************
- find the ldap password
-******************************************************************/
-static BOOL fetch_ldap_pw(TDB_CONTEXT *tdb, const char *dn, char** pw)
+static NTSTATUS machine_password (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	char *key = NULL;
-	size_t size;
-	TDB_DATA val;
-	
-	if (asprintf(&key, "%s/%s", SECRETS_LDAP_BIND_PW, dn) < 0) {
-		DEBUG(0, ("fetch_ldap_pw: asprintf failed!\n"));
-	}
-	
-	val = tdb_fetch_bystring(tdb, key);
-	*pw = val.dptr;
-	SAFE_FREE(key);
-
-	if (!size) {
-		return False;
-	}
-	
-	return True;
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
+	domainsec->plaintext_pw = talloc_strdup(ctx, vbuf.dptr);
+	return NT_STATUS_OK;
 }
 
+static NTSTATUS machine_acc (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
+{
+	struct samba3_domainsecrets *domainsec = secrets_find_domain(ctx, db, key);
 
-/**
- * Get trusted domains info from secrets.tdb.
- *
- * The linked list is allocated on the supplied talloc context, caller gets to destroy
- * when done.
- *
- * @param ctx Allocation context
- * @param enum_ctx Starting index, eg. we can start fetching at third
- *        or sixth trusted domain entry. Zero is the first index.
- *        Value it is set to is the enum context for the next enumeration.
- * @param num_domains Number of domain entries to fetch at one call
- * @param domains Pointer to array of trusted domain structs to be filled up
- *
- * @return nt status code of rpc response
- **/ 
+	memcpy(&domainsec->hash_pw, vbuf.dptr, vbuf.dsize);
+
+	return NT_STATUS_OK;
+}
 
-static NTSTATUS secrets_get_trusted_domains(TDB_CONTEXT *tdb, TALLOC_CTX* ctx, int* enum_ctx, unsigned int max_num_domains,
-                                     int *num_domains, struct samba3_trustdom ***domains)
+static NTSTATUS domtrust_acc (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db) 
 {
-	TDB_LIST_NODE *keys, *k;
-	struct samba3_trustdom *dom = NULL;
-	char *pattern;
-	unsigned int start_idx;
-	uint32_t idx = 0;
-	size_t size, packed_size = 0;
-	fstring dom_name;
-	char *packed_pass;
-	struct trusted_dom_pass *pass = talloc(ctx, struct trusted_dom_pass);
-	NTSTATUS status;
-
-	if (!pass) {
-		DEBUG(0, ("talloc_zero failed!\n"));
-		return NT_STATUS_NO_MEMORY;
-	}
-				
-	*num_domains = 0;
-	start_idx = *enum_ctx;
-
-	/* generate searching pattern */
-	if (!(pattern = talloc_asprintf(ctx, "%s/*", SECRETS_DOMTRUST_ACCT_PASS))) {
-		DEBUG(0, ("secrets_get_trusted_domains: talloc_asprintf() failed!\n"));
-		return NT_STATUS_NO_MEMORY;
-	}
+	int idx, len = 0;
+	struct samba3_trusted_dom_pass pass;
+	int pass_len;
+	
+	if (!vbuf.dptr) 
+		return NT_STATUS_UNSUCCESSFUL;
 
-	DEBUG(5, ("secrets_get_trusted_domains: looking for %d domains, starting at index %d\n", 
-		  max_num_domains, *enum_ctx));
-
-	*domains = talloc_zero_array(ctx, struct samba3_trustdom *, max_num_domains);
-
-	/* fetching trusted domains' data and collecting them in a list */
-	keys = tdb_search_keys(tdb, pattern);
-
-	/* 
-	 * if there's no keys returned ie. no trusted domain,
-	 * return "no more entries" code
-	 */
-	status = NT_STATUS_NO_MORE_ENTRIES;
-
-	/* searching for keys in secrets db -- way to go ... */
-	for (k = keys; k; k = k->next) {
-		char *secrets_key;
-		
-		/* important: ensure null-termination of the key string */
-		secrets_key = strndup(k->node_key.dptr, k->node_key.dsize);
-		if (!secrets_key) {
-			DEBUG(0, ("strndup failed!\n"));
-			return NT_STATUS_NO_MEMORY;
-		}
+	/* unpack unicode domain name and plaintext password */
+	len += tdb_unpack(tdb, vbuf.dptr, vbuf.dsize - len, "d", &pass.uni_name_len);
+	
+	for (idx = 0; idx < 32; idx++)
+		len +=  tdb_unpack(tdb, vbuf.dptr + len, vbuf.dsize - len, "w", &pass.uni_name[idx]);
 
-		packed_pass = secrets_fetch(tdb, secrets_key, &size);
-		packed_size = tdb_trusted_dom_pass_unpack(packed_pass, size, pass);
-		/* packed representation isn't needed anymore */
-		SAFE_FREE(packed_pass);
-		
-		if (size != packed_size) {
-			DEBUG(2, ("Secrets record %s is invalid!\n", secrets_key));
-			continue;
-		}
-		
-		pull_ucs2_fstring(dom_name, pass->uni_name);
-		DEBUG(18, ("Fetched secret record num %d.\nDomain name: %s, SID: %s\n",
-			   idx, dom_name, sid_string_static(&pass->domain_sid)));
-
-		SAFE_FREE(secrets_key);
-
-		if (idx >= start_idx && idx < start_idx + max_num_domains) {
-			dom = talloc(ctx, struct samba3_trustdom);
-			if (!dom) {
-				/* free returned tdb record */
-				return NT_STATUS_NO_MEMORY;
-			}
-			
-			/* copy domain sid */
-			SMB_ASSERT(sizeof(dom->sid) == sizeof(pass->domain_sid));
-			memcpy(&(dom->sid), &(pass->domain_sid), sizeof(dom->sid));
-			
-			/* copy unicode domain name */
-			dom->name = talloc_memdup(ctx, pass->uni_name,
-						  (strlen_w(pass->uni_name) + 1) * sizeof(smb_ucs2_t));
-			
-			(*domains)[idx - start_idx] = dom;
-			
-			DEBUG(18, ("Secret record is in required range.\n \
-				   start_idx = %d, max_num_domains = %d. Added to returned array.\n",
-				   start_idx, max_num_domains));
-
-			*enum_ctx = idx + 1;
-			(*num_domains)++;
-		
-			/* set proper status code to return */
-			if (k->next) {
-				/* there are yet some entries to enumerate */
-				status = STATUS_MORE_ENTRIES;
-			} else {
-				/* this is the last entry in the whole enumeration */
-				status = NT_STATUS_OK;
-			}
-		} else {
-			DEBUG(18, ("Secret is outside the required range.\n \
-				   start_idx = %d, max_num_domains = %d. Not added to returned array\n",
-				   start_idx, max_num_domains));
-		}
-		
-		idx++;		
-	}
+	len += tdb_unpack(tdb, vbuf.dptr + len, vbuf.dsize - len, "d", &pass_len);
+	pass.pass = talloc_strdup(ctx, vbuf.dptr+len);
+	len += strlen(vbuf.dptr)+1;
+	len += tdb_unpack(tdb, vbuf.dptr + len, vbuf.dsize - len, "d", &pass.mod_time);
 	
-	DEBUG(5, ("secrets_get_trusted_domains: got %d domains\n", *num_domains));
+	pass.domain_sid.sub_auths = talloc_array(ctx, uint32_t, 15);
+	/* unpack domain sid */
+	len += tdb_sid_unpack(tdb, vbuf.dptr + len, vbuf.dsize - len, &pass.domain_sid);
 
-	/* free the results of searching the keys */
-	tdb_search_list_free(keys);
+	/* FIXME: Add to list */
 
-	return status;
+	return NT_STATUS_OK;
 }
 
-/*******************************************************************************
- Fetch the current (highest) AFS key from secrets.tdb
-*******************************************************************************/
-static BOOL secrets_fetch_afs_key(TDB_CONTEXT *tdb, const char *cell, struct afs_key *result)
-{
-	fstring key;
-	struct afs_keyfile *keyfile;
-	size_t size;
-	uint32_t i;
-
-	slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_AFS_KEYFILE, cell);
+static const struct {
+	const char *prefix;
+	NTSTATUS (*handler) (TDB_CONTEXT *tdb, const char *key, TDB_DATA vbuf, TALLOC_CTX *ctx, struct samba3_secrets *db);
+} secrets_handlers[] = {
+	{ "SECRETS/AUTH_PASSWORD", ipc_password },
+	{ "SECRETS/AUTH_DOMAIN", ipc_domain },
+	{ "SECRETS/AUTH_USER", ipc_username },
+	{ "SECRETS/SID/", domain_sid },
+	{ "SECRETS/DOMGUID/", domain_guid },
+	{ "SECRETS/LDAP_BIND_PW/", ldap_bind_pw },
+	{ "SECRETS/AFS_KEYFILE/", afs_keyfile },
+	{ "SECRETS/MACHINE_SEC_CHANNEL_TYPE/", machine_sec_channel_type },
+	{ "SECRETS/MACHINE_LAST_CHANGE_TIME/", machine_last_change_time },
+	{ "SECRETS/MACHINE_PASSWORD/", machine_password },
+	{ "SECRETS/$MACHINE.ACC/", machine_acc },
+	{ "SECRETS/$DOMTRUST.ACC/", domtrust_acc },
+};
 
-	keyfile = (struct afs_keyfile *)secrets_fetch(tdb, key, &size);
 
-	if (keyfile == NULL)
-		return False;
+NTSTATUS samba3_read_secrets(const char *fname, TALLOC_CTX *ctx, struct samba3_secrets *db)
+{
+	TDB_CONTEXT *tdb = tdb_open(fname, 0, TDB_DEFAULT, O_RDONLY, 0600);
+	TDB_DATA kbuf, vbuf;
 
-	if (size != sizeof(struct afs_keyfile)) {
-		SAFE_FREE(keyfile);
-		return False;
+	if (!tdb) {
+		DEBUG(0,("Failed to open %s\n", fname));
+		return NT_STATUS_UNSUCCESSFUL;
 	}
 
-	i = ntohl(keyfile->nkeys);
+	ZERO_STRUCTP(db);
+	
+	db->ipc_cred = cli_credentials_init(ctx);
+	
+	for (kbuf = tdb_firstkey(tdb); kbuf.dptr; kbuf = tdb_nextkey(tdb, kbuf))
+	{
+		int i;
+		char *key;
+		vbuf = tdb_fetch(tdb, kbuf);
+
+		for (i = 0; secrets_handlers[i].prefix; i++) {
+			if (!strncmp(kbuf.dptr, secrets_handlers[i].prefix, strlen(secrets_handlers[i].prefix))) {
+				key = talloc_strndup(ctx, kbuf.dptr+strlen(secrets_handlers[i].prefix), kbuf.dsize-strlen(secrets_handlers[i].prefix));
+				secrets_handlers[i].handler(tdb, key, vbuf, ctx, db);
+				talloc_free(key);
+				break;
+			}
+		}
 
-	if (i > SECRETS_AFS_MAXKEYS) {
-		SAFE_FREE(keyfile);
-		return False;
+		if (!secrets_handlers[i].prefix) {
+			DEBUG(0, ("Unable to find handler for string %s", kbuf.dptr));
+		}
 	}
-
-	*result = keyfile->entry[i-1];
-
-	result->kvno = ntohl(result->kvno);
-
-	return True;
-}
-
-/******************************************************************************
-  When kerberos is not available, choose between anonymous or
-  authenticated connections.  
-
-  We need to use an authenticated connection if DCs have the
-  RestrictAnonymous registry entry set > 0, or the "Additional
-  restrictions for anonymous connections" set in the win2k Local
-  Security Policy.
-
-  Caller to free() result in domain, username, password
-*******************************************************************************/
-static void secrets_fetch_ipc_userpass(TDB_CONTEXT *tdb, char **username, char **domain, char **password)
-{
-	*username = secrets_fetch(tdb, SECRETS_AUTH_USER, NULL);
-	*domain = secrets_fetch(tdb, SECRETS_AUTH_DOMAIN, NULL);
-	*password = secrets_fetch(tdb, SECRETS_AUTH_PASSWORD, NULL);
 	
-	if (*username && **username) {
-
-		if (!*domain || !**domain)
-			*domain = smb_xstrdup(lp_workgroup());
-		
-		if (!*password || !**password)
-			*password = smb_xstrdup("");
-
-		DEBUG(3, ("IPC$ connections done by user %s\\%s\n", 
-			  *domain, *username));
-
-	} else {
-		DEBUG(3, ("IPC$ connections done anonymously\n"));
-		*username = smb_xstrdup("");
-		*domain = smb_xstrdup("");
-		*password = smb_xstrdup("");
-	}
-}
-
+	tdb_close(tdb);
 
+	return NT_STATUS_OK;
+}