static bool do_winbind_online(struct tevent_context *ev_ctx, struct messaging_context *msg_ctx, const struct server_id pid, const int argc, const char **argv) { TDB_CONTEXT *tdb; if (argc != 1) { fprintf(stderr, "Usage: smbcontrol winbindd online\n"); return False; } /* Remove the entry in the winbindd_cache tdb to tell a later starting winbindd that we're online. */ tdb = tdb_open_log(state_path("winbindd_cache.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600); if (!tdb) { fprintf(stderr, "Cannot open the tdb %s for writing.\n", state_path("winbindd_cache.tdb")); return False; } tdb_delete_bystring(tdb, "WINBINDD_OFFLINE"); tdb_close(tdb); return send_message(msg_ctx, pid, MSG_WINBIND_ONLINE, NULL, 0); }
bool login_cache_delentry(const struct samu *sampass) { int ret; char *keystr; if (!login_cache_init()) return False; if (pdb_get_nt_username(sampass) == NULL) { return False; } keystr = SMB_STRDUP(pdb_get_nt_username(sampass)); if (!keystr || !keystr[0]) { SAFE_FREE(keystr); return False; } DEBUG(9, ("About to delete entry for %s\n", keystr)); ret = tdb_delete_bystring(cache, keystr); DEBUG(9, ("tdb_delete returned %d\n", ret)); SAFE_FREE(keystr); return ret == 0; }
BOOL remove_account_policy_migrated(void) { if (!init_account_policy()) { return False; } return tdb_delete_bystring(tdb, "AP_MIGRATED_TO_PASSDB"); }
TDB_DATA get_printer_notify_pid_list(TDB_CONTEXT *tdb, const char *printer_name, BOOL cleanlist) { TDB_DATA data; size_t i; ZERO_STRUCT(data); data = tdb_fetch_bystring( tdb, NOTIFY_PID_LIST_KEY ); if (!data.dptr) { ZERO_STRUCT(data); return data; } if (data.dsize % 8) { DEBUG(0,("get_printer_notify_pid_list: Size of record for printer %s not a multiple of 8 !\n", printer_name )); tdb_delete_bystring(tdb, NOTIFY_PID_LIST_KEY ); SAFE_FREE(data.dptr); ZERO_STRUCT(data); return data; } if (!cleanlist) return data; /* * Weed out all dead entries. */ for( i = 0; i < data.dsize; i += 8) { pid_t pid = (pid_t)IVAL(data.dptr, i); if (pid == sys_getpid()) continue; /* Entry is dead if process doesn't exist or refcount is zero. */ while ((i < data.dsize) && ((IVAL(data.dptr, i + 4) == 0) || !process_exists(pid))) { /* Refcount == zero is a logic error and should never happen. */ if (IVAL(data.dptr, i + 4) == 0) { DEBUG(0,("get_printer_notify_pid_list: Refcount == 0 for pid = %u printer %s !\n", (unsigned int)pid, printer_name )); } if (data.dsize - i > 8) memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8); data.dsize -= 8; } } return data; }
void netsamlogon_clear_cached_user(const struct dom_sid *user_sid) { char keystr[DOM_SID_STR_BUFLEN]; if (!netsamlogon_cache_init()) { DEBUG(0,("netsamlogon_clear_cached_user: cannot open " "%s for write!\n", NETSAMLOGON_TDB)); return; } /* Prepare key as DOMAIN-SID/USER-RID string */ dom_sid_string_buf(user_sid, keystr, sizeof(keystr)); DEBUG(10,("netsamlogon_clear_cached_user: SID [%s]\n", keystr)); tdb_delete_bystring(netsamlogon_tdb, keystr); }
/* save the notify array */ static NTSTATUS notify_save(struct notify_context *notify) { TDB_DATA dbuf; DATA_BLOB blob; enum ndr_err_code ndr_err; int ret; TALLOC_CTX *tmp_ctx; /* if possible, remove some depth arrays */ while (notify->array->num_depths > 0 && notify->array->depth[notify->array->num_depths-1].num_entries == 0) { notify->array->num_depths--; } /* we might just be able to delete the record */ if (notify->array->num_depths == 0) { ret = tdb_delete_bystring(notify->w->tdb, NOTIFY_KEY); if (ret != 0) { return NT_STATUS_INTERNAL_DB_CORRUPTION; } return NT_STATUS_OK; } tmp_ctx = talloc_new(notify); NT_STATUS_HAVE_NO_MEMORY(tmp_ctx); ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, notify->array, (ndr_push_flags_fn_t)ndr_push_notify_array); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { talloc_free(tmp_ctx); return ndr_map_error2ntstatus(ndr_err); } dbuf.dptr = blob.data; dbuf.dsize = blob.length; ret = tdb_store_bystring(notify->w->tdb, NOTIFY_KEY, dbuf, TDB_REPLACE); talloc_free(tmp_ctx); if (ret != 0) { return NT_STATUS_INTERNAL_DB_CORRUPTION; } return NT_STATUS_OK; }
bool netsamlogon_cache_store(const char *username, struct netr_SamInfo3 *info3) { uint8_t dummy = 0; TDB_DATA data = { .dptr = &dummy, .dsize = sizeof(dummy) }; char keystr[DOM_SID_STR_BUFLEN]; bool result = false; struct dom_sid user_sid; TALLOC_CTX *tmp_ctx = talloc_stackframe(); DATA_BLOB blob; enum ndr_err_code ndr_err; struct netsamlogoncache_entry r; int ret; if (!info3) { return false; } if (!netsamlogon_cache_init()) { DEBUG(0,("netsamlogon_cache_store: cannot open %s for write!\n", NETSAMLOGON_TDB)); return false; } /* * First write a record with just the domain sid for * netsamlogon_cache_domain_known. Use TDB_INSERT to avoid * overwriting potentially other data. We're just interested * in the existence of that record. */ dom_sid_string_buf(info3->base.domain_sid, keystr, sizeof(keystr)); ret = tdb_store_bystring(netsamlogon_tdb, keystr, data, TDB_INSERT); if ((ret == -1) && (tdb_error(netsamlogon_tdb) != TDB_ERR_EXISTS)) { DBG_WARNING("Could not store domain marker for %s: %s\n", keystr, tdb_errorstr(netsamlogon_tdb)); TALLOC_FREE(tmp_ctx); return false; } sid_compose(&user_sid, info3->base.domain_sid, info3->base.rid); /* Prepare key as DOMAIN-SID/USER-RID string */ dom_sid_string_buf(&user_sid, keystr, sizeof(keystr)); DEBUG(10,("netsamlogon_cache_store: SID [%s]\n", keystr)); /* Prepare data */ if (info3->base.full_name.string == NULL) { struct netr_SamInfo3 *cached_info3; const char *full_name = NULL; cached_info3 = netsamlogon_cache_get(tmp_ctx, &user_sid); if (cached_info3 != NULL) { full_name = cached_info3->base.full_name.string; } if (full_name != NULL) { info3->base.full_name.string = talloc_strdup(info3, full_name); } } /* only Samba fills in the username, not sure why NT doesn't */ /* so we fill it in since winbindd_getpwnam() makes use of it */ if (!info3->base.account_name.string) { info3->base.account_name.string = talloc_strdup(info3, username); } r.timestamp = time(NULL); r.info3 = *info3; if (DEBUGLEVEL >= 10) { NDR_PRINT_DEBUG(netsamlogoncache_entry, &r); } ndr_err = ndr_push_struct_blob(&blob, tmp_ctx, &r, (ndr_push_flags_fn_t)ndr_push_netsamlogoncache_entry); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { DEBUG(0,("netsamlogon_cache_store: failed to push entry to cache\n")); TALLOC_FREE(tmp_ctx); return false; } data.dsize = blob.length; data.dptr = blob.data; if (tdb_store_bystring(netsamlogon_tdb, keystr, data, TDB_REPLACE) == 0) { result = true; } TALLOC_FREE(tmp_ctx); return result; } /*********************************************************************** Retrieves a netr_SamInfo3 structure from a tdb. Caller must free the user_info struct (talloced memory) ***********************************************************************/ struct netr_SamInfo3 *netsamlogon_cache_get(TALLOC_CTX *mem_ctx, const struct dom_sid *user_sid) { struct netr_SamInfo3 *info3 = NULL; TDB_DATA data; char keystr[DOM_SID_STR_BUFLEN]; enum ndr_err_code ndr_err; DATA_BLOB blob; struct netsamlogoncache_entry r; if (!netsamlogon_cache_init()) { DEBUG(0,("netsamlogon_cache_get: cannot open %s for write!\n", NETSAMLOGON_TDB)); return NULL; } /* Prepare key as DOMAIN-SID/USER-RID string */ dom_sid_string_buf(user_sid, keystr, sizeof(keystr)); DEBUG(10,("netsamlogon_cache_get: SID [%s]\n", keystr)); data = tdb_fetch_bystring( netsamlogon_tdb, keystr ); if (!data.dptr) { return NULL; } info3 = talloc_zero(mem_ctx, struct netr_SamInfo3); if (!info3) { goto done; } blob = data_blob_const(data.dptr, data.dsize); ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r, (ndr_pull_flags_fn_t)ndr_pull_netsamlogoncache_entry); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { DEBUG(0,("netsamlogon_cache_get: failed to pull entry from cache\n")); tdb_delete_bystring(netsamlogon_tdb, keystr); TALLOC_FREE(info3); goto done; } if (DEBUGLEVEL >= 10) { NDR_PRINT_DEBUG(netsamlogoncache_entry, &r); } info3 = (struct netr_SamInfo3 *)talloc_memdup(mem_ctx, &r.info3, sizeof(r.info3)); done: SAFE_FREE(data.dptr); return info3; } bool netsamlogon_cache_have(const struct dom_sid *sid) { char keystr[DOM_SID_STR_BUFLEN]; bool ok; if (!netsamlogon_cache_init()) { DBG_WARNING("Cannot open %s\n", NETSAMLOGON_TDB); return false; } dom_sid_string_buf(sid, keystr, sizeof(keystr)); ok = tdb_exists(netsamlogon_tdb, string_term_tdb_data(keystr)); return ok; }
BOOL regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr ) { int num_subkeys, i; pstring path; REGSUBKEY_CTR *subkeys, *old_subkeys; char *oldkeyname; /* fetch a list of the old subkeys so we can determine if any were deleted */ if ( !(old_subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) { DEBUG(0,("regdb_store_keys: talloc() failure!\n")); return False; } regdb_fetch_keys( key, old_subkeys ); /* store the subkey list for the parent */ if ( !regdb_store_keys_internal( key, ctr ) ) { DEBUG(0,("regdb_store_keys: Failed to store new subkey list for parent [%s}\n", key )); return False; } /* now delete removed keys */ num_subkeys = regsubkey_ctr_numkeys( old_subkeys ); for ( i=0; i<num_subkeys; i++ ) { oldkeyname = regsubkey_ctr_specific_key( old_subkeys, i ); if ( !regsubkey_ctr_key_exists( ctr, oldkeyname ) ) { pstr_sprintf( path, "%s%c%s", key, '/', oldkeyname ); normalize_reg_path( path ); tdb_delete_bystring( tdb_reg, path ); } } TALLOC_FREE( old_subkeys ); /* now create records for any subkeys that don't already exist */ num_subkeys = regsubkey_ctr_numkeys( ctr ); for ( i=0; i<num_subkeys; i++ ) { pstr_sprintf( path, "%s%c%s", key, '/', regsubkey_ctr_specific_key( ctr, i ) ); if ( !(subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) { DEBUG(0,("regdb_store_keys: talloc() failure!\n")); return False; } if ( regdb_fetch_keys( path, subkeys ) == -1 ) { /* create a record with 0 subkeys */ if ( !regdb_store_keys_internal( path, subkeys ) ) { DEBUG(0,("regdb_store_keys: Failed to store new record for key [%s}\n", path )); TALLOC_FREE( subkeys ); return False; } } TALLOC_FREE( subkeys ); } return True; }