git.ozlabs.org Git - ccan/blob - ccan/tdb/tdb.c

   1  /*
   2    Unix SMB/CIFS implementation.
   3
   4    trivial database library
   5
   6    Copyright (C) Andrew Tridgell              1999-2005
   7    Copyright (C) Paul `Rusty' Russell              2000
   8    Copyright (C) Jeremy Allison                    2000-2003
   9
  10      ** NOTE! The following LGPL license applies to the tdb
  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 #include "tdb_private.h"
  29
  30 TDB_DATA tdb_null;
  31
  32 /*
  33   non-blocking increment of the tdb sequence number if the tdb has been opened using
  34   the TDB_SEQNUM flag
  35 */
  36 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
  37 {
  38         tdb_off_t seqnum=0;
  39
  40         if (!(tdb->flags & TDB_SEQNUM)) {
  41                 return;
  42         }
  43
  44         tdb_trace(tdb, "tdb_increment_seqnum_nonblock");
  45
  46         /* we ignore errors from this, as we have no sane way of
  47            dealing with them.
  48         */
  49         tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
  50         seqnum++;
  51         tdb_ofs_write(tdb, TDB_SEQNUM_OFS, &seqnum);
  52 }
  53
  54 /*
  55   increment the tdb sequence number if the tdb has been opened using
  56   the TDB_SEQNUM flag
  57 */
  58 static void tdb_increment_seqnum(struct tdb_context *tdb)
  59 {
  60         if (!(tdb->flags & TDB_SEQNUM)) {
  61                 return;
  62         }
  63
  64         if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
  65                 return;
  66         }
  67
  68         tdb_trace(tdb, "tdb_increment_seqnum");
  69
  70         tdb_increment_seqnum_nonblock(tdb);
  71
  72         tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
  73 }
  74
  75 static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
  76 {
  77         return memcmp(data.dptr, key.dptr, data.dsize);
  78 }
  79
  80 /* Returns 0 on fail.  On success, return offset of record, and fills
  81    in rec */
  82 static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
  83                         struct list_struct *r)
  84 {
  85         tdb_off_t rec_ptr;
  86
  87         /* read in the hash top */
  88         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
  89                 return 0;
  90
  91         /* keep looking until we find the right record */
  92         while (rec_ptr) {
  93                 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
  94                         return 0;
  95
  96                 if (!TDB_DEAD(r) && hash==r->full_hash
  97                     && key.dsize==r->key_len
  98                     && tdb_parse_data(tdb, key, rec_ptr + sizeof(*r),
  99                                       r->key_len, tdb_key_compare,
 100                                       NULL) == 0) {
 101                         return rec_ptr;
 102                 }
 103                 rec_ptr = r->next;
 104         }
 105         return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
 106 }
 107
 108 /* As tdb_find, but if you succeed, keep the lock */
 109 tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
 110                            struct list_struct *rec)
 111 {
 112         uint32_t rec_ptr;
 113
 114         if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
 115                 return 0;
 116         if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
 117                 tdb_unlock(tdb, BUCKET(hash), locktype);
 118         return rec_ptr;
 119 }
 120
 121
 122 /* update an entry in place - this only works if the new data size
 123    is <= the old data size and the key exists.
 124    on failure return -1.
 125 */
 126 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
 127 {
 128         struct list_struct rec;
 129         tdb_off_t rec_ptr;
 130
 131         /* find entry */
 132         if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
 133                 return -1;
 134
 135         /* must be long enough key, data and tailer */
 136         if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
 137                 tdb->ecode = TDB_SUCCESS; /* Not really an error */
 138                 return -1;
 139         }
 140
 141         if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 142                       dbuf.dptr, dbuf.dsize) == -1)
 143                 return -1;
 144
 145         if (dbuf.dsize != rec.data_len) {
 146                 /* update size */
 147                 rec.data_len = dbuf.dsize;
 148                 return tdb_rec_write(tdb, rec_ptr, &rec);
 149         }
 150
 151         return 0;
 152 }
 153
 154 /* find an entry in the database given a key */
 155 /* If an entry doesn't exist tdb_err will be set to
 156  * TDB_ERR_NOEXIST. If a key has no data attached
 157  * then the TDB_DATA will have zero length but
 158  * a non-zero pointer
 159  */
 160 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
 161 {
 162         tdb_off_t rec_ptr;
 163         struct list_struct rec;
 164         TDB_DATA ret;
 165         uint32_t hash;
 166
 167         /* find which hash bucket it is in */
 168         hash = tdb->hash_fn(&key);
 169         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 170                 tdb_trace(tdb, "tdb_fetch ");
 171                 tdb_trace_record(tdb, key);
 172                 tdb_trace(tdb, "= ENOENT\n");
 173                 return tdb_null;
 174         }
 175         ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 176                                   rec.data_len);
 177         ret.dsize = rec.data_len;
 178         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 179         tdb_trace(tdb, "tdb_fetch ");
 180         tdb_trace_record(tdb, key);
 181         tdb_trace(tdb, "= ");
 182         tdb_trace_record(tdb, ret);
 183         tdb_trace(tdb, "\n");
 184         return ret;
 185 }
 186
 187 /*
 188  * Find an entry in the database and hand the record's data to a parsing
 189  * function. The parsing function is executed under the chain read lock, so it
 190  * should be fast and should not block on other syscalls.
 191  *
 192  * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
 193  *
 194  * For mmapped tdb's that do not have a transaction open it points the parsing
 195  * function directly at the mmap area, it avoids the malloc/memcpy in this
 196  * case. If a transaction is open or no mmap is available, it has to do
 197  * malloc/read/parse/free.
 198  *
 199  * This is interesting for all readers of potentially large data structures in
 200  * the tdb records, ldb indexes being one example.
 201  */
 202
 203 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
 204                      int (*parser)(TDB_DATA key, TDB_DATA data,
 205                                    void *private_data),
 206                      void *private_data)
 207 {
 208         tdb_off_t rec_ptr;
 209         struct list_struct rec;
 210         int ret;
 211         uint32_t hash;
 212
 213         /* find which hash bucket it is in */
 214         hash = tdb->hash_fn(&key);
 215
 216         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 217                 tdb_trace(tdb, "tdb_parse_record ");
 218                 tdb_trace_record(tdb, key);
 219                 tdb_trace(tdb, "= ENOENT\n");
 220                 return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
 221         }
 222
 223         tdb_trace(tdb, "tdb_parse_record ");
 224         tdb_trace_record(tdb, key);
 225         tdb_trace(tdb, "= %u\n", rec.data_len);
 226
 227         ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
 228                              rec.data_len, parser, private_data);
 229
 230         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 231
 232         return ret;
 233 }
 234
 235 /* check if an entry in the database exists
 236
 237    note that 1 is returned if the key is found and 0 is returned if not found
 238    this doesn't match the conventions in the rest of this module, but is
 239    compatible with gdbm
 240 */
 241 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 242 {
 243         struct list_struct rec;
 244
 245         if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
 246                 return 0;
 247         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 248         return 1;
 249 }
 250
 251 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
 252 {
 253         uint32_t hash = tdb->hash_fn(&key);
 254         int ret;
 255
 256         ret = tdb_exists_hash(tdb, key, hash);
 257         tdb_trace(tdb, "tdb_exists ");
 258         tdb_trace_record(tdb, key);
 259         tdb_trace(tdb, "= %i\n", ret);
 260         return ret;
 261 }
 262
 263 /* actually delete an entry in the database given the offset */
 264 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
 265 {
 266         tdb_off_t last_ptr, i;
 267         struct list_struct lastrec;
 268
 269         if (tdb->read_only || tdb->traverse_read) return -1;
 270
 271         if (tdb->traverse_write != 0 ||
 272             tdb_write_lock_record(tdb, rec_ptr) == -1) {
 273                 /* Someone traversing here: mark it as dead */
 274                 rec->magic = TDB_DEAD_MAGIC;
 275                 return tdb_rec_write(tdb, rec_ptr, rec);
 276         }
 277         if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
 278                 return -1;
 279
 280         /* find previous record in hash chain */
 281         if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
 282                 return -1;
 283         for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
 284                 if (tdb_rec_read(tdb, i, &lastrec) == -1)
 285                         return -1;
 286
 287         /* unlink it: next ptr is at start of record. */
 288         if (last_ptr == 0)
 289                 last_ptr = TDB_HASH_TOP(rec->full_hash);
 290         if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
 291                 return -1;
 292
 293         /* recover the space */
 294         if (tdb_free(tdb, rec_ptr, rec) == -1)
 295                 return -1;
 296         return 0;
 297 }
 298
 299 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
 300 {
 301         int res = 0;
 302         tdb_off_t rec_ptr;
 303         struct list_struct rec;
 304
 305         /* read in the hash top */
 306         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 307                 return 0;
 308
 309         while (rec_ptr) {
 310                 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
 311                         return 0;
 312
 313                 if (rec.magic == TDB_DEAD_MAGIC) {
 314                         res += 1;
 315                 }
 316                 rec_ptr = rec.next;
 317         }
 318         return res;
 319 }
 320
 321 /*
 322  * Purge all DEAD records from a hash chain
 323  */
 324 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
 325 {
 326         int res = -1;
 327         struct list_struct rec;
 328         tdb_off_t rec_ptr;
 329
 330         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 331                 return -1;
 332         }
 333
 334         /* read in the hash top */
 335         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 336                 goto fail;
 337
 338         while (rec_ptr) {
 339                 tdb_off_t next;
 340
 341                 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
 342                         goto fail;
 343                 }
 344
 345                 next = rec.next;
 346
 347                 if (rec.magic == TDB_DEAD_MAGIC
 348                     && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
 349                         goto fail;
 350                 }
 351                 rec_ptr = next;
 352         }
 353         res = 0;
 354  fail:
 355         tdb_unlock(tdb, -1, F_WRLCK);
 356         return res;
 357 }
 358
 359 /* delete an entry in the database given a key */
 360 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 361 {
 362         tdb_off_t rec_ptr;
 363         struct list_struct rec;
 364         int ret;
 365
 366         if (tdb->max_dead_records != 0) {
 367
 368                 /*
 369                  * Allow for some dead records per hash chain, mainly for
 370                  * tdb's with a very high create/delete rate like locking.tdb.
 371                  */
 372
 373                 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 374                         return -1;
 375
 376                 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
 377                         /*
 378                          * Don't let the per-chain freelist grow too large,
 379                          * delete all existing dead records
 380                          */
 381                         tdb_purge_dead(tdb, hash);
 382                 }
 383
 384                 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
 385                         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 386                         return -1;
 387                 }
 388
 389                 /*
 390                  * Just mark the record as dead.
 391                  */
 392                 rec.magic = TDB_DEAD_MAGIC;
 393                 ret = tdb_rec_write(tdb, rec_ptr, &rec);
 394         }
 395         else {
 396                 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
 397                                                    &rec)))
 398                         return -1;
 399
 400                 ret = tdb_do_delete(tdb, rec_ptr, &rec);
 401         }
 402
 403         if (ret == 0) {
 404                 tdb_increment_seqnum(tdb);
 405         }
 406
 407         if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
 408                 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
 409         return ret;
 410 }
 411
 412 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
 413 {
 414         uint32_t hash = tdb->hash_fn(&key);
 415         int ret;
 416
 417         ret = tdb_delete_hash(tdb, key, hash);
 418         tdb_trace(tdb, "tdb_delete ");
 419         tdb_trace_record(tdb, key);
 420         tdb_trace(tdb, "= %i\n", ret);
 421         return ret;
 422 }
 423
 424 /*
 425  * See if we have a dead record around with enough space
 426  */
 427 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
 428                                struct list_struct *r, tdb_len_t length)
 429 {
 430         tdb_off_t rec_ptr;
 431
 432         /* read in the hash top */
 433         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 434                 return 0;
 435
 436         /* keep looking until we find the right record */
 437         while (rec_ptr) {
 438                 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
 439                         return 0;
 440
 441                 if (TDB_DEAD(r) && r->rec_len >= length) {
 442                         /*
 443                          * First fit for simple coding, TODO: change to best
 444                          * fit
 445                          */
 446                         return rec_ptr;
 447                 }
 448                 rec_ptr = r->next;
 449         }
 450         return 0;
 451 }
 452
 453 /* store an element in the database, replacing any existing element
 454    with the same key
 455
 456    return 0 on success, -1 on failure
 457 */
 458 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
 459 {
 460         struct list_struct rec;
 461         uint32_t hash;
 462         tdb_off_t rec_ptr;
 463         char *p = NULL;
 464         int ret = -1;
 465
 466         if (tdb->read_only || tdb->traverse_read) {
 467                 tdb->ecode = TDB_ERR_RDONLY;
 468                 return -1;
 469         }
 470
 471         /* find which hash bucket it is in */
 472         hash = tdb->hash_fn(&key);
 473         if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 474                 return -1;
 475
 476         tdb_trace(tdb, "tdb_store %s ", flag == TDB_INSERT ? "insert" :
 477                   flag == TDB_MODIFY ? "modify" : "normal");
 478         tdb_trace_record(tdb, key);
 479         tdb_trace_record(tdb, dbuf);
 480
 481         /* check for it existing, on insert. */
 482         if (flag == TDB_INSERT) {
 483                 if (tdb_exists_hash(tdb, key, hash)) {
 484                         tdb->ecode = TDB_ERR_EXISTS;
 485                         tdb_trace(tdb, "= EEXIST\n");
 486                         goto fail;
 487                 }
 488         } else {
 489                 /* first try in-place update, on modify or replace. */
 490                 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
 491                         tdb_trace(tdb, "= inplace\n");
 492                         goto done;
 493                 }
 494                 if (tdb->ecode == TDB_ERR_NOEXIST &&
 495                     flag == TDB_MODIFY) {
 496                         /* if the record doesn't exist and we are in TDB_MODIFY mode then
 497                          we should fail the store */
 498                         tdb_trace(tdb, "= ENOENT\n");
 499                         goto fail;
 500                 }
 501         }
 502         /* reset the error code potentially set by the tdb_update() */
 503         tdb->ecode = TDB_SUCCESS;
 504
 505         /* delete any existing record - if it doesn't exist we don't
 506            care.  Doing this first reduces fragmentation, and avoids
 507            coalescing with `allocated' block before it's updated. */
 508         if (flag != TDB_INSERT)
 509                 tdb_delete_hash(tdb, key, hash);
 510
 511         /* Copy key+value *before* allocating free space in case malloc
 512            fails and we are left with a dead spot in the tdb. */
 513
 514         if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
 515                 tdb->ecode = TDB_ERR_OOM;
 516                 goto fail;
 517         }
 518
 519         memcpy(p, key.dptr, key.dsize);
 520         if (dbuf.dsize)
 521                 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
 522
 523         if (tdb->max_dead_records != 0) {
 524                 /*
 525                  * Allow for some dead records per hash chain, look if we can
 526                  * find one that can hold the new record. We need enough space
 527                  * for key, data and tailer. If we find one, we don't have to
 528                  * consult the central freelist.
 529                  */
 530                 rec_ptr = tdb_find_dead(
 531                         tdb, hash, &rec,
 532                         key.dsize + dbuf.dsize + sizeof(tdb_off_t));
 533
 534                 if (rec_ptr != 0) {
 535                         rec.key_len = key.dsize;
 536                         rec.data_len = dbuf.dsize;
 537                         rec.full_hash = hash;
 538                         rec.magic = TDB_MAGIC;
 539                         if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
 540                             || tdb->methods->tdb_write(
 541                                     tdb, rec_ptr + sizeof(rec),
 542                                     p, key.dsize + dbuf.dsize) == -1) {
 543                                 goto fail;
 544                         }
 545                         goto done;
 546                         tdb_trace(tdb, "= fromdead\n");
 547                 }
 548         }
 549
 550         /*
 551          * We have to allocate some space from the freelist, so this means we
 552          * have to lock it. Use the chance to purge all the DEAD records from
 553          * the hash chain under the freelist lock.
 554          */
 555
 556         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 557                 goto fail;
 558         }
 559
 560         if ((tdb->max_dead_records != 0)
 561             && (tdb_purge_dead(tdb, hash) == -1)) {
 562                 tdb_unlock(tdb, -1, F_WRLCK);
 563                 goto fail;
 564         }
 565
 566         /* we have to allocate some space */
 567         rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
 568
 569         tdb_unlock(tdb, -1, F_WRLCK);
 570
 571         if (rec_ptr == 0) {
 572                 goto fail;
 573         }
 574
 575         /* Read hash top into next ptr */
 576         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
 577                 goto fail;
 578
 579         rec.key_len = key.dsize;
 580         rec.data_len = dbuf.dsize;
 581         rec.full_hash = hash;
 582         rec.magic = TDB_MAGIC;
 583
 584         tdb_trace(tdb, "= allocate\n");
 585
 586         /* write out and point the top of the hash chain at it */
 587         if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
 588             || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
 589             || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
 590                 /* Need to tdb_unallocate() here */
 591                 goto fail;
 592         }
 593
 594  done:
 595         ret = 0;
 596  fail:
 597         if (ret == 0) {
 598                 tdb_increment_seqnum(tdb);
 599         }
 600
 601         SAFE_FREE(p);
 602         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 603         return ret;
 604 }
 605
 606
 607 /* Append to an entry. Create if not exist. */
 608 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
 609 {
 610         uint32_t hash;
 611         TDB_DATA dbuf;
 612         int ret = -1;
 613
 614         /* find which hash bucket it is in */
 615         hash = tdb->hash_fn(&key);
 616         if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 617                 return -1;
 618
 619         dbuf = tdb_fetch(tdb, key);
 620         tdb_trace(tdb, "tdb_append ");
 621         tdb_trace_record(tdb, key);
 622         tdb_trace_record(tdb, dbuf);
 623         tdb_trace(tdb, "= %s\n", dbuf.dptr ? "insert" : "append");
 624
 625         if (dbuf.dptr == NULL) {
 626                 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
 627         } else {
 628                 unsigned char *new_dptr = (unsigned char *)realloc(dbuf.dptr,
 629                                                      dbuf.dsize + new_dbuf.dsize);
 630                 if (new_dptr == NULL) {
 631                         free(dbuf.dptr);
 632                 }
 633                 dbuf.dptr = new_dptr;
 634         }
 635
 636         if (dbuf.dptr == NULL) {
 637                 tdb->ecode = TDB_ERR_OOM;
 638                 goto failed;
 639         }
 640
 641         memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
 642         dbuf.dsize += new_dbuf.dsize;
 643
 644         ret = tdb_store(tdb, key, dbuf, 0);
 645
 646 failed:
 647         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 648         SAFE_FREE(dbuf.dptr);
 649         return ret;
 650 }
 651
 652
 653 /*
 654   return the name of the current tdb file
 655   useful for external logging functions
 656 */
 657 const char *tdb_name(struct tdb_context *tdb)
 658 {
 659         return tdb->name;
 660 }
 661
 662 /*
 663   return the underlying file descriptor being used by tdb, or -1
 664   useful for external routines that want to check the device/inode
 665   of the fd
 666 */
 667 int tdb_fd(struct tdb_context *tdb)
 668 {
 669         return tdb->fd;
 670 }
 671
 672 /*
 673   return the current logging function
 674   useful for external tdb routines that wish to log tdb errors
 675 */
 676 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
 677 {
 678         return tdb->log.log_fn;
 679 }
 680
 681
 682 /*
 683   get the tdb sequence number. Only makes sense if the writers opened
 684   with TDB_SEQNUM set. Note that this sequence number will wrap quite
 685   quickly, so it should only be used for a 'has something changed'
 686   test, not for code that relies on the count of the number of changes
 687   made. If you want a counter then use a tdb record.
 688
 689   The aim of this sequence number is to allow for a very lightweight
 690   test of a possible tdb change.
 691 */
 692 int tdb_get_seqnum(struct tdb_context *tdb)
 693 {
 694         tdb_off_t seqnum=0;
 695
 696         tdb_trace(tdb, "tdb_get_seqnum\n");
 697         tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
 698         return seqnum;
 699 }
 700
 701 int tdb_hash_size(struct tdb_context *tdb)
 702 {
 703         return tdb->header.hash_size;
 704 }
 705
 706 size_t tdb_map_size(struct tdb_context *tdb)
 707 {
 708         return tdb->map_size;
 709 }
 710
 711 int tdb_get_flags(struct tdb_context *tdb)
 712 {
 713         return tdb->flags;
 714 }
 715
 716 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
 717 {
 718         tdb->flags |= flags;
 719 }
 720
 721 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
 722 {
 723         tdb->flags &= ~flags;
 724 }
 725
 726
 727 /*
 728   enable sequence number handling on an open tdb
 729 */
 730 void tdb_enable_seqnum(struct tdb_context *tdb)
 731 {
 732         tdb->flags |= TDB_SEQNUM;
 733 }
 734
 735
 736 /*
 737   add a region of the file to the freelist. Length is the size of the region in bytes,
 738   which includes the free list header that needs to be added
 739  */
 740 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
 741 {
 742         struct list_struct rec;
 743         if (length <= sizeof(rec)) {
 744                 /* the region is not worth adding */
 745                 return 0;
 746         }
 747         if (length + offset > tdb->map_size) {
 748                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
 749                 return -1;
 750         }
 751         memset(&rec,'\0',sizeof(rec));
 752         rec.rec_len = length - sizeof(rec);
 753         if (tdb_free(tdb, offset, &rec) == -1) {
 754                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
 755                 return -1;
 756         }
 757         return 0;
 758 }
 759
 760 /*
 761   wipe the entire database, deleting all records. This can be done
 762   very fast by using a global lock. The entire data portion of the
 763   file becomes a single entry in the freelist.
 764
 765   This code carefully steps around the recovery area, leaving it alone
 766  */
 767 int tdb_wipe_all(struct tdb_context *tdb)
 768 {
 769         int i;
 770         tdb_off_t offset = 0;
 771         ssize_t data_len;
 772         tdb_off_t recovery_head;
 773         tdb_len_t recovery_size = 0;
 774
 775         if (tdb_lockall(tdb) != 0) {
 776                 return -1;
 777         }
 778
 779         tdb_trace(tdb, "tdb_wipe_all\n");
 780
 781         /* see if the tdb has a recovery area, and remember its size
 782            if so. We don't want to lose this as otherwise each
 783            tdb_wipe_all() in a transaction will increase the size of
 784            the tdb by the size of the recovery area */
 785         if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
 786                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
 787                 goto failed;
 788         }
 789
 790         if (recovery_head != 0) {
 791                 struct list_struct rec;
 792                 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
 793                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
 794                         return -1;
 795                 }
 796                 recovery_size = rec.rec_len + sizeof(rec);
 797         }
 798
 799         /* wipe the hashes */
 800         for (i=0;i<tdb->header.hash_size;i++) {
 801                 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
 802                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
 803                         goto failed;
 804                 }
 805         }
 806
 807         /* wipe the freelist */
 808         if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
 809                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
 810                 goto failed;
 811         }
 812
 813         /* add all the rest of the file to the freelist, possibly leaving a gap
 814            for the recovery area */
 815         if (recovery_size == 0) {
 816                 /* the simple case - the whole file can be used as a freelist */
 817                 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
 818                 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
 819                         goto failed;
 820                 }
 821         } else {
 822                 /* we need to add two freelist entries - one on either
 823                    side of the recovery area
 824
 825                    Note that we cannot shift the recovery area during
 826                    this operation. Only the transaction.c code may
 827                    move the recovery area or we risk subtle data
 828                    corruption
 829                 */
 830                 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
 831                 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
 832                         goto failed;
 833                 }
 834                 /* and the 2nd free list entry after the recovery area - if any */
 835                 data_len = tdb->map_size - (recovery_head+recovery_size);
 836                 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
 837                         goto failed;
 838                 }
 839         }
 840
 841         if (tdb_unlockall(tdb) != 0) {
 842                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
 843                 goto failed;
 844         }
 845
 846         return 0;
 847
 848 failed:
 849         tdb_unlockall(tdb);
 850         return -1;
 851 }
 852
 853 #ifdef TDB_TRACE
 854 #include <stdarg.h>
 855
 856 void tdb_trace(const struct tdb_context *tdb, const char *fmt, ...)
 857 {
 858         char msg[256];
 859         va_list args;
 860         int len;
 861
 862         va_start(args, fmt);
 863         len = vsprintf(msg, fmt, args);
 864         va_end(args);
 865
 866         write(tdb->tracefd, msg, len);
 867 }
 868
 869 void tdb_trace_record(const struct tdb_context *tdb, TDB_DATA rec)
 870 {
 871         char msg[20];
 872         unsigned int i;
 873
 874         write(tdb->tracefd, msg, sprintf(msg, "%zu:", rec.dsize));
 875         for (i = 0; i < rec.dsize; i++)
 876                 write(tdb->tracefd, msg, sprintf(msg, "%02x", rec.dptr[i]));
 877         write(tdb->tracefd, " ", 1);
 878 }
 879 #endif