ntdb: simply disallow NULL names.
[kai/samba-autobuild/.git] / lib / ntdb / ntdb.h
1 #ifndef CCAN_NTDB_H
2 #define CCAN_NTDB_H
3
4 /*
5    NTDB: trivial database library version 2
6
7    Copyright (C) Andrew Tridgell 1999-2004
8    Copyright (C) Rusty Russell 2010-2012
9
10      ** NOTE! The following LGPL license applies to the ntdb
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13
14    This library is free software; you can redistribute it and/or
15    modify it under the terms of the GNU Lesser General Public
16    License as published by the Free Software Foundation; either
17    version 3 of the License, or (at your option) any later version.
18
19    This library is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22    Lesser General Public License for more details.
23
24    You should have received a copy of the GNU Lesser General Public
25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 */
27
28 #ifdef  __cplusplus
29 extern "C" {
30 #endif
31
32 #ifdef HAVE_LIBREPLACE
33 #include <replace.h>
34 #else
35 #if HAVE_FILE_OFFSET_BITS
36 #define _FILE_OFFSET_BITS 64
37 #endif
38 /* For mode_t */
39 #include <sys/types.h>
40 /* For O_* flags. */
41 #include <sys/stat.h>
42 /* For sig_atomic_t. */
43 #include <signal.h>
44 /* For uint64_t */
45 #include <stdint.h>
46 /* For bool */
47 #include <stdbool.h>
48 /* For memcmp */
49 #include <string.h>
50 #endif
51
52 #if HAVE_CCAN
53 #include <ccan/compiler/compiler.h>
54 #include <ccan/typesafe_cb/typesafe_cb.h>
55 #include <ccan/cast/cast.h>
56 #else
57 #ifndef typesafe_cb_preargs
58 /* Failing to have CCAN just mean less typesafe protection, etc. */
59 #define typesafe_cb_preargs(rtype, atype, fn, arg, ...) \
60         ((rtype (*)(__VA_ARGS__, atype))(fn))
61 #endif
62 #ifndef cast_const
63 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
64 #define cast_const(type, expr) ((type)((intptr_t)(expr)))
65 #else
66 #define cast_const(type, expr) ((type *)(expr))
67 #endif
68 #endif
69 #endif /* !HAVE_CCAN */
70
71 union ntdb_attribute;
72 struct ntdb_context;
73
74 /**
75  * struct TDB_DATA - (n)tdb data blob
76  *
77  * To ease compatibility, we use 'struct TDB_DATA' from tdb.h, so if
78  * you want to include both tdb.h and ntdb.h, you need to #include
79  * tdb.h first.
80  */
81 #ifndef __TDB_H__
82 struct TDB_DATA {
83         unsigned char *dptr;
84         size_t dsize;
85 };
86 #endif
87
88 typedef struct TDB_DATA NTDB_DATA;
89
90 /**
91  * ntdb_open - open a database file
92  * @name: the file name (or database name if flags contains NTDB_INTERNAL)
93  * @ntdb_flags: options for this database
94  * @open_flags: flags argument for ntdb's open() call.
95  * @mode: mode argument for ntdb's open() call.
96  * @attributes: linked list of extra attributes for this ntdb.
97  *
98  * This call opens (and potentially creates) a database file.
99  * Multiple processes can have the NTDB file open at once.
100  *
101  * On failure it will return NULL, and set errno: it may also call
102  * any log attribute found in @attributes.
103  *
104  * See also:
105  *      union ntdb_attribute
106  */
107 struct ntdb_context *ntdb_open(const char *name, int ntdb_flags,
108                                int open_flags, mode_t mode,
109                                union ntdb_attribute *attributes);
110
111
112 /* flags for ntdb_open() */
113 #define NTDB_DEFAULT 0 /* just a readability place holder */
114 #define NTDB_INTERNAL 2 /* don't store on disk */
115 #define NTDB_NOLOCK   4 /* don't do any locking */
116 #define NTDB_NOMMAP   8 /* don't use mmap */
117 #define NTDB_CONVERT 16 /* convert endian */
118 #define NTDB_NOSYNC   64 /* don't use synchronous transactions */
119 #define NTDB_SEQNUM   128 /* maintain a sequence number */
120 #define NTDB_ALLOW_NESTING   256 /* fake nested transactions */
121 #define NTDB_RDONLY   512 /* implied by O_RDONLY */
122 #define NTDB_CANT_CHECK  2048 /* has a feature which we don't understand */
123
124 /**
125  * ntdb_close - close and free a ntdb.
126  * @ntdb: the ntdb context returned from ntdb_open()
127  *
128  * This always succeeds, in that @ntdb is unusable after this call.  But if
129  * some unexpected error occurred while closing, it will return non-zero
130  * (the only clue as to cause will be via the log attribute).
131  */
132 int ntdb_close(struct ntdb_context *ntdb);
133
134 /**
135  * enum NTDB_ERROR - error returns for NTDB
136  *
137  * See Also:
138  *      ntdb_errorstr()
139  */
140 enum NTDB_ERROR {
141         NTDB_SUCCESS    = 0,    /* No error. */
142         NTDB_ERR_CORRUPT = -1,  /* We read the db, and it was bogus. */
143         NTDB_ERR_IO     = -2,   /* We couldn't read/write the db. */
144         NTDB_ERR_LOCK   = -3,   /* Locking failed. */
145         NTDB_ERR_OOM    = -4,   /* Out of Memory. */
146         NTDB_ERR_EXISTS = -5,   /* The key already exists. */
147         NTDB_ERR_NOEXIST        = -6,   /* The key does not exist. */
148         NTDB_ERR_EINVAL = -7,   /* You're using it wrong. */
149         NTDB_ERR_RDONLY = -8,   /* The database is read-only. */
150         NTDB_ERR_LAST = NTDB_ERR_RDONLY
151 };
152
153 /**
154  * ntdb_store - store a key/value pair in a ntdb.
155  * @ntdb: the ntdb context returned from ntdb_open()
156  * @key: the key
157  * @dbuf: the data to associate with the key.
158  * @flag: NTDB_REPLACE, NTDB_INSERT or NTDB_MODIFY.
159  *
160  * This inserts (or overwrites) a key/value pair in the NTDB.  If flag
161  * is NTDB_REPLACE, it doesn't matter whether the key exists or not;
162  * NTDB_INSERT means it must not exist (returns NTDB_ERR_EXISTS otherwise),
163  * and NTDB_MODIFY means it must exist (returns NTDB_ERR_NOEXIST otherwise).
164  *
165  * On success, this returns NTDB_SUCCESS.
166  *
167  * See also:
168  *      ntdb_fetch, ntdb_transaction_start, ntdb_append, ntdb_delete.
169  */
170 enum NTDB_ERROR ntdb_store(struct ntdb_context *ntdb,
171                            NTDB_DATA key,
172                            NTDB_DATA dbuf,
173                            int flag);
174
175 /* flags to ntdb_store() */
176 #define NTDB_REPLACE 1          /* A readability place holder */
177 #define NTDB_INSERT 2           /* Don't overwrite an existing entry */
178 #define NTDB_MODIFY 3           /* Don't create an existing entry    */
179
180 /**
181  * ntdb_fetch - fetch a value from a ntdb.
182  * @ntdb: the ntdb context returned from ntdb_open()
183  * @key: the key
184  * @data: pointer to data.
185  *
186  * This looks up a key in the database and sets it in @data.
187  *
188  * If it returns NTDB_SUCCESS, the key was found: it is your
189  * responsibility to call free() on @data->dptr.
190  *
191  * Otherwise, it returns an error (usually, NTDB_ERR_NOEXIST) and @data is
192  * undefined.
193  */
194 enum NTDB_ERROR ntdb_fetch(struct ntdb_context *ntdb, NTDB_DATA key,
195                            NTDB_DATA *data);
196
197 /**
198  * ntdb_errorstr - map the ntdb error onto a constant readable string
199  * @ecode: the enum NTDB_ERROR to map.
200  *
201  * This is useful for displaying errors to users.
202  */
203 const char *ntdb_errorstr(enum NTDB_ERROR ecode);
204
205 /**
206  * ntdb_append - append a value to a key/value pair in a ntdb.
207  * @ntdb: the ntdb context returned from ntdb_open()
208  * @key: the key
209  * @dbuf: the data to append.
210  *
211  * This is equivalent to fetching a record, reallocating .dptr to add the
212  * data, and writing it back, only it's much more efficient.  If the key
213  * doesn't exist, it's equivalent to ntdb_store (with an additional hint that
214  * you expect to expand the record in future).
215  *
216  * See Also:
217  *      ntdb_fetch(), ntdb_store()
218  */
219 enum NTDB_ERROR ntdb_append(struct ntdb_context *ntdb,
220                             NTDB_DATA key, NTDB_DATA dbuf);
221
222 /**
223  * ntdb_delete - delete a key from a ntdb.
224  * @ntdb: the ntdb context returned from ntdb_open()
225  * @key: the key to delete.
226  *
227  * Returns NTDB_SUCCESS on success, or an error (usually NTDB_ERR_NOEXIST).
228  *
229  * See Also:
230  *      ntdb_fetch(), ntdb_store()
231  */
232 enum NTDB_ERROR ntdb_delete(struct ntdb_context *ntdb, NTDB_DATA key);
233
234 /**
235  * ntdb_exists - does a key exist in the database?
236  * @ntdb: the ntdb context returned from ntdb_open()
237  * @key: the key to search for.
238  *
239  * Returns true if it exists, or false if it doesn't or any other error.
240  */
241 bool ntdb_exists(struct ntdb_context *ntdb, NTDB_DATA key);
242
243 /**
244  * ntdb_deq - are NTDB_DATA equal?
245  * @a: one NTDB_DATA
246  * @b: another NTDB_DATA
247  */
248 static inline bool ntdb_deq(NTDB_DATA a, NTDB_DATA b)
249 {
250         return a.dsize == b.dsize && memcmp(a.dptr, b.dptr, a.dsize) == 0;
251 }
252
253 /**
254  * ntdb_mkdata - make a NTDB_DATA from const data
255  * @p: the constant pointer
256  * @len: the length
257  *
258  * As the dptr member of NTDB_DATA is not constant, you need to
259  * cast it.  This function keeps thost casts in one place, as well as
260  * suppressing the warning some compilers give when casting away a
261  * qualifier (eg. gcc with -Wcast-qual)
262  */
263 static inline NTDB_DATA ntdb_mkdata(const void *p, size_t len)
264 {
265         NTDB_DATA d;
266         d.dptr = cast_const(void *, p);
267         d.dsize = len;
268         return d;
269 }
270
271 /**
272  * ntdb_transaction_start - start a transaction
273  * @ntdb: the ntdb context returned from ntdb_open()
274  *
275  * This begins a series of atomic operations.  Other processes will be able
276  * to read the ntdb, but not alter it (they will block), nor will they see
277  * any changes until ntdb_transaction_commit() is called.
278  *
279  * Note that if the NTDB_ALLOW_NESTING flag is set, a ntdb_transaction_start()
280  * within a transaction will succeed, but it's not a real transaction:
281  * (1) An inner transaction which is committed is not actually committed until
282  *     the outer transaction is; if the outer transaction is cancelled, the
283  *     inner ones are discarded.
284  * (2) ntdb_transaction_cancel() marks the outer transaction as having an error,
285  *     so the final ntdb_transaction_commit() will fail.
286  * (3) the outer transaction will see the results of the inner transaction.
287  *
288  * See Also:
289  *      ntdb_transaction_cancel, ntdb_transaction_commit.
290  */
291 enum NTDB_ERROR ntdb_transaction_start(struct ntdb_context *ntdb);
292
293 /**
294  * ntdb_transaction_cancel - abandon a transaction
295  * @ntdb: the ntdb context returned from ntdb_open()
296  *
297  * This aborts a transaction, discarding any changes which were made.
298  * ntdb_close() does this implicitly.
299  */
300 void ntdb_transaction_cancel(struct ntdb_context *ntdb);
301
302 /**
303  * ntdb_transaction_commit - commit a transaction
304  * @ntdb: the ntdb context returned from ntdb_open()
305  *
306  * This completes a transaction, writing any changes which were made.
307  *
308  * fsync() is used to commit the transaction (unless NTDB_NOSYNC is set),
309  * making it robust against machine crashes, but very slow compared to
310  * other NTDB operations.
311  *
312  * A failure can only be caused by unexpected errors (eg. I/O or
313  * memory); this is no point looping on transaction failure.
314  *
315  * See Also:
316  *      ntdb_transaction_prepare_commit()
317  */
318 enum NTDB_ERROR ntdb_transaction_commit(struct ntdb_context *ntdb);
319
320 /**
321  * ntdb_transaction_prepare_commit - prepare to commit a transaction
322  * @ntdb: the ntdb context returned from ntdb_open()
323  *
324  * This ensures we have the resources to commit a transaction (using
325  * ntdb_transaction_commit): if this succeeds then a transaction will only
326  * fail if the write() or fsync() calls fail.
327  *
328  * If this fails you must still call ntdb_transaction_cancel() to cancel
329  * the transaction.
330  *
331  * See Also:
332  *      ntdb_transaction_commit()
333  */
334 enum NTDB_ERROR ntdb_transaction_prepare_commit(struct ntdb_context *ntdb);
335
336 /**
337  * ntdb_traverse - traverse a NTDB
338  * @ntdb: the ntdb context returned from ntdb_open()
339  * @fn: the function to call for every key/value pair (or NULL)
340  * @p: the pointer to hand to @f
341  *
342  * This walks the NTDB until all they keys have been traversed, or @fn
343  * returns non-zero.  If the traverse function or other processes are
344  * changing data or adding or deleting keys, the traverse may be
345  * unreliable: keys may be skipped or (rarely) visited twice.
346  *
347  * There is one specific exception: the special case of deleting the
348  * current key does not undermine the reliability of the traversal.
349  *
350  * On success, returns the number of keys iterated.  On error returns
351  * a negative enum NTDB_ERROR value.
352  */
353 #define ntdb_traverse(ntdb, fn, p)                                      \
354         ntdb_traverse_(ntdb, typesafe_cb_preargs(int, void *, (fn), (p), \
355                                                  struct ntdb_context *, \
356                                                  NTDB_DATA, NTDB_DATA), (p))
357
358 int64_t ntdb_traverse_(struct ntdb_context *ntdb,
359                        int (*fn)(struct ntdb_context *,
360                                  NTDB_DATA, NTDB_DATA, void *), void *p);
361
362 /**
363  * ntdb_parse_record - operate directly on data in the database.
364  * @ntdb: the ntdb context returned from ntdb_open()
365  * @key: the key whose record we should hand to @parse
366  * @parse: the function to call for the data
367  * @data: the private pointer to hand to @parse (types must match).
368  *
369  * This avoids a copy for many cases, by handing you a pointer into
370  * the memory-mapped database.  It also locks the record to prevent
371  * other accesses at the same time.
372  *
373  * Do not alter the data handed to parse()!
374  */
375 #define ntdb_parse_record(ntdb, key, parse, data)                       \
376         ntdb_parse_record_((ntdb), (key),                               \
377                            typesafe_cb_preargs(enum NTDB_ERROR, void *, \
378                                                (parse), (data),         \
379                                                NTDB_DATA, NTDB_DATA), (data))
380
381 enum NTDB_ERROR ntdb_parse_record_(struct ntdb_context *ntdb,
382                                    NTDB_DATA key,
383                                    enum NTDB_ERROR (*parse)(NTDB_DATA k,
384                                                             NTDB_DATA d,
385                                                             void *data),
386                                    void *data);
387
388 /**
389  * ntdb_get_seqnum - get a database sequence number
390  * @ntdb: the ntdb context returned from ntdb_open()
391  *
392  * This returns a sequence number: any change to the database from a
393  * ntdb context opened with the NTDB_SEQNUM flag will cause that number
394  * to increment.  Note that the incrementing is unreliable (it is done
395  * without locking), so this is only useful as an optimization.
396  *
397  * For example, you may have a regular database backup routine which
398  * does not operate if the sequence number is unchanged.  In the
399  * unlikely event of a failed increment, it will be backed up next
400  * time any way.
401  *
402  * Returns an enum NTDB_ERROR (ie. negative) on error.
403  */
404 int64_t ntdb_get_seqnum(struct ntdb_context *ntdb);
405
406 /**
407  * ntdb_firstkey - get the "first" key in a NTDB
408  * @ntdb: the ntdb context returned from ntdb_open()
409  * @key: pointer to key.
410  *
411  * This returns an arbitrary key in the database; with ntdb_nextkey() it allows
412  * open-coded traversal of the database, though it is slightly less efficient
413  * than ntdb_traverse.
414  *
415  * It is your responsibility to free @key->dptr on success.
416  *
417  * Returns NTDB_ERR_NOEXIST if the database is empty.
418  */
419 enum NTDB_ERROR ntdb_firstkey(struct ntdb_context *ntdb, NTDB_DATA *key);
420
421 /**
422  * ntdb_nextkey - get the "next" key in a NTDB
423  * @ntdb: the ntdb context returned from ntdb_open()
424  * @key: a key returned by ntdb_firstkey() or ntdb_nextkey().
425  *
426  * This returns another key in the database; it will free @key.dptr for
427  * your convenience.
428  *
429  * Returns NTDB_ERR_NOEXIST if there are no more keys.
430  */
431 enum NTDB_ERROR ntdb_nextkey(struct ntdb_context *ntdb, NTDB_DATA *key);
432
433 /**
434  * ntdb_chainlock - lock a record in the NTDB
435  * @ntdb: the ntdb context returned from ntdb_open()
436  * @key: the key to lock.
437  *
438  * This prevents any access occurring to a group of keys including @key,
439  * even if @key does not exist.  This allows primitive atomic updates of
440  * records without using transactions.
441  *
442  * You cannot begin a transaction while holding a ntdb_chainlock(), nor can
443  * you do any operations on any other keys in the database.  This also means
444  * that you cannot hold more than one ntdb_chainlock() at a time.
445  *
446  * See Also:
447  *      ntdb_chainunlock()
448  */
449 enum NTDB_ERROR ntdb_chainlock(struct ntdb_context *ntdb, NTDB_DATA key);
450
451 /**
452  * ntdb_chainunlock - unlock a record in the NTDB
453  * @ntdb: the ntdb context returned from ntdb_open()
454  * @key: the key to unlock.
455  *
456  * The key must have previously been locked by ntdb_chainlock().
457  */
458 void ntdb_chainunlock(struct ntdb_context *ntdb, NTDB_DATA key);
459
460 /**
461  * ntdb_chainlock_read - lock a record in the NTDB, for reading
462  * @ntdb: the ntdb context returned from ntdb_open()
463  * @key: the key to lock.
464  *
465  * This prevents any changes from occurring to a group of keys including @key,
466  * even if @key does not exist.  This allows primitive atomic updates of
467  * records without using transactions.
468  *
469  * You cannot begin a transaction while holding a ntdb_chainlock_read(), nor can
470  * you do any operations on any other keys in the database.  This also means
471  * that you cannot hold more than one ntdb_chainlock()/read() at a time.
472  *
473  * See Also:
474  *      ntdb_chainlock()
475  */
476 enum NTDB_ERROR ntdb_chainlock_read(struct ntdb_context *ntdb, NTDB_DATA key);
477
478 /**
479  * ntdb_chainunlock_read - unlock a record in the NTDB for reading
480  * @ntdb: the ntdb context returned from ntdb_open()
481  * @key: the key to unlock.
482  *
483  * The key must have previously been locked by ntdb_chainlock_read().
484  */
485 void ntdb_chainunlock_read(struct ntdb_context *ntdb, NTDB_DATA key);
486
487 /**
488  * ntdb_lockall - lock the entire NTDB
489  * @ntdb: the ntdb context returned from ntdb_open()
490  *
491  * You cannot hold a ntdb_chainlock while calling this.  It nests, so you
492  * must call ntdb_unlockall as many times as you call ntdb_lockall.
493  */
494 enum NTDB_ERROR ntdb_lockall(struct ntdb_context *ntdb);
495
496 /**
497  * ntdb_unlockall - unlock the entire NTDB
498  * @ntdb: the ntdb context returned from ntdb_open()
499  */
500 void ntdb_unlockall(struct ntdb_context *ntdb);
501
502 /**
503  * ntdb_lockall_read - lock the entire NTDB for reading
504  * @ntdb: the ntdb context returned from ntdb_open()
505  *
506  * This prevents others writing to the database, eg. ntdb_delete, ntdb_store,
507  * ntdb_append, but not ntdb_fetch.
508  *
509  * You cannot hold a ntdb_chainlock while calling this.  It nests, so you
510  * must call ntdb_unlockall_read as many times as you call ntdb_lockall_read.
511  */
512 enum NTDB_ERROR ntdb_lockall_read(struct ntdb_context *ntdb);
513
514 /**
515  * ntdb_unlockall_read - unlock the entire NTDB for reading
516  * @ntdb: the ntdb context returned from ntdb_open()
517  */
518 void ntdb_unlockall_read(struct ntdb_context *ntdb);
519
520 /**
521  * ntdb_wipe_all - wipe the database clean
522  * @ntdb: the ntdb context returned from ntdb_open()
523  *
524  * Completely erase the database.  This is faster than iterating through
525  * each key and doing ntdb_delete.
526  */
527 enum NTDB_ERROR ntdb_wipe_all(struct ntdb_context *ntdb);
528
529 /**
530  * ntdb_repack - repack the database
531  * @ntdb: the ntdb context returned from ntdb_open()
532  *
533  * This repacks the database; if it is suffering from a great deal of
534  * fragmentation this might help.  However, it can take twice the
535  * memory of the existing NTDB.
536  */
537 enum NTDB_ERROR ntdb_repack(struct ntdb_context *ntdb);
538
539 /**
540  * ntdb_check - check a NTDB for consistency
541  * @ntdb: the ntdb context returned from ntdb_open()
542  * @check: function to check each key/data pair (or NULL)
543  * @data: argument for @check, must match type.
544  *
545  * This performs a consistency check of the open database, optionally calling
546  * a check() function on each record so you can do your own data consistency
547  * checks as well.  If check() returns an error, that is returned from
548  * ntdb_check().
549  *
550  * Note that the NTDB uses a feature which we don't understand which
551  * indicates we can't run ntdb_check(), this will log a warning to that
552  * effect and return NTDB_SUCCESS.  You can detect this condition by
553  * looking for NTDB_CANT_CHECK in ntdb_get_flags().
554  *
555  * Returns NTDB_SUCCESS or an error.
556  */
557 #define ntdb_check(ntdb, check, data)                                   \
558         ntdb_check_((ntdb), typesafe_cb_preargs(enum NTDB_ERROR, void *, \
559                                                 (check), (data),        \
560                                                 NTDB_DATA,              \
561                                                 NTDB_DATA),             \
562                     (data))
563
564 enum NTDB_ERROR ntdb_check_(struct ntdb_context *ntdb,
565                             enum NTDB_ERROR (*check)(NTDB_DATA k,
566                                                      NTDB_DATA d,
567                                                      void *data),
568                             void *data);
569
570 /**
571  * enum ntdb_summary_flags - flags for ntdb_summary.
572  */
573 enum ntdb_summary_flags {
574         NTDB_SUMMARY_HISTOGRAMS = 1 /* Draw graphs in the summary. */
575 };
576
577 /**
578  * ntdb_summary - return a string describing the NTDB state
579  * @ntdb: the ntdb context returned from ntdb_open()
580  * @flags: flags to control the summary output.
581  * @summary: pointer to string to allocate.
582  *
583  * This returns a developer-readable string describing the overall
584  * state of the ntdb, such as the percentage used and sizes of records.
585  * It is designed to provide information about the ntdb at a glance
586  * without displaying any keys or data in the database.
587  *
588  * On success, sets @summary to point to a malloc()'ed nul-terminated
589  * multi-line string.  It is your responsibility to free() it.
590  */
591 enum NTDB_ERROR ntdb_summary(struct ntdb_context *ntdb,
592                              enum ntdb_summary_flags flags,
593                              char **summary);
594
595
596 /**
597  * ntdb_get_flags - return the flags for a ntdb
598  * @ntdb: the ntdb context returned from ntdb_open()
599  *
600  * This returns the flags on the current ntdb.  Some of these are caused by
601  * the flags argument to ntdb_open(), others (such as NTDB_CONVERT) are
602  * intuited.
603  */
604 unsigned int ntdb_get_flags(struct ntdb_context *ntdb);
605
606 /**
607  * ntdb_add_flag - set a flag for a ntdb
608  * @ntdb: the ntdb context returned from ntdb_open()
609  * @flag: one of NTDB_NOLOCK, NTDB_NOMMAP, NTDB_NOSYNC or NTDB_ALLOW_NESTING.
610  *
611  * You can use this to set a flag on the NTDB.  You cannot set these flags
612  * on a NTDB_INTERNAL ntdb.
613  */
614 void ntdb_add_flag(struct ntdb_context *ntdb, unsigned flag);
615
616 /**
617  * ntdb_remove_flag - unset a flag for a ntdb
618  * @ntdb: the ntdb context returned from ntdb_open()
619  * @flag: one of NTDB_NOLOCK, NTDB_NOMMAP, NTDB_NOSYNC or NTDB_ALLOW_NESTING.
620  *
621  * You can use this to clear a flag on the NTDB.  You cannot clear flags
622  * on a NTDB_INTERNAL ntdb.
623  */
624 void ntdb_remove_flag(struct ntdb_context *ntdb, unsigned flag);
625
626 /**
627  * enum ntdb_attribute_type - descriminator for union ntdb_attribute.
628  */
629 enum ntdb_attribute_type {
630         NTDB_ATTRIBUTE_LOG = 0,
631         NTDB_ATTRIBUTE_HASH = 1,
632         NTDB_ATTRIBUTE_SEED = 2,
633         NTDB_ATTRIBUTE_STATS = 3,
634         NTDB_ATTRIBUTE_OPENHOOK = 4,
635         NTDB_ATTRIBUTE_FLOCK = 5,
636 };
637
638 /**
639  * ntdb_get_attribute - get an attribute for an existing ntdb
640  * @ntdb: the ntdb context returned from ntdb_open()
641  * @attr: the union ntdb_attribute to set.
642  *
643  * This gets an attribute from a NTDB which has previously been set (or
644  * may return the default values).  Set @attr.base.attr to the
645  * attribute type you want get.
646  */
647 enum NTDB_ERROR ntdb_get_attribute(struct ntdb_context *ntdb,
648                                    union ntdb_attribute *attr);
649
650 /**
651  * ntdb_set_attribute - set an attribute for an existing ntdb
652  * @ntdb: the ntdb context returned from ntdb_open()
653  * @attr: the union ntdb_attribute to set.
654  *
655  * This sets an attribute on a NTDB, overriding any previous attribute
656  * of the same type.  It returns NTDB_ERR_EINVAL if the attribute is
657  * unknown or invalid.
658  *
659  * Note that NTDB_ATTRIBUTE_HASH, NTDB_ATTRIBUTE_SEED, and
660  * NTDB_ATTRIBUTE_OPENHOOK cannot currently be set after ntdb_open.
661  */
662 enum NTDB_ERROR ntdb_set_attribute(struct ntdb_context *ntdb,
663                                    const union ntdb_attribute *attr);
664
665 /**
666  * ntdb_unset_attribute - reset an attribute for an existing ntdb
667  * @ntdb: the ntdb context returned from ntdb_open()
668  * @type: the attribute type to unset.
669  *
670  * This unsets an attribute on a NTDB, returning it to the defaults
671  * (where applicable).
672  *
673  * Note that it only makes sense for NTDB_ATTRIBUTE_LOG and NTDB_ATTRIBUTE_FLOCK
674  * to be unset.
675  */
676 void ntdb_unset_attribute(struct ntdb_context *ntdb,
677                           enum ntdb_attribute_type type);
678
679 /**
680  * ntdb_name - get the name of a ntdb
681  * @ntdb: the ntdb context returned from ntdb_open()
682  *
683  * This returns a copy of the name string, made at ntdb_open() time.
684  *
685  * This is mostly useful for logging.
686  */
687 const char *ntdb_name(const struct ntdb_context *ntdb);
688
689 /**
690  * ntdb_fd - get the file descriptor of a ntdb
691  * @ntdb: the ntdb context returned from ntdb_open()
692  *
693  * This returns the file descriptor for the underlying database file, or -1
694  * for NTDB_INTERNAL.
695  */
696 int ntdb_fd(const struct ntdb_context *ntdb);
697
698 /**
699  * ntdb_foreach - iterate through every open NTDB.
700  * @fn: the function to call for every NTDB
701  * @p: the pointer to hand to @fn
702  *
703  * NTDB internally keeps track of all open TDBs; this function allows you to
704  * iterate through them.  If @fn returns non-zero, traversal stops.
705  */
706 #define ntdb_foreach(fn, p)                                             \
707         ntdb_foreach_(typesafe_cb_preargs(int, void *, (fn), (p),       \
708                                           struct ntdb_context *), (p))
709
710 void ntdb_foreach_(int (*fn)(struct ntdb_context *, void *), void *p);
711
712 /**
713  * struct ntdb_attribute_base - common fields for all ntdb attributes.
714  */
715 struct ntdb_attribute_base {
716         enum ntdb_attribute_type attr;
717         union ntdb_attribute *next;
718 };
719
720 /**
721  * enum ntdb_log_level - log levels for ntdb_attribute_log
722  * @NTDB_LOG_ERROR: used to log unrecoverable errors such as I/O errors
723  *                 or internal consistency failures.
724  * @NTDB_LOG_USE_ERROR: used to log usage errors such as invalid parameters
725  *                 or writing to a read-only database.
726  * @NTDB_LOG_WARNING: used for informational messages on issues which
727  *                   are unusual but handled by NTDB internally, such
728  *                   as a failure to mmap or failure to open /dev/urandom.
729  *                   It's also used when ntdb_open() fails without O_CREAT
730  *                   because a file does not exist.
731  */
732 enum ntdb_log_level {
733         NTDB_LOG_ERROR,
734         NTDB_LOG_USE_ERROR,
735         NTDB_LOG_WARNING
736 };
737
738 /**
739  * struct ntdb_attribute_log - log function attribute
740  *
741  * This attribute provides a hook for you to log errors.
742  */
743 struct ntdb_attribute_log {
744         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_LOG */
745         void (*fn)(struct ntdb_context *ntdb,
746                    enum ntdb_log_level level,
747                    enum NTDB_ERROR ecode,
748                    const char *message,
749                    void *data);
750         void *data;
751 };
752
753 /**
754  * struct ntdb_attribute_hash - hash function attribute
755  *
756  * This attribute allows you to provide an alternative hash function.
757  * This hash function will be handed keys from the database; it will also
758  * be handed the 8-byte NTDB_HASH_MAGIC value for checking the header (the
759  * ntdb_open() will fail if the hash value doesn't match the header).
760  *
761  * Note that if your hash function gives different results on
762  * different machine endians, your ntdb will no longer work across
763  * different architectures!
764  */
765 struct ntdb_attribute_hash {
766         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_HASH */
767         uint64_t (*fn)(const void *key, size_t len, uint64_t seed,
768                        void *data);
769         void *data;
770 };
771
772 /**
773  * struct ntdb_attribute_seed - hash function seed attribute
774  *
775  * The hash function seed is normally taken from /dev/urandom (or equivalent)
776  * but can be set manually here.  This is mainly for testing purposes.
777  */
778 struct ntdb_attribute_seed {
779         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_SEED */
780         uint64_t seed;
781 };
782
783 /**
784  * struct ntdb_attribute_stats - ntdb operational statistics
785  *
786  * This attribute records statistics of various low-level NTDB operations.
787  * This can be used to assist performance evaluation.  This is only
788  * useful for ntdb_get_attribute().
789  *
790  * New fields will be added at the end, hence the "size" argument which
791  * indicates how large your structure is: it must be filled in before
792  * calling ntdb_get_attribute(), which will overwrite it with the size
793  * ntdb knows about.
794  */
795 struct ntdb_attribute_stats {
796         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_STATS */
797         size_t size; /* = sizeof(struct ntdb_attribute_stats) */
798         uint64_t allocs;
799         uint64_t   alloc_subhash;
800         uint64_t   alloc_chain;
801         uint64_t   alloc_bucket_exact;
802         uint64_t   alloc_bucket_max;
803         uint64_t   alloc_leftover;
804         uint64_t   alloc_coalesce_tried;
805         uint64_t     alloc_coalesce_iterate_clash;
806         uint64_t     alloc_coalesce_lockfail;
807         uint64_t     alloc_coalesce_race;
808         uint64_t     alloc_coalesce_succeeded;
809         uint64_t       alloc_coalesce_num_merged;
810         uint64_t compares;
811         uint64_t   compare_wrong_bucket;
812         uint64_t   compare_wrong_offsetbits;
813         uint64_t   compare_wrong_keylen;
814         uint64_t   compare_wrong_rechash;
815         uint64_t   compare_wrong_keycmp;
816         uint64_t transactions;
817         uint64_t   transaction_cancel;
818         uint64_t   transaction_nest;
819         uint64_t   transaction_expand_file;
820         uint64_t   transaction_read_direct;
821         uint64_t      transaction_read_direct_fail;
822         uint64_t   transaction_write_direct;
823         uint64_t      transaction_write_direct_fail;
824         uint64_t expands;
825         uint64_t frees;
826         uint64_t locks;
827         uint64_t   lock_lowlevel;
828         uint64_t   lock_nonblock;
829         uint64_t     lock_nonblock_fail;
830 };
831
832 /**
833  * struct ntdb_attribute_openhook - ntdb special effects hook for open
834  *
835  * This attribute contains a function to call once we have the OPEN_LOCK
836  * for the ntdb, but before we've examined its contents.  If this succeeds,
837  * the ntdb will be populated if it's then zero-length.
838  *
839  * This is a hack to allow support for TDB-style TDB_CLEAR_IF_FIRST
840  * behaviour.
841  */
842 struct ntdb_attribute_openhook {
843         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_OPENHOOK */
844         enum NTDB_ERROR (*fn)(int fd, void *data);
845         void *data;
846 };
847
848 /**
849  * struct ntdb_attribute_flock - ntdb special effects hook for file locking
850  *
851  * This attribute contains function to call to place locks on a file; it can
852  * be used to support non-blocking operations or lock proxying.
853  *
854  * They should return 0 on success, -1 on failure and set errno.
855  *
856  * An error will be logged on error if errno is neither EAGAIN nor EINTR
857  * (normally it would only return EAGAIN if waitflag is false, and
858  * loop internally on EINTR).
859  */
860 struct ntdb_attribute_flock {
861         struct ntdb_attribute_base base; /* .attr = NTDB_ATTRIBUTE_FLOCK */
862         int (*lock)(int fd,int rw, off_t off, off_t len, bool waitflag, void *);
863         int (*unlock)(int fd, int rw, off_t off, off_t len, void *);
864         void *data;
865 };
866
867 /**
868  * union ntdb_attribute - ntdb attributes.
869  *
870  * This represents all the known attributes.
871  *
872  * See also:
873  *      struct ntdb_attribute_log, struct ntdb_attribute_hash,
874  *      struct ntdb_attribute_seed, struct ntdb_attribute_stats,
875  *      struct ntdb_attribute_openhook, struct ntdb_attribute_flock.
876  */
877 union ntdb_attribute {
878         struct ntdb_attribute_base base;
879         struct ntdb_attribute_log log;
880         struct ntdb_attribute_hash hash;
881         struct ntdb_attribute_seed seed;
882         struct ntdb_attribute_stats stats;
883         struct ntdb_attribute_openhook openhook;
884         struct ntdb_attribute_flock flock;
885 };
886
887 #ifdef  __cplusplus
888 }
889 #endif
890
891 #endif /* ntdb.h */