?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r23751: Call tdb_close even when validation was not successful.
[Samba.git] / source / lib / util_tdb.c
blob5f9a5115b6bfc61070ad3aa35ff6aa399f419f59
1 /*
2 Unix SMB/CIFS implementation.
3 tdb utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Rafal Szczesniak 2002
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23 #undef malloc
24 #undef realloc
25 #undef calloc
26 #undef strdup
27
28 /* these are little tdb utility functions that are meant to make
29 dealing with a tdb database a little less cumbersome in Samba */
30
31 static SIG_ATOMIC_T gotalarm;
32
33 /***************************************************************
34 Signal function to tell us we timed out.
35 ****************************************************************/
36
37 static void gotalarm_sig(void)
38 {
39 gotalarm = 1;
40 }
41
42 /***************************************************************
43 Make a TDB_DATA and keep the const warning in one place
44 ****************************************************************/
45
46 TDB_DATA make_tdb_data(const uint8 *dptr, size_t dsize)
47 {
48 TDB_DATA ret;
49 ret.dptr = CONST_DISCARD(uint8 *, dptr);
50 ret.dsize = dsize;
51 return ret;
52 }
53
54 TDB_DATA string_tdb_data(const char *string)
55 {
56 return make_tdb_data((const uint8 *)string, string ? strlen(string) : 0 );
57 }
58
59 TDB_DATA string_term_tdb_data(const char *string)
60 {
61 return make_tdb_data((const uint8 *)string, string ? strlen(string) + 1 : 0);
62 }
63
64 /****************************************************************************
65 Lock a chain with timeout (in seconds).
66 ****************************************************************************/
67
68 static int tdb_chainlock_with_timeout_internal( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout, int rw_type)
69 {
70 /* Allow tdb_chainlock to be interrupted by an alarm. */
71 int ret;
72 gotalarm = 0;
73
74 if (timeout) {
75 CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
76 alarm(timeout);
77 }
78
79 if (rw_type == F_RDLCK)
80 ret = tdb_chainlock_read(tdb, key);
81 else
82 ret = tdb_chainlock(tdb, key);
83
84 if (timeout) {
85 alarm(0);
86 CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
87 if (gotalarm) {
88 DEBUG(0,("tdb_chainlock_with_timeout_internal: alarm (%u) timed out for key %s in tdb %s\n",
89 timeout, key.dptr, tdb_name(tdb)));
90 /* TODO: If we time out waiting for a lock, it might
91 * be nice to use F_GETLK to get the pid of the
92 * process currently holding the lock and print that
93 * as part of the debugging message. -- mbp */
94 return -1;
95 }
96 }
97
98 return ret;
99 }
100
101 /****************************************************************************
102 Write lock a chain. Return -1 if timeout or lock failed.
103 ****************************************************************************/
104
105 int tdb_chainlock_with_timeout( TDB_CONTEXT *tdb, TDB_DATA key, unsigned int timeout)
106 {
107 return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_WRLCK);
108 }
109
110 /****************************************************************************
111 Lock a chain by string. Return -1 if timeout or lock failed.
112 ****************************************************************************/
113
114 int tdb_lock_bystring(TDB_CONTEXT *tdb, const char *keyval)
115 {
116 TDB_DATA key = string_term_tdb_data(keyval);
117
118 return tdb_chainlock(tdb, key);
119 }
120
121 int tdb_lock_bystring_with_timeout(TDB_CONTEXT *tdb, const char *keyval,
122 int timeout)
123 {
124 TDB_DATA key = string_term_tdb_data(keyval);
125
126 return tdb_chainlock_with_timeout(tdb, key, timeout);
127 }
128
129 /****************************************************************************
130 Unlock a chain by string.
131 ****************************************************************************/
132
133 void tdb_unlock_bystring(TDB_CONTEXT *tdb, const char *keyval)
134 {
135 TDB_DATA key = string_term_tdb_data(keyval);
136
137 tdb_chainunlock(tdb, key);
138 }
139
140 /****************************************************************************
141 Read lock a chain by string. Return -1 if timeout or lock failed.
142 ****************************************************************************/
143
144 int tdb_read_lock_bystring_with_timeout(TDB_CONTEXT *tdb, const char *keyval, unsigned int timeout)
145 {
146 TDB_DATA key = string_term_tdb_data(keyval);
147
148 return tdb_chainlock_with_timeout_internal(tdb, key, timeout, F_RDLCK);
149 }
150
151 /****************************************************************************
152 Read unlock a chain by string.
153 ****************************************************************************/
154
155 void tdb_read_unlock_bystring(TDB_CONTEXT *tdb, const char *keyval)
156 {
157 TDB_DATA key = string_term_tdb_data(keyval);
158
159 tdb_chainunlock_read(tdb, key);
160 }
161
162
163 /****************************************************************************
164 Fetch a int32 value by a arbitrary blob key, return -1 if not found.
165 Output is int32 in native byte order.
166 ****************************************************************************/
167
168 int32 tdb_fetch_int32_byblob(TDB_CONTEXT *tdb, TDB_DATA key)
169 {
170 TDB_DATA data;
171 int32 ret;
172
173 data = tdb_fetch(tdb, key);
174 if (!data.dptr || data.dsize != sizeof(int32)) {
175 SAFE_FREE(data.dptr);
176 return -1;
177 }
178
179 ret = IVAL(data.dptr,0);
180 SAFE_FREE(data.dptr);
181 return ret;
182 }
183
184 /****************************************************************************
185 Fetch a int32 value by string key, return -1 if not found.
186 Output is int32 in native byte order.
187 ****************************************************************************/
188
189 int32 tdb_fetch_int32(TDB_CONTEXT *tdb, const char *keystr)
190 {
191 TDB_DATA key = string_term_tdb_data(keystr);
192
193 return tdb_fetch_int32_byblob(tdb, key);
194 }
195
196 /****************************************************************************
197 Store a int32 value by an arbitary blob key, return 0 on success, -1 on failure.
198 Input is int32 in native byte order. Output in tdb is in little-endian.
199 ****************************************************************************/
200
201 int tdb_store_int32_byblob(TDB_CONTEXT *tdb, TDB_DATA key, int32 v)
202 {
203 TDB_DATA data;
204 int32 v_store;
205
206 SIVAL(&v_store,0,v);
207 data.dptr = (uint8 *)&v_store;
208 data.dsize = sizeof(int32);
209
210 return tdb_store(tdb, key, data, TDB_REPLACE);
211 }
212
213 /****************************************************************************
214 Store a int32 value by string key, return 0 on success, -1 on failure.
215 Input is int32 in native byte order. Output in tdb is in little-endian.
216 ****************************************************************************/
217
218 int tdb_store_int32(TDB_CONTEXT *tdb, const char *keystr, int32 v)
219 {
220 TDB_DATA key = string_term_tdb_data(keystr);
221
222 return tdb_store_int32_byblob(tdb, key, v);
223 }
224
225 /****************************************************************************
226 Fetch a uint32 value by a arbitrary blob key, return -1 if not found.
227 Output is uint32 in native byte order.
228 ****************************************************************************/
229
230 BOOL tdb_fetch_uint32_byblob(TDB_CONTEXT *tdb, TDB_DATA key, uint32 *value)
231 {
232 TDB_DATA data;
233
234 data = tdb_fetch(tdb, key);
235 if (!data.dptr || data.dsize != sizeof(uint32)) {
236 SAFE_FREE(data.dptr);
237 return False;
238 }
239
240 *value = IVAL(data.dptr,0);
241 SAFE_FREE(data.dptr);
242 return True;
243 }
244
245 /****************************************************************************
246 Fetch a uint32 value by string key, return -1 if not found.
247 Output is uint32 in native byte order.
248 ****************************************************************************/
249
250 BOOL tdb_fetch_uint32(TDB_CONTEXT *tdb, const char *keystr, uint32 *value)
251 {
252 TDB_DATA key = string_term_tdb_data(keystr);
253
254 return tdb_fetch_uint32_byblob(tdb, key, value);
255 }
256
257 /****************************************************************************
258 Store a uint32 value by an arbitary blob key, return 0 on success, -1 on failure.
259 Input is uint32 in native byte order. Output in tdb is in little-endian.
260 ****************************************************************************/
261
262 BOOL tdb_store_uint32_byblob(TDB_CONTEXT *tdb, TDB_DATA key, uint32 value)
263 {
264 TDB_DATA data;
265 uint32 v_store;
266 BOOL ret = True;
267
268 SIVAL(&v_store, 0, value);
269 data.dptr = (uint8 *)&v_store;
270 data.dsize = sizeof(uint32);
271
272 if (tdb_store(tdb, key, data, TDB_REPLACE) == -1)
273 ret = False;
274
275 return ret;
276 }
277
278 /****************************************************************************
279 Store a uint32 value by string key, return 0 on success, -1 on failure.
280 Input is uint32 in native byte order. Output in tdb is in little-endian.
281 ****************************************************************************/
282
283 BOOL tdb_store_uint32(TDB_CONTEXT *tdb, const char *keystr, uint32 value)
284 {
285 TDB_DATA key = string_term_tdb_data(keystr);
286
287 return tdb_store_uint32_byblob(tdb, key, value);
288 }
289 /****************************************************************************
290 Store a buffer by a null terminated string key. Return 0 on success, -1
291 on failure.
292 ****************************************************************************/
293
294 int tdb_store_bystring(TDB_CONTEXT *tdb, const char *keystr, TDB_DATA data, int flags)
295 {
296 TDB_DATA key = string_term_tdb_data(keystr);
297
298 return tdb_store(tdb, key, data, flags);
299 }
300
301 int tdb_trans_store_bystring(TDB_CONTEXT *tdb, const char *keystr,
302 TDB_DATA data, int flags)
303 {
304 TDB_DATA key = string_term_tdb_data(keystr);
305
306 return tdb_trans_store(tdb, key, data, flags);
307 }
308
309 /****************************************************************************
310 Fetch a buffer using a null terminated string key. Don't forget to call
311 free() on the result dptr.
312 ****************************************************************************/
313
314 TDB_DATA tdb_fetch_bystring(TDB_CONTEXT *tdb, const char *keystr)
315 {
316 TDB_DATA key = string_term_tdb_data(keystr);
317
318 return tdb_fetch(tdb, key);
319 }
320
321 /****************************************************************************
322 Delete an entry using a null terminated string key.
323 ****************************************************************************/
324
325 int tdb_delete_bystring(TDB_CONTEXT *tdb, const char *keystr)
326 {
327 TDB_DATA key = string_term_tdb_data(keystr);
328
329 return tdb_delete(tdb, key);
330 }
331
332 /****************************************************************************
333 Atomic integer change. Returns old value. To create, set initial value in *oldval.
334 ****************************************************************************/
335
336 int32 tdb_change_int32_atomic(TDB_CONTEXT *tdb, const char *keystr, int32 *oldval, int32 change_val)
337 {
338 int32 val;
339 int32 ret = -1;
340
341 if (tdb_lock_bystring(tdb, keystr) == -1)
342 return -1;
343
344 if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {
345 /* The lookup failed */
346 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
347 /* but not because it didn't exist */
348 goto err_out;
349 }
350
351 /* Start with 'old' value */
352 val = *oldval;
353
354 } else {
355 /* It worked, set return value (oldval) to tdb data */
356 *oldval = val;
357 }
358
359 /* Increment value for storage and return next time */
360 val += change_val;
361
362 if (tdb_store_int32(tdb, keystr, val) == -1)
363 goto err_out;
364
365 ret = 0;
366
367 err_out:
368
369 tdb_unlock_bystring(tdb, keystr);
370 return ret;
371 }
372
373 /****************************************************************************
374 Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval.
375 ****************************************************************************/
376
377 BOOL tdb_change_uint32_atomic(TDB_CONTEXT *tdb, const char *keystr, uint32 *oldval, uint32 change_val)
378 {
379 uint32 val;
380 BOOL ret = False;
381
382 if (tdb_lock_bystring(tdb, keystr) == -1)
383 return False;
384
385 if (!tdb_fetch_uint32(tdb, keystr, &val)) {
386 /* It failed */
387 if (tdb_error(tdb) != TDB_ERR_NOEXIST) {
388 /* and not because it didn't exist */
389 goto err_out;
390 }
391
392 /* Start with 'old' value */
393 val = *oldval;
394
395 } else {
396 /* it worked, set return value (oldval) to tdb data */
397 *oldval = val;
398
399 }
400
401 /* get a new value to store */
402 val += change_val;
403
404 if (!tdb_store_uint32(tdb, keystr, val))
405 goto err_out;
406
407 ret = True;
408
409 err_out:
410
411 tdb_unlock_bystring(tdb, keystr);
412 return ret;
413 }
414
415 /****************************************************************************
416 Useful pair of routines for packing/unpacking data consisting of
417 integers and strings.
418 ****************************************************************************/
419
420 size_t tdb_pack_va(uint8 *buf, int bufsize, const char *fmt, va_list ap)
421 {
422 uint8 bt;
423 uint16 w;
424 uint32 d;
425 int i;
426 void *p;
427 int len;
428 char *s;
429 char c;
430 uint8 *buf0 = buf;
431 const char *fmt0 = fmt;
432 int bufsize0 = bufsize;
433
434 while (*fmt) {
435 switch ((c = *fmt++)) {
436 case 'b': /* unsigned 8-bit integer */
437 len = 1;
438 bt = (uint8)va_arg(ap, int);
439 if (bufsize && bufsize >= len)
440 SSVAL(buf, 0, bt);
441 break;
442 case 'w': /* unsigned 16-bit integer */
443 len = 2;
444 w = (uint16)va_arg(ap, int);
445 if (bufsize && bufsize >= len)
446 SSVAL(buf, 0, w);
447 break;
448 case 'd': /* signed 32-bit integer (standard int in most systems) */
449 len = 4;
450 d = va_arg(ap, uint32);
451 if (bufsize && bufsize >= len)
452 SIVAL(buf, 0, d);
453 break;
454 case 'p': /* pointer */
455 len = 4;
456 p = va_arg(ap, void *);
457 d = p?1:0;
458 if (bufsize && bufsize >= len)
459 SIVAL(buf, 0, d);
460 break;
461 case 'P': /* null-terminated string */
462 s = va_arg(ap,char *);
463 w = strlen(s);
464 len = w + 1;
465 if (bufsize && bufsize >= len)
466 memcpy(buf, s, len);
467 break;
468 case 'f': /* null-terminated string */
469 s = va_arg(ap,char *);
470 w = strlen(s);
471 len = w + 1;
472 if (bufsize && bufsize >= len)
473 memcpy(buf, s, len);
474 break;
475 case 'B': /* fixed-length string */
476 i = va_arg(ap, int);
477 s = va_arg(ap, char *);
478 len = 4+i;
479 if (bufsize && bufsize >= len) {
480 SIVAL(buf, 0, i);
481 memcpy(buf+4, s, i);
482 }
483 break;
484 default:
485 DEBUG(0,("Unknown tdb_pack format %c in %s\n",
486 c, fmt));
487 len = 0;
488 break;
489 }
490
491 buf += len;
492 if (bufsize)
493 bufsize -= len;
494 if (bufsize < 0)
495 bufsize = 0;
496 }
497
498 DEBUG(18,("tdb_pack_va(%s, %d) -> %d\n",
499 fmt0, bufsize0, (int)PTR_DIFF(buf, buf0)));
500
501 return PTR_DIFF(buf, buf0);
502 }
503
504 size_t tdb_pack(uint8 *buf, int bufsize, const char *fmt, ...)
505 {
506 va_list ap;
507 size_t result;
508
509 va_start(ap, fmt);
510 result = tdb_pack_va(buf, bufsize, fmt, ap);
511 va_end(ap);
512 return result;
513 }
514
515 BOOL tdb_pack_append(TALLOC_CTX *mem_ctx, uint8 **buf, size_t *len,
516 const char *fmt, ...)
517 {
518 va_list ap;
519 size_t len1, len2;
520
521 va_start(ap, fmt);
522 len1 = tdb_pack_va(NULL, 0, fmt, ap);
523 va_end(ap);
524
525 if (mem_ctx != NULL) {
526 *buf = TALLOC_REALLOC_ARRAY(mem_ctx, *buf, uint8,
527 (*len) + len1);
528 } else {
529 *buf = SMB_REALLOC_ARRAY(*buf, uint8, (*len) + len1);
530 }
531
532 if (*buf == NULL) {
533 return False;
534 }
535
536 va_start(ap, fmt);
537 len2 = tdb_pack_va((*buf)+(*len), len1, fmt, ap);
538 va_end(ap);
539
540 if (len1 != len2) {
541 return False;
542 }
543
544 *len += len2;
545
546 return True;
547 }
548
549 /****************************************************************************
550 Useful pair of routines for packing/unpacking data consisting of
551 integers and strings.
552 ****************************************************************************/
553
554 int tdb_unpack(const uint8 *buf, int bufsize, const char *fmt, ...)
555 {
556 va_list ap;
557 uint8 *bt;
558 uint16 *w;
559 uint32 *d;
560 int len;
561 int *i;
562 void **p;
563 char *s, **b;
564 char c;
565 const uint8 *buf0 = buf;
566 const char *fmt0 = fmt;
567 int bufsize0 = bufsize;
568
569 va_start(ap, fmt);
570
571 while (*fmt) {
572 switch ((c=*fmt++)) {
573 case 'b':
574 len = 1;
575 bt = va_arg(ap, uint8 *);
576 if (bufsize < len)
577 goto no_space;
578 *bt = SVAL(buf, 0);
579 break;
580 case 'w':
581 len = 2;
582 w = va_arg(ap, uint16 *);
583 if (bufsize < len)
584 goto no_space;
585 *w = SVAL(buf, 0);
586 break;
587 case 'd':
588 len = 4;
589 d = va_arg(ap, uint32 *);
590 if (bufsize < len)
591 goto no_space;
592 *d = IVAL(buf, 0);
593 break;
594 case 'p':
595 len = 4;
596 p = va_arg(ap, void **);
597 if (bufsize < len)
598 goto no_space;
599 /*
600 * This isn't a real pointer - only a token (1 or 0)
601 * to mark the fact a pointer is present.
602 */
603
604 *p = (void *)(IVAL(buf, 0) ? (void *)1 : NULL);
605 break;
606 case 'P':
607 s = va_arg(ap,char *);
608 len = strlen((const char *)buf) + 1;
609 if (bufsize < len || len > sizeof(pstring))
610 goto no_space;
611 memcpy(s, buf, len);
612 break;
613 case 'f':
614 s = va_arg(ap,char *);
615 len = strlen((const char *)buf) + 1;
616 if (bufsize < len || len > sizeof(fstring))
617 goto no_space;
618 memcpy(s, buf, len);
619 break;
620 case 'B':
621 i = va_arg(ap, int *);
622 b = va_arg(ap, char **);
623 len = 4;
624 if (bufsize < len)
625 goto no_space;
626 *i = IVAL(buf, 0);
627 if (! *i) {
628 *b = NULL;
629 break;
630 }
631 len += *i;
632 if (bufsize < len)
633 goto no_space;
634 *b = (char *)SMB_MALLOC(*i);
635 if (! *b)
636 goto no_space;
637 memcpy(*b, buf+4, *i);
638 break;
639 default:
640 DEBUG(0,("Unknown tdb_unpack format %c in %s\n",
641 c, fmt));
642
643 len = 0;
644 break;
645 }
646
647 buf += len;
648 bufsize -= len;
649 }
650
651 va_end(ap);
652
653 DEBUG(18,("tdb_unpack(%s, %d) -> %d\n",
654 fmt0, bufsize0, (int)PTR_DIFF(buf, buf0)));
655
656 return PTR_DIFF(buf, buf0);
657
658 no_space:
659 return -1;
660 }
661
662
663 /****************************************************************************
664 Log tdb messages via DEBUG().
665 ****************************************************************************/
666
667 static void tdb_log(TDB_CONTEXT *tdb, enum tdb_debug_level level, const char *format, ...)
668 {
669 va_list ap;
670 char *ptr = NULL;
671
672 va_start(ap, format);
673 vasprintf(&ptr, format, ap);
674 va_end(ap);
675
676 if (!ptr || !*ptr)
677 return;
678
679 DEBUG((int)level, ("tdb(%s): %s", tdb_name(tdb) ? tdb_name(tdb) : "unnamed", ptr));
680 SAFE_FREE(ptr);
681 }
682
683 /****************************************************************************
684 Like tdb_open() but also setup a logging function that redirects to
685 the samba DEBUG() system.
686 ****************************************************************************/
687
688 TDB_CONTEXT *tdb_open_log(const char *name, int hash_size, int tdb_flags,
689 int open_flags, mode_t mode)
690 {
691 TDB_CONTEXT *tdb;
692 struct tdb_logging_context log_ctx;
693
694 if (!lp_use_mmap())
695 tdb_flags |= TDB_NOMMAP;
696
697 log_ctx.log_fn = tdb_log;
698 log_ctx.log_private = NULL;
699
700 tdb = tdb_open_ex(name, hash_size, tdb_flags,
701 open_flags, mode, &log_ctx, NULL);
702 if (!tdb)
703 return NULL;
704
705 return tdb;
706 }
707
708 /****************************************************************************
709 Allow tdb_delete to be used as a tdb_traversal_fn.
710 ****************************************************************************/
711
712 int tdb_traverse_delete_fn(TDB_CONTEXT *the_tdb, TDB_DATA key, TDB_DATA dbuf,
713 void *state)
714 {
715 return tdb_delete(the_tdb, key);
716 }
717
718
719
720 /**
721 * Search across the whole tdb for keys that match the given pattern
722 * return the result as a list of keys
723 *
724 * @param tdb pointer to opened tdb file context
725 * @param pattern searching pattern used by fnmatch(3) functions
726 *
727 * @return list of keys found by looking up with given pattern
728 **/
729 TDB_LIST_NODE *tdb_search_keys(TDB_CONTEXT *tdb, const char* pattern)
730 {
731 TDB_DATA key, next;
732 TDB_LIST_NODE *list = NULL;
733 TDB_LIST_NODE *rec = NULL;
734
735 for (key = tdb_firstkey(tdb); key.dptr; key = next) {
736 /* duplicate key string to ensure null-termination */
737 char *key_str = SMB_STRNDUP((const char *)key.dptr, key.dsize);
738 if (!key_str) {
739 DEBUG(0, ("tdb_search_keys: strndup() failed!\n"));
740 smb_panic("strndup failed!\n");
741 }
742
743 DEBUG(18, ("checking %s for match to pattern %s\n", key_str, pattern));
744
745 next = tdb_nextkey(tdb, key);
746
747 /* do the pattern checking */
748 if (fnmatch(pattern, key_str, 0) == 0) {
749 rec = SMB_MALLOC_P(TDB_LIST_NODE);
750 ZERO_STRUCTP(rec);
751
752 rec->node_key = key;
753
754 DLIST_ADD_END(list, rec, TDB_LIST_NODE *);
755
756 DEBUG(18, ("checking %s matched pattern %s\n", key_str, pattern));
757 } else {
758 free(key.dptr);
759 }
760
761 /* free duplicated key string */
762 free(key_str);
763 }
764
765 return list;
766
767 }
768
769
770 /**
771 * Free the list returned by tdb_search_keys
772 *
773 * @param node list of results found by tdb_search_keys
774 **/
775 void tdb_search_list_free(TDB_LIST_NODE* node)
776 {
777 TDB_LIST_NODE *next_node;
778
779 while (node) {
780 next_node = node->next;
781 SAFE_FREE(node->node_key.dptr);
782 SAFE_FREE(node);
783 node = next_node;
784 };
785 }
786
787 /****************************************************************************
788 tdb_store, wrapped in a transaction. This way we make sure that a process
789 that dies within writing does not leave a corrupt tdb behind.
790 ****************************************************************************/
791
792 int tdb_trans_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
793 int flag)
794 {
795 int res;
796
797 if ((res = tdb_transaction_start(tdb)) != 0) {
798 DEBUG(5, ("tdb_transaction_start failed\n"));
799 return res;
800 }
801
802 if ((res = tdb_store(tdb, key, dbuf, flag)) != 0) {
803 DEBUG(10, ("tdb_store failed\n"));
804 if (tdb_transaction_cancel(tdb) != 0) {
805 smb_panic("Cancelling transaction failed");
806 }
807 return res;
808 }
809
810 if ((res = tdb_transaction_commit(tdb)) != 0) {
811 DEBUG(5, ("tdb_transaction_commit failed\n"));
812 }
813
814 return res;
815 }
816
817 /****************************************************************************
818 tdb_delete, wrapped in a transaction. This way we make sure that a process
819 that dies within deleting does not leave a corrupt tdb behind.
820 ****************************************************************************/
821
822 int tdb_trans_delete(struct tdb_context *tdb, TDB_DATA key)
823 {
824 int res;
825
826 if ((res = tdb_transaction_start(tdb)) != 0) {
827 DEBUG(5, ("tdb_transaction_start failed\n"));
828 return res;
829 }
830
831 if ((res = tdb_delete(tdb, key)) != 0) {
832 DEBUG(10, ("tdb_delete failed\n"));
833 if (tdb_transaction_cancel(tdb) != 0) {
834 smb_panic("Cancelling transaction failed");
835 }
836 return res;
837 }
838
839 if ((res = tdb_transaction_commit(tdb)) != 0) {
840 DEBUG(5, ("tdb_transaction_commit failed\n"));
841 }
842
843 return res;
844 }
845
846 /*
847 Log tdb messages via DEBUG().
848 */
849 static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level,
850 const char *format, ...) PRINTF_ATTRIBUTE(3,4);
851
852 static void tdb_wrap_log(TDB_CONTEXT *tdb, enum tdb_debug_level level,
853 const char *format, ...)
854 {
855 va_list ap;
856 char *ptr = NULL;
857 int debuglevel = 0;
858
859 va_start(ap, format);
860 vasprintf(&ptr, format, ap);
861 va_end(ap);
862
863 switch (level) {
864 case TDB_DEBUG_FATAL:
865 debug_level = 0;
866 break;
867 case TDB_DEBUG_ERROR:
868 debuglevel = 1;
869 break;
870 case TDB_DEBUG_WARNING:
871 debuglevel = 2;
872 break;
873 case TDB_DEBUG_TRACE:
874 debuglevel = 5;
875 break;
876 default:
877 debuglevel = 0;
878 }
879
880 if (ptr != NULL) {
881 const char *name = tdb_name(tdb);
882 DEBUG(debuglevel, ("tdb(%s): %s", name ? name : "unnamed", ptr));
883 free(ptr);
884 }
885 }
886
887 static struct tdb_wrap *tdb_list;
888
889 /* destroy the last connection to a tdb */
890 static int tdb_wrap_destructor(struct tdb_wrap *w)
891 {
892 tdb_close(w->tdb);
893 DLIST_REMOVE(tdb_list, w);
894 return 0;
895 }
896
897 /*
898 wrapped connection to a tdb database
899 to close just talloc_free() the tdb_wrap pointer
900 */
901 struct tdb_wrap *tdb_wrap_open(TALLOC_CTX *mem_ctx,
902 const char *name, int hash_size, int tdb_flags,
903 int open_flags, mode_t mode)
904 {
905 struct tdb_wrap *w;
906 struct tdb_logging_context log_ctx;
907 log_ctx.log_fn = tdb_wrap_log;
908
909 if (!lp_use_mmap())
910 tdb_flags |= TDB_NOMMAP;
911
912 for (w=tdb_list;w;w=w->next) {
913 if (strcmp(name, w->name) == 0) {
914 /*
915 * Yes, talloc_reference is exactly what we want
916 * here. Otherwise we would have to implement our own
917 * reference counting.
918 */
919 return talloc_reference(mem_ctx, w);
920 }
921 }
922
923 w = talloc(mem_ctx, struct tdb_wrap);
924 if (w == NULL) {
925 return NULL;
926 }
927
928 if (!(w->name = talloc_strdup(w, name))) {
929 talloc_free(w);
930 return NULL;
931 }
932
933 w->tdb = tdb_open_ex(name, hash_size, tdb_flags,
934 open_flags, mode, &log_ctx, NULL);
935 if (w->tdb == NULL) {
936 talloc_free(w);
937 return NULL;
938 }
939
940 talloc_set_destructor(w, tdb_wrap_destructor);
941
942 DLIST_ADD(tdb_list, w);
943
944 return w;
945 }
946
947 NTSTATUS map_nt_error_from_tdb(enum TDB_ERROR err)
948 {
949 struct { enum TDB_ERROR err; NTSTATUS status; } map[] =
950 { { TDB_SUCCESS, NT_STATUS_OK },
951 { TDB_ERR_CORRUPT, NT_STATUS_INTERNAL_DB_CORRUPTION },
952 { TDB_ERR_IO, NT_STATUS_UNEXPECTED_IO_ERROR },
953 { TDB_ERR_OOM, NT_STATUS_NO_MEMORY },
954 { TDB_ERR_EXISTS, NT_STATUS_OBJECT_NAME_COLLISION },
955
956 /*
957 * TDB_ERR_LOCK is very broad, we could for example
958 * distinguish between fcntl locks and invalid lock
959 * sequences. So NT_STATUS_FILE_LOCK_CONFLICT is a
960 * compromise.
961 */
962 { TDB_ERR_LOCK, NT_STATUS_FILE_LOCK_CONFLICT },
963 /*
964 * The next two ones in the enum are not actually used
965 */
966 { TDB_ERR_NOLOCK, NT_STATUS_FILE_LOCK_CONFLICT },
967 { TDB_ERR_LOCK_TIMEOUT, NT_STATUS_FILE_LOCK_CONFLICT },
968 { TDB_ERR_NOEXIST, NT_STATUS_NOT_FOUND },
969 { TDB_ERR_EINVAL, NT_STATUS_INVALID_PARAMETER },
970 { TDB_ERR_RDONLY, NT_STATUS_ACCESS_DENIED }
971 };
972
973 int i;
974
975 for (i=0; i < sizeof(map) / sizeof(map[0]); i++) {
976 if (err == map[i].err) {
977 return map[i].status;
978 }
979 }
980
981 return NT_STATUS_INTERNAL_ERROR;
982 }
983
984
985 /*********************************************************************
986 * the following is a generic validation mechanism for tdbs.
987 *********************************************************************/
988
989 /*
990 * internal validation function, executed by the child.
991 */
992 static int tdb_validate_child(const char *tdb_path,
993 tdb_validate_data_func validate_fn,
994 int pfd)
995 {
996 int ret = -1;
997 int num_entries = 0;
998 TDB_CONTEXT *tdb = NULL;
999 struct tdb_validation_status v_status;
1000
1001 v_status.tdb_error = False;
1002 v_status.bad_freelist = False;
1003 v_status.bad_entry = False;
1004 v_status.unknown_key = False;
1005 v_status.success = True;
1006
1007 tdb = tdb_open_log(tdb_path, 0, TDB_DEFAULT, O_RDONLY, 0);
1008 if (!tdb) {
1009 v_status.tdb_error = True;
1010 v_status.success = False;
1011 goto out;
1012 }
1013
1014 /* Check the cache freelist is good. */
1015 if (tdb_validate_freelist(tdb, &num_entries) == -1) {
1016 DEBUG(0,("tdb_validate_child: bad freelist in cache %s\n",
1017 tdb_path));
1018 v_status.bad_freelist = True;
1019 v_status.success = False;
1020 goto out;
1021 }
1022
1023 DEBUG(10,("tdb_validate_child: cache %s freelist has %d entries\n",
1024 tdb_path, num_entries));
1025
1026 /* Now traverse the cache to validate it. */
1027 num_entries = tdb_traverse(tdb, validate_fn, (void *)&v_status);
1028 if (num_entries == -1 || !(v_status.success)) {
1029 DEBUG(0,("tdb_validate_child: cache %s traverse failed\n",
1030 tdb_path));
1031 if (!(v_status.success)) {
1032 if (v_status.bad_entry) {
1033 DEBUGADD(0, (" -> bad entry found\n"));
1034 }
1035 if (v_status.unknown_key) {
1036 DEBUGADD(0, (" -> unknown key encountered\n"));
1037 }
1038 }
1039 goto out;
1040 }
1041
1042 DEBUG(10,("tdb_validate_child: cache %s is good "
1043 "with %d entries\n", tdb_path, num_entries));
1044 ret = 0; /* Cache is good. */
1045
1046 out:
1047 if (tdb) {
1048 tdb_close(tdb);
1049 }
1050
1051 DEBUG(10, ("tdb_validate_child: writing status to pipe\n"));
1052 write (pfd, (const char *)&v_status, sizeof(v_status));
1053 close(pfd);
1054
1055 return ret;
1056 }
1057
1058 int tdb_validate(const char *tdb_path, tdb_validate_data_func validate_fn)
1059 {
1060 pid_t child_pid = -1;
1061 int child_status = 0;
1062 int wait_pid = 0;
1063 int ret = -1;
1064 int pipe_fds[2];
1065 struct tdb_validation_status v_status;
1066 int bytes_read = 0;
1067
1068 /* fork and let the child do the validation.
1069 * benefit: no need to twist signal handlers and panic functions.
1070 * just let the child panic. we catch the signal.
1071 * communicate the extended status struct over a pipe. */
1072
1073 if (pipe(pipe_fds) != 0) {
1074 DEBUG(0, ("tdb_validate: unable to create pipe, "
1075 "error %s", strerror(errno)));
1076 smb_panic("winbind_validate_cache: unable to create pipe.");
1077 }
1078
1079 DEBUG(10, ("tdb_validate: forking to let child do validation.\n"));
1080 child_pid = sys_fork();
1081 if (child_pid == 0) {
1082 DEBUG(10, ("tdb_validate (validation child): created\n"));
1083 close(pipe_fds[0]); /* close reading fd */
1084 DEBUG(10, ("tdb_validate (validation child): "
1085 "calling tdb_validate_child\n"));
1086 exit(tdb_validate_child(tdb_path, validate_fn, pipe_fds[1]));
1087 }
1088 else if (child_pid < 0) {
1089 smb_panic("tdb_validate: fork for validation failed.");
1090 }
1091
1092 /* parent */
1093
1094 DEBUG(10, ("tdb_validate: fork succeeded, child PID = %d\n",
1095 child_pid));
1096 close(pipe_fds[1]); /* close writing fd */
1097
1098 v_status.success = True;
1099 v_status.bad_entry = False;
1100 v_status.unknown_key = False;
1101
1102 DEBUG(10, ("tdb_validate: reading from pipe.\n"));
1103 bytes_read = read(pipe_fds[0], (void *)&v_status, sizeof(v_status));
1104 close(pipe_fds[0]);
1105
1106 if (bytes_read != sizeof(v_status)) {
1107 DEBUG(10, ("tdb_validate: read %d bytes from pipe "
1108 "but expected %d", bytes_read, (int)sizeof(v_status)));
1109 DEBUGADD(10, (" -> assuming child crashed\n"));
1110 v_status.success = False;
1111 }
1112 else {
1113 DEBUG(10, ("tdb_validate: read status from child\n"));
1114 DEBUGADD(10, (" * tdb error: %s\n", v_status.tdb_error ? "yes" : "no"));
1115 DEBUGADD(10, (" * bad freelist: %s\n", v_status.bad_freelist ? "yes" : "no"));
1116 DEBUGADD(10, (" * bad entry: %s\n", v_status.bad_entry ? "yes" : "no"));
1117 DEBUGADD(10, (" * unknown key: %s\n", v_status.unknown_key ? "yes" : "no"));
1118 DEBUGADD(10, (" => overall success: %s\n", v_status.success ? "yes" : "no"));
1119 }
1120
1121 if (!v_status.success) {
1122 DEBUG(10, ("tdb_validate: validation not successful.\n"));
1123 DEBUGADD(10, ("removing tdb %s.\n", tdb_path));
1124 unlink(tdb_path);
1125 }
1126
1127 DEBUG(10, ("tdb_validate: waiting for child to finish...\n"));
1128 while ((wait_pid = sys_waitpid(child_pid, &child_status, 0)) < 0) {
1129 if (errno == EINTR) {
1130 DEBUG(10, ("tdb_validate: got signal during "
1131 "waitpid, retrying\n"));
1132 errno = 0;
1133 continue;
1134 }
1135 DEBUG(0, ("tdb_validate: waitpid failed with "
1136 "errno %s\n", strerror(errno)));
1137 smb_panic("tdb_validate: waitpid failed.");
1138 }
1139 if (wait_pid != child_pid) {
1140 DEBUG(0, ("tdb_validate: waitpid returned pid %d, "
1141 "but %d was expexted\n", wait_pid, child_pid));
1142 smb_panic("tdb_validate: waitpid returned "
1143 "unexpected PID.");
1144 }
1145
1146 DEBUG(10, ("tdb_validate: validating child returned.\n"));
1147 if (WIFEXITED(child_status)) {
1148 DEBUG(10, ("tdb_validate: child exited, code %d.\n",
1149 WEXITSTATUS(child_status)));
1150 ret = WEXITSTATUS(child_status);
1151 }
1152 if (WIFSIGNALED(child_status)) {
1153 DEBUG(10, ("tdb_validate: child terminated "
1154 "by signal %d\n", WTERMSIG(child_status)));
1155 #ifdef WCOREDUMP
1156 if (WCOREDUMP(child_status)) {
1157 DEBUGADD(10, ("core dumped\n"));
1158 }
1159 #endif
1160 ret = WTERMSIG(child_status);
1161 }
1162 if (WIFSTOPPED(child_status)) {
1163 DEBUG(10, ("tdb_validate: child was stopped "
1164 "by signal %d\n",
1165 WSTOPSIG(child_status)));
1166 ret = WSTOPSIG(child_status);
1167 }
1168
1169 return ret;
1170 }
Samba GIT mirror