lib/dbwrap/dbwrap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Database interface wrapper
   4    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2006
   5
   6    Major code contributions from Aleksey Fedoseev (fedoseev@ru.ibm.com)
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "replace.h"
  23 #include "lib/util/debug.h"
  24 #include "lib/util/fault.h"
  25 #include "lib/util/talloc_stack.h"
  26 #include "dbwrap/dbwrap.h"
  27 #include "dbwrap/dbwrap_private.h"
  28 #include "lib/util/util_tdb.h"
  29 #include "lib/util/tevent_ntstatus.h"
  30
  31 /*
  32  * Fall back using fetch if no genuine exists operation is provided
  33  */
  34
  35 static int dbwrap_fallback_exists(struct db_context *db, TDB_DATA key)
  36 {
  37         NTSTATUS status = dbwrap_parse_record(db, key, NULL, NULL);
  38         return NT_STATUS_IS_OK(status) ? 1 : 0;
  39 }
  40
  41 static int delete_record(struct db_record *rec, void *data)
  42 {
  43         NTSTATUS status = dbwrap_record_delete(rec);
  44         return NT_STATUS_IS_OK(status) ? 0 : -1;
  45 }
  46
  47 /*
  48  * Fallback wipe implementation using traverse and delete if no genuine
  49  * wipe operation is provided
  50  */
  51 static int dbwrap_fallback_wipe(struct db_context *db)
  52 {
  53         NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL);
  54         return NT_STATUS_IS_OK(status) ? 0 : -1;
  55 }
  56
  57 static int do_nothing(struct db_record *rec, void *unused)
  58 {
  59         return 0;
  60 }
  61
  62 /*
  63  * Fallback check operation: just traverse.
  64  */
  65 static int dbwrap_fallback_check(struct db_context *db)
  66 {
  67         NTSTATUS status = dbwrap_traverse_read(db, do_nothing, NULL, NULL);
  68         return NT_STATUS_IS_OK(status) ? 0 : -1;
  69 }
  70
  71 /*
  72  * Wrapper functions for the backend methods
  73  */
  74
  75 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
  76 {
  77         return rec->key;
  78 }
  79
  80 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
  81 {
  82         return rec->value;
  83 }
  84
  85 NTSTATUS dbwrap_record_storev(struct db_record *rec,
  86                               const TDB_DATA *dbufs, int num_dbufs, int flags)
  87 {
  88         NTSTATUS status;
  89
  90         status = rec->storev(rec, dbufs, num_dbufs, flags);
  91         if (!NT_STATUS_IS_OK(status)) {
  92                 return status;
  93         }
  94         return NT_STATUS_OK;
  95 }
  96
  97 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
  98 {
  99         return dbwrap_record_storev(rec, &data, 1, flags);
 100 }
 101
 102 NTSTATUS dbwrap_record_delete(struct db_record *rec)
 103 {
 104         NTSTATUS status;
 105
 106         status = rec->delete_rec(rec);
 107         if (!NT_STATUS_IS_OK(status)) {
 108                 return status;
 109         }
 110         return NT_STATUS_OK;
 111 }
 112
 113 struct dbwrap_lock_order_state {
 114         struct db_context **locked_dbs;
 115         struct db_context *db;
 116 };
 117
 118 static void debug_lock_order(int level, struct db_context *dbs[])
 119 {
 120         int i;
 121         DEBUG(level, ("lock order: "));
 122         for (i=0; i<DBWRAP_LOCK_ORDER_MAX; i++) {
 123                 DEBUGADD(level, (" %d:%s", i + 1, dbs[i] ? dbs[i]->name : "<none>"));
 124         }
 125         DEBUGADD(level, ("\n"));
 126 }
 127
 128 static int dbwrap_lock_order_state_destructor(
 129         struct dbwrap_lock_order_state *s)
 130 {
 131         int idx = s->db->lock_order - 1;
 132
 133         DEBUG(5, ("release lock order %d for %s\n",
 134                   (int)s->db->lock_order, s->db->name));
 135
 136         if (s->locked_dbs[idx] != s->db) {
 137                 DEBUG(0, ("locked db at lock order %d is %s, expected %s\n",
 138                           idx + 1, s->locked_dbs[idx]->name, s->db->name));
 139                 debug_lock_order(0, s->locked_dbs);
 140                 smb_panic("inconsistent lock_order\n");
 141         }
 142
 143         s->locked_dbs[idx] = NULL;
 144
 145         debug_lock_order(10, s->locked_dbs);
 146
 147         return 0;
 148 }
 149
 150
 151 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
 152         struct db_context *db, TALLOC_CTX *mem_ctx)
 153 {
 154         int idx;
 155         static struct db_context *locked_dbs[DBWRAP_LOCK_ORDER_MAX];
 156         struct dbwrap_lock_order_state *state = NULL;
 157
 158         if (!DBWRAP_LOCK_ORDER_VALID(db->lock_order)) {
 159                 DEBUG(0,("Invalid lock order %d of %s\n",
 160                          (int)db->lock_order, db->name));
 161                 smb_panic("invalid lock_order\n");
 162                 return NULL;
 163         }
 164
 165         DEBUG(5, ("check lock order %d for %s\n",
 166                   (int)db->lock_order, db->name));
 167
 168
 169         for (idx=db->lock_order - 1; idx < DBWRAP_LOCK_ORDER_MAX; idx++) {
 170                 if (locked_dbs[idx] != NULL) {
 171                         DEBUG(0, ("Lock order violation: Trying %s at %d while %s at %d is locked\n",
 172                                   db->name, (int)db->lock_order, locked_dbs[idx]->name, idx + 1));
 173                         debug_lock_order(0, locked_dbs);
 174                         smb_panic("invalid lock_order");
 175                         return NULL;
 176                 }
 177         }
 178
 179         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
 180         if (state == NULL) {
 181                 DEBUG(1, ("talloc failed\n"));
 182                 return NULL;
 183         }
 184         state->db = db;
 185         state->locked_dbs = locked_dbs;
 186         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
 187
 188         locked_dbs[db->lock_order - 1] = db;
 189
 190         debug_lock_order(10, locked_dbs);
 191
 192         return state;
 193 }
 194
 195 static struct db_record *dbwrap_fetch_locked_internal(
 196         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
 197         struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
 198                                    TDB_DATA key))
 199 {
 200         struct db_record *rec;
 201         struct dbwrap_lock_order_state *lock_order = NULL;
 202
 203         if (db->lock_order != DBWRAP_LOCK_ORDER_NONE) {
 204                 lock_order = dbwrap_check_lock_order(db, mem_ctx);
 205                 if (lock_order == NULL) {
 206                         return NULL;
 207                 }
 208         }
 209         rec = db_fn(db, mem_ctx, key);
 210         if (rec == NULL) {
 211                 TALLOC_FREE(lock_order);
 212                 return NULL;
 213         }
 214         (void)talloc_steal(rec, lock_order);
 215         rec->db = db;
 216         return rec;
 217 }
 218
 219 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 220                                       TALLOC_CTX *mem_ctx,
 221                                       TDB_DATA key)
 222 {
 223         return dbwrap_fetch_locked_internal(db, mem_ctx, key,
 224                                             db->fetch_locked);
 225 }
 226
 227 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
 228                                       TALLOC_CTX *mem_ctx,
 229                                       TDB_DATA key)
 230 {
 231         return dbwrap_fetch_locked_internal(
 232                 db, mem_ctx, key,
 233                 db->try_fetch_locked
 234                 ? db->try_fetch_locked : db->fetch_locked);
 235 }
 236
 237 struct db_context *dbwrap_record_get_db(struct db_record *rec)
 238 {
 239         return rec->db;
 240 }
 241
 242 struct dbwrap_fetch_state {
 243         TALLOC_CTX *mem_ctx;
 244         TDB_DATA data;
 245 };
 246
 247 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 248                                 void *private_data)
 249 {
 250         struct dbwrap_fetch_state *state =
 251                 (struct dbwrap_fetch_state *)private_data;
 252
 253         state->data.dsize = data.dsize;
 254         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 255                                                     data.dsize);
 256 }
 257
 258 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 259                       TDB_DATA key, TDB_DATA *value)
 260 {
 261         struct dbwrap_fetch_state state;
 262         NTSTATUS status;
 263
 264         if (value == NULL) {
 265                 return NT_STATUS_INVALID_PARAMETER;
 266         }
 267
 268         state.mem_ctx = mem_ctx;
 269
 270         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 271         if (!NT_STATUS_IS_OK(status)) {
 272                 return status;
 273         }
 274         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 275                 return NT_STATUS_NO_MEMORY;
 276         }
 277         *value = state.data;
 278         return NT_STATUS_OK;
 279 }
 280
 281 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 282 {
 283         int result;
 284         if (db->exists != NULL) {
 285                 result = db->exists(db, key);
 286         } else {
 287                 result = dbwrap_fallback_exists(db,key);
 288         }
 289         return (result == 1);
 290 }
 291
 292 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 293                       TDB_DATA data, int flags)
 294 {
 295         struct db_record *rec;
 296         NTSTATUS status;
 297         TALLOC_CTX *frame = talloc_stackframe();
 298
 299         rec = dbwrap_fetch_locked(db, frame, key);
 300         if (rec == NULL) {
 301                 TALLOC_FREE(frame);
 302                 return NT_STATUS_NO_MEMORY;
 303         }
 304
 305         status = dbwrap_record_store(rec, data, flags);
 306         TALLOC_FREE(frame);
 307         return status;
 308 }
 309
 310 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 311 {
 312         struct db_record *rec;
 313         NTSTATUS status;
 314         TALLOC_CTX *frame = talloc_stackframe();
 315
 316         rec = dbwrap_fetch_locked(db, frame, key);
 317         if (rec == NULL) {
 318                 TALLOC_FREE(frame);
 319                 return NT_STATUS_NO_MEMORY;
 320         }
 321         status = dbwrap_record_delete(rec);
 322         TALLOC_FREE(frame);
 323         return status;
 324 }
 325
 326 NTSTATUS dbwrap_traverse(struct db_context *db,
 327                          int (*f)(struct db_record*, void*),
 328                          void *private_data,
 329                          int *count)
 330 {
 331         int ret = db->traverse(db, f, private_data);
 332
 333         if (ret < 0) {
 334                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 335         }
 336
 337         if (count != NULL) {
 338                 *count = ret;
 339         }
 340
 341         return NT_STATUS_OK;
 342 }
 343
 344 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 345                               int (*f)(struct db_record*, void*),
 346                               void *private_data,
 347                               int *count)
 348 {
 349         int ret = db->traverse_read(db, f, private_data);
 350
 351         if (ret < 0) {
 352                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 353         }
 354
 355         if (count != NULL) {
 356                 *count = ret;
 357         }
 358
 359         return NT_STATUS_OK;
 360 }
 361
 362 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 363 {
 364         return;
 365 }
 366
 367 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 368                              void (*parser)(TDB_DATA key, TDB_DATA data,
 369                                             void *private_data),
 370                              void *private_data)
 371 {
 372         if (parser == NULL) {
 373                 parser = dbwrap_null_parser;
 374         }
 375         return db->parse_record(db, key, parser, private_data);
 376 }
 377
 378 struct dbwrap_parse_record_state {
 379         struct db_context *db;
 380         TDB_DATA key;
 381         uint8_t _keybuf[64];
 382 };
 383
 384 static void dbwrap_parse_record_done(struct tevent_req *subreq);
 385
 386 struct tevent_req *dbwrap_parse_record_send(
 387         TALLOC_CTX *mem_ctx,
 388         struct tevent_context *ev,
 389         struct db_context *db,
 390         TDB_DATA key,
 391         void (*parser)(TDB_DATA key, TDB_DATA data, void *private_data),
 392         void *private_data,
 393         enum dbwrap_req_state *req_state)
 394 {
 395         struct tevent_req *req = NULL;
 396         struct tevent_req *subreq = NULL;
 397         struct dbwrap_parse_record_state *state = NULL;
 398         NTSTATUS status;
 399
 400         req = tevent_req_create(mem_ctx, &state, struct dbwrap_parse_record_state);
 401         if (req == NULL) {
 402                 *req_state = DBWRAP_REQ_ERROR;
 403                 return NULL;
 404         }
 405
 406         *state = (struct dbwrap_parse_record_state) {
 407                 .db = db,
 408         };
 409
 410         if (parser == NULL) {
 411                 parser = dbwrap_null_parser;
 412         }
 413
 414         *req_state = DBWRAP_REQ_INIT;
 415
 416         if (db->parse_record_send == NULL) {
 417                 /*
 418                  * Backend doesn't implement async version, call sync one
 419                  */
 420                 status = db->parse_record(db, key, parser, private_data);
 421                 if (tevent_req_nterror(req, status)) {
 422                         *req_state = DBWRAP_REQ_DONE;
 423                         return tevent_req_post(req, ev);
 424                 }
 425
 426                 *req_state = DBWRAP_REQ_DONE;
 427                 tevent_req_done(req);
 428                 return tevent_req_post(req, ev);
 429         }
 430
 431         /*
 432          * Copy the key into our state ensuring the key data buffer is always
 433          * available to the all dbwrap backend over the entire lifetime of the
 434          * async request. Otherwise the caller might have free'd the key buffer.
 435          */
 436         if (key.dsize > sizeof(state->_keybuf)) {
 437                 state->key.dptr = talloc_memdup(state, key.dptr, key.dsize);
 438                 if (tevent_req_nomem(state->key.dptr, req)) {
 439                         return tevent_req_post(req, ev);
 440                 }
 441         } else {
 442                 memcpy(state->_keybuf, key.dptr, key.dsize);
 443                 state->key.dptr = state->_keybuf;
 444         }
 445         state->key.dsize = key.dsize;
 446
 447         subreq = db->parse_record_send(state,
 448                                        ev,
 449                                        db,
 450                                        state->key,
 451                                        parser,
 452                                        private_data,
 453                                        req_state);
 454         if (tevent_req_nomem(subreq, req)) {
 455                 *req_state = DBWRAP_REQ_ERROR;
 456                 return tevent_req_post(req, ev);
 457         }
 458
 459         tevent_req_set_callback(subreq,
 460                                 dbwrap_parse_record_done,
 461                                 req);
 462         return req;
 463 }
 464
 465 static void dbwrap_parse_record_done(struct tevent_req *subreq)
 466 {
 467         struct tevent_req *req = tevent_req_callback_data(
 468                 subreq, struct tevent_req);
 469         struct dbwrap_parse_record_state *state = tevent_req_data(
 470                 req, struct dbwrap_parse_record_state);
 471         NTSTATUS status;
 472
 473         status = state->db->parse_record_recv(subreq);
 474         TALLOC_FREE(subreq);
 475         if (!NT_STATUS_IS_OK(status)) {
 476                 tevent_req_nterror(req, status);
 477                 return;
 478         }
 479
 480         tevent_req_done(req);
 481         return;
 482 }
 483
 484 NTSTATUS dbwrap_parse_record_recv(struct tevent_req *req)
 485 {
 486         return tevent_req_simple_recv_ntstatus(req);
 487 }
 488
 489 int dbwrap_wipe(struct db_context *db)
 490 {
 491         if (db->wipe == NULL) {
 492                 return dbwrap_fallback_wipe(db);
 493         }
 494         return db->wipe(db);
 495 }
 496
 497 int dbwrap_check(struct db_context *db)
 498 {
 499         if (db->check == NULL) {
 500                 return dbwrap_fallback_check(db);
 501         }
 502         return db->check(db);
 503 }
 504
 505 int dbwrap_get_seqnum(struct db_context *db)
 506 {
 507         return db->get_seqnum(db);
 508 }
 509
 510 int dbwrap_transaction_start(struct db_context *db)
 511 {
 512         if (!db->persistent) {
 513                 /*
 514                  * dbwrap_ctdb has two different data models for persistent
 515                  * and non-persistent databases. Transactions are supported
 516                  * only for the persistent databases. This check is here to
 517                  * prevent breakages of the cluster case, autobuild at this
 518                  * point only tests non-clustered Samba. Before removing this
 519                  * check, please make sure that this facility has also been
 520                  * added to dbwrap_ctdb.
 521                  *
 522                  * Thanks, vl
 523                  */
 524                 DEBUG(1, ("transactions not supported on non-persistent "
 525                           "database %s\n", db->name));
 526                 return -1;
 527         }
 528         return db->transaction_start(db);
 529 }
 530
 531 NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db)
 532 {
 533         if (db->transaction_start_nonblock) {
 534                 return db->transaction_start_nonblock(db);
 535         } else {
 536                 return dbwrap_transaction_start(db) == 0 ? NT_STATUS_OK
 537                         : NT_STATUS_UNSUCCESSFUL;
 538         }
 539 }
 540
 541 int dbwrap_transaction_commit(struct db_context *db)
 542 {
 543         return db->transaction_commit(db);
 544 }
 545
 546 int dbwrap_transaction_cancel(struct db_context *db)
 547 {
 548         return db->transaction_cancel(db);
 549 }
 550
 551 size_t dbwrap_db_id(struct db_context *db, uint8_t *id, size_t idlen)
 552 {
 553         return db->id(db, id, idlen);
 554 }
 555
 556 bool dbwrap_is_persistent(struct db_context *db)
 557 {
 558         return db->persistent;
 559 }
 560
 561 const char *dbwrap_name(struct db_context *db)
 562 {
 563         return db->name;
 564 }
 565
 566 static ssize_t tdb_data_buf(const TDB_DATA *dbufs, int num_dbufs,
 567                             uint8_t *buf, size_t buflen)
 568 {
 569         size_t needed = 0;
 570         uint8_t *p = buf;
 571         int i;
 572
 573         for (i=0; i<num_dbufs; i++) {
 574                 size_t thislen = dbufs[i].dsize;
 575                 size_t tmp;
 576
 577                 tmp = needed + thislen;
 578                 if (tmp < needed) {
 579                         /* wrap */
 580                         return -1;
 581                 }
 582                 needed = tmp;
 583
 584                 if (needed <= buflen) {
 585                         memcpy(p, dbufs[i].dptr, thislen);
 586                         p += thislen;
 587                 }
 588         }
 589
 590         return needed;
 591 }
 592
 593
 594 TDB_DATA dbwrap_merge_dbufs(TALLOC_CTX *mem_ctx,
 595                             const TDB_DATA *dbufs, int num_dbufs)
 596 {
 597         ssize_t len = tdb_data_buf(dbufs, num_dbufs, NULL, 0);
 598         uint8_t *buf;
 599
 600         if (len == -1) {
 601                 return (TDB_DATA) {0};
 602         }
 603
 604         buf = talloc_array(mem_ctx, uint8_t, len);
 605         if (buf == NULL) {
 606                 return (TDB_DATA) {0};
 607         }
 608
 609         tdb_data_buf(dbufs, num_dbufs, buf, len);
 610
 611         return (TDB_DATA) { .dptr = buf, .dsize = len };
 612 }