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