Changeset 124 for branches/samba-3.0/source/lib

Timestamp:

Mar 12, 2008, 9:08:18 AM (18 years ago)

Author:

Paul Smedley

Message:

Update source to 3.0.28a

Location:

branches/samba-3.0/source/lib

Files:

• charcnv.c (modified) (34 diffs)
• clobber.c (modified) (1 diff)
• debug.c (modified) (2 diffs)
• replace/getpass.c (modified) (2 diffs)
• replace/getpass.m4 (modified) (2 diffs)
• replace/libreplace.m4 (modified) (1 diff)
• replace/system/network.h (modified) (1 diff)
• system.c (modified) (3 diffs)
• util_str.c (modified) (3 diffs)

branches/samba-3.0/source/lib/charcnv.c

@@ -28 +28 @@
 char lp_failed_convert_char(void)
 {
-    return '_';
+        return '_';
 }
 
@@ -55 +55 @@
 static const char *charset_name(charset_t ch)
 {
-    const char *ret = NULL;
-
-    if (ch == CH_UTF16LE) ret = "UTF-16LE";
-    else if (ch == CH_UTF16BE) ret = "UTF-16BE";
-    else if (ch == CH_UNIX) ret = lp_unix_charset();
-    else if (ch == CH_DOS) ret = lp_dos_charset();
-    else if (ch == CH_DISPLAY) ret = lp_display_charset();
-    else if (ch == CH_UTF8) ret = "UTF8";
+        const char *ret = NULL;
+
+        if (ch == CH_UTF16LE) ret = "UTF-16LE";
+        else if (ch == CH_UTF16BE) ret = "UTF-16BE";
+        else if (ch == CH_UNIX) ret = lp_unix_charset();
+        else if (ch == CH_DOS) ret = lp_dos_charset();
+        else if (ch == CH_DISPLAY) ret = lp_display_charset();
+        else if (ch == CH_UTF8) ret = "UTF8";
 
 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
-    if (ret && !strcmp(ret, "LOCALE")) {
-        const char *ln = NULL;
+        if (ret && !strcmp(ret, "LOCALE")) {
+                const char *ln = NULL;
 
 #ifdef HAVE_SETLOCALE
-        setlocale(LC_ALL, "");
+                setlocale(LC_ALL, "");
 #endif
-        ln = nl_langinfo(CODESET);
-        if (ln) {
-            /* Check whether the charset name is supported
-               by iconv */
-            smb_iconv_t handle = smb_iconv_open(ln,"UCS-2LE");
-            if (handle == (smb_iconv_t) -1) {
-                DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
-                ln = NULL;
-            } else {
-                DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
-                smb_iconv_close(handle);
-            }
-        }
-        ret = ln;
-    }
+                ln = nl_langinfo(CODESET);
+                if (ln) {
+                        /* Check whether the charset name is supported
+                           by iconv */
+                        smb_iconv_t handle = smb_iconv_open(ln,"UCS-2LE");
+                        if (handle == (smb_iconv_t) -1) {
+                                DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
+                                ln = NULL;
+                        } else {
+                                DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
+                                smb_iconv_close(handle);
+                        }
+                }
+                ret = ln;
+        }
 #endif
 
-    if (!ret || !*ret) ret = "ASCII";
-    return ret;
+        if (!ret || !*ret) ret = "ASCII";
+        return ret;
 }
 
 void lazy_initialize_conv(void)
 {
-    static int initialized = False;
-
-    if (!initialized) {
-        initialized = True;
-        load_case_tables();
-        init_iconv();
-    }
+        static int initialized = False;
+
+        if (!initialized) {
+                initialized = True;
+                load_case_tables();
+                init_iconv();
+        }
 }
 
@@ -108 +108 @@
 void gfree_charcnv(void)
 {
-    int c1, c2;
-
-    for (c1=0;c1<NUM_CHARSETS;c1++) {
-        for (c2=0;c2<NUM_CHARSETS;c2++) {
-            if ( conv_handles[c1][c2] ) {
-                smb_iconv_close( conv_handles[c1][c2] );
-                conv_handles[c1][c2] = 0;
-            }
-        }
-    }
+        int c1, c2;
+
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        if ( conv_handles[c1][c2] ) {
+                                smb_iconv_close( conv_handles[c1][c2] );
+                                conv_handles[c1][c2] = 0;
+                        }
+                }
+        }
 }
 
@@ -129 +129 @@
 void init_iconv(void)
 {
-    int c1, c2;
-    BOOL did_reload = False;
-
-    /* so that charset_name() works we need to get the UNIX<->UCS2 going
-       first */
-    if (!conv_handles[CH_UNIX][CH_UTF16LE])
-        conv_handles[CH_UNIX][CH_UTF16LE] = smb_iconv_open(charset_name(CH_UTF16LE), "ASCII");
-
-    if (!conv_handles[CH_UTF16LE][CH_UNIX])
-        conv_handles[CH_UTF16LE][CH_UNIX] = smb_iconv_open("ASCII", charset_name(CH_UTF16LE));
-
-    for (c1=0;c1<NUM_CHARSETS;c1++) {
-        for (c2=0;c2<NUM_CHARSETS;c2++) {
-            const char *n1 = charset_name((charset_t)c1);
-            const char *n2 = charset_name((charset_t)c2);
-            if (conv_handles[c1][c2] &&
-                strcmp(n1, conv_handles[c1][c2]->from_name) == 0 &&
-                strcmp(n2, conv_handles[c1][c2]->to_name) == 0)
-                continue;
-
-            did_reload = True;
-
-            if (conv_handles[c1][c2])
-                smb_iconv_close(conv_handles[c1][c2]);
-
-            conv_handles[c1][c2] = smb_iconv_open(n2,n1);
-            if (conv_handles[c1][c2] == (smb_iconv_t)-1) {
-                DEBUG(0,("init_iconv: Conversion from %s to %s not supported\n",
-                     charset_name((charset_t)c1), charset_name((charset_t)c2)));
-                if (c1 != CH_UTF16LE && c1 != CH_UTF16BE) {
-                    n1 = "ASCII";
-                }
-                if (c2 != CH_UTF16LE && c2 != CH_UTF16BE) {
-                    n2 = "ASCII";
-                }
-                DEBUG(0,("init_iconv: Attempting to replace with conversion from %s to %s\n",
-                    n1, n2 ));
-                conv_handles[c1][c2] = smb_iconv_open(n2,n1);
-                if (!conv_handles[c1][c2]) {
-                    DEBUG(0,("init_iconv: Conversion from %s to %s failed", n1, n2));
-                    smb_panic("init_iconv: conv_handle initialization failed.");
-                }
-            }
-        }
-    }
-
-    if (did_reload) {
-        /* XXX: Does this really get called every time the dos
-         * codepage changes? */
-        /* XXX: Is the did_reload test too strict? */
-        conv_silent = True;
-        init_doschar_table();
-        init_valid_table();
-        conv_silent = False;
-    }
+        int c1, c2;
+        BOOL did_reload = False;
+
+        /* so that charset_name() works we need to get the UNIX<->UCS2 going
+           first */
+        if (!conv_handles[CH_UNIX][CH_UTF16LE])
+                conv_handles[CH_UNIX][CH_UTF16LE] = smb_iconv_open(charset_name(CH_UTF16LE), "ASCII");
+
+        if (!conv_handles[CH_UTF16LE][CH_UNIX])
+                conv_handles[CH_UTF16LE][CH_UNIX] = smb_iconv_open("ASCII", charset_name(CH_UTF16LE));
+
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        const char *n1 = charset_name((charset_t)c1);
+                        const char *n2 = charset_name((charset_t)c2);
+                        if (conv_handles[c1][c2] &&
+                                strcmp(n1, conv_handles[c1][c2]->from_name) == 0 &&
+                                strcmp(n2, conv_handles[c1][c2]->to_name) == 0)
+                                continue;
+
+                        did_reload = True;
+
+                        if (conv_handles[c1][c2])
+                                smb_iconv_close(conv_handles[c1][c2]);
+
+                        conv_handles[c1][c2] = smb_iconv_open(n2,n1);
+                        if (conv_handles[c1][c2] == (smb_iconv_t)-1) {
+                                DEBUG(0,("init_iconv: Conversion from %s to %s not supported\n",
+                                         charset_name((charset_t)c1), charset_name((charset_t)c2)));
+                                if (c1 != CH_UTF16LE && c1 != CH_UTF16BE) {
+                                        n1 = "ASCII";
+                                }
+                                if (c2 != CH_UTF16LE && c2 != CH_UTF16BE) {
+                                        n2 = "ASCII";
+                                }
+                                DEBUG(0,("init_iconv: Attempting to replace with conversion from %s to %s\n",
+                                        n1, n2 ));
+                                conv_handles[c1][c2] = smb_iconv_open(n2,n1);
+                                if (!conv_handles[c1][c2]) {
+                                        DEBUG(0,("init_iconv: Conversion from %s to %s failed", n1, n2));
+                                        smb_panic("init_iconv: conv_handle initialization failed.");
+                                }
+                        }
+                }
+        }
+
+        if (did_reload) {
+                /* XXX: Does this really get called every time the dos
+                 * codepage changes? */
+                /* XXX: Is the did_reload test too strict? */
+                conv_silent = True;
+                init_doschar_table();
+                init_valid_table();
+                conv_silent = False;
+        }
 }
 
@@ -202 +202 @@
 
 static size_t convert_string_internal(charset_t from, charset_t to,
-              void const *src, size_t srclen,
-              void *dest, size_t destlen, BOOL allow_bad_conv)
-{
-    size_t i_len, o_len;
-    size_t retval;
-    const char* inbuf = (const char*)src;
-    char* outbuf = (char*)dest;
-    smb_iconv_t descriptor;
-
-    lazy_initialize_conv();
-
-    descriptor = conv_handles[from][to];
-
-    if (srclen == (size_t)-1) {
-        if (from == CH_UTF16LE || from == CH_UTF16BE) {
-            srclen = (strlen_w((const smb_ucs2_t *)src)+1) * 2;
-        } else {
-            srclen = strlen((const char *)src)+1;
-        }
-    }
-
-
-    if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
-        if (!conv_silent)
-            DEBUG(0,("convert_string_internal: Conversion not supported.\n"));
-        return (size_t)-1;
-    }
-
-    i_len=srclen;
-    o_len=destlen;
+                          void const *src, size_t srclen,
+                          void *dest, size_t destlen, BOOL allow_bad_conv)
+{
+        size_t i_len, o_len;
+        size_t retval;
+        const char* inbuf = (const char*)src;
+        char* outbuf = (char*)dest;
+        smb_iconv_t descriptor;
+
+        lazy_initialize_conv();
+
+        descriptor = conv_handles[from][to];
+
+        if (srclen == (size_t)-1) {
+                if (from == CH_UTF16LE || from == CH_UTF16BE) {
+                        srclen = (strlen_w((const smb_ucs2_t *)src)+1) * 2;
+                } else {
+                        srclen = strlen((const char *)src)+1;
+                }
+        }
+
+
+        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
+                if (!conv_silent)
+                        DEBUG(0,("convert_string_internal: Conversion not supported.\n"));
+                return (size_t)-1;
+        }
+
+        i_len=srclen;
+        o_len=destlen;
 
  again:
 
-    retval = smb_iconv(descriptor, &inbuf, &i_len, &outbuf, &o_len);
-    if(retval==(size_t)-1) {
-            const char *reason="unknown error";
-        switch(errno) {
-            case EINVAL:
-                reason="Incomplete multibyte sequence";
-                if (!conv_silent)
-                    DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
-                if (allow_bad_conv)
-                    goto use_as_is;
-                break;
-            case E2BIG:
-                reason="No more room";
-                if (!conv_silent) {
-                    if (from == CH_UNIX) {
-                        DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
-                            charset_name(from), charset_name(to),
-                            (unsigned int)srclen, (unsigned int)destlen, (const char *)src));
-                    } else {
-                        DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
-                            charset_name(from), charset_name(to),
-                            (unsigned int)srclen, (unsigned int)destlen));
-                    }
-                }
-                break;
-            case EILSEQ:
-                reason="Illegal multibyte sequence";
-                if (!conv_silent)
-                    DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
-                if (allow_bad_conv)
-                    goto use_as_is;
-                break;
-            default:
-                if (!conv_silent)
-                    DEBUG(0,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
-                break;
-        }
-        /* smb_panic(reason); */
-    }
-    return destlen-o_len;
+        retval = smb_iconv(descriptor, &inbuf, &i_len, &outbuf, &o_len);
+        if(retval==(size_t)-1) {
+                        const char *reason="unknown error";
+                switch(errno) {
+                        case EINVAL:
+                                reason="Incomplete multibyte sequence";
+                                if (!conv_silent)
+                                        DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
+                                if (allow_bad_conv)
+                                        goto use_as_is;
+                                break;
+                        case E2BIG:
+                                reason="No more room";
+                                if (!conv_silent) {
+                                        if (from == CH_UNIX) {
+                                                DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
+                                                        charset_name(from), charset_name(to),
+                                                        (unsigned int)srclen, (unsigned int)destlen, (const char *)src));
+                                        } else {
+                                                DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
+                                                        charset_name(from), charset_name(to),
+                                                        (unsigned int)srclen, (unsigned int)destlen));
+                                        }
+                                }
+                                break;
+                        case EILSEQ:
+                                reason="Illegal multibyte sequence";
+                                if (!conv_silent)
+                                        DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
+                                if (allow_bad_conv)
+                                        goto use_as_is;
+                                break;
+                        default:
+                                if (!conv_silent)
+                                        DEBUG(0,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
+                                break;
+                }
+                /* smb_panic(reason); */
+        }
+        return destlen-o_len;
 
  use_as_is:
 
-    /*
-     * Conversion not supported. This is actually an error, but there are so
-     * many misconfigured iconv systems and smb.conf's out there we can't just
-     * fail. Do a very bad conversion instead.... JRA.
-     */
-
-    {
-        if (o_len == 0 || i_len == 0)
-            return destlen - o_len;
-
-        if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
-                ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
-            /* Can't convert from utf16 any endian to multibyte.
-               Replace with the default fail char.
-            */
-            if (i_len < 2)
-                return destlen - o_len;
-            if (i_len >= 2) {
-                *outbuf = lp_failed_convert_char();
-
-                outbuf++;
-                o_len--;
-
-                inbuf += 2;
-                i_len -= 2;
-            }
-
-            if (o_len == 0 || i_len == 0)
-                return destlen - o_len;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
-            /* Can't convert to UTF16LE - just widen by adding the
-               default fail char then zero.
-            */
-            if (o_len < 2)
-                return destlen - o_len;
-
-            outbuf[0] = lp_failed_convert_char();
-            outbuf[1] = '\0';
-
-            inbuf++;
-            i_len--;
-
-            outbuf += 2;
-            o_len -= 2;
-
-            if (o_len == 0 || i_len == 0)
-                return destlen - o_len;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
-                to != CH_UTF16LE && to != CH_UTF16BE) {
-            /* Failed multibyte to multibyte. Just copy the default fail char and
-                try again. */
-            outbuf[0] = lp_failed_convert_char();
-
-            inbuf++;
-            i_len--;
-
-            outbuf++;
-            o_len--;
-
-            if (o_len == 0 || i_len == 0)
-                return destlen - o_len;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else {
-            /* Keep compiler happy.... */
-            return destlen - o_len;
-        }
-    }
+        /*
+         * Conversion not supported. This is actually an error, but there are so
+         * many misconfigured iconv systems and smb.conf's out there we can't just
+         * fail. Do a very bad conversion instead.... JRA.
+         */
+
+        {
+                if (o_len == 0 || i_len == 0)
+                        return destlen - o_len;
+
+                if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
+                                ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
+                        /* Can't convert from utf16 any endian to multibyte.
+                           Replace with the default fail char.
+                        */
+                        if (i_len < 2)
+                                return destlen - o_len;
+                        if (i_len >= 2) {
+                                *outbuf = lp_failed_convert_char();
+
+                                outbuf++;
+                                o_len--;
+
+                                inbuf += 2;
+                                i_len -= 2;
+                        }
+
+                        if (o_len == 0 || i_len == 0)
+                                return destlen - o_len;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
+                        /* Can't convert to UTF16LE - just widen by adding the
+                           default fail char then zero.
+                        */
+                        if (o_len < 2)
+                                return destlen - o_len;
+
+                        outbuf[0] = lp_failed_convert_char();
+                        outbuf[1] = '\0';
+
+                        inbuf++;
+                        i_len--;
+
+                        outbuf += 2;
+                        o_len -= 2;
+
+                        if (o_len == 0 || i_len == 0)
+                                return destlen - o_len;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
+                                to != CH_UTF16LE && to != CH_UTF16BE) {
+                        /* Failed multibyte to multibyte. Just copy the default fail char and
+                                try again. */
+                        outbuf[0] = lp_failed_convert_char();
+
+                        inbuf++;
+                        i_len--;
+
+                        outbuf++;
+                        o_len--;
+
+                        if (o_len == 0 || i_len == 0)
+                                return destlen - o_len;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else {
+                        /* Keep compiler happy.... */
+                        return destlen - o_len;
+                }
+        }
 }
 
@@ -376 +376 @@
 
 size_t convert_string(charset_t from, charset_t to,
-              void const *src, size_t srclen,
-              void *dest, size_t destlen, BOOL allow_bad_conv)
-{
-    /*
-     * NB. We deliberately don't do a strlen here if srclen == -1.
-     * This is very expensive over millions of calls and is taken
-     * care of in the slow path in convert_string_internal. JRA.
-     */
+                          void const *src, size_t srclen,
+                          void *dest, size_t destlen, BOOL allow_bad_conv)
+{
+        /*
+         * NB. We deliberately don't do a strlen here if srclen == -1.
+         * This is very expensive over millions of calls and is taken
+         * care of in the slow path in convert_string_internal. JRA.
+         */
 
 #ifdef DEVELOPER
-    SMB_ASSERT(destlen != (size_t)-1);
+        SMB_ASSERT(destlen != (size_t)-1);
 #endif
 
-    if (srclen == 0)
-        return 0;
-
-    if (from != CH_UTF16LE && from != CH_UTF16BE && to != CH_UTF16LE && to != CH_UTF16BE) {
-        const unsigned char *p = (const unsigned char *)src;
-        unsigned char *q = (unsigned char *)dest;
-        size_t slen = srclen;
-        size_t dlen = destlen;
-        unsigned char lastp = '\0';
-        size_t retval = 0;
-
-        /* If all characters are ascii, fast path here. */
-        while (slen && dlen) {
-            if ((lastp = *p) <= 0x7f) {
-                *q++ = *p++;
-                if (slen != (size_t)-1) {
-                    slen--;
-                }
-                dlen--;
-                retval++;
-                if (!lastp)
-                    break;
-            } else {
+        if (srclen == 0)
+                return 0;
+
+        if (from != CH_UTF16LE && from != CH_UTF16BE && to != CH_UTF16LE && to != CH_UTF16BE) {
+                const unsigned char *p = (const unsigned char *)src;
+                unsigned char *q = (unsigned char *)dest;
+                size_t slen = srclen;
+                size_t dlen = destlen;
+                unsigned char lastp = '\0';
+                size_t retval = 0;
+
+                /* If all characters are ascii, fast path here. */
+                while (slen && dlen) {
+                        if ((lastp = *p) <= 0x7f) {
+                                *q++ = *p++;
+                                if (slen != (size_t)-1) {
+                                        slen--;
+                                }
+                                dlen--;
+                                retval++;
+                                if (!lastp)
+                                        break;
+                        } else {
 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
-                goto general_case;
+                                goto general_case;
 #else
-                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+                                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
 #endif
-            }
-        }
-        if (!dlen) {
-            /* Even if we fast path we should note if we ran out of room. */
-            if (((slen != (size_t)-1) && slen) ||
-                    ((slen == (size_t)-1) && lastp)) {
-                errno = E2BIG;
-            }
-        }
-        return retval;
-    } else if (from == CH_UTF16LE && to != CH_UTF16LE) {
-        const unsigned char *p = (const unsigned char *)src;
-        unsigned char *q = (unsigned char *)dest;
-        size_t retval = 0;
-        size_t slen = srclen;
-        size_t dlen = destlen;
-        unsigned char lastp = '\0';
-
-        /* If all characters are ascii, fast path here. */
-        while (((slen == (size_t)-1) || (slen >= 2)) && dlen) {
-            if (((lastp = *p) <= 0x7f) && (p[1] == 0)) {
-                *q++ = *p;
-                if (slen != (size_t)-1) {
-                    slen -= 2;
-                }
-                p += 2;
-                dlen--;
-                retval++;
-                if (!lastp)
-                    break;
-            } else {
+                        }
+                }
+                if (!dlen) {
+                        /* Even if we fast path we should note if we ran out of room. */
+                        if (((slen != (size_t)-1) && slen) ||
+                                        ((slen == (size_t)-1) && lastp)) {
+                                errno = E2BIG;
+                        }
+                }
+                return retval;
+        } else if (from == CH_UTF16LE && to != CH_UTF16LE) {
+                const unsigned char *p = (const unsigned char *)src;
+                unsigned char *q = (unsigned char *)dest;
+                size_t retval = 0;
+                size_t slen = srclen;
+                size_t dlen = destlen;
+                unsigned char lastp = '\0';
+
+                /* If all characters are ascii, fast path here. */
+                while (((slen == (size_t)-1) || (slen >= 2)) && dlen) {
+                        if (((lastp = *p) <= 0x7f) && (p[1] == 0)) {
+                                *q++ = *p;
+                                if (slen != (size_t)-1) {
+                                        slen -= 2;
+                                }
+                                p += 2;
+                                dlen--;
+                                retval++;
+                                if (!lastp)
+                                        break;
+                        } else {
 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
-                goto general_case;
+                                goto general_case;
 #else
-                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+                                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
 #endif
-            }
-        }
-        if (!dlen) {
-            /* Even if we fast path we should note if we ran out of room. */
-            if (((slen != (size_t)-1) && slen) ||
-                    ((slen == (size_t)-1) && lastp)) {
-                errno = E2BIG;
-            }
-        }
-        return retval;
-    } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
-        const unsigned char *p = (const unsigned char *)src;
-        unsigned char *q = (unsigned char *)dest;
-        size_t retval = 0;
-        size_t slen = srclen;
-        size_t dlen = destlen;
-        unsigned char lastp = '\0';
-
-        /* If all characters are ascii, fast path here. */
-        while (slen && (dlen >= 2)) {
-            if ((lastp = *p) <= 0x7F) {
-                *q++ = *p++;
-                *q++ = '\0';
-                if (slen != (size_t)-1) {
-                    slen--;
-                }
-                dlen -= 2;
-                retval += 2;
-                if (!lastp)
-                    break;
-            } else {
+                        }
+                }
+                if (!dlen) {
+                        /* Even if we fast path we should note if we ran out of room. */
+                        if (((slen != (size_t)-1) && slen) ||
+                                        ((slen == (size_t)-1) && lastp)) {
+                                errno = E2BIG;
+                        }
+                }
+                return retval;
+        } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
+                const unsigned char *p = (const unsigned char *)src;
+                unsigned char *q = (unsigned char *)dest;
+                size_t retval = 0;
+                size_t slen = srclen;
+                size_t dlen = destlen;
+                unsigned char lastp = '\0';
+
+                /* If all characters are ascii, fast path here. */
+                while (slen && (dlen >= 2)) {
+                        if ((lastp = *p) <= 0x7F) {
+                                *q++ = *p++;
+                                *q++ = '\0';
+                                if (slen != (size_t)-1) {
+                                        slen--;
+                                }
+                                dlen -= 2;
+                                retval += 2;
+                                if (!lastp)
+                                        break;
+                        } else {
 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
-                goto general_case;
+                                goto general_case;
 #else
-                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
+                                return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
 #endif
-            }
-        }
-        if (!dlen) {
-            /* Even if we fast path we should note if we ran out of room. */
-            if (((slen != (size_t)-1) && slen) ||
-                    ((slen == (size_t)-1) && lastp)) {
-                errno = E2BIG;
-            }
-        }
-        return retval;
-    }
+                        }
+                }
+                if (!dlen) {
+                        /* Even if we fast path we should note if we ran out of room. */
+                        if (((slen != (size_t)-1) && slen) ||
+                                        ((slen == (size_t)-1) && lastp)) {
+                                errno = E2BIG;
+                        }
+                }
+                return retval;
+        }
 
 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
   general_case:
 #endif
-    return convert_string_internal(from, to, src, srclen, dest, destlen, allow_bad_conv);
+        return convert_string_internal(from, to, src, srclen, dest, destlen, allow_bad_conv);
 }
 
@@ -524 +524 @@
 
 size_t convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
-                   void const *src, size_t srclen, void *dst, BOOL allow_bad_conv)
-{
-    size_t i_len, o_len, destlen = MAX(srclen, 512);
-    size_t retval;
-    const char *inbuf = (const char *)src;
-    char *outbuf = NULL, *ob = NULL;
-    smb_iconv_t descriptor;
-    void **dest = (void **)dst;
-
-    *dest = NULL;
-
-    if (src == NULL || srclen == (size_t)-1)
-        return (size_t)-1;
-    if (srclen == 0)
-        return 0;
-
-    lazy_initialize_conv();
-
-    descriptor = conv_handles[from][to];
-
-    if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
-        if (!conv_silent)
-            DEBUG(0,("convert_string_allocate: Conversion not supported.\n"));
-        return (size_t)-1;
-    }
+                                   void const *src, size_t srclen, void *dst, BOOL allow_bad_conv)
+{
+        size_t i_len, o_len, destlen = (srclen * 3) / 2;
+        size_t retval;
+        const char *inbuf = (const char *)src;
+        char *outbuf = NULL, *ob = NULL;
+        smb_iconv_t descriptor;
+        void **dest = (void **)dst;
+
+        *dest = NULL;
+
+        if (src == NULL || srclen == (size_t)-1)
+                return (size_t)-1;
+        if (srclen == 0)
+                return 0;
+
+        lazy_initialize_conv();
+
+        descriptor = conv_handles[from][to];
+
+        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
+                if (!conv_silent)
+                        DEBUG(0,("convert_string_allocate: Conversion not supported.\n"));
+                return (size_t)-1;
+        }
 
   convert:
 
-    if ((destlen*2) < destlen) {
-        /* wrapped ! abort. */
-        if (!conv_silent)
-            DEBUG(0, ("convert_string_allocate: destlen wrapped !\n"));
-        if (!ctx)
-            SAFE_FREE(outbuf);
-        return (size_t)-1;
-    } else {
-        destlen = destlen * 2;
-    }
-
-    if (ctx) {
-        ob = (char *)TALLOC_REALLOC(ctx, ob, destlen);
-    } else {
-        ob = (char *)SMB_REALLOC(ob, destlen);
-    }
-
-    if (!ob) {
-        DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
-        return (size_t)-1;
-    }
-    outbuf = ob;
-    i_len = srclen;
-    o_len = destlen;
+        /* +2 is for ucs2 null termination. */
+        if ((destlen*2)+2 < destlen) {
+                /* wrapped ! abort. */
+                if (!conv_silent)
+                        DEBUG(0, ("convert_string_allocate: destlen wrapped !\n"));
+                if (!ctx)
+                        SAFE_FREE(outbuf);
+                return (size_t)-1;
+        } else {
+                destlen = destlen * 2;
+        }
+
+        /* +2 is for ucs2 null termination. */
+        if (ctx) {
+                ob = (char *)TALLOC_REALLOC(ctx, ob, destlen + 2);
+        } else {
+                ob = (char *)SMB_REALLOC(ob, destlen + 2);
+        }
+
+        if (!ob) {
+                DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
+                return (size_t)-1;
+        }
+        outbuf = ob;
+        i_len = srclen;
+        o_len = destlen;
 
  again:
 
-    retval = smb_iconv(descriptor,
-               &inbuf, &i_len,
-               &outbuf, &o_len);
-    if(retval == (size_t)-1)        {
-            const char *reason="unknown error";
-        switch(errno) {
-            case EINVAL:
-                reason="Incomplete multibyte sequence";
-                if (!conv_silent)
-                    DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
-                if (allow_bad_conv)
-                    goto use_as_is;
-                break;
-            case E2BIG:
-                goto convert;
-            case EILSEQ:
-                reason="Illegal multibyte sequence";
-                if (!conv_silent)
-                    DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
-                if (allow_bad_conv)
-                    goto use_as_is;
-                break;
-        }
-        if (!conv_silent)
-            DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
-        /* smb_panic(reason); */
-        return (size_t)-1;
-    }
+        retval = smb_iconv(descriptor,
+                           &inbuf, &i_len,
+                           &outbuf, &o_len);
+        if(retval == (size_t)-1)                {
+                        const char *reason="unknown error";
+                switch(errno) {
+                        case EINVAL:
+                                reason="Incomplete multibyte sequence";
+                                if (!conv_silent)
+                                        DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
+                                if (allow_bad_conv)
+                                        goto use_as_is;
+                                break;
+                        case E2BIG:
+                                goto convert;
+                        case EILSEQ:
+                                reason="Illegal multibyte sequence";
+                                if (!conv_silent)
+                                        DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
+                                if (allow_bad_conv)
+                                        goto use_as_is;
+                                break;
+                }
+                if (!conv_silent)
+                        DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
+                /* smb_panic(reason); */
+                return (size_t)-1;
+        }
 
   out:
 
-    destlen = destlen - o_len;
-    if (ctx) {
-        ob = (char *)TALLOC_REALLOC(ctx,ob,destlen);
-    } else {
-        ob = (char *)SMB_REALLOC(ob,destlen);
-    }
-
-    if (destlen && !ob) {
-        DEBUG(0, ("convert_string_allocate: out of memory!\n"));
-        return (size_t)-1;
-    }
-
-    *dest = ob;
-    return destlen;
+        destlen = destlen - o_len;
+        if (ctx) {
+                /* We're shrinking here so we know the +2 is safe from wrap. */
+                ob = (char *)TALLOC_REALLOC(ctx,ob,destlen + 2);
+        } else {
+                ob = (char *)SMB_REALLOC(ob,destlen + 2);
+        }
+
+        if (destlen && !ob) {
+                DEBUG(0, ("convert_string_allocate: out of memory!\n"));
+                return (size_t)-1;
+        }
+
+        *dest = ob;
+
+        /* Must ucs2 null terminate in the extra space we allocated. */
+        ob[destlen] = '\0';
+        ob[destlen+1] = '\0';
+        return destlen;
 
  use_as_is:
 
-    /*
-     * Conversion not supported. This is actually an error, but there are so
-     * many misconfigured iconv systems and smb.conf's out there we can't just
-     * fail. Do a very bad conversion instead.... JRA.
-     */
-
-    {
-        if (o_len == 0 || i_len == 0)
-            goto out;
-
-        if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
-                ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
-            /* Can't convert from utf16 any endian to multibyte.
-               Replace with the default fail char.
-            */
-
-            if (i_len < 2)
-                goto out;
-
-            if (i_len >= 2) {
-                *outbuf = lp_failed_convert_char();
-
-                outbuf++;
-                o_len--;
-
-                inbuf += 2;
-                i_len -= 2;
-            }
-
-            if (o_len == 0 || i_len == 0)
-                goto out;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
-            /* Can't convert to UTF16LE - just widen by adding the
-               default fail char then zero.
-            */
-            if (o_len < 2)
-                goto out;
-
-            outbuf[0] = lp_failed_convert_char();
-            outbuf[1] = '\0';
-
-            inbuf++;
-            i_len--;
-
-            outbuf += 2;
-            o_len -= 2;
-
-            if (o_len == 0 || i_len == 0)
-                goto out;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
-                to != CH_UTF16LE && to != CH_UTF16BE) {
-            /* Failed multibyte to multibyte. Just copy the default fail char and
-               try again. */
-            outbuf[0] = lp_failed_convert_char();
-
-            inbuf++;
-            i_len--;
-
-            outbuf++;
-            o_len--;
-
-            if (o_len == 0 || i_len == 0)
-                goto out;
-
-            /* Keep trying with the next char... */
-            goto again;
-
-        } else {
-            /* Keep compiler happy.... */
-            goto out;
-        }
-    }
+        /*
+         * Conversion not supported. This is actually an error, but there are so
+         * many misconfigured iconv systems and smb.conf's out there we can't just
+         * fail. Do a very bad conversion instead.... JRA.
+         */
+
+        {
+                if (o_len == 0 || i_len == 0)
+                        goto out;
+
+                if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
+                                ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
+                        /* Can't convert from utf16 any endian to multibyte.
+                           Replace with the default fail char.
+                        */
+
+                        if (i_len < 2)
+                                goto out;
+
+                        if (i_len >= 2) {
+                                *outbuf = lp_failed_convert_char();
+
+                                outbuf++;
+                                o_len--;
+
+                                inbuf += 2;
+                                i_len -= 2;
+                        }
+
+                        if (o_len == 0 || i_len == 0)
+                                goto out;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
+                        /* Can't convert to UTF16LE - just widen by adding the
+                           default fail char then zero.
+                        */
+                        if (o_len < 2)
+                                goto out;
+
+                        outbuf[0] = lp_failed_convert_char();
+                        outbuf[1] = '\0';
+
+                        inbuf++;
+                        i_len--;
+
+                        outbuf += 2;
+                        o_len -= 2;
+
+                        if (o_len == 0 || i_len == 0)
+                                goto out;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
+                                to != CH_UTF16LE && to != CH_UTF16BE) {
+                        /* Failed multibyte to multibyte. Just copy the default fail char and
+                           try again. */
+                        outbuf[0] = lp_failed_convert_char();
+
+                        inbuf++;
+                        i_len--;
+
+                        outbuf++;
+                        o_len--;
+
+                        if (o_len == 0 || i_len == 0)
+                                goto out;
+
+                        /* Keep trying with the next char... */
+                        goto again;
+
+                } else {
+                        /* Keep compiler happy.... */
+                        goto out;
+                }
+        }
 }
 
@@ -719 +726 @@
  **/
 size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
-                 void const *src, size_t srclen, void *dst,
-                 BOOL allow_bad_conv)
-{
-    void **dest = (void **)dst;
-    size_t dest_len;
-
-    *dest = NULL;
-    dest_len=convert_string_allocate(ctx, from, to, src, srclen, dest, allow_bad_conv);
-    if (dest_len == (size_t)-1)
-        return (size_t)-1;
-    if (*dest == NULL)
-        return (size_t)-1;
-    return dest_len;
+                                 void const *src, size_t srclen, void *dst,
+                                 BOOL allow_bad_conv)
+{
+        void **dest = (void **)dst;
+        size_t dest_len;
+
+        *dest = NULL;
+        dest_len=convert_string_allocate(ctx, from, to, src, srclen, dest, allow_bad_conv);
+        if (dest_len == (size_t)-1)
+                return (size_t)-1;
+        if (*dest == NULL)
+                return (size_t)-1;
+        return dest_len;
 }
 
 size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
 {
-    size_t size;
-    smb_ucs2_t *buffer;
-
-    size = push_ucs2_allocate(&buffer, src);
-    if (size == (size_t)-1) {
-        smb_panic("failed to create UCS2 buffer");
-    }
-    if (!strupper_w(buffer) && (dest == src)) {
-        free(buffer);
-        return srclen;
-    }
-
-    size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
-    free(buffer);
-    return size;
+        size_t size;
+        smb_ucs2_t *buffer;
+
+        size = push_ucs2_allocate(&buffer, src);
+        if (size == (size_t)-1) {
+                smb_panic("failed to create UCS2 buffer");
+        }
+        if (!strupper_w(buffer) && (dest == src)) {
+                free(buffer);
+                return srclen;
+        }
+
+        size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
+        free(buffer);
+        return size;
 }
 
@@ -760 +767 @@
 char *strdup_upper(const char *s)
 {
-    pstring out_buffer;
-    const unsigned char *p = (const unsigned char *)s;
-    unsigned char *q = (unsigned char *)out_buffer;
-
-    /* this is quite a common operation, so we want it to be
-       fast. We optimise for the ascii case, knowing that all our
-       supported multi-byte character sets are ascii-compatible
-       (ie. they match for the first 128 chars) */
-
-    while (1) {
-        if (*p & 0x80)
-            break;
-        *q++ = toupper_ascii(*p);
-        if (!*p)
-            break;
-        p++;
-        if (p - ( const unsigned char *)s >= sizeof(pstring))
-            break;
-    }
-
-    if (*p) {
-        /* MB case. */
-        size_t size;
-        wpstring buffer;
-        size = convert_string(CH_UNIX, CH_UTF16LE, s, -1, buffer, sizeof(buffer), True);
-        if (size == (size_t)-1) {
-            return NULL;
-        }
-
-        strupper_w(buffer);
-
-        size = convert_string(CH_UTF16LE, CH_UNIX, buffer, -1, out_buffer, sizeof(out_buffer), True);
-        if (size == (size_t)-1) {
-            return NULL;
-        }
-    }
-
-    return SMB_STRDUP(out_buffer);
+        pstring out_buffer;
+        const unsigned char *p = (const unsigned char *)s;
+        unsigned char *q = (unsigned char *)out_buffer;
+
+        /* this is quite a common operation, so we want it to be
+           fast. We optimise for the ascii case, knowing that all our
+           supported multi-byte character sets are ascii-compatible
+           (ie. they match for the first 128 chars) */
+
+        while (1) {
+                if (*p & 0x80)
+                        break;
+                *q++ = toupper_ascii(*p);
+                if (!*p)
+                        break;
+                p++;
+                if (p - ( const unsigned char *)s >= sizeof(pstring))
+                        break;
+        }
+
+        if (*p) {
+                /* MB case. */
+                size_t size;
+                wpstring buffer;
+                size = convert_string(CH_UNIX, CH_UTF16LE, s, -1, buffer, sizeof(buffer), True);
+                if (size == (size_t)-1) {
+                        return NULL;
+                }
+
+                strupper_w(buffer);
+
+                size = convert_string(CH_UTF16LE, CH_UNIX, buffer, -1, out_buffer, sizeof(out_buffer), True);
+                if (size == (size_t)-1) {
+                        return NULL;
+                }
+        }
+
+        return SMB_STRDUP(out_buffer);
 }
 
 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
 {
-    size_t size;
-    smb_ucs2_t *buffer = NULL;
-
-    size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
-                       (void **)(void *)&buffer, True);
-    if (size == (size_t)-1 || !buffer) {
-        smb_panic("failed to create UCS2 buffer");
-    }
-    if (!strlower_w(buffer) && (dest == src)) {
-        SAFE_FREE(buffer);
-        return srclen;
-    }
-    size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
-    SAFE_FREE(buffer);
-    return size;
+        size_t size;
+        smb_ucs2_t *buffer = NULL;
+
+        size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
+                                           (void **)(void *)&buffer, True);
+        if (size == (size_t)-1 || !buffer) {
+                smb_panic("failed to create UCS2 buffer");
+        }
+        if (!strlower_w(buffer) && (dest == src)) {
+                SAFE_FREE(buffer);
+                return srclen;
+        }
+        size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
+        SAFE_FREE(buffer);
+        return size;
 }
 
@@ -825 +832 @@
 char *strdup_lower(const char *s)
 {
-    size_t size;
-    smb_ucs2_t *buffer = NULL;
-    char *out_buffer;
-
-    size = push_ucs2_allocate(&buffer, s);
-    if (size == -1 || !buffer) {
-        return NULL;
-    }
-
-    strlower_w(buffer);
-
-    size = pull_ucs2_allocate(&out_buffer, buffer);
-    SAFE_FREE(buffer);
-
-    if (size == (size_t)-1) {
-        return NULL;
-    }
-
-    return out_buffer;
+        size_t size;
+        smb_ucs2_t *buffer = NULL;
+        char *out_buffer;
+
+        size = push_ucs2_allocate(&buffer, s);
+        if (size == -1 || !buffer) {
+                return NULL;
+        }
+
+        strlower_w(buffer);
+
+        size = pull_ucs2_allocate(&out_buffer, buffer);
+        SAFE_FREE(buffer);
+
+        if (size == (size_t)-1) {
+                return NULL;
+        }
+
+        return out_buffer;
 }
 
 static size_t ucs2_align(const void *base_ptr, const void *p, int flags)
 {
-    if (flags & (STR_NOALIGN|STR_ASCII))
-        return 0;
-    return PTR_DIFF(p, base_ptr) & 1;
+        if (flags & (STR_NOALIGN|STR_ASCII))
+                return 0;
+        return PTR_DIFF(p, base_ptr) & 1;
 }
 
@@ -875 +882 @@
 
         /* No longer allow a length of -1 */
-            if (dest_len == (size_t)-1)
+                if (dest_len == (size_t)-1)
                 smb_panic("push_ascii - dest_len == -1");
 
-    if (flags & STR_UPPER) {
-        pstrcpy(tmpbuf, src);
-        strupper_m(tmpbuf);
-        src = tmpbuf;
-    }
-
-    if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
-        src_len++;
+        if (flags & STR_UPPER) {
+                pstrcpy(tmpbuf, src);
+                strupper_m(tmpbuf);
+                src = tmpbuf;
+        }
+
+        if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
+                src_len++;
 
         ret =convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
@@ -899 +906 @@
 size_t push_ascii_fstring(void *dest, const char *src)
 {
-    return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
+        return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
 }
 
 size_t push_ascii_pstring(void *dest, const char *src)
 {
-    return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
+        return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
 }
 
@@ -914 +921 @@
 size_t push_ascii_nstring(void *dest, const char *src)
 {
-    size_t i, buffer_len, dest_len;
-    smb_ucs2_t *buffer;
-
-    conv_silent = True;
-    buffer_len = push_ucs2_allocate(&buffer, src);
-    if (buffer_len == (size_t)-1) {
-        smb_panic("failed to create UCS2 buffer");
-    }
-
-    /* We're using buffer_len below to count ucs2 characters, not bytes. */
-    buffer_len /= sizeof(smb_ucs2_t);
-
-    dest_len = 0;
-    for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
-        unsigned char mb[10];
-        /* Convert one smb_ucs2_t character at a time. */
-        size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
-        if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
-            memcpy((char *)dest + dest_len, mb, mb_len);
-            dest_len += mb_len;
-        } else {
-            errno = E2BIG;
-            break;
-        }
-    }
-    ((char *)dest)[dest_len] = '\0';
-
-    SAFE_FREE(buffer);
-    conv_silent = False;
-    return dest_len;
+        size_t i, buffer_len, dest_len;
+        smb_ucs2_t *buffer;
+
+        conv_silent = True;
+        buffer_len = push_ucs2_allocate(&buffer, src);
+        if (buffer_len == (size_t)-1) {
+                smb_panic("failed to create UCS2 buffer");
+        }
+
+        /* We're using buffer_len below to count ucs2 characters, not bytes. */
+        buffer_len /= sizeof(smb_ucs2_t);
+
+        dest_len = 0;
+        for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
+                unsigned char mb[10];
+                /* Convert one smb_ucs2_t character at a time. */
+                size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
+                if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
+                        memcpy((char *)dest + dest_len, mb, mb_len);
+                        dest_len += mb_len;
+                } else {
+                        errno = E2BIG;
+                        break;
+                }
+        }
+        ((char *)dest)[dest_len] = '\0';
+
+        SAFE_FREE(buffer);
+        conv_silent = False;
+        return dest_len;
 }
 
@@ -963 +970 @@
 size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
 {
-    size_t ret;
-
-    if (dest_len == (size_t)-1)
-        dest_len = sizeof(pstring);
-
-    if (flags & STR_TERMINATE) {
-        if (src_len == (size_t)-1) {
-            src_len = strlen((const char *)src) + 1;
-        } else {
-            size_t len = strnlen((const char *)src, src_len);
-            if (len < src_len)
-                len++;
-            src_len = len;
-        }
-    }
-
-    ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
-    if (ret == (size_t)-1) {
-        ret = 0;
-        dest_len = 0;
-    }
-
-    if (dest_len && ret) {
-        /* Did we already process the terminating zero ? */
-        if (dest[MIN(ret-1, dest_len-1)] != 0) {
-            dest[MIN(ret, dest_len-1)] = 0;
-        }
-    } else  {
-        dest[0] = 0;
-    }
-
-    return src_len;
+        size_t ret;
+
+        if (dest_len == (size_t)-1)
+                dest_len = sizeof(pstring);
+
+        if (flags & STR_TERMINATE) {
+                if (src_len == (size_t)-1) {
+                        src_len = strlen((const char *)src) + 1;
+                } else {
+                        size_t len = strnlen((const char *)src, src_len);
+                        if (len < src_len)
+                                len++;
+                        src_len = len;
+                }
+        }
+
+        ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
+        if (ret == (size_t)-1) {
+                ret = 0;
+                dest_len = 0;
+        }
+
+        if (dest_len && ret) {
+                /* Did we already process the terminating zero ? */
+                if (dest[MIN(ret-1, dest_len-1)] != 0) {
+                        dest[MIN(ret, dest_len-1)] = 0;
+                }
+        } else  {
+                dest[0] = 0;
+        }
+
+        return src_len;
 }
 
 size_t pull_ascii_pstring(char *dest, const void *src)
 {
-    return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
+        return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
 }
 
 size_t pull_ascii_fstring(char *dest, const void *src)
 {
-    return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
+        return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
 }
 
@@ -1011 +1018 @@
 size_t pull_ascii_nstring(char *dest, size_t dest_len, const void *src)
 {
-    return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
+        return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
 }
 
@@ -1023 +1030 @@
  * <dl>
  * <dt>STR_TERMINATE <dd>means include the null termination.
- * <dt>STR_UPPER     <dd>means uppercase in the destination.
+ * <dt>STR_UPPER         <dd>means uppercase in the destination.
  * <dt>STR_NOALIGN   <dd>means don't do alignment.
  * </dl>
@@ -1033 +1040 @@
 size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
 {
-    size_t len=0;
-    size_t src_len;
-    size_t ret;
-
-    /* treat a pstring as "unlimited" length */
-    if (dest_len == (size_t)-1)
-        dest_len = sizeof(pstring);
-
-    if (flags & STR_TERMINATE)
-        src_len = (size_t)-1;
-    else
-        src_len = strlen(src);
-
-    if (ucs2_align(base_ptr, dest, flags)) {
-        *(char *)dest = 0;
-        dest = (void *)((char *)dest + 1);
-        if (dest_len)
-            dest_len--;
-        len++;
-    }
-
-    /* ucs2 is always a multiple of 2 bytes */
-    dest_len &= ~1;
-
-    ret =  convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
-    if (ret == (size_t)-1) {
-        return 0;
-    }
-
-    len += ret;
-
-    if (flags & STR_UPPER) {
-        smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
-        size_t i;
-
-        /* We check for i < (ret / 2) below as the dest string isn't null
-           terminated if STR_TERMINATE isn't set. */
-
-        for (i = 0; i < (ret / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
-            smb_ucs2_t v = toupper_w(dest_ucs2[i]);
-            if (v != dest_ucs2[i]) {
-                dest_ucs2[i] = v;
-            }
-        }
-    }
-
-    return len;
+        size_t len=0;
+        size_t src_len;
+        size_t ret;
+
+        /* treat a pstring as "unlimited" length */
+        if (dest_len == (size_t)-1)
+                dest_len = sizeof(pstring);
+
+        if (flags & STR_TERMINATE)
+                src_len = (size_t)-1;
+        else
+                src_len = strlen(src);
+
+        if (ucs2_align(base_ptr, dest, flags)) {
+                *(char *)dest = 0;
+                dest = (void *)((char *)dest + 1);
+                if (dest_len)
+                        dest_len--;
+                len++;
+        }
+
+        /* ucs2 is always a multiple of 2 bytes */
+        dest_len &= ~1;
+
+        ret =  convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
+        if (ret == (size_t)-1) {
+                return 0;
+        }
+
+        len += ret;
+
+        if (flags & STR_UPPER) {
+                smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
+                size_t i;
+
+                /* We check for i < (ret / 2) below as the dest string isn't null
+                   terminated if STR_TERMINATE isn't set. */
+
+                for (i = 0; i < (ret / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
+                        smb_ucs2_t v = toupper_w(dest_ucs2[i]);
+                        if (v != dest_ucs2[i]) {
+                                dest_ucs2[i] = v;
+                        }
+                }
+        }
+
+        return len;
 }
 
@@ -1090 +1097 @@
  *
  * @returns The number of bytes occupied by the string in the destination
- *         or -1 in case of error.
+ *               or -1 in case of error.
  **/
 size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-
-    *dest = NULL;
-    return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+
+        *dest = NULL;
+        return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
 }
 
@@ -1107 +1114 @@
  *
  * @returns The number of bytes occupied by the string in the destination
- *         or -1 in case of error.
+ *               or -1 in case of error.
  **/
 
 size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-
-    *dest = NULL;
-    return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+
+        *dest = NULL;
+        return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
 }
 
@@ -1123 +1130 @@
  Flags can have:
   STR_TERMINATE means include the null termination
-  STR_UPPER     means uppercase in the destination
+  STR_UPPER      means uppercase in the destination
  dest_len is the maximum length allowed in the destination. If dest_len
  is -1 then no maxiumum is used.
@@ -1130 +1137 @@
 static size_t push_utf8(void *dest, const char *src, size_t dest_len, int flags)
 {
-    size_t src_len = strlen(src);
-    pstring tmpbuf;
-
-    /* treat a pstring as "unlimited" length */
-    if (dest_len == (size_t)-1)
-        dest_len = sizeof(pstring);
-
-    if (flags & STR_UPPER) {
-        pstrcpy(tmpbuf, src);
-        strupper_m(tmpbuf);
-        src = tmpbuf;
-    }
-
-    if (flags & STR_TERMINATE)
-        src_len++;
-
-    return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
+        size_t src_len = strlen(src);
+        pstring tmpbuf;
+
+        /* treat a pstring as "unlimited" length */
+        if (dest_len == (size_t)-1)
+                dest_len = sizeof(pstring);
+
+        if (flags & STR_UPPER) {
+                pstrcpy(tmpbuf, src);
+                strupper_m(tmpbuf);
+                src = tmpbuf;
+        }
+
+        if (flags & STR_TERMINATE)
+                src_len++;
+
+        return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
 }
 
 size_t push_utf8_fstring(void *dest, const char *src)
 {
-    return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
+        return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
 }
 
@@ -1164 +1171 @@
 size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-
-    *dest = NULL;
-    return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest, True);
+        size_t src_len = strlen(src)+1;
+
+        *dest = NULL;
+        return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest, True);
 }
 
@@ -1180 +1187 @@
 size_t push_utf8_allocate(char **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-
-    *dest = NULL;
-    return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+
+        *dest = NULL;
+        return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
 }
 
@@ -1199 +1206 @@
 size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
 {
-    size_t ret;
-
-    if (dest_len == (size_t)-1)
-        dest_len = sizeof(pstring);
-
-    if (ucs2_align(base_ptr, src, flags)) {
-        src = (const void *)((const char *)src + 1);
-        if (src_len != (size_t)-1)
-            src_len--;
-    }
-
-    if (flags & STR_TERMINATE) {
-        /* src_len -1 is the default for null terminated strings. */
-        if (src_len != (size_t)-1) {
-            size_t len = strnlen_w((const smb_ucs2_t *)src,
-                        src_len/2);
-            if (len < src_len/2)
-                len++;
-            src_len = len*2;
-        }
-    }
-
-    /* ucs2 is always a multiple of 2 bytes */
-    if (src_len != (size_t)-1)
-        src_len &= ~1;
-
-    ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
-    if (ret == (size_t)-1) {
-        return 0;
-    }
-
-    if (src_len == (size_t)-1)
-        src_len = ret*2;
-
-    if (dest_len && ret) {
-        /* Did we already process the terminating zero ? */
-        if (dest[MIN(ret-1, dest_len-1)] != 0) {
-            dest[MIN(ret, dest_len-1)] = 0;
-        }
-    } else {
-        dest[0] = 0;
-    }
-
-    return src_len;
+        size_t ret;
+
+        if (dest_len == (size_t)-1)
+                dest_len = sizeof(pstring);
+
+        if (ucs2_align(base_ptr, src, flags)) {
+                src = (const void *)((const char *)src + 1);
+                if (src_len != (size_t)-1)
+                        src_len--;
+        }
+
+        if (flags & STR_TERMINATE) {
+                /* src_len -1 is the default for null terminated strings. */
+                if (src_len != (size_t)-1) {
+                        size_t len = strnlen_w((const smb_ucs2_t *)src,
+                                                src_len/2);
+                        if (len < src_len/2)
+                                len++;
+                        src_len = len*2;
+                }
+        }
+
+        /* ucs2 is always a multiple of 2 bytes */
+        if (src_len != (size_t)-1)
+                src_len &= ~1;
+
+        ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
+        if (ret == (size_t)-1) {
+                return 0;
+        }
+
+        if (src_len == (size_t)-1)
+                src_len = ret*2;
+
+        if (dest_len && ret) {
+                /* Did we already process the terminating zero ? */
+                if (dest[MIN(ret-1, dest_len-1)] != 0) {
+                        dest[MIN(ret, dest_len-1)] = 0;
+                }
+        } else {
+                dest[0] = 0;
+        }
+
+        return src_len;
 }
 
 size_t pull_ucs2_pstring(char *dest, const void *src)
 {
-    return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
+        return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
 }
 
 size_t pull_ucs2_fstring(char *dest, const void *src)
 {
-    return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
+        return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
 }
 
@@ -1265 +1272 @@
 size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
 {
-    size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
-    *dest = NULL;
-    return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
+        size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
+        *dest = NULL;
+        return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
 }
 
@@ -1280 +1287 @@
 size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
 {
-    size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
-    *dest = NULL;
-    return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
+        size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
+        *dest = NULL;
+        return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
 }
 
@@ -1295 +1302 @@
 size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-    *dest = NULL;
-    return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+        *dest = NULL;
+        return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
 }
 
@@ -1310 +1317 @@
 size_t pull_utf8_allocate(char **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-    *dest = NULL;
-    return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+        *dest = NULL;
+        return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
 }
 
@@ -1325 +1332 @@
 size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
 {
-    size_t src_len = strlen(src)+1;
-    *dest = NULL;
-    return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
+        size_t src_len = strlen(src)+1;
+        *dest = NULL;
+        return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
 }
 
@@ -1337 +1344 @@
  flags can have:
   STR_TERMINATE means include the null termination.
-  STR_UPPER     means uppercase in the destination.
-  STR_ASCII     use ascii even with unicode packet.
+  STR_UPPER      means uppercase in the destination.
+  STR_ASCII      use ascii even with unicode packet.
   STR_NOALIGN   means don't do alignment.
  dest_len is the maximum length allowed in the destination. If dest_len
@@ -1347 +1354 @@
 {
 #ifdef DEVELOPER
-    /* We really need to zero fill here, not clobber
-     * region, as we want to ensure that valgrind thinks
-     * all of the outgoing buffer has been written to
-     * so a send() or write() won't trap an error.
-     * JRA.
-     */
+        /* We really need to zero fill here, not clobber
+         * region, as we want to ensure that valgrind thinks
+         * all of the outgoing buffer has been written to
+         * so a send() or write() won't trap an error.
+         * JRA.
+         */
 #if 0
-    if (dest_len != (size_t)-1)
-        clobber_region(function, line, dest, dest_len);
+        if (dest_len != (size_t)-1)
+                clobber_region(function, line, dest, dest_len);
 #else
-    if (dest_len != (size_t)-1)
-        memset(dest, '\0', dest_len);
+        if (dest_len != (size_t)-1)
+                memset(dest, '\0', dest_len);
 #endif
 #endif
 
-    if (!(flags & STR_ASCII) && \
-        ((flags & STR_UNICODE || \
-          (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
-        return push_ucs2(base_ptr, dest, src, dest_len, flags);
-    }
-    return push_ascii(dest, src, dest_len, flags);
+        if (!(flags & STR_ASCII) && \
+                ((flags & STR_UNICODE || \
+                  (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
+                return push_ucs2(base_ptr, dest, src, dest_len, flags);
+        }
+        return push_ascii(dest, src, dest_len, flags);
 }
 
@@ -1377 +1384 @@
   STR_TERMINATE means the string in src is null terminated.
   STR_UNICODE   means to force as unicode.
-  STR_ASCII     use ascii even with unicode packet.
+  STR_ASCII      use ascii even with unicode packet.
   STR_NOALIGN   means don't do alignment.
  if STR_TERMINATE is set then src_len is ignored is it is -1
@@ -1388 +1395 @@
 {
 #ifdef DEVELOPER
-    if (dest_len != (size_t)-1)
-        clobber_region(function, line, dest, dest_len);
+        if (dest_len != (size_t)-1)
+                clobber_region(function, line, dest, dest_len);
 #endif
 
-    if (!(flags & STR_ASCII) && \
-        ((flags & STR_UNICODE || \
-          (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
-        return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
-    }
-    return pull_ascii(dest, src, dest_len, src_len, flags);
+        if (!(flags & STR_ASCII) && \
+                ((flags & STR_UNICODE || \
+                  (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
+                return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
+        }
+        return pull_ascii(dest, src, dest_len, src_len, flags);
 }
 
 size_t align_string(const void *base_ptr, const char *p, int flags)
 {
-    if (!(flags & STR_ASCII) && \
-        ((flags & STR_UNICODE || \
-          (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
-        return ucs2_align(base_ptr, p, flags);
-    }
-    return 0;
+        if (!(flags & STR_ASCII) && \
+                ((flags & STR_UNICODE || \
+                  (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
+                return ucs2_align(base_ptr, p, flags);
+        }
+        return 0;
 }
 
@@ -1422 +1429 @@
 codepoint_t next_codepoint(const char *str, size_t *size)
 {
-    /* It cannot occupy more than 4 bytes in UTF16 format */
-    uint8_t buf[4];
-    smb_iconv_t descriptor;
+        /* It cannot occupy more than 4 bytes in UTF16 format */
+        uint8_t buf[4];
+        smb_iconv_t descriptor;
 #ifdef __OS2__
-    size_t ilen_max;
+        size_t ilen_max;
 #endif
-    size_t ilen_orig;
-    size_t ilen;
-    size_t olen_orig;
-    size_t olen;
-    const char *inbuf;
-    char *outbuf;
+        size_t ilen_orig;
+        size_t ilen;
+        size_t olen_orig;
+        size_t olen;
+        const char *inbuf;
+        char *outbuf;
 
 #ifdef __OS2__
-    *size = 1;
+        *size = 1;
 #endif
 
-    if ((str[0] & 0x80) == 0) {
+        if ((str[0] & 0x80) == 0) {
 #ifndef __OS2__
-        *size = 1;
+                *size = 1;
 #endif
-        return (codepoint_t)str[0];
-    }
-
-    lazy_initialize_conv();
-
-    descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
-    if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
+                return (codepoint_t)str[0];
+        }
+
+        lazy_initialize_conv();
+
+        descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
+        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
 #ifndef __OS2__
-        *size = 1;
+                *size = 1;
 #endif
-        return INVALID_CODEPOINT;
-    }
+                return INVALID_CODEPOINT;
+        }
 #ifdef __OS2__
-    /* We assume that no multi-byte character can take
-       more than 5 bytes. This is OK as we only
-       support codepoints up to 1M */
-
-    ilen_max = strnlen( str, 5 );
+        /* We assume that no multi-byte character can take
+           more than 5 bytes. This is OK as we only
+           support codepoints up to 1M */
+
+        ilen_max = strnlen( str, 5 );
 #else
-    *size = 1;
+        *size = 1;
 #endif
-    ilen_orig = 1;
-    olen_orig = 2;
-    while( 1 )
-    {
-        ilen = ilen_orig;
-        olen = olen_orig;
-        inbuf = str;
-        outbuf = ( char * )buf;
-        if( smb_iconv( descriptor, &inbuf, &ilen, &outbuf, &olen ) != ( size_t )-1 )
-            break;
-
-        switch( errno )
-        {
-            case E2BIG :
-                if( olen_orig == 2 )
-                    olen_orig = 4;
-                else
-                    return INVALID_CODEPOINT;
-                break;
-
-            case EINVAL :
+        ilen_orig = 1;
+        olen_orig = 2;
+        while( 1 )
+        {
+                ilen = ilen_orig;
+                olen = olen_orig;
+                inbuf = str;
+                outbuf = ( char * )buf;
+                if( smb_iconv( descriptor, &inbuf, &ilen, &outbuf, &olen ) != ( size_t )-1 )
+                        break;
+
+                switch( errno )
+                {
+                        case E2BIG :
+                                if( olen_orig == 2 )
+                                        olen_orig = 4;
+                                else
+                                        return INVALID_CODEPOINT;
+                                break;
+
+                        case EINVAL :
 #ifndef __OS2__
-                /* We assume that no multi-byte character can take
-                   more than 5 bytes. This is OK as we only
-                   support codepoints up to 1M */
-                if( ilen_orig < 5 )
+                                /* We assume that no multi-byte character can take
+                                   more than 5 bytes. This is OK as we only
+                                   support codepoints up to 1M */
+                                if( ilen_orig < 5 )
 #else
-                if( ilen_orig < ilen_max )
+                                if( ilen_orig < ilen_max )
 #endif
-                    ilen_orig++;
-                else
-                    return INVALID_CODEPOINT;
-                break;
-
-            case EILSEQ :
-            default :
-                return INVALID_CODEPOINT;
-        }
-    }
-
-    olen = olen_orig - olen;
-
-    *size = ilen_orig - ilen;
-
-    if (olen == 2) {
-        /* 2 byte, UTF16-LE encoded value. */
-        return (codepoint_t)SVAL(buf, 0);
-    }
-    if (olen == 4) {
-        /* Decode a 4 byte UTF16-LE character manually.
-           See RFC2871 for the encoding machanism.
-        */
-        codepoint_t w1 = SVAL(buf,0) & ~0xD800;
-        codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
-
-        return (codepoint_t)0x10000 +
-                (w1 << 10) + w2;
-    }
-
-    /* no other length is valid */
-    return INVALID_CODEPOINT;
-}
+                                        ilen_orig++;
+                                else
+                                        return INVALID_CODEPOINT;
+                                break;
+
+                        case EILSEQ :
+                        default :
+                                return INVALID_CODEPOINT;
+                }
+        }
+
+        olen = olen_orig - olen;
+
+        *size = ilen_orig - ilen;
+
+        if (olen == 2) {
+                /* 2 byte, UTF16-LE encoded value. */
+                return (codepoint_t)SVAL(buf, 0);
+        }
+        if (olen == 4) {
+                /* Decode a 4 byte UTF16-LE character manually.
+                   See RFC2871 for the encoding machanism.
+                */
+                codepoint_t w1 = SVAL(buf,0) & ~0xD800;
+                codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
+
+                return (codepoint_t)0x10000 +
+                                (w1 << 10) + w2;
+        }
+
+        /* no other length is valid */
+        return INVALID_CODEPOINT;
+}

branches/samba-3.0/source/lib/clobber.c

@@ -55 +55 @@
          * marking might not actually take effect if we're not running
          * under valgrind.) */
+#if defined(VALGRIND_MAKE_MEM_UNDEFINED)
+        VALGRIND_MAKE_MEM_UNDEFINED(dest, len);
+#elif defined(VALGRIND_MAKE_WRITABLE)
         VALGRIND_MAKE_WRITABLE(dest, len);
+#endif
 #endif /* VALGRIND */
 #endif /* DEVELOPER */

branches/samba-3.0/source/lib/debug.c

@@ -693 +693 @@
          *  loop check do a new check as root.
          */
-
         if( geteuid() != 0 )
                 return;
@@ -716 +715 @@
                 }
         }
-
         /*
          * Here's where we need to panic if dbf == NULL..

branches/samba-3.0/source/lib/replace/getpass.c

@@ -20 +20 @@
 
 #include "replace.h"
+
+#if defined(REPLACE_GETPASS_BY_GETPASSPHRASE)
+
+#if defined(HAVE_STDIO_H)
+#include <stdio.h>
+#endif
+
+char *getsmbpass(const char *prompt)
+{
+        return getpassphrase(prompt);
+}
+
+#else /* !REPLACE_GETPASS_BY_GETPASSPHRASE */
 
 #if defined(HAVE_TERMIOS_H)
@@ -211 +224 @@
  void getsmbpasswd_dummy(void) {;}
 #endif
+
+#endif /* REPLACE_GETPASS_BY_GETPASSPHRASE */

branches/samba-3.0/source/lib/replace/getpass.m4

@@ +1 @@
+AC_CHECK_FUNC(getpass, samba_cv_HAVE_GETPASS=yes)
+AC_CHECK_FUNC(getpassphrase, samba_cv_HAVE_GETPASSPHRASE=yes)
+if test x"$samba_cv_HAVE_GETPASS" = x"yes" -a x"$samba_cv_HAVE_GETPASSPHRASE" = x"yes"; then
+        AC_DEFINE(REPLACE_GETPASS_BY_GETPASSPHRASE, 1, [getpass returns <9 chars where getpassphrase returns <265 chars])
+        AC_DEFINE(REPLACE_GETPASS,1,[Whether getpass should be replaced])
+        LIBREPLACEOBJ="${LIBREPLACEOBJ} getpass.o"
+else
+
 AC_CACHE_CHECK([whether getpass should be replaced],samba_cv_REPLACE_GETPASS,[
 SAVE_CPPFLAGS="$CPPFLAGS"
@@ -16 +24 @@
         LIBREPLACEOBJ="${LIBREPLACEOBJ} getpass.o"
 fi
+
+fi

branches/samba-3.0/source/lib/replace/libreplace.m4

@@ -100 +100 @@
 AC_CHECK_HEADERS(netinet/ip.h netinet/tcp.h netinet/in_systm.h netinet/in_ip.h)
 AC_CHECK_HEADERS(sys/sockio.h sys/un.h)
-
+AC_CHECK_HEADERS(stropts.h)
 
 dnl we need to check that net/if.h really can be used, to cope with hpux

branches/samba-3.0/source/lib/replace/system/network.h

@@ -75 +75 @@
 #endif
 
+#ifdef HAVE_STROPTS_H
+#include <stropts.h>
+#endif
+
 #ifdef SOCKET_WRAPPER
 #ifndef SOCKET_WRAPPER_NOT_REPLACE

branches/samba-3.0/source/lib/system.c

@@ -2234 +2234 @@
         int ret = -1;
         int myflags = O_RDWR;
+        int attrfd;
         if (flags & XATTR_CREATE) myflags |= O_EXCL;
         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
-        int attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
+        attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
         if (attrfd >= 0) {
                 ret = solaris_write_xattr(attrfd, value, size);
@@ -2299 +2300 @@
         int ret = -1;
         int myflags = O_RDWR | AT_SYMLINK_NOFOLLOW;
+        int attrfd;
         if (flags & XATTR_CREATE) myflags |= O_EXCL;
         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
-        int attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
+        attrfd = solaris_attropen(path, name, myflags, (mode_t) SOLARIS_ATTRMODE);
         if (attrfd >= 0) {
                 ret = solaris_write_xattr(attrfd, value, size);
@@ -2365 +2367 @@
         int ret = -1;
         int myflags = O_RDWR | O_XATTR;
+        int attrfd;
         if (flags & XATTR_CREATE) myflags |= O_EXCL;
         if (!(flags & XATTR_REPLACE)) myflags |= O_CREAT;
-        int attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
+        attrfd = solaris_openat(filedes, name, myflags, (mode_t) SOLARIS_ATTRMODE);
         if (attrfd >= 0) {
                 ret = solaris_write_xattr(attrfd, value, size);

branches/samba-3.0/source/lib/util_str.c

@@ -395 +395 @@
 **/
 
-void string_replace( pstring s, char oldc, char newc )
+/**
+ String replace.
+ NOTE: oldc and newc must be 7 bit characters
+**/
+void string_replace( char *s, char oldc, char newc )
 {
         char *p;
@@ -407 +411 @@
                 if (*p & 0x80) /* mb string - slow path. */
                         break;
-                if (*p == oldc)
+                if (*p == oldc) {
                         *p = newc;
+                }
         }
 
@@ -419 +424 @@
         p = s;
 #endif
-        push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
-        string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
-        pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
+
+        while (*p) {
+                size_t c_size;
+                next_codepoint(p, &c_size);
+
+                if (c_size == 1) {
+                        if (*p == oldc) {
+                                *p = newc;
+                        }
+                }
+                p += c_size;
+        }
 }