source: vendor/current/lib/smbconf/smbconf.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 11.6 KB
Line 
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 * create and set the definition for a new share (service).
235 */
236sbcErr smbconf_create_set_share(struct smbconf_ctx *ctx,
237 struct smbconf_service *service)
238{
239 sbcErr err, err2;
240 int i;
241 uint32_t num_includes = 0;
242 char **includes = NULL;
243 TALLOC_CTX *tmp_ctx = NULL;
244
245 if ((service->name != NULL) && smbconf_share_exists(ctx, service->name))
246 {
247 return SBC_ERR_FILE_EXISTS;
248 }
249
250 err = smbconf_transaction_start(ctx);
251 if (!SBC_ERROR_IS_OK(err)) {
252 return err;
253 }
254
255 tmp_ctx = talloc_stackframe();
256
257 err = smbconf_create_share(ctx, service->name);
258 if (!SBC_ERROR_IS_OK(err)) {
259 goto cancel;
260 }
261
262 for (i = 0; i < service->num_params; i++) {
263 if (strequal(service->param_names[i], "include")) {
264 includes = talloc_realloc(tmp_ctx, includes, char *,
265 num_includes+1);
266 if (includes == NULL) {
267 err = SBC_ERR_NOMEM;
268 goto cancel;
269 }
270 includes[num_includes] = talloc_strdup(includes,
271 service->param_values[i]);
272 if (includes[num_includes] == NULL) {
273 err = SBC_ERR_NOMEM;
274 goto cancel;
275 }
276 num_includes++;
277 } else {
278 err = smbconf_set_parameter(ctx,
279 service->name,
280 service->param_names[i],
281 service->param_values[i]);
282 if (!SBC_ERROR_IS_OK(err)) {
283 goto cancel;
284 }
285 }
286 }
287
288 err = smbconf_set_includes(ctx, service->name, num_includes,
289 discard_const_p(const char *, includes));
290 if (!SBC_ERROR_IS_OK(err)) {
291 goto cancel;
292 }
293
294 err = smbconf_transaction_commit(ctx);
295
296 goto done;
297
298cancel:
299 err2 = smbconf_transaction_cancel(ctx);
300 if (!SBC_ERROR_IS_OK(err2)) {
301 DEBUG(5, (__location__ ": Error cancelling transaction: %s\n",
302 sbcErrorString(err2)));
303 }
304
305done:
306 talloc_free(tmp_ctx);
307 return err;
308}
309
310/**
311 * get a definition of a share (service) from configuration.
312 */
313sbcErr smbconf_get_share(struct smbconf_ctx *ctx,
314 TALLOC_CTX *mem_ctx,
315 const char *servicename,
316 struct smbconf_service **service)
317{
318 return ctx->ops->get_share(ctx, mem_ctx, servicename, service);
319}
320
321/**
322 * delete a service from configuration
323 */
324sbcErr smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
325{
326 if (!smbconf_share_exists(ctx, servicename)) {
327 return SBC_ERR_NO_SUCH_SERVICE;
328 }
329
330 return ctx->ops->delete_share(ctx, servicename);
331}
332
333/**
334 * set a configuration parameter to the value provided.
335 */
336sbcErr smbconf_set_parameter(struct smbconf_ctx *ctx,
337 const char *service,
338 const char *param,
339 const char *valstr)
340{
341 return ctx->ops->set_parameter(ctx, service, param, valstr);
342}
343
344/**
345 * Set a global parameter
346 * (i.e. a parameter in the [global] service).
347 *
348 * This also creates [global] when it does not exist.
349 */
350sbcErr smbconf_set_global_parameter(struct smbconf_ctx *ctx,
351 const char *param, const char *val)
352{
353 sbcErr err;
354
355 err = smbconf_global_check(ctx);
356 if (!SBC_ERROR_IS_OK(err)) {
357 return err;
358 }
359 err = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
360
361 return err;
362}
363
364/**
365 * get the value of a configuration parameter as a string
366 */
367sbcErr smbconf_get_parameter(struct smbconf_ctx *ctx,
368 TALLOC_CTX *mem_ctx,
369 const char *service,
370 const char *param,
371 char **valstr)
372{
373 if (valstr == NULL) {
374 return SBC_ERR_INVALID_PARAM;
375 }
376
377 return ctx->ops->get_parameter(ctx, mem_ctx, service, param, valstr);
378}
379
380/**
381 * Get the value of a global parameter.
382 *
383 * Create [global] if it does not exist.
384 */
385sbcErr smbconf_get_global_parameter(struct smbconf_ctx *ctx,
386 TALLOC_CTX *mem_ctx,
387 const char *param,
388 char **valstr)
389{
390 sbcErr err;
391
392 err = smbconf_global_check(ctx);
393 if (!SBC_ERROR_IS_OK(err)) {
394 return err;
395 }
396
397 err = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
398 valstr);
399
400 return err;
401}
402
403/**
404 * delete a parameter from configuration
405 */
406sbcErr smbconf_delete_parameter(struct smbconf_ctx *ctx,
407 const char *service, const char *param)
408{
409 return ctx->ops->delete_parameter(ctx, service, param);
410}
411
412/**
413 * Delete a global parameter.
414 *
415 * Create [global] if it does not exist.
416 */
417sbcErr smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
418 const char *param)
419{
420 sbcErr err;
421
422 err = smbconf_global_check(ctx);
423 if (!SBC_ERROR_IS_OK(err)) {
424 return err;
425 }
426 err = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
427
428 return err;
429}
430
431sbcErr smbconf_get_includes(struct smbconf_ctx *ctx,
432 TALLOC_CTX *mem_ctx,
433 const char *service,
434 uint32_t *num_includes, char ***includes)
435{
436 return ctx->ops->get_includes(ctx, mem_ctx, service, num_includes,
437 includes);
438}
439
440sbcErr smbconf_get_global_includes(struct smbconf_ctx *ctx,
441 TALLOC_CTX *mem_ctx,
442 uint32_t *num_includes, char ***includes)
443{
444 sbcErr err;
445
446 err = smbconf_global_check(ctx);
447 if (!SBC_ERROR_IS_OK(err)) {
448 return err;
449 }
450 err = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
451 num_includes, includes);
452
453 return err;
454}
455
456sbcErr smbconf_set_includes(struct smbconf_ctx *ctx,
457 const char *service,
458 uint32_t num_includes, const char **includes)
459{
460 return ctx->ops->set_includes(ctx, service, num_includes, includes);
461}
462
463sbcErr smbconf_set_global_includes(struct smbconf_ctx *ctx,
464 uint32_t num_includes,
465 const char **includes)
466{
467 sbcErr err;
468
469 err = smbconf_global_check(ctx);
470 if (!SBC_ERROR_IS_OK(err)) {
471 return err;
472 }
473 err = smbconf_set_includes(ctx, GLOBAL_NAME,
474 num_includes, includes);
475
476 return err;
477}
478
479
480sbcErr smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
481{
482 return ctx->ops->delete_includes(ctx, service);
483}
484
485sbcErr smbconf_delete_global_includes(struct smbconf_ctx *ctx)
486{
487 sbcErr err;
488
489 err = smbconf_global_check(ctx);
490 if (!SBC_ERROR_IS_OK(err)) {
491 return err;
492 }
493 err = smbconf_delete_includes(ctx, GLOBAL_NAME);
494
495 return err;
496}
497
498sbcErr smbconf_transaction_start(struct smbconf_ctx *ctx)
499{
500 return ctx->ops->transaction_start(ctx);
501}
502
503sbcErr smbconf_transaction_commit(struct smbconf_ctx *ctx)
504{
505 return ctx->ops->transaction_commit(ctx);
506}
507
508sbcErr smbconf_transaction_cancel(struct smbconf_ctx *ctx)
509{
510 return ctx->ops->transaction_cancel(ctx);
511}
Note: See TracBrowser for help on using the repository browser.