r5004: add current samba3 nmblookup.c ready for updating to new nbt lib
[samba.git] / source / lib / db_wrap.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    database wrap functions
5
6    Copyright (C) Andrew Tridgell 2004
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /*
24   the stupidity of the unix fcntl locking design forces us to never
25   allow a database file to be opened twice in the same process. These
26   wrappers provide convenient access to a tdb or ldb, taking advantage
27   of talloc destructors to ensure that only a single open is done
28 */
29
30 #include "includes.h"
31 #include "dlinklist.h"
32 #include "lib/ldb/include/ldb.h"
33
34 static struct ldb_wrap *ldb_list;
35 static struct tdb_wrap *tdb_list;
36
37 /*
38   this is used to catch debug messages from ldb
39 */
40 static void ldb_wrap_debug(void *context, enum ldb_debug_level level, 
41                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
42
43 static void ldb_wrap_debug(void *context, enum ldb_debug_level level, 
44                            const char *fmt, va_list ap)
45 {
46         char *s = NULL;
47         if (DEBUGLEVEL < 4 && level > LDB_DEBUG_WARNING) {
48                 return;
49         }
50         vasprintf(&s, fmt, ap);
51         if (!s) return;
52         DEBUG(level, ("ldb: %s\n", s));
53         free(s);
54 }
55
56
57 /* destroy the last connection to a ldb */
58 static int ldb_wrap_destructor(void *ctx)
59 {
60         struct ldb_wrap *w = ctx;
61         ldb_close(w->ldb);
62         DLIST_REMOVE(ldb_list, w);
63         return 0;
64 }                                
65
66 /*
67   wrapped connection to a ldb database
68   to close just talloc_free() the ldb_wrap pointer
69  */
70 struct ldb_wrap *ldb_wrap_connect(TALLOC_CTX *mem_ctx,
71                                   const char *url,
72                                   unsigned int flags,
73                                   const char *options[])
74 {
75         struct ldb_wrap *w;
76
77         for (w=ldb_list;w;w=w->next) {
78                 if (strcmp(url, w->url) == 0) {
79                         return talloc_reference(mem_ctx, w);
80                 }
81         }
82
83         w = talloc_p(mem_ctx, struct ldb_wrap);
84         if (w == NULL) {
85                 return NULL;
86         }
87
88         w->url = talloc_strdup(w, url);
89
90         w->ldb = ldb_connect(url, flags, options);
91         if (w->ldb == NULL) {
92                 talloc_free(w);
93                 return NULL;
94         }
95         talloc_steal(w, w->ldb);
96
97         talloc_set_destructor(w, ldb_wrap_destructor);
98         ldb_set_debug(w->ldb, ldb_wrap_debug, NULL);
99
100         DLIST_ADD(ldb_list, w);
101
102         return w;
103 }
104
105
106 /*
107  Log tdb messages via DEBUG().
108 */
109 static void tdb_wrap_log(TDB_CONTEXT *tdb, int level, 
110                          const char *format, ...) PRINTF_ATTRIBUTE(3,4);
111
112 static void tdb_wrap_log(TDB_CONTEXT *tdb, int level, 
113                          const char *format, ...)
114 {
115         va_list ap;
116         char *ptr = NULL;
117
118         va_start(ap, format);
119         vasprintf(&ptr, format, ap);
120         va_end(ap);
121         
122         if (ptr != NULL) {
123                 DEBUG(level, ("tdb(%s): %s", tdb->name ? tdb->name : "unnamed", ptr));
124                 free(ptr);
125         }
126 }
127
128
129 /* destroy the last connection to a tdb */
130 static int tdb_wrap_destructor(void *ctx)
131 {
132         struct tdb_wrap *w = ctx;
133         tdb_close(w->tdb);
134         DLIST_REMOVE(tdb_list, w);
135         return 0;
136 }                                
137
138 /*
139   wrapped connection to a tdb database
140   to close just talloc_free() the tdb_wrap pointer
141  */
142 struct tdb_wrap *tdb_wrap_open(TALLOC_CTX *mem_ctx,
143                                const char *name, int hash_size, int tdb_flags,
144                                int open_flags, mode_t mode)
145 {
146         struct tdb_wrap *w;
147
148         for (w=tdb_list;w;w=w->next) {
149                 if (strcmp(name, w->name) == 0) {
150                         return talloc_reference(mem_ctx, w);
151                 }
152         }
153
154         w = talloc_p(mem_ctx, struct tdb_wrap);
155         if (w == NULL) {
156                 return NULL;
157         }
158
159         w->name = talloc_strdup(w, name);
160
161         w->tdb = tdb_open_ex(name, hash_size, tdb_flags, 
162                              open_flags, mode, tdb_wrap_log, NULL);
163         if (w->tdb == NULL) {
164                 talloc_free(w);
165                 return NULL;
166         }
167
168         talloc_set_destructor(w, tdb_wrap_destructor);
169
170         DLIST_ADD(tdb_list, w);
171
172         return w;
173 }