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 "includes.h"
  23 #include "dbwrap/dbwrap.h"
  24 #include "dbwrap/dbwrap_private.h"
  25 #include "lib/util/util_tdb.h"
  26
  27 /*
  28  * Fall back using fetch if no genuine exists operation is provided
  29  */
  30
  31 static int dbwrap_fallback_exists(struct db_context *db, TDB_DATA key)
  32 {
  33         NTSTATUS status = dbwrap_parse_record(db, key, NULL, NULL);
  34         return NT_STATUS_IS_OK(status) ? 1 : 0;
  35 }
  36
  37 static int delete_record(struct db_record *rec, void *data)
  38 {
  39         NTSTATUS status = dbwrap_record_delete(rec);
  40         return NT_STATUS_IS_OK(status) ? 0 : -1;
  41 }
  42
  43 /*
  44  * Fallback wipe implementation using traverse and delete if no genuine
  45  * wipe operation is provided
  46  */
  47 static int dbwrap_fallback_wipe(struct db_context *db)
  48 {
  49         NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL);
  50         return NT_STATUS_IS_OK(status) ? 0 : -1;
  51 }
  52
  53 static int do_nothing(struct db_record *rec, void *unused)
  54 {
  55         return 0;
  56 }
  57
  58 /*
  59  * Fallback check operation: just traverse.
  60  */
  61 static int dbwrap_fallback_check(struct db_context *db)
  62 {
  63         NTSTATUS status = dbwrap_traverse_read(db, do_nothing, NULL, NULL);
  64         return NT_STATUS_IS_OK(status) ? 0 : -1;
  65 }
  66
  67 /*
  68  * Wrapper functions for the backend methods
  69  */
  70
  71 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
  72 {
  73         return rec->key;
  74 }
  75
  76 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
  77 {
  78         return rec->value;
  79 }
  80
  81 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
  82 {
  83         NTSTATUS status;
  84         struct db_context *db;
  85
  86         status = rec->store(rec, data, flags);
  87         if (!NT_STATUS_IS_OK(status)) {
  88                 return status;
  89         }
  90         db = rec->db;
  91         if (db->stored_callback != NULL) {
  92                 db->stored_callback(db, rec,
  93                                     db->stored_callback_private_data);
  94         }
  95         return NT_STATUS_OK;
  96 }
  97
  98 void dbwrap_set_stored_callback(
  99         struct db_context *db,
 100         void (*cb)(struct db_context *db, struct db_record *rec,
 101                    void *private_data),
 102         void *private_data)
 103 {
 104         db->stored_callback = cb;
 105         db->stored_callback_private_data = private_data;
 106 }
 107
 108 NTSTATUS dbwrap_record_delete(struct db_record *rec)
 109 {
 110         NTSTATUS status;
 111         struct db_context *db;
 112
 113         status = rec->delete_rec(rec);
 114         if (!NT_STATUS_IS_OK(status)) {
 115                 return status;
 116         }
 117         db = rec->db;
 118         if (db->stored_callback != NULL) {
 119                 db->stored_callback(db, rec,
 120                                     db->stored_callback_private_data);
 121         }
 122         return NT_STATUS_OK;
 123 }
 124
 125 struct dbwrap_lock_order_state {
 126         uint8_t *plock_order_mask;
 127         uint8_t bitmask;
 128 };
 129
 130 static int dbwrap_lock_order_state_destructor(
 131         struct dbwrap_lock_order_state *s)
 132 {
 133         *s->plock_order_mask &= ~s->bitmask;
 134         return 0;
 135 }
 136
 137 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
 138         struct db_context *db, TALLOC_CTX *mem_ctx)
 139 {
 140         /*
 141          * Store the lock_order of currently locked records as bits in
 142          * "lock_order_mask". We only use levels 1,2,3 right now, so a
 143          * single uint8_t is enough.
 144          */
 145         static uint8_t lock_order_mask;
 146
 147         struct dbwrap_lock_order_state *state;
 148         uint8_t idx;
 149         int used;
 150
 151         if (db->lock_order == 0) {
 152                 /*
 153                  * lock order 0 is for example for dbwrap_rbt without
 154                  * real locking. Return state nevertheless to avoid
 155                  * special cases.
 156                  */
 157                 return talloc(mem_ctx, struct dbwrap_lock_order_state);
 158         }
 159
 160         /*
 161          * We fill bits from the high bits, to be able to use
 162          * "ffs(lock_order_mask)"
 163          */
 164         idx = sizeof(lock_order_mask)*8 - db->lock_order;
 165
 166         used = ffs(lock_order_mask);
 167
 168         DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used,
 169                   (int)db->lock_order, (int)idx));
 170
 171         if ((used != 0) && (used-1 <= idx)) {
 172                 DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n",
 173                           (int)db->lock_order, (int)lock_order_mask));
 174                 return NULL;
 175         }
 176
 177         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
 178         if (state == NULL) {
 179                 DEBUG(1, ("talloc failed\n"));
 180                 return NULL;
 181         }
 182         state->bitmask = 1 << idx;
 183         state->plock_order_mask = &lock_order_mask;
 184
 185         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
 186         lock_order_mask |= state->bitmask;
 187
 188         return state;
 189 }
 190
 191 static struct db_record *dbwrap_fetch_locked_internal(
 192         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
 193         struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
 194                                    TDB_DATA key))
 195 {
 196         struct db_record *rec;
 197         struct dbwrap_lock_order_state *lock_order;
 198         TALLOC_CTX *frame = talloc_stackframe();
 199
 200         lock_order = dbwrap_check_lock_order(db, frame);
 201         if (lock_order == NULL) {
 202                 TALLOC_FREE(frame);
 203                 return NULL;
 204         }
 205         rec = db_fn(db, mem_ctx, key);
 206         if (rec == NULL) {
 207                 TALLOC_FREE(frame);
 208                 return NULL;
 209         }
 210         (void)talloc_steal(rec, lock_order);
 211         rec->db = db;
 212         TALLOC_FREE(frame);
 213         return rec;
 214 }
 215
 216 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 217                                       TALLOC_CTX *mem_ctx,
 218                                       TDB_DATA key)
 219 {
 220         return dbwrap_fetch_locked_internal(db, mem_ctx, key,
 221                                             db->fetch_locked);
 222 }
 223
 224 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
 225                                       TALLOC_CTX *mem_ctx,
 226                                       TDB_DATA key)
 227 {
 228         return dbwrap_fetch_locked_internal(
 229                 db, mem_ctx, key,
 230                 db->try_fetch_locked
 231                 ? db->try_fetch_locked : db->fetch_locked);
 232 }
 233
 234 struct db_record *dbwrap_fetch_locked_timeout(struct db_context *db,
 235                                               TALLOC_CTX *mem_ctx,
 236                                               TDB_DATA key,
 237                                               unsigned int timeout)
 238 {
 239         struct db_record *rec;
 240         struct dbwrap_lock_order_state *lock_order;
 241         TALLOC_CTX *frame = talloc_stackframe();
 242
 243         lock_order = dbwrap_check_lock_order(db, frame);
 244         if (lock_order == NULL) {
 245                 TALLOC_FREE(frame);
 246                 return NULL;
 247         }
 248         rec = db->fetch_locked_timeout
 249                 ? db->fetch_locked_timeout(db, mem_ctx, key, timeout)
 250                 : db->fetch_locked(db, mem_ctx, key);
 251         if (rec == NULL) {
 252                 TALLOC_FREE(frame);
 253                 return NULL;
 254         }
 255         (void)talloc_steal(rec, lock_order);
 256         rec->db = db;
 257         TALLOC_FREE(frame);
 258         return rec;
 259 }
 260
 261 struct db_context *dbwrap_record_get_db(struct db_record *rec)
 262 {
 263         return rec->db;
 264 }
 265
 266 struct dbwrap_fetch_state {
 267         TALLOC_CTX *mem_ctx;
 268         TDB_DATA data;
 269 };
 270
 271 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 272                                 void *private_data)
 273 {
 274         struct dbwrap_fetch_state *state =
 275                 (struct dbwrap_fetch_state *)private_data;
 276
 277         state->data.dsize = data.dsize;
 278         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 279                                                     data.dsize);
 280 }
 281
 282 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 283                       TDB_DATA key, TDB_DATA *value)
 284 {
 285         struct dbwrap_fetch_state state;
 286         NTSTATUS status;
 287
 288         if (value == NULL) {
 289                 return NT_STATUS_INVALID_PARAMETER;
 290         }
 291
 292         state.mem_ctx = mem_ctx;
 293
 294         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 295         if (!NT_STATUS_IS_OK(status)) {
 296                 return status;
 297         }
 298         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 299                 return NT_STATUS_NO_MEMORY;
 300         }
 301         *value = state.data;
 302         return NT_STATUS_OK;
 303 }
 304
 305 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 306 {
 307         int result;
 308         if (db->exists != NULL) {
 309                 result = db->exists(db, key);
 310         } else {
 311                 result = dbwrap_fallback_exists(db,key);
 312         }
 313         return (result == 1);
 314 }
 315
 316 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 317                       TDB_DATA data, int flags)
 318 {
 319         struct db_record *rec;
 320         NTSTATUS status;
 321         TALLOC_CTX *frame = talloc_stackframe();
 322
 323         rec = dbwrap_fetch_locked(db, frame, key);
 324         if (rec == NULL) {
 325                 TALLOC_FREE(frame);
 326                 return NT_STATUS_NO_MEMORY;
 327         }
 328
 329         status = dbwrap_record_store(rec, data, flags);
 330         TALLOC_FREE(frame);
 331         return status;
 332 }
 333
 334 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 335 {
 336         struct db_record *rec;
 337         NTSTATUS status;
 338         TALLOC_CTX *frame = talloc_stackframe();
 339
 340         rec = dbwrap_fetch_locked(db, frame, key);
 341         if (rec == NULL) {
 342                 TALLOC_FREE(frame);
 343                 return NT_STATUS_NO_MEMORY;
 344         }
 345         status = dbwrap_record_delete(rec);
 346         TALLOC_FREE(frame);
 347         return status;
 348 }
 349
 350 NTSTATUS dbwrap_traverse(struct db_context *db,
 351                          int (*f)(struct db_record*, void*),
 352                          void *private_data,
 353                          int *count)
 354 {
 355         int ret = db->traverse(db, f, private_data);
 356
 357         if (ret < 0) {
 358                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 359         }
 360
 361         if (count != NULL) {
 362                 *count = ret;
 363         }
 364
 365         return NT_STATUS_OK;
 366 }
 367
 368 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 369                               int (*f)(struct db_record*, void*),
 370                               void *private_data,
 371                               int *count)
 372 {
 373         int ret = db->traverse_read(db, f, private_data);
 374
 375         if (ret < 0) {
 376                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 377         }
 378
 379         if (count != NULL) {
 380                 *count = ret;
 381         }
 382
 383         return NT_STATUS_OK;
 384 }
 385
 386 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 387 {
 388         return;
 389 }
 390
 391 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 392                              void (*parser)(TDB_DATA key, TDB_DATA data,
 393                                             void *private_data),
 394                              void *private_data)
 395 {
 396         if (parser == NULL) {
 397                 parser = dbwrap_null_parser;
 398         }
 399         return db->parse_record(db, key, parser, private_data);
 400 }
 401
 402 int dbwrap_wipe(struct db_context *db)
 403 {
 404         if (db->wipe == NULL) {
 405                 return dbwrap_fallback_wipe(db);
 406         }
 407         return db->wipe(db);
 408 }
 409
 410 int dbwrap_hash_size(struct db_context *db)
 411 {
 412         return db->hash_size;
 413 }
 414
 415 int dbwrap_check(struct db_context *db)
 416 {
 417         if (db->check == NULL) {
 418                 return dbwrap_fallback_check(db);
 419         }
 420         return db->check(db);
 421 }
 422
 423 int dbwrap_get_seqnum(struct db_context *db)
 424 {
 425         return db->get_seqnum(db);
 426 }
 427
 428 int dbwrap_transaction_start(struct db_context *db)
 429 {
 430         return db->transaction_start(db);
 431 }
 432
 433 NTSTATUS dbwrap_transaction_start_nonblock(struct db_context *db)
 434 {
 435         if (db->transaction_start_nonblock) {
 436                 return db->transaction_start_nonblock(db);
 437         } else {
 438                 return dbwrap_transaction_start(db) == 0 ? NT_STATUS_OK
 439                         : NT_STATUS_UNSUCCESSFUL;
 440         }
 441 }
 442
 443 int dbwrap_transaction_commit(struct db_context *db)
 444 {
 445         return db->transaction_commit(db);
 446 }
 447
 448 int dbwrap_transaction_cancel(struct db_context *db)
 449 {
 450         return db->transaction_cancel(db);
 451 }
 452
 453 void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen)
 454 {
 455         db->id(db, id, idlen);
 456 }
 457
 458 const char *dbwrap_name(struct db_context *db)
 459 {
 460         return db->name;
 461 }