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? */
187 * Convert string from one encoding to another, making error checking etc
188 * Slow path version - uses (slow) iconv.
190 * @param src pointer to source string (multibyte or singlebyte)
191 * @param srclen length of the source string in bytes
192 * @param dest pointer to destination string (multibyte or singlebyte)
193 * @param destlen maximal length allowed for string
194 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
195 * @returns the number of bytes occupied in the destination
197 * Ensure the srclen contains the terminating zero.
201 static size_t convert_string_internal(charset_t from
, charset_t to
,
202 void const *src
, size_t srclen
,
203 void *dest
, size_t destlen
, bool allow_bad_conv
)
207 const char* inbuf
= (const char*)src
;
208 char* outbuf
= (char*)dest
;
209 smb_iconv_t descriptor
;
211 lazy_initialize_conv();
213 descriptor
= conv_handles
[from
][to
];
215 if (srclen
== (size_t)-1) {
216 if (from
== CH_UTF16LE
|| from
== CH_UTF16BE
) {
217 srclen
= (strlen_w((const smb_ucs2_t
*)src
)+1) * 2;
219 srclen
= strlen((const char *)src
)+1;
224 if (descriptor
== (smb_iconv_t
)-1 || descriptor
== (smb_iconv_t
)0) {
226 DEBUG(0,("convert_string_internal: Conversion not supported.\n"));
235 retval
= smb_iconv(descriptor
, &inbuf
, &i_len
, &outbuf
, &o_len
);
236 if(retval
==(size_t)-1) {
237 const char *reason
="unknown error";
240 reason
="Incomplete multibyte sequence";
242 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
247 reason
="No more room";
249 if (from
== CH_UNIX
) {
250 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u - '%s'\n",
251 charset_name(from
), charset_name(to
),
252 (unsigned int)srclen
, (unsigned int)destlen
, (const char *)src
));
254 DEBUG(3,("E2BIG: convert_string(%s,%s): srclen=%u destlen=%u\n",
255 charset_name(from
), charset_name(to
),
256 (unsigned int)srclen
, (unsigned int)destlen
));
261 reason
="Illegal multibyte sequence";
263 DEBUG(3,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
269 DEBUG(0,("convert_string_internal: Conversion error: %s(%s)\n",reason
,inbuf
));
272 /* smb_panic(reason); */
274 return destlen
-o_len
;
279 * Conversion not supported. This is actually an error, but there are so
280 * many misconfigured iconv systems and smb.conf's out there we can't just
281 * fail. Do a very bad conversion instead.... JRA.
285 if (o_len
== 0 || i_len
== 0)
286 return destlen
- o_len
;
288 if (((from
== CH_UTF16LE
)||(from
== CH_UTF16BE
)) &&
289 ((to
!= CH_UTF16LE
)||(to
!= CH_UTF16BE
))) {
290 /* Can't convert from utf16 any endian to multibyte.
291 Replace with the default fail char.
294 return destlen
- o_len
;
296 *outbuf
= lp_failed_convert_char();
305 if (o_len
== 0 || i_len
== 0)
306 return destlen
- o_len
;
308 /* Keep trying with the next char... */
311 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
312 /* Can't convert to UTF16LE - just widen by adding the
313 default fail char then zero.
316 return destlen
- o_len
;
318 outbuf
[0] = lp_failed_convert_char();
327 if (o_len
== 0 || i_len
== 0)
328 return destlen
- o_len
;
330 /* Keep trying with the next char... */
333 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&&
334 to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
335 /* Failed multibyte to multibyte. Just copy the default fail char and
337 outbuf
[0] = lp_failed_convert_char();
345 if (o_len
== 0 || i_len
== 0)
346 return destlen
- o_len
;
348 /* Keep trying with the next char... */
352 /* Keep compiler happy.... */
353 return destlen
- o_len
;
359 * Convert string from one encoding to another, making error checking etc
360 * Fast path version - handles ASCII first.
362 * @param src pointer to source string (multibyte or singlebyte)
363 * @param srclen length of the source string in bytes, or -1 for nul terminated.
364 * @param dest pointer to destination string (multibyte or singlebyte)
365 * @param destlen maximal length allowed for string - *NEVER* -1.
366 * @param allow_bad_conv determines if a "best effort" conversion is acceptable (never returns errors)
367 * @returns the number of bytes occupied in the destination
369 * Ensure the srclen contains the terminating zero.
371 * This function has been hand-tuned to provide a fast path.
372 * Don't change unless you really know what you are doing. JRA.
375 size_t convert_string(charset_t from
, charset_t to
,
376 void const *src
, size_t srclen
,
377 void *dest
, size_t destlen
, bool allow_bad_conv
)
380 * NB. We deliberately don't do a strlen here if srclen == -1.
381 * This is very expensive over millions of calls and is taken
382 * care of in the slow path in convert_string_internal. JRA.
386 SMB_ASSERT(destlen
!= (size_t)-1);
392 if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
393 const unsigned char *p
= (const unsigned char *)src
;
394 unsigned char *q
= (unsigned char *)dest
;
395 size_t slen
= srclen
;
396 size_t dlen
= destlen
;
397 unsigned char lastp
= '\0';
400 /* If all characters are ascii, fast path here. */
401 while (slen
&& dlen
) {
402 if ((lastp
= *p
) <= 0x7f) {
404 if (slen
!= (size_t)-1) {
412 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
415 return retval
+ convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
420 /* Even if we fast path we should note if we ran out of room. */
421 if (((slen
!= (size_t)-1) && slen
) ||
422 ((slen
== (size_t)-1) && lastp
)) {
427 } else if (from
== CH_UTF16LE
&& to
!= CH_UTF16LE
) {
428 const unsigned char *p
= (const unsigned char *)src
;
429 unsigned char *q
= (unsigned char *)dest
;
431 size_t slen
= srclen
;
432 size_t dlen
= destlen
;
433 unsigned char lastp
= '\0';
435 /* If all characters are ascii, fast path here. */
436 while (((slen
== (size_t)-1) || (slen
>= 2)) && dlen
) {
437 if (((lastp
= *p
) <= 0x7f) && (p
[1] == 0)) {
439 if (slen
!= (size_t)-1) {
448 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
451 return retval
+ convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
456 /* Even if we fast path we should note if we ran out of room. */
457 if (((slen
!= (size_t)-1) && slen
) ||
458 ((slen
== (size_t)-1) && lastp
)) {
463 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
464 const unsigned char *p
= (const unsigned char *)src
;
465 unsigned char *q
= (unsigned char *)dest
;
467 size_t slen
= srclen
;
468 size_t dlen
= destlen
;
469 unsigned char lastp
= '\0';
471 /* If all characters are ascii, fast path here. */
472 while (slen
&& (dlen
>= 2)) {
473 if ((lastp
= *p
) <= 0x7F) {
476 if (slen
!= (size_t)-1) {
484 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
487 return retval
+ convert_string_internal(from
, to
, p
, slen
, q
, dlen
, allow_bad_conv
);
492 /* Even if we fast path we should note if we ran out of room. */
493 if (((slen
!= (size_t)-1) && slen
) ||
494 ((slen
== (size_t)-1) && lastp
)) {
501 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
504 return convert_string_internal(from
, to
, src
, srclen
, dest
, destlen
, allow_bad_conv
);
508 * Convert between character sets, allocating a new buffer for the result.
510 * @param ctx TALLOC_CTX to use to allocate with. If NULL use malloc.
511 * (this is a bad interface and needs fixing. JRA).
512 * @param srclen length of source buffer.
513 * @param dest always set at least to NULL
514 * @param converted_size set to the size of the allocated buffer on return
516 * @note -1 is not accepted for srclen.
518 * @return true if new buffer was correctly allocated, and string was
521 * Ensure the srclen contains the terminating zero.
523 * I hate the goto's in this function. It's embarressing.....
524 * There has to be a cleaner way to do this. JRA.
527 bool convert_string_allocate(TALLOC_CTX
*ctx
, charset_t from
, charset_t to
,
528 void const *src
, size_t srclen
, void *dst
,
529 size_t *converted_size
, bool allow_bad_conv
)
531 size_t i_len
, o_len
, destlen
= (srclen
* 3) / 2;
533 const char *inbuf
= (const char *)src
;
534 char *outbuf
= NULL
, *ob
= NULL
;
535 smb_iconv_t descriptor
;
536 void **dest
= (void **)dst
;
540 if (!converted_size
) {
545 if (src
== NULL
|| srclen
== (size_t)-1) {
554 lazy_initialize_conv();
556 descriptor
= conv_handles
[from
][to
];
558 if (descriptor
== (smb_iconv_t
)-1 || descriptor
== (smb_iconv_t
)0) {
560 DEBUG(0,("convert_string_allocate: Conversion not supported.\n"));
567 /* +2 is for ucs2 null termination. */
568 if ((destlen
*2)+2 < destlen
) {
569 /* wrapped ! abort. */
571 DEBUG(0, ("convert_string_allocate: destlen wrapped !\n"));
577 destlen
= destlen
* 2;
580 /* +2 is for ucs2 null termination. */
582 ob
= (char *)TALLOC_REALLOC(ctx
, ob
, destlen
+ 2);
584 ob
= (char *)SMB_REALLOC(ob
, destlen
+ 2);
588 DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
598 retval
= smb_iconv(descriptor
,
601 if(retval
== (size_t)-1) {
602 const char *reason
="unknown error";
605 reason
="Incomplete multibyte sequence";
607 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason
,inbuf
));
614 reason
="Illegal multibyte sequence";
616 DEBUG(3,("convert_string_allocate: Conversion error: %s(%s)\n",reason
,inbuf
));
622 DEBUG(0,("Conversion error: %s(%s)\n",reason
,inbuf
));
623 /* smb_panic(reason); */
634 destlen
= destlen
- o_len
;
635 /* Don't shrink unless we're reclaiming a lot of
636 * space. This is in the hot codepath and these
637 * reallocs *cost*. JRA.
640 /* We're shrinking here so we know the +2 is safe from wrap. */
642 ob
= (char *)TALLOC_REALLOC(ctx
,ob
,destlen
+ 2);
644 ob
= (char *)SMB_REALLOC(ob
,destlen
+ 2);
648 if (destlen
&& !ob
) {
649 DEBUG(0, ("convert_string_allocate: out of memory!\n"));
656 /* Must ucs2 null terminate in the extra space we allocated. */
658 ob
[destlen
+1] = '\0';
660 *converted_size
= destlen
;
666 * Conversion not supported. This is actually an error, but there are so
667 * many misconfigured iconv systems and smb.conf's out there we can't just
668 * fail. Do a very bad conversion instead.... JRA.
672 if (o_len
== 0 || i_len
== 0)
675 if (((from
== CH_UTF16LE
)||(from
== CH_UTF16BE
)) &&
676 ((to
!= CH_UTF16LE
)||(to
!= CH_UTF16BE
))) {
677 /* Can't convert from utf16 any endian to multibyte.
678 Replace with the default fail char.
685 *outbuf
= lp_failed_convert_char();
694 if (o_len
== 0 || i_len
== 0)
697 /* Keep trying with the next char... */
700 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&& to
== CH_UTF16LE
) {
701 /* Can't convert to UTF16LE - just widen by adding the
702 default fail char then zero.
707 outbuf
[0] = lp_failed_convert_char();
716 if (o_len
== 0 || i_len
== 0)
719 /* Keep trying with the next char... */
722 } else if (from
!= CH_UTF16LE
&& from
!= CH_UTF16BE
&&
723 to
!= CH_UTF16LE
&& to
!= CH_UTF16BE
) {
724 /* Failed multibyte to multibyte. Just copy the default fail char and
726 outbuf
[0] = lp_failed_convert_char();
734 if (o_len
== 0 || i_len
== 0)
737 /* Keep trying with the next char... */
741 /* Keep compiler happy.... */
748 * Convert between character sets, allocating a new buffer using talloc for the result.
750 * @param srclen length of source buffer.
751 * @param dest always set at least to NULL
752 * @parm converted_size set to the number of bytes occupied by the string in
753 * the destination on success.
754 * @note -1 is not accepted for srclen.
756 * @return true if new buffer was correctly allocated, and string was
759 bool convert_string_talloc(TALLOC_CTX
*ctx
, charset_t from
, charset_t to
,
760 void const *src
, size_t srclen
, void *dst
,
761 size_t *converted_size
, bool allow_bad_conv
)
763 void **dest
= (void **)dst
;
766 return convert_string_allocate(ctx
, from
, to
, src
, srclen
, dest
,
767 converted_size
, allow_bad_conv
);
770 size_t unix_strupper(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
775 if (!push_ucs2_allocate(&buffer
, src
, &size
)) {
779 if (!strupper_w(buffer
) && (dest
== src
)) {
784 size
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, True
);
790 strdup() a unix string to upper case.
793 char *strdup_upper(const char *s
)
795 char *out_buffer
= SMB_STRDUP(s
);
796 const unsigned char *p
= (const unsigned char *)s
;
797 unsigned char *q
= (unsigned char *)out_buffer
;
803 /* this is quite a common operation, so we want it to be
804 fast. We optimise for the ascii case, knowing that all our
805 supported multi-byte character sets are ascii-compatible
806 (ie. they match for the first 128 chars) */
811 *q
++ = toupper_ascii_fast(*p
);
817 size_t converted_size
, converted_size2
;
818 smb_ucs2_t
*buffer
= NULL
;
820 SAFE_FREE(out_buffer
);
821 if (!convert_string_allocate(NULL
, CH_UNIX
, CH_UTF16LE
, s
,
823 (void **)(void *)&buffer
,
824 &converted_size
, True
))
831 if (!convert_string_allocate(NULL
, CH_UTF16LE
, CH_UNIX
, buffer
,
833 (void **)(void *)&out_buffer
,
834 &converted_size2
, True
))
840 /* Don't need the intermediate buffer
850 talloc_strdup() a unix string to upper case.
853 char *talloc_strdup_upper(TALLOC_CTX
*ctx
, const char *s
)
855 char *out_buffer
= talloc_strdup(ctx
,s
);
856 const unsigned char *p
= (const unsigned char *)s
;
857 unsigned char *q
= (unsigned char *)out_buffer
;
863 /* this is quite a common operation, so we want it to be
864 fast. We optimise for the ascii case, knowing that all our
865 supported multi-byte character sets are ascii-compatible
866 (ie. they match for the first 128 chars) */
871 *q
++ = toupper_ascii_fast(*p
);
877 size_t converted_size
, converted_size2
;
878 smb_ucs2_t
*ubuf
= NULL
;
880 /* We're not using the ascii buffer above. */
881 TALLOC_FREE(out_buffer
);
883 if (!convert_string_talloc(ctx
, CH_UNIX
, CH_UTF16LE
, s
,
884 strlen(s
)+1, (void *)&ubuf
,
885 &converted_size
, True
))
892 if (!convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, ubuf
,
893 converted_size
, (void *)&out_buffer
,
894 &converted_size2
, True
))
900 /* Don't need the intermediate buffer
909 size_t unix_strlower(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
912 smb_ucs2_t
*buffer
= NULL
;
914 if (!convert_string_allocate(NULL
, CH_UNIX
, CH_UTF16LE
, src
, srclen
,
915 (void **)(void *)&buffer
, &size
,
918 smb_panic("failed to create UCS2 buffer");
920 if (!strlower_w(buffer
) && (dest
== src
)) {
924 size
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, True
);
930 strdup() a unix string to lower case.
933 char *strdup_lower(const char *s
)
935 size_t converted_size
;
936 smb_ucs2_t
*buffer
= NULL
;
939 if (!push_ucs2_allocate(&buffer
, s
, &converted_size
)) {
945 if (!pull_ucs2_allocate(&out_buffer
, buffer
, &converted_size
)) {
955 char *talloc_strdup_lower(TALLOC_CTX
*ctx
, const char *s
)
957 size_t converted_size
;
958 smb_ucs2_t
*buffer
= NULL
;
961 if (!push_ucs2_talloc(ctx
, &buffer
, s
, &converted_size
)) {
967 if (!pull_ucs2_talloc(ctx
, &out_buffer
, buffer
, &converted_size
)) {
978 size_t ucs2_align(const void *base_ptr
, const void *p
, int flags
)
980 if (flags
& (STR_NOALIGN
|STR_ASCII
))
982 return PTR_DIFF(p
, base_ptr
) & 1;
987 * Copy a string from a char* unix src to a dos codepage string destination.
989 * @return the number of bytes occupied by the string in the destination.
991 * @param flags can include
993 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
994 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
997 * @param dest_len the maximum length in bytes allowed in the
1000 size_t push_ascii(void *dest
, const char *src
, size_t dest_len
, int flags
)
1002 size_t src_len
= strlen(src
);
1003 char *tmpbuf
= NULL
;
1006 /* No longer allow a length of -1. */
1007 if (dest_len
== (size_t)-1) {
1008 smb_panic("push_ascii - dest_len == -1");
1011 if (flags
& STR_UPPER
) {
1012 tmpbuf
= SMB_STRDUP(src
);
1014 smb_panic("malloc fail");
1020 if (flags
& (STR_TERMINATE
| STR_TERMINATE_ASCII
)) {
1024 ret
= convert_string(CH_UNIX
, CH_DOS
, src
, src_len
, dest
, dest_len
, True
);
1025 if (ret
== (size_t)-1 &&
1026 (flags
& (STR_TERMINATE
| STR_TERMINATE_ASCII
))
1028 ((char *)dest
)[0] = '\0';
1034 size_t push_ascii_fstring(void *dest
, const char *src
)
1036 return push_ascii(dest
, src
, sizeof(fstring
), STR_TERMINATE
);
1039 /********************************************************************
1040 Push an nstring - ensure null terminated. Written by
1041 moriyama@miraclelinux.com (MORIYAMA Masayuki).
1042 ********************************************************************/
1044 size_t push_ascii_nstring(void *dest
, const char *src
)
1046 size_t i
, buffer_len
, dest_len
;
1050 if (!push_ucs2_allocate(&buffer
, src
, &buffer_len
)) {
1051 smb_panic("failed to create UCS2 buffer");
1054 /* We're using buffer_len below to count ucs2 characters, not bytes. */
1055 buffer_len
/= sizeof(smb_ucs2_t
);
1058 for (i
= 0; buffer
[i
] != 0 && (i
< buffer_len
); i
++) {
1059 unsigned char mb
[10];
1060 /* Convert one smb_ucs2_t character at a time. */
1061 size_t mb_len
= convert_string(CH_UTF16LE
, CH_DOS
, buffer
+i
, sizeof(smb_ucs2_t
), mb
, sizeof(mb
), False
);
1062 if ((mb_len
!= (size_t)-1) && (dest_len
+ mb_len
<= MAX_NETBIOSNAME_LEN
- 1)) {
1063 memcpy((char *)dest
+ dest_len
, mb
, mb_len
);
1070 ((char *)dest
)[dest_len
] = '\0';
1073 conv_silent
= False
;
1077 /********************************************************************
1078 Push and malloc an ascii string. src and dest null terminated.
1079 ********************************************************************/
1081 bool push_ascii_allocate(char **dest
, const char *src
, size_t *converted_size
)
1083 size_t src_len
= strlen(src
)+1;
1086 return convert_string_allocate(NULL
, CH_UNIX
, CH_DOS
, src
, src_len
,
1087 (void **)dest
, converted_size
, True
);
1091 * Copy a string from a dos codepage source to a unix char* destination.
1093 * The resulting string in "dest" is always null terminated.
1095 * @param flags can have:
1097 * <dt>STR_TERMINATE</dt>
1098 * <dd>STR_TERMINATE means the string in @p src
1099 * is null terminated, and src_len is ignored.</dd>
1102 * @param src_len is the length of the source area in bytes.
1103 * @returns the number of bytes occupied by the string in @p src.
1105 size_t pull_ascii(char *dest
, const void *src
, size_t dest_len
, size_t src_len
, int flags
)
1109 if (dest_len
== (size_t)-1) {
1110 /* No longer allow dest_len of -1. */
1111 smb_panic("pull_ascii - invalid dest_len of -1");
1114 if (flags
& STR_TERMINATE
) {
1115 if (src_len
== (size_t)-1) {
1116 src_len
= strlen((const char *)src
) + 1;
1118 size_t len
= strnlen((const char *)src
, src_len
);
1125 ret
= convert_string(CH_DOS
, CH_UNIX
, src
, src_len
, dest
, dest_len
, True
);
1126 if (ret
== (size_t)-1) {
1131 if (dest_len
&& ret
) {
1132 /* Did we already process the terminating zero ? */
1133 if (dest
[MIN(ret
-1, dest_len
-1)] != 0) {
1134 dest
[MIN(ret
, dest_len
-1)] = 0;
1144 * Copy a string from a dos codepage source to a unix char* destination.
1146 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1149 * The resulting string in "dest" is always null terminated.
1151 * @param flags can have:
1153 * <dt>STR_TERMINATE</dt>
1154 * <dd>STR_TERMINATE means the string in @p src
1155 * is null terminated, and src_len is ignored.</dd>
1158 * @param src_len is the length of the source area in bytes.
1159 * @returns the number of bytes occupied by the string in @p src.
1162 static size_t pull_ascii_base_talloc(TALLOC_CTX
*ctx
,
1169 size_t converted_size
;
1172 /* Ensure we never use the braindead "malloc" varient. */
1174 smb_panic("NULL talloc CTX in pull_ascii_base_talloc\n");
1180 if (flags
& STR_TERMINATE
) {
1181 if (src_len
== (size_t)-1) {
1182 src_len
= strlen((const char *)src
) + 1;
1184 size_t len
= strnlen((const char *)src
, src_len
);
1189 /* Ensure we don't use an insane length from the client. */
1190 if (src_len
>= 1024*1024) {
1191 char *msg
= talloc_asprintf(ctx
,
1192 "Bad src length (%u) in "
1193 "pull_ascii_base_talloc",
1194 (unsigned int)src_len
);
1199 if (!convert_string_allocate(ctx
, CH_DOS
, CH_UNIX
, src
, src_len
, &dest
,
1200 &converted_size
, True
))
1205 if (converted_size
&& dest
) {
1206 /* Did we already process the terminating zero ? */
1207 if (dest
[converted_size
- 1] != 0) {
1208 dest
[converted_size
- 1] = 0;
1218 size_t pull_ascii_fstring(char *dest
, const void *src
)
1220 return pull_ascii(dest
, src
, sizeof(fstring
), -1, STR_TERMINATE
);
1223 /* When pulling an nstring it can expand into a larger size (dos cp -> utf8). Cope with this. */
1225 size_t pull_ascii_nstring(char *dest
, size_t dest_len
, const void *src
)
1227 return pull_ascii(dest
, src
, dest_len
, sizeof(nstring
)-1, STR_TERMINATE
);
1231 * Copy a string from a char* src to a unicode destination.
1233 * @returns the number of bytes occupied by the string in the destination.
1235 * @param flags can have:
1238 * <dt>STR_TERMINATE <dd>means include the null termination.
1239 * <dt>STR_UPPER <dd>means uppercase in the destination.
1240 * <dt>STR_NOALIGN <dd>means don't do alignment.
1243 * @param dest_len is the maximum length allowed in the
1247 size_t push_ucs2(const void *base_ptr
, void *dest
, const char *src
, size_t dest_len
, int flags
)
1253 if (dest_len
== (size_t)-1) {
1254 /* No longer allow dest_len of -1. */
1255 smb_panic("push_ucs2 - invalid dest_len of -1");
1258 if (flags
& STR_TERMINATE
)
1259 src_len
= (size_t)-1;
1261 src_len
= strlen(src
);
1263 if (ucs2_align(base_ptr
, dest
, flags
)) {
1265 dest
= (void *)((char *)dest
+ 1);
1271 /* ucs2 is always a multiple of 2 bytes */
1274 ret
= convert_string(CH_UNIX
, CH_UTF16LE
, src
, src_len
, dest
, dest_len
, True
);
1275 if (ret
== (size_t)-1) {
1276 if ((flags
& STR_TERMINATE
) &&
1286 if (flags
& STR_UPPER
) {
1287 smb_ucs2_t
*dest_ucs2
= (smb_ucs2_t
*)dest
;
1290 /* We check for i < (ret / 2) below as the dest string isn't null
1291 terminated if STR_TERMINATE isn't set. */
1293 for (i
= 0; i
< (ret
/ 2) && i
< (dest_len
/ 2) && dest_ucs2
[i
]; i
++) {
1294 smb_ucs2_t v
= toupper_w(dest_ucs2
[i
]);
1295 if (v
!= dest_ucs2
[i
]) {
1306 * Copy a string from a unix char* src to a UCS2 destination,
1307 * allocating a buffer using talloc().
1309 * @param dest always set at least to NULL
1310 * @parm converted_size set to the number of bytes occupied by the string in
1311 * the destination on success.
1313 * @return true if new buffer was correctly allocated, and string was
1316 bool push_ucs2_talloc(TALLOC_CTX
*ctx
, smb_ucs2_t
**dest
, const char *src
,
1317 size_t *converted_size
)
1319 size_t src_len
= strlen(src
)+1;
1322 return convert_string_talloc(ctx
, CH_UNIX
, CH_UTF16LE
, src
, src_len
,
1323 (void **)dest
, converted_size
, True
);
1328 * Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
1330 * @param dest always set at least to NULL
1331 * @parm converted_size set to the number of bytes occupied by the string in
1332 * the destination on success.
1334 * @return true if new buffer was correctly allocated, and string was
1338 bool push_ucs2_allocate(smb_ucs2_t
**dest
, const char *src
,
1339 size_t *converted_size
)
1341 size_t src_len
= strlen(src
)+1;
1344 return convert_string_allocate(NULL
, CH_UNIX
, CH_UTF16LE
, src
, src_len
,
1345 (void **)dest
, converted_size
, True
);
1349 Copy a string from a char* src to a UTF-8 destination.
1350 Return the number of bytes occupied by the string in the destination
1352 STR_TERMINATE means include the null termination
1353 STR_UPPER means uppercase in the destination
1354 dest_len is the maximum length allowed in the destination. If dest_len
1355 is -1 then no maxiumum is used.
1358 static size_t push_utf8(void *dest
, const char *src
, size_t dest_len
, int flags
)
1362 char *tmpbuf
= NULL
;
1364 if (dest_len
== (size_t)-1) {
1365 /* No longer allow dest_len of -1. */
1366 smb_panic("push_utf8 - invalid dest_len of -1");
1369 if (flags
& STR_UPPER
) {
1370 tmpbuf
= strdup_upper(src
);
1375 src_len
= strlen(src
);
1378 src_len
= strlen(src
);
1379 if (flags
& STR_TERMINATE
) {
1383 ret
= convert_string(CH_UNIX
, CH_UTF8
, src
, src_len
, dest
, dest_len
, True
);
1388 size_t push_utf8_fstring(void *dest
, const char *src
)
1390 return push_utf8(dest
, src
, sizeof(fstring
), STR_TERMINATE
);
1394 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
1396 * @param dest always set at least to NULL
1397 * @parm converted_size set to the number of bytes occupied by the string in
1398 * the destination on success.
1400 * @return true if new buffer was correctly allocated, and string was
1404 bool push_utf8_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1405 size_t *converted_size
)
1407 size_t src_len
= strlen(src
)+1;
1410 return convert_string_talloc(ctx
, CH_UNIX
, CH_UTF8
, src
, src_len
,
1411 (void**)dest
, converted_size
, True
);
1415 * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
1417 * @param dest always set at least to NULL
1418 * @parm converted_size set to the number of bytes occupied by the string in
1419 * the destination on success.
1421 * @return true if new buffer was correctly allocated, and string was
1425 bool push_utf8_allocate(char **dest
, const char *src
, size_t *converted_size
)
1427 size_t src_len
= strlen(src
)+1;
1430 return convert_string_allocate(NULL
, CH_UNIX
, CH_UTF8
, src
, src_len
,
1431 (void **)dest
, converted_size
, True
);
1435 Copy a string from a ucs2 source to a unix char* destination.
1437 STR_TERMINATE means the string in src is null terminated.
1438 STR_NOALIGN means don't try to align.
1439 if STR_TERMINATE is set then src_len is ignored if it is -1.
1440 src_len is the length of the source area in bytes
1441 Return the number of bytes occupied by the string in src.
1442 The resulting string in "dest" is always null terminated.
1445 size_t pull_ucs2(const void *base_ptr
, char *dest
, const void *src
, size_t dest_len
, size_t src_len
, int flags
)
1449 if (dest_len
== (size_t)-1) {
1450 /* No longer allow dest_len of -1. */
1451 smb_panic("pull_ucs2 - invalid dest_len of -1");
1455 if (dest
&& dest_len
> 0) {
1461 if (ucs2_align(base_ptr
, src
, flags
)) {
1462 src
= (const void *)((const char *)src
+ 1);
1463 if (src_len
!= (size_t)-1)
1467 if (flags
& STR_TERMINATE
) {
1468 /* src_len -1 is the default for null terminated strings. */
1469 if (src_len
!= (size_t)-1) {
1470 size_t len
= strnlen_w((const smb_ucs2_t
*)src
,
1472 if (len
< src_len
/2)
1478 /* ucs2 is always a multiple of 2 bytes */
1479 if (src_len
!= (size_t)-1)
1482 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, src
, src_len
, dest
, dest_len
, True
);
1483 if (ret
== (size_t)-1) {
1488 if (src_len
== (size_t)-1)
1491 if (dest_len
&& ret
) {
1492 /* Did we already process the terminating zero ? */
1493 if (dest
[MIN(ret
-1, dest_len
-1)] != 0) {
1494 dest
[MIN(ret
, dest_len
-1)] = 0;
1504 Copy a string from a ucs2 source to a unix char* destination.
1505 Talloc version with a base pointer.
1506 Uses malloc if TALLOC_CTX is NULL (this is a bad interface and
1509 STR_TERMINATE means the string in src is null terminated.
1510 STR_NOALIGN means don't try to align.
1511 if STR_TERMINATE is set then src_len is ignored if it is -1.
1512 src_len is the length of the source area in bytes
1513 Return the number of bytes occupied by the string in src.
1514 The resulting string in "dest" is always null terminated.
1517 size_t pull_ucs2_base_talloc(TALLOC_CTX
*ctx
,
1518 const void *base_ptr
,
1530 /* Ensure we never use the braindead "malloc" varient. */
1532 smb_panic("NULL talloc CTX in pull_ucs2_base_talloc\n");
1540 if (ucs2_align(base_ptr
, src
, flags
)) {
1541 src
= (const void *)((const char *)src
+ 1);
1542 if (src_len
!= (size_t)-1)
1546 if (flags
& STR_TERMINATE
) {
1547 /* src_len -1 is the default for null terminated strings. */
1548 if (src_len
!= (size_t)-1) {
1549 size_t len
= strnlen_w((const smb_ucs2_t
*)src
,
1551 if (len
< src_len
/2)
1556 * src_len == -1 - alloc interface won't take this
1557 * so we must calculate.
1559 src_len
= (strlen_w((const smb_ucs2_t
*)src
)+1)*sizeof(smb_ucs2_t
);
1561 /* Ensure we don't use an insane length from the client. */
1562 if (src_len
>= 1024*1024) {
1563 smb_panic("Bad src length in pull_ucs2_base_talloc\n");
1567 /* ucs2 is always a multiple of 2 bytes */
1568 if (src_len
!= (size_t)-1) {
1572 if (!convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, src
, src_len
,
1573 (void *)&dest
, &dest_len
, True
)) {
1577 if (src_len
== (size_t)-1)
1578 src_len
= dest_len
*2;
1581 /* Did we already process the terminating zero ? */
1582 if (dest
[dest_len
-1] != 0) {
1583 size_t size
= talloc_get_size(dest
);
1584 /* Have we got space to append the '\0' ? */
1585 if (size
<= dest_len
) {
1587 dest
= TALLOC_REALLOC_ARRAY(ctx
, dest
, char,
1591 dest_len
= (size_t)-1;
1596 dest
[dest_len
] = '\0';
1607 size_t pull_ucs2_fstring(char *dest
, const void *src
)
1609 return pull_ucs2(NULL
, dest
, src
, sizeof(fstring
), -1, STR_TERMINATE
);
1613 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
1615 * @param dest always set at least to NULL
1616 * @parm converted_size set to the number of bytes occupied by the string in
1617 * the destination on success.
1619 * @return true if new buffer was correctly allocated, and string was
1623 bool pull_ucs2_talloc(TALLOC_CTX
*ctx
, char **dest
, const smb_ucs2_t
*src
,
1624 size_t *converted_size
)
1626 size_t src_len
= (strlen_w(src
)+1) * sizeof(smb_ucs2_t
);
1629 return convert_string_talloc(ctx
, CH_UTF16LE
, CH_UNIX
, src
, src_len
,
1630 (void **)dest
, converted_size
, True
);
1634 * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
1636 * @param dest always set at least to NULL
1637 * @parm converted_size set to the number of bytes occupied by the string in
1638 * the destination on success.
1639 * @return true if new buffer was correctly allocated, and string was
1643 bool pull_ucs2_allocate(char **dest
, const smb_ucs2_t
*src
,
1644 size_t *converted_size
)
1646 size_t src_len
= (strlen_w(src
)+1) * sizeof(smb_ucs2_t
);
1649 return convert_string_allocate(NULL
, CH_UTF16LE
, CH_UNIX
, src
, src_len
,
1650 (void **)dest
, converted_size
, True
);
1654 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
1656 * @param dest always set at least to NULL
1657 * @parm converted_size set to the number of bytes occupied by the string in
1658 * the destination on success.
1660 * @return true if new buffer was correctly allocated, and string was
1664 bool pull_utf8_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1665 size_t *converted_size
)
1667 size_t src_len
= strlen(src
)+1;
1670 return convert_string_talloc(ctx
, CH_UTF8
, CH_UNIX
, src
, src_len
,
1671 (void **)dest
, converted_size
, True
);
1675 * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
1677 * @param dest always set at least to NULL
1678 * @parm converted_size set to the number of bytes occupied by the string in
1679 * the destination on success.
1681 * @return true if new buffer was correctly allocated, and string was
1685 bool pull_utf8_allocate(char **dest
, const char *src
, size_t *converted_size
)
1687 size_t src_len
= strlen(src
)+1;
1690 return convert_string_allocate(NULL
, CH_UTF8
, CH_UNIX
, src
, src_len
,
1691 (void **)dest
, converted_size
, True
);
1695 * Copy a string from a DOS src to a unix char * destination, allocating a buffer using talloc
1697 * @param dest always set at least to NULL
1698 * @parm converted_size set to the number of bytes occupied by the string in
1699 * the destination on success.
1701 * @return true if new buffer was correctly allocated, and string was
1705 bool pull_ascii_talloc(TALLOC_CTX
*ctx
, char **dest
, const char *src
,
1706 size_t *converted_size
)
1708 size_t src_len
= strlen(src
)+1;
1711 return convert_string_talloc(ctx
, CH_DOS
, CH_UNIX
, src
, src_len
,
1712 (void **)dest
, converted_size
, True
);
1716 Copy a string from a char* src to a unicode or ascii
1717 dos codepage destination choosing unicode or ascii based on the
1718 flags in the SMB buffer starting at base_ptr.
1719 Return the number of bytes occupied by the string in the destination.
1721 STR_TERMINATE means include the null termination.
1722 STR_UPPER means uppercase in the destination.
1723 STR_ASCII use ascii even with unicode packet.
1724 STR_NOALIGN means don't do alignment.
1725 dest_len is the maximum length allowed in the destination. If dest_len
1726 is -1 then no maxiumum is used.
1729 size_t push_string_fn(const char *function
, unsigned int line
,
1730 const void *base_ptr
, uint16 flags2
,
1731 void *dest
, const char *src
,
1732 size_t dest_len
, int flags
)
1735 /* We really need to zero fill here, not clobber
1736 * region, as we want to ensure that valgrind thinks
1737 * all of the outgoing buffer has been written to
1738 * so a send() or write() won't trap an error.
1742 clobber_region(function
, line
, dest
, dest_len
);
1744 memset(dest
, '\0', dest_len
);
1748 if (!(flags
& STR_ASCII
) && \
1749 ((flags
& STR_UNICODE
|| \
1750 (flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1751 return push_ucs2(base_ptr
, dest
, src
, dest_len
, flags
);
1753 return push_ascii(dest
, src
, dest_len
, flags
);
1758 Copy a string from a unicode or ascii source (depending on
1759 the packet flags) to a char* destination.
1761 STR_TERMINATE means the string in src is null terminated.
1762 STR_UNICODE means to force as unicode.
1763 STR_ASCII use ascii even with unicode packet.
1764 STR_NOALIGN means don't do alignment.
1765 if STR_TERMINATE is set then src_len is ignored is it is -1
1766 src_len is the length of the source area in bytes.
1767 Return the number of bytes occupied by the string in src.
1768 The resulting string in "dest" is always null terminated.
1771 size_t pull_string_fn(const char *function
,
1773 const void *base_ptr
,
1782 clobber_region(function
, line
, dest
, dest_len
);
1785 if ((base_ptr
== NULL
) && ((flags
& (STR_ASCII
|STR_UNICODE
)) == 0)) {
1786 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1790 if (!(flags
& STR_ASCII
) && \
1791 ((flags
& STR_UNICODE
|| \
1792 (smb_flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1793 return pull_ucs2(base_ptr
, dest
, src
, dest_len
, src_len
, flags
);
1795 return pull_ascii(dest
, src
, dest_len
, src_len
, flags
);
1799 Copy a string from a unicode or ascii source (depending on
1800 the packet flags) to a char* destination.
1801 Variant that uses talloc.
1803 STR_TERMINATE means the string in src is null terminated.
1804 STR_UNICODE means to force as unicode.
1805 STR_ASCII use ascii even with unicode packet.
1806 STR_NOALIGN means don't do alignment.
1807 if STR_TERMINATE is set then src_len is ignored is it is -1
1808 src_len is the length of the source area in bytes.
1809 Return the number of bytes occupied by the string in src.
1810 The resulting string in "dest" is always null terminated.
1813 size_t pull_string_talloc_fn(const char *function
,
1816 const void *base_ptr
,
1823 if ((base_ptr
== NULL
) && ((flags
& (STR_ASCII
|STR_UNICODE
)) == 0)) {
1824 smb_panic("No base ptr to get flg2 and neither ASCII nor "
1828 if (!(flags
& STR_ASCII
) && \
1829 ((flags
& STR_UNICODE
|| \
1830 (smb_flags2
& FLAGS2_UNICODE_STRINGS
)))) {
1831 return pull_ucs2_base_talloc(ctx
,
1838 return pull_ascii_base_talloc(ctx
,
1846 size_t align_string(const void *base_ptr
, const char *p
, int flags
)
1848 if (!(flags
& STR_ASCII
) && \
1849 ((flags
& STR_UNICODE
|| \
1850 (SVAL(base_ptr
, smb_flg2
) & FLAGS2_UNICODE_STRINGS
)))) {
1851 return ucs2_align(base_ptr
, p
, flags
);
1857 Return the unicode codepoint for the next multi-byte CH_UNIX character
1858 in the string. The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
1860 Also return the number of bytes consumed (which tells the caller
1861 how many bytes to skip to get to the next CH_UNIX character).
1863 Return INVALID_CODEPOINT if the next character cannot be converted.
1866 codepoint_t
next_codepoint(const char *str
, size_t *size
)
1868 /* It cannot occupy more than 4 bytes in UTF16 format */
1870 smb_iconv_t descriptor
;
1876 if ((str
[0] & 0x80) == 0) {
1878 return (codepoint_t
)str
[0];
1881 /* We assume that no multi-byte character can take
1882 more than 5 bytes. This is OK as we only
1883 support codepoints up to 1M */
1885 ilen_orig
= strnlen(str
, 5);
1888 lazy_initialize_conv();
1890 descriptor
= conv_handles
[CH_UNIX
][CH_UTF16LE
];
1891 if (descriptor
== (smb_iconv_t
)-1 || descriptor
== (smb_iconv_t
)0) {
1893 return INVALID_CODEPOINT
;
1896 /* This looks a little strange, but it is needed to cope
1897 with codepoints above 64k which are encoded as per RFC2781. */
1899 outbuf
= (char *)buf
;
1900 smb_iconv(descriptor
, &str
, &ilen
, &outbuf
, &olen
);
1902 /* We failed to convert to a 2 byte character.
1903 See if we can convert to a 4 UTF16-LE byte char encoding.
1906 outbuf
= (char *)buf
;
1907 smb_iconv(descriptor
, &str
, &ilen
, &outbuf
, &olen
);
1909 /* We didn't convert any bytes */
1911 return INVALID_CODEPOINT
;
1918 *size
= ilen_orig
- ilen
;
1921 /* 2 byte, UTF16-LE encoded value. */
1922 return (codepoint_t
)SVAL(buf
, 0);
1925 /* Decode a 4 byte UTF16-LE character manually.
1926 See RFC2871 for the encoding machanism.
1928 codepoint_t w1
= SVAL(buf
,0) & ~0xD800;
1929 codepoint_t w2
= SVAL(buf
,2) & ~0xDC00;
1931 return (codepoint_t
)0x10000 +
1935 /* no other length is valid */
1936 return INVALID_CODEPOINT
;