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         TDB_DATA val;
  53         if ( db->fetch(db, talloc_tos(), key, &val) != 0 ) {
  54                 return 0;
  55         }
  56         if (val.dptr == NULL ) {
  57                 return 0;
  58         } else {
  59                 TALLOC_FREE(val.dptr);
  60                 return 1;
  61         }
  62 }
  63
  64 /*
  65  * Fall back using fetch if no genuine parse operation is provided
  66  */
  67
  68 int dbwrap_fallback_parse_record(struct db_context *db, TDB_DATA key,
  69                                  int (*parser)(TDB_DATA key,
  70                                                TDB_DATA data,
  71                                                void *private_data),
  72                                  void *private_data)
  73 {
  74         TDB_DATA data;
  75         int res;
  76
  77         res = db->fetch(db, talloc_tos(), key, &data);
  78         if (res != 0) {
  79                 return -1;
  80         }
  81
  82         res = parser(key, data, private_data);
  83         TALLOC_FREE(data.dptr);
  84         return res;
  85 }
  86
  87
  88 TDB_DATA dbwrap_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
  89                       TDB_DATA key)
  90 {
  91         TDB_DATA result;
  92
  93         if (db->fetch(db, mem_ctx, key, &result) != 0) {
  94                 return make_tdb_data(NULL, 0);
  95         }
  96
  97         return result;
  98 }
  99
 100 bool dbwrap_exists(struct db_context *db, TDB_DATA key)
 101 {
 102         int result;
 103         if (db->exists != NULL) {
 104                 result = db->exists(db, key);
 105         } else {
 106                 result = dbwrap_fallback_exists(db,key);
 107         }
 108         return (result == 1);
 109 }
 110
 111 NTSTATUS dbwrap_store(struct db_context *db, TDB_DATA key,
 112                       TDB_DATA data, int flags)
 113 {
 114         struct db_record *rec;
 115         NTSTATUS status;
 116
 117         rec = db->fetch_locked(db, talloc_tos(), key);
 118         if (rec == NULL) {
 119                 return NT_STATUS_NO_MEMORY;
 120         }
 121
 122         status = rec->store(rec, data, flags);
 123         TALLOC_FREE(rec);
 124         return status;
 125 }
 126
 127 NTSTATUS dbwrap_delete(struct db_context *db, TDB_DATA key)
 128 {
 129         struct db_record *rec;
 130         NTSTATUS status;
 131
 132         rec = db->fetch_locked(db, talloc_tos(), key);
 133         if (rec == NULL) {
 134                 return NT_STATUS_NO_MEMORY;
 135         }
 136         status = rec->delete_rec(rec);
 137         TALLOC_FREE(rec);
 138         return status;
 139 }
 140
 141 NTSTATUS dbwrap_traverse(struct db_context *db,
 142                          int (*f)(struct db_record*, void*),
 143                          void *private_data,
 144                          int *count)
 145 {
 146         int ret = db->traverse(db, f, private_data);
 147
 148         if (ret < 0) {
 149                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 150         }
 151
 152         if (count != NULL) {
 153                 *count = ret;
 154         }
 155
 156         return NT_STATUS_OK;
 157 }
 158
 159 NTSTATUS dbwrap_traverse_read(struct db_context *db,
 160                               int (*f)(struct db_record*, void*),
 161                               void *private_data,
 162                               int *count)
 163 {
 164         int ret = db->traverse_read(db, f, private_data);
 165
 166         if (ret < 0) {
 167                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
 168         }
 169
 170         if (count != NULL) {
 171                 *count = ret;
 172         }
 173
 174         return NT_STATUS_OK;
 175 }
 176
 177 static int dbwrap_null_parser(TDB_DATA key, TDB_DATA val, void* data)
 178 {
 179         return 0;
 180 }
 181
 182 int dbwrap_parse_record(struct db_context *db, TDB_DATA key,
 183                         int (*parser)(TDB_DATA key, TDB_DATA data,
 184                                       void *private_data),
 185                         void *private_data)
 186 {
 187         if (parser == NULL) {
 188                 parser = dbwrap_null_parser;
 189         }
 190
 191         if (db->parse_record) {
 192                 return db->parse_record(db, key, parser, private_data);
 193         } else {
 194                 return dbwrap_fallback_parse_record(db, key, parser, private_data);
 195         }
 196 }