Rename libnet_smbconf_drop() to libnet_conf_drop().

[ira/wip.git] / source / libnet / libnet_conf.c

diff --git a/source/libnet/libnet_conf.c b/source/libnet/libnet_conf.c
index ca5b0c408fb9addc1258adc17ea4fa9783da443c..f9f1759de2aa67091f2f8f48fff33a62c3d9f8c2 100644 (file)
--- a/source/libnet/libnet_conf.c
+++ b/source/libnet/libnet_conf.c
@@ -31,10 +31,10 @@
 /**
  * add a string to a talloced array of strings.
  */
-static WERROR libnet_smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
-                                               char ***array,
-                                               uint32_t count,
-                                               const char *string)
+static WERROR libnet_conf_add_string_to_array(TALLOC_CTX *mem_ctx,
+                                             char ***array,
+                                             uint32_t count,
+                                             const char *string)
 {
        char **new_array = NULL;
 
@@ -55,15 +55,16 @@ static WERROR libnet_smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
 }
 
 /**
- * Open a subkey of KEY_SMBCONF (i.e a service)
+ * Open a registry key specified by "path"
  */
-static WERROR libnet_smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
-                                          const char *path,
-                                          uint32 desired_access,
-                                          struct registry_key **key)
+static WERROR libnet_conf_reg_open_path(TALLOC_CTX *mem_ctx,
+                                       const char *path,
+                                       uint32 desired_access,
+                                       struct registry_key **key)
 {
        WERROR werr = WERR_OK;
        NT_USER_TOKEN *token;
+       TALLOC_CTX *tmp_ctx = NULL;
 
        if (path == NULL) {
                DEBUG(1, ("Error: NULL path string given\n"));
@@ -71,7 +72,13 @@ static WERROR libnet_smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
                goto done;
        }
 
-       token = registry_create_admin_token(mem_ctx);
+       tmp_ctx = talloc_new(mem_ctx);
+       if (tmp_ctx == NULL) {
+               werr = WERR_NOMEM;
+               goto done;
+       }
+
+       token = registry_create_admin_token(tmp_ctx);
        if (token == NULL) {
                DEBUG(1, ("Error creating admin token\n"));
                /* what is the appropriate error code here? */
@@ -87,20 +94,20 @@ static WERROR libnet_smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
        }
 
 done:
+       TALLOC_FREE(tmp_ctx);
        return werr;
 }
 
 /**
  * Open a subkey of KEY_SMBCONF (i.e a service)
  */
-static WERROR libnet_smbconf_reg_open_service_key(TALLOC_CTX *ctx,
-                                                 const char *servicename,
-                                                 uint32 desired_access,
-                                                 struct registry_key **key)
+static WERROR libnet_conf_reg_open_service_key(TALLOC_CTX *ctx,
+                                              const char *servicename,
+                                              uint32 desired_access,
+                                              struct registry_key **key)
 {
        WERROR werr = WERR_OK;
        char *path = NULL;
-       NT_USER_TOKEN *token;
 
        if (servicename == NULL) {
                DEBUG(3, ("Error: NULL servicename given.\n"));
@@ -110,7 +117,7 @@ static WERROR libnet_smbconf_reg_open_service_key(TALLOC_CTX *ctx,
 
        path = talloc_asprintf(ctx, "%s\\%s", KEY_SMBCONF, servicename);
 
-       werr = libnet_smbconf_reg_open_path(ctx, path, desired_access, key);
+       werr = libnet_conf_reg_open_path(ctx, path, desired_access, key);
 
 done:
        TALLOC_FREE(path);
@@ -120,16 +127,15 @@ done:
 /*
  * open the base key KEY_SMBCONF
  */
-static WERROR libnet_smbconf_reg_open_basekey(TALLOC_CTX *ctx,
-                                             uint32 desired_access,
-                                             struct registry_key **key)
+static WERROR libnet_conf_reg_open_base_key(TALLOC_CTX *ctx,
+                                           uint32 desired_access,
+                                           struct registry_key **key)
 {
-       return libnet_smbconf_reg_open_path(ctx, KEY_SMBCONF, desired_access,
-                                           key);
+       return libnet_conf_reg_open_path(ctx, KEY_SMBCONF, desired_access, key);
 }
 
-static bool libnet_smbconf_value_exists(struct registry_key *key,
-                                       const char *param)
+static bool libnet_conf_value_exists(struct registry_key *key,
+                                    const char *param)
 {
        bool ret = false;
        WERROR werr = WERR_OK;
@@ -148,9 +154,9 @@ static bool libnet_smbconf_value_exists(struct registry_key *key,
 /*
  * create a subkey of KEY_SMBCONF
  */
-static WERROR libnet_smbconf_reg_createkey_internal(TALLOC_CTX *ctx,
-                                                   const char * subkeyname,
-                                                   struct registry_key **newkey)
+static WERROR libnet_conf_reg_create_service_key(TALLOC_CTX *ctx,
+                                                const char * subkeyname,
+                                                struct registry_key **newkey)
 {
        WERROR werr = WERR_OK;
        struct registry_key *create_parent = NULL;
@@ -165,8 +171,8 @@ static WERROR libnet_smbconf_reg_createkey_internal(TALLOC_CTX *ctx,
                goto done;
        }
 
-       werr = libnet_smbconf_reg_open_basekey(create_ctx, REG_KEY_WRITE,
-                                              &create_parent);
+       werr = libnet_conf_reg_open_base_key(create_ctx, REG_KEY_WRITE,
+                                            &create_parent);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
@@ -190,9 +196,9 @@ done:
 /*
  * add a value to a key.
  */
-static WERROR libnet_smbconf_reg_setvalue_internal(struct registry_key *key,
-                                                  const char *valname,
-                                                  const char *valstr)
+static WERROR libnet_conf_reg_set_value(struct registry_key *key,
+                                       const char *valname,
+                                       const char *valstr)
 {
        struct registry_value val;
        WERROR werr = WERR_OK;
@@ -264,8 +270,8 @@ done:
  * which are ar stored as REG_SZ values, so the incomplete
  * handling should be ok.
  */
-static char *libnet_smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
-                                                 struct registry_value *value)
+static char *libnet_conf_format_registry_value(TALLOC_CTX *mem_ctx,
+                                              struct registry_value *value)
 {
        char *result = NULL;
 
@@ -305,11 +311,11 @@ static char *libnet_smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
  * Get the values of a key as a list of value names
  * and a list of value strings (ordered)
  */
-static WERROR libnet_smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
-                                           struct registry_key *key,
-                                           uint32_t *num_values,
-                                           char ***value_names,
-                                           char ***value_strings)
+static WERROR libnet_conf_reg_get_values(TALLOC_CTX *mem_ctx,
+                                        struct registry_key *key,
+                                        uint32_t *num_values,
+                                        char ***value_names,
+                                        char ***value_strings)
 {
        TALLOC_CTX *tmp_ctx = NULL;
        WERROR werr = WERR_OK;
@@ -339,19 +345,19 @@ static WERROR libnet_smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
        {
                char *valstring;
 
-               werr = libnet_smbconf_add_string_to_array(tmp_ctx,
-                                                         &tmp_valnames,
-                                                         count, valname);
+               werr = libnet_conf_add_string_to_array(tmp_ctx,
+                                                      &tmp_valnames,
+                                                      count, valname);
                if (!W_ERROR_IS_OK(werr)) {
                        goto done;
                }
 
-               valstring = libnet_smbconf_format_registry_value(tmp_ctx,
-                                                                valvalue);
-               werr = libnet_smbconf_add_string_to_array(tmp_ctx,
-                                                         &tmp_valstrings,
-                                                         count,
-                                                         valstring);
+               valstring = libnet_conf_format_registry_value(tmp_ctx,
+                                                             valvalue);
+               werr = libnet_conf_add_string_to_array(tmp_ctx,
+                                                      &tmp_valstrings,
+                                                      count,
+                                                      valstring);
                if (!W_ERROR_IS_OK(werr)) {
                        goto done;
                }
@@ -385,11 +391,10 @@ done:
 /**
  * Drop the whole configuration (restarting empty).
  */
-WERROR libnet_smbconf_drop(void)
+WERROR libnet_conf_drop(void)
 {
        char *path, *p;
        WERROR werr = WERR_OK;
-       NT_USER_TOKEN *token;
        struct registry_key *parent_key = NULL;
        struct registry_key *new_key = NULL;
        TALLOC_CTX* mem_ctx = talloc_stackframe();
@@ -402,8 +407,8 @@ WERROR libnet_smbconf_drop(void)
        }
        p = strrchr(path, '\\');
        *p = '\0';
-       werr = libnet_smbconf_reg_open_path(mem_ctx, path, REG_KEY_WRITE,
-                                           &parent_key);
+       werr = libnet_conf_reg_open_path(mem_ctx, path, REG_KEY_WRITE,
+                                        &parent_key);
 
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
@@ -534,18 +539,17 @@ WERROR libnet_smbconf_get_share_names(TALLOC_CTX *mem_ctx, uint32_t *num_shares,
 
        /* make sure "global" is always listed first */
        if (libnet_smbconf_share_exists(GLOBAL_NAME)) {
-               werr = libnet_smbconf_add_string_to_array(tmp_ctx,
-                                                         &tmp_share_names,
-                                                         0, GLOBAL_NAME);
+               werr = libnet_conf_add_string_to_array(tmp_ctx,
+                                                      &tmp_share_names,
+                                                      0, GLOBAL_NAME);
                if (!W_ERROR_IS_OK(werr)) {
                        goto done;
                }
                added_count++;
        }
 
-       werr = libnet_smbconf_reg_open_basekey(tmp_ctx,
-                                              SEC_RIGHTS_ENUM_SUBKEYS,
-                                              &key);
+       werr = libnet_conf_reg_open_base_key(tmp_ctx, SEC_RIGHTS_ENUM_SUBKEYS,
+                                            &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
@@ -559,10 +563,10 @@ WERROR libnet_smbconf_get_share_names(TALLOC_CTX *mem_ctx, uint32_t *num_shares,
                        continue;
                }
 
-               werr = libnet_smbconf_add_string_to_array(tmp_ctx,
-                                                         &tmp_share_names,
-                                                         added_count,
-                                                         subkey_name);
+               werr = libnet_conf_add_string_to_array(tmp_ctx,
+                                                      &tmp_share_names,
+                                                      added_count,
+                                                      subkey_name);
                if (!W_ERROR_IS_OK(werr)) {
                        goto done;
                }
@@ -595,8 +599,8 @@ bool libnet_smbconf_share_exists(const char *servicename)
        TALLOC_CTX *mem_ctx = talloc_stackframe();
        struct registry_key *key = NULL;
 
-       werr = libnet_smbconf_reg_open_service_key(mem_ctx, servicename,
-                                                  REG_KEY_READ, &key);
+       werr = libnet_conf_reg_open_service_key(mem_ctx, servicename,
+                                               REG_KEY_READ, &key);
        if (W_ERROR_IS_OK(werr)) {
                ret = true;
        }
@@ -605,6 +609,27 @@ bool libnet_smbconf_share_exists(const char *servicename)
        return ret;
 }
 
+/**
+ * Add a service if it does not already exist.
+ */
+WERROR libnet_smbconf_create_share(const char *servicename)
+{
+       WERROR werr;
+       TALLOC_CTX *mem_ctx = talloc_stackframe();
+       struct registry_key *key = NULL;
+
+       if (libnet_smbconf_share_exists(servicename)) {
+               werr = WERR_ALREADY_EXISTS;
+               goto done;
+       }
+
+       werr = libnet_conf_reg_create_service_key(mem_ctx, servicename, &key);
+
+done:
+       TALLOC_FREE(mem_ctx);
+       return werr;
+}
+
 /**
  * get a definition of a share (service) from configuration.
  */
@@ -615,14 +640,14 @@ WERROR libnet_smbconf_getshare(TALLOC_CTX *mem_ctx, const char *servicename,
        WERROR werr = WERR_OK;
        struct registry_key *key = NULL;
 
-       werr = libnet_smbconf_reg_open_service_key(mem_ctx, servicename,
-                                                  REG_KEY_READ, &key);
+       werr = libnet_conf_reg_open_service_key(mem_ctx, servicename,
+                                               REG_KEY_READ, &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
 
-       werr = libnet_smbconf_reg_get_values(mem_ctx, key, num_params,
-                                            param_names, param_values);
+       werr = libnet_conf_reg_get_values(mem_ctx, key, num_params,
+                                         param_names, param_values);
 
 done:
        TALLOC_FREE(key);
@@ -638,7 +663,7 @@ WERROR libnet_smbconf_delshare(const char *servicename)
        struct registry_key *key = NULL;
        TALLOC_CTX *ctx = talloc_stackframe();
 
-       werr = libnet_smbconf_reg_open_basekey(ctx, REG_KEY_WRITE, &key);
+       werr = libnet_conf_reg_open_base_key(ctx, REG_KEY_WRITE, &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
@@ -662,17 +687,17 @@ WERROR libnet_smbconf_setparm(const char *service,
        TALLOC_CTX *mem_ctx = talloc_stackframe();
 
        if (!libnet_smbconf_share_exists(service)) {
-               werr = libnet_smbconf_reg_createkey_internal(mem_ctx, service,
-                                                            &key);
-       } else {
-               werr = libnet_smbconf_reg_open_service_key(mem_ctx, service,
-                                                          REG_KEY_WRITE, &key);
+               werr = WERR_NO_SUCH_SERVICE;
+               goto done;
        }
+
+       werr = libnet_conf_reg_open_service_key(mem_ctx, service, REG_KEY_WRITE,
+                                               &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
 
-       werr = libnet_smbconf_reg_setvalue_internal(key, param, valstr);
+       werr = libnet_conf_reg_set_value(key, param, valstr);
 
 done:
        TALLOC_FREE(mem_ctx);
@@ -701,13 +726,13 @@ WERROR libnet_smbconf_getparm(TALLOC_CTX *mem_ctx,
                goto done;
        }
 
-       werr = libnet_smbconf_reg_open_service_key(mem_ctx, service,
-                                                  REG_KEY_READ, &key);
+       werr = libnet_conf_reg_open_service_key(mem_ctx, service, REG_KEY_READ,
+                                               &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
 
-       if (!libnet_smbconf_value_exists(key, param)) {
+       if (!libnet_conf_value_exists(key, param)) {
                werr = WERR_INVALID_PARAM;
                goto done;
        }
@@ -717,7 +742,7 @@ WERROR libnet_smbconf_getparm(TALLOC_CTX *mem_ctx,
                goto done;
        }
 
-       *valstr = libnet_smbconf_format_registry_value(mem_ctx, value);
+       *valstr = libnet_conf_format_registry_value(mem_ctx, value);
 
        if (*valstr == NULL) {
                werr = WERR_NOMEM;
@@ -743,13 +768,13 @@ WERROR libnet_smbconf_delparm(const char *service,
                return WERR_NO_SUCH_SERVICE;
        }
 
-       werr = libnet_smbconf_reg_open_service_key(mem_ctx, service,
-                                                  REG_KEY_ALL, &key);
+       werr = libnet_conf_reg_open_service_key(mem_ctx, service, REG_KEY_ALL,
+                                               &key);
        if (!W_ERROR_IS_OK(werr)) {
                goto done;
        }
 
-       if (!libnet_smbconf_value_exists(key, param)) {
+       if (!libnet_conf_value_exists(key, param)) {
                werr = WERR_INVALID_PARAM;
                goto done;
        }