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.
764 char *strdup_upper(const char *s)
766 char *out_buffer = SMB_STRDUP(s);
767 const unsigned char *p = (const unsigned char *)s;
768 unsigned char *q = (unsigned char *)out_buffer;
774 /* this is quite a common operation, so we want it to be
775 fast. We optimise for the ascii case, knowing that all our
776 supported multi-byte character sets are ascii-compatible
777 (ie. they match for the first 128 chars) */
782 *q++ = toupper_ascii(*p);
789 smb_ucs2_t *buffer = NULL;
791 SAFE_FREE(out_buffer);
792 size = convert_string_allocate(NULL,
797 (void **)(void *)&buffer,
799 if (size == (size_t)-1) {
805 size = convert_string_allocate(NULL,
810 (void **)(void *)&out_buffer,
813 /* Don't need the intermediate buffer
818 if (size == (size_t)-1) {
827 talloc_strdup() a unix string to upper case.
830 char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *s)
832 char *out_buffer = talloc_strdup(ctx,s);
833 const unsigned char *p = (const unsigned char *)s;
834 unsigned char *q = (unsigned char *)out_buffer;
840 /* this is quite a common operation, so we want it to be
841 fast. We optimise for the ascii case, knowing that all our
842 supported multi-byte character sets are ascii-compatible
843 (ie. they match for the first 128 chars) */
848 *q++ = toupper_ascii(*p);
855 smb_ucs2_t *ubuf = NULL;
857 /* We're not using the ascii buffer above. */
858 TALLOC_FREE(out_buffer);
860 size = convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE,
864 if (size == (size_t)-1) {
870 size = convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX,
875 /* Don't need the intermediate buffer
881 if (size == (size_t)-1) {
889 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
892 smb_ucs2_t *buffer = NULL;
894 size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
895 (void **)(void *)&buffer, True);
896 if (size == (size_t)-1 || !buffer) {
897 smb_panic("failed to create UCS2 buffer");
899 if (!strlower_w(buffer) && (dest == src)) {
903 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
909 strdup() a unix string to lower case.
912 char *strdup_lower(const char *s)
915 smb_ucs2_t *buffer = NULL;
918 size = push_ucs2_allocate(&buffer, s);
919 if (size == -1 || !buffer) {
925 size = pull_ucs2_allocate(&out_buffer, buffer);
928 if (size == (size_t)-1) {
935 static size_t ucs2_align(const void *base_ptr, const void *p, int flags)
937 if (flags & (STR_NOALIGN|STR_ASCII))
939 return PTR_DIFF(p, base_ptr) & 1;
944 * Copy a string from a char* unix src to a dos codepage string destination.
946 * @return the number of bytes occupied by the string in the destination.
948 * @param flags can include
950 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
951 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
954 * @param dest_len the maximum length in bytes allowed in the
957 size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
959 size_t src_len = strlen(src);
963 /* No longer allow a length of -1. */
964 if (dest_len == (size_t)-1) {
965 smb_panic("push_ascii - dest_len == -1");
969 if (flags & STR_UPPER) {
970 tmpbuf = SMB_STRDUP(src);
972 smb_panic("malloc fail");
979 if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
983 ret = convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
985 if (ret == (size_t)-1) {
991 size_t push_ascii_fstring(void *dest, const char *src)
993 return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
996 size_t push_ascii_pstring(void *dest, const char *src)
998 return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
1001 /********************************************************************
1002 Push an nstring - ensure null terminated. Written by
1003 moriyama@miraclelinux.com (MORIYAMA Masayuki).
1004 ********************************************************************/
1006 size_t push_ascii_nstring(void *dest, const char *src)
1008 size_t i, buffer_len, dest_len;
1012 buffer_len = push_ucs2_allocate(&buffer, src);
1013 if (buffer_len == (size_t)-1) {
1014 smb_panic("failed to create UCS2 buffer");
1017 /* We're using buffer_len below to count ucs2 characters, not bytes. */
1018 buffer_len /= sizeof(smb_ucs2_t);
1021 for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
1022 unsigned char mb[10];
1023 /* Convert one smb_ucs2_t character at a time. */
1024 size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
1025 if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
1026 memcpy((char *)dest + dest_len, mb, mb_len);
1033 ((char *)dest)[dest_len] = '\0';
1036 conv_silent = False;
1040 /********************************************************************
1041 Push and malloc an ascii string. src and dest null terminated.
1042 ********************************************************************/
1044 size_t push_ascii_allocate(char **dest, const char *src)
1046 size_t src_len = strlen(src)+1;
1049 return convert_string_allocate(NULL, CH_UNIX, CH_DOS, src, src_len, (void **)dest, True);
1053 * Copy a string from a dos codepage source to a unix char* destination.
1055 * The resulting string in "dest" is always null terminated.
1057 * @param flags can have:
1059 * <dt>STR_TERMINATE</dt>
1060 * <dd>STR_TERMINATE means the string in @p src
1061 * is null terminated, and src_len is ignored.</dd>
1064 * @param src_len is the length of the source area in bytes.
1065 * @returns the number of bytes occupied by the string in @p src.
1067 size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
1071 if (dest_len == (size_t)-1)
1072 dest_len = sizeof(pstring);
1074 if (flags & STR_TERMINATE) {
1075 if (src_len == (size_t)-1) {
1076 src_len = strlen((const char *)src) + 1;
1078 size_t len = strnlen((const char *)src, src_len);
1085 ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
1086 if (ret == (size_t)-1) {
1091 if (dest_len && ret) {
1092 /* Did we already process the terminating zero ? */
1093 if (dest[MIN(ret-1, dest_len-1)] != 0) {
1094 dest[MIN(ret, dest_len-1)] = 0;
1104 * Copy a string from a dos codepage source to a unix char* destination.
1106 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1109 * The resulting string in "dest" is always null terminated.
1111 * @param flags can have:
1113 * <dt>STR_TERMINATE</dt>
1114 * <dd>STR_TERMINATE means the string in @p src
1115 * is null terminated, and src_len is ignored.</dd>
1118 * @param src_len is the length of the source area in bytes.
1119 * @returns the number of bytes occupied by the string in @p src.
1122 static size_t pull_ascii_base_talloc(TALLOC_CTX *ctx,
1129 size_t dest_len = 0;
1132 /* Ensure we never use the braindead "malloc" varient. */
1134 smb_panic("NULL talloc CTX in pull_ascii_base_talloc\n");
1140 if (flags & STR_TERMINATE) {
1141 if (src_len == (size_t)-1) {
1142 src_len = strlen((const char *)src) + 1;
1144 size_t len = strnlen((const char *)src, src_len);
1149 /* Ensure we don't use an insane length from the client. */
1150 if (src_len >= 1024*1024) {
1151 char *msg = talloc_asprintf(ctx,
1152 "Bad src length (%u) in "
1153 "pull_ascii_base_talloc",
1154 (unsigned int)src_len);
1159 dest_len = convert_string_allocate(ctx,
1167 if (dest_len == (size_t)-1) {
1171 if (dest_len && dest) {
1172 /* Did we already process the terminating zero ? */
1173 if (dest[dest_len-1] != 0) {
1174 dest[dest_len-1] = 0;
1185 size_t pull_ascii_pstring(char *dest, const void *src)
1187 return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
1190 size_t pull_ascii_fstring(char *dest, const void *src)
1192 return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
1195 /* When pulling an nstring it can expand into a larger size (dos cp -> utf8). Cope with this. */
1197 size_t pull_ascii_nstring(char *dest, size_t dest_len, const void *src)
1199 return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
1203 * Copy a string from a char* src to a unicode destination.
1205 * @returns the number of bytes occupied by the string in the destination.
1207 * @param flags can have:
1210 * <dt>STR_TERMINATE <dd>means include the null termination.
1211 * <dt>STR_UPPER <dd>means uppercase in the destination.
1212 * <dt>STR_NOALIGN <dd>means don't do alignment.
1215 * @param dest_len is the maximum length allowed in the
1216 * destination. If dest_len is -1 then no maxiumum is used.
1219 size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
1225 /* treat a pstring as "unlimited" length */
1226 if (dest_len == (size_t)-1)
1227 dest_len = sizeof(pstring);
1229 if (flags & STR_TERMINATE)
1230 src_len = (size_t)-1;
1232 src_len = strlen(src);
1234 if (ucs2_align(base_ptr, dest, flags)) {
1236 dest = (void *)((char *)dest + 1);
1242 /* ucs2 is always a multiple of 2 bytes */
1245 ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
1246 if (ret == (size_t)-1) {
1252 if (flags & STR_UPPER) {
1253 smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
1256 /* We check for i < (ret / 2) below as the dest string isn't null
1257 terminated if STR_TERMINATE isn't set. */
1259 for (i = 0; i < (ret / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
1260 smb_ucs2_t v = toupper_w(dest_ucs2[i]);
1261 if (v != dest_ucs2[i]) {
1272 * Copy a string from a unix char* src to a UCS2 destination,
1273 * allocating a buffer using talloc().
1275 * @param dest always set at least to NULL
1277 * @returns The number of bytes occupied by the string in the destination
1278 * or -1 in case of error.
1280 size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
1282 size_t src_len = strlen(src)+1;
1285 return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1290 * Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
1292 * @param dest always set at least to NULL
1294 * @returns The number of bytes occupied by the string in the destination
1295 * or -1 in case of error.
1298 size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
1300 size_t src_len = strlen(src)+1;
1303 return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1307 Copy a string from a char* src to a UTF-8 destination.
1308 Return the number of bytes occupied by the string in the destination
1310 STR_TERMINATE means include the null termination
1311 STR_UPPER means uppercase in the destination
1312 dest_len is the maximum length allowed in the destination. If dest_len
1313 is -1 then no maxiumum is used.
1316 static size_t push_utf8(void *dest, const char *src, size_t dest_len, int flags)
1318 size_t src_len = strlen(src);
1321 /* treat a pstring as "unlimited" length */
1322 if (dest_len == (size_t)-1)
1323 dest_len = sizeof(pstring);
1325 if (flags & STR_UPPER) {
1326 pstrcpy(tmpbuf, src);
1331 if (flags & STR_TERMINATE)
1334 return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
1337 size_t push_utf8_fstring(void *dest, const char *src)
1339 return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
1343 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
1345 * @param dest always set at least to NULL
1347 * @returns The number of bytes occupied by the string in the destination
1350 size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1352 size_t src_len = strlen(src)+1;
1355 return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest, True);
1359 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
1361 * @param dest always set at least to NULL
1363 * @returns The number of bytes occupied by the string in the destination
1366 size_t push_utf8_allocate(char **dest, const char *src)
1368 size_t src_len = strlen(src)+1;
1371 return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
1375 Copy a string from a ucs2 source to a unix char* destination.
1377 STR_TERMINATE means the string in src is null terminated.
1378 STR_NOALIGN means don't try to align.
1379 if STR_TERMINATE is set then src_len is ignored if it is -1.
1380 src_len is the length of the source area in bytes
1381 Return the number of bytes occupied by the string in src.
1382 The resulting string in "dest" is always null terminated.
1385 size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
1393 if (dest_len == (size_t)-1)
1394 dest_len = sizeof(pstring);
1396 if (ucs2_align(base_ptr, src, flags)) {
1397 src = (const void *)((const char *)src + 1);
1398 if (src_len != (size_t)-1)
1402 if (flags & STR_TERMINATE) {
1403 /* src_len -1 is the default for null terminated strings. */
1404 if (src_len != (size_t)-1) {
1405 size_t len = strnlen_w((const smb_ucs2_t *)src,
1407 if (len < src_len/2)
1413 /* ucs2 is always a multiple of 2 bytes */
1414 if (src_len != (size_t)-1)
1417 ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
1418 if (ret == (size_t)-1) {
1422 if (src_len == (size_t)-1)
1425 if (dest_len && ret) {
1426 /* Did we already process the terminating zero ? */
1427 if (dest[MIN(ret-1, dest_len-1)] != 0) {
1428 dest[MIN(ret, dest_len-1)] = 0;
1438 Copy a string from a ucs2 source to a unix char* destination.
1439 Talloc version with a base pointer.
1440 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1443 STR_TERMINATE means the string in src is null terminated.
1444 STR_NOALIGN means don't try to align.
1445 if STR_TERMINATE is set then src_len is ignored if it is -1.
1446 src_len is the length of the source area in bytes
1447 Return the number of bytes occupied by the string in src.
1448 The resulting string in "dest" is always null terminated.
1451 static size_t pull_ucs2_base_talloc(TALLOC_CTX *ctx,
1452 const void *base_ptr,
1464 /* Ensure we never use the braindead "malloc" varient. */
1466 smb_panic("NULL talloc CTX in pull_ucs2_base_talloc\n");
1474 if (ucs2_align(base_ptr, src, flags)) {
1475 src = (const void *)((const char *)src + 1);
1476 if (src_len != (size_t)-1)
1480 if (flags & STR_TERMINATE) {
1481 /* src_len -1 is the default for null terminated strings. */
1482 if (src_len != (size_t)-1) {
1483 size_t len = strnlen_w((const smb_ucs2_t *)src,
1485 if (len < src_len/2)
1489 /* Ensure we don't use an insane length from the client. */
1490 if (src_len >= 1024*1024) {
1491 smb_panic("Bad src length in pull_ucs2_base_talloc\n");
1495 /* ucs2 is always a multiple of 2 bytes */
1496 if (src_len != (size_t)-1) {
1500 dest_len = convert_string_talloc(ctx,
1507 if (dest_len == (size_t)-1) {
1511 if (src_len == (size_t)-1)
1512 src_len = dest_len*2;
1515 /* Did we already process the terminating zero ? */
1516 if (dest[dest_len-1] != 0) {
1517 size_t size = talloc_get_size(dest);
1518 /* Have we got space to append the '\0' ? */
1519 if (size <= dest_len) {
1521 dest = TALLOC_REALLOC_ARRAY(ctx, dest, char,
1525 dest_len = (size_t)-1;
1530 dest[dest_len] = '\0';
1541 size_t pull_ucs2_pstring(char *dest, const void *src)
1543 return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
1546 size_t pull_ucs2_fstring(char *dest, const void *src)
1548 return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
1552 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
1554 * @param dest always set at least to NULL
1556 * @returns The number of bytes occupied by the string in the destination
1559 size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
1561 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1563 return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1567 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
1569 * @param dest always set at least to NULL
1571 * @returns The number of bytes occupied by the string in the destination
1574 size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
1576 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1578 return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1582 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
1584 * @param dest always set at least to NULL
1586 * @returns The number of bytes occupied by the string in the destination
1589 size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1591 size_t src_len = strlen(src)+1;
1593 return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1597 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
1599 * @param dest always set at least to NULL
1601 * @returns The number of bytes occupied by the string in the destination
1604 size_t pull_utf8_allocate(char **dest, const char *src)
1606 size_t src_len = strlen(src)+1;
1608 return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1612 * Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
1614 * @param dest always set at least to NULL
1616 * @returns The number of bytes occupied by the string in the destination
1619 size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1621 size_t src_len = strlen(src)+1;
1623 return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
1627 Copy a string from a char* src to a unicode or ascii
1628 dos codepage destination choosing unicode or ascii based on the
1629 flags in the SMB buffer starting at base_ptr.
1630 Return the number of bytes occupied by the string in the destination.
1632 STR_TERMINATE means include the null termination.
1633 STR_UPPER means uppercase in the destination.
1634 STR_ASCII use ascii even with unicode packet.
1635 STR_NOALIGN means don't do alignment.
1636 dest_len is the maximum length allowed in the destination. If dest_len
1637 is -1 then no maxiumum is used.
1640 size_t push_string_fn(const char *function, unsigned int line,
1641 const void *base_ptr, uint16 flags2,
1642 void *dest, const char *src,
1643 size_t dest_len, int flags)
1646 /* We really need to zero fill here, not clobber
1647 * region, as we want to ensure that valgrind thinks
1648 * all of the outgoing buffer has been written to
1649 * so a send() or write() won't trap an error.
1653 if (dest_len != (size_t)-1)
1654 clobber_region(function, line, dest, dest_len);
1656 if (dest_len != (size_t)-1)
1657 memset(dest, '\0', dest_len);
1661 if (!(flags & STR_ASCII) && \
1662 ((flags & STR_UNICODE || \
1663 (flags2 & FLAGS2_UNICODE_STRINGS)))) {
1664 return push_ucs2(base_ptr, dest, src, dest_len, flags);
1666 return push_ascii(dest, src, dest_len, flags);
1671 Copy a string from a unicode or ascii source (depending on
1672 the packet flags) to a char* destination.
1674 STR_TERMINATE means the string in src is null terminated.
1675 STR_UNICODE means to force as unicode.
1676 STR_ASCII use ascii even with unicode packet.
1677 STR_NOALIGN means don't do alignment.
1678 if STR_TERMINATE is set then src_len is ignored is it is -1
1679 src_len is the length of the source area in bytes.
1680 Return the number of bytes occupied by the string in src.
1681 The resulting string in "dest" is always null terminated.
1684 size_t pull_string_fn(const char *function, unsigned int line,
1685 const void *base_ptr, uint16 smb_flags2, char *dest,
1686 const void *src, size_t dest_len, size_t src_len,
1690 if (dest_len != (size_t)-1)
1691 clobber_region(function, line, dest, dest_len);
1694 if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
1695 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1699 if (!(flags & STR_ASCII) && \
1700 ((flags & STR_UNICODE || \
1701 (smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
1702 return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
1704 return pull_ascii(dest, src, dest_len, src_len, flags);
1708 Copy a string from a unicode or ascii source (depending on
1709 the packet flags) to a char* destination.
1710 Variant that uses talloc.
1712 STR_TERMINATE means the string in src is null terminated.
1713 STR_UNICODE means to force as unicode.
1714 STR_ASCII use ascii even with unicode packet.
1715 STR_NOALIGN means don't do alignment.
1716 if STR_TERMINATE is set then src_len is ignored is it is -1
1717 src_len is the length of the source area in bytes.
1718 Return the number of bytes occupied by the string in src.
1719 The resulting string in "dest" is always null terminated.
1722 size_t pull_string_talloc_fn(const char *function,
1725 const void *base_ptr,
1732 if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
1733 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1737 if (!(flags & STR_ASCII) && \
1738 ((flags & STR_UNICODE || \
1739 (smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
1740 return pull_ucs2_base_talloc(ctx,
1747 return pull_ascii_base_talloc(ctx,
1755 size_t align_string(const void *base_ptr, const char *p, int flags)
1757 if (!(flags & STR_ASCII) && \
1758 ((flags & STR_UNICODE || \
1759 (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
1760 return ucs2_align(base_ptr, p, flags);
1766 Return the unicode codepoint for the next multi-byte CH_UNIX character
1767 in the string. The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
1769 Also return the number of bytes consumed (which tells the caller
1770 how many bytes to skip to get to the next CH_UNIX character).
1772 Return INVALID_CODEPOINT if the next character cannot be converted.
1775 codepoint_t next_codepoint(const char *str, size_t *size)
1777 /* It cannot occupy more than 4 bytes in UTF16 format */
1779 smb_iconv_t descriptor;
1785 if ((str[0] & 0x80) == 0) {
1787 return (codepoint_t)str[0];
1790 /* We assume that no multi-byte character can take
1791 more than 5 bytes. This is OK as we only
1792 support codepoints up to 1M */
1794 ilen_orig = strnlen(str, 5);
1797 lazy_initialize_conv();
1799 descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
1800 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
1802 return INVALID_CODEPOINT;
1805 /* This looks a little strange, but it is needed to cope
1806 with codepoints above 64k which are encoded as per RFC2781. */
1808 outbuf = (char *)buf;
1809 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1811 /* We failed to convert to a 2 byte character.
1812 See if we can convert to a 4 UTF16-LE byte char encoding.
1815 outbuf = (char *)buf;
1816 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1818 /* We didn't convert any bytes */
1820 return INVALID_CODEPOINT;
1827 *size = ilen_orig - ilen;
1830 /* 2 byte, UTF16-LE encoded value. */
1831 return (codepoint_t)SVAL(buf, 0);
1834 /* Decode a 4 byte UTF16-LE character manually.
1835 See RFC2871 for the encoding machanism.
1837 codepoint_t w1 = SVAL(buf,0) & ~0xD800;
1838 codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
1840 return (codepoint_t)0x10000 +
1844 /* no other length is valid */
1845 return INVALID_CODEPOINT;