source: vendor/3.5.0/source3/lib/dbwrap_tdb.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

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