2 * Unix SMB/CIFS implementation.
3 * libnet smbconf registry Support
4 * Copyright (C) Michael Adam 2007
5 * Copyright (C) Guenther Deschner 2007
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.
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.
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/>.
23 /**********************************************************************
25 * Helper functions (mostly registry related)
26 * TODO: These should be eventually static.
28 **********************************************************************/
31 * add a string to a talloced array of strings.
33 static WERROR libnet_smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
38 WERROR werr = WERR_OK;
39 char **new_array = NULL;
41 if ((array == NULL) || (string == NULL)) {
42 return WERR_INVALID_PARAM;
45 new_array = TALLOC_REALLOC_ARRAY(mem_ctx, *array, char *, count + 1);
46 if (new_array == NULL) {
50 new_array[count] = talloc_strdup(new_array, string);
58 * Open a subkey of KEY_SMBCONF (i.e a service)
60 WERROR libnet_smbconf_reg_open_path(TALLOC_CTX *ctx,
61 const char *subkeyname,
62 uint32 desired_access,
63 struct registry_key **key)
65 WERROR werr = WERR_OK;
69 if (!(token = registry_create_admin_token(ctx))) {
70 DEBUG(1, ("Error creating admin token\n"));
74 if (subkeyname == NULL) {
75 path = talloc_strdup(ctx, KEY_SMBCONF);
77 path = talloc_asprintf(ctx, "%s\\%s", KEY_SMBCONF, subkeyname);
80 werr = reg_open_path(ctx, path, desired_access,
83 if (!W_ERROR_IS_OK(werr)) {
84 DEBUG(1, ("Error opening registry path '%s': %s\n",
85 path, dos_errstr(werr)));
94 * open the base key KEY_SMBCONF
96 WERROR libnet_smbconf_reg_open_basepath(TALLOC_CTX *ctx, uint32 desired_access,
97 struct registry_key **key)
99 return libnet_smbconf_reg_open_path(ctx, NULL, desired_access, key);
103 * check if a subkey of KEY_SMBCONF of a given name exists
105 bool libnet_smbconf_key_exists(const char *subkeyname)
108 WERROR werr = WERR_OK;
109 TALLOC_CTX *mem_ctx = talloc_stackframe();
110 struct registry_key *key = NULL;
112 werr = libnet_smbconf_reg_open_path(mem_ctx, subkeyname, REG_KEY_READ,
114 if (W_ERROR_IS_OK(werr)) {
118 TALLOC_FREE(mem_ctx);
122 static bool libnet_smbconf_value_exists(struct registry_key *key,
126 WERROR werr = WERR_OK;
127 TALLOC_CTX *ctx = talloc_stackframe();
128 struct registry_value *value = NULL;
130 werr = reg_queryvalue(ctx, key, param, &value);
131 if (W_ERROR_IS_OK(werr)) {
140 * create a subkey of KEY_SMBCONF
142 WERROR libnet_smbconf_reg_createkey_internal(TALLOC_CTX *ctx,
143 const char * subkeyname,
144 struct registry_key **newkey)
146 WERROR werr = WERR_OK;
147 struct registry_key *create_parent = NULL;
148 TALLOC_CTX *create_ctx;
149 enum winreg_CreateAction action = REG_ACTION_NONE;
151 /* create a new talloc ctx for creation. it will hold
152 * the intermediate parent key (SMBCONF) for creation
153 * and will be destroyed when leaving this function... */
154 if (!(create_ctx = talloc_new(ctx))) {
159 werr = libnet_smbconf_reg_open_basepath(create_ctx, REG_KEY_WRITE,
161 if (!W_ERROR_IS_OK(werr)) {
165 werr = reg_createkey(ctx, create_parent, subkeyname,
166 REG_KEY_WRITE, newkey, &action);
167 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
168 d_fprintf(stderr, "Key '%s' already exists.\n", subkeyname);
169 werr = WERR_ALREADY_EXISTS;
171 if (!W_ERROR_IS_OK(werr)) {
172 d_fprintf(stderr, "Error creating key %s: %s\n",
173 subkeyname, dos_errstr(werr));
177 TALLOC_FREE(create_ctx);
182 * add a value to a key.
184 WERROR libnet_smbconf_reg_setvalue_internal(struct registry_key *key,
188 struct registry_value val;
189 WERROR werr = WERR_OK;
191 const char *canon_valname;
192 const char *canon_valstr;
194 if (!lp_canonicalize_parameter_with_value(valname, valstr,
198 if (canon_valname == NULL) {
199 d_fprintf(stderr, "invalid parameter '%s' given\n",
202 d_fprintf(stderr, "invalid value '%s' given for "
203 "parameter '%s'\n", valstr, valname);
205 werr = WERR_INVALID_PARAM;
212 val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
213 val.v.sz.len = strlen(canon_valstr) + 1;
215 if (registry_smbconf_valname_forbidden(canon_valname)) {
216 d_fprintf(stderr, "Parameter '%s' not allowed in registry.\n",
218 werr = WERR_INVALID_PARAM;
222 subkeyname = strrchr_m(key->key->name, '\\');
223 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
224 d_fprintf(stderr, "Invalid registry key '%s' given as "
225 "smbconf section.\n", key->key->name);
226 werr = WERR_INVALID_PARAM;
230 if (!strequal(subkeyname, GLOBAL_NAME) &&
231 lp_parameter_is_global(valname))
233 d_fprintf(stderr, "Global paramter '%s' not allowed in "
234 "service definition ('%s').\n", canon_valname,
236 werr = WERR_INVALID_PARAM;
240 werr = reg_setvalue(key, canon_valname, &val);
241 if (!W_ERROR_IS_OK(werr)) {
243 "Error adding value '%s' to "
245 canon_valname, key->key->name, dos_errstr(werr));
253 * format a registry_value into a string.
255 * This is intended to be used for smbconf registry values,
256 * which are ar stored as REG_SZ values, so the incomplete
257 * handling should be ok.
259 char *libnet_smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
260 struct registry_value *value)
264 /* alternatively, create a new talloc context? */
265 if (mem_ctx == NULL) {
269 switch (value->type) {
271 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
275 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
279 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
280 result = talloc_asprintf(mem_ctx, "\"%s\" ",
281 value->v.multi_sz.strings[j]);
286 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
287 (int)value->v.binary.length);
290 result = talloc_asprintf(mem_ctx, "<unprintable>");
297 * Get the values of a key as a list of value names
298 * and a list of value strings (ordered)
300 static WERROR libnet_smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
301 struct registry_key *key,
302 uint32_t *num_values,
304 char ***value_strings)
306 TALLOC_CTX *tmp_ctx = NULL;
307 WERROR werr = WERR_OK;
309 struct registry_value *valvalue = NULL;
310 char *valname = NULL;
311 char **tmp_valnames = NULL;
312 char **tmp_valstrings = NULL;
314 if ((num_values == NULL) || (value_names == NULL) ||
315 (value_strings == NULL))
317 werr = WERR_INVALID_PARAM;
321 tmp_ctx = talloc_new(mem_ctx);
322 if (tmp_ctx == NULL) {
328 W_ERROR_IS_OK(werr = reg_enumvalue(tmp_ctx, key, count, &valname,
334 werr = libnet_smbconf_add_string_to_array(tmp_ctx,
337 if (!W_ERROR_IS_OK(werr)) {
341 valstring = libnet_smbconf_format_registry_value(tmp_ctx,
343 werr = libnet_smbconf_add_string_to_array(tmp_ctx,
347 if (!W_ERROR_IS_OK(werr)) {
351 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
359 *value_names = talloc_move(mem_ctx, &tmp_valnames);
360 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
364 TALLOC_FREE(tmp_ctx);
368 /**********************************************************************
370 * The actual net conf api functions, that are exported.
372 **********************************************************************/
375 * Drop the whole configuration (restarting empty).
377 WERROR libnet_smbconf_drop(void)
380 WERROR werr = WERR_OK;
381 NT_USER_TOKEN *token;
382 struct registry_key *parent_key = NULL;
383 struct registry_key *new_key = NULL;
384 TALLOC_CTX* mem_ctx = talloc_stackframe();
385 enum winreg_CreateAction action;
387 if (!(token = registry_create_admin_token(mem_ctx))) {
388 /* what is the appropriate error code here? */
389 werr = WERR_CAN_NOT_COMPLETE;
393 path = talloc_strdup(mem_ctx, KEY_SMBCONF);
398 p = strrchr(path, '\\');
400 werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token, &parent_key);
402 if (!W_ERROR_IS_OK(werr)) {
406 werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
408 if (!W_ERROR_IS_OK(werr)) {
412 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
416 TALLOC_FREE(mem_ctx);
421 * get the list of share names defined in the configuration.
423 WERROR libnet_smbconf_get_share_names(TALLOC_CTX *mem_ctx, uint32_t *num_shares,
427 uint32_t added_count = 0;
428 TALLOC_CTX *tmp_ctx = NULL;
429 WERROR werr = WERR_OK;
430 struct registry_key *key = NULL;
431 char *subkey_name = NULL;
432 char **tmp_share_names = NULL;
434 if ((num_shares == NULL) || (share_names == NULL)) {
435 werr = WERR_INVALID_PARAM;
439 tmp_ctx = talloc_new(mem_ctx);
440 if (tmp_ctx == NULL) {
445 /* make sure "global" is always listed first */
446 if (libnet_smbconf_key_exists(GLOBAL_NAME)) {
447 werr = libnet_smbconf_add_string_to_array(tmp_ctx,
450 if (!W_ERROR_IS_OK(werr)) {
456 werr = libnet_smbconf_reg_open_basepath(tmp_ctx,
457 SEC_RIGHTS_ENUM_SUBKEYS,
459 if (!W_ERROR_IS_OK(werr)) {
464 W_ERROR_IS_OK(werr = reg_enumkey(tmp_ctx, key, count,
465 &subkey_name, NULL));
468 if (strequal(subkey_name, GLOBAL_NAME)) {
472 werr = libnet_smbconf_add_string_to_array(tmp_ctx,
476 if (!W_ERROR_IS_OK(werr)) {
481 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
486 *num_shares = added_count;
487 if (added_count > 0) {
488 *share_names = talloc_move(mem_ctx, &tmp_share_names);
492 TALLOC_FREE(tmp_ctx);
497 * get a definition of a share (service) from configuration.
499 WERROR libnet_smbconf_getshare(TALLOC_CTX *mem_ctx, const char *servicename,
500 uint32_t *num_params, char ***param_names,
501 char ***param_values)
503 WERROR werr = WERR_OK;
504 struct registry_key *key = NULL;
506 werr = libnet_smbconf_reg_open_path(mem_ctx, servicename, REG_KEY_READ,
508 if (!W_ERROR_IS_OK(werr)) {
512 werr = libnet_smbconf_reg_get_values(mem_ctx, key, num_params,
513 param_names, param_values);
521 * delete a service from configuration
523 WERROR libnet_smbconf_delshare(const char *servicename)
525 WERROR werr = WERR_OK;
526 struct registry_key *key = NULL;
527 TALLOC_CTX *ctx = talloc_stackframe();
529 werr = libnet_smbconf_reg_open_basepath(ctx, REG_KEY_WRITE, &key);
530 if (!W_ERROR_IS_OK(werr)) {
534 werr = reg_deletekey_recursive(key, key, servicename);
542 * set a configuration parameter to the value provided.
544 WERROR libnet_smbconf_setparm(const char *service,
549 struct registry_key *key = NULL;
550 TALLOC_CTX *mem_ctx = talloc_stackframe();
552 if (!libnet_smbconf_key_exists(service)) {
553 werr = libnet_smbconf_reg_createkey_internal(mem_ctx, service,
556 werr = libnet_smbconf_reg_open_path(mem_ctx, service,
557 REG_KEY_WRITE, &key);
559 if (!W_ERROR_IS_OK(werr)) {
563 werr = libnet_smbconf_reg_setvalue_internal(key, param, valstr);
566 TALLOC_FREE(mem_ctx);
571 * get the value of a configuration parameter as a string
573 WERROR libnet_smbconf_getparm(TALLOC_CTX *mem_ctx,
578 WERROR werr = WERR_OK;
579 struct registry_key *key = NULL;
580 struct registry_value *value = NULL;
582 if (valstr == NULL) {
583 werr = WERR_INVALID_PARAM;
587 if (!libnet_smbconf_key_exists(service)) {
588 werr = WERR_NO_SUCH_SERVICE;
592 werr = libnet_smbconf_reg_open_path(mem_ctx, service, REG_KEY_READ,
594 if (!W_ERROR_IS_OK(werr)) {
598 if (!libnet_smbconf_value_exists(key, param)) {
599 werr = WERR_INVALID_PARAM;
603 werr = reg_queryvalue(mem_ctx, key, param, &value);
604 if (!W_ERROR_IS_OK(werr)) {
608 *valstr = libnet_smbconf_format_registry_value(mem_ctx, value);
610 if (*valstr == NULL) {
621 * delete a parameter from configuration
623 WERROR libnet_smbconf_delparm(const char *service,
626 struct registry_key *key = NULL;
627 WERROR werr = WERR_OK;
628 TALLOC_CTX *mem_ctx = talloc_stackframe();
630 if (!libnet_smbconf_key_exists(service)) {
631 return WERR_NO_SUCH_SERVICE;
634 werr = libnet_smbconf_reg_open_path(mem_ctx, service, REG_KEY_ALL, &key);
635 if (!W_ERROR_IS_OK(werr)) {
639 if (!libnet_smbconf_value_exists(key, param)) {
640 werr = WERR_INVALID_PARAM;
644 werr = reg_deletevalue(key, param);
647 TALLOC_FREE(mem_ctx);
652 /**********************************************************************
654 * Convenience functions that are also exported.
656 **********************************************************************/
658 WERROR libnet_smbconf_set_global_param(const char *param,
661 return libnet_smbconf_setparm(GLOBAL_NAME, param, val);