/****************************************************************************
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;
}
/*
unlock the notify db
*/
static void notify_unlock(struct notify_context *notify)
{
tdb_unlock_bystring(notify->w->tdb, NOTIFY_KEY);
}
NTSTATUS evlog_push_record_tdb(TALLOC_CTX *mem_ctx,
TDB_CONTEXT *tdb,
struct eventlog_Record_tdb *r,
uint32_t *record_number)
{
TDB_DATA kbuf, ebuf;
DATA_BLOB blob;
enum ndr_err_code ndr_err;
int ret;
if (!r) {
return NT_STATUS_INVALID_PARAMETER;
}
if (!can_write_to_eventlog(tdb, r->size)) {
return NT_STATUS_EVENTLOG_CANT_START;
}
/* need to read the record number and insert it into the entry here */
/* lock */
ret = tdb_lock_bystring_with_timeout(tdb, EVT_NEXT_RECORD, 1);
if (ret == -1) {
return NT_STATUS_LOCK_NOT_GRANTED;
}
/* read */
r->record_number = tdb_fetch_int32(tdb, EVT_NEXT_RECORD);
ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, r,
(ndr_push_flags_fn_t)ndr_push_eventlog_Record_tdb);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
tdb_unlock_bystring(tdb, EVT_NEXT_RECORD);
return ndr_map_error2ntstatus(ndr_err);
}
/* increment the record count */
kbuf.dsize = sizeof(int32_t);
kbuf.dptr = (uint8_t *)&r->record_number;
ebuf.dsize = blob.length;
ebuf.dptr = blob.data;
ret = tdb_store(tdb, kbuf, ebuf, 0);
if (ret == -1) {
tdb_unlock_bystring(tdb, EVT_NEXT_RECORD);
return NT_STATUS_EVENTLOG_FILE_CORRUPT;
}
ret = tdb_store_int32(tdb, EVT_NEXT_RECORD, r->record_number + 1);
if (ret == -1) {
tdb_unlock_bystring(tdb, EVT_NEXT_RECORD);
return NT_STATUS_EVENTLOG_FILE_CORRUPT;
}
tdb_unlock_bystring(tdb, EVT_NEXT_RECORD);
if (record_number) {
*record_number = r->record_number;
}
return NT_STATUS_OK;
}
static bool make_way_for_eventlogs( TDB_CONTEXT * the_tdb, int32_t needed,
bool whack_by_date )
{
int32_t start_record, i, new_start;
int32_t end_record;
int32_t reclen, tresv1, trecnum, timegen, timewr;
int nbytes, len, Retention, MaxSize;
TDB_DATA key, ret;
time_t current_time, exp_time;
/* discard some eventlogs */
/* read eventlogs from oldest_entry -- there can't be any discontinuity in recnos,
although records not necessarily guaranteed to have successive times */
/* */
/* lock */
tdb_lock_bystring_with_timeout( the_tdb, EVT_NEXT_RECORD, 1 );
/* read */
end_record = tdb_fetch_int32( the_tdb, EVT_NEXT_RECORD );
start_record = tdb_fetch_int32( the_tdb, EVT_OLDEST_ENTRY );
Retention = tdb_fetch_int32( the_tdb, EVT_RETENTION );
MaxSize = tdb_fetch_int32( the_tdb, EVT_MAXSIZE );
time( ¤t_time );
/* calculate ... */
exp_time = current_time - Retention; /* discard older than exp_time */
/* todo - check for sanity in next_record */
nbytes = 0;
DEBUG( 3,
( "MaxSize [%d] Retention [%d] Current Time [%u] exp_time [%u]\n",
MaxSize, Retention, (unsigned int)current_time, (unsigned int)exp_time ) );
DEBUG( 3,
( "Start Record [%u] End Record [%u]\n",
(unsigned int)start_record,
(unsigned int)end_record ));
for ( i = start_record; i < end_record; i++ ) {
/* read a record, add the amt to nbytes */
key.dsize = sizeof(int32_t);
key.dptr = (unsigned char *)&i;
ret = tdb_fetch( the_tdb, key );
if ( ret.dsize == 0 ) {
DEBUG( 8,
( "Can't find a record for the key, record [%d]\n",
i ) );
tdb_unlock_bystring( the_tdb, EVT_NEXT_RECORD );
return False;
}
nbytes += ret.dsize; /* note this includes overhead */
len = tdb_unpack( ret.dptr, ret.dsize, "ddddd", &reclen,
&tresv1, &trecnum, &timegen, &timewr );
if (len == -1) {
DEBUG( 10,("make_way_for_eventlogs: tdb_unpack failed.\n"));
tdb_unlock_bystring( the_tdb, EVT_NEXT_RECORD );
SAFE_FREE( ret.dptr );
return False;
}
DEBUG( 8,
( "read record %u, record size is [%d], total so far [%d]\n",
(unsigned int)i, reclen, nbytes ) );
SAFE_FREE( ret.dptr );
/* note that other servers may just stop writing records when the size limit
is reached, and there are no records older than 'retention'. This doesn't
like a very useful thing to do, so instead we whack (as in sleeps with the
fishes) just enough records to fit the what we need. This behavior could
be changed to 'match', if the need arises. */
if ( !whack_by_date && ( nbytes >= needed ) )
break; /* done */
if ( whack_by_date && ( timegen >= exp_time ) )
break; /* done */
}
DEBUG( 3,
( "nbytes [%d] needed [%d] start_record is [%u], should be set to [%u]\n",
nbytes, needed, (unsigned int)start_record, (unsigned int)i ) );
/* todo - remove eventlog entries here and set starting record to start_record... */
new_start = i;
if ( start_record != new_start ) {
for ( i = start_record; i < new_start; i++ ) {
key.dsize = sizeof(int32_t);
key.dptr = (unsigned char *)&i;
tdb_delete( the_tdb, key );
}
tdb_store_int32( the_tdb, EVT_OLDEST_ENTRY, new_start );
}
tdb_unlock_bystring( the_tdb, EVT_NEXT_RECORD );
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);
}
