2 Unix SMB/CIFS implementation.
4 trivial database library
6 Copyright (C) Andrew Tridgell 1999-2005
7 Copyright (C) Paul `Rusty' Russell 2000
8 Copyright (C) Jeremy Allison 2000-2003
10 ** NOTE! The following LGPL license applies to the tdb
11 ** library. This does NOT imply that all of Samba is released
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.
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.
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/>.
28 #include "tdb1_private.h"
30 /* We use two hashes to double-check they're using the right hash function. */
31 void tdb1_header_hash(struct tdb_context
*tdb
,
32 uint32_t *magic1_hash
, uint32_t *magic2_hash
)
34 uint32_t tdb1_magic
= TDB1_MAGIC
;
36 *magic1_hash
= tdb_hash(tdb
, TDB_MAGIC_FOOD
, sizeof(TDB_MAGIC_FOOD
));
37 *magic2_hash
= tdb_hash(tdb
, TDB1_CONV(tdb1_magic
), sizeof(tdb1_magic
));
39 /* Make sure at least one hash is non-zero! */
40 if (*magic1_hash
== 0 && *magic2_hash
== 0)
44 /* initialise a new database with a specified hash size */
45 static int tdb1_new_database(struct tdb_context
*tdb
, int hash_size
)
47 struct tdb1_header
*newdb
;
51 /* We make it up in memory, then write it out if not internal */
52 size
= sizeof(struct tdb1_header
) + (hash_size
+1)*sizeof(tdb1_off_t
);
53 if (!(newdb
= (struct tdb1_header
*)calloc(size
, 1))) {
54 tdb
->last_error
= TDB_ERR_OOM
;
58 /* Fill in the header */
59 newdb
->version
= TDB1_VERSION
;
60 newdb
->hash_size
= hash_size
;
62 tdb1_header_hash(tdb
, &newdb
->magic1_hash
, &newdb
->magic2_hash
);
64 /* Make sure older tdbs (which don't check the magic hash fields)
65 * will refuse to open this TDB. */
66 if (tdb
->hash_fn
== tdb1_incompatible_hash
)
67 newdb
->rwlocks
= TDB1_HASH_RWLOCK_MAGIC
;
69 if (tdb
->flags
& TDB_INTERNAL
) {
71 tdb
->file
->map_size
= size
;
72 tdb
->file
->map_ptr
= (char *)newdb
;
73 memcpy(&tdb
->tdb1
.header
, newdb
, sizeof(tdb
->tdb1
.header
));
74 /* Convert the `ondisk' version if asked. */
78 if (lseek(tdb
->file
->fd
, 0, SEEK_SET
) == -1)
81 if (ftruncate(tdb
->file
->fd
, 0) == -1)
84 /* This creates an endian-converted header, as if read from disk */
86 memcpy(&tdb
->tdb1
.header
, newdb
, sizeof(tdb
->tdb1
.header
));
87 /* Don't endian-convert the magic food! */
88 memcpy(newdb
->magic_food
, TDB_MAGIC_FOOD
, strlen(TDB_MAGIC_FOOD
)+1);
89 /* we still have "ret == -1" here */
90 if (tdb1_write_all(tdb
->file
->fd
, newdb
, size
))
100 /* open the database, creating it if necessary
102 The open_flags and mode are passed straight to the open call on the
103 database file. A flags value of O_WRONLY is invalid. The hash size
104 is advisory, use zero for a default value.
106 Return is NULL on error, in which case errno is also set. Don't
107 try to call tdb1_error or tdb1_errname, just do strerror(errno).
109 @param name may be NULL for internal databases. */
110 struct tdb_context
*tdb1_open(const char *name
, int hash_size
, int tdb1_flags
,
111 int open_flags
, mode_t mode
)
113 return tdb1_open_ex(name
, hash_size
, tdb1_flags
, open_flags
, mode
, NULL
, NULL
);
116 static bool hash_correct(struct tdb_context
*tdb
,
117 uint32_t *m1
, uint32_t *m2
)
119 tdb1_header_hash(tdb
, m1
, m2
);
120 return (tdb
->tdb1
.header
.magic1_hash
== *m1
&&
121 tdb
->tdb1
.header
.magic2_hash
== *m2
);
124 static bool check_header_hash(struct tdb_context
*tdb
,
125 uint32_t *m1
, uint32_t *m2
)
127 if (hash_correct(tdb
, m1
, m2
))
130 /* If they use one inbuilt, try the other inbuilt hash. */
131 if (tdb
->hash_fn
== tdb1_old_hash
)
132 tdb
->hash_fn
= tdb1_incompatible_hash
;
133 else if (tdb
->hash_fn
== tdb1_incompatible_hash
)
134 tdb
->hash_fn
= tdb1_old_hash
;
137 return hash_correct(tdb
, m1
, m2
);
140 struct tdb_context
*tdb1_open_ex(const char *name
, int hash_size
, int tdb1_flags
,
141 int open_flags
, mode_t mode
,
142 const struct tdb1_logging_context
*log_ctx
,
143 tdb1_hash_func hash_fn
)
145 struct tdb_context
*tdb
;
149 const char *hash_alg
;
150 uint32_t magic1
, magic2
;
152 if (!(tdb
= (struct tdb_context
*)calloc(1, sizeof *tdb
))) {
157 tdb
->file
= calloc(1, sizeof *tdb
->file
);
166 tdb
->file
->map_ptr
= NULL
;
167 tdb
->flags
= tdb1_flags
|TDB_VERSION1
;
168 tdb
->open_flags
= open_flags
;
169 tdb
->lock_fn
= tdb_fcntl_lock
;
170 tdb
->unlock_fn
= tdb_fcntl_unlock
;
172 tdb
->log_fn
= log_ctx
->log_fn
;
173 tdb
->log_data
= log_ctx
->log_private
;
177 if (name
== NULL
&& (tdb1_flags
& TDB_INTERNAL
)) {
178 name
= "__TDB1_INTERNAL__";
182 tdb
->name
= (char *)"__NULL__";
183 tdb_logerr(tdb
, TDB_ERR_EINVAL
, TDB_LOG_USE_ERROR
,
184 "tdb1_open_ex: called with name == NULL");
190 /* now make a copy of the name, as the caller memory might went away */
191 if (!(tdb
->name
= (char *)strdup(name
))) {
193 * set the name as the given string, so that tdb1_name() will
194 * work in case of an error.
196 tdb
->name
= (char *)name
;
197 tdb_logerr(tdb
, TDB_ERR_OOM
, TDB_LOG_ERROR
,
198 "tdb1_open_ex: can't strdup(%s)", name
);
206 tdb
->hash_fn
= hash_fn
;
207 if (hash_fn
== tdb1_incompatible_hash
)
208 hash_alg
= "tdb1_incompatible_hash";
210 hash_alg
= "the user defined";
212 tdb
->hash_fn
= tdb1_old_hash
;
213 hash_alg
= "default";
216 /* cache the page size */
217 tdb
->tdb1
.page_size
= getpagesize();
218 if (tdb
->tdb1
.page_size
<= 0) {
219 tdb
->tdb1
.page_size
= 0x2000;
222 /* FIXME: Used to be 5 for TDB_VOLATILE. */
223 tdb
->tdb1
.max_dead_records
= 0;
225 if ((open_flags
& O_ACCMODE
) == O_WRONLY
) {
226 tdb_logerr(tdb
, TDB_ERR_EINVAL
, TDB_LOG_USE_ERROR
,
227 "tdb1_open_ex: can't open tdb %s write-only",
234 hash_size
= TDB1_DEFAULT_HASH_SIZE
;
235 if ((open_flags
& O_ACCMODE
) == O_RDONLY
) {
236 tdb
->flags
|= TDB_RDONLY
;
237 /* read only databases don't do locking */
238 tdb
->flags
|= TDB_NOLOCK
;
241 /* internal databases don't mmap or lock, and start off cleared */
242 if (tdb
->flags
& TDB_INTERNAL
) {
243 tdb
->flags
|= (TDB_NOLOCK
| TDB_NOMMAP
);
244 if (tdb1_new_database(tdb
, hash_size
) != 0) {
245 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
246 "tdb1_open_ex: tdb1_new_database failed!");
252 if ((tdb
->file
->fd
= open(name
, open_flags
, mode
)) == -1) {
253 tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
254 "tdb1_open_ex: could not open file %s: %s",
255 name
, strerror(errno
));
256 goto fail
; /* errno set by open(2) */
259 /* on exec, don't inherit the fd */
260 v
= fcntl(tdb
->file
->fd
, F_GETFD
, 0);
261 fcntl(tdb
->file
->fd
, F_SETFD
, v
| FD_CLOEXEC
);
263 /* ensure there is only one process initialising at once */
264 if (tdb1_nest_lock(tdb
, TDB1_OPEN_LOCK
, F_WRLCK
, TDB_LOCK_WAIT
) == -1) {
265 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
266 "tdb1_open_ex: failed to get open lock on %s: %s",
267 name
, strerror(errno
));
268 goto fail
; /* errno set by tdb1_brlock */
272 if (read(tdb
->file
->fd
, &tdb
->tdb1
.header
, sizeof(tdb
->tdb1
.header
)) != sizeof(tdb
->tdb1
.header
)
273 || strcmp(tdb
->tdb1
.header
.magic_food
, TDB_MAGIC_FOOD
) != 0) {
274 if (!(open_flags
& O_CREAT
) || tdb1_new_database(tdb
, hash_size
) == -1) {
276 errno
= EIO
; /* ie bad format or something */
280 rev
= (tdb
->flags
& TDB_CONVERT
);
281 } else if (tdb
->tdb1
.header
.version
!= TDB1_VERSION
282 && !(rev
= (tdb
->tdb1
.header
.version
==TDB1_BYTEREV(TDB1_VERSION
)))) {
288 tdb
->flags
&= ~TDB_CONVERT
;
290 tdb
->flags
|= TDB_CONVERT
;
291 tdb1_convert(&tdb
->tdb1
.header
, sizeof(tdb
->tdb1
.header
));
293 if (fstat(tdb
->file
->fd
, &st
) == -1)
296 if (tdb
->tdb1
.header
.rwlocks
!= 0 &&
297 tdb
->tdb1
.header
.rwlocks
!= TDB1_HASH_RWLOCK_MAGIC
) {
298 tdb_logerr(tdb
, TDB_ERR_CORRUPT
, TDB_LOG_ERROR
,
299 "tdb1_open_ex: spinlocks no longer supported");
303 if ((tdb
->tdb1
.header
.magic1_hash
== 0) && (tdb
->tdb1
.header
.magic2_hash
== 0)) {
304 /* older TDB without magic hash references */
305 tdb
->hash_fn
= tdb1_old_hash
;
306 } else if (!check_header_hash(tdb
, &magic1
, &magic2
)) {
307 tdb_logerr(tdb
, TDB_ERR_CORRUPT
, TDB_LOG_USE_ERROR
,
309 "%s was not created with %s hash function we are using\n"
310 "magic1_hash[0x%08X %s 0x%08X] "
311 "magic2_hash[0x%08X %s 0x%08X]",
313 tdb
->tdb1
.header
.magic1_hash
,
314 (tdb
->tdb1
.header
.magic1_hash
== magic1
) ? "==" : "!=",
316 tdb
->tdb1
.header
.magic2_hash
,
317 (tdb
->tdb1
.header
.magic2_hash
== magic2
) ? "==" : "!=",
323 tdb
->file
->map_size
= st
.st_size
;
324 tdb
->file
->device
= st
.st_dev
;
325 tdb
->file
->inode
= st
.st_ino
;
328 /* if needed, run recovery */
329 if (tdb1_transaction_recover(tdb
) == -1) {
334 /* Internal (memory-only) databases skip all the code above to
335 * do with disk files, and resume here by releasing their
336 * open lock and hooking into the active list. */
337 if (tdb1_nest_unlock(tdb
, TDB1_OPEN_LOCK
, F_WRLCK
) == -1) {
343 { int save_errno
= errno
;
348 if (tdb
->file
->map_ptr
) {
349 if (tdb
->flags
& TDB_INTERNAL
)
350 SAFE_FREE(tdb
->file
->map_ptr
);
354 if (tdb
->file
->fd
!= -1)
355 if (close(tdb
->file
->fd
) != 0)
356 tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
357 "tdb1_open_ex: failed to close tdb->fd on error!");
359 SAFE_FREE(tdb
->file
->lockrecs
);
360 SAFE_FREE(tdb
->file
);
362 SAFE_FREE(tdb
->name
);
370 * Set the maximum number of dead records per hash chain
373 void tdb1_set_max_dead(struct tdb_context
*tdb
, int max_dead
)
375 tdb
->tdb1
.max_dead_records
= max_dead
;
381 * @returns -1 for error; 0 for success.
383 int tdb1_close(struct tdb_context
*tdb
)
387 if (tdb
->tdb1
.transaction
) {
388 tdb1_transaction_cancel(tdb
);
391 if (tdb
->file
->map_ptr
) {
392 if (tdb
->flags
& TDB_INTERNAL
)
393 SAFE_FREE(tdb
->file
->map_ptr
);
397 SAFE_FREE(tdb
->name
);
398 if (tdb
->file
->fd
!= -1) {
399 ret
= close(tdb
->file
->fd
);
402 SAFE_FREE(tdb
->file
->lockrecs
);
403 SAFE_FREE(tdb
->file
);
405 memset(tdb
, 0, sizeof(*tdb
));