source: trunk/server/lib/smbconf/smbconf.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 10.3 KB
RevLine 
[745]1/*
2 * Unix SMB/CIFS implementation.
3 * libsmbconf - Samba configuration library
4 * Copyright (C) Michael Adam 2007-2008
5 * Copyright (C) Guenther Deschner 2007
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 3 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, see <http://www.gnu.org/licenses/>.
19 */
20
21#include "includes.h"
22#include "smbconf_private.h"
23
24/**********************************************************************
25 *
26 * internal helper functions
27 *
28 **********************************************************************/
29
30static sbcErr smbconf_global_check(struct smbconf_ctx *ctx)
31{
32 if (!smbconf_share_exists(ctx, GLOBAL_NAME)) {
33 return smbconf_create_share(ctx, GLOBAL_NAME);
34 }
35
36 return SBC_ERR_OK;
37}
38
39
40/**********************************************************************
41 *
42 * The actual libsmbconf API functions that are exported.
43 *
44 **********************************************************************/
45
46const char *sbcErrorString(sbcErr error)
47{
48 switch (error) {
49 case SBC_ERR_OK:
50 return "SBC_ERR_OK";
51 case SBC_ERR_NOT_IMPLEMENTED:
52 return "SBC_ERR_NOT_IMPLEMENTED";
53 case SBC_ERR_NOT_SUPPORTED:
54 return "SBC_ERR_NOT_SUPPORTED";
55 case SBC_ERR_UNKNOWN_FAILURE:
56 return "SBC_ERR_UNKNOWN_FAILURE";
57 case SBC_ERR_NOMEM:
58 return "SBC_ERR_NOMEM";
59 case SBC_ERR_INVALID_PARAM:
60 return "SBC_ERR_INVALID_PARAM";
61 case SBC_ERR_BADFILE:
62 return "SBC_ERR_BADFILE";
63 case SBC_ERR_NO_SUCH_SERVICE:
64 return "SBC_ERR_NO_SUCH_SERVICE";
65 case SBC_ERR_IO_FAILURE:
66 return "SBC_ERR_IO_FAILURE";
67 case SBC_ERR_CAN_NOT_COMPLETE:
68 return "SBC_ERR_CAN_NOT_COMPLETE";
69 case SBC_ERR_NO_MORE_ITEMS:
70 return "SBC_ERR_NO_MORE_ITEMS";
71 case SBC_ERR_FILE_EXISTS:
72 return "SBC_ERR_FILE_EXISTS";
73 case SBC_ERR_ACCESS_DENIED:
74 return "SBC_ERR_ACCESS_DENIED";
75 }
76
77 return "unknown sbcErr value";
78}
79
80
81/**
82 * Tell whether the backend requires messaging to be set up
83 * for the backend to work correctly.
84 */
85bool smbconf_backend_requires_messaging(struct smbconf_ctx *ctx)
86{
87 return ctx->ops->requires_messaging(ctx);
88}
89
90/**
91 * Tell whether the source is writeable.
92 */
93bool smbconf_is_writeable(struct smbconf_ctx *ctx)
94{
95 return ctx->ops->is_writeable(ctx);
96}
97
98/**
99 * Close the configuration.
100 */
101void smbconf_shutdown(struct smbconf_ctx *ctx)
102{
103 talloc_free(ctx);
104}
105
106/**
107 * Detect changes in the configuration.
108 * The given csn struct is filled with the current csn.
109 * smbconf_changed() can also be used for initial retrieval
110 * of the csn.
111 */
112bool smbconf_changed(struct smbconf_ctx *ctx, struct smbconf_csn *csn,
113 const char *service, const char *param)
114{
115 struct smbconf_csn old_csn;
116
117 if (csn == NULL) {
118 return false;
119 }
120
121 old_csn = *csn;
122
123 ctx->ops->get_csn(ctx, csn, service, param);
124 return (csn->csn != old_csn.csn);
125}
126
127/**
128 * Drop the whole configuration (restarting empty).
129 */
130sbcErr smbconf_drop(struct smbconf_ctx *ctx)
131{
132 return ctx->ops->drop(ctx);
133}
134
135/**
136 * Get the whole configuration as lists of strings with counts:
137 *
138 * num_shares : number of shares
139 * share_names : list of length num_shares of share names
140 * num_params : list of length num_shares of parameter counts for each share
141 * param_names : list of lists of parameter names for each share
142 * param_values : list of lists of parameter values for each share
143 */
144sbcErr smbconf_get_config(struct smbconf_ctx *ctx,
145 TALLOC_CTX *mem_ctx,
146 uint32_t *num_shares,
147 struct smbconf_service ***services)
148{
149 sbcErr err;
150 TALLOC_CTX *tmp_ctx = NULL;
151 uint32_t tmp_num_shares;
152 char **tmp_share_names;
153 struct smbconf_service **tmp_services;
154 uint32_t count;
155
156 if ((num_shares == NULL) || (services == NULL)) {
157 err = SBC_ERR_INVALID_PARAM;
158 goto done;
159 }
160
161 tmp_ctx = talloc_stackframe();
162
163 err = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
164 &tmp_share_names);
165 if (!SBC_ERROR_IS_OK(err)) {
166 goto done;
167 }
168
169 tmp_services = talloc_array(tmp_ctx, struct smbconf_service *,
170 tmp_num_shares);
171 if (tmp_services == NULL) {
172 err = SBC_ERR_NOMEM;
173 goto done;
174 }
175
176 for (count = 0; count < tmp_num_shares; count++) {
177 err = smbconf_get_share(ctx, tmp_services,
178 tmp_share_names[count],
179 &tmp_services[count]);
180 if (!SBC_ERROR_IS_OK(err)) {
181 goto done;
182 }
183 }
184
185 err = SBC_ERR_OK;
186
187 *num_shares = tmp_num_shares;
188 if (tmp_num_shares > 0) {
189 *services = talloc_move(mem_ctx, &tmp_services);
190 } else {
191 *services = NULL;
192 }
193
194done:
195 talloc_free(tmp_ctx);
196 return err;
197}
198
199/**
200 * get the list of share names defined in the configuration.
201 */
202sbcErr smbconf_get_share_names(struct smbconf_ctx *ctx,
203 TALLOC_CTX *mem_ctx,
204 uint32_t *num_shares,
205 char ***share_names)
206{
207 return ctx->ops->get_share_names(ctx, mem_ctx, num_shares,
208 share_names);
209}
210
211/**
212 * check if a share/service of a given name exists
213 */
214bool smbconf_share_exists(struct smbconf_ctx *ctx,
215 const char *servicename)
216{
217 return ctx->ops->share_exists(ctx, servicename);
218}
219
220/**
221 * Add a service if it does not already exist.
222 */
223sbcErr smbconf_create_share(struct smbconf_ctx *ctx,
224 const char *servicename)
225{
226 if ((servicename != NULL) && smbconf_share_exists(ctx, servicename)) {
227 return SBC_ERR_FILE_EXISTS;
228 }
229
230 return ctx->ops->create_share(ctx, servicename);
231}
232
233/**
234 * get a definition of a share (service) from configuration.
235 */
236sbcErr smbconf_get_share(struct smbconf_ctx *ctx,
237 TALLOC_CTX *mem_ctx,
238 const char *servicename,
239 struct smbconf_service **service)
240{
241 return ctx->ops->get_share(ctx, mem_ctx, servicename, service);
242}
243
244/**
245 * delete a service from configuration
246 */
247sbcErr smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
248{
249 if (!smbconf_share_exists(ctx, servicename)) {
250 return SBC_ERR_NO_SUCH_SERVICE;
251 }
252
253 return ctx->ops->delete_share(ctx, servicename);
254}
255
256/**
257 * set a configuration parameter to the value provided.
258 */
259sbcErr smbconf_set_parameter(struct smbconf_ctx *ctx,
260 const char *service,
261 const char *param,
262 const char *valstr)
263{
264 return ctx->ops->set_parameter(ctx, service, param, valstr);
265}
266
267/**
268 * Set a global parameter
269 * (i.e. a parameter in the [global] service).
270 *
271 * This also creates [global] when it does not exist.
272 */
273sbcErr smbconf_set_global_parameter(struct smbconf_ctx *ctx,
274 const char *param, const char *val)
275{
276 sbcErr err;
277
278 err = smbconf_global_check(ctx);
279 if (!SBC_ERROR_IS_OK(err)) {
280 return err;
281 }
282 err = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
283
284 return err;
285}
286
287/**
288 * get the value of a configuration parameter as a string
289 */
290sbcErr smbconf_get_parameter(struct smbconf_ctx *ctx,
291 TALLOC_CTX *mem_ctx,
292 const char *service,
293 const char *param,
294 char **valstr)
295{
296 if (valstr == NULL) {
297 return SBC_ERR_INVALID_PARAM;
298 }
299
300 return ctx->ops->get_parameter(ctx, mem_ctx, service, param, valstr);
301}
302
303/**
304 * Get the value of a global parameter.
305 *
306 * Create [global] if it does not exist.
307 */
308sbcErr smbconf_get_global_parameter(struct smbconf_ctx *ctx,
309 TALLOC_CTX *mem_ctx,
310 const char *param,
311 char **valstr)
312{
313 sbcErr err;
314
315 err = smbconf_global_check(ctx);
316 if (!SBC_ERROR_IS_OK(err)) {
317 return err;
318 }
319
320 err = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
321 valstr);
322
323 return err;
324}
325
326/**
327 * delete a parameter from configuration
328 */
329sbcErr smbconf_delete_parameter(struct smbconf_ctx *ctx,
330 const char *service, const char *param)
331{
332 return ctx->ops->delete_parameter(ctx, service, param);
333}
334
335/**
336 * Delete a global parameter.
337 *
338 * Create [global] if it does not exist.
339 */
340sbcErr smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
341 const char *param)
342{
343 sbcErr err;
344
345 err = smbconf_global_check(ctx);
346 if (!SBC_ERROR_IS_OK(err)) {
347 return err;
348 }
349 err = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
350
351 return err;
352}
353
354sbcErr smbconf_get_includes(struct smbconf_ctx *ctx,
355 TALLOC_CTX *mem_ctx,
356 const char *service,
357 uint32_t *num_includes, char ***includes)
358{
359 return ctx->ops->get_includes(ctx, mem_ctx, service, num_includes,
360 includes);
361}
362
363sbcErr smbconf_get_global_includes(struct smbconf_ctx *ctx,
364 TALLOC_CTX *mem_ctx,
365 uint32_t *num_includes, char ***includes)
366{
367 sbcErr err;
368
369 err = smbconf_global_check(ctx);
370 if (!SBC_ERROR_IS_OK(err)) {
371 return err;
372 }
373 err = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
374 num_includes, includes);
375
376 return err;
377}
378
379sbcErr smbconf_set_includes(struct smbconf_ctx *ctx,
380 const char *service,
381 uint32_t num_includes, const char **includes)
382{
383 return ctx->ops->set_includes(ctx, service, num_includes, includes);
384}
385
386sbcErr smbconf_set_global_includes(struct smbconf_ctx *ctx,
387 uint32_t num_includes,
388 const char **includes)
389{
390 sbcErr err;
391
392 err = smbconf_global_check(ctx);
393 if (!SBC_ERROR_IS_OK(err)) {
394 return err;
395 }
396 err = smbconf_set_includes(ctx, GLOBAL_NAME,
397 num_includes, includes);
398
399 return err;
400}
401
402
403sbcErr smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
404{
405 return ctx->ops->delete_includes(ctx, service);
406}
407
408sbcErr smbconf_delete_global_includes(struct smbconf_ctx *ctx)
409{
410 sbcErr err;
411
412 err = smbconf_global_check(ctx);
413 if (!SBC_ERROR_IS_OK(err)) {
414 return err;
415 }
416 err = smbconf_delete_includes(ctx, GLOBAL_NAME);
417
418 return err;
419}
420
421sbcErr smbconf_transaction_start(struct smbconf_ctx *ctx)
422{
423 return ctx->ops->transaction_start(ctx);
424}
425
426sbcErr smbconf_transaction_commit(struct smbconf_ctx *ctx)
427{
428 return ctx->ops->transaction_commit(ctx);
429}
430
431sbcErr smbconf_transaction_cancel(struct smbconf_ctx *ctx)
432{
433 return ctx->ops->transaction_cancel(ctx);
434}
Note: See TracBrowser for help on using the repository browser.