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