/*
lock the record for a particular privilege (write lock)
*/
static NTSTATUS privilege_lock_right(const char *right)
{
if (tdb_lock_bystring(tdb, right, LOCK_TIMEOUT) != 0) {
return NT_STATUS_INTERNAL_ERROR;
}
return NT_STATUS_OK;
}
int gencache_lock_entry( const char *key )
{
if (!gencache_init())
return -1;
return tdb_lock_bystring(cache, key, 0);
}
/*
lock the notify db
*/
static NTSTATUS notify_lock(struct notify_context *notify)
{
if (tdb_lock_bystring(notify->w->tdb, NOTIFY_KEY) != 0) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
return NT_STATUS_OK;
}
BOOL share_info_db_init(void)
{
const char *vstring = "INFO/version";
int32 vers_id;
if (share_tdb) {
return True;
}
share_tdb = tdb_open_log(lock_path("share_info.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (!share_tdb) {
DEBUG(0,("Failed to open share info database %s (%s)\n",
lock_path("share_info.tdb"), strerror(errno) ));
return False;
}
/* handle a Samba upgrade */
tdb_lock_bystring(share_tdb, vstring);
/* Cope with byte-reversed older versions of the db. */
vers_id = tdb_fetch_int32(share_tdb, vstring);
if ((vers_id == SHARE_DATABASE_VERSION_V1) || (IREV(vers_id) == SHARE_DATABASE_VERSION_V1)) {
/* Written on a bigendian machine with old fetch_int code. Save as le. */
tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
vers_id = SHARE_DATABASE_VERSION_V2;
}
if (vers_id != SHARE_DATABASE_VERSION_V2) {
tdb_traverse(share_tdb, tdb_traverse_delete_fn, NULL);
tdb_store_int32(share_tdb, vstring, SHARE_DATABASE_VERSION_V2);
}
tdb_unlock_bystring(share_tdb, vstring);
return True;
}
BOOL secrets_lock_trust_account_password(const char *domain, BOOL dolock)
{
if (!tdb)
return False;
if (dolock)
return (tdb_lock_bystring(tdb, trust_keystr(domain),0) == 0);
else
tdb_unlock_bystring(tdb, trust_keystr(domain));
return True;
}
BOOL init_account_policy(void)
{
const char *vstring = "INFO/version";
uint32 version;
int i;
if (tdb) {
return True;
}
tdb = tdb_open_log(lock_path("account_policy.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (!tdb) {
DEBUG(0,("Failed to open account policy database\n"));
return False;
}
/* handle a Samba upgrade */
tdb_lock_bystring(tdb, vstring);
if (!tdb_fetch_uint32(tdb, vstring, &version) || version != DATABASE_VERSION) {
tdb_store_uint32(tdb, vstring, DATABASE_VERSION);
for (i=0; account_policy_names[i].field; i++) {
if (!account_policy_set_default_on_empty(account_policy_names[i].field)) {
DEBUG(0,("failed to set default value in account policy tdb\n"));
return False;
}
}
}
tdb_unlock_bystring(tdb, vstring);
/* These exist by default on NT4 in [HKLM\SECURITY\Policy\Accounts] */
privilege_create_account( &global_sid_World );
privilege_create_account( &global_sid_Builtin_Account_Operators );
privilege_create_account( &global_sid_Builtin_Server_Operators );
privilege_create_account( &global_sid_Builtin_Print_Operators );
privilege_create_account( &global_sid_Builtin_Backup_Operators );
/* BUILTIN\Administrators get everything -- *always* */
if ( lp_enable_privileges() ) {
if ( !grant_all_privileges( &global_sid_Builtin_Administrators ) ) {
DEBUG(1,("init_account_policy: Failed to grant privileges "
"to BUILTIN\\Administrators!\n"));
}
}
return True;
}
/*
lock the secrets tdb based on a string - this is used as a primitive form of mutex
between smbd instances.
*/
BOOL secrets_named_mutex(const char *name, unsigned int timeout)
{
int ret;
if (!message_init())
return False;
ret = tdb_lock_bystring(tdb, name, timeout);
if (ret == 0)
DEBUG(10,("secrets_named_mutex: got mutex for %s\n", name ));
return (ret == 0);
}
PyObject *py_tdb_hnd_lock_bystring(PyObject *self, PyObject *args)
{
tdb_hnd_object *obj = (tdb_hnd_object *)self;
int result, timeout = 30;
char *s;
if (!obj->tdb) {
PyErr_SetString(py_tdb_error, "tdb object has been closed");
return NULL;
}
if (!PyArg_ParseTuple(args, "s|i", &s, &timeout))
return NULL;
result = tdb_lock_bystring(obj->tdb, s, timeout);
return PyInt_FromLong(result != -1);
}
bool tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val)
{
uint32_t val;
bool ret = false;
if (tdb_lock_bystring(tdb, keystr) == -1)
return false;
if (!tdb_fetch_uint32(tdb, keystr, &val)) {
/* It failed */
if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
/* and not because it didn't exist */
goto err_out;
}
/* Start with 'old' value */
val = *oldval;
} else {
/* it worked, set return value (oldval) to tdb data */
*oldval = val;
}
/* get a new value to store */
val += change_val;
if (!tdb_store_uint32(tdb, keystr, val))
goto err_out;
ret = true;
err_out:
tdb_unlock_bystring(tdb, keystr);
return ret;
}
int32_t tdb_change_int32_atomic(struct tdb_context *tdb, const char *keystr, int32_t *oldval, int32_t change_val)
{
int32_t val;
int32_t ret = -1;
if (tdb_lock_bystring(tdb, keystr) == -1)
return -1;
if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {
/* The lookup failed */
if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
/* but not because it didn't exist */
goto err_out;
}
/* Start with 'old' value */
val = *oldval;
} else {
/* It worked, set return value (oldval) to tdb data */
*oldval = val;
}
/* Increment value for storage and return next time */
val += change_val;
if (tdb_store_int32(tdb, keystr, val) == -1)
goto err_out;
ret = 0;
err_out:
tdb_unlock_bystring(tdb, keystr);
return ret;
}
BOOL init_account_policy(void)
{
static pid_t local_pid;
const char *vstring = "INFO/version";
uint32 version;
if (tdb && local_pid == sys_getpid())
return True;
tdb = tdb_open_log(lock_path("account_policy.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (!tdb) {
DEBUG(0,("Failed to open account policy database\n"));
return False;
}
local_pid = sys_getpid();
/* handle a Samba upgrade */
tdb_lock_bystring(tdb, vstring,0);
if (!tdb_fetch_uint32(tdb, vstring, &version) || version != DATABASE_VERSION) {
tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
tdb_store_uint32(tdb, vstring, DATABASE_VERSION);
account_policy_set(AP_MIN_PASSWORD_LEN, MINPASSWDLENGTH); /* 5 chars minimum */
account_policy_set(AP_PASSWORD_HISTORY, 0); /* don't keep any old password */
account_policy_set(AP_USER_MUST_LOGON_TO_CHG_PASS, 0); /* don't force user to logon */
account_policy_set(AP_MAX_PASSWORD_AGE, (uint32)-1); /* don't expire */
account_policy_set(AP_MIN_PASSWORD_AGE, 0); /* 0 days */
account_policy_set(AP_LOCK_ACCOUNT_DURATION, 30); /* lockout for 30 minutes */
account_policy_set(AP_RESET_COUNT_TIME, 30); /* reset after 30 minutes */
account_policy_set(AP_BAD_ATTEMPT_LOCKOUT, 0); /* don't lockout */
account_policy_set(AP_TIME_TO_LOGOUT, -1); /* don't force logout */
}
tdb_unlock_bystring(tdb, vstring);
return True;
}
static int next_jobnum(char *printer)
{
fstring keystr;
int jobnum;
slprintf(keystr, sizeof(keystr) - 1, "JOBNUM/%s", printer);
tdb_lock_bystring(tdb, keystr);
jobnum = tdb_fetch_int32(tdb, keystr);
/* Create next job index if none exists */
if (jobnum == -1) {
jobnum = atoi(PRINT_FIRSTJOB);
}
jobnum++;
tdb_store_int32(tdb, keystr, jobnum);
tdb_unlock_bystring(tdb, keystr);
return jobnum;
}
/****************************************************************************
Open the group mapping tdb.
****************************************************************************/
static bool init_group_mapping(void)
{
const char *ldb_path;
if (db != NULL) {
return true;
}
db = db_open(NULL, state_path("group_mapping.tdb"), 0,
TDB_DEFAULT, O_RDWR|O_CREAT, 0600,
DBWRAP_LOCK_ORDER_1);
if (db == NULL) {
DEBUG(0, ("Failed to open group mapping database: %s\n",
strerror(errno)));
return false;
}
ldb_path = state_path("group_mapping.ldb");
if (file_exist(ldb_path) && !mapping_switch(ldb_path)) {
unlink(state_path("group_mapping.tdb"));
return false;
} else {
/* handle upgrade from old versions of the database */
#if 0 /* -- Needs conversion to dbwrap -- */
const char *vstring = "INFO/version";
int32 vers_id;
GROUP_MAP *map_table = NULL;
size_t num_entries = 0;
/* handle a Samba upgrade */
tdb_lock_bystring(tdb, vstring);
/* Cope with byte-reversed older versions of the db. */
vers_id = tdb_fetch_int32(tdb, vstring);
if ((vers_id == DATABASE_VERSION_V1)
|| (IREV(vers_id) == DATABASE_VERSION_V1)) {
/*
* Written on a bigendian machine with old fetch_int
* code. Save as le.
*/
tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
vers_id = DATABASE_VERSION_V2;
}
/* if its an unknown version we remove everthing in the db */
if (vers_id != DATABASE_VERSION_V2) {
tdb_wipe_all(tdb);
tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
}
tdb_unlock_bystring(tdb, vstring);
/* cleanup any map entries with a gid == -1 */
if ( enum_group_mapping( NULL, SID_NAME_UNKNOWN, &map_table,
&num_entries, False ) ) {
int i;
for ( i=0; i<num_entries; i++ ) {
if ( map_table[i].gid == -1 ) {
group_map_remove( &map_table[i].sid );
}
}
SAFE_FREE( map_table );
}
#endif
}
return true;
}
/****************************************************************************
Open the group mapping tdb.
****************************************************************************/
static bool init_group_mapping(void)
{
if (db != NULL) {
return true;
}
db = db_open_trans(NULL, state_path("group_mapping.tdb"), 0,
TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
if (db == NULL) {
DEBUG(0, ("Failed to open group mapping database: %s\n",
strerror(errno)));
return false;
}
#if 0
/*
* This code was designed to handle a group mapping version
* upgrade. mapping_tdb is not active by default anymore, so ignore
* this here.
*/
{
const char *vstring = "INFO/version";
int32 vers_id;
GROUP_MAP *map_table = NULL;
size_t num_entries = 0;
/* handle a Samba upgrade */
tdb_lock_bystring(tdb, vstring);
/* Cope with byte-reversed older versions of the db. */
vers_id = tdb_fetch_int32(tdb, vstring);
if ((vers_id == DATABASE_VERSION_V1)
|| (IREV(vers_id) == DATABASE_VERSION_V1)) {
/*
* Written on a bigendian machine with old fetch_int
* code. Save as le.
*/
tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
vers_id = DATABASE_VERSION_V2;
}
/* if its an unknown version we remove everthing in the db */
if (vers_id != DATABASE_VERSION_V2) {
tdb_wipe_all(tdb);
tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
}
tdb_unlock_bystring(tdb, vstring);
/* cleanup any map entries with a gid == -1 */
if ( enum_group_mapping( NULL, SID_NAME_UNKNOWN, &map_table,
&num_entries, False ) ) {
int i;
for ( i=0; i<num_entries; i++ ) {
if ( map_table[i].gid == -1 ) {
group_map_remove( &map_table[i].sid );
}
}
SAFE_FREE( map_table );
}
}
#endif
return true;
}
static BOOL tdbsam_convert(TDB_CONTEXT *pdb_tdb, tdbsamver_t from)
{
const char * vstring = TDBSAM_VERSION_STRING;
SAM_ACCOUNT *user = NULL;
const char *prefix = USERPREFIX;
TDB_DATA data, key, old_key;
uint8 *buf = NULL;
BOOL ret;
if (pdb_tdb == NULL) {
DEBUG(0,("tdbsam_convert: Bad TDB Context pointer.\n"));
return False;
}
/* handle a Samba upgrade */
tdb_lock_bystring(pdb_tdb, vstring, 0);
if (!NT_STATUS_IS_OK(pdb_init_sam(&user))) {
DEBUG(0,("tdbsam_convert: cannot initialized a SAM_ACCOUNT.\n"));
return False;
}
/* Enumerate all records and convert them */
key = tdb_firstkey(pdb_tdb);
while (key.dptr) {
/* skip all non-USER entries (eg. RIDs) */
while ((key.dsize != 0) && (strncmp(key.dptr, prefix, strlen (prefix)))) {
old_key = key;
/* increment to next in line */
key = tdb_nextkey(pdb_tdb, key);
SAFE_FREE(old_key.dptr);
}
if (key.dptr) {
/* read from tdbsam */
data = tdb_fetch(pdb_tdb, key);
if (!data.dptr) {
DEBUG(0,("tdbsam_convert: database entry not found: %s.\n",key.dptr));
return False;
}
if (!NT_STATUS_IS_OK(pdb_reset_sam(user))) {
DEBUG(0,("tdbsam_convert: cannot reset SAM_ACCOUNT.\n"));
SAFE_FREE(data.dptr);
return False;
}
/* unpack the buffer from the former format */
DEBUG(10,("tdbsam_convert: Try unpacking a record with (key:%s) (version:%d)\n", key.dptr, from));
switch (from) {
case 0:
ret = init_sam_from_buffer_v0(user, (uint8 *)data.dptr, data.dsize);
break;
case 1:
ret = init_sam_from_buffer_v1(user, (uint8 *)data.dptr, data.dsize);
break;
default:
/* unknown tdbsam version */
ret = False;
}
if (!ret) {
DEBUG(0,("tdbsam_convert: Bad SAM_ACCOUNT entry returned from TDB (key:%s) (version:%d)\n", key.dptr, from));
SAFE_FREE(data.dptr);
return False;
}
/* pack from the buffer into the new format */
DEBUG(10,("tdbsam_convert: Try packing a record (key:%s) (version:%d)\n", key.dptr, from));
if ((data.dsize=init_buffer_from_sam (&buf, user, False)) == -1) {
DEBUG(0,("tdbsam_convert: cannot pack the SAM_ACCOUNT into the new format\n"));
SAFE_FREE(data.dptr);
return False;
}
data.dptr = (char *)buf;
/* Store the buffer inside the TDBSAM */
if (tdb_store(pdb_tdb, key, data, TDB_MODIFY) != TDB_SUCCESS) {
DEBUG(0,("tdbsam_convert: cannot store the SAM_ACCOUNT (key:%s) in new format\n",key.dptr));
SAFE_FREE(data.dptr);
return False;
}
SAFE_FREE(data.dptr);
/* increment to next in line */
old_key = key;
key = tdb_nextkey(pdb_tdb, key);
SAFE_FREE(old_key.dptr);
}
}
pdb_free_sam(&user);
/* upgrade finished */
tdb_store_int32(pdb_tdb, vstring, TDBSAM_VERSION);
tdb_unlock_bystring(pdb_tdb, vstring);
return(True);
}
