2 Unix SMB/CIFS implementation.
3 Character set conversion Extensions
4 Copyright (C) Igor Vergeichik <iverg@mail.ru> 2001
5 Copyright (C) Andrew Tridgell 2001
6 Copyright (C) Simo Sorce 2001
7 Copyright (C) Martin Pool 2003
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 /* We can parameterize this if someone complains.... JRA. */
27 char lp_failed_convert_char(void)
35 * @brief Character-set conversion routines built on our iconv.
37 * @note Samba's internal character set (at least in the 3.0 series)
38 * is always the same as the one for the Unix filesystem. It is
39 * <b>not</b> necessarily UTF-8 and may be different on machines that
40 * need i18n filenames to be compatible with Unix software. It does
41 * have to be a superset of ASCII. All multibyte sequences must start
42 * with a byte with the high bit set.
48 static smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
49 static BOOL conv_silent; /* Should we do a debug if the conversion fails ? */
52 * Return the name of a charset to give to iconv().
54 static const char *charset_name(charset_t ch)
56 const char *ret = NULL;
58 if (ch == CH_UTF16LE) ret = "UTF-16LE";
59 else if (ch == CH_UTF16BE) ret = "UTF-16BE";
60 else if (ch == CH_UNIX) ret = lp_unix_charset();
61 else if (ch == CH_DOS) ret = lp_dos_charset();
62 else if (ch == CH_DISPLAY) ret = lp_display_charset();
63 else if (ch == CH_UTF8) ret = "UTF8";
65 #if defined(HAVE_NL_LANGINFO) && defined(CODESET)
66 if (ret && !strcmp(ret, "LOCALE")) {
67 const char *ln = NULL;
70 setlocale(LC_ALL, "");
72 ln = nl_langinfo(CODESET);
74 /* Check whether the charset name is supported
76 smb_iconv_t handle = smb_iconv_open(ln,"UCS-2LE");
77 if (handle == (smb_iconv_t) -1) {
78 DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
81 DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
82 smb_iconv_close(handle);
89 if (!ret || !*ret) ret = "ASCII";
93 void lazy_initialize_conv(void)
95 static int initialized = False;
105 * Destroy global objects allocated by init_iconv()
107 void gfree_charcnv(void)
111 for (c1=0;c1<NUM_CHARSETS;c1++) {
112 for (c2=0;c2<NUM_CHARSETS;c2++) {
113 if ( conv_handles[c1][c2] ) {
114 smb_iconv_close( conv_handles[c1][c2] );
115 conv_handles[c1][c2] = 0;
122 * Initialize iconv conversion descriptors.
124 * This is called the first time it is needed, and also called again
125 * every time the configuration is reloaded, because the charset or
126 * codepage might have changed.
128 void init_iconv(void)
131 BOOL did_reload = False;
133 /* so that charset_name() works we need to get the UNIX<->UCS2 going
135 if (!conv_handles[CH_UNIX][CH_UTF16LE])
136 conv_handles[CH_UNIX][CH_UTF16LE] = smb_iconv_open(charset_name(CH_UTF16LE), "ASCII");
138 if (!conv_handles[CH_UTF16LE][CH_UNIX])
139 conv_handles[CH_UTF16LE][CH_UNIX] = smb_iconv_open("ASCII", charset_name(CH_UTF16LE));
141 for (c1=0;c1<NUM_CHARSETS;c1++) {
142 for (c2=0;c2<NUM_CHARSETS;c2++) {
143 const char *n1 = charset_name((charset_t)c1);
144 const char *n2 = charset_name((charset_t)c2);
145 if (conv_handles[c1][c2] &&
146 strcmp(n1, conv_handles[c1][c2]->from_name) == 0 &&
147 strcmp(n2, conv_handles[c1][c2]->to_name) == 0)
152 if (conv_handles[c1][c2])
153 smb_iconv_close(conv_handles[c1][c2]);
155 conv_handles[c1][c2] = smb_iconv_open(n2,n1);
156 if (conv_handles[c1][c2] == (smb_iconv_t)-1) {
157 DEBUG(0,("init_iconv: Conversion from %s to %s not supported\n",
158 charset_name((charset_t)c1), charset_name((charset_t)c2)));
159 if (c1 != CH_UTF16LE && c1 != CH_UTF16BE) {
162 if (c2 != CH_UTF16LE && c2 != CH_UTF16BE) {
165 DEBUG(0,("init_iconv: Attempting to replace with conversion from %s to %s\n",
167 conv_handles[c1][c2] = smb_iconv_open(n2,n1);
168 if (!conv_handles[c1][c2]) {
169 DEBUG(0,("init_iconv: Conversion from %s to %s failed", n1, n2));
170 smb_panic("init_iconv: conv_handle initialization failed");
177 /* XXX: Does this really get called every time the dos
178 * codepage changes? */
179 /* XXX: Is the did_reload test too strict? */
181 init_doschar_table();
188 * Convert string from one encoding to another, making error checking etc
189 * Slow path version - uses (slow) iconv.
191 * @param src pointer to source string (multibyte or singlebyte)
192 * @param srclen length of the source string in bytes
193 * @param dest pointer to destination string (multibyte or singlebyte)
194 * @param destlen maximal length allowed for string
195 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
196 * @returns the number of bytes occupied in the destination
198 * Ensure the srclen contains the terminating zero.
202 static size_t convert_string_internal(charset_t from, charset_t to,
203 void const *src, size_t srclen,
204 void *dest, size_t destlen, BOOL allow_bad_conv)
208 const char* inbuf = (const char*)src;
209 char* outbuf = (char*)dest;
210 smb_iconv_t descriptor;
212 lazy_initialize_conv();
214 descriptor = conv_handles[from][to];
216 if (srclen == (size_t)-1) {
217 if (from == CH_UTF16LE || from == CH_UTF16BE) {
218 srclen = (strlen_w((const smb_ucs2_t *)src)+1) * 2;
220 srclen = strlen((const char *)src)+1;
225 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
227 DEBUG(0,("convert_string_internal: Conversion not supported.\n"));
236 retval = smb_iconv(descriptor, &inbuf, &i_len, &outbuf, &o_len);
237 if(retval==(size_t)-1) {
238 const char *reason="unknown error";
241 reason="Incomplete multibyte sequence";
243 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
248 reason="No more room";
250 if (from == CH_UNIX) {
251 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
252 charset_name(from), charset_name(to),
253 (unsigned int)srclen, (unsigned int)destlen, (const char *)src));
255 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
256 charset_name(from), charset_name(to),
257 (unsigned int)srclen, (unsigned int)destlen));
262 reason="Illegal multibyte sequence";
264 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
270 DEBUG(0,("convert_string_internal: Conversion error: %s(%s)\n",reason,inbuf));
273 /* smb_panic(reason); */
275 return destlen-o_len;
280 * Conversion not supported. This is actually an error, but there are so
281 * many misconfigured iconv systems and smb.conf's out there we can't just
282 * fail. Do a very bad conversion instead.... JRA.
286 if (o_len == 0 || i_len == 0)
287 return destlen - o_len;
289 if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
290 ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
291 /* Can't convert from utf16 any endian to multibyte.
292 Replace with the default fail char.
295 return destlen - o_len;
297 *outbuf = lp_failed_convert_char();
306 if (o_len == 0 || i_len == 0)
307 return destlen - o_len;
309 /* Keep trying with the next char... */
312 } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
313 /* Can't convert to UTF16LE - just widen by adding the
314 default fail char then zero.
317 return destlen - o_len;
319 outbuf[0] = lp_failed_convert_char();
328 if (o_len == 0 || i_len == 0)
329 return destlen - o_len;
331 /* Keep trying with the next char... */
334 } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
335 to != CH_UTF16LE && to != CH_UTF16BE) {
336 /* Failed multibyte to multibyte. Just copy the default fail char and
338 outbuf[0] = lp_failed_convert_char();
346 if (o_len == 0 || i_len == 0)
347 return destlen - o_len;
349 /* Keep trying with the next char... */
353 /* Keep compiler happy.... */
354 return destlen - o_len;
360 * Convert string from one encoding to another, making error checking etc
361 * Fast path version - handles ASCII first.
363 * @param src pointer to source string (multibyte or singlebyte)
364 * @param srclen length of the source string in bytes, or -1 for nul terminated.
365 * @param dest pointer to destination string (multibyte or singlebyte)
366 * @param destlen maximal length allowed for string - *NEVER* -1.
367 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
368 * @returns the number of bytes occupied in the destination
370 * Ensure the srclen contains the terminating zero.
372 * This function has been hand-tuned to provide a fast path.
373 * Don't change unless you really know what you are doing. JRA.
376 size_t convert_string(charset_t from, charset_t to,
377 void const *src, size_t srclen,
378 void *dest, size_t destlen, BOOL allow_bad_conv)
381 * NB. We deliberately don't do a strlen here if srclen == -1.
382 * This is very expensive over millions of calls and is taken
383 * care of in the slow path in convert_string_internal. JRA.
387 SMB_ASSERT(destlen != (size_t)-1);
393 if (from != CH_UTF16LE && from != CH_UTF16BE && to != CH_UTF16LE && to != CH_UTF16BE) {
394 const unsigned char *p = (const unsigned char *)src;
395 unsigned char *q = (unsigned char *)dest;
396 size_t slen = srclen;
397 size_t dlen = destlen;
398 unsigned char lastp = '\0';
401 /* If all characters are ascii, fast path here. */
402 while (slen && dlen) {
403 if ((lastp = *p) <= 0x7f) {
405 if (slen != (size_t)-1) {
413 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
416 return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
421 /* Even if we fast path we should note if we ran out of room. */
422 if (((slen != (size_t)-1) && slen) ||
423 ((slen == (size_t)-1) && lastp)) {
428 } else if (from == CH_UTF16LE && to != CH_UTF16LE) {
429 const unsigned char *p = (const unsigned char *)src;
430 unsigned char *q = (unsigned char *)dest;
432 size_t slen = srclen;
433 size_t dlen = destlen;
434 unsigned char lastp = '\0';
436 /* If all characters are ascii, fast path here. */
437 while (((slen == (size_t)-1) || (slen >= 2)) && dlen) {
438 if (((lastp = *p) <= 0x7f) && (p[1] == 0)) {
440 if (slen != (size_t)-1) {
449 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
452 return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
457 /* Even if we fast path we should note if we ran out of room. */
458 if (((slen != (size_t)-1) && slen) ||
459 ((slen == (size_t)-1) && lastp)) {
464 } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
465 const unsigned char *p = (const unsigned char *)src;
466 unsigned char *q = (unsigned char *)dest;
468 size_t slen = srclen;
469 size_t dlen = destlen;
470 unsigned char lastp = '\0';
472 /* If all characters are ascii, fast path here. */
473 while (slen && (dlen >= 2)) {
474 if ((lastp = *p) <= 0x7F) {
477 if (slen != (size_t)-1) {
485 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
488 return retval + convert_string_internal(from, to, p, slen, q, dlen, allow_bad_conv);
493 /* Even if we fast path we should note if we ran out of room. */
494 if (((slen != (size_t)-1) && slen) ||
495 ((slen == (size_t)-1) && lastp)) {
502 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
505 return convert_string_internal(from, to, src, srclen, dest, destlen, allow_bad_conv);
509 * Convert between character sets, allocating a new buffer for the result.
511 * @param ctx TALLOC_CTX to use to allocate with. If NULL use malloc.
512 * (this is a bad interface and needs fixing. JRA).
513 * @param srclen length of source buffer.
514 * @param dest always set at least to NULL
515 * @note -1 is not accepted for srclen.
517 * @returns Size in bytes of the converted string; or -1 in case of error.
519 * Ensure the srclen contains the terminating zero.
521 * I hate the goto's in this function. It's embarressing.....
522 * There has to be a cleaner way to do this. JRA.
525 size_t convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
526 void const *src, size_t srclen, void *dst, BOOL allow_bad_conv)
528 size_t i_len, o_len, destlen = MAX(srclen, 512);
530 const char *inbuf = (const char *)src;
531 char *outbuf = NULL, *ob = NULL;
532 smb_iconv_t descriptor;
533 void **dest = (void **)dst;
537 if (src == NULL || srclen == (size_t)-1)
542 lazy_initialize_conv();
544 descriptor = conv_handles[from][to];
546 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
548 DEBUG(0,("convert_string_allocate: Conversion not supported.\n"));
554 if ((destlen*2) < destlen) {
555 /* wrapped ! abort. */
557 DEBUG(0, ("convert_string_allocate: destlen wrapped !\n"));
562 destlen = destlen * 2;
566 ob = (char *)TALLOC_REALLOC(ctx, ob, destlen);
568 ob = (char *)SMB_REALLOC(ob, destlen);
572 DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
581 retval = smb_iconv(descriptor,
584 if(retval == (size_t)-1) {
585 const char *reason="unknown error";
588 reason="Incomplete multibyte sequence";
590 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
597 reason="Illegal multibyte sequence";
599 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
605 DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
606 /* smb_panic(reason); */
617 destlen = destlen - o_len;
619 ob = (char *)TALLOC_REALLOC(ctx,ob,destlen);
621 ob = (char *)SMB_REALLOC(ob,destlen);
624 if (destlen && !ob) {
625 DEBUG(0, ("convert_string_allocate: out of memory!\n"));
635 * Conversion not supported. This is actually an error, but there are so
636 * many misconfigured iconv systems and smb.conf's out there we can't just
637 * fail. Do a very bad conversion instead.... JRA.
641 if (o_len == 0 || i_len == 0)
644 if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
645 ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
646 /* Can't convert from utf16 any endian to multibyte.
647 Replace with the default fail char.
654 *outbuf = lp_failed_convert_char();
663 if (o_len == 0 || i_len == 0)
666 /* Keep trying with the next char... */
669 } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
670 /* Can't convert to UTF16LE - just widen by adding the
671 default fail char then zero.
676 outbuf[0] = lp_failed_convert_char();
685 if (o_len == 0 || i_len == 0)
688 /* Keep trying with the next char... */
691 } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
692 to != CH_UTF16LE && to != CH_UTF16BE) {
693 /* Failed multibyte to multibyte. Just copy the default fail char and
695 outbuf[0] = lp_failed_convert_char();
703 if (o_len == 0 || i_len == 0)
706 /* Keep trying with the next char... */
710 /* Keep compiler happy.... */
717 * Convert between character sets, allocating a new buffer using talloc for the result.
719 * @param srclen length of source buffer.
720 * @param dest always set at least to NULL
721 * @note -1 is not accepted for srclen.
723 * @returns Size in bytes of the converted string; or -1 in case of error.
725 size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
726 void const *src, size_t srclen, void *dst,
729 void **dest = (void **)dst;
733 dest_len=convert_string_allocate(ctx, from, to, src, srclen, dest, allow_bad_conv);
734 if (dest_len == (size_t)-1)
741 size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
746 size = push_ucs2_allocate(&buffer, src);
747 if (size == (size_t)-1) {
748 smb_panic("failed to create UCS2 buffer");
750 if (!strupper_w(buffer) && (dest == src)) {
755 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
761 strdup() a unix string to upper case.
765 char *strdup_upper(const char *s)
768 const unsigned char *p = (const unsigned char *)s;
769 unsigned char *q = (unsigned char *)out_buffer;
771 /* this is quite a common operation, so we want it to be
772 fast. We optimise for the ascii case, knowing that all our
773 supported multi-byte character sets are ascii-compatible
774 (ie. they match for the first 128 chars) */
779 *q++ = toupper_ascii(*p);
783 if (p - ( const unsigned char *)s >= sizeof(pstring))
791 size = convert_string(CH_UNIX, CH_UTF16LE, s, -1, buffer, sizeof(buffer), True);
792 if (size == (size_t)-1) {
798 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, -1, out_buffer, sizeof(out_buffer), True);
799 if (size == (size_t)-1) {
804 return SMB_STRDUP(out_buffer);
808 talloc_strdup() a unix string to upper case.
811 char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s)
813 char *out_buffer = talloc_strdup(ctx,s);
814 const unsigned char *p = (const unsigned char *)s;
815 unsigned char *q = (unsigned char *)out_buffer;
821 /* this is quite a common operation, so we want it to be
822 fast. We optimise for the ascii case, knowing that all our
823 supported multi-byte character sets are ascii-compatible
824 (ie. they match for the first 128 chars) */
829 *q++ = toupper_ascii(*p);
838 smb_ucs2_t *ubuf = NULL;
840 /* We're not using the ascii buffer above. */
841 TALLOC_FREE(out_buffer);
843 size = convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE,
847 if (size == (size_t)-1) {
853 size = convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX,
858 /* Don't need the intermediate buffer
864 if (size == (size_t)-1) {
872 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
875 smb_ucs2_t *buffer = NULL;
877 size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
878 (void **)(void *)&buffer, True);
879 if (size == (size_t)-1 || !buffer) {
880 smb_panic("failed to create UCS2 buffer");
882 if (!strlower_w(buffer) && (dest == src)) {
886 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
892 strdup() a unix string to lower case.
895 char *strdup_lower(const char *s)
898 smb_ucs2_t *buffer = NULL;
901 size = push_ucs2_allocate(&buffer, s);
902 if (size == -1 || !buffer) {
908 size = pull_ucs2_allocate(&out_buffer, buffer);
911 if (size == (size_t)-1) {
918 static size_t ucs2_align(const void *base_ptr, const void *p, int flags)
920 if (flags & (STR_NOALIGN|STR_ASCII))
922 return PTR_DIFF(p, base_ptr) & 1;
927 * Copy a string from a char* unix src to a dos codepage string destination.
929 * @return the number of bytes occupied by the string in the destination.
931 * @param flags can include
933 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
934 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
937 * @param dest_len the maximum length in bytes allowed in the
938 * destination. If @p dest_len is -1 then no maximum is used.
940 size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
942 size_t src_len = strlen(src);
945 /* treat a pstring as "unlimited" length */
946 if (dest_len == (size_t)-1)
947 dest_len = sizeof(pstring);
949 if (flags & STR_UPPER) {
950 pstrcpy(tmpbuf, src);
955 if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
958 return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
961 size_t push_ascii_fstring(void *dest, const char *src)
963 return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
966 size_t push_ascii_pstring(void *dest, const char *src)
968 return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
971 /********************************************************************
972 Push an nstring - ensure null terminated. Written by
973 moriyama@miraclelinux.com (MORIYAMA Masayuki).
974 ********************************************************************/
976 size_t push_ascii_nstring(void *dest, const char *src)
978 size_t i, buffer_len, dest_len;
982 buffer_len = push_ucs2_allocate(&buffer, src);
983 if (buffer_len == (size_t)-1) {
984 smb_panic("failed to create UCS2 buffer");
987 /* We're using buffer_len below to count ucs2 characters, not bytes. */
988 buffer_len /= sizeof(smb_ucs2_t);
991 for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
992 unsigned char mb[10];
993 /* Convert one smb_ucs2_t character at a time. */
994 size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
995 if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
996 memcpy((char *)dest + dest_len, mb, mb_len);
1003 ((char *)dest)[dest_len] = '\0';
1006 conv_silent = False;
1011 * Copy a string from a dos codepage source to a unix char* destination.
1013 * The resulting string in "dest" is always null terminated.
1015 * @param flags can have:
1017 * <dt>STR_TERMINATE</dt>
1018 * <dd>STR_TERMINATE means the string in @p src
1019 * is null terminated, and src_len is ignored.</dd>
1022 * @param src_len is the length of the source area in bytes.
1023 * @returns the number of bytes occupied by the string in @p src.
1025 size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
1029 if (dest_len == (size_t)-1)
1030 dest_len = sizeof(pstring);
1032 if (flags & STR_TERMINATE) {
1033 if (src_len == (size_t)-1) {
1034 src_len = strlen((const char *)src) + 1;
1036 size_t len = strnlen((const char *)src, src_len);
1043 ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
1044 if (ret == (size_t)-1) {
1049 if (dest_len && ret) {
1050 /* Did we already process the terminating zero ? */
1051 if (dest[MIN(ret-1, dest_len-1)] != 0) {
1052 dest[MIN(ret, dest_len-1)] = 0;
1062 * Copy a string from a dos codepage source to a unix char* destination.
1064 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1067 * The resulting string in "dest" is always null terminated.
1069 * @param flags can have:
1071 * <dt>STR_TERMINATE</dt>
1072 * <dd>STR_TERMINATE means the string in @p src
1073 * is null terminated, and src_len is ignored.</dd>
1076 * @param src_len is the length of the source area in bytes.
1077 * @returns the number of bytes occupied by the string in @p src.
1080 static size_t pull_ascii_base_talloc(TALLOC_CTX *ctx,
1087 size_t dest_len = 0;
1090 /* Ensure we never use the braindead "malloc" varient. */
1092 smb_panic("NULL talloc CTX in pull_ascii_base_talloc\n");
1098 if (flags & STR_TERMINATE) {
1099 if (src_len == (size_t)-1) {
1100 src_len = strlen((const char *)src) + 1;
1102 size_t len = strnlen((const char *)src, src_len);
1107 /* Ensure we don't use an insane length from the client. */
1108 if (src_len >= 1024*1024) {
1109 char *msg = talloc_asprintf(ctx,
1110 "Bad src length (%u) in "
1111 "pull_ascii_base_talloc",
1117 dest_len = convert_string_allocate(ctx,
1125 if (dest_len == (size_t)-1) {
1129 if (dest_len && dest) {
1130 /* Did we already process the terminating zero ? */
1131 if (dest[dest_len-1] != 0) {
1132 dest[dest_len-1] = 0;
1143 size_t pull_ascii_pstring(char *dest, const void *src)
1145 return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
1148 size_t pull_ascii_fstring(char *dest, const void *src)
1150 return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
1153 /* When pulling an nstring it can expand into a larger size (dos cp -> utf8). Cope with this. */
1155 size_t pull_ascii_nstring(char *dest, size_t dest_len, const void *src)
1157 return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
1161 * Copy a string from a char* src to a unicode destination.
1163 * @returns the number of bytes occupied by the string in the destination.
1165 * @param flags can have:
1168 * <dt>STR_TERMINATE <dd>means include the null termination.
1169 * <dt>STR_UPPER <dd>means uppercase in the destination.
1170 * <dt>STR_NOALIGN <dd>means don't do alignment.
1173 * @param dest_len is the maximum length allowed in the
1174 * destination. If dest_len is -1 then no maxiumum is used.
1177 size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
1183 /* treat a pstring as "unlimited" length */
1184 if (dest_len == (size_t)-1)
1185 dest_len = sizeof(pstring);
1187 if (flags & STR_TERMINATE)
1188 src_len = (size_t)-1;
1190 src_len = strlen(src);
1192 if (ucs2_align(base_ptr, dest, flags)) {
1194 dest = (void *)((char *)dest + 1);
1200 /* ucs2 is always a multiple of 2 bytes */
1203 ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
1204 if (ret == (size_t)-1) {
1210 if (flags & STR_UPPER) {
1211 smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
1214 /* We check for i < (ret / 2) below as the dest string isn't null
1215 terminated if STR_TERMINATE isn't set. */
1217 for (i = 0; i < (ret / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
1218 smb_ucs2_t v = toupper_w(dest_ucs2[i]);
1219 if (v != dest_ucs2[i]) {
1230 * Copy a string from a unix char* src to a UCS2 destination,
1231 * allocating a buffer using talloc().
1233 * @param dest always set at least to NULL
1235 * @returns The number of bytes occupied by the string in the destination
1236 * or -1 in case of error.
1238 size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
1240 size_t src_len = strlen(src)+1;
1243 return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1248 * Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
1250 * @param dest always set at least to NULL
1252 * @returns The number of bytes occupied by the string in the destination
1253 * or -1 in case of error.
1256 size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
1258 size_t src_len = strlen(src)+1;
1261 return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1265 Copy a string from a char* src to a UTF-8 destination.
1266 Return the number of bytes occupied by the string in the destination
1268 STR_TERMINATE means include the null termination
1269 STR_UPPER means uppercase in the destination
1270 dest_len is the maximum length allowed in the destination. If dest_len
1271 is -1 then no maxiumum is used.
1274 static size_t push_utf8(void *dest, const char *src, size_t dest_len, int flags)
1276 size_t src_len = strlen(src);
1279 /* treat a pstring as "unlimited" length */
1280 if (dest_len == (size_t)-1)
1281 dest_len = sizeof(pstring);
1283 if (flags & STR_UPPER) {
1284 pstrcpy(tmpbuf, src);
1289 if (flags & STR_TERMINATE)
1292 return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
1295 size_t push_utf8_fstring(void *dest, const char *src)
1297 return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
1301 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
1303 * @param dest always set at least to NULL
1305 * @returns The number of bytes occupied by the string in the destination
1308 size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1310 size_t src_len = strlen(src)+1;
1313 return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest, True);
1317 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
1319 * @param dest always set at least to NULL
1321 * @returns The number of bytes occupied by the string in the destination
1324 size_t push_utf8_allocate(char **dest, const char *src)
1326 size_t src_len = strlen(src)+1;
1329 return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
1333 Copy a string from a ucs2 source to a unix char* destination.
1335 STR_TERMINATE means the string in src is null terminated.
1336 STR_NOALIGN means don't try to align.
1337 if STR_TERMINATE is set then src_len is ignored if it is -1.
1338 src_len is the length of the source area in bytes
1339 Return the number of bytes occupied by the string in src.
1340 The resulting string in "dest" is always null terminated.
1343 size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
1347 if (dest_len == (size_t)-1)
1348 dest_len = sizeof(pstring);
1350 if (ucs2_align(base_ptr, src, flags)) {
1351 src = (const void *)((const char *)src + 1);
1352 if (src_len != (size_t)-1)
1356 if (flags & STR_TERMINATE) {
1357 /* src_len -1 is the default for null terminated strings. */
1358 if (src_len != (size_t)-1) {
1359 size_t len = strnlen_w((const smb_ucs2_t *)src,
1361 if (len < src_len/2)
1367 /* ucs2 is always a multiple of 2 bytes */
1368 if (src_len != (size_t)-1)
1371 ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
1372 if (ret == (size_t)-1) {
1376 if (src_len == (size_t)-1)
1379 if (dest_len && ret) {
1380 /* Did we already process the terminating zero ? */
1381 if (dest[MIN(ret-1, dest_len-1)] != 0) {
1382 dest[MIN(ret, dest_len-1)] = 0;
1392 Copy a string from a ucs2 source to a unix char* destination.
1393 Talloc version with a base pointer.
1394 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1397 STR_TERMINATE means the string in src is null terminated.
1398 STR_NOALIGN means don't try to align.
1399 if STR_TERMINATE is set then src_len is ignored if it is -1.
1400 src_len is the length of the source area in bytes
1401 Return the number of bytes occupied by the string in src.
1402 The resulting string in "dest" is always null terminated.
1405 static size_t pull_ucs2_base_talloc(TALLOC_CTX *ctx,
1406 const void *base_ptr,
1418 /* Ensure we never use the braindead "malloc" varient. */
1420 smb_panic("NULL talloc CTX in pull_ucs2_base_talloc\n");
1424 if (ucs2_align(base_ptr, src, flags)) {
1425 src = (const void *)((const char *)src + 1);
1426 if (src_len != (size_t)-1)
1430 if (flags & STR_TERMINATE) {
1431 /* src_len -1 is the default for null terminated strings. */
1432 if (src_len != (size_t)-1) {
1433 size_t len = strnlen_w((const smb_ucs2_t *)src,
1435 if (len < src_len/2)
1439 /* Ensure we don't use an insane length from the client. */
1440 if (src_len >= 1024*1024) {
1441 smb_panic("Bad src length in pull_ucs2_base_talloc\n");
1445 /* ucs2 is always a multiple of 2 bytes */
1446 if (src_len != (size_t)-1) {
1450 dest_len = convert_string_talloc(ctx,
1457 if (dest_len == (size_t)-1) {
1461 if (src_len == (size_t)-1)
1462 src_len = dest_len*2;
1465 /* Did we already process the terminating zero ? */
1466 if (dest[dest_len-1] != 0) {
1467 size_t size = talloc_get_size(dest);
1468 /* Have we got space to append the '\0' ? */
1469 if (size <= dest_len) {
1471 dest = TALLOC_REALLOC(ctx, dest,
1475 dest_len = (size_t)-1;
1480 dest[dest_len] = '\0';
1491 size_t pull_ucs2_pstring(char *dest, const void *src)
1493 return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
1496 size_t pull_ucs2_fstring(char *dest, const void *src)
1498 return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
1502 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
1504 * @param dest always set at least to NULL
1506 * @returns The number of bytes occupied by the string in the destination
1509 size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
1511 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1513 return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1517 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
1519 * @param dest always set at least to NULL
1521 * @returns The number of bytes occupied by the string in the destination
1524 size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
1526 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1528 return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1532 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
1534 * @param dest always set at least to NULL
1536 * @returns The number of bytes occupied by the string in the destination
1539 size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1541 size_t src_len = strlen(src)+1;
1543 return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1547 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
1549 * @param dest always set at least to NULL
1551 * @returns The number of bytes occupied by the string in the destination
1554 size_t pull_utf8_allocate(char **dest, const char *src)
1556 size_t src_len = strlen(src)+1;
1558 return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1562 * Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
1564 * @param dest always set at least to NULL
1566 * @returns The number of bytes occupied by the string in the destination
1569 size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1571 size_t src_len = strlen(src)+1;
1573 return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
1577 Copy a string from a char* src to a unicode or ascii
1578 dos codepage destination choosing unicode or ascii based on the
1579 flags in the SMB buffer starting at base_ptr.
1580 Return the number of bytes occupied by the string in the destination.
1582 STR_TERMINATE means include the null termination.
1583 STR_UPPER means uppercase in the destination.
1584 STR_ASCII use ascii even with unicode packet.
1585 STR_NOALIGN means don't do alignment.
1586 dest_len is the maximum length allowed in the destination. If dest_len
1587 is -1 then no maxiumum is used.
1590 size_t push_string_fn(const char *function, unsigned int line,
1591 const void *base_ptr, uint16 flags2,
1592 void *dest, const char *src,
1593 size_t dest_len, int flags)
1596 /* We really need to zero fill here, not clobber
1597 * region, as we want to ensure that valgrind thinks
1598 * all of the outgoing buffer has been written to
1599 * so a send() or write() won't trap an error.
1603 if (dest_len != (size_t)-1)
1604 clobber_region(function, line, dest, dest_len);
1606 if (dest_len != (size_t)-1)
1607 memset(dest, '\0', dest_len);
1611 if (!(flags & STR_ASCII) && \
1612 ((flags & STR_UNICODE || \
1613 (flags2 & FLAGS2_UNICODE_STRINGS)))) {
1614 return push_ucs2(base_ptr, dest, src, dest_len, flags);
1616 return push_ascii(dest, src, dest_len, flags);
1621 Copy a string from a unicode or ascii source (depending on
1622 the packet flags) to a char* destination.
1624 STR_TERMINATE means the string in src is null terminated.
1625 STR_UNICODE means to force as unicode.
1626 STR_ASCII use ascii even with unicode packet.
1627 STR_NOALIGN means don't do alignment.
1628 if STR_TERMINATE is set then src_len is ignored is it is -1
1629 src_len is the length of the source area in bytes.
1630 Return the number of bytes occupied by the string in src.
1631 The resulting string in "dest" is always null terminated.
1634 size_t pull_string_fn(const char *function, unsigned int line,
1635 const void *base_ptr, uint16 smb_flags2, char *dest,
1636 const void *src, size_t dest_len, size_t src_len,
1640 if (dest_len != (size_t)-1)
1641 clobber_region(function, line, dest, dest_len);
1644 if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
1645 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1649 if (!(flags & STR_ASCII) && \
1650 ((flags & STR_UNICODE || \
1651 (smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
1652 return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
1654 return pull_ascii(dest, src, dest_len, src_len, flags);
1658 Copy a string from a unicode or ascii source (depending on
1659 the packet flags) to a char* destination.
1660 Variant that uses talloc.
1662 STR_TERMINATE means the string in src is null terminated.
1663 STR_UNICODE means to force as unicode.
1664 STR_ASCII use ascii even with unicode packet.
1665 STR_NOALIGN means don't do alignment.
1666 if STR_TERMINATE is set then src_len is ignored is it is -1
1667 src_len is the length of the source area in bytes.
1668 Return the number of bytes occupied by the string in src.
1669 The resulting string in "dest" is always null terminated.
1672 size_t pull_string_talloc_fn(const char *function,
1675 const void *base_ptr,
1682 if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
1683 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1687 if (!(flags & STR_ASCII) && \
1688 ((flags & STR_UNICODE || \
1689 (smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
1690 return pull_ucs2_base_talloc(ctx,
1697 return pull_ascii_base_talloc(ctx,
1705 size_t align_string(const void *base_ptr, const char *p, int flags)
1707 if (!(flags & STR_ASCII) && \
1708 ((flags & STR_UNICODE || \
1709 (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
1710 return ucs2_align(base_ptr, p, flags);
1716 Return the unicode codepoint for the next multi-byte CH_UNIX character
1717 in the string. The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
1719 Also return the number of bytes consumed (which tells the caller
1720 how many bytes to skip to get to the next CH_UNIX character).
1722 Return INVALID_CODEPOINT if the next character cannot be converted.
1725 codepoint_t next_codepoint(const char *str, size_t *size)
1727 /* It cannot occupy more than 4 bytes in UTF16 format */
1729 smb_iconv_t descriptor;
1735 if ((str[0] & 0x80) == 0) {
1737 return (codepoint_t)str[0];
1740 /* We assume that no multi-byte character can take
1741 more than 5 bytes. This is OK as we only
1742 support codepoints up to 1M */
1744 ilen_orig = strnlen(str, 5);
1747 lazy_initialize_conv();
1749 descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
1750 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
1752 return INVALID_CODEPOINT;
1755 /* This looks a little strange, but it is needed to cope
1756 with codepoints above 64k which are encoded as per RFC2781. */
1758 outbuf = (char *)buf;
1759 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1761 /* We failed to convert to a 2 byte character.
1762 See if we can convert to a 4 UTF16-LE byte char encoding.
1765 outbuf = (char *)buf;
1766 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1768 /* We didn't convert any bytes */
1770 return INVALID_CODEPOINT;
1777 *size = ilen_orig - ilen;
1780 /* 2 byte, UTF16-LE encoded value. */
1781 return (codepoint_t)SVAL(buf, 0);
1784 /* Decode a 4 byte UTF16-LE character manually.
1785 See RFC2871 for the encoding machanism.
1787 codepoint_t w1 = SVAL(buf,0) & ~0xD800;
1788 codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
1790 return (codepoint_t)0x10000 +
1794 /* no other length is valid */
1795 return INVALID_CODEPOINT;