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 /*
  38  * Fall back using fetch if no genuine parse operation is provided
  39  */
  40
  41 static NTSTATUS dbwrap_fallback_parse_record(struct db_context *db, TDB_DATA key,
  42                                              void (*parser)(TDB_DATA key,
  43                                                             TDB_DATA data,
  44                                                             void *private_data),
  45                                              void *private_data)
  46 {
  47         struct db_record *rec;
  48         TDB_DATA data;
  49
  50         rec = dbwrap_fetch_locked(db, talloc_tos(), key);
  51         if (rec == NULL) {
  52                 return NT_STATUS_NOT_FOUND;
  53         }
  54         data = dbwrap_record_get_value(rec);
  55
  56         data.dptr = talloc_memdup(talloc_tos(), data.dptr, data.dsize);
  57         TALLOC_FREE(rec);
  58         if (data.dptr == NULL) {
  59                 return NT_STATUS_NO_MEMORY;
  60         }
  61
  62         parser(key, data, private_data);
  63
  64         TALLOC_FREE(data.dptr);
  65         return NT_STATUS_OK;
  66 }
  67
  68
  69 static int delete_record(struct db_record *rec, void *data)
  70 {
  71         NTSTATUS status = dbwrap_record_delete(rec);
  72         return NT_STATUS_IS_OK(status) ? 0 : -1;
  73 }
  74
  75 /*
  76  * Fallback wipe implementation using traverse and delete if no genuine
  77  * wipe operation is provided
  78  */
  79 static int dbwrap_fallback_wipe(struct db_context *db)
  80 {
  81         NTSTATUS status = dbwrap_trans_traverse(db, delete_record, NULL);
  82         return NT_STATUS_IS_OK(status) ? 0 : -1;
  83 }
  84
  85
  86 /*
  87  * Wrapper functions for the backend methods
  88  */
  89
  90 TDB_DATA dbwrap_record_get_key(const struct db_record *rec)
  91 {
  92         return rec->key;
  93 }
  94
  95 TDB_DATA dbwrap_record_get_value(const struct db_record *rec)
  96 {
  97         return rec->value;
  98 }
  99
 100 NTSTATUS dbwrap_record_store(struct db_record *rec, TDB_DATA data, int flags)
 101 {
 102         return rec->store(rec, data, flags);
 103 }
 104
 105 NTSTATUS dbwrap_record_delete(struct db_record *rec)
 106 {
 107         return rec->delete_rec(rec);
 108 }
 109
 110 struct db_record *dbwrap_fetch_locked(struct db_context *db,
 111                                       TALLOC_CTX *mem_ctx,
 112                                       TDB_DATA key)
 113 {
 114         return db->fetch_locked(db, mem_ctx, key);
 115 }
 116
 117 struct dbwrap_fetch_state {
 118         TALLOC_CTX *mem_ctx;
 119         TDB_DATA data;
 120 };
 121
 122 static void dbwrap_fetch_parser(TDB_DATA key, TDB_DATA data,
 123                                 void *private_data)
 124 {
 125         struct dbwrap_fetch_state *state =
 126                 (struct dbwrap_fetch_state *)private_data;
 127
 128         state->data.dsize = data.dsize;
 129         state->data.dptr = (uint8_t *)talloc_memdup(state->mem_ctx, data.dptr,
 130                                                     data.dsize);
 131 }
 132
 133 NTSTATUS dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 134                       TDB_DATA key, TDB_DATA *value)
 135 {
 136         struct dbwrap_fetch_state state;
 137         NTSTATUS status;
 138
 139         if (value == NULL) {
 140                 return NT_STATUS_INVALID_PARAMETER;
 141         }
 142
 143         state.mem_ctx = mem_ctx;
 144
 145         status = dbwrap_parse_record(db, key, dbwrap_fetch_parser, &state);
 146         if (!NT_STATUS_IS_OK(status)) {
 147                 return status;
 148         }
 149         if ((state.data.dsize != 0) && (state.data.dptr == NULL)) {
 150                 return NT_STATUS_NO_MEMORY;
 151         }
 152         *value = state.data;
 153         return NT_STATUS_OK;
 154 }
 155
 156 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 157 {
 158         int result;
 159         if (db->exists != NULL) {
 160                 result = db->exists(db, key);
 161         } else {
 162                 result = dbwrap_fallback_exists(db,key);
 163         }
 164         return (result == 1);
 165 }
 166
 167 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 168                       TDB_DATA data, int flags)
 169 {
 170         struct db_record *rec;
 171         NTSTATUS status;
 172
 173         rec = dbwrap_fetch_locked(db, talloc_tos(), key);
 174         if (rec == NULL) {
 175                 return NT_STATUS_NO_MEMORY;
 176         }
 177
 178         status = dbwrap_record_store(rec, data, flags);
 179         TALLOC_FREE(rec);
 180         return status;
 181 }
 182
 183 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 184 {
 185         struct db_record *rec;
 186         NTSTATUS status;
 187
 188         rec = dbwrap_fetch_locked(db, talloc_tos(), key);
 189         if (rec == NULL) {
 190                 return NT_STATUS_NO_MEMORY;
 191         }
 192         status = dbwrap_record_delete(rec);
 193         TALLOC_FREE(rec);
 194         return status;
 195 }
 196
 197 NTSTATUS dbwrap_traverse(struct db_context *db,
 198                          int (*f)(struct db_record*, void*),
 199                          void *private_data,
 200                          int *count)
 201 {
 202         int ret = db->traverse(db, f, private_data);
 203
 204         if (ret < 0) {
 205                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 206         }
 207
 208         if (count != NULL) {
 209                 *count = ret;
 210         }
 211
 212         return NT_STATUS_OK;
 213 }
 214
 215 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 216                               int (*f)(struct db_record*, void*),
 217                               void *private_data,
 218                               int *count)
 219 {
 220         int ret = db->traverse_read(db, f, private_data);
 221
 222         if (ret < 0) {
 223                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 224         }
 225
 226         if (count != NULL) {
 227                 *count = ret;
 228         }
 229
 230         return NT_STATUS_OK;
 231 }
 232
 233 static void dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 234 {
 235         return;
 236 }
 237
 238 NTSTATUS dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 239                              void (*parser)(TDB_DATA key, TDB_DATA data,
 240                                             void *private_data),
 241                              void *private_data)
 242 {
 243         if (parser == NULL) {
 244                 parser = dbwrap_null_parser;
 245         }
 246
 247         if (db->parse_record == NULL) {
 248                 return dbwrap_fallback_parse_record(db, key, parser,
 249                                                     private_data);
 250         }
 251         return db->parse_record(db, key, parser, private_data);
 252 }
 253
 254 int dbwrap_wipe(struct db_context *db)
 255 {
 256         if (db->wipe == NULL) {
 257                 return dbwrap_fallback_wipe(db);
 258         }
 259         return db->wipe(db);
 260 }
 261
 262 int dbwrap_get_seqnum(struct db_context *db)
 263 {
 264         return db->get_seqnum(db);
 265 }
 266
 267 int dbwrap_get_flags(struct db_context *db)
 268 {
 269         return db->get_flags(db);
 270 }
 271
 272 int dbwrap_transaction_start(struct db_context *db)
 273 {
 274         return db->transaction_start(db);
 275 }
 276
 277 int dbwrap_transaction_commit(struct db_context *db)
 278 {
 279         return db->transaction_commit(db);
 280 }
 281
 282 int dbwrap_transaction_cancel(struct db_context *db)
 283 {
 284         return db->transaction_cancel(db);
 285 }