8478ca20d7b2621bd1f7ebaf1cd275351d66f329
[samba.git] / lib / tdb / include / tdb.h
1 #ifndef __TDB_H__
2 #define __TDB_H__
3
4 /* 
5    Unix SMB/CIFS implementation.
6
7    trivial database library
8
9    Copyright (C) Andrew Tridgell 1999-2004
10    
11      ** NOTE! The following LGPL license applies to the tdb
12      ** library. This does NOT imply that all of Samba is released
13      ** under the LGPL
14    
15    This library is free software; you can redistribute it and/or
16    modify it under the terms of the GNU Lesser General Public
17    License as published by the Free Software Foundation; either
18    version 3 of the License, or (at your option) any later version.
19
20    This library is distributed in the hope that it will be useful,
21    but WITHOUT ANY WARRANTY; without even the implied warranty of
22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23    Lesser General Public License for more details.
24
25    You should have received a copy of the GNU Lesser General Public
26    License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 */
28
29 #ifdef  __cplusplus
30 extern "C" {
31 #endif
32
33 #include <signal.h>
34 #include <stdbool.h>
35
36 /**
37  * @defgroup tdb The tdb API
38  *
39  * tdb is a Trivial database. In concept, it is very much like GDBM, and BSD's
40  * DB except that it allows multiple simultaneous writers and uses locking
41  * internally to keep writers from trampling on each other. tdb is also
42  * extremely small.
43  *
44  * @section tdb_interface Interface
45  *
46  * The interface is very similar to gdbm except for the following:
47  *
48  * <ul>
49  * <li>different open interface. The tdb_open call is more similar to a
50  * traditional open()</li>
51  * <li>no tdbm_reorganise() function</li>
52  * <li>no tdbm_sync() function. No operations are cached in the library
53  *     anyway</li>
54  * <li>added a tdb_traverse() function for traversing the whole database</li>
55  * <li>added transactions support</li>
56  * </ul>
57  *
58  * A general rule for using tdb is that the caller frees any returned TDB_DATA
59  * structures. Just call free(p.dptr) to free a TDB_DATA return value called p.
60  * This is the same as gdbm.
61  *
62  * @{
63  */
64
65 /** Flags to tdb_store() */
66 #define TDB_REPLACE 1           /** Unused */
67 #define TDB_INSERT 2            /** Don't overwrite an existing entry */
68 #define TDB_MODIFY 3            /** Don't create an existing entry    */
69
70 /** Flags for tdb_open() */
71 #define TDB_DEFAULT 0 /** just a readability place holder */
72 #define TDB_CLEAR_IF_FIRST 1 /** If this is the first open, wipe the db */
73 #define TDB_INTERNAL 2 /** Don't store on disk */
74 #define TDB_NOLOCK   4 /** Don't do any locking */
75 #define TDB_NOMMAP   8 /** Don't use mmap */
76 #define TDB_CONVERT 16 /** Convert endian (internal use) */
77 #define TDB_BIGENDIAN 32 /** Header is big-endian (internal use) */
78 #define TDB_NOSYNC   64 /** Don't use synchronous transactions */
79 #define TDB_SEQNUM   128 /** Maintain a sequence number */
80 #define TDB_VOLATILE   256 /** Activate the per-hashchain freelist, default 5 */
81 #define TDB_ALLOW_NESTING 512 /** Allow transactions to nest */
82 #define TDB_DISALLOW_NESTING 1024 /** Disallow transactions to nest */
83 #define TDB_INCOMPATIBLE_HASH 2048 /** Better hashing: can't be opened by tdb < 1.2.6. */
84 #define TDB_MUTEX_LOCKING 4096 /** optimized locking using robust mutexes if supported,
85                                    only with tdb >= 1.3.0 and TDB_CLEAR_IF_FIRST
86                                    after checking tdb_runtime_check_for_robust_mutexes() */
87
88 /** The tdb error codes */
89 enum TDB_ERROR {TDB_SUCCESS=0, TDB_ERR_CORRUPT, TDB_ERR_IO, TDB_ERR_LOCK, 
90                 TDB_ERR_OOM, TDB_ERR_EXISTS, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT,
91                 TDB_ERR_NOEXIST, TDB_ERR_EINVAL, TDB_ERR_RDONLY,
92                 TDB_ERR_NESTING};
93
94 /** Debugging uses one of the following levels */
95 enum tdb_debug_level {TDB_DEBUG_FATAL = 0, TDB_DEBUG_ERROR, 
96                       TDB_DEBUG_WARNING, TDB_DEBUG_TRACE};
97
98 /** The tdb data structure */
99 typedef struct TDB_DATA {
100         unsigned char *dptr;
101         size_t dsize;
102 } TDB_DATA;
103
104 #ifndef PRINTF_ATTRIBUTE
105 #if (__GNUC__ >= 3)
106 /** Use gcc attribute to check printf fns.  a1 is the 1-based index of
107  * the parameter containing the format, and a2 the index of the first
108  * argument. Note that some gcc 2.x versions don't handle this
109  * properly **/
110 #define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
111 #else
112 #define PRINTF_ATTRIBUTE(a1, a2)
113 #endif
114 #endif
115
116 /** This is the context structure that is returned from a db open. */
117 typedef struct tdb_context TDB_CONTEXT;
118
119 typedef int (*tdb_traverse_func)(struct tdb_context *, TDB_DATA, TDB_DATA, void *);
120 typedef void (*tdb_log_func)(struct tdb_context *, enum tdb_debug_level, const char *, ...) PRINTF_ATTRIBUTE(3, 4);
121 typedef unsigned int (*tdb_hash_func)(TDB_DATA *key);
122
123 struct tdb_logging_context {
124         tdb_log_func log_fn;
125         void *log_private;
126 };
127
128 /**
129  * @brief Open the database and creating it if necessary.
130  *
131  * @param[in]  name     The name of the db to open.
132  *
133  * @param[in]  hash_size The hash size is advisory, use zero for a default
134  *                       value.
135  *
136  * @param[in]  tdb_flags The flags to use to open the db:\n\n
137  *                         TDB_CLEAR_IF_FIRST - Clear database if we are the
138  *                                              only one with it open\n
139  *                         TDB_INTERNAL - Don't use a file, instead store the
140  *                                        data in memory. The filename is
141  *                                        ignored in this case.\n
142  *                         TDB_NOLOCK - Don't do any locking\n
143  *                         TDB_NOMMAP - Don't use mmap\n
144  *                         TDB_NOSYNC - Don't synchronise transactions to disk\n
145  *                         TDB_SEQNUM - Maintain a sequence number\n
146  *                         TDB_VOLATILE - activate the per-hashchain freelist,
147  *                                        default 5.\n
148  *                         TDB_ALLOW_NESTING - Allow transactions to nest.\n
149  *                         TDB_DISALLOW_NESTING - Disallow transactions to nest.\n
150  *                         TDB_INCOMPATIBLE_HASH - Better hashing: can't be opened by tdb < 1.2.6.\n
151  *                         TDB_MUTEX_LOCKING - Optimized locking using robust mutexes if supported,
152  *                                             can't be opened by tdb < 1.3.0.
153  *                                             Only valid in combination with TDB_CLEAR_IF_FIRST
154  *                                             after checking tdb_runtime_check_for_robust_mutexes()\n
155  *
156  * @param[in]  open_flags Flags for the open(2) function.
157  *
158  * @param[in]  mode     The mode for the open(2) function.
159  *
160  * @return              A tdb context structure, NULL on error.
161  */
162 struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
163                       int open_flags, mode_t mode);
164
165 /**
166  * @brief Open the database and creating it if necessary.
167  *
168  * This is like tdb_open(), but allows you to pass an initial logging and
169  * hash function. Be careful when passing a hash function - all users of the
170  * database must use the same hash function or you will get data corruption.
171  *
172  * @param[in]  name     The name of the db to open.
173  *
174  * @param[in]  hash_size The hash size is advisory, use zero for a default
175  *                       value.
176  *
177  * @param[in]  tdb_flags The flags to use to open the db:\n\n
178  *                         TDB_CLEAR_IF_FIRST - Clear database if we are the
179  *                                              only one with it open\n
180  *                         TDB_INTERNAL - Don't use a file, instead store the
181  *                                        data in memory. The filename is
182  *                                        ignored in this case.\n
183  *                         TDB_NOLOCK - Don't do any locking\n
184  *                         TDB_NOMMAP - Don't use mmap\n
185  *                         TDB_NOSYNC - Don't synchronise transactions to disk\n
186  *                         TDB_SEQNUM - Maintain a sequence number\n
187  *                         TDB_VOLATILE - activate the per-hashchain freelist,
188  *                                        default 5.\n
189  *                         TDB_ALLOW_NESTING - Allow transactions to nest.\n
190  *                         TDB_DISALLOW_NESTING - Disallow transactions to nest.\n
191  *                         TDB_INCOMPATIBLE_HASH - Better hashing: can't be opened by tdb < 1.2.6.\n
192  *                         TDB_MUTEX_LOCKING - Optimized locking using robust mutexes if supported,
193  *                                             can't be opened by tdb < 1.3.0.
194  *                                             Only valid in combination with TDB_CLEAR_IF_FIRST
195  *                                             after checking tdb_runtime_check_for_robust_mutexes()\n
196  *
197  * @param[in]  open_flags Flags for the open(2) function.
198  *
199  * @param[in]  mode     The mode for the open(2) function.
200  *
201  * @param[in]  log_ctx  The logging function to use.
202  *
203  * @param[in]  hash_fn  The hash function you want to use.
204  *
205  * @return              A tdb context structure, NULL on error.
206  *
207  * @see tdb_open()
208  */
209 struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
210                          int open_flags, mode_t mode,
211                          const struct tdb_logging_context *log_ctx,
212                          tdb_hash_func hash_fn);
213
214 /**
215  * @brief Set the maximum number of dead records per hash chain.
216  *
217  * @param[in]  tdb      The database handle to set the maximum.
218  *
219  * @param[in]  max_dead The maximum number of dead records per hash chain.
220  */
221 void tdb_set_max_dead(struct tdb_context *tdb, int max_dead);
222
223 /**
224  * @brief Reopen a tdb.
225  *
226  * This can be used after a fork to ensure that we have an independent seek
227  * pointer from our parent and to re-establish locks.
228  *
229  * @param[in]  tdb      The database to reopen. It will be free'd on error!
230  *
231  * @return              0 on success, -1 on error.
232  *
233  * @note Don't call tdb_error() after this function cause the tdb context will
234  *       be freed on error.
235  */
236 int tdb_reopen(struct tdb_context *tdb);
237
238 /**
239  * @brief Reopen all tdb's
240  *
241  * If the parent is longlived (ie. a parent daemon architecture), we know it
242  * will keep it's active lock on a tdb opened with CLEAR_IF_FIRST. Thus for
243  * child processes we don't have to add an active lock. This is essential to
244  * improve performance on systems that keep POSIX locks as a non-scalable data
245  * structure in the kernel.
246  *
247  * @param[in]  parent_longlived Wether the parent is longlived or not.
248  *
249  * @return              0 on success, -1 on error.
250  */
251 int tdb_reopen_all(int parent_longlived);
252
253 /**
254  * @brief Set a different tdb logging function.
255  *
256  * @param[in]  tdb      The tdb to set the logging function.
257  *
258  * @param[in]  log_ctx  The logging function to set.
259  */
260 void tdb_set_logging_function(struct tdb_context *tdb, const struct tdb_logging_context *log_ctx);
261
262 /**
263  * @brief Get the tdb last error code.
264  *
265  * @param[in]  tdb      The tdb to get the error code from.
266  *
267  * @return              A TDB_ERROR code.
268  *
269  * @see TDB_ERROR
270  */
271 enum TDB_ERROR tdb_error(struct tdb_context *tdb);
272
273 /**
274  * @brief Get a error string for the last tdb error
275  *
276  * @param[in]  tdb      The tdb to get the error code from.
277  *
278  * @return              An error string.
279  */
280 const char *tdb_errorstr(struct tdb_context *tdb);
281
282 /**
283  * @brief Fetch an entry in the database given a key.
284  *
285  * The caller must free the resulting data.
286  *
287  * @param[in]  tdb      The tdb to fetch the key.
288  *
289  * @param[in]  key      The key to fetch.
290  *
291  * @return              The key entry found in the database, NULL on error with
292  *                      TDB_ERROR set.
293  *
294  * @see tdb_error()
295  * @see tdb_errorstr()
296  */
297 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key);
298
299 /**
300  * @brief Hand a record to a parser function without allocating it.
301  *
302  * This function is meant as a fast tdb_fetch alternative for large records
303  * that are frequently read. The "key" and "data" arguments point directly
304  * into the tdb shared memory, they are not aligned at any boundary.
305  *
306  * @warning The parser is called while tdb holds a lock on the record. DO NOT
307  * call other tdb routines from within the parser. Also, for good performance
308  * you should make the parser fast to allow parallel operations.
309  *
310  * @param[in]  tdb      The tdb to parse the record.
311  *
312  * @param[in]  key      The key to parse.
313  *
314  * @param[in]  parser   The parser to use to parse the data.
315  *
316  * @param[in]  private_data A private data pointer which is passed to the parser
317  *                          function.
318  *
319  * @return              -1 if the record was not found. If the record was found,
320  *                      the return value of "parser" is passed up to the caller.
321  */
322 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
323                               int (*parser)(TDB_DATA key, TDB_DATA data,
324                                             void *private_data),
325                               void *private_data);
326
327 /**
328  * @brief Delete an entry in the database given a key.
329  *
330  * @param[in]  tdb      The tdb to delete the key.
331  *
332  * @param[in]  key      The key to delete.
333  *
334  * @return              0 on success, -1 if the key doesn't exist.
335  */
336 int tdb_delete(struct tdb_context *tdb, TDB_DATA key);
337
338 /**
339  * @brief Store an element in the database.
340  *
341  * This replaces any existing element with the same key.
342  *
343  * @param[in]  tdb      The tdb to store the entry.
344  *
345  * @param[in]  key      The key to use to store the entry.
346  *
347  * @param[in]  dbuf     The data to store under the key.
348  *
349  * @param[in]  flag     The flags to store the key:\n\n
350  *                      TDB_INSERT: Don't overwrite an existing entry.\n
351  *                      TDB_MODIFY: Don't create a new entry\n
352  *
353  * @return              0 on success, -1 on error with error code set.
354  *
355  * @see tdb_error()
356  * @see tdb_errorstr()
357  */
358 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
359
360 /**
361  * @brief Append data to an entry.
362  *
363  * If the entry doesn't exist, it will create a new one.
364  *
365  * @param[in]  tdb      The database to use.
366  *
367  * @param[in]  key      The key to append the data.
368  *
369  * @param[in]  new_dbuf The data to append to the key.
370  *
371  * @return              0 on success, -1 on error with error code set.
372  *
373  * @see tdb_error()
374  * @see tdb_errorstr()
375  */
376 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf);
377
378 /**
379  * @brief Close a database.
380  *
381  * @param[in]  tdb      The database to close. The context will be free'd.
382  *
383  * @return              0 for success, -1 on error.
384  *
385  * @note Don't call tdb_error() after this function cause the tdb context will
386  *       be freed on error.
387  */
388 int tdb_close(struct tdb_context *tdb);
389
390 /**
391  * @brief Find the first entry in the database and return its key.
392  *
393  * The caller must free the returned data.
394  *
395  * @param[in]  tdb      The database to use.
396  *
397  * @return              The first entry of the database, an empty TDB_DATA entry
398  *                      if the database is empty.
399  */
400 TDB_DATA tdb_firstkey(struct tdb_context *tdb);
401
402 /**
403  * @brief Find the next entry in the database, returning its key.
404  *
405  * The caller must free the returned data.
406  *
407  * @param[in]  tdb      The database to use.
408  *
409  * @param[in]  key      The key from which you want the next key.
410  *
411  * @return              The next entry of the current key, an empty TDB_DATA
412  *                      entry if there is no entry.
413  */
414 TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA key);
415
416 /**
417  * @brief Traverse the entire database.
418  *
419  * While traversing the function fn(tdb, key, data, state) is called on each
420  * element. If fn is NULL then it is not called. A non-zero return value from
421  * fn() indicates that the traversal should stop. Traversal callbacks may not
422  * start transactions.
423  *
424  * @warning The data buffer given to the callback fn does NOT meet the alignment
425  * restrictions malloc gives you.
426  *
427  * @param[in]  tdb      The database to traverse.
428  *
429  * @param[in]  fn       The function to call on each entry.
430  *
431  * @param[in]  private_data The private data which should be passed to the
432  *                          traversing function.
433  *
434  * @return              The record count traversed, -1 on error.
435  */
436 int tdb_traverse(struct tdb_context *tdb, tdb_traverse_func fn, void *private_data);
437
438 /**
439  * @brief Traverse the entire database.
440  *
441  * While traversing the database the function fn(tdb, key, data, state) is
442  * called on each element, but marking the database read only during the
443  * traversal, so any write operations will fail. This allows tdb to use read
444  * locks, which increases the parallelism possible during the traversal.
445  *
446  * @param[in]  tdb      The database to traverse.
447  *
448  * @param[in]  fn       The function to call on each entry.
449  *
450  * @param[in]  private_data The private data which should be passed to the
451  *                          traversing function.
452  *
453  * @return              The record count traversed, -1 on error.
454  */
455 int tdb_traverse_read(struct tdb_context *tdb, tdb_traverse_func fn, void *private_data);
456
457 /**
458  * @brief Check if an entry in the database exists.
459  *
460  * @note 1 is returned if the key is found and 0 is returned if not found this
461  * doesn't match the conventions in the rest of this module, but is compatible
462  * with gdbm.
463  *
464  * @param[in]  tdb      The database to check if the entry exists.
465  *
466  * @param[in]  key      The key to check if the entry exists.
467  *
468  * @return              1 if the key is found, 0 if not.
469  */
470 int tdb_exists(struct tdb_context *tdb, TDB_DATA key);
471
472 /**
473  * @brief Lock entire database with a write lock.
474  *
475  * @param[in]  tdb      The database to lock.
476  *
477  * @return              0 on success, -1 on error with error code set.
478  *
479  * @see tdb_error()
480  * @see tdb_errorstr()
481  */
482 int tdb_lockall(struct tdb_context *tdb);
483
484 /**
485  * @brief Lock entire database with a write lock.
486  *
487  * This is the non-blocking call.
488  *
489  * @param[in]  tdb      The database to lock.
490  *
491  * @return              0 on success, -1 on error with error code set.
492  *
493  * @see tdb_lockall()
494  * @see tdb_error()
495  * @see tdb_errorstr()
496  */
497 int tdb_lockall_nonblock(struct tdb_context *tdb);
498
499 /**
500  * @brief Unlock entire database with write lock.
501  *
502  * @param[in]  tdb      The database to unlock.
503  *
504  * @return              0 on success, -1 on error with error code set.
505  *
506  * @see tdb_lockall()
507  * @see tdb_error()
508  * @see tdb_errorstr()
509  */
510 int tdb_unlockall(struct tdb_context *tdb);
511
512 /**
513  * @brief Lock entire database with a read lock.
514  *
515  * @param[in]  tdb      The database to lock.
516  *
517  * @return              0 on success, -1 on error with error code set.
518  *
519  * @see tdb_error()
520  * @see tdb_errorstr()
521  */
522 int tdb_lockall_read(struct tdb_context *tdb);
523
524 /**
525  * @brief Lock entire database with a read lock.
526  *
527  * This is the non-blocking call.
528  *
529  * @param[in]  tdb      The database to lock.
530  *
531  * @return              0 on success, -1 on error with error code set.
532  *
533  * @see tdb_lockall_read()
534  * @see tdb_error()
535  * @see tdb_errorstr()
536  */
537 int tdb_lockall_read_nonblock(struct tdb_context *tdb);
538
539 /**
540  * @brief Unlock entire database with read lock.
541  *
542  * @param[in]  tdb      The database to unlock.
543  *
544  * @return              0 on success, -1 on error with error code set.
545  *
546  * @see tdb_lockall_read()
547  * @see tdb_error()
548  * @see tdb_errorstr()
549  */
550 int tdb_unlockall_read(struct tdb_context *tdb);
551
552 /**
553  * @brief Lock entire database with write lock - mark only.
554  *
555  * @todo Add more details.
556  *
557  * @param[in]  tdb      The database to mark.
558  *
559  * @return              0 on success, -1 on error with error code set.
560  *
561  * @see tdb_error()
562  * @see tdb_errorstr()
563  */
564 int tdb_lockall_mark(struct tdb_context *tdb);
565
566 /**
567  * @brief Lock entire database with write lock - unmark only.
568  *
569  * @todo Add more details.
570  *
571  * @param[in]  tdb      The database to mark.
572  *
573  * @return              0 on success, -1 on error with error code set.
574  *
575  * @see tdb_error()
576  * @see tdb_errorstr()
577  */
578 int tdb_lockall_unmark(struct tdb_context *tdb);
579
580 /**
581  * @brief Get the name of the current tdb file.
582  *
583  * This is useful for external logging functions.
584  *
585  * @param[in]  tdb      The database to get the name from.
586  *
587  * @return              The name of the database.
588  */
589 const char *tdb_name(struct tdb_context *tdb);
590
591 /**
592  * @brief Get the underlying file descriptor being used by tdb.
593  *
594  * This is useful for external routines that want to check the device/inode
595  * of the fd.
596  *
597  * @param[in]  tdb      The database to get the fd from.
598  *
599  * @return              The file descriptor or -1.
600  */
601 int tdb_fd(struct tdb_context *tdb);
602
603 /**
604  * @brief Get the current logging function.
605  *
606  * This is useful for external tdb routines that wish to log tdb errors.
607  *
608  * @param[in]  tdb      The database to get the logging function from.
609  *
610  * @return              The logging function of the database.
611  *
612  * @see tdb_get_logging_private()
613  */
614 tdb_log_func tdb_log_fn(struct tdb_context *tdb);
615
616 /**
617  * @brief Get the private data of the logging function.
618  *
619  * @param[in]  tdb      The database to get the data from.
620  *
621  * @return              The private data pointer of the logging function.
622  *
623  * @see tdb_log_fn()
624  */
625 void *tdb_get_logging_private(struct tdb_context *tdb);
626
627 /**
628  * @brief Start a transaction.
629  *
630  * All operations after the transaction start can either be committed with
631  * tdb_transaction_commit() or cancelled with tdb_transaction_cancel().
632  *
633  * If you call tdb_transaction_start() again on the same tdb context while a
634  * transaction is in progress, then the same transaction buffer is re-used. The
635  * number of tdb_transaction_{commit,cancel} operations must match the number
636  * of successful tdb_transaction_start() calls.
637  *
638  * Note that transactions are by default disk synchronous, and use a recover
639  * area in the database to automatically recover the database on the next open
640  * if the system crashes during a transaction. You can disable the synchronous
641  * transaction recovery setup using the TDB_NOSYNC flag, which will greatly
642  * speed up operations at the risk of corrupting your database if the system
643  * crashes.
644  *
645  * Operations made within a transaction are not visible to other users of the
646  * database until a successful commit.
647  *
648  * @param[in]  tdb      The database to start the transaction.
649  *
650  * @return              0 on success, -1 on error with error code set.
651  *
652  * @see tdb_error()
653  * @see tdb_errorstr()
654  */
655 int tdb_transaction_start(struct tdb_context *tdb);
656
657 /**
658  * @brief Start a transaction, non-blocking.
659  *
660  * @param[in]  tdb      The database to start the transaction.
661  *
662  * @return              0 on success, -1 on error with error code set.
663  *
664  * @see tdb_error()
665  * @see tdb_errorstr()
666  * @see tdb_transaction_start()
667  */
668 int tdb_transaction_start_nonblock(struct tdb_context *tdb);
669
670 /**
671  * @brief Prepare to commit a current transaction, for two-phase commits.
672  *
673  * Once prepared for commit, the only allowed calls are tdb_transaction_commit()
674  * or tdb_transaction_cancel(). Preparing allocates disk space for the pending
675  * updates, so a subsequent commit should succeed (barring any hardware
676  * failures).
677  *
678  * @param[in]  tdb      The database to prepare the commit.
679  *
680  * @return              0 on success, -1 on error with error code set.
681  *
682  * @see tdb_error()
683  * @see tdb_errorstr()
684  */
685 int tdb_transaction_prepare_commit(struct tdb_context *tdb);
686
687 /**
688  * @brief Commit a current transaction.
689  *
690  * This updates the database and releases the current transaction locks.
691  *
692  * @param[in]  tdb      The database to commit the transaction.
693  *
694  * @return              0 on success, -1 on error with error code set.
695  *
696  * @see tdb_error()
697  * @see tdb_errorstr()
698  */
699 int tdb_transaction_commit(struct tdb_context *tdb);
700
701 /**
702  * @brief Cancel a current transaction.
703  *
704  * This discards all write and lock operations that have been made since the
705  * transaction started.
706  *
707  * @param[in]  tdb      The tdb to cancel the transaction on.
708  *
709  * @return              0 on success, -1 on error with error code set.
710  *
711  * @see tdb_error()
712  * @see tdb_errorstr()
713  */
714 int tdb_transaction_cancel(struct tdb_context *tdb);
715
716 /**
717  * @brief Get the tdb sequence number.
718  *
719  * Only makes sense if the writers opened with TDB_SEQNUM set. Note that this
720  * sequence number will wrap quite quickly, so it should only be used for a
721  * 'has something changed' test, not for code that relies on the count of the
722  * number of changes made. If you want a counter then use a tdb record.
723  *
724  * The aim of this sequence number is to allow for a very lightweight test of a
725  * possible tdb change.
726  *
727  * @param[in]  tdb      The database to get the sequence number from.
728  *
729  * @return              The sequence number or 0.
730  *
731  * @see tdb_open()
732  * @see tdb_enable_seqnum()
733  */
734 int tdb_get_seqnum(struct tdb_context *tdb);
735
736 /**
737  * @brief Get the hash size.
738  *
739  * @param[in]  tdb      The database to get the hash size from.
740  *
741  * @return              The hash size.
742  */
743 int tdb_hash_size(struct tdb_context *tdb);
744
745 /**
746  * @brief Get the map size.
747  *
748  * @param[in]  tdb     The database to get the map size from.
749  *
750  * @return             The map size.
751  */
752 size_t tdb_map_size(struct tdb_context *tdb);
753
754 /**
755  * @brief Get the tdb flags set during open.
756  *
757  * @param[in]  tdb      The database to get the flags form.
758  *
759  * @return              The flags set to on the database.
760  */
761 int tdb_get_flags(struct tdb_context *tdb);
762
763 /**
764  * @brief Add flags to the database.
765  *
766  * @param[in]  tdb      The database to add the flags.
767  *
768  * @param[in]  flag     The tdb flags to add.
769  */
770 void tdb_add_flags(struct tdb_context *tdb, unsigned flag);
771
772 /**
773  * @brief Remove flags from the database.
774  *
775  * @param[in]  tdb      The database to remove the flags.
776  *
777  * @param[in]  flag     The tdb flags to remove.
778  */
779 void tdb_remove_flags(struct tdb_context *tdb, unsigned flag);
780
781 /**
782  * @brief Enable sequence number handling on an open tdb.
783  *
784  * @param[in]  tdb      The database to enable sequence number handling.
785  *
786  * @see tdb_get_seqnum()
787  */
788 void tdb_enable_seqnum(struct tdb_context *tdb);
789
790 /**
791  * @brief Increment the tdb sequence number.
792  *
793  * This only works if the tdb has been opened using the TDB_SEQNUM flag or
794  * enabled using tdb_enable_seqnum().
795  *
796  * @param[in]  tdb      The database to increment the sequence number.
797  *
798  * @see tdb_enable_seqnum()
799  * @see tdb_get_seqnum()
800  */
801 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb);
802
803 /**
804  * @brief Create a hash of the key.
805  *
806  * @param[in]  key      The key to hash
807  *
808  * @return              The hash.
809  */
810 unsigned int tdb_jenkins_hash(TDB_DATA *key);
811
812 /**
813  * @brief Check the consistency of the database.
814  *
815  * This check the consistency of the database calling back the check function
816  * (if non-NULL) on each record.  If some consistency check fails, or the
817  * supplied check function returns -1, tdb_check returns -1, otherwise 0.
818  *
819  * @note The logging function (if set) will be called with additional
820  * information on the corruption found.
821  *
822  * @param[in]  tdb      The database to check.
823  *
824  * @param[in]  check    The check function to use.
825  *
826  * @param[in]  private_data the private data to pass to the check function.
827  *
828  * @return              0 on success, -1 on error with error code set.
829  *
830  * @see tdb_error()
831  * @see tdb_errorstr()
832  */
833 int tdb_check(struct tdb_context *tdb,
834               int (*check) (TDB_DATA key, TDB_DATA data, void *private_data),
835               void *private_data);
836
837 /**
838  * @brief Dump all possible records in a corrupt database.
839  *
840  * This is the only way to get data out of a database where tdb_check() fails.
841  * It will call walk() with anything which looks like a database record; this
842  * may well include invalid, incomplete or duplicate records.
843  *
844  * @param[in]  tdb      The database to check.
845  *
846  * @param[in]  walk     The walk function to use.
847  *
848  * @param[in]  private_data the private data to pass to the walk function.
849  *
850  * @return              0 on success, -1 on error with error code set.
851  *
852  * @see tdb_error()
853  * @see tdb_errorstr()
854  */
855 int tdb_rescue(struct tdb_context *tdb,
856                void (*walk) (TDB_DATA key, TDB_DATA data, void *private_data),
857                void *private_data);
858
859 /**
860  * @brief Check if support for TDB_MUTEX_LOCKING is available at runtime.
861  *
862  * On some systems the API for pthread_mutexattr_setrobust() is not available.
863  * On other systems there are some bugs in the interaction between glibc and
864  * the linux kernel.
865  *
866  * This function provides a runtime check if robust mutexes are really
867  * available.
868  *
869  * This needs to be called and return true before TDB_MUTEX_LOCKING
870  * can be used at runtime.
871  *
872  * @note This calls fork(), but the SIGCHILD handling should be transparent.
873  *
874  * @return              true if supported, false otherwise.
875  *
876  * @see TDB_MUTEX_LOCKING
877  */
878 bool tdb_runtime_check_for_robust_mutexes(void);
879
880 /* @} ******************************************************************/
881
882 /* Low level locking functions: use with care */
883 int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key);
884 int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key);
885 int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key);
886 int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
887 int tdb_chainlock_read_nonblock(struct tdb_context *tdb, TDB_DATA key);
888 int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
889 int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key);
890 int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key);
891
892 void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *sigptr);
893
894 /* wipe and repack */
895 int tdb_wipe_all(struct tdb_context *tdb);
896 int tdb_repack(struct tdb_context *tdb);
897
898 /* Debug functions. Not used in production. */
899 void tdb_dump_all(struct tdb_context *tdb);
900 int tdb_printfreelist(struct tdb_context *tdb);
901 int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries);
902 int tdb_freelist_size(struct tdb_context *tdb);
903 char *tdb_summary(struct tdb_context *tdb);
904
905 extern TDB_DATA tdb_null;
906
907 #ifdef  __cplusplus
908 }
909 #endif
910
911 #endif /* tdb.h */