source3/lib/dbwrap_tdb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Database interface wrapper around tdb
   4    Copyright (C) Volker Lendecke 2005-2007
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "dbwrap.h"
  22
  23 struct db_tdb_ctx {
  24         struct tdb_wrap *wtdb;
  25 };
  26
  27 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag);
  28 static NTSTATUS db_tdb_delete(struct db_record *rec);
  29
  30 static int db_tdb_record_destr(struct db_record* data)
  31 {
  32         struct db_tdb_ctx *ctx =
  33                 talloc_get_type_abort(data->private_data, struct db_tdb_ctx);
  34
  35         /* This hex_encode_talloc() call allocates memory on data context. By way how current
  36            __talloc_free() code works, it is OK to allocate in the destructor as
  37            the children of data will be freed after call to the destructor and this
  38            new 'child' will be caught and freed correctly.
  39          */
  40         DEBUG(10, (DEBUGLEVEL > 10
  41                    ? "Unlocking key %s\n" : "Unlocking key %.20s\n",
  42                    hex_encode_talloc(data, (unsigned char *)data->key.dptr,
  43                               data->key.dsize)));
  44
  45         if (tdb_chainunlock(ctx->wtdb->tdb, data->key) != 0) {
  46                 DEBUG(0, ("tdb_chainunlock failed\n"));
  47                 return -1;
  48         }
  49         return 0;
  50 }
  51
  52 struct tdb_fetch_locked_state {
  53         TALLOC_CTX *mem_ctx;
  54         struct db_record *result;
  55 };
  56
  57 static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,
  58                                   void *private_data)
  59 {
  60         struct tdb_fetch_locked_state *state =
  61                 (struct tdb_fetch_locked_state *)private_data;
  62
  63         state->result = (struct db_record *)talloc_size(
  64                 state->mem_ctx,
  65                 sizeof(struct db_record) + key.dsize + data.dsize);
  66
  67         if (state->result == NULL) {
  68                 return 0;
  69         }
  70
  71         state->result->key.dsize = key.dsize;
  72         state->result->key.dptr = ((uint8 *)state->result)
  73                 + sizeof(struct db_record);
  74         memcpy(state->result->key.dptr, key.dptr, key.dsize);
  75
  76         state->result->value.dsize = data.dsize;
  77
  78         if (data.dsize > 0) {
  79                 state->result->value.dptr = state->result->key.dptr+key.dsize;
  80                 memcpy(state->result->value.dptr, data.dptr, data.dsize);
  81         }
  82         else {
  83                 state->result->value.dptr = NULL;
  84         }
  85
  86         return 0;
  87 }
  88
  89 static struct db_record *db_tdb_fetch_locked(struct db_context *db,
  90                                      TALLOC_CTX *mem_ctx, TDB_DATA key)
  91 {
  92         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
  93                                                        struct db_tdb_ctx);
  94         struct tdb_fetch_locked_state state;
  95
  96         /* Do not accidently allocate/deallocate w/o need when debug level is lower than needed */
  97         if(DEBUGLEVEL >= 10) {
  98                 char *keystr = hex_encode_talloc(talloc_tos(), (unsigned char*)key.dptr, key.dsize);
  99                 DEBUG(10, (DEBUGLEVEL > 10
 100                            ? "Locking key %s\n" : "Locking key %.20s\n",
 101                            keystr));
 102                 TALLOC_FREE(keystr);
 103         }
 104
 105         if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
 106                 DEBUG(3, ("tdb_chainlock failed\n"));
 107                 return NULL;
 108         }
 109
 110         state.mem_ctx = mem_ctx;
 111         state.result = NULL;
 112
 113         tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse, &state);
 114
 115         if (state.result == NULL) {
 116                 db_tdb_fetchlock_parse(key, tdb_null, &state);
 117         }
 118
 119         if (state.result == NULL) {
 120                 tdb_chainunlock(ctx->wtdb->tdb, key);
 121                 return NULL;
 122         }
 123
 124         talloc_set_destructor(state.result, db_tdb_record_destr);
 125
 126         state.result->private_data = talloc_reference(state.result, ctx);
 127         state.result->store = db_tdb_store;
 128         state.result->delete_rec = db_tdb_delete;
 129
 130         DEBUG(10, ("Allocated locked data 0x%p\n", state.result));
 131
 132         return state.result;
 133 }
 134
 135 struct tdb_fetch_state {
 136         TALLOC_CTX *mem_ctx;
 137         int result;
 138         TDB_DATA data;
 139 };
 140
 141 static int db_tdb_fetch_parse(TDB_DATA key, TDB_DATA data,
 142                               void *private_data)
 143 {
 144         struct tdb_fetch_state *state =
 145                 (struct tdb_fetch_state *)private_data;
 146
 147         state->data.dptr = (uint8 *)talloc_memdup(state->mem_ctx, data.dptr,
 148                                                   data.dsize);
 149         if (state->data.dptr == NULL) {
 150                 state->result = -1;
 151                 return 0;
 152         }
 153
 154         state->data.dsize = data.dsize;
 155         return 0;
 156 }
 157
 158 static int db_tdb_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 159                         TDB_DATA key, TDB_DATA *pdata)
 160 {
 161         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 162                 db->private_data, struct db_tdb_ctx);
 163
 164         struct tdb_fetch_state state;
 165
 166         state.mem_ctx = mem_ctx;
 167         state.result = 0;
 168         state.data = tdb_null;
 169
 170         tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetch_parse, &state);
 171
 172         if (state.result == -1) {
 173                 return -1;
 174         }
 175
 176         *pdata = state.data;
 177         return 0;
 178 }
 179
 180 static int db_tdb_parse(struct db_context *db, TDB_DATA key,
 181                         int (*parser)(TDB_DATA key, TDB_DATA data,
 182                                       void *private_data),
 183                         void *private_data)
 184 {
 185         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 186                 db->private_data, struct db_tdb_ctx);
 187
 188         return tdb_parse_record(ctx->wtdb->tdb, key, parser, private_data);
 189 }
 190
 191 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag)
 192 {
 193         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
 194                                                        struct db_tdb_ctx);
 195
 196         /*
 197          * This has a bug: We need to replace rec->value for correct
 198          * operation, but right now brlock and locking don't use the value
 199          * anymore after it was stored.
 200          */
 201
 202         return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ?
 203                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 204 }
 205
 206 static NTSTATUS db_tdb_delete(struct db_record *rec)
 207 {
 208         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
 209                                                        struct db_tdb_ctx);
 210
 211         if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {
 212                 return NT_STATUS_OK;
 213         }
 214
 215         if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) {
 216                 return NT_STATUS_NOT_FOUND;
 217         }
 218
 219         return NT_STATUS_UNSUCCESSFUL;
 220 }
 221
 222 struct db_tdb_traverse_ctx {
 223         struct db_context *db;
 224         int (*f)(struct db_record *rec, void *private_data);
 225         void *private_data;
 226 };
 227
 228 static int db_tdb_traverse_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
 229                                 void *private_data)
 230 {
 231         struct db_tdb_traverse_ctx *ctx =
 232                 (struct db_tdb_traverse_ctx *)private_data;
 233         struct db_record rec;
 234
 235         rec.key = kbuf;
 236         rec.value = dbuf;
 237         rec.store = db_tdb_store;
 238         rec.delete_rec = db_tdb_delete;
 239         rec.private_data = ctx->db->private_data;
 240
 241         return ctx->f(&rec, ctx->private_data);
 242 }
 243
 244 static int db_tdb_traverse(struct db_context *db,
 245                            int (*f)(struct db_record *rec, void *private_data),
 246                            void *private_data)
 247 {
 248         struct db_tdb_ctx *db_ctx =
 249                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 250         struct db_tdb_traverse_ctx ctx;
 251
 252         ctx.db = db;
 253         ctx.f = f;
 254         ctx.private_data = private_data;
 255         return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx);
 256 }
 257
 258 static NTSTATUS db_tdb_store_deny(struct db_record *rec, TDB_DATA data, int flag)
 259 {
 260         return NT_STATUS_MEDIA_WRITE_PROTECTED;
 261 }
 262
 263 static NTSTATUS db_tdb_delete_deny(struct db_record *rec)
 264 {
 265         return NT_STATUS_MEDIA_WRITE_PROTECTED;
 266 }
 267
 268 static int db_tdb_traverse_read_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
 269                                 void *private_data)
 270 {
 271         struct db_tdb_traverse_ctx *ctx =
 272                 (struct db_tdb_traverse_ctx *)private_data;
 273         struct db_record rec;
 274
 275         rec.key = kbuf;
 276         rec.value = dbuf;
 277         rec.store = db_tdb_store_deny;
 278         rec.delete_rec = db_tdb_delete_deny;
 279         rec.private_data = ctx->db->private_data;
 280
 281         return ctx->f(&rec, ctx->private_data);
 282 }
 283
 284 static int db_tdb_traverse_read(struct db_context *db,
 285                            int (*f)(struct db_record *rec, void *private_data),
 286                            void *private_data)
 287 {
 288         struct db_tdb_ctx *db_ctx =
 289                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 290         struct db_tdb_traverse_ctx ctx;
 291
 292         ctx.db = db;
 293         ctx.f = f;
 294         ctx.private_data = private_data;
 295         return tdb_traverse_read(db_ctx->wtdb->tdb, db_tdb_traverse_read_func, &ctx);
 296 }
 297
 298 static int db_tdb_get_seqnum(struct db_context *db)
 299
 300 {
 301         struct db_tdb_ctx *db_ctx =
 302                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 303         return tdb_get_seqnum(db_ctx->wtdb->tdb);
 304 }
 305
 306 static int db_tdb_get_flags(struct db_context *db)
 307
 308 {
 309         struct db_tdb_ctx *db_ctx =
 310                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 311         return tdb_get_flags(db_ctx->wtdb->tdb);
 312 }
 313
 314 static int db_tdb_transaction_start(struct db_context *db)
 315 {
 316         struct db_tdb_ctx *db_ctx =
 317                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 318         return tdb_transaction_start(db_ctx->wtdb->tdb);
 319 }
 320
 321 static int db_tdb_transaction_commit(struct db_context *db)
 322 {
 323         struct db_tdb_ctx *db_ctx =
 324                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 325         return tdb_transaction_commit(db_ctx->wtdb->tdb);
 326 }
 327
 328 static int db_tdb_transaction_cancel(struct db_context *db)
 329 {
 330         struct db_tdb_ctx *db_ctx =
 331                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 332         return tdb_transaction_cancel(db_ctx->wtdb->tdb);
 333 }
 334
 335 struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx,
 336                                const char *name,
 337                                int hash_size, int tdb_flags,
 338                                int open_flags, mode_t mode)
 339 {
 340         struct db_context *result = NULL;
 341         struct db_tdb_ctx *db_tdb;
 342
 343         result = TALLOC_ZERO_P(mem_ctx, struct db_context);
 344         if (result == NULL) {
 345                 DEBUG(0, ("talloc failed\n"));
 346                 goto fail;
 347         }
 348
 349         result->private_data = db_tdb = TALLOC_P(result, struct db_tdb_ctx);
 350         if (db_tdb == NULL) {
 351                 DEBUG(0, ("talloc failed\n"));
 352                 goto fail;
 353         }
 354
 355         db_tdb->wtdb = tdb_wrap_open(db_tdb, name, hash_size, tdb_flags,
 356                                      open_flags, mode);
 357         if (db_tdb->wtdb == NULL) {
 358                 DEBUG(3, ("Could not open tdb: %s\n", strerror(errno)));
 359                 goto fail;
 360         }
 361
 362         result->fetch_locked = db_tdb_fetch_locked;
 363         result->fetch = db_tdb_fetch;
 364         result->traverse = db_tdb_traverse;
 365         result->traverse_read = db_tdb_traverse_read;
 366         result->parse_record = db_tdb_parse;
 367         result->get_seqnum = db_tdb_get_seqnum;
 368         result->get_flags = db_tdb_get_flags;
 369         result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
 370         result->transaction_start = db_tdb_transaction_start;
 371         result->transaction_commit = db_tdb_transaction_commit;
 372         result->transaction_cancel = db_tdb_transaction_cancel;
 373         return result;
 374
 375  fail:
 376         if (result != NULL) {
 377                 TALLOC_FREE(result);
 378         }
 379         return NULL;
 380 }