Add a new non-convenience version of push_codepoint.

diff --git a/lib/util/charset/charcnv.c b/lib/util/charset/charcnv.c
index 94d47a9f7f098b9f9f7bee3d60d1581d78d69f77..a479f4442653eb4aa9907d7047d53987cd30ed04 100644 (file)
--- a/lib/util/charset/charcnv.c
+++ b/lib/util/charset/charcnv.c
@@ -430,7 +430,7 @@ _PUBLIC_ codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic
   return the number of bytes occupied by the CH_UNIX character, or
   -1 on failure
 */
-_PUBLIC_ ssize_t push_codepoint(struct smb_iconv_convenience *ic, 
+_PUBLIC_ ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic, 
                                char *str, codepoint_t c)
 {
        smb_iconv_t descriptor;
@@ -478,3 +478,5 @@ _PUBLIC_ ssize_t push_codepoint(struct smb_iconv_convenience *ic,
        }
        return 5 - olen;
 }
+
+

diff --git a/lib/util/charset/charset.h b/lib/util/charset/charset.h
index 37c5acafafa105614ad0120939c5fc8c46aa0fd1..2c8aa41ad5c78287c4ce627b4664dfaacfbef0b9 100644 (file)
--- a/lib/util/charset/charset.h
+++ b/lib/util/charset/charset.h
@@ -151,11 +151,12 @@ ssize_t iconv_talloc(TALLOC_CTX *mem_ctx,
 extern struct smb_iconv_convenience *global_iconv_convenience;
 
 codepoint_t next_codepoint(const char *str, size_t *size);
+ssize_t push_codepoint(char *str, codepoint_t c);
 
 /* codepoints */
 codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic, 
                            const char *str, size_t *size);
-ssize_t push_codepoint(struct smb_iconv_convenience *ic, 
+ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic, 
                                char *str, codepoint_t c);
 codepoint_t toupper_m(codepoint_t val);
 codepoint_t tolower_m(codepoint_t val);

diff --git a/lib/util/charset/tests/iconv.c b/lib/util/charset/tests/iconv.c
index 091876f63b674998114ff0acafedf91954a75b44..e8d7bc138406b123908acfec0bc565e5db6c7f0a 100644 (file)
--- a/lib/util/charset/tests/iconv.c
+++ b/lib/util/charset/tests/iconv.c
@@ -288,7 +288,7 @@ static bool test_codepoint(struct torture_context *tctx, unsigned int codepoint)
        size_t size, size2;
        codepoint_t c;
 
-       size = push_codepoint(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
+       size = push_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
        torture_assert(tctx, size != -1 || (codepoint >= 0xd800 && codepoint <= 0x10000), 
                       "Invalid Codepoint range");
 

diff --git a/lib/util/charset/util_unistr.c b/lib/util/charset/util_unistr.c
index ea2bfeab9f1556c30fd483dfdf99bd2d29856d9a..812129cffbcb67b51e318e077e48fb72770d8c44 100644 (file)
--- a/lib/util/charset/util_unistr.c
+++ b/lib/util/charset/util_unistr.c
@@ -444,7 +444,7 @@ _PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
 
                c = tolower_m(c);
 
-               c_size = push_codepoint(iconv_convenience, dest+size, c);
+               c_size = push_codepoint_convenience(iconv_convenience, dest+size, c);
                if (c_size == -1) {
                        talloc_free(dest);
                        return NULL;
@@ -490,7 +490,7 @@ _PUBLIC_ char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n)
 
                c = toupper_m(c);
 
-               c_size = push_codepoint(iconv_convenience, dest+size, c);
+               c_size = push_codepoint_convenience(iconv_convenience, dest+size, c);
                if (c_size == -1) {
                        talloc_free(dest);
                        return NULL;
@@ -551,7 +551,7 @@ _PUBLIC_ void strlower_m(char *s)
        while (*s) {
                size_t c_size, c_size2;
                codepoint_t c = next_codepoint_convenience(iconv_convenience, s, &c_size);
-               c_size2 = push_codepoint(iconv_convenience, d, tolower_m(c));
+               c_size2 = push_codepoint_convenience(iconv_convenience, d, tolower_m(c));
                if (c_size2 > c_size) {
                        DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
                                 c, tolower_m(c), (int)c_size, (int)c_size2));
@@ -590,7 +590,7 @@ _PUBLIC_ void strupper_m(char *s)
        while (*s) {
                size_t c_size, c_size2;
                codepoint_t c = next_codepoint_convenience(iconv_convenience, s, &c_size);
-               c_size2 = push_codepoint(iconv_convenience, d, toupper_m(c));
+               c_size2 = push_codepoint_convenience(iconv_convenience, d, toupper_m(c));
                if (c_size2 > c_size) {
                        DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
                                 c, toupper_m(c), (int)c_size, (int)c_size2));
@@ -992,3 +992,8 @@ _PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
 {
        return next_codepoint_convenience(get_iconv_convenience(), str, size);
 }
+
+_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
+       return push_codepoint(get_iconv_convenience(), str, c);
+}

diff --git a/source4/lib/registry/patchfile_preg.c b/source4/lib/registry/patchfile_preg.c
index e9801bb4250952e2006c60477ad48bd7b732932e..30a9aea2a5cd8030c13fc80d1a16749a755f8352 100644 (file)
--- a/source4/lib/registry/patchfile_preg.c
+++ b/source4/lib/registry/patchfile_preg.c
@@ -27,27 +27,26 @@
 struct preg_data {
        int fd;
        TALLOC_CTX *ctx;
-       struct smb_iconv_convenience *ic;
 };
 
-static WERROR preg_read_utf16(struct smb_iconv_convenience *ic, int fd, char *c)
+static WERROR preg_read_utf16(int fd, char *c)
 {
        uint16_t v;
 
        if (read(fd, &v, 2) < 2) {
                return WERR_GENERAL_FAILURE;
        }
-       push_codepoint(ic, c, v);
+       push_codepoint(c, v);
        return WERR_OK;
 }
-static WERROR preg_write_utf16(struct smb_iconv_convenience *ic, int fd, const char *string)
+static WERROR preg_write_utf16(int fd, const char *string)
 {
        codepoint_t v;
        uint16_t i;
        size_t size;
 
        for (i = 0; i < strlen(string); i+=size) {
-               v = next_codepoint_convenience(ic, &string[i], &size);
+               v = next_codepoint(&string[i], &size);
                if (write(fd, &v, 2) < 2) {
                        return WERR_GENERAL_FAILURE;
                }
@@ -67,19 +66,19 @@ static WERROR reg_preg_diff_set_value(void *_data, const char *key_name,
        struct preg_data *data = (struct preg_data *)_data;
        uint32_t buf;
        
-       preg_write_utf16(data->ic, data->fd, "[");
-       preg_write_utf16(data->ic, data->fd, key_name);
-       preg_write_utf16(data->ic, data->fd, ";");
-       preg_write_utf16(data->ic, data->fd, value_name);
-       preg_write_utf16(data->ic, data->fd, ";");
+       preg_write_utf16(data->fd, "[");
+       preg_write_utf16(data->fd, key_name);
+       preg_write_utf16(data->fd, ";");
+       preg_write_utf16(data->fd, value_name);
+       preg_write_utf16(data->fd, ";");
        SIVAL(&buf, 0, value_type);
        write(data->fd, &buf, sizeof(uint32_t));
-       preg_write_utf16(data->ic, data->fd, ";");
+       preg_write_utf16(data->fd, ";");
        SIVAL(&buf, 0, value_data.length);
        write(data->fd, &buf, sizeof(uint32_t));
-       preg_write_utf16(data->ic, data->fd, ";");
+       preg_write_utf16(data->fd, ";");
        write(data->fd, value_data.data, value_data.length);
-       preg_write_utf16(data->ic, data->fd, "]");
+       preg_write_utf16(data->fd, "]");
        
        return WERR_OK;
 }
@@ -169,7 +168,6 @@ _PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
        write(data->fd, (uint8_t *)&preg_header,8);
 
        data->ctx = ctx;
-       data->ic = ic;
 
        *callbacks = talloc(ctx, struct reg_diff_callbacks);
 
@@ -228,7 +226,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
        while(1) {
                uint32_t value_type, length;
 
-               if (!W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr))) {
+               if (!W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr))) {
                        break;
                }
                if (*buf_ptr != '[') {
@@ -239,7 +237,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
 
                /* Get the path */
                buf_ptr = buf;
-               while (W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
+               while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
                       *buf_ptr != ';' && buf_ptr-buf < buf_size) {
                        buf_ptr++;
                }
@@ -248,7 +246,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
 
                /* Get the name */
                buf_ptr = buf;
-               while (W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
+               while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
                       *buf_ptr != ';' && buf_ptr-buf < buf_size) {
                        buf_ptr++;
                }
@@ -265,7 +263,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
 
                /* Read past delimiter */
                buf_ptr = buf;
-               if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
+               if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
                    *buf_ptr == ';') && buf_ptr-buf < buf_size) {
                        DEBUG(0, ("Error in PReg file.\n"));
                        ret = WERR_GENERAL_FAILURE;
@@ -279,7 +277,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
                }
                /* Read past delimiter */
                buf_ptr = buf;
-               if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
+               if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
                    *buf_ptr == ';') && buf_ptr-buf < buf_size) {
                        DEBUG(0, ("Error in PReg file.\n"));
                        ret = WERR_GENERAL_FAILURE;
@@ -297,7 +295,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
 
                /* Check if delimiter is in place (whine if it isn't) */
                buf_ptr = buf;
-               if (!(W_ERROR_IS_OK(preg_read_utf16(iconv_convenience, fd, buf_ptr)) &&
+               if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
                    *buf_ptr == ']') && buf_ptr-buf < buf_size) {
                        DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",
                                *buf_ptr, *buf_ptr));

diff --git a/source4/ntvfs/posix/pvfs_rename.c b/source4/ntvfs/posix/pvfs_rename.c
index 7f8eab5aa0b6e3c36a323a8025e348149a65e89c..0616d38bee59e226e05ad0c6c8c909fd6885c7c2 100644 (file)
--- a/source4/ntvfs/posix/pvfs_rename.c
+++ b/source4/ntvfs/posix/pvfs_rename.c
@@ -118,13 +118,13 @@ static const char *pvfs_resolve_wildcard_component(TALLOC_CTX *mem_ctx,
                c1 = next_codepoint_convenience(iconv_convenience, p1, &c_size1);
                c2 = next_codepoint_convenience(iconv_convenience, p2, &c_size2);
                if (c2 == '?') {
-                       d += push_codepoint(iconv_convenience, d, c1);
+                       d += push_codepoint_convenience(iconv_convenience, d, c1);
                } else if (c2 == '*') {
                        memcpy(d, p1, strlen(p1));
                        d += strlen(p1);
                        break;
                } else {
-                       d += push_codepoint(iconv_convenience, d, c2);
+                       d += push_codepoint_convenience(iconv_convenience, d, c2);
                }
 
                p1 += c_size1;