2 Unix SMB/CIFS implementation.
4 LDB based services configuration
6 Copyright (C) Simo Sorce 2006
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.
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.
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.
24 #include "ldb/include/ldb.h"
25 #include "ldb/include/ldb_errors.h"
26 #include "auth/auth.h"
28 #include "param/share.h"
30 static NTSTATUS
sldb_init(TALLOC_CTX
*mem_ctx
, const struct share_ops
*ops
, struct share_context
**ctx
)
32 struct ldb_context
*sdb
;
34 *ctx
= talloc(mem_ctx
, struct share_context
);
36 DEBUG(0, ("ERROR: Out of memory!\n"));
37 return NT_STATUS_NO_MEMORY
;
40 sdb
= ldb_wrap_connect( *ctx
,
41 private_path(*ctx
, "share.ldb"),
47 return NT_STATUS_UNSUCCESSFUL
;
51 (*ctx
)->priv_data
= (void *)sdb
;
56 static const char *sldb_string_option(struct share_config
*scfg
, const char *opt_name
, const char *defval
)
58 struct ldb_message
*msg
;
59 struct ldb_message_element
*el
;
61 if (scfg
== NULL
) return defval
;
63 msg
= talloc_get_type(scfg
->opaque
, struct ldb_message
);
65 if (strchr(opt_name
, ':')) {
68 name
= talloc_strdup(scfg
, opt_name
);
72 p
= strchr(name
, ':');
75 el
= ldb_msg_find_element(msg
, name
);
77 el
= ldb_msg_find_element(msg
, opt_name
);
84 return (const char *)(el
->values
[0].data
);
87 static int sldb_int_option(struct share_config
*scfg
, const char *opt_name
, int defval
)
92 val
= sldb_string_option(scfg
, opt_name
, NULL
);
93 if (val
== NULL
) return defval
;
96 ret
= (int)strtol(val
, NULL
, 10);
102 static BOOL
sldb_bool_option(struct share_config
*scfg
, const char *opt_name
, BOOL defval
)
106 val
= sldb_string_option(scfg
, opt_name
, NULL
);
107 if (val
== NULL
) return defval
;
109 if (strcasecmp(val
, "true") == 0) return True
;
114 static const char **sldb_string_list_option(TALLOC_CTX
*mem_ctx
, struct share_config
*scfg
, const char *opt_name
)
116 struct ldb_message
*msg
;
117 struct ldb_message_element
*el
;
121 if (scfg
== NULL
) return NULL
;
123 msg
= talloc_get_type(scfg
->opaque
, struct ldb_message
);
125 if (strchr(opt_name
, ':')) {
128 name
= talloc_strdup(scfg
, opt_name
);
132 p
= strchr(name
, ':');
135 el
= ldb_msg_find_element(msg
, name
);
137 el
= ldb_msg_find_element(msg
, opt_name
);
144 list
= talloc_array(mem_ctx
, const char *, el
->num_values
+ 1);
145 if (!list
) return NULL
;
147 for (i
= 0; i
< el
->num_values
; i
++) {
148 list
[i
] = (const char *)(el
->values
[i
].data
);
155 static NTSTATUS
sldb_list_all(TALLOC_CTX
*mem_ctx
,
156 struct share_context
*ctx
,
162 struct ldb_context
*ldb
;
163 struct ldb_result
*res
;
166 tmp_ctx
= talloc_new(mem_ctx
);
168 DEBUG(0,("ERROR: Out of memory!\n"));
169 return NT_STATUS_NO_MEMORY
;
172 ldb
= talloc_get_type(ctx
->priv_data
, struct ldb_context
);
174 ret
= ldb_search(ldb
, ldb_dn_explode(tmp_ctx
, "CN=SHARES"), LDB_SCOPE_SUBTREE
, "(name=*)", NULL
, &res
);
175 if (ret
!= LDB_SUCCESS
) {
176 talloc_free(tmp_ctx
);
177 return NT_STATUS_UNSUCCESSFUL
;
179 talloc_steal(tmp_ctx
, res
);
181 n
= talloc_array(mem_ctx
, const char *, res
->count
);
183 DEBUG(0,("ERROR: Out of memory!\n"));
184 talloc_free(tmp_ctx
);
185 return NT_STATUS_NO_MEMORY
;
188 for (i
= 0, j
= 0; i
< res
->count
; i
++) {
189 n
[j
] = talloc_strdup(n
, ldb_msg_find_attr_as_string(res
->msgs
[i
], "name", NULL
));
191 DEBUG(0,("WARNING: Malformed share object in share database\n!"));
199 talloc_free(tmp_ctx
);
204 static NTSTATUS
sldb_get_config(TALLOC_CTX
*mem_ctx
,
205 struct share_context
*ctx
,
207 struct share_config
**scfg
)
210 struct share_config
*s
;
211 struct ldb_context
*ldb
;
212 struct ldb_result
*res
;
216 tmp_ctx
= talloc_new(mem_ctx
);
218 DEBUG(0,("ERROR: Out of memory!\n"));
219 return NT_STATUS_NO_MEMORY
;
222 ldb
= talloc_get_type(ctx
->priv_data
, struct ldb_context
);
224 filter
= talloc_asprintf(tmp_ctx
,"(name=%s)", name
);
226 DEBUG(0,("ERROR: Out of memory!\n"));
227 talloc_free(tmp_ctx
);
228 return NT_STATUS_NO_MEMORY
;
230 ret
= ldb_search(ldb
, ldb_dn_explode(tmp_ctx
, "CN=SHARES"), LDB_SCOPE_SUBTREE
, filter
, NULL
, &res
);
231 if (ret
!= LDB_SUCCESS
|| res
->count
!= 1) {
232 talloc_free(tmp_ctx
);
233 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
235 talloc_steal(tmp_ctx
, res
);
237 s
= talloc(tmp_ctx
, struct share_config
);
239 DEBUG(0,("ERROR: Out of memory!\n"));
240 talloc_free(tmp_ctx
);
241 return NT_STATUS_NO_MEMORY
;
244 s
->name
= talloc_strdup(s
, ldb_msg_find_attr_as_string(res
->msgs
[0], "name", NULL
));
246 DEBUG(0,("ERROR: Invalid share object!\n"));
247 talloc_free(tmp_ctx
);
248 return NT_STATUS_UNSUCCESSFUL
;
251 s
->opaque
= talloc_steal(s
, res
->msgs
[0]);
253 DEBUG(0,("ERROR: Invalid share object!\n"));
254 talloc_free(tmp_ctx
);
255 return NT_STATUS_UNSUCCESSFUL
;
260 *scfg
= talloc_steal(mem_ctx
, s
);
262 talloc_free(tmp_ctx
);
266 NTSTATUS
share_ldb_init(void)
268 struct share_ops ops
;
271 ops
.init
= sldb_init
;
272 ops
.string_option
= sldb_string_option
;
273 ops
.int_option
= sldb_int_option
;
274 ops
.bool_option
= sldb_bool_option
;
275 ops
.string_list_option
= sldb_string_list_option
;
276 ops
.list_all
= sldb_list_all
;
277 ops
.get_config
= sldb_get_config
;
279 return share_register(&ops
);