lib/dbwrap/dbwrap_util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Utility functions for the dbwrap API
   4    Copyright (C) Volker Lendecke 2007
   5    Copyright (C) Michael Adam 2009
   6    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
   7
   8    Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "dbwrap.h"
  27 #include "lib/util/util_tdb.h"
  28
  29 struct dbwrap_fetch_int32_state {
  30         NTSTATUS status;
  31         int32_t result;
  32 };
  33
  34 static void dbwrap_fetch_int32_parser(TDB_DATA key, TDB_DATA data,
  35                                       void *private_data)
  36 {
  37         struct dbwrap_fetch_int32_state *state =
  38                 (struct dbwrap_fetch_int32_state *)private_data;
  39
  40         if (data.dsize != sizeof(state->result)) {
  41                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
  42                 return;
  43         }
  44         state->result = IVAL(data.dptr, 0);
  45         state->status = NT_STATUS_OK;
  46 }
  47
  48 NTSTATUS dbwrap_fetch_int32(struct db_context *db, TDB_DATA key,
  49                             int32_t *result)
  50 {
  51         struct dbwrap_fetch_int32_state state;
  52         NTSTATUS status;
  53
  54         if (result == NULL) {
  55                 return NT_STATUS_INVALID_PARAMETER;
  56         }
  57
  58         state.status = NT_STATUS_INTERNAL_ERROR;
  59
  60         status = dbwrap_parse_record(db, key, dbwrap_fetch_int32_parser, &state);
  61         if (!NT_STATUS_IS_OK(status)) {
  62                 return status;
  63         }
  64
  65         if (NT_STATUS_IS_OK(state.status)) {
  66                 *result = state.result;
  67         }
  68         return state.status;
  69 }
  70
  71 NTSTATUS dbwrap_fetch_int32_bystring(struct db_context *db, const char *keystr,
  72                                      int32_t *result)
  73 {
  74         return dbwrap_fetch_int32(db, string_term_tdb_data(keystr), result);
  75 }
  76
  77 NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr,
  78                                      int32_t v)
  79 {
  80         struct db_record *rec;
  81         int32_t v_store;
  82         NTSTATUS status;
  83
  84         rec = dbwrap_fetch_locked(db, talloc_tos(),
  85                                   string_term_tdb_data(keystr));
  86         if (rec == NULL) {
  87                 return NT_STATUS_UNSUCCESSFUL;
  88         }
  89
  90         SIVAL(&v_store, 0, v);
  91
  92         status = dbwrap_record_store(rec,
  93                                      make_tdb_data((const uint8_t *)&v_store,
  94                                                    sizeof(v_store)),
  95                                      TDB_REPLACE);
  96         TALLOC_FREE(rec);
  97         return status;
  98 }
  99
 100 struct dbwrap_fetch_uint32_state {
 101         NTSTATUS status;
 102         uint32_t result;
 103 };
 104
 105 static void dbwrap_fetch_uint32_parser(TDB_DATA key, TDB_DATA data,
 106                                        void *private_data)
 107 {
 108         struct dbwrap_fetch_uint32_state *state =
 109                 (struct dbwrap_fetch_uint32_state *)private_data;
 110
 111         if (data.dsize != sizeof(state->result)) {
 112                 state->status = NT_STATUS_INTERNAL_DB_CORRUPTION;
 113                 return;
 114         }
 115         state->result = IVAL(data.dptr, 0);
 116         state->status = NT_STATUS_OK;
 117 }
 118
 119 NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db,
 120                                       const char *keystr, uint32_t *val)
 121 {
 122         struct dbwrap_fetch_uint32_state state;
 123         NTSTATUS status;
 124
 125         if (val == NULL) {
 126                 return NT_STATUS_INVALID_PARAMETER;
 127         }
 128
 129         state.status = NT_STATUS_INTERNAL_ERROR;
 130
 131         status = dbwrap_parse_record(db, string_term_tdb_data(keystr),
 132                                      dbwrap_fetch_uint32_parser, &state);
 133         if (!NT_STATUS_IS_OK(status)) {
 134                 return status;
 135         }
 136         if (NT_STATUS_IS_OK(state.status)) {
 137                 *val = state.result;
 138         }
 139         return state.status;
 140 }
 141
 142 NTSTATUS dbwrap_store_uint32_bystring(struct db_context *db,
 143                                       const char *keystr, uint32_t v)
 144 {
 145         struct db_record *rec;
 146         uint32_t v_store;
 147         NTSTATUS status;
 148
 149         rec = dbwrap_fetch_locked(db, talloc_tos(),
 150                                   string_term_tdb_data(keystr));
 151         if (rec == NULL) {
 152                 return NT_STATUS_INVALID_PARAMETER;
 153         }
 154
 155         SIVAL(&v_store, 0, v);
 156
 157         status = dbwrap_record_store(rec,
 158                                      make_tdb_data((const uint8_t *)&v_store,
 159                                                    sizeof(v_store)),
 160                                      TDB_REPLACE);
 161         TALLOC_FREE(rec);
 162         return status;
 163 }
 164
 165 /**
 166  * Atomic unsigned integer change (addition):
 167  *
 168  * if value does not exist yet in the db, use *oldval as initial old value.
 169  * return old value in *oldval.
 170  * store *oldval + change_val to db.
 171  */
 172
 173 struct dbwrap_change_uint32_atomic_context {
 174         const char *keystr;
 175         uint32_t *oldval;
 176         uint32_t change_val;
 177 };
 178
 179 static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db,
 180                                                    void *private_data)
 181 {
 182         struct db_record *rec;
 183         uint32_t val = (uint32_t)-1;
 184         uint32_t v_store;
 185         NTSTATUS ret;
 186         struct dbwrap_change_uint32_atomic_context *state;
 187         TDB_DATA value;
 188
 189         state = (struct dbwrap_change_uint32_atomic_context *)private_data;
 190
 191         rec = dbwrap_fetch_locked(db, talloc_tos(),
 192                                   string_term_tdb_data(state->keystr));
 193         if (!rec) {
 194                 return NT_STATUS_UNSUCCESSFUL;
 195         }
 196
 197         value = dbwrap_record_get_value(rec);
 198
 199         if (value.dptr == NULL) {
 200                 val = *(state->oldval);
 201         } else if (value.dsize == sizeof(val)) {
 202                 val = IVAL(value.dptr, 0);
 203                 *(state->oldval) = val;
 204         } else {
 205                 ret = NT_STATUS_UNSUCCESSFUL;
 206                 goto done;
 207         }
 208
 209         val += state->change_val;
 210
 211         SIVAL(&v_store, 0, val);
 212
 213         ret = dbwrap_record_store(rec,
 214                                   make_tdb_data((const uint8_t *)&v_store,
 215                                                 sizeof(v_store)),
 216                                   TDB_REPLACE);
 217
 218 done:
 219         TALLOC_FREE(rec);
 220         return ret;
 221 }
 222
 223 NTSTATUS dbwrap_change_uint32_atomic_bystring(struct db_context *db,
 224                                               const char *keystr,
 225                                               uint32_t *oldval,
 226                                               uint32_t change_val)
 227 {
 228         NTSTATUS ret;
 229         struct dbwrap_change_uint32_atomic_context state;
 230
 231         state.keystr = keystr;
 232         state.oldval = oldval;
 233         state.change_val = change_val;
 234
 235         ret = dbwrap_change_uint32_atomic_action(db, &state);
 236
 237         return ret;
 238 }
 239
 240 NTSTATUS dbwrap_trans_change_uint32_atomic_bystring(struct db_context *db,
 241                                                     const char *keystr,
 242                                                     uint32_t *oldval,
 243                                                     uint32_t change_val)
 244 {
 245         NTSTATUS ret;
 246         struct dbwrap_change_uint32_atomic_context state;
 247
 248         state.keystr = keystr;
 249         state.oldval = oldval;
 250         state.change_val = change_val;
 251
 252         ret = dbwrap_trans_do(db, dbwrap_change_uint32_atomic_action, &state);
 253
 254         return ret;
 255 }
 256
 257 /**
 258  * Atomic integer change (addition):
 259  *
 260  * if value does not exist yet in the db, use *oldval as initial old value.
 261  * return old value in *oldval.
 262  * store *oldval + change_val to db.
 263  */
 264
 265 struct dbwrap_change_int32_atomic_context {
 266         TDB_DATA key;
 267         int32_t *oldval;
 268         int32_t change_val;
 269 };
 270
 271 static NTSTATUS dbwrap_change_int32_atomic_action(struct db_context *db,
 272                                                   void *private_data)
 273 {
 274         struct db_record *rec;
 275         int32_t val = -1;
 276         int32_t v_store;
 277         NTSTATUS ret;
 278         struct dbwrap_change_int32_atomic_context *state;
 279         TDB_DATA value;
 280
 281         state = (struct dbwrap_change_int32_atomic_context *)private_data;
 282
 283         rec = dbwrap_fetch_locked(db, talloc_tos(), state->key);
 284         if (!rec) {
 285                 return NT_STATUS_UNSUCCESSFUL;
 286         }
 287
 288         value = dbwrap_record_get_value(rec);
 289
 290         if (value.dptr == NULL) {
 291                 val = *(state->oldval);
 292         } else if (value.dsize == sizeof(val)) {
 293                 val = IVAL(value.dptr, 0);
 294                 *(state->oldval) = val;
 295         } else {
 296                 ret = NT_STATUS_UNSUCCESSFUL;
 297                 goto done;
 298         }
 299
 300         val += state->change_val;
 301
 302         SIVAL(&v_store, 0, val);
 303
 304         ret = dbwrap_record_store(rec,
 305                                   make_tdb_data((const uint8_t *)&v_store,
 306                                                 sizeof(v_store)),
 307                                   TDB_REPLACE);
 308
 309 done:
 310         TALLOC_FREE(rec);
 311         return ret;
 312 }
 313
 314 NTSTATUS dbwrap_change_int32_atomic(struct db_context *db,
 315                                     TDB_DATA key,
 316                                     int32_t *oldval,
 317                                     int32_t change_val)
 318 {
 319         NTSTATUS ret;
 320         struct dbwrap_change_int32_atomic_context state;
 321
 322         state.key = key;
 323         state.oldval = oldval;
 324         state.change_val = change_val;
 325
 326         ret = dbwrap_change_int32_atomic_action(db, &state);
 327
 328         return ret;
 329 }
 330
 331 NTSTATUS dbwrap_change_int32_atomic_bystring(struct db_context *db,
 332                                              const char *keystr,
 333                                              int32_t *oldval,
 334                                              int32_t change_val)
 335 {
 336         return dbwrap_change_int32_atomic(db, string_term_tdb_data(keystr),
 337                                           oldval, change_val);
 338 }
 339
 340 NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db,
 341                                                    const char *keystr,
 342                                                    int32_t *oldval,
 343                                                    int32_t change_val)
 344 {
 345         NTSTATUS ret;
 346         struct dbwrap_change_int32_atomic_context state;
 347
 348         state.key = string_term_tdb_data(keystr);
 349         state.oldval = oldval;
 350         state.change_val = change_val;
 351
 352         ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state);
 353
 354         return ret;
 355 }
 356
 357 struct dbwrap_store_context {
 358         TDB_DATA *key;
 359         TDB_DATA *dbuf;
 360         int flag;
 361 };
 362
 363 static NTSTATUS dbwrap_store_action(struct db_context *db, void *private_data)
 364 {
 365         struct db_record *rec = NULL;
 366         NTSTATUS status;
 367         struct dbwrap_store_context *store_ctx;
 368
 369         store_ctx = (struct dbwrap_store_context *)private_data;
 370
 371         rec = dbwrap_fetch_locked(db, talloc_tos(), *(store_ctx->key));
 372         if (rec == NULL) {
 373                 DEBUG(5, ("fetch_locked failed\n"));
 374                 return NT_STATUS_NO_MEMORY;
 375         }
 376
 377         status = dbwrap_record_store(rec, *(store_ctx->dbuf), store_ctx->flag);
 378         if (!NT_STATUS_IS_OK(status)) {
 379                 DEBUG(5, ("store returned %s\n", nt_errstr(status)));
 380         }
 381
 382         TALLOC_FREE(rec);
 383         return status;
 384 }
 385
 386 NTSTATUS dbwrap_trans_store(struct db_context *db, TDB_DATA key, TDB_DATA dbuf,
 387                             int flag)
 388 {
 389         NTSTATUS status;
 390         struct dbwrap_store_context store_ctx;
 391
 392         store_ctx.key = &key;
 393         store_ctx.dbuf = &dbuf;
 394         store_ctx.flag = flag;
 395
 396         status = dbwrap_trans_do(db, dbwrap_store_action, &store_ctx);
 397
 398         return status;
 399 }
 400
 401 static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
 402 {
 403         NTSTATUS status;
 404         struct db_record *rec;
 405         TDB_DATA *key = (TDB_DATA *)private_data;
 406
 407         rec = dbwrap_fetch_locked(db, talloc_tos(), *key);
 408         if (rec == NULL) {
 409                 DEBUG(5, ("fetch_locked failed\n"));
 410                 return NT_STATUS_NO_MEMORY;
 411         }
 412
 413         status = dbwrap_record_delete(rec);
 414         if (!NT_STATUS_IS_OK(status)) {
 415                 DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status)));
 416         }
 417
 418         talloc_free(rec);
 419         return  status;
 420 }
 421
 422 NTSTATUS dbwrap_trans_delete(struct db_context *db, TDB_DATA key)
 423 {
 424         NTSTATUS status;
 425
 426         status = dbwrap_trans_do(db, dbwrap_delete_action, &key);
 427
 428         return status;
 429 }
 430
 431 NTSTATUS dbwrap_trans_store_int32_bystring(struct db_context *db,
 432                                            const char *keystr,
 433                                            int32_t v)
 434 {
 435         int32_t v_store;
 436
 437         SIVAL(&v_store, 0, v);
 438
 439         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 440                                   make_tdb_data((const uint8_t *)&v_store,
 441                                                 sizeof(v_store)),
 442                                   TDB_REPLACE);
 443 }
 444
 445 NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db,
 446                                             const char *keystr,
 447                                             uint32_t v)
 448 {
 449         uint32_t v_store;
 450
 451         SIVAL(&v_store, 0, v);
 452
 453         return dbwrap_trans_store(db, string_term_tdb_data(keystr),
 454                                   make_tdb_data((const uint8_t *)&v_store,
 455                                                 sizeof(v_store)),
 456                                   TDB_REPLACE);
 457 }
 458
 459 NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,
 460                                      TDB_DATA data, int flags)
 461 {
 462         return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);
 463 }
 464
 465 NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key)
 466 {
 467         return dbwrap_trans_delete(db, string_term_tdb_data(key));
 468 }
 469
 470 /**
 471  * Wrap db action(s) into a transaction.
 472  */
 473 NTSTATUS dbwrap_trans_do(struct db_context *db,
 474                          NTSTATUS (*action)(struct db_context *, void *),
 475                          void *private_data)
 476 {
 477         int res;
 478         NTSTATUS status;
 479
 480         res = dbwrap_transaction_start(db);
 481         if (res != 0) {
 482                 DEBUG(5, ("transaction_start failed\n"));
 483                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 484         }
 485
 486         status = action(db, private_data);
 487         if (!NT_STATUS_IS_OK(status)) {
 488                 if (dbwrap_transaction_cancel(db) != 0) {
 489                         smb_panic("Cancelling transaction failed");
 490                 }
 491                 return status;
 492         }
 493
 494         res = dbwrap_transaction_commit(db);
 495         if (res == 0) {
 496                 return NT_STATUS_OK;
 497         }
 498
 499         DEBUG(2, ("transaction_commit failed\n"));
 500         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 501 }
 502
 503 struct dbwrap_trans_traverse_action_ctx {
 504         int (*f)(struct db_record* rec, void* private_data);
 505         void* private_data;
 506 };
 507
 508
 509 static NTSTATUS dbwrap_trans_traverse_action(struct db_context* db, void* private_data)
 510 {
 511         struct dbwrap_trans_traverse_action_ctx* ctx =
 512                 (struct dbwrap_trans_traverse_action_ctx*)private_data;
 513
 514         NTSTATUS status = dbwrap_traverse(db, ctx->f, ctx->private_data, NULL);
 515
 516         return status;
 517 }
 518
 519 NTSTATUS dbwrap_trans_traverse(struct db_context *db,
 520                                int (*f)(struct db_record*, void*),
 521                                void *private_data)
 522 {
 523         struct dbwrap_trans_traverse_action_ctx ctx = {
 524                 .f = f,
 525                 .private_data = private_data,
 526         };
 527         return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
 528 }
 529
 530 NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
 531 {
 532         return dbwrap_delete(db, string_term_tdb_data(key));
 533 }
 534
 535 NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
 536                                TDB_DATA data, int flags)
 537 {
 538         return dbwrap_store(db, string_term_tdb_data(key), data, flags);
 539 }
 540
 541 NTSTATUS dbwrap_fetch_bystring(struct db_context *db, TALLOC_CTX *mem_ctx,
 542                                const char *key, TDB_DATA *value)
 543 {
 544         return dbwrap_fetch(db, mem_ctx, string_term_tdb_data(key), value);
 545 }
 546
 547
 548
 549 NTSTATUS dbwrap_delete_bystring_upper(struct db_context *db, const char *key)
 550 {
 551         char *key_upper;
 552         NTSTATUS status;
 553
 554         key_upper = talloc_strdup_upper(talloc_tos(), key);
 555         if (key_upper == NULL) {
 556                 return NT_STATUS_NO_MEMORY;
 557         }
 558
 559         status = dbwrap_delete_bystring(db, key_upper);
 560
 561         talloc_free(key_upper);
 562         return status;
 563 }
 564
 565 NTSTATUS dbwrap_store_bystring_upper(struct db_context *db, const char *key,
 566                                      TDB_DATA data, int flags)
 567 {
 568         char *key_upper;
 569         NTSTATUS status;
 570
 571         key_upper = talloc_strdup_upper(talloc_tos(), key);
 572         if (key_upper == NULL) {
 573                 return NT_STATUS_NO_MEMORY;
 574         }
 575
 576         status = dbwrap_store_bystring(db, key_upper, data, flags);
 577
 578         talloc_free(key_upper);
 579         return status;
 580 }
 581
 582 NTSTATUS dbwrap_fetch_bystring_upper(struct db_context *db, TALLOC_CTX *mem_ctx,
 583                                      const char *key, TDB_DATA *value)
 584 {
 585         char *key_upper;
 586         NTSTATUS status;
 587
 588         key_upper = talloc_strdup_upper(talloc_tos(), key);
 589         if (key_upper == NULL) {
 590                 return NT_STATUS_NO_MEMORY;
 591         }
 592
 593         status = dbwrap_fetch_bystring(db, mem_ctx, key_upper, value);
 594
 595         talloc_free(key_upper);
 596         return status;
 597 }
 598
 599 struct dbwrap_marshall_state {
 600         uint8_t *buf;
 601         size_t bufsize;
 602         size_t dbsize;
 603 };
 604
 605 static int dbwrap_marshall_fn(struct db_record *rec, void *private_data)
 606 {
 607         struct dbwrap_marshall_state *state = private_data;
 608         TDB_DATA key, value;
 609         size_t new_dbsize;
 610
 611         key = dbwrap_record_get_key(rec);
 612         value = dbwrap_record_get_value(rec);
 613
 614         new_dbsize = state->dbsize;
 615         new_dbsize += 8 + key.dsize;
 616         new_dbsize += 8 + value.dsize;
 617
 618         if (new_dbsize <= state->bufsize) {
 619                 uint8_t *p = state->buf + state->dbsize;
 620
 621                 SBVAL(p, 0, key.dsize);
 622                 p += 8;
 623                 memcpy(p, key.dptr, key.dsize);
 624                 p += key.dsize;
 625
 626                 SBVAL(p, 0, value.dsize);
 627                 p += 8;
 628                 memcpy(p, value.dptr, value.dsize);
 629         }
 630         state->dbsize = new_dbsize;
 631         return 0;
 632 }
 633
 634 size_t dbwrap_marshall(struct db_context *db, uint8_t *buf, size_t bufsize)
 635 {
 636         struct dbwrap_marshall_state state;
 637
 638         state.bufsize = bufsize;
 639         state.buf = buf;
 640         state.dbsize = 0;
 641
 642         dbwrap_traverse_read(db, dbwrap_marshall_fn, &state, NULL);
 643
 644         return state.dbsize;
 645 }
 646
 647 static ssize_t dbwrap_unmarshall_get_data(const uint8_t *buf, size_t buflen,
 648                                           size_t ofs, TDB_DATA *pdata)
 649 {
 650         uint64_t space, len;
 651         const uint8_t *p;
 652
 653         if (ofs == buflen) {
 654                 return 0;
 655         }
 656         if (ofs > buflen) {
 657                 return -1;
 658         }
 659
 660         space = buflen - ofs;
 661         if (space < 8) {
 662                 return -1;
 663         }
 664
 665         p = buf + ofs;
 666         len = BVAL(p, 0);
 667
 668         p += 8;
 669         space -= 8;
 670
 671         if (len > space) {
 672                 return -1;
 673         }
 674
 675         *pdata = (TDB_DATA) { .dptr = discard_const_p(uint8_t, p),
 676                               .dsize = len };
 677         return len + 8;
 678 }
 679
 680 NTSTATUS dbwrap_parse_marshall_buf(const uint8_t *buf, size_t buflen,
 681                                    bool (*fn)(TDB_DATA key, TDB_DATA value,
 682                                               void *private_data),
 683                                    void *private_data)
 684 {
 685         size_t ofs = 0;
 686
 687         while (true) {
 688                 ssize_t len;
 689                 TDB_DATA key, value;
 690                 bool ok;
 691
 692                 len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &key);
 693                 if (len == 0) {
 694                         break;
 695                 }
 696                 if (len == -1) {
 697                         return NT_STATUS_INVALID_PARAMETER;
 698                 }
 699                 ofs += len;
 700
 701                 len = dbwrap_unmarshall_get_data(buf, buflen, ofs, &value);
 702                 if (len == 0) {
 703                         break;
 704                 }
 705                 if (len == -1) {
 706                         return NT_STATUS_INVALID_PARAMETER;
 707                 }
 708                 ofs += len;
 709
 710                 ok = fn(key, value, private_data);
 711                 if (!ok) {
 712                         break;
 713                 }
 714         }
 715
 716         return NT_STATUS_OK;
 717 }
 718
 719 struct dbwrap_unmarshall_state {
 720         struct db_context *db;
 721         NTSTATUS ret;
 722 };
 723
 724 static bool dbwrap_unmarshall_fn(TDB_DATA key, TDB_DATA value,
 725                                  void *private_data)
 726 {
 727         struct dbwrap_unmarshall_state *state = private_data;
 728         struct db_record *rec;
 729         NTSTATUS status;
 730
 731         rec = dbwrap_fetch_locked(state->db, state->db, key);
 732         if (rec == NULL) {
 733                 DEBUG(10, ("%s: dbwrap_fetch_locked failed\n",
 734                            __func__));
 735                 state->ret = NT_STATUS_NO_MEMORY;
 736                 return false;
 737         }
 738
 739         status = dbwrap_record_store(rec, value, 0);
 740         TALLOC_FREE(rec);
 741         if (!NT_STATUS_IS_OK(status)) {
 742                 DEBUG(10, ("%s: dbwrap_record_store failed: %s\n",
 743                            __func__, nt_errstr(status)));
 744                 state->ret = status;
 745                 return false;
 746         }
 747
 748         return true;
 749 }
 750
 751 NTSTATUS dbwrap_unmarshall(struct db_context *db, const uint8_t *buf,
 752                            size_t buflen)
 753 {
 754         struct dbwrap_unmarshall_state state = { .db = db };
 755         NTSTATUS status;
 756
 757         status = dbwrap_parse_marshall_buf(buf, buflen,
 758                                            dbwrap_unmarshall_fn, &state);
 759         if (!NT_STATUS_IS_OK(status)) {
 760                 return status;
 761         }
 762         return state.ret;
 763 }