Remove more uses of global_loadparm.
authorJelmer Vernooij <jelmer@samba.org>
Thu, 21 Feb 2008 15:01:19 +0000 (16:01 +0100)
committerJelmer Vernooij <jelmer@samba.org>
Thu, 21 Feb 2008 15:01:19 +0000 (16:01 +0100)
source/lib/registry/patchfile.c
source/lib/registry/patchfile_dotreg.c
source/lib/registry/registry.h
source/lib/registry/tests/generic.c
source/lib/registry/tools/regshell.c
source/lib/registry/tools/regtree.c
source/lib/registry/util.c
source/torture/rpc/samba3rpc.c

index fa1367b..a457901 100644 (file)
@@ -23,6 +23,7 @@
 #include "lib/registry/patchfile.h"
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
+#include "param/param.h"
 
 
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
@@ -30,6 +31,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
                                   void *callback_data);
 
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+                                    struct smb_iconv_convenience *iconv_convenience,
                                     const struct reg_diff_callbacks *callbacks,
                                     void *callback_data);
 
@@ -306,7 +308,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
                return reg_preg_diff_load(fd, callbacks, callback_data);
        } else {
                /* Must be a normal .REG file */
-               return reg_dotreg_diff_load(fd, callbacks, callback_data);
+               return reg_dotreg_diff_load(fd, lp_iconv_convenience(global_loadparm), callbacks, callback_data);
        }
 }
 
index ebcafc9..46ea7c0 100644 (file)
@@ -26,6 +26,7 @@
 #include "lib/registry/patchfile.h"
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
+#include "param/param.h"
 
 /**
  * @file
@@ -36,6 +37,7 @@
 
 struct dotreg_data {
        int fd;
+       struct smb_iconv_convenience *iconv_convenience;
 };
 
 static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
@@ -64,7 +66,7 @@ static WERROR reg_dotreg_diff_set_value(void *_data, const char *path,
 
        fdprintf(data->fd, "\"%s\"=%s:%s\n",
                        value_name, str_regtype(value_type),
-                       reg_val_data_string(NULL, value_type, value));
+                       reg_val_data_string(NULL, data->iconv_convenience, value_type, value));
 
        return WERR_OK;
 }
@@ -107,6 +109,8 @@ _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
        data = talloc_zero(ctx, struct dotreg_data);
        *callback_data = data;
 
+       data->iconv_convenience = lp_iconv_convenience(global_loadparm);
+
        if (filename) {
                data->fd = open(filename, O_CREAT, 0755);
                if (data->fd == -1) {
@@ -135,6 +139,7 @@ _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
  * Load diff file
  */
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+                                    struct smb_iconv_convenience *iconv_convenience,
                                     const struct reg_diff_callbacks *callbacks,
                                     void *callback_data)
 {
@@ -239,7 +244,8 @@ _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
                        q++;
                }
 
-               reg_string_to_val(line, q?p:"REG_SZ", q?q:p,
+               reg_string_to_val(line, iconv_convenience, 
+                                 q?p:"REG_SZ", q?q:p,
                                  &value_type, &value);
 
                error = callbacks->set_value(callback_data, curkey, line,
index fac9180..5e0b971 100644 (file)
@@ -254,11 +254,10 @@ WERROR reg_create_key(TALLOC_CTX *mem_ctx,
 
 /* Utility functions */
 const char *str_regtype(int type);
-char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
-                         const DATA_BLOB data);
-char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
+char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
                          uint32_t type, const DATA_BLOB data);
-bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+bool reg_string_to_val(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *type_str,
                       const char *data_str, uint32_t *type, DATA_BLOB *data);
 WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
                        const char *name, struct registry_key **result);
index 25a8979..145e599 100644 (file)
@@ -45,7 +45,7 @@ static bool test_reg_val_data_string_dword(struct torture_context *ctx)
        uint32_t d = 0x20;
        DATA_BLOB db = { (uint8_t *)&d, sizeof(d) };
        torture_assert_str_equal(ctx, "0x20",
-                                reg_val_data_string(ctx, REG_DWORD, db),
+                                reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD, db),
                                 "dword failed");
        return true;
 }
@@ -56,11 +56,11 @@ static bool test_reg_val_data_string_sz(struct torture_context *ctx)
        db.length = convert_string_talloc(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UNIX, CH_UTF16,
                                          "bla", 3, (void **)&db.data);
        torture_assert_str_equal(ctx, "bla",
-                                reg_val_data_string(ctx, REG_SZ, db),
+                                reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
                                 "sz failed");
        db.length = 4;
        torture_assert_str_equal(ctx, "bl",
-                                reg_val_data_string(ctx, REG_SZ, db),
+                                reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
                                 "sz failed");
        return true;
 }
@@ -70,7 +70,7 @@ static bool test_reg_val_data_string_binary(struct torture_context *ctx)
        uint8_t x[] = { 0x1, 0x2, 0x3, 0x4 };
        DATA_BLOB db = { x, 4 };
        torture_assert_str_equal(ctx, "01020304",
-                                reg_val_data_string(ctx, REG_BINARY, db),
+                                reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
                                 "binary failed");
        return true;
 }
@@ -80,7 +80,7 @@ static bool test_reg_val_data_string_empty(struct torture_context *ctx)
 {
        DATA_BLOB db = { NULL, 0 };
        torture_assert_str_equal(ctx, "",
-                                reg_val_data_string(ctx, REG_BINARY, db),
+                                reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
                                 "empty failed");
        return true;
 }
@@ -93,7 +93,7 @@ static bool test_reg_val_description(struct torture_context *ctx)
                                            strlen("stationary traveller"),
                                            (void **)&data.data);
        torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
-                                reg_val_description(ctx, "camel", REG_SZ, data),
+                                reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), "camel", REG_SZ, data),
                                 "reg_val_description failed");
        return true;
 }
@@ -107,7 +107,7 @@ static bool test_reg_val_description_nullname(struct torture_context *ctx)
                                            strlen("west berlin"),
                                            (void **)&data.data);
        torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
-                                reg_val_description(ctx, NULL, REG_SZ, data),
+                                reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), NULL, REG_SZ, data),
                                 "description with null name failed");
        return true;
 }
index d5c506a..58f64cb 100644 (file)
@@ -141,7 +141,8 @@ static WERROR cmd_set(struct regshell_context *ctx, int argc, char **argv)
                return WERR_INVALID_PARAM;
        }
 
-       if (!reg_string_to_val(ctx, argv[2], argv[3], &val.data_type,
+       if (!reg_string_to_val(ctx, lp_iconv_convenience(cmdline_lp_ctx), 
+                              argv[2], argv[3], &val.data_type,
                               &val.data)) {
                fprintf(stderr, "Unable to interpret data\n");
                return WERR_INVALID_PARAM;
@@ -199,7 +200,7 @@ static WERROR cmd_print(struct regshell_context *ctx, int argc, char **argv)
        }
 
        printf("%s\n%s\n", str_regtype(value_type),
-                  reg_val_data_string(ctx, value_type, value_data));
+                  reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), value_type, value_data));
 
        return WERR_OK;
 }
@@ -233,7 +234,7 @@ static WERROR cmd_ls(struct regshell_context *ctx, int argc, char **argv)
                                                                     &data_type,
                                                                     &data)); i++) {
                printf("V \"%s\" %s %s\n", name, str_regtype(data_type),
-                          reg_val_data_string(ctx, data_type, data));
+                          reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), data_type, data));
        }
 
        return WERR_OK;
index 0f47d8f..424d351 100644 (file)
@@ -82,7 +82,7 @@ static void print_tree(int level, struct registry_key *p,
                        int j;
                        char *desc;
                        for(j = 0; j < level+1; j++) putchar(' ');
-                       desc = reg_val_description(mem_ctx, valuename,
+                       desc = reg_val_description(mem_ctx, lp_iconv_convenience(cmdline_lp_ctx), valuename,
                                                   value_type, value_data);
                        printf("%s\n", desc);
                }
index a251ae4..68efd56 100644 (file)
@@ -51,7 +51,9 @@ _PUBLIC_ const char *str_regtype(int type)
        return "Unknown";
 }
 
-_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, 
+                                  struct smb_iconv_convenience *iconv_convenience,
+                                  uint32_t type,
                                   const DATA_BLOB data)
 {
        char *ret = NULL;
@@ -62,7 +64,7 @@ _PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
        switch (type) {
                case REG_EXPAND_SZ:
                case REG_SZ:
-                       convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX,
+                       convert_string_talloc(mem_ctx, iconv_convenience, CH_UTF16, CH_UNIX,
                                              data.data, data.length,
                                              (void **)&ret);
                        return ret;
@@ -85,16 +87,20 @@ _PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
 }
 
 /** Generate a string that describes a registry value */
-_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
+_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx, 
+                                  struct smb_iconv_convenience *iconv_convenience, 
+                                  const char *name,
                                   uint32_t data_type,
                                   const DATA_BLOB data)
 {
        return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
                               str_regtype(data_type),
-                              reg_val_data_string(mem_ctx, data_type, data));
+                              reg_val_data_string(mem_ctx, iconv_convenience, data_type, data));
 }
 
-_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, 
+                               struct smb_iconv_convenience *iconv_convenience,
+                               const char *type_str,
                                const char *data_str, uint32_t *type,
                                DATA_BLOB *data)
 {
@@ -118,7 +124,7 @@ _PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
        {
                case REG_SZ:
                case REG_EXPAND_SZ:
-               data->length = convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UNIX, CH_UTF16,
+               data->length = convert_string_talloc(mem_ctx, iconv_convenience, CH_UNIX, CH_UTF16,
                                                     data_str, strlen(data_str),
                                                     (void **)&data->data);
                        break;
index 1386f61..95252e7 100644 (file)
@@ -3269,7 +3269,8 @@ static NTSTATUS torture_samba3_setconfig(struct smbcli_state *cli,
                goto done;
        }
 
-       if (!reg_string_to_val(hklm, "REG_SZ", value, &type, &val)) {
+       if (!reg_string_to_val(hklm, lp_iconv_convenience(lp_ctx), "REG_SZ", 
+                              value, &type, &val)) {
                d_printf("(%s) reg_string_to_val failed\n", __location__);
                goto done;
        }