2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
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 2 of the License, or
9 (at your option) any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 /* these are little tdb utility functions that are meant to make
25 dealing with a tdb database a little less cumbersome in Samba */
27 static SIG_ATOMIC_T gotalarm
;
29 /***************************************************************
30 Signal function to tell us we timed out.
31 ****************************************************************/
33 static void gotalarm_sig(void)
38 /***************************************************************
39 Make a TDB_DATA and keep the const warning in one place
40 ****************************************************************/
42 static TDB_DATA
make_tdb_data(const char *dptr
, size_t dsize
)
50 /****************************************************************************
51 Lock a chain with timeout (in seconds).
52 ****************************************************************************/
54 static int tdb_chainlock_with_timeout_internal( TDB_CONTEXT
*tdb
, TDB_DATA key
, unsigned int timeout
, int rw_type
)
56 /* Allow tdb_chainlock to be interrupted by an alarm. */
59 tdb_set_lock_alarm(&gotalarm
);
62 CatchSignal(SIGALRM
, SIGNAL_CAST gotalarm_sig
);
66 if (rw_type
== F_RDLCK
)
67 ret
= tdb_chainlock_read(tdb
, key
);
69 ret
= tdb_chainlock(tdb
, key
);
73 CatchSignal(SIGALRM
, SIGNAL_CAST SIG_IGN
);
75 DEBUG(0,("tdb_chainlock_with_timeout_internal: alarm (%u) timed out for key %s in tdb %s\n",
76 timeout
, key
.dptr
, tdb
->name
));
77 /* TODO: If we time out waiting for a lock, it might
78 * be nice to use F_GETLK to get the pid of the
79 * process currently holding the lock and print that
80 * as part of the debugging message. -- mbp */
88 /****************************************************************************
89 Write lock a chain. Return -1 if timeout or lock failed.
90 ****************************************************************************/
92 int tdb_chainlock_with_timeout( TDB_CONTEXT
*tdb
, TDB_DATA key
, unsigned int timeout
)
94 return tdb_chainlock_with_timeout_internal(tdb
, key
, timeout
, F_WRLCK
);
97 /****************************************************************************
98 Lock a chain by string. Return -1 if timeout or lock failed.
99 ****************************************************************************/
101 int tdb_lock_bystring(TDB_CONTEXT
*tdb
, const char *keyval
, unsigned int timeout
)
103 TDB_DATA key
= make_tdb_data(keyval
, strlen(keyval
)+1);
105 return tdb_chainlock_with_timeout_internal(tdb
, key
, timeout
, F_WRLCK
);
108 /****************************************************************************
109 Unlock a chain by string.
110 ****************************************************************************/
112 void tdb_unlock_bystring(TDB_CONTEXT
*tdb
, const char *keyval
)
114 TDB_DATA key
= make_tdb_data(keyval
, strlen(keyval
)+1);
116 tdb_chainunlock(tdb
, key
);
119 /****************************************************************************
120 Read lock a chain by string. Return -1 if timeout or lock failed.
121 ****************************************************************************/
123 int tdb_read_lock_bystring(TDB_CONTEXT
*tdb
, const char *keyval
, unsigned int timeout
)
125 TDB_DATA key
= make_tdb_data(keyval
, strlen(keyval
)+1);
127 return tdb_chainlock_with_timeout_internal(tdb
, key
, timeout
, F_RDLCK
);
130 /****************************************************************************
131 Read unlock a chain by string.
132 ****************************************************************************/
134 void tdb_read_unlock_bystring(TDB_CONTEXT
*tdb
, const char *keyval
)
136 TDB_DATA key
= make_tdb_data(keyval
, strlen(keyval
)+1);
138 tdb_chainunlock_read(tdb
, key
);
142 /****************************************************************************
143 Fetch a int32 value by a arbitrary blob key, return -1 if not found.
144 Output is int32 in native byte order.
145 ****************************************************************************/
147 int32
tdb_fetch_int32_byblob(TDB_CONTEXT
*tdb
, const char *keyval
, size_t len
)
149 TDB_DATA key
= make_tdb_data(keyval
, len
);
153 data
= tdb_fetch(tdb
, key
);
154 if (!data
.dptr
|| data
.dsize
!= sizeof(int32
)) {
155 SAFE_FREE(data
.dptr
);
159 ret
= IVAL(data
.dptr
,0);
160 SAFE_FREE(data
.dptr
);
164 /****************************************************************************
165 Fetch a int32 value by string key, return -1 if not found.
166 Output is int32 in native byte order.
167 ****************************************************************************/
169 int32
tdb_fetch_int32(TDB_CONTEXT
*tdb
, const char *keystr
)
171 return tdb_fetch_int32_byblob(tdb
, keystr
, strlen(keystr
) + 1);
174 /****************************************************************************
175 Store a int32 value by an arbitary blob key, return 0 on success, -1 on failure.
176 Input is int32 in native byte order. Output in tdb is in little-endian.
177 ****************************************************************************/
179 int tdb_store_int32_byblob(TDB_CONTEXT
*tdb
, const char *keystr
, size_t len
, int32 v
)
181 TDB_DATA key
= make_tdb_data(keystr
, len
);
186 data
.dptr
= (void *)&v_store
;
187 data
.dsize
= sizeof(int32
);
189 return tdb_store(tdb
, key
, data
, TDB_REPLACE
);
192 /****************************************************************************
193 Store a int32 value by string key, return 0 on success, -1 on failure.
194 Input is int32 in native byte order. Output in tdb is in little-endian.
195 ****************************************************************************/
197 int tdb_store_int32(TDB_CONTEXT
*tdb
, const char *keystr
, int32 v
)
199 return tdb_store_int32_byblob(tdb
, keystr
, strlen(keystr
) + 1, v
);
202 /****************************************************************************
203 Fetch a uint32 value by a arbitrary blob key, return -1 if not found.
204 Output is uint32 in native byte order.
205 ****************************************************************************/
207 BOOL
tdb_fetch_uint32_byblob(TDB_CONTEXT
*tdb
, const char *keyval
, size_t len
, uint32
*value
)
209 TDB_DATA key
= make_tdb_data(keyval
, len
);
212 data
= tdb_fetch(tdb
, key
);
213 if (!data
.dptr
|| data
.dsize
!= sizeof(uint32
)) {
214 SAFE_FREE(data
.dptr
);
218 *value
= IVAL(data
.dptr
,0);
219 SAFE_FREE(data
.dptr
);
223 /****************************************************************************
224 Fetch a uint32 value by string key, return -1 if not found.
225 Output is uint32 in native byte order.
226 ****************************************************************************/
228 BOOL
tdb_fetch_uint32(TDB_CONTEXT
*tdb
, const char *keystr
, uint32
*value
)
230 return tdb_fetch_uint32_byblob(tdb
, keystr
, strlen(keystr
) + 1, value
);
233 /****************************************************************************
234 Store a uint32 value by an arbitary blob key, return 0 on success, -1 on failure.
235 Input is uint32 in native byte order. Output in tdb is in little-endian.
236 ****************************************************************************/
238 BOOL
tdb_store_uint32_byblob(TDB_CONTEXT
*tdb
, const char *keystr
, size_t len
, uint32 value
)
240 TDB_DATA key
= make_tdb_data(keystr
, len
);
245 SIVAL(&v_store
, 0, value
);
246 data
.dptr
= (void *)&v_store
;
247 data
.dsize
= sizeof(uint32
);
249 if (tdb_store(tdb
, key
, data
, TDB_REPLACE
) == -1)
255 /****************************************************************************
256 Store a uint32 value by string key, return 0 on success, -1 on failure.
257 Input is uint32 in native byte order. Output in tdb is in little-endian.
258 ****************************************************************************/
260 BOOL
tdb_store_uint32(TDB_CONTEXT
*tdb
, const char *keystr
, uint32 value
)
262 return tdb_store_uint32_byblob(tdb
, keystr
, strlen(keystr
) + 1, value
);
264 /****************************************************************************
265 Store a buffer by a null terminated string key. Return 0 on success, -1
267 ****************************************************************************/
269 int tdb_store_bystring(TDB_CONTEXT
*tdb
, const char *keystr
, TDB_DATA data
, int flags
)
271 TDB_DATA key
= make_tdb_data(keystr
, strlen(keystr
)+1);
273 return tdb_store(tdb
, key
, data
, flags
);
276 /****************************************************************************
277 Fetch a buffer using a null terminated string key. Don't forget to call
278 free() on the result dptr.
279 ****************************************************************************/
281 TDB_DATA
tdb_fetch_bystring(TDB_CONTEXT
*tdb
, const char *keystr
)
283 TDB_DATA key
= make_tdb_data(keystr
, strlen(keystr
)+1);
285 return tdb_fetch(tdb
, key
);
288 /****************************************************************************
289 Delete an entry using a null terminated string key.
290 ****************************************************************************/
292 int tdb_delete_bystring(TDB_CONTEXT
*tdb
, const char *keystr
)
294 TDB_DATA key
= make_tdb_data(keystr
, strlen(keystr
)+1);
296 return tdb_delete(tdb
, key
);
299 /****************************************************************************
300 Atomic integer change. Returns old value. To create, set initial value in *oldval.
301 ****************************************************************************/
303 int32
tdb_change_int32_atomic(TDB_CONTEXT
*tdb
, const char *keystr
, int32
*oldval
, int32 change_val
)
308 if (tdb_lock_bystring(tdb
, keystr
,0) == -1)
311 if ((val
= tdb_fetch_int32(tdb
, keystr
)) == -1) {
312 /* The lookup failed */
313 if (tdb_error(tdb
) != TDB_ERR_NOEXIST
) {
314 /* but not because it didn't exist */
318 /* Start with 'old' value */
322 /* It worked, set return value (oldval) to tdb data */
326 /* Increment value for storage and return next time */
329 if (tdb_store_int32(tdb
, keystr
, val
) == -1)
336 tdb_unlock_bystring(tdb
, keystr
);
340 /****************************************************************************
341 Atomic unsigned integer change. Returns old value. To create, set initial value in *oldval.
342 ****************************************************************************/
344 BOOL
tdb_change_uint32_atomic(TDB_CONTEXT
*tdb
, const char *keystr
, uint32
*oldval
, uint32 change_val
)
349 if (tdb_lock_bystring(tdb
, keystr
,0) == -1)
352 if (!tdb_fetch_uint32(tdb
, keystr
, &val
)) {
354 if (tdb_error(tdb
) != TDB_ERR_NOEXIST
) {
355 /* and not because it didn't exist */
359 /* Start with 'old' value */
363 /* it worked, set return value (oldval) to tdb data */
368 /* get a new value to store */
371 if (!tdb_store_uint32(tdb
, keystr
, val
))
378 tdb_unlock_bystring(tdb
, keystr
);
382 /****************************************************************************
383 Useful pair of routines for packing/unpacking data consisting of
384 integers and strings.
385 ****************************************************************************/
387 size_t tdb_pack(char *buf
, int bufsize
, const char *fmt
, ...)
399 const char *fmt0
= fmt
;
400 int bufsize0
= bufsize
;
405 switch ((c
= *fmt
++)) {
406 case 'b': /* unsigned 8-bit integer */
408 bt
= (uint8
)va_arg(ap
, int);
409 if (bufsize
&& bufsize
>= len
)
412 case 'w': /* unsigned 16-bit integer */
414 w
= (uint16
)va_arg(ap
, int);
415 if (bufsize
&& bufsize
>= len
)
418 case 'd': /* signed 32-bit integer (standard int in most systems) */
420 d
= va_arg(ap
, uint32
);
421 if (bufsize
&& bufsize
>= len
)
424 case 'p': /* pointer */
426 p
= va_arg(ap
, void *);
428 if (bufsize
&& bufsize
>= len
)
431 case 'P': /* null-terminated string */
432 s
= va_arg(ap
,char *);
435 if (bufsize
&& bufsize
>= len
)
438 case 'f': /* null-terminated string */
439 s
= va_arg(ap
,char *);
442 if (bufsize
&& bufsize
>= len
)
445 case 'B': /* fixed-length string */
447 s
= va_arg(ap
, char *);
449 if (bufsize
&& bufsize
>= len
) {
455 DEBUG(0,("Unknown tdb_pack format %c in %s\n",
470 DEBUG(18,("tdb_pack(%s, %d) -> %d\n",
471 fmt0
, bufsize0
, (int)PTR_DIFF(buf
, buf0
)));
473 return PTR_DIFF(buf
, buf0
);
476 /****************************************************************************
477 Useful pair of routines for packing/unpacking data consisting of
478 integers and strings.
479 ****************************************************************************/
481 int tdb_unpack(char *buf
, int bufsize
, const char *fmt
, ...)
493 const char *fmt0
= fmt
;
494 int bufsize0
= bufsize
;
499 switch ((c
=*fmt
++)) {
502 bt
= va_arg(ap
, uint8
*);
509 w
= va_arg(ap
, uint16
*);
516 d
= va_arg(ap
, uint32
*);
523 p
= va_arg(ap
, void **);
526 *p
= (void *)IVAL(buf
, 0);
529 s
= va_arg(ap
,char *);
530 len
= strlen(buf
) + 1;
531 if (bufsize
< len
|| len
> sizeof(pstring
))
536 s
= va_arg(ap
,char *);
537 len
= strlen(buf
) + 1;
538 if (bufsize
< len
|| len
> sizeof(fstring
))
543 i
= va_arg(ap
, int *);
544 b
= va_arg(ap
, char **);
556 *b
= (char *)malloc(*i
);
559 memcpy(*b
, buf
+4, *i
);
562 DEBUG(0,("Unknown tdb_unpack format %c in %s\n",
575 DEBUG(18,("tdb_unpack(%s, %d) -> %d\n",
576 fmt0
, bufsize0
, (int)PTR_DIFF(buf
, buf0
)));
578 return PTR_DIFF(buf
, buf0
);
586 * Pack SID passed by pointer
588 * @param pack_buf pointer to buffer which is to be filled with packed data
589 * @param bufsize size of packing buffer
590 * @param sid pointer to sid to be packed
592 * @return length of the packed representation of the whole structure
594 size_t tdb_sid_pack(char* pack_buf
, int bufsize
, DOM_SID
* sid
)
599 if (!sid
|| !pack_buf
) return -1;
601 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "bb", sid
->sid_rev_num
,
604 for (idx
= 0; idx
< 6; idx
++) {
605 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "b", sid
->id_auth
[idx
]);
608 for (idx
= 0; idx
< MAXSUBAUTHS
; idx
++) {
609 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "d", sid
->sub_auths
[idx
]);
617 * Unpack SID into a pointer
619 * @param pack_buf pointer to buffer with packed representation
620 * @param bufsize size of the buffer
621 * @param sid pointer to sid structure to be filled with unpacked data
623 * @return size of structure unpacked from buffer
625 size_t tdb_sid_unpack(char* pack_buf
, int bufsize
, DOM_SID
* sid
)
629 if (!sid
|| !pack_buf
) return -1;
631 len
+= tdb_unpack(pack_buf
+ len
, bufsize
- len
, "bb",
632 &sid
->sid_rev_num
, &sid
->num_auths
);
634 for (idx
= 0; idx
< 6; idx
++) {
635 len
+= tdb_unpack(pack_buf
+ len
, bufsize
- len
, "b", &sid
->id_auth
[idx
]);
638 for (idx
= 0; idx
< MAXSUBAUTHS
; idx
++) {
639 len
+= tdb_unpack(pack_buf
+ len
, bufsize
- len
, "d", &sid
->sub_auths
[idx
]);
647 * Pack TRUSTED_DOM_PASS passed by pointer
649 * @param pack_buf pointer to buffer which is to be filled with packed data
650 * @param bufsize size of the buffer
651 * @param pass pointer to trusted domain password to be packed
653 * @return length of the packed representation of the whole structure
655 size_t tdb_trusted_dom_pass_pack(char* pack_buf
, int bufsize
, TRUSTED_DOM_PASS
* pass
)
659 if (!pack_buf
|| !pass
) return -1;
661 /* packing unicode domain name and password */
662 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "d", pass
->uni_name_len
);
664 for (idx
= 0; idx
< 32; idx
++)
665 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "w", pass
->uni_name
[idx
]);
667 len
+= tdb_pack(pack_buf
+ len
, bufsize
- len
, "dPd", pass
->pass_len
,
668 pass
->pass
, pass
->mod_time
);
670 /* packing SID structure */
671 len
+= tdb_sid_pack(pack_buf
+ len
, bufsize
- len
, &pass
->domain_sid
);
678 * Unpack TRUSTED_DOM_PASS passed by pointer
680 * @param pack_buf pointer to buffer with packed representation
681 * @param bufsize size of the buffer
682 * @param pass pointer to trusted domain password to be filled with unpacked data
684 * @return size of structure unpacked from buffer
686 size_t tdb_trusted_dom_pass_unpack(char* pack_buf
, int bufsize
, TRUSTED_DOM_PASS
* pass
)
690 if (!pack_buf
|| !pass
) return -1;
692 /* unpack unicode domain name and plaintext password */
693 len
+= tdb_unpack(pack_buf
, bufsize
- len
, "d", &pass
->uni_name_len
);
695 for (idx
= 0; idx
< 32; idx
++)
696 len
+= tdb_unpack(pack_buf
+ len
, bufsize
- len
, "w", &pass
->uni_name
[idx
]);
698 len
+= tdb_unpack(pack_buf
+ len
, bufsize
- len
, "dPd", &pass
->pass_len
, &pass
->pass
,
701 /* unpack domain sid */
702 len
+= tdb_sid_unpack(pack_buf
+ len
, bufsize
- len
, &pass
->domain_sid
);
708 /****************************************************************************
709 Log tdb messages via DEBUG().
710 ****************************************************************************/
712 static void tdb_log(TDB_CONTEXT
*tdb
, int level
, const char *format
, ...)
717 va_start(ap
, format
);
718 vasprintf(&ptr
, format
, ap
);
724 DEBUG(level
, ("tdb(%s): %s", tdb
->name
? tdb
->name
: "unnamed", ptr
));
728 /****************************************************************************
729 Like tdb_open() but also setup a logging function that redirects to
730 the samba DEBUG() system.
731 ****************************************************************************/
733 TDB_CONTEXT
*tdb_open_log(const char *name
, int hash_size
, int tdb_flags
,
734 int open_flags
, mode_t mode
)
739 tdb_flags
|= TDB_NOMMAP
;
741 tdb
= tdb_open_ex(name
, hash_size
, tdb_flags
,
742 open_flags
, mode
, tdb_log
);
750 /****************************************************************************
751 Allow tdb_delete to be used as a tdb_traversal_fn.
752 ****************************************************************************/
754 int tdb_traverse_delete_fn(TDB_CONTEXT
*the_tdb
, TDB_DATA key
, TDB_DATA dbuf
,
757 return tdb_delete(the_tdb
, key
);
763 * Search across the whole tdb for keys that match the given pattern
764 * return the result as a list of keys
766 * @param tdb pointer to opened tdb file context
767 * @param pattern searching pattern used by fnmatch(3) functions
769 * @return list of keys found by looking up with given pattern
771 TDB_LIST_NODE
*tdb_search_keys(TDB_CONTEXT
*tdb
, const char* pattern
)
774 TDB_LIST_NODE
*list
= NULL
;
775 TDB_LIST_NODE
*rec
= NULL
;
776 TDB_LIST_NODE
*tmp
= NULL
;
778 for (key
= tdb_firstkey(tdb
); key
.dptr
; key
= next
) {
779 /* duplicate key string to ensure null-termination */
780 char *key_str
= (char*) strndup(key
.dptr
, key
.dsize
);
782 DEBUG(0, ("tdb_search_keys: strndup() failed!\n"));
783 smb_panic("strndup failed!\n");
786 DEBUG(18, ("checking %s for match to pattern %s\n", key_str
, pattern
));
788 next
= tdb_nextkey(tdb
, key
);
790 /* do the pattern checking */
791 if (fnmatch(pattern
, key_str
, 0) == 0) {
792 rec
= (TDB_LIST_NODE
*) malloc(sizeof(*rec
));
797 DLIST_ADD_END(list
, rec
, tmp
);
799 DEBUG(18, ("checking %s matched pattern %s\n", key_str
, pattern
));
804 /* free duplicated key string */
814 * Free the list returned by tdb_search_keys
816 * @param node list of results found by tdb_search_keys
818 void tdb_search_list_free(TDB_LIST_NODE
* node
)
820 TDB_LIST_NODE
*next_node
;
823 next_node
= node
->next
;
824 SAFE_FREE(node
->node_key
.dptr
);