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 bool conv_silent
; /* Should we do a debug if the conversion fails ? */
49 static bool initialized
;
51 void lazy_initialize_conv(void)
54 load_case_tables_library();
61 * Destroy global objects allocated by init_iconv()
63 void gfree_charcnv(void)
65 TALLOC_FREE(global_iconv_convenience
);
70 * Initialize iconv conversion descriptors.
72 * This is called the first time it is needed, and also called again
73 * every time the configuration is reloaded, because the charset or
74 * codepage might have changed.
78 global_iconv_convenience
= smb_iconv_convenience_reinit(NULL
, lp_dos_charset(),
79 lp_unix_charset(), lp_display_charset(),
80 true, global_iconv_convenience
);
84 * Convert string from one encoding to another, making error checking etc
85 * Slow path version - uses (slow) iconv.
87 * @param src pointer to source string (multibyte or singlebyte)
88 * @param srclen length of the source string in bytes
89 * @param dest pointer to destination string (multibyte or singlebyte)
90 * @param destlen maximal length allowed for string
91 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
92 * @returns the number of bytes occupied in the destination
94 * Ensure the srclen contains the terminating zero.
98 static size_t convert_string_internal(charset_t from
, charset_t to
,
99 void const *src
, size_t srclen
,
100 void *dest
, size_t destlen
, bool allow_bad_conv
)
104 const char* inbuf
= (const char*)src
;
105 char* outbuf
= (char*)dest
;
106 smb_iconv_t descriptor
;
107 struct smb_iconv_convenience
*ic
;
109 lazy_initialize_conv();
110 ic
= get_iconv_convenience();
111 descriptor
= get_conv_handle(ic
, from
, to
);
113 if (srclen
== (size_t)-1) {
114 if (from
== CH_UTF16LE
|| from
== CH_UTF16BE
) {
115 srclen
= (strlen_w((const smb_ucs2_t
*)src
)+1) * 2;
117 srclen
= strlen((const char *)src
)+1;
122 if (descriptor
== (smb_iconv_t
)-1 || descriptor
== (smb_iconv_t
)0) {
124 DEBUG(0,("convert_string_internal: Conversion not supported.\n"));
133 retval
= smb_iconv(descriptor
, &inbuf
, &i_len
, &outbuf
, &o_len
);
134 if(retval
==(size_t)-1) {
135 const char *reason
="unknown error";
138 reason
="Incomplete multibyte sequence";
140 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
145 reason
="No more room";
147 if (from
== CH_UNIX
) {
148 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
149 charset_name(ic
, from
), charset_name(ic
, to
),
150 (unsigned int)srclen
, (unsigned int)destlen
, (const char *)src
));
152 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
153 charset_name(ic
, from
), charset_name(ic
, to
),
154 (unsigned int)srclen
, (unsigned int)destlen
));
159 reason
="Illegal multibyte sequence";
161 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
168 DEBUG(0,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
171 /* smb_panic(reason); */
173 return destlen
-o_len
;
178 * Conversion not supported. This is actually an error, but there are so
179 * many misconfigured iconv systems and smb.conf's out there we can't just
180 * fail. Do a very bad conversion instead.... JRA.
184 if (o_len
== 0 || i_len
== 0)
185 return destlen
- o_len
;
187 if (((from
== CH_UTF16LE
)||(from
== CH_UTF16BE
)) &&
188 ((to
!= CH_UTF16LE
)||(to
!= CH_UTF16BE
))) {
189 /* Can't convert from utf16 any endian to multibyte.
190 Replace with the default fail char.
193 return destlen
- o_len
;
195 *outbuf
= lp_failed_convert_char();
204 if (o_len
== 0 || i_len
== 0)
205 return destlen
- o_len
;
207 /* Keep trying with the next char... */
210 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
211 /* Can't convert to UTF16LE - just widen by adding the
212 default fail char then zero.
215 return destlen
- o_len
;
217 outbuf
[0] = lp_failed_convert_char();
226 if (o_len
== 0 || i_len
== 0)
227 return destlen
- o_len
;
229 /* Keep trying with the next char... */
232 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&&
233 to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
234 /* Failed multibyte to multibyte. Just copy the default fail char and
236 outbuf
[0] = lp_failed_convert_char();
244 if (o_len
== 0 || i_len
== 0)
245 return destlen
- o_len
;
247 /* Keep trying with the next char... */
251 /* Keep compiler happy.... */
252 return destlen
- o_len
;
258 * Convert string from one encoding to another, making error checking etc
259 * Fast path version - handles ASCII first.
261 * @param src pointer to source string (multibyte or singlebyte)
262 * @param srclen length of the source string in bytes, or -1 for nul terminated.
263 * @param dest pointer to destination string (multibyte or singlebyte)
264 * @param destlen maximal length allowed for string - *NEVER* -1.
265 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
266 * @returns the number of bytes occupied in the destination
268 * Ensure the srclen contains the terminating zero.
270 * This function has been hand-tuned to provide a fast path.
271 * Don't change unless you really know what you are doing. JRA.
274 size_t convert_string(charset_t from
, charset_t to
,
275 void const *src
, size_t srclen
,
276 void *dest
, size_t destlen
, bool allow_bad_conv
)
279 * NB. We deliberately don't do a strlen here if srclen == -1.
280 * This is very expensive over millions of calls and is taken
281 * care of in the slow path in convert_string_internal. JRA.
285 SMB_ASSERT(destlen
!= (size_t)-1);
291 if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
292 const unsigned char *p
= (const unsigned char *)src
;
293 unsigned char *q
= (unsigned char *)dest
;
294 size_t slen
= srclen
;
295 size_t dlen
= destlen
;
296 unsigned char lastp
= '\0';
299 /* If all characters are ascii, fast path here. */
300 while (slen
&& dlen
) {
301 if ((lastp
= *p
) <= 0x7f) {
303 if (slen
!= (size_t)-1) {
311 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
314 size_t ret
= convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
315 if (ret
== (size_t)-1) {
323 /* Even if we fast path we should note if we ran out of room. */
324 if (((slen
!= (size_t)-1) && slen
) ||
325 ((slen
== (size_t)-1) && lastp
)) {
330 } else if (from
== CH_UTF16LE
&& to
!= CH_UTF16LE
) {
331 const unsigned char *p
= (const unsigned char *)src
;
332 unsigned char *q
= (unsigned char *)dest
;
334 size_t slen
= srclen
;
335 size_t dlen
= destlen
;
336 unsigned char lastp
= '\0';
338 /* If all characters are ascii, fast path here. */
339 while (((slen
== (size_t)-1) || (slen
>= 2)) && dlen
) {
340 if (((lastp
= *p
) <= 0x7f) && (p
[1] == 0)) {
342 if (slen
!= (size_t)-1) {
351 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
354 size_t ret
= convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
355 if (ret
== (size_t)-1) {
363 /* Even if we fast path we should note if we ran out of room. */
364 if (((slen
!= (size_t)-1) && slen
) ||
365 ((slen
== (size_t)-1) && lastp
)) {
370 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
371 const unsigned char *p
= (const unsigned char *)src
;
372 unsigned char *q
= (unsigned char *)dest
;
374 size_t slen
= srclen
;
375 size_t dlen
= destlen
;
376 unsigned char lastp
= '\0';
378 /* If all characters are ascii, fast path here. */
379 while (slen
&& (dlen
>= 2)) {
380 if ((lastp
= *p
) <= 0x7F) {
383 if (slen
!= (size_t)-1) {
391 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
394 size_t ret
= convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
395 if (ret
== (size_t)-1) {
403 /* Even if we fast path we should note if we ran out of room. */
404 if (((slen
!= (size_t)-1) && slen
) ||
405 ((slen
== (size_t)-1) && lastp
)) {
412 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
415 return convert_string_internal(from
, to
, src
, srclen
, dest
, destlen
, allow_bad_conv
);
419 * Convert between character sets, allocating a new buffer using talloc for the result.
421 * @param srclen length of source buffer.
422 * @param dest always set at least to NULL
423 * @parm converted_size set to the number of bytes occupied by the string in
424 * the destination on success.
425 * @note -1 is not accepted for srclen.
427 * @return true if new buffer was correctly allocated, and string was
430 * Ensure the srclen contains the terminating zero.
432 * I hate the goto's in this function. It's embarressing.....
433 * There has to be a cleaner way to do this. JRA.
435 bool convert_string_talloc(TALLOC_CTX
*ctx
, charset_t from
, charset_t to
,
436 void const *src
, size_t srclen
, void *dst
,
437 size_t *converted_size
, bool allow_bad_conv
)
440 size_t i_len
, o_len
, destlen
= (srclen
* 3) / 2;
442 const char *inbuf
= (const char *)src
;
443 char *outbuf
= NULL
, *ob
= NULL
;
444 smb_iconv_t descriptor
;
445 void **dest
= (void **)dst
;
446 struct smb_iconv_convenience
*ic
;
450 if (!converted_size
) {
455 if (src
== NULL
|| srclen
== (size_t)-1) {
461 /* We really should treat this as an error, but
462 there are too many callers that need this to
463 return a NULL terminated string in the correct
465 if (to
== CH_UTF16LE
|| to
== CH_UTF16BE
|| to
== CH_UTF16MUNGED
) {
470 ob
= talloc_zero_array(ctx
, char, destlen
);
475 *converted_size
= destlen
;
480 lazy_initialize_conv();
481 ic
= get_iconv_convenience();
482 descriptor
= get_conv_handle(ic
, from
, to
);
484 if (descriptor
== (smb_iconv_t
)-1 || descriptor
== (smb_iconv_t
)0) {
486 DEBUG(0,("convert_string_talloc: Conversion not supported.\n"));
493 /* +2 is for ucs2 null termination. */
494 if ((destlen
*2)+2 < destlen
) {
495 /* wrapped ! abort. */
497 DEBUG(0, ("convert_string_talloc: destlen wrapped !\n"));
502 destlen
= destlen
* 2;
505 /* +2 is for ucs2 null termination. */
506 ob
= (char *)TALLOC_REALLOC(ctx
, ob
, destlen
+ 2);
509 DEBUG(0, ("convert_string_talloc: realloc failed!\n"));
519 retval
= smb_iconv(descriptor
,
522 if(retval
== (size_t)-1) {
523 const char *reason
="unknown error";
526 reason
="Incomplete multibyte sequence";
528 DEBUG(3,("convert_string_talloc: Conversion error: %s(%s)\n",reason
,inbuf
));
535 reason
="Illegal multibyte sequence";
537 DEBUG(3,("convert_string_talloc: Conversion error: %s(%s)\n",reason
,inbuf
));
543 DEBUG(0,("Conversion error: %s(%s)\n",reason
,inbuf
));
544 /* smb_panic(reason); */
551 destlen
= destlen
- o_len
;
552 /* Don't shrink unless we're reclaiming a lot of
553 * space. This is in the hot codepath and these
554 * reallocs *cost*. JRA.
557 /* We're shrinking here so we know the +2 is safe from wrap. */
558 ob
= (char *)TALLOC_REALLOC(ctx
,ob
,destlen
+ 2);
561 if (destlen
&& !ob
) {
562 DEBUG(0, ("convert_string_talloc: out of memory!\n"));
569 /* Must ucs2 null terminate in the extra space we allocated. */
571 ob
[destlen
+1] = '\0';
573 /* Ensure we can never return a *converted_size of zero. */
575 /* This can happen from a bad iconv "use_as_is:" call. */
576 if (to
== CH_UTF16LE
|| to
== CH_UTF16BE
|| to
== CH_UTF16MUNGED
) {
583 *converted_size
= destlen
;
589 * Conversion not supported. This is actually an error, but there are so
590 * many misconfigured iconv systems and smb.conf's out there we can't just
591 * fail. Do a very bad conversion instead.... JRA.
595 if (o_len
== 0 || i_len
== 0)
598 if (((from
== CH_UTF16LE
)||(from
== CH_UTF16BE
)) &&
599 ((to
!= CH_UTF16LE
)||(to
!= CH_UTF16BE
))) {
600 /* Can't convert from utf16 any endian to multibyte.
601 Replace with the default fail char.
608 *outbuf
= lp_failed_convert_char();
617 if (o_len
== 0 || i_len
== 0)
620 /* Keep trying with the next char... */
623 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
624 /* Can't convert to UTF16LE - just widen by adding the
625 default fail char then zero.
630 outbuf
[0] = lp_failed_convert_char();
639 if (o_len
== 0 || i_len
== 0)
642 /* Keep trying with the next char... */
645 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&&
646 to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
647 /* Failed multibyte to multibyte. Just copy the default fail char and
649 outbuf
[0] = lp_failed_convert_char();
657 if (o_len
== 0 || i_len
== 0)
660 /* Keep trying with the next char... */
664 /* Keep compiler happy.... */
670 size_t unix_strupper(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
675 if (!push_ucs2_talloc(talloc_tos(), &buffer
, src
, &size
)) {
679 if (!strupper_w(buffer
) && (dest
== src
)) {
684 size
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, True
);
690 talloc_strdup() a unix string to upper case.
693 char *talloc_strdup_upper(TALLOC_CTX
*ctx
, const char *s
)
695 char *out_buffer
= talloc_strdup(ctx
,s
);
696 const unsigned char *p
= (const unsigned char *)s
;
697 unsigned char *q
= (unsigned char *)out_buffer
;
703 /* this is quite a common operation, so we want it to be
704 fast. We optimise for the ascii case, knowing that all our
705 supported multi-byte character sets are ascii-compatible
706 (ie. they match for the first 128 chars) */
711 *q
++ = toupper_ascii_fast(*p
);
717 size_t converted_size
, converted_size2
;
718 smb_ucs2_t
*ubuf
= NULL
;
720 /* We're not using the ascii buffer above. */
721 TALLOC_FREE(out_buffer
);
723 if (!convert_string_talloc(ctx
, CH_UNIX
, CH_UTF16LE
, s
,
724 strlen(s
)+1, (void *)&ubuf
,
725 &converted_size
, True
))
732 if (!convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, ubuf
,
733 converted_size
, (void *)&out_buffer
,
734 &converted_size2
, True
))
740 /* Don't need the intermediate buffer
749 char *strupper_talloc(TALLOC_CTX
*ctx
, const char *s
) {
750 return talloc_strdup_upper(ctx
, s
);
754 size_t unix_strlower(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
757 smb_ucs2_t
*buffer
= NULL
;
759 if (!convert_string_talloc(talloc_tos(), CH_UNIX
, CH_UTF16LE
, src
, srclen
,
760 (void **)(void *)&buffer
, &size
,
763 smb_panic("failed to create UCS2 buffer");
765 if (!strlower_w(buffer
) && (dest
== src
)) {
769 size
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, True
);
775 char *talloc_strdup_lower(TALLOC_CTX
*ctx
, const char *s
)
777 size_t converted_size
;
778 smb_ucs2_t
*buffer
= NULL
;
781 if (!push_ucs2_talloc(ctx
, &buffer
, s
, &converted_size
)) {
787 if (!pull_ucs2_talloc(ctx
, &out_buffer
, buffer
, &converted_size
)) {
797 char *strlower_talloc(TALLOC_CTX
*ctx
, const char *s
) {
798 return talloc_strdup_lower(ctx
, s
);
801 size_t ucs2_align(const void *base_ptr
, const void *p
, int flags
)
803 if (flags
& (STR_NOALIGN
|STR_ASCII
))
805 return PTR_DIFF(p
, base_ptr
) & 1;
810 * Copy a string from a char* unix src to a dos codepage string destination.
812 * @return the number of bytes occupied by the string in the destination.
814 * @param flags can include
816 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
817 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
820 * @param dest_len the maximum length in bytes allowed in the
823 size_t push_ascii(void *dest
, const char *src
, size_t dest_len
, int flags
)
829 /* No longer allow a length of -1. */
830 if (dest_len
== (size_t)-1) {
831 smb_panic("push_ascii - dest_len == -1");
834 if (flags
& STR_UPPER
) {
835 tmpbuf
= SMB_STRDUP(src
);
837 smb_panic("malloc fail");
843 src_len
= strlen(src
);
844 if (flags
& (STR_TERMINATE
| STR_TERMINATE_ASCII
)) {
848 ret
= convert_string(CH_UNIX
, CH_DOS
, src
, src_len
, dest
, dest_len
, True
);
851 if (ret
== (size_t)-1) {
852 if ((flags
& (STR_TERMINATE
| STR_TERMINATE_ASCII
))
854 ((char *)dest
)[0] = '\0';
861 size_t push_ascii_fstring(void *dest
, const char *src
)
863 return push_ascii(dest
, src
, sizeof(fstring
), STR_TERMINATE
);
866 /********************************************************************
867 Push an nstring - ensure null terminated. Written by
868 moriyama@miraclelinux.com (MORIYAMA Masayuki).
869 ********************************************************************/
871 size_t push_ascii_nstring(void *dest
, const char *src
)
873 size_t i
, buffer_len
, dest_len
;
877 if (!push_ucs2_talloc(talloc_tos(), &buffer
, src
, &buffer_len
)) {
878 smb_panic("failed to create UCS2 buffer");
881 /* We're using buffer_len below to count ucs2 characters, not bytes. */
882 buffer_len
/= sizeof(smb_ucs2_t
);
885 for (i
= 0; buffer
[i
] != 0 && (i
< buffer_len
); i
++) {
886 unsigned char mb
[10];
887 /* Convert one smb_ucs2_t character at a time. */
888 size_t mb_len
= convert_string(CH_UTF16LE
, CH_DOS
, buffer
+i
, sizeof(smb_ucs2_t
), mb
, sizeof(mb
), False
);
889 if ((mb_len
!= (size_t)-1) && (dest_len
+ mb_len
<= MAX_NETBIOSNAME_LEN
- 1)) {
890 memcpy((char *)dest
+ dest_len
, mb
, mb_len
);
897 ((char *)dest
)[dest_len
] = '\0';
904 /********************************************************************
905 Push and malloc an ascii string. src and dest null terminated.
906 ********************************************************************/
908 bool push_ascii_talloc(TALLOC_CTX
*mem_ctx
, char **dest
, const char *src
, size_t *converted_size
)
910 size_t src_len
= strlen(src
)+1;
913 return convert_string_talloc(mem_ctx
, CH_UNIX
, CH_DOS
, src
, src_len
,
914 (void **)dest
, converted_size
, True
);
918 * Copy a string from a dos codepage source to a unix char* destination.
920 * The resulting string in "dest" is always null terminated.
922 * @param flags can have:
924 * <dt>STR_TERMINATE</dt>
925 * <dd>STR_TERMINATE means the string in @p src
926 * is null terminated, and src_len is ignored.</dd>
929 * @param src_len is the length of the source area in bytes.
930 * @returns the number of bytes occupied by the string in @p src.
932 size_t pull_ascii(char *dest
, const void *src
, size_t dest_len
, size_t src_len
, int flags
)
936 if (dest_len
== (size_t)-1) {
937 /* No longer allow dest_len of -1. */
938 smb_panic("pull_ascii - invalid dest_len of -1");
941 if (flags
& STR_TERMINATE
) {
942 if (src_len
== (size_t)-1) {
943 src_len
= strlen((const char *)src
) + 1;
945 size_t len
= strnlen((const char *)src
, src_len
);
952 ret
= convert_string(CH_DOS
, CH_UNIX
, src
, src_len
, dest
, dest_len
, True
);
953 if (ret
== (size_t)-1) {
958 if (dest_len
&& ret
) {
959 /* Did we already process the terminating zero ? */
960 if (dest
[MIN(ret
-1, dest_len
-1)] != 0) {
961 dest
[MIN(ret
, dest_len
-1)] = 0;
971 * Copy a string from a dos codepage source to a unix char* destination.
974 * The resulting string in "dest" is always null terminated.
976 * @param flags can have:
978 * <dt>STR_TERMINATE</dt>
979 * <dd>STR_TERMINATE means the string in @p src
980 * is null terminated, and src_len is ignored.</dd>
983 * @param src_len is the length of the source area in bytes.
984 * @returns the number of bytes occupied by the string in @p src.
987 static size_t pull_ascii_base_talloc(TALLOC_CTX
*ctx
,
1002 if (flags
& STR_TERMINATE
) {
1003 if (src_len
== (size_t)-1) {
1004 src_len
= strlen((const char *)src
) + 1;
1006 size_t len
= strnlen((const char *)src
, src_len
);
1011 /* Ensure we don't use an insane length from the client. */
1012 if (src_len
>= 1024*1024) {
1013 char *msg
= talloc_asprintf(ctx
,
1014 "Bad src length (%u) in "
1015 "pull_ascii_base_talloc",
1016 (unsigned int)src_len
);
1020 /* Can't have an unlimited length
1021 * non STR_TERMINATE'd.
1023 if (src_len
== (size_t)-1) {
1029 /* src_len != -1 here. */
1031 if (!convert_string_talloc(ctx
, CH_DOS
, CH_UNIX
, src
, src_len
, &dest
,
1036 if (dest_len
&& dest
) {
1037 /* Did we already process the terminating zero ? */
1038 if (dest
[dest_len
-1] != 0) {
1039 size_t size
= talloc_get_size(dest
);
1040 /* Have we got space to append the '\0' ? */
1041 if (size
<= dest_len
) {
1043 dest
= TALLOC_REALLOC_ARRAY(ctx
, dest
, char,
1047 dest_len
= (size_t)-1;
1052 dest
[dest_len
] = '\0';
1063 size_t pull_ascii_fstring(char *dest
, const void *src
)
1065 return pull_ascii(dest
, src
, sizeof(fstring
), -1, STR_TERMINATE
);
1068 /* When pulling an nstring it can expand into a larger size (dos cp -> utf8). Cope with this. */
1070 size_t pull_ascii_nstring(char *dest
, size_t dest_len
, const void *src
)
1072 return pull_ascii(dest
, src
, dest_len
, sizeof(nstring
)-1, STR_TERMINATE
);
1076 * Copy a string from a char* src to a unicode destination.
1078 * @returns the number of bytes occupied by the string in the destination.
1080 * @param flags can have:
1083 * <dt>STR_TERMINATE <dd>means include the null termination.
1084 * <dt>STR_UPPER <dd>means uppercase in the destination.
1085 * <dt>STR_NOALIGN <dd>means don't do alignment.
1088 * @param dest_len is the maximum length allowed in the
1092 size_t push_ucs2(const void *base_ptr
, void *dest
, const char *src
, size_t dest_len
, int flags
)
1098 if (dest_len
== (size_t)-1) {
1099 /* No longer allow dest_len of -1. */
1100 smb_panic("push_ucs2 - invalid dest_len of -1");
1103 if (flags
& STR_TERMINATE
)
1104 src_len
= (size_t)-1;
1106 src_len
= strlen(src
);
1108 if (ucs2_align(base_ptr
, dest
, flags
)) {
1110 dest
= (void *)((char *)dest
+ 1);
1116 /* ucs2 is always a multiple of 2 bytes */
1119 ret
= convert_string(CH_UNIX
, CH_UTF16LE
, src
, src_len
, dest
, dest_len
, True
);
1120 if (ret
== (size_t)-1) {
1121 if ((flags
& STR_TERMINATE
) &&
1131 if (flags
& STR_UPPER
) {
1132 smb_ucs2_t
*dest_ucs2
= (smb_ucs2_t
*)dest
;
1135 /* We check for i < (ret / 2) below as the dest string isn't null
1136 terminated if STR_TERMINATE isn't set. */
1138 for (i
= 0; i
< (ret
/ 2) && i
< (dest_len
/ 2) && dest_ucs2
[i
]; i
++) {
1139 smb_ucs2_t v
= toupper_w(dest_ucs2
[i
]);
1140 if (v
!= dest_ucs2
[i
]) {
1151 * Copy a string from a unix char* src to a UCS2 destination,
1152 * allocating a buffer using talloc().
1154 * @param dest always set at least to NULL
1155 * @parm converted_size set to the number of bytes occupied by the string in
1156 * the destination on success.
1158 * @return true if new buffer was correctly allocated, and string was
1161 bool push_ucs2_talloc(TALLOC_CTX
*ctx
, smb_ucs2_t
**dest
, const char *src
,
1162 size_t *converted_size
)
1164 size_t src_len
= strlen(src
)+1;
1167 return convert_string_talloc(ctx
, CH_UNIX
, CH_UTF16LE
, src
, src_len
,
1168 (void **)dest
, converted_size
, True
);
1173 Copy a string from a char* src to a UTF-8 destination.
1174 Return the number of bytes occupied by the string in the destination
1176 STR_TERMINATE means include the null termination
1177 STR_UPPER means uppercase in the destination
1178 dest_len is the maximum length allowed in the destination. If dest_len
1179 is -1 then no maxiumum is used.
1182 static size_t push_utf8(void *dest
, const char *src
, size_t dest_len
, int flags
)
1186 char *tmpbuf
= NULL
;
1188 if (dest_len
== (size_t)-1) {
1189 /* No longer allow dest_len of -1. */
1190 smb_panic("push_utf8 - invalid dest_len of -1");
1193 if (flags
& STR_UPPER
) {
1194 tmpbuf
= strupper_talloc(talloc_tos(), src
);
1199 src_len
= strlen(src
);
1202 src_len
= strlen(src
);
1203 if (flags
& STR_TERMINATE
) {
1207 ret
= convert_string(CH_UNIX
, CH_UTF8
, src
, src_len
, dest
, dest_len
, True
);
1208 TALLOC_FREE(tmpbuf
);
1212 size_t push_utf8_fstring(void *dest
, const char *src
)
1214 return push_utf8(dest
, src
, sizeof(fstring
), STR_TERMINATE
);
1218 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
1220 * @param dest always set at least to NULL
1221 * @parm converted_size set to the number of bytes occupied by the string in
1222 * the destination on success.
1224 * @return true if new buffer was correctly allocated, and string was
1228 bool push_utf8_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1229 size_t *converted_size
)
1231 size_t src_len
= strlen(src
)+1;
1234 return convert_string_talloc(ctx
, CH_UNIX
, CH_UTF8
, src
, src_len
,
1235 (void**)dest
, converted_size
, True
);
1239 Copy a string from a ucs2 source to a unix char* destination.
1241 STR_TERMINATE means the string in src is null terminated.
1242 STR_NOALIGN means don't try to align.
1243 if STR_TERMINATE is set then src_len is ignored if it is -1.
1244 src_len is the length of the source area in bytes
1245 Return the number of bytes occupied by the string in src.
1246 The resulting string in "dest" is always null terminated.
1249 size_t pull_ucs2(const void *base_ptr
, char *dest
, const void *src
, size_t dest_len
, size_t src_len
, int flags
)
1252 size_t ucs2_align_len
= 0;
1254 if (dest_len
== (size_t)-1) {
1255 /* No longer allow dest_len of -1. */
1256 smb_panic("pull_ucs2 - invalid dest_len of -1");
1260 if (dest
&& dest_len
> 0) {
1266 if (ucs2_align(base_ptr
, src
, flags
)) {
1267 src
= (const void *)((const char *)src
+ 1);
1268 if (src_len
!= (size_t)-1)
1273 if (flags
& STR_TERMINATE
) {
1274 /* src_len -1 is the default for null terminated strings. */
1275 if (src_len
!= (size_t)-1) {
1276 size_t len
= strnlen_w((const smb_ucs2_t
*)src
,
1278 if (len
< src_len
/2)
1284 /* ucs2 is always a multiple of 2 bytes */
1285 if (src_len
!= (size_t)-1)
1288 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, src
, src_len
, dest
, dest_len
, True
);
1289 if (ret
== (size_t)-1) {
1294 if (src_len
== (size_t)-1)
1297 if (dest_len
&& ret
) {
1298 /* Did we already process the terminating zero ? */
1299 if (dest
[MIN(ret
-1, dest_len
-1)] != 0) {
1300 dest
[MIN(ret
, dest_len
-1)] = 0;
1306 return src_len
+ ucs2_align_len
;
1310 Copy a string from a ucs2 source to a unix char* destination.
1311 Talloc version with a base pointer.
1312 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1315 STR_TERMINATE means the string in src is null terminated.
1316 STR_NOALIGN means don't try to align.
1317 if STR_TERMINATE is set then src_len is ignored if it is -1.
1318 src_len is the length of the source area in bytes
1319 Return the number of bytes occupied by the string in src.
1320 The resulting string in "dest" is always null terminated.
1323 size_t pull_ucs2_base_talloc(TALLOC_CTX
*ctx
,
1324 const void *base_ptr
,
1332 size_t ucs2_align_len
= 0;
1337 /* Ensure we never use the braindead "malloc" varient. */
1339 smb_panic("NULL talloc CTX in pull_ucs2_base_talloc\n");
1347 if (ucs2_align(base_ptr
, src
, flags
)) {
1348 src
= (const void *)((const char *)src
+ 1);
1349 if (src_len
!= (size_t)-1)
1354 if (flags
& STR_TERMINATE
) {
1355 /* src_len -1 is the default for null terminated strings. */
1356 if (src_len
!= (size_t)-1) {
1357 size_t len
= strnlen_w((const smb_ucs2_t
*)src
,
1359 if (len
< src_len
/2)
1364 * src_len == -1 - alloc interface won't take this
1365 * so we must calculate.
1367 src_len
= (strlen_w((const smb_ucs2_t
*)src
)+1)*sizeof(smb_ucs2_t
);
1369 /* Ensure we don't use an insane length from the client. */
1370 if (src_len
>= 1024*1024) {
1371 smb_panic("Bad src length in pull_ucs2_base_talloc\n");
1374 /* Can't have an unlimited length
1375 * non STR_TERMINATE'd.
1377 if (src_len
== (size_t)-1) {
1383 /* src_len != -1 here. */
1385 /* ucs2 is always a multiple of 2 bytes */
1388 if (!convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, src
, src_len
,
1389 (void *)&dest
, &dest_len
, True
)) {
1394 /* Did we already process the terminating zero ? */
1395 if (dest
[dest_len
-1] != 0) {
1396 size_t size
= talloc_get_size(dest
);
1397 /* Have we got space to append the '\0' ? */
1398 if (size
<= dest_len
) {
1400 dest
= TALLOC_REALLOC_ARRAY(ctx
, dest
, char,
1404 dest_len
= (size_t)-1;
1409 dest
[dest_len
] = '\0';
1417 return src_len
+ ucs2_align_len
;
1420 size_t pull_ucs2_fstring(char *dest
, const void *src
)
1422 return pull_ucs2(NULL
, dest
, src
, sizeof(fstring
), -1, STR_TERMINATE
);
1426 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
1428 * @param dest always set at least to NULL
1429 * @parm converted_size set to the number of bytes occupied by the string in
1430 * the destination on success.
1432 * @return true if new buffer was correctly allocated, and string was
1436 bool pull_ucs2_talloc(TALLOC_CTX
*ctx
, char **dest
, const smb_ucs2_t
*src
,
1437 size_t *converted_size
)
1439 size_t src_len
= (strlen_w(src
)+1) * sizeof(smb_ucs2_t
);
1442 return convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, src
, src_len
,
1443 (void **)dest
, converted_size
, True
);
1447 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
1449 * @param dest always set at least to NULL
1450 * @parm converted_size set to the number of bytes occupied by the string in
1451 * the destination on success.
1453 * @return true if new buffer was correctly allocated, and string was
1457 bool pull_utf8_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1458 size_t *converted_size
)
1460 size_t src_len
= strlen(src
)+1;
1463 return convert_string_talloc(ctx
, CH_UTF8
, CH_UNIX
, src
, src_len
,
1464 (void **)dest
, converted_size
, True
);
1469 * Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
1471 * @param dest always set at least to NULL
1472 * @parm converted_size set to the number of bytes occupied by the string in
1473 * the destination on success.
1475 * @return true if new buffer was correctly allocated, and string was
1479 bool pull_ascii_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1480 size_t *converted_size
)
1482 size_t src_len
= strlen(src
)+1;
1485 return convert_string_talloc(ctx
, CH_DOS
, CH_UNIX
, src
, src_len
,
1486 (void **)dest
, converted_size
, True
);
1490 Copy a string from a char* src to a unicode or ascii
1491 dos codepage destination choosing unicode or ascii based on the
1493 Return the number of bytes occupied by the string in the destination.
1495 STR_TERMINATE means include the null termination.
1496 STR_UPPER means uppercase in the destination.
1497 STR_ASCII use ascii even with unicode packet.
1498 STR_NOALIGN means don't do alignment.
1499 dest_len is the maximum length allowed in the destination. If dest_len
1500 is -1 then no maxiumum is used.
1503 size_t push_string_check_fn(const char *function
, unsigned int line
,
1504 void *dest
, const char *src
,
1505 size_t dest_len
, int flags
)
1508 /* We really need to zero fill here, not clobber
1509 * region, as we want to ensure that valgrind thinks
1510 * all of the outgoing buffer has been written to
1511 * so a send() or write() won't trap an error.
1515 clobber_region(function
, line
, dest
, dest_len
);
1517 memset(dest
, '\0', dest_len
);
1521 if (!(flags
& STR_ASCII
) && (flags
& STR_UNICODE
)) {
1522 return push_ucs2(NULL
, dest
, src
, dest_len
, flags
);
1524 return push_ascii(dest
, src
, dest_len
, flags
);
1529 Copy a string from a char* src to a unicode or ascii
1530 dos codepage destination choosing unicode or ascii based on the
1531 flags in the SMB buffer starting at base_ptr.
1532 Return the number of bytes occupied by the string in the destination.
1534 STR_TERMINATE means include the null termination.
1535 STR_UPPER means uppercase in the destination.
1536 STR_ASCII use ascii even with unicode packet.
1537 STR_NOALIGN means don't do alignment.
1538 dest_len is the maximum length allowed in the destination. If dest_len
1539 is -1 then no maxiumum is used.
1542 size_t push_string_base(const char *function
, unsigned int line
,
1543 const char *base
, uint16 flags2
,
1544 void *dest
, const char *src
,
1545 size_t dest_len
, int flags
)
1548 /* We really need to zero fill here, not clobber
1549 * region, as we want to ensure that valgrind thinks
1550 * all of the outgoing buffer has been written to
1551 * so a send() or write() won't trap an error.
1555 clobber_region(function
, line
, dest
, dest_len
);
1557 memset(dest
, '\0', dest_len
);
1561 if (!(flags
& STR_ASCII
) && \
1562 ((flags
& STR_UNICODE
|| \
1563 (flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1564 return push_ucs2(base
, dest
, src
, dest_len
, flags
);
1566 return push_ascii(dest
, src
, dest_len
, flags
);
1570 Copy a string from a char* src to a unicode or ascii
1571 dos codepage destination choosing unicode or ascii based on the
1573 Return the number of bytes occupied by the string in the destination.
1575 STR_TERMINATE means include the null termination.
1576 STR_UPPER means uppercase in the destination.
1577 STR_ASCII use ascii even with unicode packet.
1578 STR_NOALIGN means don't do alignment.
1579 dest_len is the maximum length allowed in the destination. If dest_len
1580 is -1 then no maxiumum is used.
1583 ssize_t
push_string(void *dest
, const char *src
, size_t dest_len
, int flags
)
1587 /* We really need to zero fill here, not clobber
1588 * region, as we want to ensure that valgrind thinks
1589 * all of the outgoing buffer has been written to
1590 * so a send() or write() won't trap an error.
1593 memset(dest
, '\0', dest_len
);
1596 if (!(flags
& STR_ASCII
) && \
1597 (flags
& STR_UNICODE
)) {
1598 ret
= push_ucs2(NULL
, dest
, src
, dest_len
, flags
);
1600 ret
= push_ascii(dest
, src
, dest_len
, flags
);
1602 if (ret
== (size_t)-1) {
1609 Copy a string from a unicode or ascii source (depending on
1610 the packet flags) to a char* destination.
1612 STR_TERMINATE means the string in src is null terminated.
1613 STR_UNICODE means to force as unicode.
1614 STR_ASCII use ascii even with unicode packet.
1615 STR_NOALIGN means don't do alignment.
1616 if STR_TERMINATE is set then src_len is ignored is it is -1
1617 src_len is the length of the source area in bytes.
1618 Return the number of bytes occupied by the string in src.
1619 The resulting string in "dest" is always null terminated.
1622 size_t pull_string_fn(const char *function
,
1624 const void *base_ptr
,
1633 clobber_region(function
, line
, dest
, dest_len
);
1636 if ((base_ptr
== NULL
) && ((flags
& (STR_ASCII
|STR_UNICODE
)) == 0)) {
1637 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1641 if (!(flags
& STR_ASCII
) && \
1642 ((flags
& STR_UNICODE
|| \
1643 (smb_flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1644 return pull_ucs2(base_ptr
, dest
, src
, dest_len
, src_len
, flags
);
1646 return pull_ascii(dest
, src
, dest_len
, src_len
, flags
);
1650 Copy a string from a unicode or ascii source (depending on
1651 the packet flags) to a char* destination.
1652 Variant that uses talloc.
1654 STR_TERMINATE means the string in src is null terminated.
1655 STR_UNICODE means to force as unicode.
1656 STR_ASCII use ascii even with unicode packet.
1657 STR_NOALIGN means don't do alignment.
1658 if STR_TERMINATE is set then src_len is ignored is it is -1
1659 src_len is the length of the source area in bytes.
1660 Return the number of bytes occupied by the string in src.
1661 The resulting string in "dest" is always null terminated.
1664 size_t pull_string_talloc_fn(const char *function
,
1667 const void *base_ptr
,
1674 if ((base_ptr
== NULL
) && ((flags
& (STR_ASCII
|STR_UNICODE
)) == 0)) {
1675 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1679 if (!(flags
& STR_ASCII
) && \
1680 ((flags
& STR_UNICODE
|| \
1681 (smb_flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1682 return pull_ucs2_base_talloc(ctx
,
1689 return pull_ascii_base_talloc(ctx
,
1697 size_t align_string(const void *base_ptr
, const char *p
, int flags
)
1699 if (!(flags
& STR_ASCII
) && \
1700 ((flags
& STR_UNICODE
|| \
1701 (SVAL(base_ptr
, smb_flg2
) & FLAGS2_UNICODE_STRINGS
)))) {
1702 return ucs2_align(base_ptr
, p
, flags
);