lib/charcnv.c

Character-set conversion routines built on our iconv. [詳細]

ソースコードを見る。

関数
char	lp_failed_convert_char (void)
static const char *	charset_name (charset_t ch)
	Return the name of a charset to give to iconv().
void	lazy_initialize_conv (void)
void	gfree_charcnv (void)
	Destroy global objects allocated by init_iconv()
void	init_iconv (void)
	Initialize iconv conversion descriptors.
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)
	Convert string from one encoding to another, making error checking etc Slow path version - uses (slow) iconv.
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)
	Convert string from one encoding to another, making error checking etc Fast path version - handles ASCII first.
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)
	Convert between character sets, allocating a new buffer for the result.
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)
	Convert between character sets, allocating a new buffer using talloc for the result.
size_t	unix_strupper (const char *src, size_t srclen, char *dest, size_t destlen)
char *	strdup_upper (const char *s)
	strdup() a unix string to upper case.
size_t	unix_strlower (const char *src, size_t srclen, char *dest, size_t destlen)
char *	strdup_lower (const char *s)
	strdup() a unix string to lower case.
static size_t	ucs2_align (const void *base_ptr, const void *p, int flags)
size_t	push_ascii (void *dest, const char *src, size_t dest_len, int flags)
	Copy a string from a char* unix src to a dos codepage string destination.
size_t	push_ascii_fstring (void *dest, const char *src)
size_t	push_ascii_pstring (void *dest, const char *src)
size_t	push_ascii_nstring (void *dest, const char *src)
size_t	pull_ascii (char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
	Copy a string from a dos codepage source to a unix char* destination.
size_t	pull_ascii_pstring (char *dest, const void *src)
size_t	pull_ascii_fstring (char *dest, const void *src)
size_t	pull_ascii_nstring (char *dest, size_t dest_len, const void *src)
size_t	push_ucs2 (const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
	Copy a string from a char* src to a unicode destination.
size_t	push_ucs2_talloc (TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
	Copy a string from a unix char* src to a UCS2 destination, allocating a buffer using talloc().
size_t	push_ucs2_allocate (smb_ucs2_t **dest, const char *src)
	Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
static size_t	push_utf8 (void *dest, const char *src, size_t dest_len, int flags)
	Copy a string from a char* src to a UTF-8 destination.
size_t	push_utf8_fstring (void *dest, const char *src)
size_t	push_utf8_talloc (TALLOC_CTX *ctx, char **dest, const char *src)
	Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
size_t	push_utf8_allocate (char **dest, const char *src)
	Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
size_t	pull_ucs2 (const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
	Copy a string from a ucs2 source to a unix char* destination.
size_t	pull_ucs2_pstring (char *dest, const void *src)
size_t	pull_ucs2_fstring (char *dest, const void *src)
size_t	pull_ucs2_talloc (TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
	Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
size_t	pull_ucs2_allocate (char **dest, const smb_ucs2_t *src)
	Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
size_t	pull_utf8_talloc (TALLOC_CTX *ctx, char **dest, const char *src)
	Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
size_t	pull_utf8_allocate (char **dest, const char *src)
	Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
size_t	pull_ascii_talloc (TALLOC_CTX *ctx, char **dest, const char *src)
	Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
size_t	push_string_fn (const char *function, unsigned int line, const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
	Copy a string from a char* src to a unicode or ascii dos codepage destination choosing unicode or ascii based on the flags in the SMB buffer starting at base_ptr.
size_t	pull_string_fn (const char *function, unsigned int line, const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
	Copy a string from a unicode or ascii source (depending on the packet flags) to a char* destination.
size_t	align_string (const void *base_ptr, const char *p, int flags)
codepoint_t	next_codepoint (const char *str, size_t *size)
変数
static smb_iconv_t	conv_handles [NUM_CHARSETS][NUM_CHARSETS]
static BOOL	conv_silent

---

説明

Character-set conversion routines built on our iconv.

覚え書き:

Samba's internal character set (at least in the 3.0 series) is always the same as the one for the Unix filesystem. It is not necessarily UTF-8 and may be different on machines that need i18n filenames to be compatible with Unix software. It does have to be a superset of ASCII. All multibyte sequences must start with a byte with the high bit set.

参照:

lib/iconv.c

charcnv.c で定義されています。

---

関数

char lp_failed_convert_char

(

void

)

charcnv.c の 28 行で定義されています。

参照元 convert_string_allocate()・convert_string_internal().

{
        return '_';
}

static const char* charset_name

(

charset_t

ch

)

[static]

Return the name of a charset to give to iconv().

charcnv.c の 55 行で定義されています。

参照先 CH_DISPLAY・CH_DOS・CH_UNIX・CH_UTF16BE・CH_UTF16LE・CH_UTF8・handle・smb_iconv_close()・smb_iconv_open().

参照元 convert_string_internal()・init_iconv().

{
        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;

#ifdef HAVE_SETLOCALE
                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;
        }
#endif

        if (!ret || !*ret) ret = "ASCII";
        return ret;
}

void lazy_initialize_conv

(

void

)

charcnv.c の 94 行で定義されています。

参照先 init_iconv()・initialized・load_case_tables().

参照元 check_dos_char()・convert_string_allocate()・convert_string_internal()・next_codepoint().

{
        static int initialized = False;

        if (!initialized) {
                initialized = True;
                load_case_tables();
                init_iconv();
        }
}

void gfree_charcnv

(

void

)

Destroy global objects allocated by init_iconv()

charcnv.c の 108 行で定義されています。

参照先 conv_handles・smb_iconv_close().

参照元 gfree_all().

{
        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;
                        }
                }
        }
}

void init_iconv

(

void

)

Initialize iconv conversion descriptors.

This is called the first time it is needed, and also called again every time the configuration is reloaded, because the charset or codepage might have changed.

charcnv.c の 129 行で定義されています。

参照先 CH_UNIX・CH_UTF16BE・CH_UTF16LE・charset_name()・conv_handles・conv_silent・init_doschar_table()・init_valid_table()・smb_iconv_close()・smb_iconv_open()・smb_panic().

参照元 handle_charset()・lazy_initialize_conv().

{
        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;
        }
}

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
	)			[static]

Convert string from one encoding to another, making error checking etc Slow path version - uses (slow) iconv.

引数:

	src	pointer to source string (multibyte or singlebyte)
	srclen	length of the source string in bytes
	dest	pointer to destination string (multibyte or singlebyte)
	destlen	maximal length allowed for string
	allow_bad_conv	determines if a "best effort" conversion is acceptable (never returns errors)

戻り値:

the number of bytes occupied in the destination

Ensure the srclen contains the terminating zero.

charcnv.c の 203 行で定義されています。

参照先 CH_UNIX・CH_UTF16BE・CH_UTF16LE・charset_name()・conv_handles・conv_silent・errno・lazy_initialize_conv()・lp_failed_convert_char()・smb_iconv()・strlen_w().

参照元 convert_string().

{
        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;

 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;
                }
        }
}

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
	)

Convert string from one encoding to another, making error checking etc Fast path version - handles ASCII first.

引数:

	src	pointer to source string (multibyte or singlebyte)
	srclen	length of the source string in bytes, or -1 for nul terminated.
	dest	pointer to destination string (multibyte or singlebyte)
	destlen	maximal length allowed for string - *NEVER* -1.
	allow_bad_conv	determines if a "best effort" conversion is acceptable (never returns errors)

戻り値:

the number of bytes occupied in the destination

Ensure the srclen contains the terminating zero.

This function has been hand-tuned to provide a fast path. Don't change unless you really know what you are doing. JRA.

charcnv.c の 377 行で定義されています。

参照先 CH_UTF16BE・CH_UTF16LE・convert_string_internal()・errno.

参照元 cgi_handle_authorization()・cgi_load_variables()・check_dos_char_slowly()・d_vfprintf()・form_name()・is_legal_name()・main()・ndr_push_charset()・pull_ascii()・pull_ucs2()・push_ascii()・push_ascii_nstring()・push_ucs2()・push_utf8()・smbldap_get_single_attribute()・strdup_upper()・torture_utable()・unix_strlower()・unix_strupper().

{
        /*
         * 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);
#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 {
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
                                goto general_case;
#else
                                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 {
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
                                goto general_case;
#else
                                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 {
#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
                                goto general_case;
#else
                                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;
        }

#ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
  general_case:
#endif
        return convert_string_internal(from, to, src, srclen, dest, destlen, allow_bad_conv);
}

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
	)

Convert between character sets, allocating a new buffer for the result.

引数:

	ctx	TALLOC_CTX to use to allocate with. If NULL use malloc.
	srclen	length of source buffer.
	dest	always set at least to NULL

覚え書き:

-1 is not accepted for srclen.

戻り値:

Size in bytes of the converted string; or -1 in case of error.

Ensure the srclen contains the terminating zero.

I hate the goto's in this function. It's embarressing..... There has to be a cleaner way to do this. JRA.

charcnv.c の 525 行で定義されています。

参照先 CH_UTF16BE・CH_UTF16LE・conv_handles・conv_silent・errno・lazy_initialize_conv()・lp_failed_convert_char()・smb_iconv().

参照元 cli_message_text_build()・convert_string_talloc()・msg_deliver()・notify_marshall_changes()・pull_ucs2_allocate()・pull_utf8_allocate()・push_ucs2_allocate()・push_utf8_allocate()・test_plaintext()・unix_strlower().

{
        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:

        /* +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;
        }

  out:

        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;
                }
        }
}

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
	)

Convert between character sets, allocating a new buffer using talloc for the result.

引数:

	srclen	length of source buffer.
	dest	always set at least to NULL

覚え書き:

-1 is not accepted for srclen.

戻り値:

Size in bytes of the converted string; or -1 in case of error.

charcnv.c の 728 行で定義されています。

参照先 convert_string_allocate().

参照元 ndr_pull_charset()・ndr_pull_string()・ndr_push_string()・pull_ascii_talloc()・pull_ucs2_talloc()・pull_utf8_talloc()・push_ucs2_talloc()・push_utf8_talloc().

{
        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
	)

charcnv.c の 744 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string()・push_ucs2_allocate()・size・smb_panic()・strupper_w().

参照元 StrnCaseCmp()・strupper_m().

{
        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;
}

char* strdup_upper

(

const char *

s

)

strdup() a unix string to upper case.

Max size is pstring.

charcnv.c の 768 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string()・size・strupper_w()・toupper_ascii().

参照元 alloc_sub_basic()・stat_cache_add()・stat_cache_delete()・stat_cache_lookup()・test_plaintext().

{
        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
	)

charcnv.c の 810 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string()・convert_string_allocate()・size・smb_panic()・strlower_w().

参照元 strlower_m().

{
        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;
}

char* strdup_lower

(

const char *

s

)

strdup() a unix string to lower case.

charcnv.c の 833 行で定義されています。

参照先 pull_ucs2_allocate()・push_ucs2_allocate()・size・strlower_w().

参照元 alloc_sub_basic()・net_usershare_add()・net_usershare_delete().

{
        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
	)			[static]

charcnv.c の 856 行で定義されています。

参照元 align_string()・pull_ucs2()・push_ucs2().

{
        if (flags & (STR_NOALIGN|STR_ASCII))
                return 0;
        return PTR_DIFF(p, base_ptr) & 1;
}

size_t push_ascii	(	void *	dest,
		const char *	src,
		size_t	dest_len,
		int	flags
	)

Copy a string from a char* unix src to a dos codepage string destination.

戻り値:

the number of bytes occupied by the string in the destination.

引数:

	flags	can include STR_TERMINATE means include the null termination STR_UPPER means uppercase in the destination
	dest_len	the maximum length in bytes allowed in the destination. If dest_len is -1 then no maximum is used.

charcnv.c の 878 行で定義されています。

参照先 CH_DOS・CH_UNIX・convert_string()・smb_panic()・strupper_m()・tmpbuf.

参照元 api_RNetServerGetInfo()・cli_NetServerEnum()・CopyAndAdvance()・CopyExpanded()・E_deshash()・fill_share_info()・fill_srv_info()・make_dir_struct()・make_nmb_name()・my_make_nmb_name()・PackDriverData()・process_logon_packet()・push_ascii_fstring()・push_ascii_pstring()・push_string_fn()・str_ascii_charnum()・upcase_name()・wins_record_to_name_record().

{
        size_t src_len = strlen(src);
        pstring tmpbuf;
        size_t ret;

        /* No longer allow a length of -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++;

        ret =convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
        if (ret == (size_t)-1 &&
                        (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
                        && dest_len > 0) {
                ((char *)dest)[0] = '\0';
        }
        return ret;
}

size_t push_ascii_fstring	(	void *	dest,
		const char *	src
	)

charcnv.c の 906 行で定義されています。

参照先 push_ascii().

参照元 api_RNetShareEnum()・ea_list_size()・fill_ea_buffer()・get_ea_list_from_file().

{
        return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
}

size_t push_ascii_pstring	(	void *	dest,
		const char *	src
	)

charcnv.c の 911 行で定義されています。

参照先 push_ascii().

{
        return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
}

size_t push_ascii_nstring	(	void *	dest,
		const char *	src
	)

charcnv.c の 921 行で定義されています。

参照先 CH_DOS・CH_UTF16LE・conv_silent・convert_string()・errno・push_ucs2_allocate()・smb_panic().

参照元 name_mangle()・name_to_unstring()・negprot_spnego()・process_node_status_request()・register_name()・upcase_name()・wins_record_to_name_record().

{
        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 pull_ascii	(	char *	dest,
		const void *	src,
		size_t	dest_len,
		size_t	src_len,
		int	flags
	)

Copy a string from a dos codepage source to a unix char* destination.

The resulting string in "dest" is always null terminated.

引数:

	flags	can have: STR_TERMINATE STR_TERMINATE means the string in src is null terminated, and src_len is ignored.
	src_len	is the length of the source area in bytes.

戻り値:

the number of bytes occupied by the string in src.

charcnv.c の 970 行で定義されています。

参照先 CH_DOS・CH_UNIX・convert_string()・len.

参照元 cli_get_server_name()・process_browse_packet()・process_lanman_packet()・process_lm_host_announce()・pull_ascii_fstring()・pull_ascii_nstring()・pull_ascii_pstring()・pull_string_fn()・upcase_name().

{
        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
	)

charcnv.c の 1006 行で定義されています。

参照先 pull_ascii().

参照元 api_RNetShareAdd()・cli_NetServerEnum()・cli_RNetShareEnum().

{
        return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
}

size_t pull_ascii_fstring	(	char *	dest,
		const void *	src
	)

charcnv.c の 1011 行で定義されています。

参照先 pull_ascii().

参照元 api_RNetServerEnum()・api_RNetShareAdd()・api_SamOEMChangePassword()・api_SetUserPassword()・cli_get_ea_list()・do_node_status()・name_interpret()・name_mangle()・nmb_namestr()・process_host_announce()・process_local_master_announce()・process_logon_packet().

{
        return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
}

size_t pull_ascii_nstring	(	char *	dest,
		size_t	dest_len,
		const void *	src
	)

charcnv.c の 1018 行で定義されています。

参照先 pull_ascii().

参照元 add_dns_result()・announce_local_master_browser_to_domain_master_browser()・asyncdns_process()・become_domain_master_fail()・become_domain_master_query_fail()・become_domain_master_query_success()・become_domain_master_stage2()・become_local_master_fail2()・become_local_master_stage2()・become_logon_server_fail()・become_logon_server_success()・check_for_master_browser_fail()・check_for_master_browser_success()・domain_master_node_status_success()・find_domain_master_name_query_success()・get_domain_master_name_node_status_success()・insert_permanent_name_into_unicast()・insert_refresh_name_into_unicast()・make_wins_proxy_name_query_request()・multihomed_register_name()・name_status_find()・name_to_key()・name_to_unstring()・process_announce_request()・process_browse_packet()・process_election()・process_get_backup_list_request()・process_host_announce()・process_lanman_packet()・process_lm_announce_request()・process_lm_host_announce()・process_local_master_announce()・process_logon_packet()・process_master_browser_announce()・process_name_release_request()・process_node_status_request()・process_workgroup_announce()・register_name()・register_name_response()・send_backup_list_response()・standard_success_register()・status_compare()・sync_all_dmbs()・sync_with_dmb()・unbecome_local_master_fail()・unbecome_local_master_success()・upcase_name()・wins_process_multihomed_name_registration_request()・wins_process_name_query_request()・wins_process_name_registration_request()・wins_write_name_record().

{
        return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
}

size_t push_ucs2	(	const void *	base_ptr,
		void *	dest,
		const char *	src,
		size_t	dest_len,
		int	flags
	)

Copy a string from a char* src to a unicode destination.

戻り値:

the number of bytes occupied by the string in the destination.

引数:

flags

can have:

STR_TERMINATE

means include the null termination.

STR_UPPER

means uppercase in the destination.

STR_NOALIGN

means don't do alignment.

引数:

dest_len

is the maximum length allowed in the destination. If dest_len is -1 then no maxiumum is used.

charcnv.c の 1040 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string()・len・toupper_w()・ucs2_align().

参照元 all_string_sub_wa()・catia_string_replace()・current_version()・dos_PutUniCode()・E_md4hash()・map_single_multi_sz_into_ctr()・map_sz_into_ctr()・ms_fnmatch()・prod_options()・push_string_fn()・rpcstr_push()・str_charnum()・strchr_m()・strhaslower()・strhasupper()・strnrchr_m()・strrchr_m()・tcpip_params()・trim_string_wa().

{
        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 push_ucs2_talloc	(	TALLOC_CTX *	ctx,
		smb_ucs2_t **	dest,
		const char *	src
	)

Copy a string from a unix char* src to a UCS2 destination, allocating a buffer using talloc().

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination or -1 in case of error.

charcnv.c の 1101 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string_talloc().

参照元 init_r_enum_trust_dom().

{
        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 push_ucs2_allocate	(	smb_ucs2_t **	dest,
		const char *	src
	)

Copy a string from a unix char* src to a UCS2 destination, allocating a buffer

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination or -1 in case of error.

charcnv.c の 1119 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string_allocate().

参照元 check_push_ucs2()・count_chars()・is_8_3()・name_map()・ntv2_owf_gen()・push_ascii_nstring()・secrets_store_trusted_domain_password()・StrCaseCmp()・strdup_lower()・strstr_m()・test_plaintext()・unix_strupper().

{
        size_t src_len = strlen(src)+1;

        *dest = NULL;
        return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
}

static size_t push_utf8	(	void *	dest,
		const char *	src,
		size_t	dest_len,
		int	flags
	)			[static]

Copy a string from a char* src to a UTF-8 destination.

Return the number of bytes occupied by the string in the destination Flags can have: STR_TERMINATE means include the null termination 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.

charcnv.c の 1137 行で定義されています。

参照先 CH_UNIX・CH_UTF8・convert_string()・strupper_m()・tmpbuf.

参照元 push_utf8_fstring().

{
        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
	)

charcnv.c の 1158 行で定義されています。

参照先 push_utf8().

参照元 py_auth_crap()・py_auth_smbd().

{
        return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
}

size_t push_utf8_talloc	(	TALLOC_CTX *	ctx,
		char **	dest,
		const char *	src
	)

Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1171 行で定義されています。

参照先 CH_UNIX・CH_UTF8・convert_string_talloc().

参照元 ads_do_paged_search_args()・ads_do_search()・ads_push_strvals().

{
        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 push_utf8_allocate	(	char **	dest,
		const char *	src
	)

Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1187 行で定義されています。

参照先 CH_UNIX・CH_UTF8・convert_string_allocate().

参照元 ads_del_dn()・ads_gen_add()・ads_gen_mod()・ldapsam_modify_entry()・print_share_mode()・shares_page()・show_parameter()・smb_krb5_parse_name()・smb_krb5_parse_name_norealm_conv()・smbldap_add()・smbldap_delete()・smbldap_modify()・smbldap_search_ext()・smbldap_set_mod().

{
        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 pull_ucs2	(	const void *	base_ptr,
		char *	dest,
		const void *	src,
		size_t	dest_len,
		size_t	src_len,
		int	flags
	)

Copy a string from a ucs2 source to a unix char* destination.

Flags can have: STR_TERMINATE means the string in src is null terminated. STR_NOALIGN means don't try to align. if STR_TERMINATE is set then src_len is ignored if it is -1. src_len is the length of the source area in bytes Return the number of bytes occupied by the string in src. The resulting string in "dest" is always null terminated.

charcnv.c の 1206 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string()・len・strnlen_w()・ucs2_align().

参照元 catia_string_replace()・pull_string_fn()・pull_ucs2_fstring()・pull_ucs2_pstring()・receive_getdc_response()・rpcstr_pull()・rpcstr_pull_unistr2_fstring()・rpcstr_pull_unistr2_talloc()・unistr2_tdup()・unistr2_to_ascii()・unistr3_to_ascii().

{
        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
	)

charcnv.c の 1254 行で定義されています。

参照先 pull_ucs2().

参照元 process_logon_packet()・strchr_m()・strnrchr_m()・strrchr_m().

{
        return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
}

size_t pull_ucs2_fstring	(	char *	dest,
		const void *	src
	)

charcnv.c の 1259 行で定義されています。

参照先 pull_ucs2().

参照元 process_logon_packet().

{
        return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
}

size_t pull_ucs2_talloc	(	TALLOC_CTX *	ctx,
		char **	dest,
		const smb_ucs2_t *	src
	)

Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1272 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string_talloc()・strlen_w().

参照元 map_multi_sz()・map_sz()・secrets_trusted_domains().

{
        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 pull_ucs2_allocate	(	char **	dest,
		const smb_ucs2_t *	src
	)

Copy a string from a UCS2 src to a unix char * destination, allocating a buffer

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1287 行で定義されています。

参照先 CH_UNIX・CH_UTF16LE・convert_string_allocate()・strlen_w().

参照元 check_push_ucs2()・strdup_lower()・strstr_m().

{
        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 pull_utf8_talloc	(	TALLOC_CTX *	ctx,
		char **	dest,
		const char *	src
	)

Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1302 行で定義されています。

参照先 CH_UNIX・CH_UTF8・convert_string_talloc().

参照元 ads_process_results()・ads_pull_string()・ads_pull_strings()・ads_pull_strvals()・ldapgroup2displayentry()・ldapuser2displayentry()・smbldap_talloc_dn()・smbldap_talloc_single_attribute().

{
        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 pull_utf8_allocate	(	char **	dest,
		const char *	src
	)

Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1317 行で定義されています。

参照先 CH_UNIX・CH_UTF8・convert_string_allocate().

参照元 ads_get_dn()・nt_printer_publish_ads()・smb_krb5_unparse_name()・smbldap_get_dn().

{
        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 pull_ascii_talloc	(	TALLOC_CTX *	ctx,
		char **	dest,
		const char *	src
	)

Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc

引数:

dest

always set at least to NULL

戻り値:

The number of bytes occupied by the string in the destination

charcnv.c の 1332 行で定義されています。

参照先 CH_DOS・CH_UNIX・convert_string_talloc().

参照元 read_ea_list_entry()・read_ea_name_list().

{
        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 push_string_fn	(	const char *	function,
		unsigned int	line,
		const void *	base_ptr,
		void *	dest,
		const char *	src,
		size_t	dest_len,
		int	flags
	)

Copy a string from a char* src to a unicode or ascii dos codepage destination choosing unicode or ascii based on the flags in the SMB buffer starting at base_ptr.

Return the number of bytes occupied by the string in the destination. 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_NOALIGN means don't do alignment. dest_len is the maximum length allowed in the destination. If dest_len is -1 then no maxiumum is used.

charcnv.c の 1353 行で定義されています。

参照先 clobber_region()・push_ascii()・push_ucs2().

参照元 clistr_push_fn()・srvstr_push_fn().

{
#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.
         */
#if 0
        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);
#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);
}

size_t pull_string_fn	(	const char *	function,
		unsigned int	line,
		const void *	base_ptr,
		char *	dest,
		const void *	src,
		size_t	dest_len,
		size_t	src_len,
		int	flags
	)

Copy a string from a unicode or ascii source (depending on the packet flags) to a char* destination.

Flags can have: 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_NOALIGN means don't do alignment. if STR_TERMINATE is set then src_len is ignored is it is -1 src_len is the length of the source area in bytes. Return the number of bytes occupied by the string in src. The resulting string in "dest" is always null terminated.

charcnv.c の 1394 行で定義されています。

参照先 clobber_region()・pull_ascii()・pull_ucs2().

参照元 clistr_pull_fn().

{
#ifdef DEVELOPER
        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);
}

size_t align_string	(	const void *	base_ptr,
		const char *	p,
		int	flags
	)

charcnv.c の 1409 行で定義されています。

参照先 ucs2_align().

参照元 clistr_align_in()・clistr_align_out()・get_lanman2_dir_entry().

{
        if (!(flags & STR_ASCII) && \
            ((flags & STR_UNICODE || \
              (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
                return ucs2_align(base_ptr, p, flags);
        }
        return 0;
}

codepoint_t next_codepoint	(	const char *	str,
		size_t *	size
	)

charcnv.c の 1429 行で定義されています。

参照先 buf・CH_UNIX・CH_UTF16LE・conv_handles・lazy_initialize_conv()・smb_iconv().

参照元 check_path_syntax_internal()・escape_shell_string()・set_conn_connectpath()・string_replace()・strlen_m().

{
        /* It cannot occupy more than 4 bytes in UTF16 format */
        uint8_t buf[4];
        smb_iconv_t descriptor;
        size_t ilen_orig;
        size_t ilen;
        size_t olen;
        char *outbuf;

        if ((str[0] & 0x80) == 0) {
                *size = 1;
                return (codepoint_t)str[0];
        }

        /* 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_orig = strnlen(str, 5);
        ilen = ilen_orig;

        lazy_initialize_conv();

        descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
        if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
                *size = 1;
                return INVALID_CODEPOINT;
        }

        /* This looks a little strange, but it is needed to cope
           with codepoints above 64k which are encoded as per RFC2781. */
        olen = 2;
        outbuf = (char *)buf;
        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
        if (olen == 2) {
                /* We failed to convert to a 2 byte character.
                   See if we can convert to a 4 UTF16-LE byte char encoding.
                */
                olen = 4;
                outbuf = (char *)buf;
                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
                if (olen == 4) {
                        /* We didn't convert any bytes */
                        *size = 1;
                        return INVALID_CODEPOINT;
                }
                olen = 4 - olen;
        } else {
                olen = 2 - 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;
}

---

変数

smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS] [static]

charcnv.c の 49 行で定義されています。

参照元 convert_string_allocate()・convert_string_internal()・gfree_charcnv()・init_iconv()・next_codepoint().

BOOL conv_silent [static]

charcnv.c の 50 行で定義されています。

参照元 convert_string_allocate()・convert_string_internal()・init_iconv()・push_ascii_nstring().

---