Remove extra 0x prefix for the "%p" format specifiers, avoiding 0x0x0 strings in...
[kai/samba-autobuild/.git] / 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/tdb_wrap/tdb_wrap.h"
25 #include "lib/util/util_tdb.h"
26 #include "system/filesys.h"
27 #include "lib/param/param.h"
28 #include "libcli/util/error.h"
29
30 struct db_tdb_ctx {
31         struct tdb_wrap *wtdb;
32
33         struct {
34                 dev_t dev;
35                 ino_t ino;
36         } id;
37 };
38
39 static NTSTATUS db_tdb_storev(struct db_record *rec,
40                               const TDB_DATA *dbufs, int num_dbufs, int flag);
41 static NTSTATUS db_tdb_delete(struct db_record *rec);
42
43 static void db_tdb_log_key(const char *prefix, TDB_DATA key)
44 {
45         size_t len;
46         char *keystr;
47         TALLOC_CTX *frame;
48         if (DEBUGLEVEL < 10) {
49                 return;
50         }
51         frame = talloc_stackframe();
52         len = key.dsize;
53         if (DEBUGLEVEL == 10) {
54                 /*
55                  * Only fully spam at debuglevel > 10
56                  */
57                 len = MIN(10, key.dsize);
58         }
59         keystr = hex_encode_talloc(frame, (unsigned char *)(key.dptr),
60                                    len);
61         DEBUG(10, ("%s key %s\n", prefix, keystr));
62         TALLOC_FREE(frame);
63 }
64
65 static int db_tdb_record_destr(struct db_record* data)
66 {
67         struct db_tdb_ctx *ctx =
68                 talloc_get_type_abort(data->private_data, struct db_tdb_ctx);
69
70         db_tdb_log_key("Unlocking", data->key);
71         tdb_chainunlock(ctx->wtdb->tdb, data->key);
72         return 0;
73 }
74
75 struct tdb_fetch_locked_state {
76         TALLOC_CTX *mem_ctx;
77         struct db_record *result;
78 };
79
80 static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,
81                                   void *private_data)
82 {
83         struct tdb_fetch_locked_state *state =
84                 (struct tdb_fetch_locked_state *)private_data;
85         struct db_record *result;
86
87         result = (struct db_record *)talloc_size(
88                 state->mem_ctx,
89                 sizeof(struct db_record) + key.dsize + data.dsize);
90
91         if (result == NULL) {
92                 return 0;
93         }
94         state->result = result;
95
96         result->key.dsize = key.dsize;
97         result->key.dptr = ((uint8_t *)result) + sizeof(struct db_record);
98         memcpy(result->key.dptr, key.dptr, key.dsize);
99
100         result->value.dsize = data.dsize;
101
102         if (data.dsize > 0) {
103                 result->value.dptr = result->key.dptr+key.dsize;
104                 memcpy(result->value.dptr, data.dptr, data.dsize);
105         }
106         else {
107                 result->value.dptr = NULL;
108         }
109
110         return 0;
111 }
112
113 static struct db_record *db_tdb_fetch_locked_internal(
114         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
115 {
116         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
117                                                        struct db_tdb_ctx);
118         struct tdb_fetch_locked_state state;
119
120         state.mem_ctx = mem_ctx;
121         state.result = NULL;
122
123         if ((tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse,
124                               &state) < 0) &&
125             (tdb_error(ctx->wtdb->tdb) != TDB_ERR_NOEXIST)) {
126                 tdb_chainunlock(ctx->wtdb->tdb, key);
127                 return NULL;
128         }
129
130         if (state.result == NULL) {
131                 db_tdb_fetchlock_parse(key, tdb_null, &state);
132         }
133
134         if (state.result == NULL) {
135                 tdb_chainunlock(ctx->wtdb->tdb, key);
136                 return NULL;
137         }
138
139         talloc_set_destructor(state.result, db_tdb_record_destr);
140
141         state.result->private_data = ctx;
142         state.result->storev = db_tdb_storev;
143         state.result->delete_rec = db_tdb_delete;
144
145         DEBUG(10, ("Allocated locked data %p\n", state.result));
146
147         return state.result;
148 }
149
150 static struct db_record *db_tdb_fetch_locked(
151         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
152 {
153         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
154                                                        struct db_tdb_ctx);
155
156         db_tdb_log_key("Locking", key);
157         if (tdb_chainlock(ctx->wtdb->tdb, key) != 0) {
158                 DEBUG(3, ("tdb_chainlock failed\n"));
159                 return NULL;
160         }
161         return db_tdb_fetch_locked_internal(db, mem_ctx, key);
162 }
163
164 static struct db_record *db_tdb_try_fetch_locked(
165         struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key)
166 {
167         struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,
168                                                        struct db_tdb_ctx);
169
170         db_tdb_log_key("Trying to lock", key);
171         if (tdb_chainlock_nonblock(ctx->wtdb->tdb, key) != 0) {
172                 DEBUG(3, ("tdb_chainlock_nonblock failed\n"));
173                 return NULL;
174         }
175         return db_tdb_fetch_locked_internal(db, mem_ctx, key);
176 }
177
178 static NTSTATUS db_tdb_do_locked(struct db_context *db, TDB_DATA key,
179                                  void (*fn)(struct db_record *rec,
180                                             void *private_data),
181                                  void *private_data)
182 {
183         struct db_tdb_ctx *ctx = talloc_get_type_abort(
184                 db->private_data, struct db_tdb_ctx);
185         uint8_t *buf = NULL;
186         struct db_record rec;
187         int ret;
188
189         ret = tdb_chainlock(ctx->wtdb->tdb, key);
190         if (ret == -1) {
191                 enum TDB_ERROR err = tdb_error(ctx->wtdb->tdb);
192                 DBG_DEBUG("tdb_chainlock failed: %s\n",
193                           tdb_errorstr(ctx->wtdb->tdb));
194                 return map_nt_error_from_tdb(err);
195         }
196
197         ret = tdb_fetch_talloc(ctx->wtdb->tdb, key, ctx, &buf);
198
199         if ((ret != 0) && (ret != ENOENT)) {
200                 DBG_DEBUG("tdb_fetch_talloc failed: %s\n",
201                           strerror(errno));
202                 tdb_chainunlock(ctx->wtdb->tdb, key);
203                 return map_nt_error_from_unix_common(ret);
204         }
205
206         rec = (struct db_record) {
207                 .db = db, .key = key,
208                 .value = (struct TDB_DATA) { .dptr = buf,
209                                              .dsize = talloc_get_size(buf) },
210                 .storev = db_tdb_storev, .delete_rec = db_tdb_delete,
211                 .private_data = ctx
212         };
213
214         fn(&rec, private_data);
215
216         talloc_free(buf);
217
218         tdb_chainunlock(ctx->wtdb->tdb, key);
219
220         return NT_STATUS_OK;
221 }
222
223 static int db_tdb_exists(struct db_context *db, TDB_DATA key)
224 {
225         struct db_tdb_ctx *ctx = talloc_get_type_abort(
226                 db->private_data, struct db_tdb_ctx);
227         return tdb_exists(ctx->wtdb->tdb, key);
228 }
229
230 static int db_tdb_wipe(struct db_context *db)
231 {
232         struct db_tdb_ctx *ctx = talloc_get_type_abort(
233                 db->private_data, struct db_tdb_ctx);
234         return tdb_wipe_all(ctx->wtdb->tdb);
235 }
236
237 static int db_tdb_check(struct db_context *db)
238 {
239         struct db_tdb_ctx *ctx = talloc_get_type_abort(
240                 db->private_data, struct db_tdb_ctx);
241         return tdb_check(ctx->wtdb->tdb, NULL, NULL);
242 }
243
244 struct db_tdb_parse_state {
245         void (*parser)(TDB_DATA key, TDB_DATA data,
246                        void *private_data);
247         void *private_data;
248 };
249
250 /*
251  * tdb_parse_record expects a parser returning int, mixing up tdb and
252  * parser errors. Wrap around that by always returning 0 and have
253  * dbwrap_parse_record expect a parser returning void.
254  */
255
256 static int db_tdb_parser(TDB_DATA key, TDB_DATA data, void *private_data)
257 {
258         struct db_tdb_parse_state *state =
259                 (struct db_tdb_parse_state *)private_data;
260         state->parser(key, data, state->private_data);
261         return 0;
262 }
263
264 static NTSTATUS db_tdb_parse(struct db_context *db, TDB_DATA key,
265                              void (*parser)(TDB_DATA key, TDB_DATA data,
266                                            void *private_data),
267                              void *private_data)
268 {
269         struct db_tdb_ctx *ctx = talloc_get_type_abort(
270                 db->private_data, struct db_tdb_ctx);
271         struct db_tdb_parse_state state;
272         int ret;
273
274         state.parser = parser;
275         state.private_data = private_data;
276
277         ret = tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_parser, &state);
278
279         if (ret != 0) {
280                 return map_nt_error_from_tdb(tdb_error(ctx->wtdb->tdb));
281         }
282         return NT_STATUS_OK;
283 }
284
285 static NTSTATUS db_tdb_storev(struct db_record *rec,
286                               const TDB_DATA *dbufs, int num_dbufs, int flag)
287 {
288         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
289                                                        struct db_tdb_ctx);
290         int ret;
291
292         /*
293          * This has a bug: We need to replace rec->value for correct
294          * operation, but right now brlock and locking don't use the value
295          * anymore after it was stored.
296          */
297
298         ret = tdb_storev(ctx->wtdb->tdb, rec->key, dbufs, num_dbufs, flag);
299         return (ret == 0) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
300 }
301
302 static NTSTATUS db_tdb_delete(struct db_record *rec)
303 {
304         struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,
305                                                        struct db_tdb_ctx);
306
307         if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {
308                 return NT_STATUS_OK;
309         }
310
311         if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) {
312                 return NT_STATUS_NOT_FOUND;
313         }
314
315         return NT_STATUS_UNSUCCESSFUL;
316 }
317
318 struct db_tdb_traverse_ctx {
319         struct db_context *db;
320         int (*f)(struct db_record *rec, void *private_data);
321         void *private_data;
322 };
323
324 static int db_tdb_traverse_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
325                                 void *private_data)
326 {
327         struct db_tdb_traverse_ctx *ctx =
328                 (struct db_tdb_traverse_ctx *)private_data;
329         struct db_record rec;
330
331         rec.key = kbuf;
332         rec.value = dbuf;
333         rec.storev = db_tdb_storev;
334         rec.delete_rec = db_tdb_delete;
335         rec.private_data = ctx->db->private_data;
336         rec.db = ctx->db;
337
338         return ctx->f(&rec, ctx->private_data);
339 }
340
341 static int db_tdb_traverse(struct db_context *db,
342                            int (*f)(struct db_record *rec, void *private_data),
343                            void *private_data)
344 {
345         struct db_tdb_ctx *db_ctx =
346                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
347         struct db_tdb_traverse_ctx ctx;
348
349         ctx.db = db;
350         ctx.f = f;
351         ctx.private_data = private_data;
352         return tdb_traverse(db_ctx->wtdb->tdb, db_tdb_traverse_func, &ctx);
353 }
354
355 static NTSTATUS db_tdb_storev_deny(struct db_record *rec,
356                                    const TDB_DATA *dbufs, int num_dbufs,
357                                    int flag)
358 {
359         return NT_STATUS_MEDIA_WRITE_PROTECTED;
360 }
361
362 static NTSTATUS db_tdb_delete_deny(struct db_record *rec)
363 {
364         return NT_STATUS_MEDIA_WRITE_PROTECTED;
365 }
366
367 static int db_tdb_traverse_read_func(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
368                                 void *private_data)
369 {
370         struct db_tdb_traverse_ctx *ctx =
371                 (struct db_tdb_traverse_ctx *)private_data;
372         struct db_record rec;
373
374         rec.key = kbuf;
375         rec.value = dbuf;
376         rec.storev = db_tdb_storev_deny;
377         rec.delete_rec = db_tdb_delete_deny;
378         rec.private_data = ctx->db->private_data;
379         rec.db = ctx->db;
380
381         return ctx->f(&rec, ctx->private_data);
382 }
383
384 static int db_tdb_traverse_read(struct db_context *db,
385                            int (*f)(struct db_record *rec, void *private_data),
386                            void *private_data)
387 {
388         struct db_tdb_ctx *db_ctx =
389                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
390         struct db_tdb_traverse_ctx ctx;
391
392         ctx.db = db;
393         ctx.f = f;
394         ctx.private_data = private_data;
395         return tdb_traverse_read(db_ctx->wtdb->tdb, db_tdb_traverse_read_func, &ctx);
396 }
397
398 static int db_tdb_get_seqnum(struct db_context *db)
399
400 {
401         struct db_tdb_ctx *db_ctx =
402                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
403         return tdb_get_seqnum(db_ctx->wtdb->tdb);
404 }
405
406 static int db_tdb_transaction_start(struct db_context *db)
407 {
408         struct db_tdb_ctx *db_ctx =
409                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
410         return tdb_transaction_start(db_ctx->wtdb->tdb) ? -1 : 0;
411 }
412
413 static NTSTATUS db_tdb_transaction_start_nonblock(struct db_context *db)
414 {
415         struct db_tdb_ctx *db_ctx =
416                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
417         int ret;
418
419         ret = tdb_transaction_start_nonblock(db_ctx->wtdb->tdb);
420         if (ret != 0) {
421                 return map_nt_error_from_tdb(tdb_error(db_ctx->wtdb->tdb));
422         }
423         return NT_STATUS_OK;
424 }
425
426 static int db_tdb_transaction_commit(struct db_context *db)
427 {
428         struct db_tdb_ctx *db_ctx =
429                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
430         return tdb_transaction_commit(db_ctx->wtdb->tdb) ? -1 : 0;
431 }
432
433 static int db_tdb_transaction_cancel(struct db_context *db)
434 {
435         struct db_tdb_ctx *db_ctx =
436                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
437         tdb_transaction_cancel(db_ctx->wtdb->tdb);
438         return 0;
439 }
440
441 static size_t db_tdb_id(struct db_context *db, uint8_t *id, size_t idlen)
442 {
443         struct db_tdb_ctx *db_ctx =
444                 talloc_get_type_abort(db->private_data, struct db_tdb_ctx);
445
446         if (idlen >= sizeof(db_ctx->id)) {
447                 memcpy(id, &db_ctx->id, sizeof(db_ctx->id));
448         }
449
450         return sizeof(db_ctx->id);
451 }
452
453 struct db_context *db_open_tdb(TALLOC_CTX *mem_ctx,
454                                const char *name,
455                                int hash_size, int tdb_flags,
456                                int open_flags, mode_t mode,
457                                enum dbwrap_lock_order lock_order,
458                                uint64_t dbwrap_flags)
459 {
460         struct db_context *result = NULL;
461         struct db_tdb_ctx *db_tdb;
462         struct stat st;
463
464         result = talloc_zero(mem_ctx, struct db_context);
465         if (result == NULL) {
466                 DEBUG(0, ("talloc failed\n"));
467                 goto fail;
468         }
469
470         result->private_data = db_tdb = talloc(result, struct db_tdb_ctx);
471         if (db_tdb == NULL) {
472                 DEBUG(0, ("talloc failed\n"));
473                 goto fail;
474         }
475         result->lock_order = lock_order;
476
477         db_tdb->wtdb = tdb_wrap_open(db_tdb, name, hash_size, tdb_flags,
478                                      open_flags, mode);
479         if (db_tdb->wtdb == NULL) {
480                 DEBUG(3, ("Could not open tdb: %s\n", strerror(errno)));
481                 goto fail;
482         }
483
484         ZERO_STRUCT(db_tdb->id);
485
486         if (fstat(tdb_fd(db_tdb->wtdb->tdb), &st) == -1) {
487                 DEBUG(3, ("fstat failed: %s\n", strerror(errno)));
488                 goto fail;
489         }
490         db_tdb->id.dev = st.st_dev;
491         db_tdb->id.ino = st.st_ino;
492
493         result->fetch_locked = db_tdb_fetch_locked;
494         result->try_fetch_locked = db_tdb_try_fetch_locked;
495         result->do_locked = db_tdb_do_locked;
496         result->traverse = db_tdb_traverse;
497         result->traverse_read = db_tdb_traverse_read;
498         result->parse_record = db_tdb_parse;
499         result->get_seqnum = db_tdb_get_seqnum;
500         result->persistent = ((tdb_flags & TDB_CLEAR_IF_FIRST) == 0);
501         result->transaction_start = db_tdb_transaction_start;
502         result->transaction_start_nonblock = db_tdb_transaction_start_nonblock;
503         result->transaction_commit = db_tdb_transaction_commit;
504         result->transaction_cancel = db_tdb_transaction_cancel;
505         result->exists = db_tdb_exists;
506         result->wipe = db_tdb_wipe;
507         result->id = db_tdb_id;
508         result->check = db_tdb_check;
509         result->name = tdb_name(db_tdb->wtdb->tdb);
510         return result;
511
512  fail:
513         TALLOC_FREE(result);
514         return NULL;
515 }