#include "winbindd.h"
#include "tdb_validate.h"
#include "../libcli/auth/libcli_auth.h"
-#include "../librpc/gen_ndr/ndr_wbint.h"
+#include "../librpc/gen_ndr/ndr_winbind.h"
#include "ads.h"
#include "nss_info.h"
#include "../libcli/security/security.h"
#include "passdb/machine_sid.h"
#include "util_tdb.h"
+#include "libsmb/samlogon_cache.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
-#define WINBINDD_CACHE_VERSION 2
+#define WINBINDD_CACHE_VER1 1 /* initial db version */
+#define WINBINDD_CACHE_VER2 2 /* second version with timeouts for NDR entries */
+
+#define WINBINDD_CACHE_VERSION WINBINDD_CACHE_VER2
#define WINBINDD_CACHE_VERSION_KEYSTR "WINBINDD_CACHE_VERSION"
extern struct winbindd_methods reconnect_methods;
#ifdef HAVE_ADS
-extern struct winbindd_methods ads_methods;
+extern struct winbindd_methods reconnect_ads_methods;
#endif
extern struct winbindd_methods builtin_passdb_methods;
extern struct winbindd_methods sam_passdb_methods;
struct cache_entry {
NTSTATUS status;
- uint32 sequence_number;
+ uint32_t sequence_number;
uint64_t timeout;
- uint8 *data;
- uint32 len, ofs;
+ uint8_t *data;
+ uint32_t len, ofs;
};
void (*smb_panic_fn)(const char *const why) = smb_panic;
static struct winbind_cache *wcache;
+static char *wcache_path(void)
+{
+ /*
+ * Data needs to be kept persistent in state directory for
+ * running with "winbindd offline logon".
+ */
+ return state_path("winbindd_cache.tdb");
+}
+
/* get the winbind_cache structure */
static struct winbind_cache *get_cache(struct winbindd_domain *domain)
{
if (domain->internal) {
domain->backend = &builtin_passdb_methods;
- domain->initialized = True;
+ }
+
+ if (dom_sid_equal(&domain->sid, &global_sid_Builtin)) {
+ domain->initialized = true;
}
if (strequal(domain->name, get_global_sam_name()) &&
- sid_check_is_domain(&domain->sid)) {
+ sid_check_is_our_sam(&domain->sid)) {
domain->backend = &sam_passdb_methods;
- domain->initialized = True;
}
if ( !domain->initialized ) {
- init_dc_connection( domain );
+ /* We do not need a connection to an RW DC for cache operation */
+ init_dc_connection(domain, false);
}
/*
- OK. listen up becasue I'm only going to say this once.
+ OK. Listen up because I'm only going to say this once.
We have the following scenarios to consider
(a) trusted AD domains on a Samba DC,
(b) trusted AD domains and we are joined to a non-kerberos domain
&& domain->active_directory
&& !lp_winbind_rpc_only()) {
DEBUG(5,("get_cache: Setting ADS methods for domain %s\n", domain->name));
- domain->backend = &ads_methods;
+ domain->backend = &reconnect_ads_methods;
} else {
#endif /* HAVE_ADS */
DEBUG(5,("get_cache: Setting MS-RPC methods for domain %s\n", domain->name));
}
/*
- pull a uint32 from a cache entry
+ pull a uint32_t from a cache entry
*/
-static uint32 centry_uint32(struct cache_entry *centry)
+static uint32_t centry_uint32(struct cache_entry *centry)
{
- uint32 ret;
+ uint32_t ret;
if (!centry_check_bytes(centry, 4)) {
smb_panic_fn("centry_uint32");
}
/*
- pull a uint16 from a cache entry
+ pull a uint16_t from a cache entry
*/
-static uint16 centry_uint16(struct cache_entry *centry)
+static uint16_t centry_uint16(struct cache_entry *centry)
{
- uint16 ret;
+ uint16_t ret;
if (!centry_check_bytes(centry, 2)) {
smb_panic_fn("centry_uint16");
}
}
/*
- pull a uint8 from a cache entry
+ pull a uint8_t from a cache entry
*/
-static uint8 centry_uint8(struct cache_entry *centry)
+static uint8_t centry_uint8(struct cache_entry *centry)
{
- uint8 ret;
+ uint8_t ret;
if (!centry_check_bytes(centry, 1)) {
smb_panic_fn("centry_uint8");
}
}
ret = IVAL(centry->data, centry->ofs);
centry->ofs += 4;
- ret += (uint64)IVAL(centry->data, centry->ofs) << 32;
+ ret += (uint64_t)IVAL(centry->data, centry->ofs) << 32;
centry->ofs += 4;
return ret;
}
*/
static char *centry_string(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
{
- uint32 len;
+ uint32_t len;
char *ret;
len = centry_uint8(centry);
*/
static char *centry_hash16(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
{
- uint32 len;
+ uint32_t len;
char *ret;
len = centry_uint8(centry);
return ret;
}
-static bool wcache_fetch_seqnum(const char *domain_name, uint32_t *seqnum,
- uint32_t *last_seq_check)
+struct wcache_seqnum_state {
+ uint32_t *seqnum;
+ uint32_t *last_seq_check;
+};
+
+static int wcache_seqnum_parser(TDB_DATA key, TDB_DATA data,
+ void *private_data)
{
- char *key;
- TDB_DATA data;
+ struct wcache_seqnum_state *state = private_data;
- if (wcache->tdb == NULL) {
- DEBUG(10,("wcache_fetch_seqnum: tdb == NULL\n"));
- return false;
+ if (data.dsize != 8) {
+ DEBUG(10, ("wcache_fetch_seqnum: invalid data size %d\n",
+ (int)data.dsize));
+ return -1;
}
- key = talloc_asprintf(talloc_tos(), "SEQNUM/%s", domain_name);
- if (key == NULL) {
- DEBUG(10, ("talloc failed\n"));
- return false;
- }
+ *state->seqnum = IVAL(data.dptr, 0);
+ *state->last_seq_check = IVAL(data.dptr, 4);
+ return 0;
+}
- data = tdb_fetch_bystring(wcache->tdb, key);
- TALLOC_FREE(key);
+static bool wcache_fetch_seqnum(const char *domain_name, uint32_t *seqnum,
+ uint32_t *last_seq_check)
+{
+ struct wcache_seqnum_state state = {
+ .seqnum = seqnum, .last_seq_check = last_seq_check
+ };
+ size_t len = strlen(domain_name);
+ char keystr[len+8];
+ TDB_DATA key = { .dptr = (uint8_t *)keystr, .dsize = sizeof(keystr) };
+ int ret;
- if (data.dptr == NULL) {
- DEBUG(10, ("wcache_fetch_seqnum: %s not found\n",
- domain_name));
- return false;
- }
- if (data.dsize != 8) {
- DEBUG(10, ("wcache_fetch_seqnum: invalid data size %d\n",
- (int)data.dsize));
- SAFE_FREE(data.dptr);
+ if (wcache->tdb == NULL) {
+ DEBUG(10,("wcache_fetch_seqnum: tdb == NULL\n"));
return false;
}
- *seqnum = IVAL(data.dptr, 0);
- *last_seq_check = IVAL(data.dptr, 4);
- SAFE_FREE(data.dptr);
+ snprintf(keystr, sizeof(keystr), "SEQNUM/%s", domain_name);
- return true;
+ ret = tdb_parse_record(wcache->tdb, key, wcache_seqnum_parser,
+ &state);
+ return (ret == 0);
}
static NTSTATUS fetch_cache_seqnum( struct winbindd_domain *domain, time_t now )
{
- uint32 last_check, time_diff;
+ uint32_t last_check, time_diff;
if (!wcache_fetch_seqnum(domain->name, &domain->sequence_number,
&last_check)) {
if ( time_diff > lp_winbind_cache_time() ) {
DEBUG(10,("fetch_cache_seqnum: timeout [%s][%u @ %u]\n",
domain->name, domain->sequence_number,
- (uint32)domain->last_seq_check));
+ (uint32_t)domain->last_seq_check));
return NT_STATUS_UNSUCCESSFUL;
}
DEBUG(10,("fetch_cache_seqnum: success [%s][%u @ %u]\n",
domain->name, domain->sequence_number,
- (uint32)domain->last_seq_check));
+ (uint32_t)domain->last_seq_check));
return NT_STATUS_OK;
}
bool wcache_store_seqnum(const char *domain_name, uint32_t seqnum,
time_t last_seq_check)
{
- char *key_str;
+ size_t len = strlen(domain_name);
+ char keystr[len+8];
+ TDB_DATA key = { .dptr = (uint8_t *)keystr, .dsize = sizeof(keystr) };
uint8_t buf[8];
int ret;
return false;
}
- key_str = talloc_asprintf(talloc_tos(), "SEQNUM/%s", domain_name);
- if (key_str == NULL) {
- DEBUG(10, ("talloc_asprintf failed\n"));
- return false;
- }
+ snprintf(keystr, sizeof(keystr), "SEQNUM/%s", domain_name);
SIVAL(buf, 0, seqnum);
SIVAL(buf, 4, last_seq_check);
- ret = tdb_store_bystring(wcache->tdb, key_str,
- make_tdb_data(buf, sizeof(buf)), TDB_REPLACE);
- TALLOC_FREE(key_str);
+ ret = tdb_store(wcache->tdb, key, make_tdb_data(buf, sizeof(buf)),
+ TDB_REPLACE);
if (ret != 0) {
DEBUG(10, ("tdb_store_bystring failed: %s\n",
- tdb_errorstr_compat(wcache->tdb)));
- TALLOC_FREE(key_str);
+ tdb_errorstr(wcache->tdb)));
return false;
}
}
/*
- refresh the domain sequence number. If force is true
- then always refresh it, no matter how recently we fetched it
+ refresh the domain sequence number on timeout.
*/
-static void refresh_sequence_number(struct winbindd_domain *domain, bool force)
+static void refresh_sequence_number(struct winbindd_domain *domain)
{
NTSTATUS status;
unsigned time_diff;
time_diff = t - domain->last_seq_check;
/* see if we have to refetch the domain sequence number */
- if (!force && (time_diff < cache_time) &&
+ if ((time_diff < cache_time) &&
(domain->sequence_number != DOM_SEQUENCE_NONE) &&
NT_STATUS_IS_OK(domain->last_status)) {
DEBUG(10, ("refresh_sequence_number: %s time ok\n", domain->name));
TDB_DATA key;
key = string_tdb_data(kstr);
- data = tdb_fetch_compat(wcache->tdb, key);
+ data = tdb_fetch(wcache->tdb, key);
if (!data.dptr) {
/* a cache miss */
return NULL;
static bool is_my_own_sam_domain(struct winbindd_domain *domain)
{
if (strequal(domain->name, get_global_sam_name()) &&
- sid_check_is_domain(&domain->sid)) {
+ sid_check_is_our_sam(&domain->sid)) {
return true;
}
return NULL;
}
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
va_start(ap, format);
smb_xvasprintf(&kstr, format, ap);
/*
make sure we have at least len bytes available in a centry
*/
-static void centry_expand(struct cache_entry *centry, uint32 len)
+static void centry_expand(struct cache_entry *centry, uint32_t len)
{
if (centry->len - centry->ofs >= len)
return;
}
/*
- push a uint32 into a centry
+ push a uint32_t into a centry
*/
-static void centry_put_uint32(struct cache_entry *centry, uint32 v)
+static void centry_put_uint32(struct cache_entry *centry, uint32_t v)
{
centry_expand(centry, 4);
SIVAL(centry->data, centry->ofs, v);
}
/*
- push a uint16 into a centry
+ push a uint16_t into a centry
*/
-static void centry_put_uint16(struct cache_entry *centry, uint16 v)
+static void centry_put_uint16(struct cache_entry *centry, uint16_t v)
{
centry_expand(centry, 2);
SSVAL(centry->data, centry->ofs, v);
}
/*
- push a uint8 into a centry
+ push a uint8_t into a centry
*/
-static void centry_put_uint8(struct cache_entry *centry, uint8 v)
+static void centry_put_uint8(struct cache_entry *centry, uint8_t v)
{
centry_expand(centry, 1);
SCVAL(centry->data, centry->ofs, v);
/*
push a 16 byte hash into a centry - treat as 16 byte string.
*/
-static void centry_put_hash16(struct cache_entry *centry, const uint8 val[16])
+static void centry_put_hash16(struct cache_entry *centry, const uint8_t val[16])
{
centry_put_uint8(centry, 16);
centry_expand(centry, 16);
*/
static void centry_put_ntstatus(struct cache_entry *centry, NTSTATUS status)
{
- uint32 status_value = NT_STATUS_V(status);
+ uint32_t status_value = NT_STATUS_V(status);
centry_put_uint32(centry, status_value);
}
/*
start a centry for output. When finished, call centry_end()
*/
-struct cache_entry *centry_start(struct winbindd_domain *domain, NTSTATUS status)
+static struct cache_entry *centry_start(struct winbindd_domain *domain,
+ NTSTATUS status)
{
struct cache_entry *centry;
centry = SMB_XMALLOC_P(struct cache_entry);
centry->len = 8192; /* reasonable default */
- centry->data = SMB_XMALLOC_ARRAY(uint8, centry->len);
+ centry->data = SMB_XMALLOC_ARRAY(uint8_t, centry->len);
centry->ofs = 0;
centry->sequence_number = domain->sequence_number;
centry->timeout = lp_winbind_cache_time() + time(NULL);
centry = centry_start(domain, status);
if (!centry)
return;
+
+ if ((domain_name == NULL) || (domain_name[0] == '\0')) {
+ struct winbindd_domain *mydomain =
+ find_domain_from_sid_noinit(sid);
+ if (mydomain != NULL) {
+ domain_name = mydomain->name;
+ }
+ }
+
centry_put_uint32(centry, type);
centry_put_sid(centry, sid);
fstrcpy(uname, name);
- strupper_m(uname);
+ (void)strupper_m(uname);
centry_end(centry, "NS/%s/%s", domain_name, uname);
DEBUG(10,("wcache_save_name_to_sid: %s\\%s -> %s (%s)\n", domain_name,
uname, sid_string_dbg(sid), nt_errstr(status)));
if (!centry)
return;
+ if ((domain_name == NULL) || (domain_name[0] == '\0')) {
+ struct winbindd_domain *mydomain =
+ find_domain_from_sid_noinit(sid);
+ if (mydomain != NULL) {
+ domain_name = mydomain->name;
+ }
+ }
+
if (NT_STATUS_IS_OK(status)) {
centry_put_uint32(centry, type);
centry_put_string(centry, domain_name);
centry_free(centry);
}
-
-static void wcache_save_user(struct winbindd_domain *domain, NTSTATUS status,
- struct wbint_userinfo *info)
-{
- struct cache_entry *centry;
- fstring sid_string;
-
- if (is_null_sid(&info->user_sid)) {
- return;
- }
-
- centry = centry_start(domain, status);
- if (!centry)
- return;
- centry_put_string(centry, info->acct_name);
- centry_put_string(centry, info->full_name);
- centry_put_string(centry, info->homedir);
- centry_put_string(centry, info->shell);
- centry_put_uint32(centry, info->primary_gid);
- centry_put_sid(centry, &info->user_sid);
- centry_put_sid(centry, &info->group_sid);
- centry_end(centry, "U/%s", sid_to_fstring(sid_string,
- &info->user_sid));
- DEBUG(10,("wcache_save_user: %s (acct_name %s)\n", sid_string, info->acct_name));
- centry_free(centry);
-}
-
static void wcache_save_lockout_policy(struct winbindd_domain *domain,
NTSTATUS status,
struct samr_DomInfo12 *lockout_policy)
centry_put_string( centry, alias );
fstrcpy(uname, name);
- strupper_m(uname);
+ (void)strupper_m(uname);
centry_end(centry, "NSS/NA/%s", uname);
DEBUG(10,("wcache_save_username_alias: %s -> %s\n", name, alias ));
centry_put_string( centry, name );
fstrcpy(uname, alias);
- strupper_m(uname);
+ (void)strupper_m(uname);
centry_end(centry, "NSS/AN/%s", uname);
DEBUG(10,("wcache_save_alias_username: %s -> %s\n", alias, name ));
if (!cache->tdb)
goto do_query;
- if ( (upper_name = SMB_STRDUP(name)) == NULL )
+ upper_name = talloc_strdup(mem_ctx, name);
+ if (upper_name == NULL) {
return NT_STATUS_NO_MEMORY;
- strupper_m(upper_name);
+ }
+ if (!strupper_m(upper_name)) {
+ talloc_free(upper_name);
+ return NT_STATUS_INVALID_PARAMETER;
+ }
centry = wcache_fetch(cache, domain, "NSS/NA/%s", upper_name);
- SAFE_FREE( upper_name );
+ talloc_free(upper_name);
if (!centry)
goto do_query;
if (!cache->tdb)
goto do_query;
- if ( (upper_name = SMB_STRDUP(alias)) == NULL )
+ upper_name = talloc_strdup(mem_ctx, alias);
+ if (upper_name == NULL) {
return NT_STATUS_NO_MEMORY;
- strupper_m(upper_name);
+ }
+ if (!strupper_m(upper_name)) {
+ talloc_free(upper_name);
+ return NT_STATUS_INVALID_PARAMETER;
+ }
centry = wcache_fetch(cache, domain, "NSS/AN/%s", upper_name);
- SAFE_FREE( upper_name );
+ talloc_free(upper_name);
if (!centry)
goto do_query;
struct winbind_cache *cache = get_cache(domain);
TDB_DATA data;
fstring key_str, tmp;
- uint32 rid;
+ uint32_t rid;
if (!cache->tdb) {
return NT_STATUS_INTERNAL_DB_ERROR;
fstr_sprintf(key_str, "CRED/%s", sid_to_fstring(tmp, sid));
- data = tdb_fetch_compat(cache->tdb, string_tdb_data(key_str));
+ data = tdb_fetch(cache->tdb, string_tdb_data(key_str));
if (!data.dptr) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
NTSTATUS wcache_get_creds(struct winbindd_domain *domain,
TALLOC_CTX *mem_ctx,
const struct dom_sid *sid,
- const uint8 **cached_nt_pass,
- const uint8 **cached_salt)
+ const uint8_t **cached_nt_pass,
+ const uint8_t **cached_salt)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
NTSTATUS status;
- time_t t;
- uint32 rid;
+ uint32_t rid;
fstring tmp;
- if (!winbindd_use_cache()) {
- return NT_STATUS_OBJECT_NAME_NOT_FOUND;
- }
-
if (!cache->tdb) {
return NT_STATUS_INTERNAL_DB_ERROR;
}
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
- t = centry_time(centry);
+ /*
+ * We don't use the time element at this moment,
+ * but we have to consume it, so that we don't
+ * neet to change the disk format of the cache.
+ */
+ (void)centry_time(centry);
/* In the salted case this isn't actually the nt_hash itself,
but the MD5 of the salt + nt_hash. Let the caller
sort this out. It can tell as we only return the cached_salt
if we are returning a salted cred. */
- *cached_nt_pass = (const uint8 *)centry_hash16(centry, mem_ctx);
+ *cached_nt_pass = (const uint8_t *)centry_hash16(centry, mem_ctx);
if (*cached_nt_pass == NULL) {
fstring sidstr;
/* We only have 17 bytes more data in the salted cred case. */
if (centry->len - centry->ofs == 17) {
- *cached_salt = (const uint8 *)centry_hash16(centry, mem_ctx);
+ *cached_salt = (const uint8_t *)centry_hash16(centry, mem_ctx);
} else {
*cached_salt = NULL;
}
NTSTATUS wcache_save_creds(struct winbindd_domain *domain,
const struct dom_sid *sid,
- const uint8 nt_pass[NT_HASH_LEN])
+ const uint8_t nt_pass[NT_HASH_LEN])
{
struct cache_entry *centry;
fstring sid_string;
- uint32 rid;
- uint8 cred_salt[NT_HASH_LEN];
- uint8 salted_hash[NT_HASH_LEN];
+ uint32_t rid;
+ uint8_t cred_salt[NT_HASH_LEN];
+ uint8_t salted_hash[NT_HASH_LEN];
if (is_null_sid(sid)) {
return NT_STATUS_INVALID_SID;
/* Query display info. This is the basic user list fn */
-static NTSTATUS query_user_list(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- uint32 *num_entries,
- struct wbint_userinfo **info)
+NTSTATUS wb_cache_query_user_list(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ uint32_t **prids)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
+ uint32_t num_rids = 0;
+ uint32_t *rids = NULL;
NTSTATUS status;
unsigned int i, retry;
bool old_status = domain->online;
+ *prids = NULL;
+
if (!cache->tdb)
goto do_query;
goto do_query;
do_fetch_cache:
- *num_entries = centry_uint32(centry);
+ num_rids = centry_uint32(centry);
- if (*num_entries == 0)
+ if (num_rids == 0) {
goto do_cached;
+ }
- (*info) = talloc_array(mem_ctx, struct wbint_userinfo, *num_entries);
- if (! (*info)) {
- smb_panic_fn("query_user_list out of memory");
+ rids = talloc_array(mem_ctx, uint32_t, num_rids);
+ if (rids == NULL) {
+ centry_free(centry);
+ return NT_STATUS_NO_MEMORY;
}
- for (i=0; i<(*num_entries); i++) {
- (*info)[i].acct_name = centry_string(centry, mem_ctx);
- (*info)[i].full_name = centry_string(centry, mem_ctx);
- (*info)[i].homedir = centry_string(centry, mem_ctx);
- (*info)[i].shell = centry_string(centry, mem_ctx);
- centry_sid(centry, &(*info)[i].user_sid);
- centry_sid(centry, &(*info)[i].group_sid);
+
+ for (i=0; i<num_rids; i++) {
+ rids[i] = centry_uint32(centry);
}
do_cached:
return status;
do_query:
- *num_entries = 0;
- *info = NULL;
/* Return status value returned by seq number check */
DEBUG(10,("query_user_list: [Cached] - doing backend query for list for domain %s\n",
domain->name ));
- status = domain->backend->query_user_list(domain, mem_ctx, num_entries, info);
+ rids = NULL;
+ status = domain->backend->query_user_list(domain, mem_ctx,
+ &rids);
+ num_rids = talloc_array_length(rids);
+
if (!NT_STATUS_IS_OK(status)) {
DEBUG(3, ("query_user_list: returned 0x%08x, "
"retrying\n", NT_STATUS_V(status)));
if (NT_STATUS_EQUAL(status, NT_STATUS_UNSUCCESSFUL)) {
DEBUG(3, ("query_user_list: flushing "
"connection cache\n"));
- invalidate_cm_connection(&domain->conn);
+ invalidate_cm_connection(domain);
}
if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
NT_STATUS_EQUAL(status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
set_domain_offline(domain);
}
/* store partial response. */
- if (*num_entries > 0) {
+ if (num_rids > 0) {
/*
* humm, what about the status used for cache?
* Should it be NT_STATUS_OK?
(retry++ < 5));
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
centry = centry_start(domain, status);
if (!centry)
goto skip_save;
- centry_put_uint32(centry, *num_entries);
- for (i=0; i<(*num_entries); i++) {
- centry_put_string(centry, (*info)[i].acct_name);
- centry_put_string(centry, (*info)[i].full_name);
- centry_put_string(centry, (*info)[i].homedir);
- centry_put_string(centry, (*info)[i].shell);
- centry_put_sid(centry, &(*info)[i].user_sid);
- centry_put_sid(centry, &(*info)[i].group_sid);
- if (domain->backend && domain->backend->consistent) {
- /* when the backend is consistent we can pre-prime some mappings */
- wcache_save_name_to_sid(domain, NT_STATUS_OK,
- domain->name,
- (*info)[i].acct_name,
- &(*info)[i].user_sid,
- SID_NAME_USER);
- wcache_save_sid_to_name(domain, NT_STATUS_OK,
- &(*info)[i].user_sid,
- domain->name,
- (*info)[i].acct_name,
- SID_NAME_USER);
- wcache_save_user(domain, NT_STATUS_OK, &(*info)[i]);
- }
+ centry_put_uint32(centry, num_rids);
+ for (i=0; i<num_rids; i++) {
+ centry_put_uint32(centry, rids[i]);
}
centry_end(centry, "UL/%s", domain->name);
centry_free(centry);
+ *prids = rids;
+
skip_save:
return status;
}
/* list all domain groups */
-static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- uint32 *num_entries,
- struct wb_acct_info **info)
+NTSTATUS wb_cache_enum_dom_groups(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ uint32_t *num_entries,
+ struct wb_acct_info **info)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
}
/* list all domain groups */
-static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- uint32 *num_entries,
- struct wb_acct_info **info)
+NTSTATUS wb_cache_enum_local_groups(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ uint32_t *num_entries,
+ struct wb_acct_info **info)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_NO_MEMORY;
}
+ if ((domain_name == NULL) || (domain_name[0] == '\0')) {
+ domain_name = domain->name;
+ }
+
centry = wcache_fetch(cache, domain, "NS/%s/%s", domain_name, uname);
TALLOC_FREE(uname);
if (centry == NULL) {
}
/* convert a single name to a sid in a domain */
-static NTSTATUS name_to_sid(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const char *domain_name,
- const char *name,
- uint32_t flags,
- struct dom_sid *sid,
- enum lsa_SidType *type)
+NTSTATUS wb_cache_name_to_sid(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ const char *domain_name,
+ const char *name,
+ uint32_t flags,
+ struct dom_sid *sid,
+ enum lsa_SidType *type)
{
NTSTATUS status;
bool old_status;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (domain->online &&
(NT_STATUS_IS_OK(status) || NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))) {
/* Only save the reverse mapping if this was not a UPN */
if (!strchr(name, '@')) {
- strupper_m(discard_const_p(char, domain_name));
- strlower_m(discard_const_p(char, name));
+ if (!strupper_m(discard_const_p(char, domain_name))) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ (void)strlower_m(discard_const_p(char, name));
wcache_save_sid_to_name(domain, status, sid, domain_name, name, *type);
}
}
return status;
}
-NTSTATUS wcache_sid_to_name(struct winbindd_domain *domain,
- const struct dom_sid *sid,
- TALLOC_CTX *mem_ctx,
- char **domain_name,
- char **name,
- enum lsa_SidType *type)
+static NTSTATUS wcache_sid_to_name(struct winbindd_domain *domain,
+ const struct dom_sid *sid,
+ TALLOC_CTX *mem_ctx,
+ char **domain_name,
+ char **name,
+ enum lsa_SidType *type)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry;
/* convert a sid to a user or group name. The sid is guaranteed to be in the domain
given */
-static NTSTATUS sid_to_name(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *sid,
- char **domain_name,
- char **name,
- enum lsa_SidType *type)
+NTSTATUS wb_cache_sid_to_name(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ const struct dom_sid *sid,
+ char **domain_name,
+ char **name,
+ enum lsa_SidType *type)
{
NTSTATUS status;
bool old_status;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return status;
}
-static NTSTATUS rids_to_names(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *domain_sid,
- uint32 *rids,
- size_t num_rids,
- char **domain_name,
- char ***names,
- enum lsa_SidType **types)
+NTSTATUS wb_cache_rids_to_names(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ const struct dom_sid *domain_sid,
+ uint32_t *rids,
+ size_t num_rids,
+ char **domain_name,
+ char ***names,
+ enum lsa_SidType **types)
{
struct winbind_cache *cache = get_cache(domain);
size_t i;
} else {
/* something's definitely wrong */
result = centry->status;
+ centry_free(centry);
goto error;
}
names, types);
if (NT_STATUS_EQUAL(result, NT_STATUS_IO_TIMEOUT) ||
- NT_STATUS_EQUAL(result, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
+ NT_STATUS_EQUAL(result, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
if (!domain->internal && old_status) {
set_domain_offline(domain);
}
old_status) {
have_mapped = have_unmapped = false;
+ *names = talloc_array(mem_ctx, char *, num_rids);
+ if (*names == NULL) {
+ result = NT_STATUS_NO_MEMORY;
+ goto error;
+ }
+
+ *types = talloc_array(mem_ctx, enum lsa_SidType,
+ num_rids);
+ if (*types == NULL) {
+ result = NT_STATUS_NO_MEMORY;
+ goto error;
+ }
+
for (i=0; i<num_rids; i++) {
struct dom_sid sid;
struct cache_entry *centry;
} else {
/* something's definitely wrong */
result = centry->status;
+ centry_free(centry);
goto error;
}
return result;
}
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
for (i=0; i<num_rids; i++) {
struct dom_sid sid;
and the rest of the data doesn't matter */
status = centry->status;
if (NT_STATUS_IS_OK(status)) {
+ info->domain_name = centry_string(centry, mem_ctx);
info->acct_name = centry_string(centry, mem_ctx);
info->full_name = centry_string(centry, mem_ctx);
info->homedir = centry_string(centry, mem_ctx);
info->shell = centry_string(centry, mem_ctx);
+ info->uid = centry_uint32(centry);
info->primary_gid = centry_uint32(centry);
+ info->primary_group_name = centry_string(centry, mem_ctx);
centry_sid(centry, &info->user_sid);
centry_sid(centry, &info->group_sid);
}
return status;
}
-/* Lookup user information from a rid */
-static NTSTATUS query_user(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *user_sid,
- struct wbint_userinfo *info)
-{
- NTSTATUS status;
- bool old_status;
-
- old_status = domain->online;
- status = wcache_query_user(domain, mem_ctx, user_sid, info);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
- return status;
- }
-
- ZERO_STRUCTP(info);
-
- /* Return status value returned by seq number check */
-
- if (!NT_STATUS_IS_OK(domain->last_status))
- return domain->last_status;
-
- DEBUG(10,("query_user: [Cached] - doing backend query for info for domain %s\n",
- domain->name ));
-
- status = domain->backend->query_user(domain, mem_ctx, user_sid, info);
-
- if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
- NT_STATUS_EQUAL(status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
- if (!domain->internal && old_status) {
- set_domain_offline(domain);
- }
- if (!domain->internal &&
- !domain->online &&
- old_status) {
- NTSTATUS cache_status;
- cache_status = wcache_query_user(domain, mem_ctx, user_sid, info);
- return cache_status;
- }
- }
- /* and save it */
- refresh_sequence_number(domain, false);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
- wcache_save_user(domain, status, info);
-
- return status;
-}
-
-NTSTATUS wcache_lookup_usergroups(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *user_sid,
- uint32_t *pnum_sids,
- struct dom_sid **psids)
-{
- struct winbind_cache *cache = get_cache(domain);
- struct cache_entry *centry = NULL;
- NTSTATUS status;
- uint32_t i, num_sids;
- struct dom_sid *sids;
- fstring sid_string;
-
- if (cache->tdb == NULL) {
- return NT_STATUS_NOT_FOUND;
- }
- centry = wcache_fetch(cache, domain, "UG/%s",
- sid_to_fstring(sid_string, user_sid));
- if (centry == NULL) {
- return NT_STATUS_NOT_FOUND;
- }
-
- /* If we have an access denied cache entry and a cached info3 in the
- samlogon cache then do a query. This will force the rpc back end
- to return the info3 data. */
-
- if (NT_STATUS_EQUAL(domain->last_status, NT_STATUS_ACCESS_DENIED)
- && netsamlogon_cache_have(user_sid)) {
- DEBUG(10, ("lookup_usergroups: cached access denied and have "
- "cached info3\n"));
- domain->last_status = NT_STATUS_OK;
- centry_free(centry);
- return NT_STATUS_NOT_FOUND;
- }
-
- num_sids = centry_uint32(centry);
- sids = talloc_array(mem_ctx, struct dom_sid, num_sids);
- if (sids == NULL) {
- centry_free(centry);
- return NT_STATUS_NO_MEMORY;
- }
-
- for (i=0; i<num_sids; i++) {
- centry_sid(centry, &sids[i]);
- }
-
- status = centry->status;
-
- DEBUG(10,("lookup_usergroups: [Cached] - cached info for domain %s "
- "status: %s\n", domain->name, nt_errstr(status)));
-
- centry_free(centry);
-
- *pnum_sids = num_sids;
- *psids = sids;
- return status;
-}
-
-/* Lookup groups a user is a member of. */
-static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *user_sid,
- uint32 *num_groups, struct dom_sid **user_gids)
+/**
+* @brief Query a fullname from the username cache (for further gecos processing)
+*
+* @param domain A pointer to the winbindd_domain struct.
+* @param mem_ctx The talloc context.
+* @param user_sid The user sid.
+* @param full_name A pointer to the full_name string.
+*
+* @return NTSTATUS code
+*/
+NTSTATUS wcache_query_user_fullname(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ const struct dom_sid *user_sid,
+ const char **full_name)
{
- struct cache_entry *centry = NULL;
NTSTATUS status;
- unsigned int i;
- fstring sid_string;
- bool old_status;
+ struct wbint_userinfo info;
- old_status = domain->online;
- status = wcache_lookup_usergroups(domain, mem_ctx, user_sid,
- num_groups, user_gids);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ status = wcache_query_user(domain, mem_ctx, user_sid, &info);
+ if (!NT_STATUS_IS_OK(status)) {
return status;
}
- (*num_groups) = 0;
- (*user_gids) = NULL;
-
- /* Return status value returned by seq number check */
-
- if (!NT_STATUS_IS_OK(domain->last_status))
- return domain->last_status;
-
- DEBUG(10,("lookup_usergroups: [Cached] - doing backend query for info for domain %s\n",
- domain->name ));
-
- status = domain->backend->lookup_usergroups(domain, mem_ctx, user_sid, num_groups, user_gids);
-
- if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT) ||
- NT_STATUS_EQUAL(status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
- if (!domain->internal && old_status) {
- set_domain_offline(domain);
- }
- if (!domain->internal &&
- !domain->online &&
- old_status) {
- NTSTATUS cache_status;
- cache_status = wcache_lookup_usergroups(domain, mem_ctx, user_sid,
- num_groups, user_gids);
- return cache_status;
+ if (info.full_name != NULL) {
+ *full_name = talloc_strdup(mem_ctx, info.full_name);
+ if (*full_name == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
}
- if ( NT_STATUS_EQUAL(status, NT_STATUS_SYNCHRONIZATION_REQUIRED) )
- goto skip_save;
-
- /* and save it */
- refresh_sequence_number(domain, false);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
- centry = centry_start(domain, status);
- if (!centry)
- goto skip_save;
-
- centry_put_uint32(centry, *num_groups);
- for (i=0; i<(*num_groups); i++) {
- centry_put_sid(centry, &(*user_gids)[i]);
- }
- centry_end(centry, "UG/%s", sid_to_fstring(sid_string, user_sid));
- centry_free(centry);
-
-skip_save:
- return status;
+ return NT_STATUS_OK;
}
static char *wcache_make_sidlist(TALLOC_CTX *mem_ctx, uint32_t num_sids,
return status;
}
-static NTSTATUS lookup_useraliases(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- uint32 num_sids, const struct dom_sid *sids,
- uint32 *num_aliases, uint32 **alias_rids)
+NTSTATUS wb_cache_lookup_useraliases(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ uint32_t num_sids,
+ const struct dom_sid *sids,
+ uint32_t *num_aliases,
+ uint32_t **alias_rids)
{
struct cache_entry *centry = NULL;
NTSTATUS status;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
*sid_mem = talloc_array(mem_ctx, struct dom_sid, *num_names);
*names = talloc_array(mem_ctx, char *, *num_names);
- *name_types = talloc_array(mem_ctx, uint32, *num_names);
+ *name_types = talloc_array(mem_ctx, uint32_t, *num_names);
if ((*sid_mem == NULL) || (*names == NULL) || (*name_types == NULL)) {
TALLOC_FREE(*sid_mem);
return status;
}
-static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- const struct dom_sid *group_sid,
- enum lsa_SidType type,
- uint32 *num_names,
- struct dom_sid **sid_mem, char ***names,
- uint32 **name_types)
+NTSTATUS wb_cache_lookup_groupmem(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ const struct dom_sid *group_sid,
+ enum lsa_SidType type,
+ uint32_t *num_names,
+ struct dom_sid **sid_mem,
+ char ***names,
+ uint32_t **name_types)
{
struct cache_entry *centry = NULL;
NTSTATUS status;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
}
/* find the sequence number for a domain */
-static NTSTATUS sequence_number(struct winbindd_domain *domain, uint32 *seq)
+NTSTATUS wb_cache_sequence_number(struct winbindd_domain *domain,
+ uint32_t *seq)
{
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
*seq = domain->sequence_number;
/* enumerate trusted domains
* (we need to have the list of trustdoms in the cache when we go offline) -
* Guenther */
-static NTSTATUS trusted_domains(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- struct netr_DomainTrustList *trusts)
+NTSTATUS wb_cache_trusted_domains(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ struct netr_DomainTrustList *trusts)
{
NTSTATUS status;
struct winbind_cache *cache;
}
/* get lockout policy */
-static NTSTATUS lockout_policy(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- struct samr_DomInfo12 *policy)
+NTSTATUS wb_cache_lockout_policy(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo12 *policy)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
}
/* get password policy */
-static NTSTATUS password_policy(struct winbindd_domain *domain,
- TALLOC_CTX *mem_ctx,
- struct samr_DomInfo1 *policy)
+NTSTATUS wb_cache_password_policy(struct winbindd_domain *domain,
+ TALLOC_CTX *mem_ctx,
+ struct samr_DomInfo1 *policy)
{
struct winbind_cache *cache = get_cache(domain);
struct cache_entry *centry = NULL;
}
}
/* and save it */
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
fstring key_str, sid_string;
struct winbind_cache *cache;
- /* dont clear cached U/SID and UG/SID entries when we want to logon
+ /* don't clear cached U/SID and UG/SID entries when we want to logon
* offline - gd */
if (lp_winbind_offline_logon()) {
DEBUG(10, ("wcache_invalidate_samlogon: clearing %s\n", key_str));
tdb_delete(cache->tdb, string_tdb_data(key_str));
- /* Clear UG/SID cache entry */
- fstr_sprintf(key_str, "UG/%s", sid_to_fstring(sid_string, sid));
- DEBUG(10, ("wcache_invalidate_samlogon: clearing %s\n", key_str));
- tdb_delete(cache->tdb, string_tdb_data(key_str));
-
/* Samba/winbindd never needs this. */
netsamlogon_clear_cached_user(sid);
}
bool init_wcache(void)
{
+ char *db_path;
+
if (wcache == NULL) {
wcache = SMB_XMALLOC_P(struct winbind_cache);
ZERO_STRUCTP(wcache);
if (wcache->tdb != NULL)
return true;
+ db_path = wcache_path();
+ if (db_path == NULL) {
+ return false;
+ }
+
/* when working offline we must not clear the cache on restart */
- wcache->tdb = tdb_open_log(state_path("winbindd_cache.tdb"),
+ wcache->tdb = tdb_open_log(db_path,
WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
TDB_INCOMPATIBLE_HASH |
(lp_winbind_offline_logon() ? TDB_DEFAULT : (TDB_DEFAULT | TDB_CLEAR_IF_FIRST)),
O_RDWR|O_CREAT, 0600);
-
+ TALLOC_FREE(db_path);
if (wcache->tdb == NULL) {
DEBUG(0,("Failed to open winbindd_cache.tdb!\n"));
return false;
bool initialize_winbindd_cache(void)
{
bool cache_bad = true;
- uint32 vers;
+ uint32_t vers;
if (!init_wcache()) {
DEBUG(0,("initialize_winbindd_cache: init_wcache failed.\n"));
}
if (cache_bad) {
+ char *db_path;
+
DEBUG(0,("initialize_winbindd_cache: clearing cache "
"and re-creating with version number %d\n",
WINBINDD_CACHE_VERSION ));
tdb_close(wcache->tdb);
wcache->tdb = NULL;
- if (unlink(state_path("winbindd_cache.tdb")) == -1) {
+ db_path = wcache_path();
+ if (db_path == NULL) {
+ return false;
+ }
+
+ if (unlink(db_path) == -1) {
DEBUG(0,("initialize_winbindd_cache: unlink %s failed %s ",
- state_path("winbindd_cache.tdb"),
+ db_path,
strerror(errno) ));
+ TALLOC_FREE(db_path);
return false;
}
+ TALLOC_FREE(db_path);
if (!init_wcache()) {
DEBUG(0,("initialize_winbindd_cache: re-initialization "
"init_wcache failed.\n"));
/* Write the version. */
if (!tdb_store_uint32(wcache->tdb, WINBINDD_CACHE_VERSION_KEYSTR, WINBINDD_CACHE_VERSION)) {
DEBUG(0,("initialize_winbindd_cache: version number store failed %s\n",
- tdb_errorstr_compat(wcache->tdb) ));
+ tdb_errorstr(wcache->tdb) ));
return false;
}
}
return NT_STATUS_IS_OK(status);
}
+/*
+ * Cache a name to sid without checking the sequence number.
+ * Used when caching from a trusted PAC.
+ */
+
+void cache_name2sid_trusted(struct winbindd_domain *domain,
+ const char *domain_name,
+ const char *name,
+ enum lsa_SidType type,
+ const struct dom_sid *sid)
+{
+ /*
+ * Ensure we store the mapping with the
+ * existing sequence number from the cache.
+ */
+ get_cache(domain);
+ (void)fetch_cache_seqnum(domain, time(NULL));
+ wcache_save_name_to_sid(domain,
+ NT_STATUS_OK,
+ domain_name,
+ name,
+ sid,
+ type);
+}
+
void cache_name2sid(struct winbindd_domain *domain,
const char *domain_name, const char *name,
enum lsa_SidType type, const struct dom_sid *sid)
{
- refresh_sequence_number(domain, false);
+ refresh_sequence_number(domain);
wcache_save_name_to_sid(domain, NT_STATUS_OK, domain_name, name,
sid, type);
}
/* flush the cache */
void wcache_flush_cache(void)
{
+ char *db_path;
+
if (!wcache)
return;
if (wcache->tdb) {
return;
}
+ db_path = wcache_path();
+ if (db_path == NULL) {
+ return;
+ }
+
/* when working offline we must not clear the cache on restart */
- wcache->tdb = tdb_open_log(state_path("winbindd_cache.tdb"),
- WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
+ wcache->tdb = tdb_open_log(db_path,
+ WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
TDB_INCOMPATIBLE_HASH |
(lp_winbind_offline_logon() ? TDB_DEFAULT : (TDB_DEFAULT | TDB_CLEAR_IF_FIRST)),
O_RDWR|O_CREAT, 0600);
-
+ TALLOC_FREE(db_path);
if (!wcache->tdb) {
DEBUG(0,("Failed to open winbindd_cache.tdb!\n"));
return;
struct winbind_cache *cache = get_cache(domain);
NTSTATUS status;
int ret;
- struct cred_list *cred, *oldest = NULL;
+ struct cred_list *cred, *next, *oldest = NULL;
if (!cache->tdb) {
return NT_STATUS_INTERNAL_DB_ERROR;
TDB_DATA data;
time_t t;
- data = tdb_fetch_compat(cache->tdb, string_tdb_data(cred->name));
+ data = tdb_fetch(cache->tdb, string_tdb_data(cred->name));
if (!data.dptr) {
DEBUG(10,("wcache_remove_oldest_cached_creds: entry for [%s] not found\n",
cred->name));
status = NT_STATUS_UNSUCCESSFUL;
}
done:
- SAFE_FREE(wcache_cred_list);
+ for (cred = wcache_cred_list; cred; cred = next) {
+ next = cred->next;
+ DLIST_REMOVE(wcache_cred_list, cred);
+ SAFE_FREE(cred);
+ }
SAFE_FREE(oldest);
return status;
struct cache_entry *centry;
centry = SMB_XMALLOC_P(struct cache_entry);
- centry->data = (unsigned char *)memdup(data.dptr, data.dsize);
+ centry->data = (unsigned char *)smb_memdup(data.dptr, data.dsize);
if (!centry->data) {
SAFE_FREE(centry);
return NULL;
(void)centry_string(centry, mem_ctx);
(void)centry_string(centry, mem_ctx);
(void)centry_string(centry, mem_ctx);
+ (void)centry_string(centry, mem_ctx);
+ (void)centry_uint32(centry);
(void)centry_uint32(centry);
+ (void)centry_string(centry, mem_ctx);
(void)centry_sid(centry, &sid);
(void)centry_sid(centry, &sid);
struct tdb_validation_status *state)
{
struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
- int32 num_entries, i;
+ int32_t num_entries, i;
if (!centry) {
return 1;
}
- num_entries = (int32)centry_uint32(centry);
+ num_entries = (int32_t)centry_uint32(centry);
for (i=0; i< num_entries; i++) {
- struct dom_sid sid;
- (void)centry_string(centry, mem_ctx);
- (void)centry_string(centry, mem_ctx);
- (void)centry_string(centry, mem_ctx);
- (void)centry_string(centry, mem_ctx);
- (void)centry_sid(centry, &sid);
- (void)centry_sid(centry, &sid);
+ (void)centry_uint32(centry);
}
centry_free(centry);
struct tdb_validation_status *state)
{
struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
- int32 num_entries, i;
+ int32_t num_entries, i;
if (!centry) {
return 1;
return 0;
}
-static int validate_ug(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
- struct tdb_validation_status *state)
-{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
- int32 num_groups, i;
-
- if (!centry) {
- return 1;
- }
-
- num_groups = centry_uint32(centry);
-
- for (i=0; i< num_groups; i++) {
- struct dom_sid sid;
- centry_sid(centry, &sid);
- }
-
- centry_free(centry);
-
- if (!(state->success)) {
- return 1;
- }
- DEBUG(10,("validate_ug: %s ok\n", keystr));
- return 0;
-}
-
static int validate_ua(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
struct tdb_validation_status *state)
{
struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
- int32 num_aliases, i;
+ int32_t num_aliases, i;
if (!centry) {
return 1;
struct tdb_validation_status *state)
{
struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
- int32 num_names, i;
+ int32_t num_names, i;
if (!centry) {
return 1;
return 0;
}
-static int validate_pwinfo(TALLOC_CTX *mem_ctx, const char *keystr,
- TDB_DATA dbuf, struct tdb_validation_status *state)
-{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
-
- if (!centry) {
- return 1;
- }
-
- (void)centry_string(centry, mem_ctx);
- (void)centry_string(centry, mem_ctx);
- (void)centry_string(centry, mem_ctx);
- (void)centry_uint32(centry);
-
- centry_free(centry);
-
- if (!(state->success)) {
- return 1;
- }
- DEBUG(10,("validate_pwinfo: %s ok\n", keystr));
- return 0;
-}
-
static int validate_nss_an(TALLOC_CTX *mem_ctx, const char *keystr,
TDB_DATA dbuf,
struct tdb_validation_status *state)
if (!(state->success)) {
return 1;
}
- DEBUG(10,("validate_pwinfo: %s ok\n", keystr));
+ DBG_DEBUG("%s ok\n", keystr);
return 0;
}
{"CRED/", validate_cred},
{"UL/", validate_ul},
{"GL/", validate_gl},
- {"UG/", validate_ug},
{"UA", validate_ua},
{"GM/", validate_gm},
{"DR/", validate_dr},
{"DE/", validate_de},
- {"NSS/PWINFO/", validate_pwinfo},
{"TRUSTDOMCACHE/", validate_trustdomcache},
{"NSS/NA/", validate_nss_na},
{"NSS/AN/", validate_nss_an},
struct tdb_validation_status *v_state = (struct tdb_validation_status *)state;
/* Paranoia check. */
- if (strncmp("UA/", (const char *)kbuf.dptr, 3) == 0) {
+ if (strncmp("UA/", (const char *)kbuf.dptr, 3) == 0 ||
+ strncmp("NDR/", (const char *)kbuf.dptr, 4) == 0) {
max_key_len = 1024 * 1024;
}
if (kbuf.dsize > max_key_len) {
}
DEBUG(0,("cache_traverse_validate_fn: unknown cache entry\nkey :\n"));
- dump_data(0, (uint8 *)kbuf.dptr, kbuf.dsize);
+ dump_data(0, (uint8_t *)kbuf.dptr, kbuf.dsize);
DEBUG(0,("data :\n"));
- dump_data(0, (uint8 *)dbuf.dptr, dbuf.dsize);
+ dump_data(0, (uint8_t *)dbuf.dptr, dbuf.dsize);
v_state->unknown_key = true;
v_state->success = false;
return 1; /* terminate. */
exit(47);
}
+static int wbcache_update_centry_fn(TDB_CONTEXT *tdb,
+ TDB_DATA key,
+ TDB_DATA data,
+ void *state)
+{
+ uint64_t ctimeout;
+ TDB_DATA blob;
+
+ if (is_non_centry_key(key)) {
+ return 0;
+ }
+
+ if (data.dptr == NULL || data.dsize == 0) {
+ if (tdb_delete(tdb, key) < 0) {
+ DEBUG(0, ("tdb_delete for [%s] failed!\n",
+ key.dptr));
+ return 1;
+ }
+ }
+
+ /* add timeout to blob (uint64_t) */
+ blob.dsize = data.dsize + 8;
+
+ blob.dptr = SMB_XMALLOC_ARRAY(uint8_t, blob.dsize);
+ if (blob.dptr == NULL) {
+ return 1;
+ }
+ memset(blob.dptr, 0, blob.dsize);
+
+ /* copy status and seqnum */
+ memcpy(blob.dptr, data.dptr, 8);
+
+ /* add timeout */
+ ctimeout = lp_winbind_cache_time() + time(NULL);
+ SBVAL(blob.dptr, 8, ctimeout);
+
+ /* copy the rest */
+ memcpy(blob.dptr + 16, data.dptr + 8, data.dsize - 8);
+
+ if (tdb_store(tdb, key, blob, TDB_REPLACE) < 0) {
+ DEBUG(0, ("tdb_store to update [%s] failed!\n",
+ key.dptr));
+ SAFE_FREE(blob.dptr);
+ return 1;
+ }
+
+ SAFE_FREE(blob.dptr);
+ return 0;
+}
+
+static bool wbcache_upgrade_v1_to_v2(TDB_CONTEXT *tdb)
+{
+ int rc;
+
+ DEBUG(1, ("Upgrade to version 2 of the winbindd_cache.tdb\n"));
+
+ rc = tdb_traverse(tdb, wbcache_update_centry_fn, NULL);
+ if (rc < 0) {
+ return false;
+ }
+
+ return true;
+}
+
/***********************************************************************
Try and validate every entry in the winbindd cache. If we fail here,
delete the cache tdb and return non-zero.
int winbindd_validate_cache(void)
{
int ret = -1;
- const char *tdb_path = state_path("winbindd_cache.tdb");
+ char *tdb_path = NULL;
TDB_CONTEXT *tdb = NULL;
+ uint32_t vers_id;
+ bool ok;
DEBUG(10, ("winbindd_validate_cache: replacing panic function\n"));
smb_panic_fn = validate_panic;
+ tdb_path = wcache_path();
+ if (tdb_path == NULL) {
+ goto done;
+ }
- tdb = tdb_open_log(tdb_path,
+ tdb = tdb_open_log(tdb_path,
WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
TDB_INCOMPATIBLE_HASH |
- ( lp_winbind_offline_logon()
- ? TDB_DEFAULT
+ ( lp_winbind_offline_logon()
+ ? TDB_DEFAULT
: TDB_DEFAULT | TDB_CLEAR_IF_FIRST ),
- O_RDWR|O_CREAT,
+ O_RDWR|O_CREAT,
0600);
if (!tdb) {
DEBUG(0, ("winbindd_validate_cache: "
"error opening/initializing tdb\n"));
goto done;
}
+
+ /* Version check and upgrade code. */
+ if (!tdb_fetch_uint32(tdb, WINBINDD_CACHE_VERSION_KEYSTR, &vers_id)) {
+ DEBUG(10, ("Fresh database\n"));
+ tdb_store_uint32(tdb, WINBINDD_CACHE_VERSION_KEYSTR, WINBINDD_CACHE_VERSION);
+ vers_id = WINBINDD_CACHE_VERSION;
+ }
+
+ if (vers_id != WINBINDD_CACHE_VERSION) {
+ if (vers_id == WINBINDD_CACHE_VER1) {
+ ok = wbcache_upgrade_v1_to_v2(tdb);
+ if (!ok) {
+ DEBUG(10, ("winbindd_validate_cache: upgrade to version 2 failed.\n"));
+ unlink(tdb_path);
+ goto done;
+ }
+
+ tdb_store_uint32(tdb,
+ WINBINDD_CACHE_VERSION_KEYSTR,
+ WINBINDD_CACHE_VERSION);
+ vers_id = WINBINDD_CACHE_VER2;
+ }
+ }
+
tdb_close(tdb);
ret = tdb_validate_and_backup(tdb_path, cache_traverse_validate_fn);
}
done:
+ TALLOC_FREE(tdb_path);
DEBUG(10, ("winbindd_validate_cache: restoring panic function\n"));
smb_panic_fn = smb_panic;
return ret;
int winbindd_validate_cache_nobackup(void)
{
int ret = -1;
- const char *tdb_path = state_path("winbindd_cache.tdb");
+ char *tdb_path;
DEBUG(10, ("winbindd_validate_cache: replacing panic function\n"));
smb_panic_fn = validate_panic;
+ tdb_path = wcache_path();
+ if (tdb_path == NULL) {
+ goto err_panic_restore;
+ }
if (wcache == NULL || wcache->tdb == NULL) {
ret = tdb_validate_open(tdb_path, cache_traverse_validate_fn);
"successful.\n"));
}
+ TALLOC_FREE(tdb_path);
+err_panic_restore:
DEBUG(10, ("winbindd_validate_cache_nobackup: restoring panic "
"function\n"));
smb_panic_fn = smb_panic;
if ( !list )
return false;
- list[idx].domain_name = talloc_strdup( list, new_dom->name );
- list[idx].dns_name = talloc_strdup( list, new_dom->alt_name );
+ list[idx].domain_name = talloc_strdup(list, new_dom->name);
+ if (list[idx].domain_name == NULL) {
+ return false;
+ }
+ if (new_dom->alt_name != NULL) {
+ list[idx].dns_name = talloc_strdup(list, new_dom->alt_name);
+ if (list[idx].dns_name == NULL) {
+ return false;
+ }
+ }
if ( !is_null_sid( &new_dom->sid ) ) {
sid_copy( &list[idx].sid, &new_dom->sid );
len += tdb_pack( buffer+len, buflen-len, "fffddd",
domains[i].domain_name,
- domains[i].dns_name,
+ domains[i].dns_name ? domains[i].dns_name : "",
sid_to_fstring(tmp, &domains[i].sid),
domains[i].trust_flags,
domains[i].trust_attribs,
struct winbindd_tdc_domain **domains )
{
fstring domain_name, dns_name, sid_string;
- uint32 type, attribs, flags;
+ uint32_t type, attribs, flags;
int num_domains;
int len = 0;
int i;
}
for ( i=0; i<num_domains; i++ ) {
- len += tdb_unpack( buf+len, buflen-len, "fffddd",
+ int this_len;
+
+ this_len = tdb_unpack( buf+len, buflen-len, "fffddd",
domain_name,
dns_name,
sid_string,
&attribs,
&type );
- if ( len == -1 ) {
+ if ( this_len == -1 ) {
DEBUG(5,("unpack_tdc_domains: Failed to unpack domain array\n"));
TALLOC_FREE( list );
return 0;
}
+ len += this_len;
DEBUG(11,("unpack_tdc_domains: Unpacking domain %s (%s) "
"SID %s, flags = 0x%x, attribs = 0x%x, type = 0x%x\n",
flags, attribs, type));
list[i].domain_name = talloc_strdup( list, domain_name );
- list[i].dns_name = talloc_strdup( list, dns_name );
+ list[i].dns_name = NULL;
+ if (dns_name[0] != '\0') {
+ list[i].dns_name = talloc_strdup(list, dns_name);
+ }
if ( !string_to_sid( &(list[i].sid), sid_string ) ) {
DEBUG(10,("unpack_tdc_domains: no SID for domain %s\n",
domain_name));
if ( !key.dptr )
return false;
- data = tdb_fetch_compat( wcache->tdb, key );
+ data = tdb_fetch( wcache->tdb, key );
SAFE_FREE( key.dptr );
return ret;
}
+static struct winbindd_tdc_domain *wcache_tdc_dup_domain(
+ TALLOC_CTX *mem_ctx, const struct winbindd_tdc_domain *src)
+{
+ struct winbindd_tdc_domain *dst;
+
+ dst = talloc(mem_ctx, struct winbindd_tdc_domain);
+ if (dst == NULL) {
+ goto fail;
+ }
+ dst->domain_name = talloc_strdup(dst, src->domain_name);
+ if (dst->domain_name == NULL) {
+ goto fail;
+ }
+
+ dst->dns_name = NULL;
+ if (src->dns_name != NULL) {
+ dst->dns_name = talloc_strdup(dst, src->dns_name);
+ if (dst->dns_name == NULL) {
+ goto fail;
+ }
+ }
+
+ sid_copy(&dst->sid, &src->sid);
+ dst->trust_flags = src->trust_flags;
+ dst->trust_type = src->trust_type;
+ dst->trust_attribs = src->trust_attribs;
+ return dst;
+fail:
+ TALLOC_FREE(dst);
+ return NULL;
+}
+
/*********************************************************************
********************************************************************/
DEBUG(10,("wcache_tdc_fetch_domain: Searching for domain %s\n", name));
if ( !init_wcache() ) {
- return false;
+ return NULL;
}
/* fetch the list */
DEBUG(10,("wcache_tdc_fetch_domain: Found domain %s\n",
name));
- d = talloc( ctx, struct winbindd_tdc_domain );
- if ( !d )
- break;
-
- d->domain_name = talloc_strdup( d, dom_list[i].domain_name );
- d->dns_name = talloc_strdup( d, dom_list[i].dns_name );
- sid_copy( &d->sid, &dom_list[i].sid );
- d->trust_flags = dom_list[i].trust_flags;
- d->trust_type = dom_list[i].trust_type;
- d->trust_attribs = dom_list[i].trust_attribs;
-
+ d = wcache_tdc_dup_domain(ctx, &dom_list[i]);
break;
}
}
sid_string_dbg(sid)));
if (!init_wcache()) {
- return false;
+ return NULL;
}
/* fetch the list */
dom_list[i].domain_name,
sid_string_dbg(sid)));
- d = talloc(ctx, struct winbindd_tdc_domain);
- if (!d)
- break;
-
- d->domain_name = talloc_strdup(d,
- dom_list[i].domain_name);
-
- d->dns_name = talloc_strdup(d, dom_list[i].dns_name);
- sid_copy(&d->sid, &dom_list[i].sid);
- d->trust_flags = dom_list[i].trust_flags;
- d->trust_type = dom_list[i].trust_type;
- d->trust_attribs = dom_list[i].trust_attribs;
-
+ d = wcache_tdc_dup_domain(ctx, &dom_list[i]);
break;
}
}
return;
}
-
-/*********************************************************************
- ********************************************************************/
-
-static void wcache_save_user_pwinfo(struct winbindd_domain *domain,
- NTSTATUS status,
- const struct dom_sid *user_sid,
- const char *homedir,
- const char *shell,
- const char *gecos,
- uint32 gid)
-{
- struct cache_entry *centry;
- fstring tmp;
-
- if ( (centry = centry_start(domain, status)) == NULL )
- return;
-
- centry_put_string( centry, homedir );
- centry_put_string( centry, shell );
- centry_put_string( centry, gecos );
- centry_put_uint32( centry, gid );
-
- centry_end(centry, "NSS/PWINFO/%s", sid_to_fstring(tmp, user_sid) );
-
- DEBUG(10,("wcache_save_user_pwinfo: %s\n", sid_string_dbg(user_sid) ));
-
- centry_free(centry);
-}
-
-#ifdef HAVE_ADS
-
-NTSTATUS nss_get_info_cached( struct winbindd_domain *domain,
- const struct dom_sid *user_sid,
- TALLOC_CTX *ctx,
- const char **homedir, const char **shell,
- const char **gecos, gid_t *p_gid)
-{
- struct winbind_cache *cache = get_cache(domain);
- struct cache_entry *centry = NULL;
- NTSTATUS nt_status;
- fstring tmp;
-
- if (!cache->tdb)
- goto do_query;
-
- centry = wcache_fetch(cache, domain, "NSS/PWINFO/%s",
- sid_to_fstring(tmp, user_sid));
-
- if (!centry)
- goto do_query;
-
- *homedir = centry_string( centry, ctx );
- *shell = centry_string( centry, ctx );
- *gecos = centry_string( centry, ctx );
- *p_gid = centry_uint32( centry );
-
- centry_free(centry);
-
- DEBUG(10,("nss_get_info_cached: [Cached] - user_sid %s\n",
- sid_string_dbg(user_sid)));
-
- return NT_STATUS_OK;
-
-do_query:
-
- nt_status = nss_get_info( domain->name, user_sid, ctx,
- homedir, shell, gecos, p_gid );
-
- DEBUG(10, ("nss_get_info returned %s\n", nt_errstr(nt_status)));
-
- if ( NT_STATUS_IS_OK(nt_status) ) {
- DEBUG(10, ("result:\n\thomedir = '%s'\n", *homedir));
- DEBUGADD(10, ("\tshell = '%s'\n", *shell));
- DEBUGADD(10, ("\tgecos = '%s'\n", *gecos));
- DEBUGADD(10, ("\tgid = '%u'\n", (unsigned int)*p_gid));
-
- wcache_save_user_pwinfo( domain, nt_status, user_sid,
- *homedir, *shell, *gecos, *p_gid );
- }
-
- if ( NT_STATUS_EQUAL( nt_status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND ) ) {
- DEBUG(5,("nss_get_info_cached: Setting domain %s offline\n",
- domain->name ));
- set_domain_offline( domain );
- }
-
- return nt_status;
-}
-
-#endif
-
-/* the cache backend methods are exposed via this structure */
-struct winbindd_methods cache_methods = {
- true,
- query_user_list,
- enum_dom_groups,
- enum_local_groups,
- name_to_sid,
- sid_to_name,
- rids_to_names,
- query_user,
- lookup_usergroups,
- lookup_useraliases,
- lookup_groupmem,
- sequence_number,
- lockout_policy,
- password_policy,
- trusted_domains
-};
-
-static bool wcache_ndr_key(TALLOC_CTX *mem_ctx, char *domain_name,
+static bool wcache_ndr_key(TALLOC_CTX *mem_ctx, const char *domain_name,
uint32_t opnum, const DATA_BLOB *req,
TDB_DATA *pkey)
{
if (!wcache_ndr_key(talloc_tos(), domain->name, opnum, req, &key)) {
return false;
}
- data = tdb_fetch_compat(wcache->tdb, key);
+ data = tdb_fetch(wcache->tdb, key);
TALLOC_FREE(key.dptr);
if (data.dptr == NULL) {