static int check_filesystem(TDB_CONTEXT *tdb, io_channel channel)
{
__u32 s_mtime;
__u8 s_uuid[16];
errcode_t retval;
TDB_DATA tdb_key, tdb_data;
struct ext2_super_block super;
io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);
retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);
if (retval) {
com_err(prg_name,
retval, _("Failed to read the file system data \n"));
return retval;
}
tdb_key.dptr = mtime_key;
tdb_key.dsize = sizeof(mtime_key);
tdb_data = tdb_fetch(tdb, tdb_key);
if (!tdb_data.dptr) {
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
com_err(prg_name, retval,
_("Failed tdb_fetch %s\n"), tdb_errorstr(tdb));
return retval;
}
s_mtime = *(__u32 *)tdb_data.dptr;
if (super.s_mtime != s_mtime) {
com_err(prg_name, 0,
_("The file system Mount time didn't match %u\n"),
s_mtime);
return -1;
}
tdb_key.dptr = uuid_key;
tdb_key.dsize = sizeof(uuid_key);
tdb_data = tdb_fetch(tdb, tdb_key);
if (!tdb_data.dptr) {
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
com_err(prg_name, retval,
_("Failed tdb_fetch %s\n"), tdb_errorstr(tdb));
return retval;
}
memcpy(s_uuid, tdb_data.dptr, sizeof(s_uuid));
if (memcmp(s_uuid, super.s_uuid, sizeof(s_uuid))) {
com_err(prg_name, 0,
_("The file system UUID didn't match \n"));
return -1;
}
return 0;
}
static NTSTATUS tdbsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sam_pass)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
TDB_CONTEXT *pwd_tdb;
TDB_DATA key;
fstring keystr;
uint32 rid;
fstring name;
fstrcpy(name, pdb_get_username(sam_pass));
strlower_m(name);
/* open the TDB */
if (!(pwd_tdb = tdb_open_log(tdb_state->tdbsam_location, 0, TDB_DEFAULT, O_RDWR, 0600))) {
DEBUG(0, ("Unable to open TDB passwd!"));
return nt_status;
}
/* set the search key */
slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
key.dptr = keystr;
key.dsize = strlen (keystr) + 1;
rid = pdb_get_user_rid(sam_pass);
/* it's outaa here! 8^) */
if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
tdb_close(pwd_tdb);
return nt_status;
}
/* delete also the RID key */
/* set the search key */
slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
key.dptr = keystr;
key.dsize = strlen (keystr) + 1;
/* it's outaa here! 8^) */
if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
DEBUG(5, ("Error deleting entry from tdb rid database!\n"));
DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
tdb_close(pwd_tdb);
return nt_status;
}
tdb_close(pwd_tdb);
return NT_STATUS_OK;
}
static void terror(enum TDB_ERROR err, const char *why)
{
if (err != TDB_SUCCESS)
printf("%s:%s\n", tdb_errorstr(err), why);
else
printf("%s\n", why);
}
static void e2fsck_put_dir_info(e2fsck_t ctx, struct dir_info *dir)
{
struct dir_info_db *db = ctx->dir_info;
struct dir_info_ent buf;
TDB_DATA key, data;
#ifdef DIRINFO_DEBUG
printf("e2fsck_put_dir_info (%d, %d, %d)...", dir->ino, dir->dotdot,
dir->parent);
#endif
if (!db->tdb)
return;
buf.parent = dir->parent;
buf.dotdot = dir->dotdot;
key.dptr = (unsigned char *) &dir->ino;
key.dsize = sizeof(ext2_ino_t);
data.dptr = (unsigned char *) &buf;
data.dsize = sizeof(buf);
if (tdb_store(db->tdb, key, data, TDB_REPLACE) == -1) {
printf("store failed: %s\n", tdb_errorstr(db->tdb));
}
return;
}
static BOOL allowable_number_of_smbd_processes(void)
{
int max_processes = lp_max_smbd_processes();
if (!max_processes)
return True;
{
TDB_CONTEXT *tdb = conn_tdb_ctx();
int32 val;
if (!tdb) {
DEBUG(0,("allowable_number_of_smbd_processes: can't open connection tdb.\n" ));
return False;
}
val = tdb_fetch_int32(tdb, "INFO/total_smbds");
if (val == -1 && (tdb_error(tdb) != TDB_ERR_NOEXIST)) {
DEBUG(0,("allowable_number_of_smbd_processes: can't fetch INFO/total_smbds. Error %s\n",
tdb_errorstr(tdb) ));
return False;
}
if (val > max_processes) {
DEBUG(0,("allowable_number_of_smbd_processes: number of processes (%d) is over allowed limit (%d)\n",
val, max_processes ));
return False;
}
}
return True;
}
static int lock_record(const char *dbpath, const char *dbflags, const char *dbkey)
{
TDB_DATA key;
struct tdb_context *tdb;
int tdb_flags;
/* No error checking since CTDB always passes sane values */
tdb_flags = strtol(dbflags, NULL, 0);
/* Convert hex key to key */
if (strcmp(dbkey, "NULL") == 0) {
key.dptr = NULL;
key.dsize = 0;
} else {
key.dptr = hex_decode_talloc(NULL, dbkey, &key.dsize);
}
tdb = tdb_open(dbpath, 0, tdb_flags, O_RDWR, 0600);
if (tdb == NULL) {
fprintf(stderr, "%s: Error opening database %s\n", progname, dbpath);
return 1;
}
if (tdb_chainlock(tdb, key) < 0) {
fprintf(stderr, "%s: Error getting record lock (%s)\n",
progname, tdb_errorstr(tdb));
return 1;
}
return 0;
}
/*
* Transaction end
*/
int partition_metadata_end_trans(struct ldb_module *module)
{
struct partition_private_data *data;
struct tdb_context *tdb;
data = talloc_get_type_abort(ldb_module_get_private(module),
struct partition_private_data);
if (!data || !data->metadata || !data->metadata->db) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
"partition_metadata: metadata not initialized");
}
tdb = data->metadata->db->tdb;
if (data->metadata->in_transaction == 0) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
"partition_metadata: not in transaction");
}
data->metadata->in_transaction--;
if (tdb_transaction_commit(tdb) != 0) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
tdb_errorstr(tdb));
}
return LDB_SUCCESS;
}
static int lock_db(const char *dbpath, const char *dbflags)
{
struct tdb_context *tdb;
int tdb_flags;
/* No error checking since CTDB always passes sane values */
tdb_flags = strtol(dbflags, NULL, 0);
tdb = tdb_open(dbpath, 0, tdb_flags, O_RDWR, 0600);
if (tdb == NULL) {
fprintf(stderr, "%s: Error opening database %s\n", progname, dbpath);
return 1;
}
set_priority();
if (tdb_lockall(tdb) < 0) {
fprintf(stderr, "%s: Error getting db lock (%s)\n",
progname, tdb_errorstr(tdb));
return 1;
}
reset_priority();
return 0;
}
static int count_fn( TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *udp)
{
struct connections_data crec;
struct count_stat *cs = (struct count_stat *)udp;
if (dbuf.dsize != sizeof(crec))
return 0;
memcpy(&crec, dbuf.dptr, sizeof(crec));
if (crec.cnum == -1)
return 0;
/* If the pid was not found delete the entry from connections.tdb */
if (cs->Clear && !process_exists(crec.pid) && (errno == ESRCH)) {
DEBUG(2,("pid %u doesn't exist - deleting connections %d [%s]\n",
(unsigned int)crec.pid, crec.cnum, crec.name));
if (tdb_delete(the_tdb, kbuf) != 0)
DEBUG(0,("count_fn: tdb_delete failed with error %s\n", tdb_errorstr(tdb) ));
return 0;
}
if (strequal(crec.name, cs->name))
cs->curr_connections++;
return 0;
}
/*
unlock a record in the ltdb, given a key
*/
int ctdb_ltdb_unlock(struct ctdb_db_context *ctdb_db, TDB_DATA key)
{
int ret = tdb_chainunlock(ctdb_db->ltdb->tdb, key);
if (ret != 0) {
DEBUG(DEBUG_ERR,("tdb_chainunlock failed on db %s [%s]\n", ctdb_db->db_name, tdb_errorstr(ctdb_db->ltdb->tdb)));
}
return ret;
}
/*
* Write a key with uin64 value
*/
static int partition_metadata_set_uint64(struct ldb_module *module,
const char *key, uint64_t value,
bool insert)
{
struct partition_private_data *data;
struct tdb_context *tdb;
TDB_DATA tdb_key, tdb_data;
int tdb_flag;
char *value_str;
TALLOC_CTX *tmp_ctx;
data = talloc_get_type_abort(ldb_module_get_private(module),
struct partition_private_data);
if (!data || !data->metadata || !data->metadata->db) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
"partition_metadata: metadata tdb not initialized");
}
tmp_ctx = talloc_new(NULL);
if (tmp_ctx == NULL) {
return ldb_module_oom(module);
}
tdb = data->metadata->db->tdb;
value_str = talloc_asprintf(tmp_ctx, "%llu", (unsigned long long)value);
if (value_str == NULL) {
talloc_free(tmp_ctx);
return ldb_module_oom(module);
}
tdb_key.dptr = (uint8_t *)discard_const_p(char, key);
tdb_key.dsize = strlen(key);
tdb_data.dptr = (uint8_t *)value_str;
tdb_data.dsize = strlen(value_str);
if (insert) {
tdb_flag = TDB_INSERT;
} else {
tdb_flag = TDB_MODIFY;
}
if (tdb_store(tdb, tdb_key, tdb_data, tdb_flag) != 0) {
int ret;
char *error_string = talloc_asprintf(tmp_ctx, "%s: tdb_store of key %s failed: %s",
tdb_name(tdb), key, tdb_errorstr(tdb));
ret = ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
error_string);
talloc_free(tmp_ctx);
return ret;
}
talloc_free(tmp_ctx);
return LDB_SUCCESS;
}
static void info_tdb(void)
{
int count;
total_bytes = 0;
if ((count = tdb_traverse(tdb, traverse_fn, NULL) == -1))
printf("Error = %s\n", tdb_errorstr(tdb));
else
printf("%d records totalling %d bytes\n", count, total_bytes);
}
static void tdb_log(struct tdb_context *tdb,
enum tdb_log_level level,
enum TDB_ERROR ecode,
const char *message,
void *data)
{
fprintf(stderr, "tdb:%s:%s:%s\n",
tdb_name(tdb), tdb_errorstr(ecode), message);
}
static void info_tdb(void)
{
char *summary = tdb_summary(tdb);
if (!summary) {
printf("Error = %s\n", tdb_errorstr(tdb));
} else {
printf("%s", summary);
free(summary);
}
}
BOOL register_message_flags(BOOL doreg, uint32 msg_flags)
{
struct connections_key key;
struct connections_data *pcrec;
TDB_DATA kbuf, dbuf;
if (!tdb)
return False;
DEBUG(10,("register_message_flags: %s flags 0x%x\n",
doreg ? "adding" : "removing",
(unsigned int)msg_flags ));
make_conn_key(NULL, "", &kbuf, &key);
dbuf = tdb_fetch(tdb, kbuf);
if (!dbuf.dptr) {
DEBUG(0,("register_message_flags: tdb_fetch failed: %s\n",
tdb_errorstr(tdb)));
return False;
}
pcrec = (struct connections_data *)dbuf.dptr;
if (doreg)
pcrec->bcast_msg_flags |= msg_flags;
else
pcrec->bcast_msg_flags &= ~msg_flags;
if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
DEBUG(0,("register_message_flags: tdb_store failed: %s.\n",
tdb_errorstr(tdb) ));
SAFE_FREE(dbuf.dptr);
return False;
}
DEBUG(10,("register_message_flags: new flags 0x%x\n",
(unsigned int)pcrec->bcast_msg_flags ));
SAFE_FREE(dbuf.dptr);
return True;
}
/*
* Read a key with uint64 value
*/
static int partition_metadata_get_uint64(struct ldb_module *module,
const char *key, uint64_t *value,
uint64_t default_value)
{
struct partition_private_data *data;
struct tdb_context *tdb;
TDB_DATA tdb_key, tdb_data;
char *value_str;
TALLOC_CTX *tmp_ctx;
data = talloc_get_type_abort(ldb_module_get_private(module),
struct partition_private_data);
if (!data || !data->metadata || !data->metadata->db) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
"partition_metadata: metadata tdb not initialized");
}
tmp_ctx = talloc_new(NULL);
if (tmp_ctx == NULL) {
return ldb_module_oom(module);
}
tdb = data->metadata->db->tdb;
tdb_key.dptr = (uint8_t *)discard_const_p(char, key);
tdb_key.dsize = strlen(key);
tdb_data = tdb_fetch(tdb, tdb_key);
if (!tdb_data.dptr) {
if (tdb_error(tdb) == TDB_ERR_NOEXIST) {
*value = default_value;
return LDB_SUCCESS;
} else {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
tdb_errorstr(tdb));
}
}
value_str = talloc_strndup(tmp_ctx, (char *)tdb_data.dptr, tdb_data.dsize);
if (value_str == NULL) {
SAFE_FREE(tdb_data.dptr);
talloc_free(tmp_ctx);
return ldb_module_oom(module);
}
*value = strtoull(value_str, NULL, 10);
SAFE_FREE(tdb_data.dptr);
talloc_free(tmp_ctx);
return LDB_SUCCESS;
}
static
NTSTATUS schannel_store_session_key_tdb(struct tdb_wrap *tdb_sc,
TALLOC_CTX *mem_ctx,
struct netlogon_creds_CredentialState *creds)
{
enum ndr_err_code ndr_err;
DATA_BLOB blob;
TDB_DATA value;
int ret;
char *keystr;
char *name_upper;
name_upper = strupper_talloc(mem_ctx, creds->computer_name);
if (!name_upper) {
return NT_STATUS_NO_MEMORY;
}
keystr = talloc_asprintf(mem_ctx, "%s/%s",
SECRETS_SCHANNEL_STATE, name_upper);
TALLOC_FREE(name_upper);
if (!keystr) {
return NT_STATUS_NO_MEMORY;
}
ndr_err = ndr_push_struct_blob(&blob, mem_ctx, creds,
(ndr_push_flags_fn_t)ndr_push_netlogon_creds_CredentialState);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(keystr);
return ndr_map_error2ntstatus(ndr_err);
}
value.dptr = blob.data;
value.dsize = blob.length;
ret = tdb_store_bystring(tdb_sc->tdb, keystr, value, TDB_REPLACE);
if (ret != TDB_SUCCESS) {
DEBUG(0,("Unable to add %s to session key db - %s\n",
keystr, tdb_errorstr(tdb_sc->tdb)));
talloc_free(keystr);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
DEBUG(3,("schannel_store_session_key_tdb: stored schannel info with key %s\n",
keystr));
if (DEBUGLEVEL >= 10) {
NDR_PRINT_DEBUG(netlogon_creds_CredentialState, creds);
}
talloc_free(keystr);
return NT_STATUS_OK;
}
static int tdb_ass_subscript(tdb_hnd_object *obj, PyObject *key, PyObject *value)
{
TDB_DATA krec, drec;
if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize)) {
PyErr_SetString(PyExc_TypeError,
"tdb mappings have string indices only");
return -1;
}
if (!obj->tdb) {
PyErr_SetString(
py_tdb_error, "tdb object has been closed");
return -1;
}
if (!value) {
/* Delete value */
if (tdb_delete(obj->tdb, krec) == -1) {
PyErr_SetString(PyExc_KeyError,
PyString_AsString(value));
return -1;
}
} else {
/* Set value */
if (!PyArg_Parse(value, "s#", &drec.dptr, &drec.dsize)) {
PyErr_SetString(PyExc_TypeError,
"tdb mappings have string elements only");
return -1;
}
errno = 0;
if (tdb_store(obj->tdb, krec, drec, 0) < 0 ) {
if (errno != 0)
PyErr_SetFromErrno(py_tdb_error);
else
PyErr_SetString(
py_tdb_error,
(char *)tdb_errorstr(obj->tdb));
return -1;
}
}
return 0;
}
void tap_log_fn(struct tdb_context *tdb,
enum tdb_log_level level,
enum TDB_ERROR ecode,
const char *message, void *priv)
{
if (suppress_logging)
return;
diag("tdb log level %u: %s: %s%s",
level, tdb_errorstr(ecode), log_prefix, message);
if (log_last)
free(log_last);
log_last = strdup(message);
tap_log_messages++;
}
static void tdb_log(struct tdb_context *tdb,
enum tdb_log_level level,
enum TDB_ERROR ecode,
const char *message,
void *data)
{
printf("tdb:%s:%s:%s\n",
tdb_name(tdb), tdb_errorstr(ecode), message);
fflush(stdout);
#if 0
{
char str[200];
signal(SIGUSR1, SIG_IGN);
sprintf(str,"xterm -e gdb /proc/%d/exe %d", getpid(), getpid());
system(str);
}
#endif
}
static int read_rec(FILE *f, TDB_CONTEXT *tdb, int *eof)
{
int length;
TDB_DATA key, data;
int ret = -1;
key.dptr = NULL;
data.dptr = NULL;
if (swallow(f, "{\n", eof) == -1) {
goto fail;
}
length = read_linehead(f);
if (length == -1) {
goto fail;
}
if (read_data(f, &key, length) == -1) {
goto fail;
}
if (swallow(f, "\"\n", NULL) == -1) {
goto fail;
}
length = read_linehead(f);
if (length == -1) {
goto fail;
}
if (read_data(f, &data, length) == -1) {
goto fail;
}
if ((swallow(f, "\"\n", NULL) == -1)
|| (swallow(f, "}\n", NULL) == -1)) {
goto fail;
}
if (tdb_store(tdb, key, data, TDB_INSERT) != 0) {
fprintf(stderr, "TDB error: %s\n", tdb_errorstr(tdb));
goto fail;
}
ret = 0;
fail:
free(key.dptr);
free(data.dptr);
return ret;
}
static NTSTATUS tdbsam_getsampwrid (struct pdb_methods *my_methods, SAM_ACCOUNT *user, uint32 rid)
{
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
TDB_CONTEXT *pwd_tdb;
TDB_DATA data, key;
fstring keystr;
fstring name;
if (user==NULL) {
DEBUG(0,("pdb_getsampwrid: SAM_ACCOUNT is NULL.\n"));
return nt_status;
}
/* set search key */
slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
key.dptr = keystr;
key.dsize = strlen (keystr) + 1;
/* open the accounts TDB */
if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY))) {
DEBUG(0, ("pdb_getsampwrid: Unable to open TDB rid database!\n"));
return nt_status;
}
/* get the record */
data = tdb_fetch (pwd_tdb, key);
if (!data.dptr) {
DEBUG(5,("pdb_getsampwrid (TDB): error looking up RID %d by key %s.\n", rid, keystr));
DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
tdb_close (pwd_tdb);
return nt_status;
}
fstrcpy(name, data.dptr);
SAFE_FREE(data.dptr);
tdb_close (pwd_tdb);
return tdbsam_getsampwnam (my_methods, user, name);
}
/*
* A simple interator function
*/
struct dir_info *e2fsck_dir_info_iter(e2fsck_t ctx, struct dir_info_iter *iter)
{
TDB_DATA data, key;
struct dir_info_db *db = ctx->dir_info;
struct dir_info_ent *buf;
static struct dir_info ret_dir_info;
if (!ctx->dir_info || !iter)
return 0;
if (db->tdb) {
if (iter->tdb_iter.dptr == 0)
return 0;
key = iter->tdb_iter;
data = tdb_fetch(db->tdb, key);
if (!data.dptr) {
printf("iter fetch failed: %s\n",
tdb_errorstr(db->tdb));
return 0;
}
buf = (struct dir_info_ent *) data.dptr;
ret_dir_info.ino = *((ext2_ino_t *) iter->tdb_iter.dptr);
ret_dir_info.dotdot = buf->dotdot;
ret_dir_info.parent = buf->parent;
iter->tdb_iter = tdb_nextkey(db->tdb, key);
free(key.dptr);
free(data.dptr);
return &ret_dir_info;
}
if (iter->i >= ctx->dir_info->count)
return 0;
#ifdef DIRINFO_DEBUG
printf("iter(%d, %d, %d)...", ctx->dir_info->array[iter->i].ino,
ctx->dir_info->array[iter->i].dotdot,
ctx->dir_info->array[iter->i].parent);
#endif
ctx->dir_info->last_lookup = ctx->dir_info->array + iter->i++;
return(ctx->dir_info->last_lookup);
}
BOOL yield_connection(connection_struct *conn, const char *name)
{
struct connections_key key;
TDB_DATA kbuf;
if (!tdb)
return False;
DEBUG(3,("Yielding connection to %s\n",name));
make_conn_key(conn, name, &kbuf, &key);
if (tdb_delete(tdb, kbuf) != 0) {
int dbg_lvl = (!conn && (tdb_error(tdb) == TDB_ERR_NOEXIST)) ? 3 : 0;
DEBUG(dbg_lvl,("yield_connection: tdb_delete for name %s failed with error %s.\n",
name, tdb_errorstr(tdb) ));
return (False);
}
return(True);
}
/**
\details Update a TDB record
*/
static enum MAPISTATUS mapi_handles_tdb_update(struct mapi_handles_context *handles_ctx,
uint32_t handle, uint32_t container_handle)
{
TALLOC_CTX *mem_ctx;
TDB_DATA key;
TDB_DATA dbuf;
int ret;
/* Sanity checks */
OPENCHANGE_RETVAL_IF(!handles_ctx, MAPI_E_NOT_INITIALIZED, NULL);
OPENCHANGE_RETVAL_IF(!handles_ctx->tdb_ctx, MAPI_E_NOT_INITIALIZED, NULL);
OPENCHANGE_RETVAL_IF(!handle, MAPI_E_INVALID_PARAMETER, NULL);
mem_ctx = talloc_named(NULL, 0, "mapi_handles_tdb_update");
key.dptr = (unsigned char *) talloc_asprintf(mem_ctx, "0x%x", handle);
key.dsize = strlen((const char *)key.dptr);
/* Step 1. Makes sure the record exists */
ret = tdb_exists(handles_ctx->tdb_ctx, key);
OPENCHANGE_RETVAL_IF(!ret, MAPI_E_NOT_FOUND, mem_ctx);
/* Step 2. Update record */
dbuf.dptr = (unsigned char *) talloc_asprintf(mem_ctx, "0x%x", container_handle);
dbuf.dsize = strlen((const char *)dbuf.dptr);
ret = tdb_store(handles_ctx->tdb_ctx, key, dbuf, TDB_MODIFY);
talloc_free(mem_ctx);
if (ret == -1) {
OC_DEBUG(3, "Unable to update 0x%x record: %s\n",
handle, tdb_errorstr(handles_ctx->tdb_ctx));
return MAPI_E_CORRUPT_STORE;
}
return MAPI_E_SUCCESS;
}
static int set_blk_size(TDB_CONTEXT *tdb, io_channel channel)
{
int block_size;
errcode_t retval;
TDB_DATA tdb_key, tdb_data;
tdb_key.dptr = blksize_key;
tdb_key.dsize = sizeof(blksize_key);
tdb_data = tdb_fetch(tdb, tdb_key);
if (!tdb_data.dptr) {
retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);
com_err(prg_name, retval,
_("Failed tdb_fetch %s\n"), tdb_errorstr(tdb));
return retval;
}
block_size = *(int *)tdb_data.dptr;
#ifdef DEBUG
printf("Block size %d\n", block_size);
#endif
io_channel_set_blksize(channel, block_size);
return 0;
}
static int sss_ncache_set_str(struct sss_nc_ctx *ctx,
char *str, bool permanent)
{
TDB_DATA key;
TDB_DATA data;
char *timest;
int ret;
ret = string_to_tdb_data(str, &key);
if (ret != EOK) return ret;
if (permanent) {
timest = talloc_strdup(ctx, "0");
} else {
timest = talloc_asprintf(ctx, "%llu",
(unsigned long long int)time(NULL));
}
if (!timest) return ENOMEM;
ret = string_to_tdb_data(timest, &data);
if (ret != EOK) goto done;
DEBUG(6, ("Adding [%s] to negative cache%s\n",
str, permanent?" permanently":""));
ret = tdb_store(ctx->tdb, key, data, TDB_REPLACE);
if (ret != 0) {
DEBUG(1, ("Negative cache failed to set entry: [%s]\n",
tdb_errorstr(ctx->tdb)));
ret = EFAULT;
}
done:
talloc_free(timest);
return ret;
}
static void tdb_wrap_log(struct tdb_context *tdb,
enum tdb_log_level level,
enum TDB_ERROR ecode,
const char *message,
void *unused)
{
int dl;
const char *name = tdb_name(tdb);
switch (level) {
case TDB_LOG_USE_ERROR:
case TDB_LOG_ERROR:
dl = 0;
break;
case TDB_LOG_WARNING:
dl = 2;
break;
default:
dl = 0;
}
DEBUG(dl, ("tdb(%s):%s: %s", name ? name : "unnamed",
tdb_errorstr(ecode), message));
}
int main(int argc, char *argv[])
{
int c,force = 0;
TDB_CONTEXT *tdb;
TDB_DATA key, data;
io_channel channel;
errcode_t retval;
int mount_flags;
blk64_t blk_num;
char *device_name, *tdb_file;
io_manager manager = unix_io_manager;
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, "");
setlocale(LC_CTYPE, "");
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
textdomain(NLS_CAT_NAME);
#endif
add_error_table(&et_ext2_error_table);
prg_name = argv[0];
while((c = getopt(argc, argv, "f")) != EOF) {
switch (c) {
case 'f':
force = 1;
break;
default:
usage(prg_name);
}
}
if (argc != optind+2)
usage(prg_name);
tdb_file = argv[optind];
device_name = argv[optind+1];
tdb = tdb_open(tdb_file, 0, 0, O_RDONLY, 0600);
if (!tdb) {
com_err(prg_name, errno,
_("Failed tdb_open %s\n"), tdb_file);
exit(1);
}
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
if (retval) {
com_err(prg_name, retval, _("Error while determining whether "
"%s is mounted.\n"), device_name);
exit(1);
}
if (mount_flags & EXT2_MF_MOUNTED) {
com_err(prg_name, retval, _("e2undo should only be run on "
"unmounted file system\n"));
exit(1);
}
retval = manager->open(device_name,
IO_FLAG_EXCLUSIVE | IO_FLAG_RW, &channel);
if (retval) {
com_err(prg_name, retval,
_("Failed to open %s\n"), device_name);
exit(1);
}
if (!force && check_filesystem(tdb, channel)) {
exit(1);
}
if (set_blk_size(tdb, channel)) {
exit(1);
}
for (key = tdb_firstkey(tdb); key.dptr; key = tdb_nextkey(tdb, key)) {
if (!strcmp((char *) key.dptr, (char *) mtime_key) ||
!strcmp((char *) key.dptr, (char *) uuid_key) ||
!strcmp((char *) key.dptr, (char *) blksize_key)) {
continue;
}
data = tdb_fetch(tdb, key);
if (!data.dptr) {
com_err(prg_name, 0,
_("Failed tdb_fetch %s\n"), tdb_errorstr(tdb));
exit(1);
}
blk_num = *(unsigned long *)key.dptr;
printf(_("Replayed transaction of size %zd at location %llu\n"),
data.dsize, blk_num);
retval = io_channel_write_blk64(channel, blk_num,
-data.dsize, data.dptr);
if (retval == -1) {
com_err(prg_name, retval,
_("Failed write %s\n"),
strerror(errno));
exit(1);
}
}
io_channel_close(channel);
tdb_close(tdb);
return 0;
}
/*
* get_dir_info() --- given an inode number, try to find the directory
* information entry for it.
*/
static struct dir_info *e2fsck_get_dir_info(e2fsck_t ctx, ext2_ino_t ino)
{
struct dir_info_db *db = ctx->dir_info;
int low, high, mid;
struct dir_info_ent *buf;
static struct dir_info ret_dir_info;
if (!db)
return 0;
#ifdef DIRINFO_DEBUG
printf("e2fsck_get_dir_info %d...", ino);
#endif
if (db->tdb) {
TDB_DATA key, data;
key.dptr = (unsigned char *) &ino;
key.dsize = sizeof(ext2_ino_t);
data = tdb_fetch(db->tdb, key);
if (!data.dptr) {
if (tdb_error(db->tdb) != TDB_ERR_NOEXIST)
printf("fetch failed: %s\n",
tdb_errorstr(db->tdb));
return 0;
}
buf = (struct dir_info_ent *) data.dptr;
ret_dir_info.ino = ino;
ret_dir_info.dotdot = buf->dotdot;
ret_dir_info.parent = buf->parent;
#ifdef DIRINFO_DEBUG
printf("(%d,%d,%d)\n", ino, buf->dotdot, buf->parent);
#endif
free(data.dptr);
return &ret_dir_info;
}
if (db->last_lookup && db->last_lookup->ino == ino)
return db->last_lookup;
low = 0;
high = ctx->dir_info->count-1;
if (ino == ctx->dir_info->array[low].ino) {
#ifdef DIRINFO_DEBUG
printf("(%d,%d,%d)\n", ino,
ctx->dir_info->array[low].dotdot,
ctx->dir_info->array[low].parent);
#endif
return &ctx->dir_info->array[low];
}
if (ino == ctx->dir_info->array[high].ino) {
#ifdef DIRINFO_DEBUG
printf("(%d,%d,%d)\n", ino,
ctx->dir_info->array[high].dotdot,
ctx->dir_info->array[high].parent);
#endif
return &ctx->dir_info->array[high];
}
while (low < high) {
mid = (low+high)/2;
if (mid == low || mid == high)
break;
if (ino == ctx->dir_info->array[mid].ino) {
#ifdef DIRINFO_DEBUG
printf("(%d,%d,%d)\n", ino,
ctx->dir_info->array[mid].dotdot,
ctx->dir_info->array[mid].parent);
#endif
return &ctx->dir_info->array[mid];
}
if (ino < ctx->dir_info->array[mid].ino)
high = mid;
else
low = mid;
}
return 0;
}