2023-03-28 12:15:50 +03:00
/*
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
Unix SMB / CIFS implementation .
Database interface wrapper around tdb
Copyright ( C ) Volker Lendecke 2005 - 2007
2010-03-14 16:06:45 +03:00
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
( at your option ) any later version .
2010-03-14 16:06:45 +03:00
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
2010-03-14 16:06:45 +03:00
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
*/
2007-11-07 22:18:38 +03:00
# ifndef __DBWRAP_H__
# define __DBWRAP_H__
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
2014-10-29 12:20:20 +03:00
# include "replace.h"
# include <talloc.h>
2016-12-27 11:13:37 +03:00
# include <tevent.h>
2014-10-29 12:20:20 +03:00
# include "libcli/util/ntstatus.h"
2012-06-19 07:13:10 +04:00
# include "tdb.h"
2011-05-05 13:25:29 +04:00
2011-08-24 16:53:42 +04:00
struct db_record ;
struct db_context ;
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
2012-05-11 23:36:48 +04:00
enum dbwrap_lock_order {
2014-01-27 20:20:56 +04:00
DBWRAP_LOCK_ORDER_NONE = 0 , /* Don't check lock orders for this db. */
2012-05-11 23:36:48 +04:00
DBWRAP_LOCK_ORDER_1 = 1 ,
DBWRAP_LOCK_ORDER_2 = 2 ,
2019-09-15 12:56:25 +03:00
DBWRAP_LOCK_ORDER_3 = 3 ,
DBWRAP_LOCK_ORDER_4 = 4
2012-05-11 23:36:48 +04:00
} ;
2014-01-27 16:38:51 +04:00
# define DBWRAP_FLAG_NONE 0x0000000000000000ULL
2014-01-28 14:31:44 +04:00
# define DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS 0x0000000000000001ULL
2014-01-27 16:38:51 +04:00
2017-01-10 16:22:21 +03:00
enum dbwrap_req_state {
/**
* We are creating the request
*/
DBWRAP_REQ_INIT ,
/**
* The request is queued and waiting to be dispatched
*/
DBWRAP_REQ_QUEUED ,
/**
* We are waiting to receive the reply
*/
DBWRAP_REQ_DISPATCHED ,
/**
* The request is finished
*/
DBWRAP_REQ_DONE ,
/**
* The request errored out
*/
DBWRAP_REQ_ERROR
} ;
2011-08-17 10:45:09 +04:00
/* The following definitions come from lib/dbwrap.c */
2008-03-25 14:54:14 +03:00
2011-08-19 12:50:20 +04:00
TDB_DATA dbwrap_record_get_key ( const struct db_record * rec ) ;
TDB_DATA dbwrap_record_get_value ( const struct db_record * rec ) ;
2011-08-19 12:51:27 +04:00
NTSTATUS dbwrap_record_store ( struct db_record * rec , TDB_DATA data , int flags ) ;
2016-09-13 13:25:14 +03:00
NTSTATUS dbwrap_record_storev ( struct db_record * rec ,
const TDB_DATA * dbufs , int num_dbufs , int flags ) ;
2011-08-19 12:52:57 +04:00
NTSTATUS dbwrap_record_delete ( struct db_record * rec ) ;
2023-03-28 12:15:15 +03:00
/**
* @ brief Adds TDB records from one db_context to another
*
* @ param to Destination db_context
* @ param from Source db_context
* @ param flags ( TDB_INSERT or TDB_REPLACE )
*
* @ return NT_STATUS_OK on success or NT_STATUS_INTERNAL_DB_CORRUPTION
*/
NTSTATUS
dbwrap_merge_dbs ( struct db_context * to , struct db_context * from , int flags ) ;
2011-08-19 12:53:29 +04:00
struct db_record * dbwrap_fetch_locked ( struct db_context * db ,
TALLOC_CTX * mem_ctx ,
TDB_DATA key ) ;
2012-01-02 16:30:51 +04:00
struct db_context * dbwrap_record_get_db ( struct db_record * rec ) ;
2011-08-19 12:50:20 +04:00
2019-11-21 17:19:16 +03:00
void dbwrap_lock_order_lock ( const char * db_name ,
enum dbwrap_lock_order lock_order ) ;
void dbwrap_lock_order_unlock ( const char * db_name ,
enum dbwrap_lock_order lock_order ) ;
2016-11-09 10:45:59 +03:00
NTSTATUS dbwrap_do_locked ( struct db_context * db , TDB_DATA key ,
void ( * fn ) ( struct db_record * rec ,
2019-10-23 12:34:47 +03:00
TDB_DATA value ,
2016-11-09 10:45:59 +03:00
void * private_data ) ,
void * private_data ) ;
2008-12-17 10:53:31 +03:00
NTSTATUS dbwrap_delete ( struct db_context * db , TDB_DATA key ) ;
NTSTATUS dbwrap_store ( struct db_context * db , TDB_DATA key ,
TDB_DATA data , int flags ) ;
2011-08-24 15:08:13 +04:00
NTSTATUS dbwrap_fetch ( struct db_context * db , TALLOC_CTX * mem_ctx ,
TDB_DATA key , TDB_DATA * value ) ;
2011-07-04 12:15:44 +04:00
bool dbwrap_exists ( struct db_context * db , TDB_DATA key ) ;
2011-08-17 10:45:09 +04:00
NTSTATUS dbwrap_traverse ( struct db_context * db ,
int ( * f ) ( struct db_record * , void * ) ,
2011-08-17 11:51:12 +04:00
void * private_data ,
int * count ) ;
2011-08-17 11:59:25 +04:00
NTSTATUS dbwrap_traverse_read ( struct db_context * db ,
int ( * f ) ( struct db_record * , void * ) ,
void * private_data ,
int * count ) ;
2011-12-08 18:50:33 +04:00
NTSTATUS dbwrap_parse_record ( struct db_context * db , TDB_DATA key ,
void ( * parser ) ( TDB_DATA key , TDB_DATA data ,
void * private_data ) ,
void * private_data ) ;
2016-12-27 11:13:37 +03:00
/**
* Async implementation of dbwrap_parse_record
*
* @ param [ in ] mem_ctx talloc memory context to use .
*
* @ param [ in ] ev tevent context to use
*
* @ param [ in ] db Database to query
*
* @ param [ in ] key Record key , the function makes a copy of this
*
* @ param [ in ] parser Parser callback function
*
* @ param [ in ] private_data Private data for the callback function
*
* @ param [ out ] req_state Pointer to a enum dbwrap_req_state variable
*
* @ note req_state is updated in the send function . To determine the final
2023-03-31 12:10:03 +03:00
* result of the request the caller should therefore not rely on req_state . The
2016-12-27 11:13:37 +03:00
* primary use case is to give the caller an indication whether the request is
* already sent to ctdb ( DBWRAP_REQ_DISPATCHED ) or if it ' s still stuck in the
* sendqueue ( DBWRAP_REQ_QUEUED ) .
* */
struct tevent_req * dbwrap_parse_record_send (
TALLOC_CTX * mem_ctx ,
struct tevent_context * ev ,
struct db_context * db ,
TDB_DATA key ,
void ( * parser ) ( TDB_DATA key , TDB_DATA data , void * private_data ) ,
void * private_data ,
enum dbwrap_req_state * req_state ) ;
NTSTATUS dbwrap_parse_record_recv ( struct tevent_req * req ) ;
2011-08-16 16:39:19 +04:00
int dbwrap_wipe ( struct db_context * db ) ;
2012-06-22 09:37:43 +04:00
int dbwrap_check ( struct db_context * db ) ;
2011-08-18 16:09:56 +04:00
int dbwrap_get_seqnum ( struct db_context * db ) ;
2012-06-22 09:37:44 +04:00
/* Returns 0 if unknown. */
2011-08-18 00:51:12 +04:00
int dbwrap_transaction_start ( struct db_context * db ) ;
2012-06-22 09:37:44 +04:00
NTSTATUS dbwrap_transaction_start_nonblock ( struct db_context * db ) ;
2011-08-18 00:51:12 +04:00
int dbwrap_transaction_commit ( struct db_context * db ) ;
int dbwrap_transaction_cancel ( struct db_context * db ) ;
2015-09-20 17:26:06 +03:00
size_t dbwrap_db_id ( struct db_context * db , uint8_t * id , size_t idlen ) ;
2013-01-02 04:02:56 +04:00
bool dbwrap_is_persistent ( struct db_context * db ) ;
2012-06-22 09:37:44 +04:00
const char * dbwrap_name ( struct db_context * db ) ;
2011-08-17 10:45:09 +04:00
/* The following definitions come from lib/dbwrap_util.c */
2016-02-25 02:56:14 +03:00
NTSTATUS dbwrap_purge ( struct db_context * db , TDB_DATA key ) ;
NTSTATUS dbwrap_purge_bystring ( struct db_context * db , const char * key ) ;
2007-11-24 21:56:16 +03:00
NTSTATUS dbwrap_delete_bystring ( struct db_context * db , const char * key ) ;
NTSTATUS dbwrap_store_bystring ( struct db_context * db , const char * key ,
TDB_DATA data , int flags ) ;
2011-08-24 15:08:13 +04:00
NTSTATUS dbwrap_fetch_bystring ( struct db_context * db , TALLOC_CTX * mem_ctx ,
const char * key , TDB_DATA * value ) ;
r22775: For the cluster code I've developed a wrapper around tdb to put different
database backends in place dynamically.
The main abstractions are db_context and db_record, it should be mainly
self-describing, see include/dbwrap.h. You open the db just as you would open
a tdb, this time with db_open(). If you want to fetch a record, just do the
db->fetch() call, if you want to do operations on it, you need to get it with
fetch_locked().
I added dbwrap_file.c (not heavily tested lately) as an example for what can
be done with that abstraction, uses a file per key. So if anybody is willing
to shape that up, we might have a chance on reiserfs again.... :-)
This abstraction works fine for brlock.tdb, locking.tdb, connections.tdb and
sessionid.tdb. It should work fine for the others as well, I just did not yet
get around to convert them.
If nobody loudly screams NO, then I will import the code that uses this soon.
Volker
(This used to be commit e9d7484ca246cfca4a1fd23be35edc2783136ebe)
2007-05-10 14:42:13 +04:00
2012-06-15 12:52:07 +04:00
NTSTATUS dbwrap_fetch_int32 ( struct db_context * db , TDB_DATA key ,
int32_t * result ) ;
2012-06-14 22:26:28 +04:00
NTSTATUS dbwrap_fetch_int32_bystring ( struct db_context * db , const char * keystr ,
int32_t * result ) ;
2012-06-14 22:30:16 +04:00
NTSTATUS dbwrap_store_int32_bystring ( struct db_context * db , const char * keystr ,
int32_t v ) ;
2012-06-14 22:39:27 +04:00
NTSTATUS dbwrap_fetch_uint32_bystring ( struct db_context * db ,
const char * keystr , uint32_t * val ) ;
2012-06-15 11:09:57 +04:00
NTSTATUS dbwrap_store_uint32_bystring ( struct db_context * db ,
const char * keystr , uint32_t v ) ;
2012-06-15 11:18:17 +04:00
NTSTATUS dbwrap_change_uint32_atomic_bystring ( struct db_context * db ,
const char * keystr ,
uint32_t * oldval ,
uint32_t change_val ) ;
2012-06-15 11:20:25 +04:00
NTSTATUS dbwrap_trans_change_uint32_atomic_bystring ( struct db_context * db ,
const char * keystr ,
uint32_t * oldval ,
uint32_t change_val ) ;
2012-06-15 12:50:00 +04:00
NTSTATUS dbwrap_change_int32_atomic ( struct db_context * db ,
TDB_DATA key ,
int32_t * oldval ,
int32_t change_val ) ;
2012-06-15 11:43:13 +04:00
NTSTATUS dbwrap_change_int32_atomic_bystring ( struct db_context * db ,
const char * keystr ,
int32_t * oldval ,
int32_t change_val ) ;
2012-06-15 11:45:18 +04:00
NTSTATUS dbwrap_trans_change_int32_atomic_bystring ( struct db_context * db ,
const char * keystr ,
int32_t * oldval ,
int32_t change_val ) ;
2010-08-18 20:59:23 +04:00
NTSTATUS dbwrap_trans_store ( struct db_context * db , TDB_DATA key , TDB_DATA dbuf ,
int flag ) ;
NTSTATUS dbwrap_trans_delete ( struct db_context * db , TDB_DATA key ) ;
2012-06-15 11:48:20 +04:00
NTSTATUS dbwrap_trans_store_int32_bystring ( struct db_context * db ,
const char * keystr ,
int32_t v ) ;
2012-06-15 11:51:21 +04:00
NTSTATUS dbwrap_trans_store_uint32_bystring ( struct db_context * db ,
const char * keystr ,
uint32_t v ) ;
2010-08-18 20:59:23 +04:00
NTSTATUS dbwrap_trans_store_bystring ( struct db_context * db , const char * key ,
TDB_DATA data , int flags ) ;
NTSTATUS dbwrap_trans_delete_bystring ( struct db_context * db , const char * key ) ;
NTSTATUS dbwrap_trans_do ( struct db_context * db ,
NTSTATUS ( * action ) ( struct db_context * , void * ) ,
void * private_data ) ;
2011-03-16 11:13:40 +03:00
NTSTATUS dbwrap_trans_traverse ( struct db_context * db ,
int ( * f ) ( struct db_record * , void * ) ,
void * private_data ) ;
2011-03-18 16:39:15 +03:00
2010-08-18 20:59:23 +04:00
NTSTATUS dbwrap_delete_bystring_upper ( struct db_context * db , const char * key ) ;
NTSTATUS dbwrap_store_bystring_upper ( struct db_context * db , const char * key ,
TDB_DATA data , int flags ) ;
2011-08-24 15:08:13 +04:00
NTSTATUS dbwrap_fetch_bystring_upper ( struct db_context * db , TALLOC_CTX * mem_ctx ,
const char * key , TDB_DATA * value ) ;
2010-08-18 20:59:23 +04:00
2014-11-05 16:02:38 +03:00
size_t dbwrap_marshall ( struct db_context * db , uint8_t * buf , size_t bufsize ) ;
NTSTATUS dbwrap_parse_marshall_buf ( const uint8_t * buf , size_t buflen ,
bool ( * fn ) ( TDB_DATA key , TDB_DATA value ,
void * private_data ) ,
void * private_data ) ;
NTSTATUS dbwrap_unmarshall ( struct db_context * db , const uint8_t * buf ,
size_t buflen ) ;
2022-09-10 18:33:31 +03:00
NTSTATUS dbwrap_merge_dbufs ( TDB_DATA * buf , TALLOC_CTX * mem_ctx ,
2016-09-12 18:11:09 +03:00
const TDB_DATA * dbufs , int num_dbufs ) ;
2014-11-05 16:02:38 +03:00
2012-06-22 09:37:43 +04:00
/**
2015-03-12 16:40:43 +03:00
* This opens a tdb file
2012-06-22 09:37:43 +04:00
*/
struct db_context * dbwrap_local_open ( TALLOC_CTX * mem_ctx ,
const char * name ,
int hash_size , int tdb_flags ,
int open_flags , mode_t mode ,
2014-01-27 19:38:25 +04:00
enum dbwrap_lock_order lock_order ,
uint64_t dbwrap_flags ) ;
2012-06-22 09:37:43 +04:00
2007-11-07 22:18:38 +03:00
# endif /* __DBWRAP_H__ */