source3/lib/dbwrap/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/dbwrap.h"
  22 #include "dbwrap/dbwrap_private.h"
  23 #include "dbwrap/dbwrap_tdb.h"
  24 #include "lib/util/tdb_wrap.h"
  25 #include "lib/param/param.h"
  26 #include "util_tdb.h"
  27
  28 struct db_tdb_ctx {
  29         struct tdb_wrap *wtdb;
  30 };
  31
  32 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag);
  33 static NTSTATUS db_tdb_delete(struct db_record *rec);
  34
  35 static void db_tdb_log_key(const char *prefix, TDB_DATA key)
  36 {
  37         size_t len;
  38         char *keystr;
  39
  40         if (DEBUGLEVEL < 10) {
  41                 return;
  42         }
  43         len = key.dsize;
  44         if (DEBUGLEVEL == 10) {
  45                 /*
  46                  * Only fully spam at debuglevel > 10
  47                  */
  48                 len = MIN(10, key.dsize);
  49         }
  50         keystr = hex_encode_talloc(talloc_tos(), (unsigned char *)(key.dptr),
  51                                    len);
  52         DEBUG(10, ("%s key %s\n", prefix, keystr));
  53         TALLOC_FREE(keystr);
  54 }
  55
  56 static int db_tdb_record_destr(struct db_record* data)
  57 {
  58         struct db_tdb_ctx *ctx =
  59                 talloc_get_type_abort(data->private_data, struct db_tdb_ctx);
  60
  61         db_tdb_log_key("Unlocking", data->key);
  62         tdb_chainunlock(ctx->wtdb->tdb, data->key);
  63         return 0;
  64 }
  65
  66 struct tdb_fetch_locked_state {
  67         TALLOC_CTX *mem_ctx;
  68         struct db_record *result;
  69 };
  70
  71 static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,
  72                                   void *private_data)
  73 {
  74         struct tdb_fetch_locked_state *state =
  75                 (struct tdb_fetch_locked_state *)private_data;
  76         struct db_record *result;
  77
  78         result = (struct db_record *)talloc_size(
  79                 state->mem_ctx,
  80                 sizeof(struct db_record) + key.dsize + data.dsize);
  81
  82         if (result == NULL) {
  83                 return 0;
  84         }
  85         state->result = result;
  86
  87         result->key.dsize = key.dsize;
  88         result->key.dptr = ((uint8 *)result) + sizeof(struct db_record);
  89         memcpy(result->key.dptr, key.dptr, key.dsize);
  90
  91         result->value.dsize = data.dsize;
  92
  93         if (data.dsize > 0) {
  94                 result->value.dptr = result->key.dptr+key.dsize;
  95                 memcpy(result->value.dptr, data.dptr, data.dsize);
  96         }
  97         else {
  98                 result->value.dptr = NULL;
  99         }
 100
 101         return 0;
 102 }
 103
 104 static struct db_record *db_tdb_fetch_locked(struct db_context *db,
 105                                      TALLOC_CTX *mem_ctx, TDB_DATA key)
 106 {
 107         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
 108                                                        struct db_tdb_ctx);
 109         struct tdb_fetch_locked_state state;
 110
 111         db_tdb_log_key("Locking", key);
 112
 113         if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
 114                 DEBUG(3, ("tdb_chainlock failed\n"));
 115                 return NULL;
 116         }
 117
 118         state.mem_ctx = mem_ctx;
 119         state.result = NULL;
 120
 121         tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse, &state);
 122
 123         if (state.result == NULL) {
 124                 db_tdb_fetchlock_parse(key, tdb_null, &state);
 125         }
 126
 127         if (state.result == NULL) {
 128                 tdb_chainunlock(ctx->wtdb->tdb, key);
 129                 return NULL;
 130         }
 131
 132         talloc_set_destructor(state.result, db_tdb_record_destr);
 133
 134         state.result->private_data = talloc_reference(state.result, ctx);
 135         state.result->store = db_tdb_store;
 136         state.result->delete_rec = db_tdb_delete;
 137
 138         DEBUG(10, ("Allocated locked data 0x%p\n", state.result));
 139
 140         return state.result;
 141 }
 142
 143 struct tdb_fetch_state {
 144         TALLOC_CTX *mem_ctx;
 145         NTSTATUS result;
 146         TDB_DATA data;
 147 };
 148
 149 static int db_tdb_fetch_parse(TDB_DATA key, TDB_DATA data,
 150                               void *private_data)
 151 {
 152         struct tdb_fetch_state *state =
 153                 (struct tdb_fetch_state *)private_data;
 154
 155         if (data.dptr == NULL) {
 156                 /* should not happen */
 157                 state->result = NT_STATUS_INTERNAL_DB_ERROR;
 158                 return -1;
 159         }
 160
 161         state->data.dptr = (uint8 *)talloc_memdup(state->mem_ctx, data.dptr,
 162                                                   data.dsize);
 163         if (state->data.dptr == NULL) {
 164                 state->result = NT_STATUS_NO_MEMORY;
 165                 return -1;
 166         }
 167
 168         state->data.dsize = data.dsize;
 169         return 0;
 170 }
 171
 172 static NTSTATUS db_tdb_fetch(struct db_context *db, TALLOC_CTX *mem_ctx,
 173                              TDB_DATA key, TDB_DATA *pdata)
 174 {
 175         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 176                 db->private_data, struct db_tdb_ctx);
 177
 178         struct tdb_fetch_state state;
 179         int ret;
 180
 181         state.mem_ctx = mem_ctx;
 182         state.result = NT_STATUS_OK;
 183         state.data = tdb_null;
 184
 185         ret = tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetch_parse, &state);
 186
 187         if (ret != 0) {
 188                 NTSTATUS status;
 189
 190                 if (!NT_STATUS_IS_OK(state.result)) {
 191                         /* the parser has set an error code. return it */
 192                         return state.result;
 193                 }
 194
 195                 status = map_nt_error_from_tdb(tdb_error(ctx->wtdb->tdb));
 196                 return status;
 197         }
 198
 199         if (!NT_STATUS_IS_OK(state.result)) {
 200                 return state.result;
 201         }
 202
 203         *pdata = state.data;
 204         return NT_STATUS_OK;
 205 }
 206
 207 static int db_tdb_exists(struct db_context *db, TDB_DATA key)
 208 {
 209         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 210                 db->private_data, struct db_tdb_ctx);
 211         return tdb_exists(ctx->wtdb->tdb, key);
 212 }
 213
 214 static int db_tdb_wipe(struct db_context *db)
 215 {
 216         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 217                 db->private_data, struct db_tdb_ctx);
 218         return tdb_wipe_all(ctx->wtdb->tdb);
 219 }
 220
 221 static int db_tdb_parse(struct db_context *db, TDB_DATA key,
 222                         int (*parser)(TDB_DATA key, TDB_DATA data,
 223                                       void *private_data),
 224                         void *private_data)
 225 {
 226         struct db_tdb_ctx *ctx = talloc_get_type_abort(
 227                 db->private_data, struct db_tdb_ctx);
 228
 229         return tdb_parse_record(ctx->wtdb->tdb, key, parser, private_data) ? -1 : 0;
 230 }
 231
 232 static NTSTATUS db_tdb_store(struct db_record *rec, TDB_DATA data, int flag)
 233 {
 234         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
 235                                                        struct db_tdb_ctx);
 236
 237         /*
 238          * This has a bug: We need to replace rec->value for correct
 239          * operation, but right now brlock and locking don't use the value
 240          * anymore after it was stored.
 241          */
 242
 243         return (tdb_store(ctx->wtdb->tdb, rec->key, data, flag) == 0) ?
 244                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 245 }
 246
 247 static NTSTATUS db_tdb_delete(struct db_record *rec)
 248 {
 249         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
 250                                                        struct db_tdb_ctx);
 251
 252         if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {
 253                 return NT_STATUS_OK;
 254         }
 255
 256         if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) {
 257                 return NT_STATUS_NOT_FOUND;
 258         }
 259
 260         return NT_STATUS_UNSUCCESSFUL;
 261 }
 262
 263 struct db_tdb_traverse_ctx {
 264         struct db_context *db;
 265         int (*f)(struct db_record *rec, void *private_data);
 266         void *private_data;
 267 };
 268
 269 static int db_tdb_traverse_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
 270                                 void *private_data)
 271 {
 272         struct db_tdb_traverse_ctx *ctx =
 273                 (struct db_tdb_traverse_ctx *)private_data;
 274         struct db_record rec;
 275
 276         rec.key = kbuf;
 277         rec.value = dbuf;
 278         rec.store = db_tdb_store;
 279         rec.delete_rec = db_tdb_delete;
 280         rec.private_data = ctx->db->private_data;
 281
 282         return ctx->f(&rec, ctx->private_data);
 283 }
 284
 285 static int db_tdb_traverse(struct db_context *db,
 286                            int (*f)(struct db_record *rec, void *private_data),
 287                            void *private_data)
 288 {
 289         struct db_tdb_ctx *db_ctx =
 290                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 291         struct db_tdb_traverse_ctx ctx;
 292
 293         ctx.db = db;
 294         ctx.f = f;
 295         ctx.private_data = private_data;
 296         return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx);
 297 }
 298
 299 static NTSTATUS db_tdb_store_deny(struct db_record *rec, TDB_DATA data, int flag)
 300 {
 301         return NT_STATUS_MEDIA_WRITE_PROTECTED;
 302 }
 303
 304 static NTSTATUS db_tdb_delete_deny(struct db_record *rec)
 305 {
 306         return NT_STATUS_MEDIA_WRITE_PROTECTED;
 307 }
 308
 309 static int db_tdb_traverse_read_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
 310                                 void *private_data)
 311 {
 312         struct db_tdb_traverse_ctx *ctx =
 313                 (struct db_tdb_traverse_ctx *)private_data;
 314         struct db_record rec;
 315
 316         rec.key = kbuf;
 317         rec.value = dbuf;
 318         rec.store = db_tdb_store_deny;
 319         rec.delete_rec = db_tdb_delete_deny;
 320         rec.private_data = ctx->db->private_data;
 321
 322         return ctx->f(&rec, ctx->private_data);
 323 }
 324
 325 static int db_tdb_traverse_read(struct db_context *db,
 326                            int (*f)(struct db_record *rec, void *private_data),
 327                            void *private_data)
 328 {
 329         struct db_tdb_ctx *db_ctx =
 330                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 331         struct db_tdb_traverse_ctx ctx;
 332
 333         ctx.db = db;
 334         ctx.f = f;
 335         ctx.private_data = private_data;
 336         return tdb_traverse_read(db_ctx->wtdb->tdb, db_tdb_traverse_read_func, &ctx);
 337 }
 338
 339 static int db_tdb_get_seqnum(struct db_context *db)
 340
 341 {
 342         struct db_tdb_ctx *db_ctx =
 343                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 344         return tdb_get_seqnum(db_ctx->wtdb->tdb);
 345 }
 346
 347 static int db_tdb_get_flags(struct db_context *db)
 348
 349 {
 350         struct db_tdb_ctx *db_ctx =
 351                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 352         return tdb_get_flags(db_ctx->wtdb->tdb);
 353 }
 354
 355 static int db_tdb_transaction_start(struct db_context *db)
 356 {
 357         struct db_tdb_ctx *db_ctx =
 358                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 359         return tdb_transaction_start(db_ctx->wtdb->tdb) ? -1 : 0;
 360 }
 361
 362 static int db_tdb_transaction_commit(struct db_context *db)
 363 {
 364         struct db_tdb_ctx *db_ctx =
 365                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 366         return tdb_transaction_commit(db_ctx->wtdb->tdb) ? -1 : 0;
 367 }
 368
 369 static int db_tdb_transaction_cancel(struct db_context *db)
 370 {
 371         struct db_tdb_ctx *db_ctx =
 372                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
 373         tdb_transaction_cancel(db_ctx->wtdb->tdb);
 374         return 0;
 375 }
 376
 377 struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx,
 378                                const char *name,
 379                                int hash_size, int tdb_flags,
 380                                int open_flags, mode_t mode)
 381 {
 382         struct db_context *result = NULL;
 383         struct db_tdb_ctx *db_tdb;
 384         struct loadparm_context *lp_ctx;
 385
 386         result = talloc_zero(mem_ctx, struct db_context);
 387         if (result == NULL) {
 388                 DEBUG(0, ("talloc failed\n"));
 389                 goto fail;
 390         }
 391         lp_ctx = loadparm_init_s3(result, loadparm_s3_context());
 392
 393         result->private_data = db_tdb = talloc(result, struct db_tdb_ctx);
 394         if (db_tdb == NULL) {
 395                 DEBUG(0, ("talloc failed\n"));
 396                 goto fail;
 397         }
 398
 399         db_tdb->wtdb = tdb_wrap_open(db_tdb, name, hash_size, tdb_flags,
 400                                      open_flags, mode, lp_ctx);
 401         talloc_unlink(result, lp_ctx);
 402         if (db_tdb->wtdb == NULL) {
 403                 DEBUG(3, ("Could not open tdb: %s\n", strerror(errno)));
 404                 goto fail;
 405         }
 406
 407         result->fetch_locked = db_tdb_fetch_locked;
 408         result->fetch = db_tdb_fetch;
 409         result->traverse = db_tdb_traverse;
 410         result->traverse_read = db_tdb_traverse_read;
 411         result->parse_record = db_tdb_parse;
 412         result->get_seqnum = db_tdb_get_seqnum;
 413         result->get_flags = db_tdb_get_flags;
 414         result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
 415         result->transaction_start = db_tdb_transaction_start;
 416         result->transaction_commit = db_tdb_transaction_commit;
 417         result->transaction_cancel = db_tdb_transaction_cancel;
 418         result->exists = db_tdb_exists;
 419         result->wipe = db_tdb_wipe;
 420         return result;
 421
 422  fail:
 423         if (result != NULL) {
 424                 TALLOC_FREE(result);
 425         }
 426         return NULL;
 427 }