source3/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 "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         return rec->store(rec, data, flags);
  71 }
  72
  73 NTSTATUS dbwrap_record_delete(struct db_record *rec)
  74 {
  75         return rec->delete_rec(rec);
  76 }
  77
  78 struct dbwrap_lock_order_state {
  79         uint8_t *plock_order_mask;
  80         uint8_t bitmask;
  81 };
  82
  83 static int dbwrap_lock_order_state_destructor(
  84         struct dbwrap_lock_order_state *s)
  85 {
  86         *s->plock_order_mask &= ~s->bitmask;
  87         return 0;
  88 }
  89
  90 static struct dbwrap_lock_order_state *dbwrap_check_lock_order(
  91         struct db_context *db, TALLOC_CTX *mem_ctx)
  92 {
  93         /*
  94          * Store the lock_order of currently locked records as bits in
  95          * "lock_order_mask". We only use levels 1,2,3 right now, so a
  96          * single uint8_t is enough.
  97          */
  98         static uint8_t lock_order_mask;
  99
 100         struct dbwrap_lock_order_state *state;
 101         uint8_t idx;
 102         int used;
 103
 104         if (db->lock_order == 0) {
 105                 /*
 106                  * lock order 0 is for example for dbwrap_rbt without
 107                  * real locking. Return state nevertheless to avoid
 108                  * special cases.
 109                  */
 110                 return talloc(mem_ctx, struct dbwrap_lock_order_state);
 111         }
 112
 113         /*
 114          * We fill bits from the high bits, to be able to use
 115          * "ffs(lock_order_mask)"
 116          */
 117         idx = sizeof(lock_order_mask)*8 - db->lock_order;
 118
 119         used = ffs(lock_order_mask);
 120
 121         DEBUG(5, ("used=%d, lock_order=%d, idx=%d\n", used,
 122                   (int)db->lock_order, (int)idx));
 123
 124         if ((used != 0) && (used-1 <= idx)) {
 125                 DEBUG(0, ("Lock order violation: Trying %d, order_mask=%x\n",
 126                           (int)db->lock_order, (int)lock_order_mask));
 127                 return NULL;
 128         }
 129
 130         state = talloc(mem_ctx, struct dbwrap_lock_order_state);
 131         if (state == NULL) {
 132                 DEBUG(1, ("talloc failed\n"));
 133                 return NULL;
 134         }
 135         state->bitmask = 1 << idx;
 136         state->plock_order_mask = &lock_order_mask;
 137
 138         talloc_set_destructor(state, dbwrap_lock_order_state_destructor);
 139         lock_order_mask |= state->bitmask;
 140
 141         return state;
 142 }
 143
 144 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 145                                       TALLOC_CTX *mem_ctx,
 146                                       TDB_DATA key)
 147 {
 148         struct db_record *rec;
 149         struct dbwrap_lock_order_state *lock_order;
 150
 151         lock_order = dbwrap_check_lock_order(db, talloc_tos());
 152         if (lock_order == NULL) {
 153                 return NULL;
 154         }
 155         rec = db->fetch_locked(db, mem_ctx, key);
 156         if (rec == NULL) {
 157                 TALLOC_FREE(lock_order);
 158                 return NULL;
 159         }
 160         (void)talloc_steal(rec, lock_order);
 161         return rec;
 162 }
 163
 164 struct dbwrap_fetch_state {
 165         TALLOC_CTX *mem_ctx;
 166         TDB_DATA data;
 167 };
 168
 169 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 170                                 void *private_data)
 171 {
 172         struct dbwrap_fetch_state *state =
 173                 (struct dbwrap_fetch_state *)private_data;
 174
 175         state->data.dsize = data.dsize;
 176         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 177                                                     data.dsize);
 178 }
 179
 180 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 181                       TDB_DATA key, TDB_DATA *value)
 182 {
 183         struct dbwrap_fetch_state state;
 184         NTSTATUS status;
 185
 186         if (value == NULL) {
 187                 return NT_STATUS_INVALID_PARAMETER;
 188         }
 189
 190         state.mem_ctx = mem_ctx;
 191
 192         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 193         if (!NT_STATUS_IS_OK(status)) {
 194                 return status;
 195         }
 196         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 197                 return NT_STATUS_NO_MEMORY;
 198         }
 199         *value = state.data;
 200         return NT_STATUS_OK;
 201 }
 202
 203 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 204 {
 205         int result;
 206         if (db->exists != NULL) {
 207                 result = db->exists(db, key);
 208         } else {
 209                 result = dbwrap_fallback_exists(db,key);
 210         }
 211         return (result == 1);
 212 }
 213
 214 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 215                       TDB_DATA data, int flags)
 216 {
 217         struct db_record *rec;
 218         NTSTATUS status;
 219
 220         rec = dbwrap_fetch_locked(db, talloc_tos(), key);
 221         if (rec == NULL) {
 222                 return NT_STATUS_NO_MEMORY;
 223         }
 224
 225         status = dbwrap_record_store(rec, data, flags);
 226         TALLOC_FREE(rec);
 227         return status;
 228 }
 229
 230 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 231 {
 232         struct db_record *rec;
 233         NTSTATUS status;
 234
 235         rec = dbwrap_fetch_locked(db, talloc_tos(), key);
 236         if (rec == NULL) {
 237                 return NT_STATUS_NO_MEMORY;
 238         }
 239         status = dbwrap_record_delete(rec);
 240         TALLOC_FREE(rec);
 241         return status;
 242 }
 243
 244 NTSTATUS dbwrap_traverse(struct db_context *db,
 245                          int (*f)(struct db_record*, void*),
 246                          void *private_data,
 247                          int *count)
 248 {
 249         int ret = db->traverse(db, f, private_data);
 250
 251         if (ret < 0) {
 252                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 253         }
 254
 255         if (count != NULL) {
 256                 *count = ret;
 257         }
 258
 259         return NT_STATUS_OK;
 260 }
 261
 262 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 263                               int (*f)(struct db_record*, void*),
 264                               void *private_data,
 265                               int *count)
 266 {
 267         int ret = db->traverse_read(db, f, private_data);
 268
 269         if (ret < 0) {
 270                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 271         }
 272
 273         if (count != NULL) {
 274                 *count = ret;
 275         }
 276
 277         return NT_STATUS_OK;
 278 }
 279
 280 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 281 {
 282         return;
 283 }
 284
 285 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 286                              void (*parser)(TDB_DATA key, TDB_DATA data,
 287                                             void *private_data),
 288                              void *private_data)
 289 {
 290         if (parser == NULL) {
 291                 parser = dbwrap_null_parser;
 292         }
 293         return db->parse_record(db, key, parser, private_data);
 294 }
 295
 296 int dbwrap_wipe(struct db_context *db)
 297 {
 298         if (db->wipe == NULL) {
 299                 return dbwrap_fallback_wipe(db);
 300         }
 301         return db->wipe(db);
 302 }
 303
 304 int dbwrap_get_seqnum(struct db_context *db)
 305 {
 306         return db->get_seqnum(db);
 307 }
 308
 309 int dbwrap_get_flags(struct db_context *db)
 310 {
 311         return db->get_flags(db);
 312 }
 313
 314 int dbwrap_transaction_start(struct db_context *db)
 315 {
 316         return db->transaction_start(db);
 317 }
 318
 319 int dbwrap_transaction_commit(struct db_context *db)
 320 {
 321         return db->transaction_commit(db);
 322 }
 323
 324 int dbwrap_transaction_cancel(struct db_context *db)
 325 {
 326         return db->transaction_cancel(db);
 327 }