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
  54 /*
  55  * Wrapper functions for the backend methods
  56  */
  57
  58 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
  59 {
  60         return rec->key;
  61 }
  62
  63 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
  64 {
  65         return rec->value;
  66 }
  67
  68 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
  69 {
  70         NTSTATUS status;
  71         struct db_context *db;
  72
  73         status = rec->store(rec, data, flags);
  74         if (!NT_STATUS_IS_OK(status)) {
  75                 return status;
  76         }
  77         db = rec->db;
  78         if (db->stored_callback != NULL) {
  79                 db->stored_callback(db, rec,
  80                                     db->stored_callback_private_data);
  81         }
  82         return NT_STATUS_OK;
  83 }
  84
  85 void dbwrap_set_stored_callback(
  86         struct db_context *db,
  87         void (*cb)(struct db_context *db, struct db_record *rec,
  88                    void *private_data),
  89         void *private_data)
  90 {
  91         db->stored_callback = cb;
  92         db->stored_callback_private_data = private_data;
  93 }
  94
  95 NTSTATUS dbwrap_record_delete(struct db_record *rec)
  96 {
  97         NTSTATUS status;
  98         struct db_context *db;
  99
 100         status = rec->delete_rec(rec);
 101         if (!NT_STATUS_IS_OK(status)) {
 102                 return status;
 103         }
 104         db = rec->db;
 105         if (db->stored_callback != NULL) {
 106                 db->stored_callback(db, rec,
 107                                     db->stored_callback_private_data);
 108         }
 109         return NT_STATUS_OK;
 110 }
 111
 112 struct dbwrap_lock_order_state {
 113         uint8_t *plock_order_mask;
 114         uint8_t bitmask;
 115 };
 116
 117 static int dbwrap_lock_order_state_destructor(
 118         struct dbwrap_lock_order_state *s)
 119 {
 120         *s->plock_order_mask &= ~s->bitmask;
 121         return 0;
 122 }
 123
 124 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
 125         struct db_context *db, TALLOC_CTX *mem_ctx)
 126 {
 127         /*
 128          * Store the lock_order of currently locked records as bits in
 129          * "lock_order_mask". We only use levels 1,2,3 right now, so a
 130          * single uint8_t is enough.
 131          */
 132         static uint8_t lock_order_mask;
 133
 134         struct dbwrap_lock_order_state *state;
 135         uint8_t idx;
 136         int used;
 137
 138         if (db->lock_order == 0) {
 139                 /*
 140                  * lock order 0 is for example for dbwrap_rbt without
 141                  * real locking. Return state nevertheless to avoid
 142                  * special cases.
 143                  */
 144                 return talloc(mem_ctx, struct dbwrap_lock_order_state);
 145         }
 146
 147         /*
 148          * We fill bits from the high bits, to be able to use
 149          * "ffs(lock_order_mask)"
 150          */
 151         idx = sizeof(lock_order_mask)*8 - db->lock_order;
 152
 153         used = ffs(lock_order_mask);
 154
 155         DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used,
 156                   (int)db->lock_order, (int)idx));
 157
 158         if ((used != 0) && (used-1 <= idx)) {
 159                 DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n",
 160                           (int)db->lock_order, (int)lock_order_mask));
 161                 return NULL;
 162         }
 163
 164         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
 165         if (state == NULL) {
 166                 DEBUG(1, ("talloc failed\n"));
 167                 return NULL;
 168         }
 169         state->bitmask = 1 << idx;
 170         state->plock_order_mask = &lock_order_mask;
 171
 172         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
 173         lock_order_mask |= state->bitmask;
 174
 175         return state;
 176 }
 177
 178 static struct db_record *dbwrap_fetch_locked_internal(
 179         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key,
 180         struct db_record *(*db_fn)(struct db_context *db, TALLOC_CTX *mem_ctx,
 181                                    TDB_DATA key))
 182 {
 183         struct db_record *rec;
 184         struct dbwrap_lock_order_state *lock_order;
 185         TALLOC_CTX *frame = talloc_stackframe();
 186
 187         lock_order = dbwrap_check_lock_order(db, frame);
 188         if (lock_order == NULL) {
 189                 TALLOC_FREE(frame);
 190                 return NULL;
 191         }
 192         rec = db_fn(db, mem_ctx, key);
 193         if (rec == NULL) {
 194                 TALLOC_FREE(frame);
 195                 return NULL;
 196         }
 197         (void)talloc_steal(rec, lock_order);
 198         rec->db = db;
 199         TALLOC_FREE(frame);
 200         return rec;
 201 }
 202
 203 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 204                                       TALLOC_CTX *mem_ctx,
 205                                       TDB_DATA key)
 206 {
 207         return dbwrap_fetch_locked_internal(db, mem_ctx, key,
 208                                             db->fetch_locked);
 209 }
 210
 211 struct db_record *dbwrap_try_fetch_locked(struct db_context *db,
 212                                       TALLOC_CTX *mem_ctx,
 213                                       TDB_DATA key)
 214 {
 215         return dbwrap_fetch_locked_internal(
 216                 db, mem_ctx, key,
 217                 db->try_fetch_locked
 218                 ? db->try_fetch_locked : db->fetch_locked);
 219 }
 220
 221 struct db_context *dbwrap_record_get_db(struct db_record *rec)
 222 {
 223         return rec->db;
 224 }
 225
 226 struct dbwrap_fetch_state {
 227         TALLOC_CTX *mem_ctx;
 228         TDB_DATA data;
 229 };
 230
 231 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 232                                 void *private_data)
 233 {
 234         struct dbwrap_fetch_state *state =
 235                 (struct dbwrap_fetch_state *)private_data;
 236
 237         state->data.dsize = data.dsize;
 238         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 239                                                     data.dsize);
 240 }
 241
 242 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 243                       TDB_DATA key, TDB_DATA *value)
 244 {
 245         struct dbwrap_fetch_state state;
 246         NTSTATUS status;
 247
 248         if (value == NULL) {
 249                 return NT_STATUS_INVALID_PARAMETER;
 250         }
 251
 252         state.mem_ctx = mem_ctx;
 253
 254         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 255         if (!NT_STATUS_IS_OK(status)) {
 256                 return status;
 257         }
 258         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 259                 return NT_STATUS_NO_MEMORY;
 260         }
 261         *value = state.data;
 262         return NT_STATUS_OK;
 263 }
 264
 265 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 266 {
 267         int result;
 268         if (db->exists != NULL) {
 269                 result = db->exists(db, key);
 270         } else {
 271                 result = dbwrap_fallback_exists(db,key);
 272         }
 273         return (result == 1);
 274 }
 275
 276 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 277                       TDB_DATA data, int flags)
 278 {
 279         struct db_record *rec;
 280         NTSTATUS status;
 281         TALLOC_CTX *frame = talloc_stackframe();
 282
 283         rec = dbwrap_fetch_locked(db, frame, key);
 284         if (rec == NULL) {
 285                 TALLOC_FREE(frame);
 286                 return NT_STATUS_NO_MEMORY;
 287         }
 288
 289         status = dbwrap_record_store(rec, data, flags);
 290         TALLOC_FREE(frame);
 291         return status;
 292 }
 293
 294 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 295 {
 296         struct db_record *rec;
 297         NTSTATUS status;
 298         TALLOC_CTX *frame = talloc_stackframe();
 299
 300         rec = dbwrap_fetch_locked(db, frame, key);
 301         if (rec == NULL) {
 302                 TALLOC_FREE(frame);
 303                 return NT_STATUS_NO_MEMORY;
 304         }
 305         status = dbwrap_record_delete(rec);
 306         TALLOC_FREE(frame);
 307         return status;
 308 }
 309
 310 NTSTATUS dbwrap_traverse(struct db_context *db,
 311                          int (*f)(struct db_record*, void*),
 312                          void *private_data,
 313                          int *count)
 314 {
 315         int ret = db->traverse(db, f, private_data);
 316
 317         if (ret < 0) {
 318                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 319         }
 320
 321         if (count != NULL) {
 322                 *count = ret;
 323         }
 324
 325         return NT_STATUS_OK;
 326 }
 327
 328 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 329                               int (*f)(struct db_record*, void*),
 330                               void *private_data,
 331                               int *count)
 332 {
 333         int ret = db->traverse_read(db, f, private_data);
 334
 335         if (ret < 0) {
 336                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 337         }
 338
 339         if (count != NULL) {
 340                 *count = ret;
 341         }
 342
 343         return NT_STATUS_OK;
 344 }
 345
 346 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 347 {
 348         return;
 349 }
 350
 351 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 352                              void (*parser)(TDB_DATA key, TDB_DATA data,
 353                                             void *private_data),
 354                              void *private_data)
 355 {
 356         if (parser == NULL) {
 357                 parser = dbwrap_null_parser;
 358         }
 359         return db->parse_record(db, key, parser, private_data);
 360 }
 361
 362 int dbwrap_wipe(struct db_context *db)
 363 {
 364         if (db->wipe == NULL) {
 365                 return dbwrap_fallback_wipe(db);
 366         }
 367         return db->wipe(db);
 368 }
 369
 370 int dbwrap_get_seqnum(struct db_context *db)
 371 {
 372         return db->get_seqnum(db);
 373 }
 374
 375 int dbwrap_get_flags(struct db_context *db)
 376 {
 377         return db->get_flags(db);
 378 }
 379
 380 int dbwrap_transaction_start(struct db_context *db)
 381 {
 382         return db->transaction_start(db);
 383 }
 384
 385 int dbwrap_transaction_commit(struct db_context *db)
 386 {
 387         return db->transaction_commit(db);
 388 }
 389
 390 int dbwrap_transaction_cancel(struct db_context *db)
 391 {
 392         return db->transaction_cancel(db);
 393 }
 394
 395 void dbwrap_db_id(struct db_context *db, const uint8_t **id, size_t *idlen)
 396 {
 397         db->id(db, id, idlen);
 398 }