/* 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); }