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 * @param srclen length of source buffer.
513 * @param dest always set at least to NULL
514 * @note -1 is not accepted for srclen.
516 * @returns Size in bytes of the converted string; or -1 in case of error.
518 * Ensure the srclen contains the terminating zero.
520 * I hate the goto's in this function. It's embarressing.....
521 * There has to be a cleaner way to do this. JRA.
524 size_t convert_string_allocate(TALLOC_CTX *ctx, charset_t from, charset_t to,
525 void const *src, size_t srclen, void *dst, BOOL allow_bad_conv)
527 size_t i_len, o_len, destlen = MAX(srclen, 512);
529 const char *inbuf = (const char *)src;
530 char *outbuf = NULL, *ob = NULL;
531 smb_iconv_t descriptor;
532 void **dest = (void **)dst;
536 if (src == NULL || srclen == (size_t)-1)
541 lazy_initialize_conv();
543 descriptor = conv_handles[from][to];
545 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
547 DEBUG(0,("convert_string_allocate: Conversion not supported.\n"));
553 if ((destlen*2) < destlen) {
554 /* wrapped ! abort. */
556 DEBUG(0, ("convert_string_allocate: destlen wrapped !\n"));
561 destlen = destlen * 2;
565 ob = (char *)TALLOC_REALLOC(ctx, ob, destlen);
567 ob = (char *)SMB_REALLOC(ob, destlen);
571 DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
580 retval = smb_iconv(descriptor,
583 if(retval == (size_t)-1) {
584 const char *reason="unknown error";
587 reason="Incomplete multibyte sequence";
589 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
596 reason="Illegal multibyte sequence";
598 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason,inbuf));
604 DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
605 /* smb_panic(reason); */
611 destlen = destlen - o_len;
613 ob = (char *)TALLOC_REALLOC(ctx,ob,destlen);
615 ob = (char *)SMB_REALLOC(ob,destlen);
618 if (destlen && !ob) {
619 DEBUG(0, ("convert_string_allocate: out of memory!\n"));
629 * Conversion not supported. This is actually an error, but there are so
630 * many misconfigured iconv systems and smb.conf's out there we can't just
631 * fail. Do a very bad conversion instead.... JRA.
635 if (o_len == 0 || i_len == 0)
638 if (((from == CH_UTF16LE)||(from == CH_UTF16BE)) &&
639 ((to != CH_UTF16LE)||(to != CH_UTF16BE))) {
640 /* Can't convert from utf16 any endian to multibyte.
641 Replace with the default fail char.
648 *outbuf = lp_failed_convert_char();
657 if (o_len == 0 || i_len == 0)
660 /* Keep trying with the next char... */
663 } else if (from != CH_UTF16LE && from != CH_UTF16BE && to == CH_UTF16LE) {
664 /* Can't convert to UTF16LE - just widen by adding the
665 default fail char then zero.
670 outbuf[0] = lp_failed_convert_char();
679 if (o_len == 0 || i_len == 0)
682 /* Keep trying with the next char... */
685 } else if (from != CH_UTF16LE && from != CH_UTF16BE &&
686 to != CH_UTF16LE && to != CH_UTF16BE) {
687 /* Failed multibyte to multibyte. Just copy the default fail char and
689 outbuf[0] = lp_failed_convert_char();
697 if (o_len == 0 || i_len == 0)
700 /* Keep trying with the next char... */
704 /* Keep compiler happy.... */
711 * Convert between character sets, allocating a new buffer using talloc for the result.
713 * @param srclen length of source buffer.
714 * @param dest always set at least to NULL
715 * @note -1 is not accepted for srclen.
717 * @returns Size in bytes of the converted string; or -1 in case of error.
719 size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
720 void const *src, size_t srclen, void *dst,
723 void **dest = (void **)dst;
727 dest_len=convert_string_allocate(ctx, from, to, src, srclen, dest, allow_bad_conv);
728 if (dest_len == (size_t)-1)
735 size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
740 size = push_ucs2_allocate(&buffer, src);
741 if (size == (size_t)-1) {
742 smb_panic("failed to create UCS2 buffer");
744 if (!strupper_w(buffer) && (dest == src)) {
749 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
755 strdup() a unix string to upper case.
759 char *strdup_upper(const char *s)
762 const unsigned char *p = (const unsigned char *)s;
763 unsigned char *q = (unsigned char *)out_buffer;
765 /* this is quite a common operation, so we want it to be
766 fast. We optimise for the ascii case, knowing that all our
767 supported multi-byte character sets are ascii-compatible
768 (ie. they match for the first 128 chars) */
773 *q++ = toupper_ascii(*p);
777 if (p - ( const unsigned char *)s >= sizeof(pstring))
785 size = convert_string(CH_UNIX, CH_UTF16LE, s, -1, buffer, sizeof(buffer), True);
786 if (size == (size_t)-1) {
792 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, -1, out_buffer, sizeof(out_buffer), True);
793 if (size == (size_t)-1) {
798 return SMB_STRDUP(out_buffer);
801 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
804 smb_ucs2_t *buffer = NULL;
806 size = convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, srclen,
807 (void **)(void *)&buffer, True);
808 if (size == (size_t)-1 || !buffer) {
809 smb_panic("failed to create UCS2 buffer");
811 if (!strlower_w(buffer) && (dest == src)) {
815 size = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, True);
821 strdup() a unix string to lower case.
824 char *strdup_lower(const char *s)
827 smb_ucs2_t *buffer = NULL;
830 size = push_ucs2_allocate(&buffer, s);
831 if (size == -1 || !buffer) {
837 size = pull_ucs2_allocate(&out_buffer, buffer);
840 if (size == (size_t)-1) {
847 static size_t ucs2_align(const void *base_ptr, const void *p, int flags)
849 if (flags & (STR_NOALIGN|STR_ASCII))
851 return PTR_DIFF(p, base_ptr) & 1;
856 * Copy a string from a char* unix src to a dos codepage string destination.
858 * @return the number of bytes occupied by the string in the destination.
860 * @param flags can include
862 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
863 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
866 * @param dest_len the maximum length in bytes allowed in the
867 * destination. If @p dest_len is -1 then no maximum is used.
869 size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
871 size_t src_len = strlen(src);
874 /* treat a pstring as "unlimited" length */
875 if (dest_len == (size_t)-1)
876 dest_len = sizeof(pstring);
878 if (flags & STR_UPPER) {
879 pstrcpy(tmpbuf, src);
884 if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
887 return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, True);
890 size_t push_ascii_fstring(void *dest, const char *src)
892 return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
895 size_t push_ascii_pstring(void *dest, const char *src)
897 return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
900 /********************************************************************
901 Push an nstring - ensure null terminated. Written by
902 moriyama@miraclelinux.com (MORIYAMA Masayuki).
903 ********************************************************************/
905 size_t push_ascii_nstring(void *dest, const char *src)
907 size_t i, buffer_len, dest_len;
911 buffer_len = push_ucs2_allocate(&buffer, src);
912 if (buffer_len == (size_t)-1) {
913 smb_panic("failed to create UCS2 buffer");
916 /* We're using buffer_len below to count ucs2 characters, not bytes. */
917 buffer_len /= sizeof(smb_ucs2_t);
920 for (i = 0; buffer[i] != 0 && (i < buffer_len); i++) {
921 unsigned char mb[10];
922 /* Convert one smb_ucs2_t character at a time. */
923 size_t mb_len = convert_string(CH_UTF16LE, CH_DOS, buffer+i, sizeof(smb_ucs2_t), mb, sizeof(mb), False);
924 if ((mb_len != (size_t)-1) && (dest_len + mb_len <= MAX_NETBIOSNAME_LEN - 1)) {
925 memcpy((char *)dest + dest_len, mb, mb_len);
932 ((char *)dest)[dest_len] = '\0';
940 * Copy a string from a dos codepage source to a unix char* destination.
942 * The resulting string in "dest" is always null terminated.
944 * @param flags can have:
946 * <dt>STR_TERMINATE</dt>
947 * <dd>STR_TERMINATE means the string in @p src
948 * is null terminated, and src_len is ignored.</dd>
951 * @param src_len is the length of the source area in bytes.
952 * @returns the number of bytes occupied by the string in @p src.
954 size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
958 if (dest_len == (size_t)-1)
959 dest_len = sizeof(pstring);
961 if (flags & STR_TERMINATE) {
962 if (src_len == (size_t)-1) {
963 src_len = strlen((const char *)src) + 1;
965 size_t len = strnlen((const char *)src, src_len);
972 ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, True);
973 if (ret == (size_t)-1) {
978 if (dest_len && ret) {
979 /* Did we already process the terminating zero ? */
980 if (dest[MIN(ret-1, dest_len-1)] != 0) {
981 dest[MIN(ret, dest_len-1)] = 0;
990 size_t pull_ascii_pstring(char *dest, const void *src)
992 return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
995 size_t pull_ascii_fstring(char *dest, const void *src)
997 return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
1000 /* When pulling an nstring it can expand into a larger size (dos cp -> utf8). Cope with this. */
1002 size_t pull_ascii_nstring(char *dest, size_t dest_len, const void *src)
1004 return pull_ascii(dest, src, dest_len, sizeof(nstring)-1, STR_TERMINATE);
1008 * Copy a string from a char* src to a unicode destination.
1010 * @returns the number of bytes occupied by the string in the destination.
1012 * @param flags can have:
1015 * <dt>STR_TERMINATE <dd>means include the null termination.
1016 * <dt>STR_UPPER <dd>means uppercase in the destination.
1017 * <dt>STR_NOALIGN <dd>means don't do alignment.
1020 * @param dest_len is the maximum length allowed in the
1021 * destination. If dest_len is -1 then no maxiumum is used.
1024 size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
1030 /* treat a pstring as "unlimited" length */
1031 if (dest_len == (size_t)-1)
1032 dest_len = sizeof(pstring);
1034 if (flags & STR_TERMINATE)
1035 src_len = (size_t)-1;
1037 src_len = strlen(src);
1039 if (ucs2_align(base_ptr, dest, flags)) {
1041 dest = (void *)((char *)dest + 1);
1047 /* ucs2 is always a multiple of 2 bytes */
1050 ret = convert_string(CH_UNIX, CH_UTF16LE, src, src_len, dest, dest_len, True);
1051 if (ret == (size_t)-1) {
1057 if (flags & STR_UPPER) {
1058 smb_ucs2_t *dest_ucs2 = (smb_ucs2_t *)dest;
1061 /* We check for i < (ret / 2) below as the dest string isn't null
1062 terminated if STR_TERMINATE isn't set. */
1064 for (i = 0; i < (ret / 2) && i < (dest_len / 2) && dest_ucs2[i]; i++) {
1065 smb_ucs2_t v = toupper_w(dest_ucs2[i]);
1066 if (v != dest_ucs2[i]) {
1077 * Copy a string from a unix char* src to a UCS2 destination,
1078 * allocating a buffer using talloc().
1080 * @param dest always set at least to NULL
1082 * @returns The number of bytes occupied by the string in the destination
1083 * or -1 in case of error.
1085 size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
1087 size_t src_len = strlen(src)+1;
1090 return convert_string_talloc(ctx, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1095 * Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
1097 * @param dest always set at least to NULL
1099 * @returns The number of bytes occupied by the string in the destination
1100 * or -1 in case of error.
1103 size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
1105 size_t src_len = strlen(src)+1;
1108 return convert_string_allocate(NULL, CH_UNIX, CH_UTF16LE, src, src_len, (void **)dest, True);
1112 Copy a string from a char* src to a UTF-8 destination.
1113 Return the number of bytes occupied by the string in the destination
1115 STR_TERMINATE means include the null termination
1116 STR_UPPER means uppercase in the destination
1117 dest_len is the maximum length allowed in the destination. If dest_len
1118 is -1 then no maxiumum is used.
1121 static size_t push_utf8(void *dest, const char *src, size_t dest_len, int flags)
1123 size_t src_len = strlen(src);
1126 /* treat a pstring as "unlimited" length */
1127 if (dest_len == (size_t)-1)
1128 dest_len = sizeof(pstring);
1130 if (flags & STR_UPPER) {
1131 pstrcpy(tmpbuf, src);
1136 if (flags & STR_TERMINATE)
1139 return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len, True);
1142 size_t push_utf8_fstring(void *dest, const char *src)
1144 return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
1148 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
1150 * @param dest always set at least to NULL
1152 * @returns The number of bytes occupied by the string in the destination
1155 size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1157 size_t src_len = strlen(src)+1;
1160 return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest, True);
1164 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
1166 * @param dest always set at least to NULL
1168 * @returns The number of bytes occupied by the string in the destination
1171 size_t push_utf8_allocate(char **dest, const char *src)
1173 size_t src_len = strlen(src)+1;
1176 return convert_string_allocate(NULL, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, True);
1180 Copy a string from a ucs2 source to a unix char* destination.
1182 STR_TERMINATE means the string in src is null terminated.
1183 STR_NOALIGN means don't try to align.
1184 if STR_TERMINATE is set then src_len is ignored if it is -1.
1185 src_len is the length of the source area in bytes
1186 Return the number of bytes occupied by the string in src.
1187 The resulting string in "dest" is always null terminated.
1190 size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
1194 if (dest_len == (size_t)-1)
1195 dest_len = sizeof(pstring);
1197 if (ucs2_align(base_ptr, src, flags)) {
1198 src = (const void *)((const char *)src + 1);
1199 if (src_len != (size_t)-1)
1203 if (flags & STR_TERMINATE) {
1204 /* src_len -1 is the default for null terminated strings. */
1205 if (src_len != (size_t)-1) {
1206 size_t len = strnlen_w((const smb_ucs2_t *)src,
1208 if (len < src_len/2)
1214 /* ucs2 is always a multiple of 2 bytes */
1215 if (src_len != (size_t)-1)
1218 ret = convert_string(CH_UTF16LE, CH_UNIX, src, src_len, dest, dest_len, True);
1219 if (ret == (size_t)-1) {
1223 if (src_len == (size_t)-1)
1226 if (dest_len && ret) {
1227 /* Did we already process the terminating zero ? */
1228 if (dest[MIN(ret-1, dest_len-1)] != 0) {
1229 dest[MIN(ret, dest_len-1)] = 0;
1238 size_t pull_ucs2_pstring(char *dest, const void *src)
1240 return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
1243 size_t pull_ucs2_fstring(char *dest, const void *src)
1245 return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
1249 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
1251 * @param dest always set at least to NULL
1253 * @returns The number of bytes occupied by the string in the destination
1256 size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
1258 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1260 return convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1264 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
1266 * @param dest always set at least to NULL
1268 * @returns The number of bytes occupied by the string in the destination
1271 size_t pull_ucs2_allocate(char **dest, const smb_ucs2_t *src)
1273 size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
1275 return convert_string_allocate(NULL, CH_UTF16LE, CH_UNIX, src, src_len, (void **)dest, True);
1279 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
1281 * @param dest always set at least to NULL
1283 * @returns The number of bytes occupied by the string in the destination
1286 size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1288 size_t src_len = strlen(src)+1;
1290 return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1294 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
1296 * @param dest always set at least to NULL
1298 * @returns The number of bytes occupied by the string in the destination
1301 size_t pull_utf8_allocate(char **dest, const char *src)
1303 size_t src_len = strlen(src)+1;
1305 return convert_string_allocate(NULL, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, True);
1309 * Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
1311 * @param dest always set at least to NULL
1313 * @returns The number of bytes occupied by the string in the destination
1316 size_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
1318 size_t src_len = strlen(src)+1;
1320 return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, True);
1324 Copy a string from a char* src to a unicode or ascii
1325 dos codepage destination choosing unicode or ascii based on the
1326 flags in the SMB buffer starting at base_ptr.
1327 Return the number of bytes occupied by the string in the destination.
1329 STR_TERMINATE means include the null termination.
1330 STR_UPPER means uppercase in the destination.
1331 STR_ASCII use ascii even with unicode packet.
1332 STR_NOALIGN means don't do alignment.
1333 dest_len is the maximum length allowed in the destination. If dest_len
1334 is -1 then no maxiumum is used.
1337 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)
1340 /* We really need to zero fill here, not clobber
1341 * region, as we want to ensure that valgrind thinks
1342 * all of the outgoing buffer has been written to
1343 * so a send() or write() won't trap an error.
1347 if (dest_len != (size_t)-1)
1348 clobber_region(function, line, dest, dest_len);
1350 if (dest_len != (size_t)-1)
1351 memset(dest, '\0', dest_len);
1355 if (!(flags & STR_ASCII) && \
1356 ((flags & STR_UNICODE || \
1357 (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
1358 return push_ucs2(base_ptr, dest, src, dest_len, flags);
1360 return push_ascii(dest, src, dest_len, flags);
1365 Copy a string from a unicode or ascii source (depending on
1366 the packet flags) to a char* destination.
1368 STR_TERMINATE means the string in src is null terminated.
1369 STR_UNICODE means to force as unicode.
1370 STR_ASCII use ascii even with unicode packet.
1371 STR_NOALIGN means don't do alignment.
1372 if STR_TERMINATE is set then src_len is ignored is it is -1
1373 src_len is the length of the source area in bytes.
1374 Return the number of bytes occupied by the string in src.
1375 The resulting string in "dest" is always null terminated.
1378 size_t pull_string_fn(const char *function, unsigned int line,
1379 const void *base_ptr, uint16 smb_flags2, char *dest,
1380 const void *src, size_t dest_len, size_t src_len,
1384 if (dest_len != (size_t)-1)
1385 clobber_region(function, line, dest, dest_len);
1388 if ((base_ptr == NULL) && ((flags & (STR_ASCII|STR_UNICODE)) == 0)) {
1389 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1393 if (!(flags & STR_ASCII) && \
1394 ((flags & STR_UNICODE || \
1395 (smb_flags2 & FLAGS2_UNICODE_STRINGS)))) {
1396 return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
1398 return pull_ascii(dest, src, dest_len, src_len, flags);
1401 size_t align_string(const void *base_ptr, const char *p, int flags)
1403 if (!(flags & STR_ASCII) && \
1404 ((flags & STR_UNICODE || \
1405 (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
1406 return ucs2_align(base_ptr, p, flags);
1412 Return the unicode codepoint for the next multi-byte CH_UNIX character
1413 in the string. The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
1415 Also return the number of bytes consumed (which tells the caller
1416 how many bytes to skip to get to the next CH_UNIX character).
1418 Return INVALID_CODEPOINT if the next character cannot be converted.
1421 codepoint_t next_codepoint(const char *str, size_t *size)
1423 /* It cannot occupy more than 4 bytes in UTF16 format */
1425 smb_iconv_t descriptor;
1431 if ((str[0] & 0x80) == 0) {
1433 return (codepoint_t)str[0];
1436 /* We assume that no multi-byte character can take
1437 more than 5 bytes. This is OK as we only
1438 support codepoints up to 1M */
1440 ilen_orig = strnlen(str, 5);
1443 lazy_initialize_conv();
1445 descriptor = conv_handles[CH_UNIX][CH_UTF16LE];
1446 if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
1448 return INVALID_CODEPOINT;
1451 /* This looks a little strange, but it is needed to cope
1452 with codepoints above 64k which are encoded as per RFC2781. */
1454 outbuf = (char *)buf;
1455 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1457 /* We failed to convert to a 2 byte character.
1458 See if we can convert to a 4 UTF16-LE byte char encoding.
1461 outbuf = (char *)buf;
1462 smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
1464 /* We didn't convert any bytes */
1466 return INVALID_CODEPOINT;
1473 *size = ilen_orig - ilen;
1476 /* 2 byte, UTF16-LE encoded value. */
1477 return (codepoint_t)SVAL(buf, 0);
1480 /* Decode a 4 byte UTF16-LE character manually.
1481 See RFC2871 for the encoding machanism.
1483 codepoint_t w1 = SVAL(buf,0) & ~0xD800;
1484 codepoint_t w2 = SVAL(buf,2) & ~0xDC00;
1486 return (codepoint_t)0x10000 +
1490 /* no other length is valid */
1491 return INVALID_CODEPOINT;