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