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_store(struct db_record *rec, TDB_DATA data, int flags)
  86 {
  87         NTSTATUS status;
  88
  89         status = rec->store(rec, data, flags);
  90         if (!NT_STATUS_IS_OK(status)) {
  91                 return status;
  92         }
  93         return NT_STATUS_OK;
  94 }
  95
  96 NTSTATUS dbwrap_record_delete(struct db_record *rec)
  97 {
  98         NTSTATUS status;
  99
 100         status = rec->delete_rec(rec);
 101         if (!NT_STATUS_IS_OK(status)) {
 102                 return status;
 103         }
 104         return NT_STATUS_OK;
 105 }
 106
 107 struct dbwrap_lock_order_state {
 108         struct db_context **locked_dbs;
 109         struct db_context *db;
 110 };
 111
 112 static void debug_lock_order(int level, struct db_context *dbs[])
 113 {
 114         int i;
 115         DEBUG(level, ("lock order: "));
 116         for (i=0; i<DBWRAP_LOCK_ORDER_MAX; i++) {
 117                 DEBUGADD(level, (" %d:%s", i + 1, dbs[i] ? dbs[i]->name : "<none>"));
 118         }
 119         DEBUGADD(level, ("\n"));
 120 }
 121
 122 static int dbwrap_lock_order_state_destructor(
 123         struct dbwrap_lock_order_state *s)
 124 {
 125         int idx = s->db->lock_order - 1;
 126
 127         DEBUG(5, ("release lock order %d for %s\n",
 128                   (int)s->db->lock_order, s->db->name));
 129
 130         if (s->locked_dbs[idx] != s->db) {
 131                 DEBUG(0, ("locked db at lock order %d is %s, expected %s\n",
 132                           idx + 1, s->locked_dbs[idx]->name, s->db->name));
 133                 debug_lock_order(0, s->locked_dbs);
 134                 smb_panic("inconsistent lock_order\n");
 135         }
 136
 137         s->locked_dbs[idx] = NULL;
 138
 139         debug_lock_order(10, s->locked_dbs);
 140
 141         return 0;
 142 }
 143
 144
 145 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
 146         struct db_context *db, TALLOC_CTX *mem_ctx)
 147 {
 148         int idx;
 149         static struct db_context *locked_dbs[DBWRAP_LOCK_ORDER_MAX];
 150         struct dbwrap_lock_order_state *state = NULL;
 151
 152         if (!DBWRAP_LOCK_ORDER_VALID(db->lock_order)) {
 153                 DEBUG(0,("Invalid lock order %d of %s\n",
 154                          (int)db->lock_order, db->name));
 155                 smb_panic("invalid lock_order\n");
 156                 return NULL;
 157         }
 158
 159         DEBUG(5, ("check lock order %d for %s\n",
 160                   (int)db->lock_order, db->name));
 161
 162
 163         for (idx=db->lock_order - 1; idx < DBWRAP_LOCK_ORDER_MAX; idx++) {
 164                 if (locked_dbs[idx] != NULL) {
 165                         DEBUG(0, ("Lock order violation: Trying %s at %d while %s at %d is locked\n",
 166                                   db->name, (int)db->lock_order, locked_dbs[idx]->name, idx + 1));
 167                         debug_lock_order(0, locked_dbs);
 168                         smb_panic("invalid lock_order");
 169                         return NULL;
 170                 }
 171         }
 172
 173         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
 174         if (state == NULL) {
 175                 DEBUG(1, ("talloc failed\n"));
 176                 return NULL;
 177         }
 178         state->db = db;
 179         state->locked_dbs = locked_dbs;
 180         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
 181
 182         locked_dbs[db->lock_order - 1] = db;
 183
 184         debug_lock_order(10, locked_dbs);
 185
 186         return state;
 187 }
 188
 189 static struct db_record *dbwrap_fetch_locked_internal(
 190         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
 191         struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
 192                                    TDB_DATA key))
 193 {
 194         struct db_record *rec;
 195         struct dbwrap_lock_order_state *lock_order = NULL;
 196
 197         if (db->lock_order != DBWRAP_LOCK_ORDER_NONE) {
 198                 lock_order = dbwrap_check_lock_order(db, mem_ctx);
 199                 if (lock_order == NULL) {
 200                         return NULL;
 201                 }
 202         }
 203         rec = db_fn(db, mem_ctx, key);
 204         if (rec == NULL) {
 205                 TALLOC_FREE(lock_order);
 206                 return NULL;
 207         }
 208         (void)talloc_steal(rec, lock_order);
 209         rec->db = db;
 210         return rec;
 211 }
 212
 213 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 214                                       TALLOC_CTX *mem_ctx,
 215                                       TDB_DATA key)
 216 {
 217         return dbwrap_fetch_locked_internal(db, mem_ctx, key,
 218                                             db->fetch_locked);
 219 }
 220
 221 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
 222                                       TALLOC_CTX *mem_ctx,
 223                                       TDB_DATA key)
 224 {
 225         return dbwrap_fetch_locked_internal(
 226                 db, mem_ctx, key,
 227                 db->try_fetch_locked
 228                 ? db->try_fetch_locked : db->fetch_locked);
 229 }
 230
 231 struct db_context *dbwrap_record_get_db(struct db_record *rec)
 232 {
 233         return rec->db;
 234 }
 235
 236 struct dbwrap_fetch_state {
 237         TALLOC_CTX *mem_ctx;
 238         TDB_DATA data;
 239 };
 240
 241 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 242                                 void *private_data)
 243 {
 244         struct dbwrap_fetch_state *state =
 245                 (struct dbwrap_fetch_state *)private_data;
 246
 247         state->data.dsize = data.dsize;
 248         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 249                                                     data.dsize);
 250 }
 251
 252 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 253                       TDB_DATA key, TDB_DATA *value)
 254 {
 255         struct dbwrap_fetch_state state;
 256         NTSTATUS status;
 257
 258         if (value == NULL) {
 259                 return NT_STATUS_INVALID_PARAMETER;
 260         }
 261
 262         state.mem_ctx = mem_ctx;
 263
 264         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 265         if (!NT_STATUS_IS_OK(status)) {
 266                 return status;
 267         }
 268         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 269                 return NT_STATUS_NO_MEMORY;
 270         }
 271         *value = state.data;
 272         return NT_STATUS_OK;
 273 }
 274
 275 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 276 {
 277         int result;
 278         if (db->exists != NULL) {
 279                 result = db->exists(db, key);
 280         } else {
 281                 result = dbwrap_fallback_exists(db,key);
 282         }
 283         return (result == 1);
 284 }
 285
 286 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 287                       TDB_DATA data, int flags)
 288 {
 289         struct db_record *rec;
 290         NTSTATUS status;
 291         TALLOC_CTX *frame = talloc_stackframe();
 292
 293         rec = dbwrap_fetch_locked(db, frame, key);
 294         if (rec == NULL) {
 295                 TALLOC_FREE(frame);
 296                 return NT_STATUS_NO_MEMORY;
 297         }
 298
 299         status = dbwrap_record_store(rec, data, flags);
 300         TALLOC_FREE(frame);
 301         return status;
 302 }
 303
 304 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 305 {
 306         struct db_record *rec;
 307         NTSTATUS status;
 308         TALLOC_CTX *frame = talloc_stackframe();
 309
 310         rec = dbwrap_fetch_locked(db, frame, key);
 311         if (rec == NULL) {
 312                 TALLOC_FREE(frame);
 313                 return NT_STATUS_NO_MEMORY;
 314         }
 315         status = dbwrap_record_delete(rec);
 316         TALLOC_FREE(frame);
 317         return status;
 318 }
 319
 320 NTSTATUS dbwrap_traverse(struct db_context *db,
 321                          int (*f)(struct db_record*, void*),
 322                          void *private_data,
 323                          int *count)
 324 {
 325         int ret = db->traverse(db, f, private_data);
 326
 327         if (ret < 0) {
 328                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 329         }
 330
 331         if (count != NULL) {
 332                 *count = ret;
 333         }
 334
 335         return NT_STATUS_OK;
 336 }
 337
 338 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 339                               int (*f)(struct db_record*, void*),
 340                               void *private_data,
 341                               int *count)
 342 {
 343         int ret = db->traverse_read(db, f, private_data);
 344
 345         if (ret < 0) {
 346                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 347         }
 348
 349         if (count != NULL) {
 350                 *count = ret;
 351         }
 352
 353         return NT_STATUS_OK;
 354 }
 355
 356 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 357 {
 358         return;
 359 }
 360
 361 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 362                              void (*parser)(TDB_DATA key, TDB_DATA data,
 363                                             void *private_data),
 364                              void *private_data)
 365 {
 366         if (parser == NULL) {
 367                 parser = dbwrap_null_parser;
 368         }
 369         return db->parse_record(db, key, parser, private_data);
 370 }
 371
 372 struct dbwrap_parse_record_state {
 373         struct db_context *db;
 374         TDB_DATA key;
 375         uint8_t _keybuf[64];
 376 };
 377
 378 static void dbwrap_parse_record_done(struct tevent_req *subreq);
 379
 380 struct tevent_req *dbwrap_parse_record_send(
 381         TALLOC_CTX *mem_ctx,
 382         struct tevent_context *ev,
 383         struct db_context *db,
 384         TDB_DATA key,
 385         void (*parser)(TDB_DATA key, TDB_DATA data, void *private_data),
 386         void *private_data,
 387         enum dbwrap_req_state *req_state)
 388 {
 389         struct tevent_req *req = NULL;
 390         struct tevent_req *subreq = NULL;
 391         struct dbwrap_parse_record_state *state = NULL;
 392         NTSTATUS status;
 393
 394         req = tevent_req_create(mem_ctx, &state, struct dbwrap_parse_record_state);
 395         if (req == NULL) {
 396                 *req_state = DBWRAP_REQ_ERROR;
 397                 return NULL;
 398         }
 399
 400         *state = (struct dbwrap_parse_record_state) {
 401                 .db = db,
 402         };
 403
 404         if (parser == NULL) {
 405                 parser = dbwrap_null_parser;
 406         }
 407
 408         *req_state = DBWRAP_REQ_INIT;
 409
 410         if (db->parse_record_send == NULL) {
 411                 /*
 412                  * Backend doesn't implement async version, call sync one
 413                  */
 414                 status = db->parse_record(db, key, parser, private_data);
 415                 if (tevent_req_nterror(req, status)) {
 416                         *req_state = DBWRAP_REQ_DONE;
 417                         return tevent_req_post(req, ev);
 418                 }
 419
 420                 *req_state = DBWRAP_REQ_DONE;
 421                 tevent_req_done(req);
 422                 return tevent_req_post(req, ev);
 423         }
 424
 425         /*
 426          * Copy the key into our state ensuring the key data buffer is always
 427          * available to the all dbwrap backend over the entire lifetime of the
 428          * async request. Otherwise the caller might have free'd the key buffer.
 429          */
 430         if (key.dsize > sizeof(state->_keybuf)) {
 431                 state->key.dptr = talloc_memdup(state, key.dptr, key.dsize);
 432                 if (tevent_req_nomem(state->key.dptr, req)) {
 433                         return tevent_req_post(req, ev);
 434                 }
 435         } else {
 436                 memcpy(state->_keybuf, key.dptr, key.dsize);
 437                 state->key.dptr = state->_keybuf;
 438         }
 439         state->key.dsize = key.dsize;
 440
 441         subreq = db->parse_record_send(state,
 442                                        ev,
 443                                        db,
 444                                        state->key,
 445                                        parser,
 446                                        private_data,
 447                                        req_state);
 448         if (tevent_req_nomem(subreq, req)) {
 449                 *req_state = DBWRAP_REQ_ERROR;
 450                 return tevent_req_post(req, ev);
 451         }
 452
 453         tevent_req_set_callback(subreq,
 454                                 dbwrap_parse_record_done,
 455                                 req);
 456         return req;
 457 }
 458
 459 static void dbwrap_parse_record_done(struct tevent_req *subreq)
 460 {
 461         struct tevent_req *req = tevent_req_callback_data(
 462                 subreq, struct tevent_req);
 463         struct dbwrap_parse_record_state *state = tevent_req_data(
 464                 req, struct dbwrap_parse_record_state);
 465         NTSTATUS status;
 466
 467         status = state->db->parse_record_recv(subreq);
 468         TALLOC_FREE(subreq);
 469         if (!NT_STATUS_IS_OK(status)) {
 470                 tevent_req_nterror(req, status);
 471                 return;
 472         }
 473
 474         tevent_req_done(req);
 475         return;
 476 }
 477
 478 NTSTATUS dbwrap_parse_record_recv(struct tevent_req *req)
 479 {
 480         return tevent_req_simple_recv_ntstatus(req);
 481 }
 482
 483 int dbwrap_wipe(struct db_context *db)
 484 {
 485         if (db->wipe == NULL) {
 486                 return dbwrap_fallback_wipe(db);
 487         }
 488         return db->wipe(db);
 489 }
 490
 491 int dbwrap_check(struct db_context *db)
 492 {
 493         if (db->check == NULL) {
 494                 return dbwrap_fallback_check(db);
 495         }
 496         return db->check(db);
 497 }
 498
 499 int dbwrap_get_seqnum(struct db_context *db)
 500 {
 501         return db->get_seqnum(db);
 502 }
 503
 504 int dbwrap_transaction_start(struct db_context *db)
 505 {
 506         if (!db->persistent) {
 507                 /*
 508                  * dbwrap_ctdb has two different data models for persistent
 509                  * and non-persistent databases. Transactions are supported
 510                  * only for the persistent databases. This check is here to
 511                  * prevent breakages of the cluster case, autobuild at this
 512                  * point only tests non-clustered Samba. Before removing this
 513                  * check, please make sure that this facility has also been
 514                  * added to dbwrap_ctdb.
 515                  *
 516                  * Thanks, vl
 517                  */
 518                 DEBUG(1, ("transactions not supported on non-persistent "
 519                           "database %s\n", db->name));
 520                 return -1;
 521         }
 522         return db->transaction_start(db);
 523 }
 524
 525 NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db)
 526 {
 527         if (db->transaction_start_nonblock) {
 528                 return db->transaction_start_nonblock(db);
 529         } else {
 530                 return dbwrap_transaction_start(db) == 0 ? NT_STATUS_OK
 531                         : NT_STATUS_UNSUCCESSFUL;
 532         }
 533 }
 534
 535 int dbwrap_transaction_commit(struct db_context *db)
 536 {
 537         return db->transaction_commit(db);
 538 }
 539
 540 int dbwrap_transaction_cancel(struct db_context *db)
 541 {
 542         return db->transaction_cancel(db);
 543 }
 544
 545 size_t dbwrap_db_id(struct db_context *db, uint8_t *id, size_t idlen)
 546 {
 547         return db->id(db, id, idlen);
 548 }
 549
 550 bool dbwrap_is_persistent(struct db_context *db)
 551 {
 552         return db->persistent;
 553 }
 554
 555 const char *dbwrap_name(struct db_context *db)
 556 {
 557         return db->name;
 558 }