static int backup_copy_fn(struct db_record *orig_rec, void *state) { struct tdbsam_backup_state *bs = (struct tdbsam_backup_state *)state; struct db_record *new_rec; NTSTATUS status; TDB_DATA key; TDB_DATA value; key = dbwrap_record_get_key(orig_rec); new_rec = dbwrap_fetch_locked(bs->new_db, talloc_tos(), key); if (new_rec == NULL) { bs->success = false; return 1; } value = dbwrap_record_get_value(orig_rec); status = dbwrap_record_store(new_rec, value, TDB_INSERT); TALLOC_FREE(new_rec); if (!NT_STATUS_IS_OK(status)) { bs->success = false; return 1; } return 0; }
static NTSTATUS store_acl_blob_fsp(vfs_handle_struct *handle, files_struct *fsp, DATA_BLOB *pblob) { uint8_t id_buf[16]; struct file_id id; TDB_DATA data; struct db_context *db = acl_db; struct db_record *rec; NTSTATUS status; DEBUG(10,("store_acl_blob_fsp: storing blob length %u on file %s\n", (unsigned int)pblob->length, fsp_str_dbg(fsp))); status = vfs_stat_fsp(fsp); if (!NT_STATUS_IS_OK(status)) { return status; } id = vfs_file_id_from_sbuf(handle->conn, &fsp->fsp_name->st); /* For backwards compatibility only store the dev/inode. */ push_file_id_16((char *)id_buf, &id); rec = dbwrap_fetch_locked(db, talloc_tos(), make_tdb_data(id_buf, sizeof(id_buf))); if (rec == NULL) { DEBUG(0, ("store_acl_blob_fsp_tdb: fetch_lock failed\n")); return NT_STATUS_INTERNAL_DB_CORRUPTION; } data.dptr = pblob->data; data.dsize = pblob->length; return dbwrap_record_store(rec, data, 0); }
bool serverid_deregister(struct server_id id) { struct db_context *db; struct serverid_key key; struct db_record *rec; TDB_DATA tdbkey; NTSTATUS status; bool ret = false; db = serverid_db(); if (db == NULL) { return false; } serverid_fill_key(&id, &key); tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key)); rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey); if (rec == NULL) { DEBUG(1, ("Could not fetch_lock serverid.tdb record\n")); return false; } status = dbwrap_record_delete(rec); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("Deleting serverid.tdb record failed: %s\n", nt_errstr(status))); goto done; } ret = true; done: TALLOC_FREE(rec); return ret; }
static struct db_record *dbwrap_cache_fetch_locked( struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key) { struct db_cache_ctx *ctx = talloc_get_type_abort( db->private_data, struct db_cache_ctx); return dbwrap_fetch_locked(ctx->backing, mem_ctx, key); }
/* lock and fetch the record */ static NTSTATUS notify_fetch_locked(struct notify_context *notify, struct db_record **rec) { *rec = dbwrap_fetch_locked(notify->db_recursive, notify, notify->key); if (*rec == NULL) { return NT_STATUS_INTERNAL_DB_CORRUPTION; } return NT_STATUS_OK; }
bool serverid_register_msg_flags(const struct server_id id, bool do_reg, uint32_t msg_flags) { struct db_context *db; struct serverid_key key; struct serverid_data *data; struct db_record *rec; TDB_DATA tdbkey; TDB_DATA value; NTSTATUS status; bool ret = false; db = serverid_db(); if (db == NULL) { return false; } serverid_fill_key(&id, &key); tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key)); rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey); if (rec == NULL) { DEBUG(1, ("Could not fetch_lock serverid.tdb record\n")); return false; } value = dbwrap_record_get_value(rec); if (value.dsize != sizeof(struct serverid_data)) { DEBUG(1, ("serverid record has unexpected size %d " "(wanted %d)\n", (int)value.dsize, (int)sizeof(struct serverid_data))); goto done; } data = (struct serverid_data *)value.dptr; if (do_reg) { data->msg_flags |= msg_flags; } else { data->msg_flags &= ~msg_flags; } status = dbwrap_record_store(rec, value, 0); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("Storing serverid.tdb record failed: %s\n", nt_errstr(status))); goto done; } ret = true; done: TALLOC_FREE(rec); return ret; }
static struct db_record *connections_fetch_record(TALLOC_CTX *mem_ctx, TDB_DATA key) { struct db_context *ctx = connections_db_ctx(True); if (ctx == NULL) { return NULL; } return dbwrap_fetch_locked(ctx, mem_ctx, key); }
void *secrets_get_trust_account_lock(TALLOC_CTX *mem_ctx, const char *domain) { struct db_context *db_ctx; if (!secrets_init()) { return NULL; } db_ctx = secrets_db_ctx(); return dbwrap_fetch_locked( db_ctx, mem_ctx, string_term_tdb_data(trust_keystr(domain))); }
NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key) { struct db_record *rec; NTSTATUS status; rec = dbwrap_fetch_locked(db, talloc_tos(), key); if (rec == NULL) { return NT_STATUS_NO_MEMORY; } status = dbwrap_record_delete(rec); TALLOC_FREE(rec); return status; }
static struct db_record *acl_tdb_lock(TALLOC_CTX *mem_ctx, struct db_context *db, const struct file_id *id) { uint8_t id_buf[16]; /* For backwards compatibility only store the dev/inode. */ push_file_id_16((char *)id_buf, id); return dbwrap_fetch_locked(db, mem_ctx, make_tdb_data(id_buf, sizeof(id_buf))); }
NTSTATUS smbXsrv_tcon_update(struct smbXsrv_tcon *tcon) { struct smbXsrv_tcon_table *table = tcon->table; NTSTATUS status; uint8_t key_buf[SMBXSRV_TCON_GLOBAL_TDB_KEY_SIZE]; TDB_DATA key; if (tcon->global->db_rec != NULL) { DEBUG(0, ("smbXsrv_tcon_update(0x%08x): " "Called with db_rec != NULL'\n", tcon->global->tcon_global_id)); return NT_STATUS_INTERNAL_ERROR; } key = smbXsrv_tcon_global_id_to_key(tcon->global->tcon_global_id, key_buf); tcon->global->db_rec = dbwrap_fetch_locked(table->global.db_ctx, tcon->global, key); if (tcon->global->db_rec == NULL) { DEBUG(0, ("smbXsrv_tcon_update(0x%08x): " "Failed to lock global key '%s'\n", tcon->global->tcon_global_id, hex_encode_talloc(talloc_tos(), key.dptr, key.dsize))); return NT_STATUS_INTERNAL_DB_ERROR; } status = smbXsrv_tcon_global_store(tcon->global); if (!NT_STATUS_IS_OK(status)) { DEBUG(0,("smbXsrv_tcon_update: " "global_id (0x%08x) store failed - %s\n", tcon->global->tcon_global_id, nt_errstr(status))); return status; } if (DEBUGLVL(10)) { struct smbXsrv_tconB tcon_blob; ZERO_STRUCT(tcon_blob); tcon_blob.version = SMBXSRV_VERSION_0; tcon_blob.info.info0 = tcon; DEBUG(10,("smbXsrv_tcon_update: global_id (0x%08x) stored\n", tcon->global->tcon_global_id)); NDR_PRINT_DEBUG(smbXsrv_tconB, &tcon_blob); } return NT_STATUS_OK; }
NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key) { struct db_record *rec; NTSTATUS status; TALLOC_CTX *frame = talloc_stackframe(); rec = dbwrap_fetch_locked(db, frame, key); if (rec == NULL) { TALLOC_FREE(frame); return NT_STATUS_NO_MEMORY; } status = dbwrap_record_delete(rec); TALLOC_FREE(frame); return status; }
bool serverid_register(const struct server_id id, uint32_t msg_flags) { struct db_context *db; struct serverid_key key; struct serverid_data data; struct db_record *rec; TDB_DATA tdbkey, tdbdata; NTSTATUS status; bool ret = false; db = serverid_db(); if (db == NULL) { return false; } serverid_fill_key(&id, &key); tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key)); rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey); if (rec == NULL) { DEBUG(1, ("Could not fetch_lock serverid.tdb record\n")); return false; } ZERO_STRUCT(data); data.unique_id = id.unique_id; data.msg_flags = msg_flags; tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data)); status = dbwrap_record_store(rec, tdbdata, 0); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("Storing serverid.tdb record failed: %s\n", nt_errstr(status))); goto done; } if (lp_clustering() && ctdb_serverids_exist_supported(messaging_ctdbd_connection())) { register_with_ctdbd(messaging_ctdbd_connection(), id.unique_id, NULL, NULL); } ret = true; done: TALLOC_FREE(rec); return ret; }
static struct share_mode_lock *get_share_mode_lock_internal( TALLOC_CTX *mem_ctx, struct file_id id, const char *servicepath, const struct smb_filename *smb_fname, const struct timespec *old_write_time) { struct share_mode_lock *lck; struct share_mode_data *d; struct db_record *rec; TDB_DATA key = locking_key(&id); TDB_DATA value; rec = dbwrap_fetch_locked(lock_db, mem_ctx, key); if (rec == NULL) { DEBUG(3, ("Could not lock share entry\n")); return NULL; } value = dbwrap_record_get_value(rec); if (value.dptr == NULL) { d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname, old_write_time); } else { d = parse_share_modes(mem_ctx, value); } if (d == NULL) { DEBUG(5, ("get_share_mode_lock_internal: " "Could not get share mode lock\n")); TALLOC_FREE(rec); return NULL; } d->id = id; d->record = talloc_move(d, &rec); talloc_set_destructor(d, share_mode_data_destructor); lck = talloc(mem_ctx, struct share_mode_lock); if (lck == NULL) { DEBUG(1, ("talloc failed\n")); TALLOC_FREE(d); return NULL; } lck->data = talloc_move(lck, &d); return lck; }
static NTSTATUS smbXsrv_open_global_lookup(struct smbXsrv_open_table *table, uint32_t open_global_id, TALLOC_CTX *mem_ctx, struct smbXsrv_open_global0 **_global) { TDB_DATA key; uint8_t key_buf[SMBXSRV_OPEN_GLOBAL_TDB_KEY_SIZE]; struct db_record *global_rec = NULL; bool is_free = false; *_global = NULL; if (table->global.db_ctx == NULL) { return NT_STATUS_INTERNAL_ERROR; } key = smbXsrv_open_global_id_to_key(open_global_id, key_buf); global_rec = dbwrap_fetch_locked(table->global.db_ctx, mem_ctx, key); if (global_rec == NULL) { DEBUG(0, ("smbXsrv_open_global_lookup(0x%08x): " "Failed to lock global key '%s'\n", open_global_id, hex_encode_talloc(talloc_tos(), key.dptr, key.dsize))); return NT_STATUS_INTERNAL_DB_ERROR; } smbXsrv_open_global_verify_record(global_rec, &is_free, NULL, mem_ctx, _global); if (is_free) { talloc_free(global_rec); return NT_STATUS_OBJECT_NAME_NOT_FOUND; } (*_global)->db_rec = talloc_move(*_global, &global_rec); talloc_set_destructor(*_global, smbXsrv_open_global_destructor); return NT_STATUS_OK; }
static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db, void *private_data) { struct db_record *rec; uint32_t val = (uint32_t)-1; uint32_t v_store; NTSTATUS ret; struct dbwrap_change_uint32_atomic_context *state; TDB_DATA value; state = (struct dbwrap_change_uint32_atomic_context *)private_data; rec = dbwrap_fetch_locked(db, talloc_tos(), string_term_tdb_data(state->keystr)); if (!rec) { return NT_STATUS_UNSUCCESSFUL; } value = dbwrap_record_get_value(rec); if (value.dptr == NULL) { val = *(state->oldval); } else if (value.dsize == sizeof(val)) { val = IVAL(value.dptr, 0); *(state->oldval) = val; } else { ret = NT_STATUS_UNSUCCESSFUL; goto done; } val += state->change_val; SIVAL(&v_store, 0, val); ret = dbwrap_record_store(rec, make_tdb_data((const uint8_t *)&v_store, sizeof(v_store)), TDB_REPLACE); done: TALLOC_FREE(rec); return ret; }
static struct db_record *smbXsrv_session_local_fetch_locked( struct db_context *db, uint32_t id, TALLOC_CTX *mem_ctx) { TDB_DATA key; uint8_t key_buf[SMBXSRV_SESSION_LOCAL_TDB_KEY_SIZE]; struct db_record *rec = NULL; key = smbXsrv_session_local_id_to_key(id, key_buf); rec = dbwrap_fetch_locked(db, mem_ctx, key); if (rec == NULL) { DBG_DEBUG("Failed to lock local id 0x%08x, key '%s'\n", id, hex_encode_talloc(talloc_tos(), key.dptr, key.dsize)); } return rec; }
static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data) { NTSTATUS status; struct db_record *rec; TDB_DATA *key = (TDB_DATA *)private_data; rec = dbwrap_fetch_locked(db, talloc_tos(), *key); if (rec == NULL) { DEBUG(5, ("fetch_locked failed\n")); return NT_STATUS_NO_MEMORY; } status = dbwrap_record_delete(rec); if (!NT_STATUS_IS_OK(status)) { DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status))); } talloc_free(rec); return status; }
bool run_dbwrap_watch1(int dummy) { struct tevent_context *ev = NULL; struct messaging_context *msg = NULL; struct db_context *backend = NULL; struct db_context *db = NULL; const char *keystr = "key"; TDB_DATA key = string_term_tdb_data(keystr); struct db_record *rec = NULL; struct tevent_req *req = NULL; NTSTATUS status; bool ret = false; ev = samba_tevent_context_init(talloc_tos()); if (ev == NULL) { fprintf(stderr, "tevent_context_init failed\n"); goto fail; } msg = messaging_init(ev, ev); if (msg == NULL) { fprintf(stderr, "messaging_init failed\n"); goto fail; } backend = db_open(msg, "test_watch.tdb", 0, TDB_DEFAULT, O_CREAT|O_RDWR, 0644, DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE); if (backend == NULL) { fprintf(stderr, "db_open failed: %s\n", strerror(errno)); goto fail; } db = db_open_watched(ev, backend, msg); rec = dbwrap_fetch_locked(db, db, key); if (rec == NULL) { fprintf(stderr, "dbwrap_fetch_locked failed\n"); goto fail; } req = dbwrap_watched_watch_send(talloc_tos(), ev, rec, (struct server_id){0});
static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data) { struct db_record *rec = NULL; NTSTATUS status; struct dbwrap_store_context *store_ctx; store_ctx = (struct dbwrap_store_context *)private_data; rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key)); if (rec == NULL) { DEBUG(5, ("fetch_locked failed\n")); return NT_STATUS_NO_MEMORY; } status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag); if (!NT_STATUS_IS_OK(status)) { DEBUG(5, ("store returned %s\n", nt_errstr(status))); } TALLOC_FREE(rec); return status; }
NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr, int32_t v) { struct db_record *rec; int32_t v_store; NTSTATUS status; rec = dbwrap_fetch_locked(db, talloc_tos(), string_term_tdb_data(keystr)); if (rec == NULL) { return NT_STATUS_UNSUCCESSFUL; } SIVAL(&v_store, 0, v); status = dbwrap_record_store(rec, make_tdb_data((const uint8_t *)&v_store, sizeof(v_store)), TDB_REPLACE); TALLOC_FREE(rec); return status; }
NTSTATUS smbXsrv_open_close(struct smbXsrv_open *op, NTTIME now) { struct smbXsrv_open_table *table; struct db_record *local_rec = NULL; struct db_record *global_rec = NULL; NTSTATUS status; NTSTATUS error = NT_STATUS_OK; if (op->table == NULL) { return NT_STATUS_OK; } table = op->table; op->table = NULL; op->status = NT_STATUS_FILE_CLOSED; op->global->disconnect_time = now; server_id_set_disconnected(&op->global->server_id); global_rec = op->global->db_rec; op->global->db_rec = NULL; if (global_rec == NULL) { uint8_t key_buf[SMBXSRV_OPEN_GLOBAL_TDB_KEY_SIZE]; TDB_DATA key; key = smbXsrv_open_global_id_to_key( op->global->open_global_id, key_buf); global_rec = dbwrap_fetch_locked(table->global.db_ctx, op->global, key); if (global_rec == NULL) { DEBUG(0, ("smbXsrv_open_close(0x%08x): " "Failed to lock global key '%s'\n", op->global->open_global_id, hex_encode_talloc(global_rec, key.dptr, key.dsize))); error = NT_STATUS_INTERNAL_ERROR; } } if (global_rec != NULL && op->global->durable) { /* * If it is a durable open we need to update the global part * instead of deleting it */ op->global->db_rec = global_rec; status = smbXsrv_open_global_store(op->global); if (NT_STATUS_IS_OK(status)) { /* * smbXsrv_open_global_store does the free * of op->global->db_rec */ global_rec = NULL; } if (!NT_STATUS_IS_OK(status)) { DEBUG(0,("smbXsrv_open_close(0x%08x)" "smbXsrv_open_global_store() failed - %s\n", op->global->open_global_id, nt_errstr(status))); error = status; } if (NT_STATUS_IS_OK(status) && CHECK_DEBUGLVL(10)) { struct smbXsrv_openB open_blob; ZERO_STRUCT(open_blob); open_blob.version = SMBXSRV_VERSION_0; open_blob.info.info0 = op; DEBUG(10,("smbXsrv_open_close(0x%08x): " "stored disconnect\n", op->global->open_global_id)); NDR_PRINT_DEBUG(smbXsrv_openB, &open_blob); } } if (global_rec != NULL) { status = dbwrap_record_delete(global_rec); if (!NT_STATUS_IS_OK(status)) { TDB_DATA key = dbwrap_record_get_key(global_rec); DEBUG(0, ("smbXsrv_open_close(0x%08x): " "failed to delete global key '%s': %s\n", op->global->open_global_id, hex_encode_talloc(global_rec, key.dptr, key.dsize), nt_errstr(status))); error = status; } } TALLOC_FREE(global_rec); local_rec = op->db_rec; if (local_rec == NULL) { uint8_t key_buf[SMBXSRV_OPEN_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; key = smbXsrv_open_local_id_to_key(op->local_id, key_buf); local_rec = dbwrap_fetch_locked(table->local.db_ctx, op, key); if (local_rec == NULL) { DEBUG(0, ("smbXsrv_open_close(0x%08x): " "Failed to lock local key '%s'\n", op->global->open_global_id, hex_encode_talloc(local_rec, key.dptr, key.dsize))); error = NT_STATUS_INTERNAL_ERROR; } } if (local_rec != NULL) { status = dbwrap_record_delete(local_rec); if (!NT_STATUS_IS_OK(status)) { TDB_DATA key = dbwrap_record_get_key(local_rec); DEBUG(0, ("smbXsrv_open_close(0x%08x): " "failed to delete local key '%s': %s\n", op->global->open_global_id, hex_encode_talloc(local_rec, key.dptr, key.dsize), nt_errstr(status))); error = status; } table->local.num_opens -= 1; } if (op->db_rec == NULL) { TALLOC_FREE(local_rec); } op->db_rec = NULL; if (op->compat) { op->compat->op = NULL; file_free(NULL, op->compat); op->compat = NULL; } return error; }
bool run_dbwrap_watch1(int dummy) { struct tevent_context *ev = NULL; struct messaging_context *msg = NULL; struct db_context *db = NULL; const char *keystr = "key"; TDB_DATA key = string_term_tdb_data(keystr); struct db_record *rec = NULL; struct tevent_req *req = NULL; NTSTATUS status; bool ret = false; ev = tevent_context_init(talloc_tos()); if (ev == NULL) { fprintf(stderr, "tevent_context_init failed\n"); goto fail; } msg = messaging_init(ev, ev); if (msg == NULL) { fprintf(stderr, "messaging_init failed\n"); goto fail; } db = db_open(msg, "test_watch.tdb", 0, TDB_DEFAULT, O_CREAT|O_RDWR, 0644, DBWRAP_LOCK_ORDER_1); if (db == NULL) { fprintf(stderr, "db_open failed: %s\n", strerror(errno)); goto fail; } dbwrap_watch_db(db, msg); rec = dbwrap_fetch_locked(db, db, key); if (rec == NULL) { fprintf(stderr, "dbwrap_fetch_locked failed\n"); goto fail; } req = dbwrap_record_watch_send(talloc_tos(), ev, rec, msg); if (req == NULL) { fprintf(stderr, "dbwrap_record_watch_send failed\n"); goto fail; } TALLOC_FREE(rec); status = dbwrap_store_int32(db, keystr, 1); if (!NT_STATUS_IS_OK(status)) { fprintf(stderr, "dbwrap_store_int32 failed: %s\n", nt_errstr(status)); goto fail; } if (!tevent_req_poll(req, ev)) { fprintf(stderr, "tevent_req_poll failed\n"); goto fail; } status = dbwrap_record_watch_recv(req, talloc_tos(), &rec); if (!NT_STATUS_IS_OK(status)) { fprintf(stderr, "dbwrap_record_watch_recv failed: %s\n", nt_errstr(status)); goto fail; } ret = true; fail: TALLOC_FREE(req); TALLOC_FREE(rec); TALLOC_FREE(db); TALLOC_FREE(msg); TALLOC_FREE(ev); return ret; }
NTSTATUS leases_db_add(const struct GUID *client_guid, const struct smb2_lease_key *lease_key, const struct file_id *id, const char *servicepath, const char *base_name, const char *stream_name) { TDB_DATA db_key, db_value; DATA_BLOB blob; struct db_record *rec; NTSTATUS status; bool ok; struct leases_db_value new_value; struct leases_db_file new_file; struct leases_db_value *value = NULL; enum ndr_err_code ndr_err; if (!leases_db_init(false)) { return NT_STATUS_INTERNAL_ERROR; } ok = leases_db_key(talloc_tos(), client_guid, lease_key, &db_key); if (!ok) { DEBUG(10, ("%s: leases_db_key failed\n", __func__)); return NT_STATUS_NO_MEMORY; } rec = dbwrap_fetch_locked(leases_db, talloc_tos(), db_key); TALLOC_FREE(db_key.dptr); if (rec == NULL) { return NT_STATUS_INTERNAL_ERROR; } db_value = dbwrap_record_get_value(rec); if (db_value.dsize != 0) { uint32_t i; DEBUG(10, ("%s: record exists\n", __func__)); value = talloc(talloc_tos(), struct leases_db_value); if (value == NULL) { status = NT_STATUS_NO_MEMORY; goto out; } blob.data = db_value.dptr; blob.length = db_value.dsize; ndr_err = ndr_pull_struct_blob_all( &blob, value, value, (ndr_pull_flags_fn_t)ndr_pull_leases_db_value); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { DEBUG(10, ("%s: ndr_pull_struct_blob_failed: %s\n", __func__, ndr_errstr(ndr_err))); status = ndr_map_error2ntstatus(ndr_err); goto out; } /* id must be unique. */ for (i = 0; i < value->num_files; i++) { if (file_id_equal(id, &value->files[i].id)) { status = NT_STATUS_OBJECT_NAME_COLLISION; goto out; } } value->files = talloc_realloc(value, value->files, struct leases_db_file, value->num_files + 1); if (value->files == NULL) { status = NT_STATUS_NO_MEMORY; goto out; } value->files[value->num_files].id = *id; value->files[value->num_files].servicepath = servicepath; value->files[value->num_files].base_name = base_name; value->files[value->num_files].stream_name = stream_name; value->num_files += 1; } else {
NTSTATUS smbXsrv_tcon_disconnect(struct smbXsrv_tcon *tcon, uint64_t vuid) { struct smbXsrv_tcon_table *table; struct db_record *local_rec = NULL; struct db_record *global_rec = NULL; NTSTATUS status; NTSTATUS error = NT_STATUS_OK; if (tcon->table == NULL) { return NT_STATUS_OK; } table = tcon->table; tcon->table = NULL; tcon->status = NT_STATUS_NETWORK_NAME_DELETED; global_rec = tcon->global->db_rec; tcon->global->db_rec = NULL; if (global_rec == NULL) { uint8_t key_buf[SMBXSRV_TCON_GLOBAL_TDB_KEY_SIZE]; TDB_DATA key; key = smbXsrv_tcon_global_id_to_key( tcon->global->tcon_global_id, key_buf); global_rec = dbwrap_fetch_locked(table->global.db_ctx, tcon->global, key); if (global_rec == NULL) { DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): " "Failed to lock global key '%s'\n", tcon->global->tcon_global_id, tcon->global->share_name, hex_encode_talloc(global_rec, key.dptr, key.dsize))); error = NT_STATUS_INTERNAL_ERROR; } } if (global_rec != NULL) { status = dbwrap_record_delete(global_rec); if (!NT_STATUS_IS_OK(status)) { TDB_DATA key = dbwrap_record_get_key(global_rec); DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): " "failed to delete global key '%s': %s\n", tcon->global->tcon_global_id, tcon->global->share_name, hex_encode_talloc(global_rec, key.dptr, key.dsize), nt_errstr(status))); error = status; } } TALLOC_FREE(global_rec); local_rec = tcon->db_rec; if (local_rec == NULL) { uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; key = smbXsrv_tcon_local_id_to_key(tcon->local_id, key_buf); local_rec = dbwrap_fetch_locked(table->local.db_ctx, tcon, key); if (local_rec == NULL) { DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): " "Failed to lock local key '%s'\n", tcon->global->tcon_global_id, tcon->global->share_name, hex_encode_talloc(local_rec, key.dptr, key.dsize))); error = NT_STATUS_INTERNAL_ERROR; } } if (local_rec != NULL) { status = dbwrap_record_delete(local_rec); if (!NT_STATUS_IS_OK(status)) { TDB_DATA key = dbwrap_record_get_key(local_rec); DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): " "failed to delete local key '%s': %s\n", tcon->global->tcon_global_id, tcon->global->share_name, hex_encode_talloc(local_rec, key.dptr, key.dsize), nt_errstr(status))); error = status; } table->local.num_tcons -= 1; } if (tcon->db_rec == NULL) { TALLOC_FREE(local_rec); } tcon->db_rec = NULL; if (tcon->compat) { bool ok; ok = set_current_service(tcon->compat, 0, true); if (!ok) { status = NT_STATUS_INTERNAL_ERROR; DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): " "set_current_service() failed: %s\n", tcon->global->tcon_global_id, tcon->global->share_name, nt_errstr(status))); tcon->compat = NULL; return status; } close_cnum(tcon->compat, vuid); tcon->compat = NULL; } return error; }
static NTSTATUS smbXsrv_tcon_create(struct smbXsrv_tcon_table *table, enum protocol_types protocol, struct server_id server_id, NTTIME now, struct smbXsrv_tcon **_tcon) { struct db_record *local_rec = NULL; struct smbXsrv_tcon *tcon = NULL; void *ptr = NULL; TDB_DATA val; struct smbXsrv_tcon_global0 *global = NULL; NTSTATUS status; if (table->local.num_tcons >= table->local.max_tcons) { return NT_STATUS_INSUFFICIENT_RESOURCES; } tcon = talloc_zero(table, struct smbXsrv_tcon); if (tcon == NULL) { return NT_STATUS_NO_MEMORY; } tcon->table = table; tcon->status = NT_STATUS_INTERNAL_ERROR; tcon->idle_time = now; status = smbXsrv_tcon_global_allocate(table->global.db_ctx, tcon, &global); if (!NT_STATUS_IS_OK(status)) { TALLOC_FREE(tcon); return status; } tcon->global = global; if (protocol >= PROTOCOL_SMB2_02) { uint64_t id = global->tcon_global_id; uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; global->tcon_wire_id = id; tcon->local_id = global->tcon_global_id; key = smbXsrv_tcon_local_id_to_key(tcon->local_id, key_buf); local_rec = dbwrap_fetch_locked(table->local.db_ctx, tcon, key); if (local_rec == NULL) { TALLOC_FREE(tcon); return NT_STATUS_NO_MEMORY; } val = dbwrap_record_get_value(local_rec); if (val.dsize != 0) { TALLOC_FREE(tcon); return NT_STATUS_INTERNAL_DB_CORRUPTION; } } else { status = smb1srv_tcon_local_allocate_id(table->local.db_ctx, table->local.lowest_id, table->local.highest_id, tcon, &local_rec, &tcon->local_id); if (!NT_STATUS_IS_OK(status)) { TALLOC_FREE(tcon); return status; } global->tcon_wire_id = tcon->local_id; } global->creation_time = now; global->server_id = server_id; ptr = tcon; val = make_tdb_data((uint8_t const *)&ptr, sizeof(ptr)); status = dbwrap_record_store(local_rec, val, TDB_REPLACE); TALLOC_FREE(local_rec); if (!NT_STATUS_IS_OK(status)) { TALLOC_FREE(tcon); return status; } table->local.num_tcons += 1; talloc_set_destructor(tcon, smbXsrv_tcon_destructor); status = smbXsrv_tcon_global_store(global); if (!NT_STATUS_IS_OK(status)) { DEBUG(0,("smbXsrv_tcon_create: " "global_id (0x%08x) store failed - %s\n", tcon->global->tcon_global_id, nt_errstr(status))); TALLOC_FREE(tcon); return status; } if (DEBUGLVL(10)) { struct smbXsrv_tconB tcon_blob; ZERO_STRUCT(tcon_blob); tcon_blob.version = SMBXSRV_VERSION_0; tcon_blob.info.info0 = tcon; DEBUG(10,("smbXsrv_tcon_create: global_id (0x%08x) stored\n", tcon->global->tcon_global_id)); NDR_PRINT_DEBUG(smbXsrv_tconB, &tcon_blob); } *_tcon = tcon; return NT_STATUS_OK; }
static NTSTATUS smb1srv_tcon_local_allocate_id(struct db_context *db, uint32_t lowest_id, uint32_t highest_id, TALLOC_CTX *mem_ctx, struct db_record **_rec, uint32_t *_id) { struct smb1srv_tcon_local_allocate_state state = { .lowest_id = lowest_id, .highest_id = highest_id, .last_id = 0, .useable_id = lowest_id, .status = NT_STATUS_INTERNAL_ERROR, }; uint32_t i; uint32_t range; NTSTATUS status; int count = 0; *_rec = NULL; *_id = 0; if (lowest_id > highest_id) { return NT_STATUS_INSUFFICIENT_RESOURCES; } /* * first we try randomly */ range = (highest_id - lowest_id) + 1; for (i = 0; i < (range / 2); i++) { uint32_t id; uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; TDB_DATA val; struct db_record *rec = NULL; id = generate_random() % range; id += lowest_id; if (id < lowest_id) { id = lowest_id; } if (id > highest_id) { id = highest_id; } key = smbXsrv_tcon_local_id_to_key(id, key_buf); rec = dbwrap_fetch_locked(db, mem_ctx, key); if (rec == NULL) { return NT_STATUS_INSUFFICIENT_RESOURCES; } val = dbwrap_record_get_value(rec); if (val.dsize != 0) { TALLOC_FREE(rec); continue; } *_rec = rec; *_id = id; return NT_STATUS_OK; } /* * if the range is almost full, * we traverse the whole table * (this relies on sorted behavior of dbwrap_rbt) */ status = dbwrap_traverse_read(db, smb1srv_tcon_local_allocate_traverse, &state, &count); if (NT_STATUS_IS_OK(status)) { if (NT_STATUS_IS_OK(state.status)) { return NT_STATUS_INTERNAL_ERROR; } if (!NT_STATUS_EQUAL(state.status, NT_STATUS_INTERNAL_ERROR)) { return state.status; } if (state.useable_id <= state.highest_id) { state.status = NT_STATUS_OK; } else { return NT_STATUS_INSUFFICIENT_RESOURCES; } } else if (!NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_DB_CORRUPTION)) { /* * Here we really expect NT_STATUS_INTERNAL_DB_CORRUPTION! * * If we get anything else it is an error, because it * means we did not manage to find a free slot in * the db. */ return NT_STATUS_INSUFFICIENT_RESOURCES; } if (NT_STATUS_IS_OK(state.status)) { uint32_t id; uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; TDB_DATA val; struct db_record *rec = NULL; id = state.useable_id; key = smbXsrv_tcon_local_id_to_key(id, key_buf); rec = dbwrap_fetch_locked(db, mem_ctx, key); if (rec == NULL) { return NT_STATUS_INSUFFICIENT_RESOURCES; } val = dbwrap_record_get_value(rec); if (val.dsize != 0) { TALLOC_FREE(rec); return NT_STATUS_INTERNAL_DB_CORRUPTION; } *_rec = rec; *_id = id; return NT_STATUS_OK; } return state.status; } struct smbXsrv_tcon_local_fetch_state { struct smbXsrv_tcon *tcon; NTSTATUS status; }; static void smbXsrv_tcon_local_fetch_parser(TDB_DATA key, TDB_DATA data, void *private_data) { struct smbXsrv_tcon_local_fetch_state *state = (struct smbXsrv_tcon_local_fetch_state *)private_data; void *ptr; if (data.dsize != sizeof(ptr)) { state->status = NT_STATUS_INTERNAL_DB_ERROR; return; } memcpy(&ptr, data.dptr, data.dsize); state->tcon = talloc_get_type_abort(ptr, struct smbXsrv_tcon); state->status = NT_STATUS_OK; } static NTSTATUS smbXsrv_tcon_local_lookup(struct smbXsrv_tcon_table *table, uint32_t tcon_local_id, NTTIME now, struct smbXsrv_tcon **_tcon) { struct smbXsrv_tcon_local_fetch_state state = { .tcon = NULL, .status = NT_STATUS_INTERNAL_ERROR, }; uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE]; TDB_DATA key; NTSTATUS status; *_tcon = NULL; if (tcon_local_id == 0) { return NT_STATUS_NETWORK_NAME_DELETED; } if (table == NULL) { /* this might happen before the end of negprot */ return NT_STATUS_NETWORK_NAME_DELETED; } if (table->local.db_ctx == NULL) { return NT_STATUS_INTERNAL_ERROR; } key = smbXsrv_tcon_local_id_to_key(tcon_local_id, key_buf); status = dbwrap_parse_record(table->local.db_ctx, key, smbXsrv_tcon_local_fetch_parser, &state); if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) { return NT_STATUS_NETWORK_NAME_DELETED; } else if (!NT_STATUS_IS_OK(status)) { return status; } if (!NT_STATUS_IS_OK(state.status)) { return state.status; } if (NT_STATUS_EQUAL(state.tcon->status, NT_STATUS_NETWORK_NAME_DELETED)) { return NT_STATUS_NETWORK_NAME_DELETED; } state.tcon->idle_time = now; *_tcon = state.tcon; return state.tcon->status; } static int smbXsrv_tcon_global_destructor(struct smbXsrv_tcon_global0 *global) { return 0; } static void smbXsrv_tcon_global_verify_record(struct db_record *db_rec, bool *is_free, bool *was_free, TALLOC_CTX *mem_ctx, struct smbXsrv_tcon_global0 **_g); static NTSTATUS smbXsrv_tcon_global_allocate(struct db_context *db, TALLOC_CTX *mem_ctx, struct smbXsrv_tcon_global0 **_global) { uint32_t i; struct smbXsrv_tcon_global0 *global = NULL; uint32_t last_free = 0; const uint32_t min_tries = 3; *_global = NULL; global = talloc_zero(mem_ctx, struct smbXsrv_tcon_global0); if (global == NULL) { return NT_STATUS_NO_MEMORY; } talloc_set_destructor(global, smbXsrv_tcon_global_destructor); /* * Here we just randomly try the whole 32-bit space * * We use just 32-bit, because we want to reuse the * ID for SRVSVC. */ for (i = 0; i < UINT32_MAX; i++) { bool is_free = false; bool was_free = false; uint32_t id; uint8_t key_buf[SMBXSRV_TCON_GLOBAL_TDB_KEY_SIZE]; TDB_DATA key; if (i >= min_tries && last_free != 0) { id = last_free; } else { id = generate_random(); } if (id == 0) { id++; } if (id == UINT32_MAX) { id--; } key = smbXsrv_tcon_global_id_to_key(id, key_buf); global->db_rec = dbwrap_fetch_locked(db, mem_ctx, key); if (global->db_rec == NULL) { talloc_free(global); return NT_STATUS_INSUFFICIENT_RESOURCES; } smbXsrv_tcon_global_verify_record(global->db_rec, &is_free, &was_free, NULL, NULL); if (!is_free) { TALLOC_FREE(global->db_rec); continue; } if (!was_free && i < min_tries) { /* * The session_id is free now, * but was not free before. * * This happens if a smbd crashed * and did not cleanup the record. * * If this is one of our first tries, * then we try to find a real free one. */ if (last_free == 0) { last_free = id; } TALLOC_FREE(global->db_rec); continue; } global->tcon_global_id = id; *_global = global; return NT_STATUS_OK; } /* should not be reached */ talloc_free(global); return NT_STATUS_INTERNAL_ERROR; }
NTSTATUS smbXsrv_open_cleanup(uint64_t persistent_id) { NTSTATUS status = NT_STATUS_OK; TALLOC_CTX *frame = talloc_stackframe(); struct smbXsrv_open_global0 *op = NULL; uint8_t key_buf[SMBXSRV_OPEN_GLOBAL_TDB_KEY_SIZE]; TDB_DATA key; TDB_DATA val; struct db_record *rec; bool delete_open = false; uint32_t global_id = persistent_id & UINT32_MAX; key = smbXsrv_open_global_id_to_key(global_id, key_buf); rec = dbwrap_fetch_locked(smbXsrv_open_global_db_ctx, frame, key); if (rec == NULL) { status = NT_STATUS_NOT_FOUND; DEBUG(1, ("smbXsrv_open_cleanup[global: 0x%08x] " "failed to fetch record from %s - %s\n", global_id, dbwrap_name(smbXsrv_open_global_db_ctx), nt_errstr(status))); goto done; } val = dbwrap_record_get_value(rec); if (val.dsize == 0) { DEBUG(10, ("smbXsrv_open_cleanup[global: 0x%08x] " "empty record in %s, skipping...\n", global_id, dbwrap_name(smbXsrv_open_global_db_ctx))); goto done; } status = smbXsrv_open_global_parse_record(talloc_tos(), rec, &op); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("smbXsrv_open_cleanup[global: 0x%08x] " "failed to read record: %s\n", global_id, nt_errstr(status))); goto done; } if (server_id_is_disconnected(&op->server_id)) { struct timeval now, disconnect_time; int64_t tdiff; now = timeval_current(); nttime_to_timeval(&disconnect_time, op->disconnect_time); tdiff = usec_time_diff(&now, &disconnect_time); delete_open = (tdiff >= 1000*op->durable_timeout_msec); DEBUG(10, ("smbXsrv_open_cleanup[global: 0x%08x] " "disconnected at [%s] %us ago with " "timeout of %us -%s reached\n", global_id, nt_time_string(frame, op->disconnect_time), (unsigned)(tdiff/1000000), op->durable_timeout_msec / 1000, delete_open ? "" : " not")); } else if (!serverid_exists(&op->server_id)) { DEBUG(10, ("smbXsrv_open_cleanup[global: 0x%08x] " "server[%s] does not exist\n", global_id, server_id_str(frame, &op->server_id))); delete_open = true; } if (!delete_open) { goto done; } status = dbwrap_record_delete(rec); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("smbXsrv_open_cleanup[global: 0x%08x] " "failed to delete record" "from %s: %s\n", global_id, dbwrap_name(smbXsrv_open_global_db_ctx), nt_errstr(status))); goto done; } DEBUG(10, ("smbXsrv_open_cleanup[global: 0x%08x] " "delete record from %s\n", global_id, dbwrap_name(smbXsrv_open_global_db_ctx))); done: talloc_free(frame); return status; }
static void test_store_records(struct db_context *db, struct tevent_context *ev) { TDB_DATA key; uint32_t *counters; TALLOC_CTX *tmp_ctx = talloc_stackframe(); struct timeval start; key = string_term_tdb_data("testkey"); start = timeval_current(); while ((timelimit == 0) || (timeval_elapsed(&start) < timelimit)) { struct db_record *rec; TDB_DATA data; TDB_DATA value; int ret; NTSTATUS status; if (!no_trans) { if (verbose) DEBUG(1, ("starting transaction\n")); ret = dbwrap_transaction_start(db); if (ret != 0) { DEBUG(0, ("Failed to start transaction on node " "%d\n", pnn)); goto fail; } if (verbose) DEBUG(1, ("transaction started\n")); do_sleep(torture_delay); } if (verbose) DEBUG(1, ("calling fetch_lock\n")); rec = dbwrap_fetch_locked(db, tmp_ctx, key); if (rec == NULL) { DEBUG(0, ("Failed to fetch record\n")); goto fail; } if (verbose) DEBUG(1, ("fetched record ok\n")); do_sleep(torture_delay); value = dbwrap_record_get_value(rec); data.dsize = MAX(value.dsize, sizeof(uint32_t) * (pnn+1)); data.dptr = (unsigned char *)talloc_zero_size(tmp_ctx, data.dsize); if (data.dptr == NULL) { DEBUG(0, ("Failed to allocate data\n")); goto fail; } memcpy(data.dptr, value.dptr, value.dsize); counters = (uint32_t *)data.dptr; /* bump our counter */ counters[pnn]++; if (verbose) DEBUG(1, ("storing data\n")); status = dbwrap_record_store(rec, data, TDB_REPLACE); if (!NT_STATUS_IS_OK(status)) { DEBUG(0, ("Failed to store record\n")); if (!no_trans) { ret = dbwrap_transaction_cancel(db); if (ret != 0) { DEBUG(0, ("Error cancelling transaction.\n")); } } goto fail; } talloc_free(rec); if (verbose) DEBUG(1, ("stored data ok\n")); do_sleep(torture_delay); if (!no_trans) { if (verbose) DEBUG(1, ("calling transaction_commit\n")); ret = dbwrap_transaction_commit(db); if (ret != 0) { DEBUG(0, ("Failed to commit transaction\n")); goto fail; } if (verbose) DEBUG(1, ("transaction committed\n")); } /* store the counters and verify that they are sane */ if (verbose || (pnn == 0)) { if (!check_counters(db, data)) { goto fail; } } talloc_free(data.dptr); do_sleep(torture_delay); } goto done; fail: success = false; done: talloc_free(tmp_ctx); return; }
/* lock the notify db */ static struct db_record *notify_lock(struct notify_context *notify) { TDB_DATA key = string_term_tdb_data(NOTIFY_KEY); return dbwrap_fetch_locked(notify->db, notify, key); }