ec88e784d088e59f271e7e3db460483e98f0b19e
[amitay/samba.git] / lib / util / charset / util_unistr.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Samba utility functions
4    Copyright (C) Andrew Tridgell 1992-2001
5    Copyright (C) Simo Sorce 2001
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "system/locale.h"
23
24 struct smb_iconv_convenience *global_iconv_convenience = NULL;
25
26 static inline struct smb_iconv_convenience *get_iconv_convenience(void)
27 {
28         if (global_iconv_convenience == NULL)
29                 global_iconv_convenience = smb_iconv_convenience_init(talloc_autofree_context(), "ASCII", "UTF-8", true);
30         return global_iconv_convenience;
31 }
32
33 /**
34  Case insensitive string compararison
35 **/
36 _PUBLIC_ int strcasecmp_m(const char *s1, const char *s2)
37 {
38         codepoint_t c1=0, c2=0;
39         size_t size1, size2;
40         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
41
42         /* handle null ptr comparisons to simplify the use in qsort */
43         if (s1 == s2) return 0;
44         if (s1 == NULL) return -1;
45         if (s2 == NULL) return 1;
46
47         while (*s1 && *s2) {
48                 c1 = next_codepoint_convenience(iconv_convenience, s1, &size1);
49                 c2 = next_codepoint_convenience(iconv_convenience, s2, &size2);
50
51                 s1 += size1;
52                 s2 += size2;
53
54                 if (c1 == c2) {
55                         continue;
56                 }
57
58                 if (c1 == INVALID_CODEPOINT ||
59                     c2 == INVALID_CODEPOINT) {
60                         /* what else can we do?? */
61                         return strcasecmp(s1, s2);
62                 }
63
64                 if (toupper_m(c1) != toupper_m(c2)) {
65                         return c1 - c2;
66                 }
67         }
68
69         return *s1 - *s2;
70 }
71
72 /**
73  * Get the next token from a string, return False if none found.
74  * Handles double-quotes.
75  * 
76  * Based on a routine by GJC@VILLAGE.COM. 
77  * Extensively modified by Andrew.Tridgell@anu.edu.au
78  **/
79 _PUBLIC_ bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
80 {
81         const char *s;
82         bool quoted;
83         size_t len=1;
84
85         if (!ptr)
86                 return false;
87
88         s = *ptr;
89
90         /* default to simple separators */
91         if (!sep)
92                 sep = " \t\n\r";
93
94         /* find the first non sep char */
95         while (*s && strchr_m(sep,*s))
96                 s++;
97         
98         /* nothing left? */
99         if (!*s)
100                 return false;
101         
102         /* copy over the token */
103         for (quoted = false; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
104                 if (*s == '\"') {
105                         quoted = !quoted;
106                 } else {
107                         len++;
108                         *buff++ = *s;
109                 }
110         }
111         
112         *ptr = (*s) ? s+1 : s;  
113         *buff = 0;
114         
115         return true;
116 }
117
118 /**
119  Case insensitive string compararison, length limited
120 **/
121 _PUBLIC_ int strncasecmp_m(const char *s1, const char *s2, size_t n)
122 {
123         codepoint_t c1=0, c2=0;
124         size_t size1, size2;
125         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
126
127         /* handle null ptr comparisons to simplify the use in qsort */
128         if (s1 == s2) return 0;
129         if (s1 == NULL) return -1;
130         if (s2 == NULL) return 1;
131
132         while (*s1 && *s2 && n) {
133                 n--;
134
135                 c1 = next_codepoint_convenience(iconv_convenience, s1, &size1);
136                 c2 = next_codepoint_convenience(iconv_convenience, s2, &size2);
137
138                 s1 += size1;
139                 s2 += size2;
140
141                 if (c1 == c2) {
142                         continue;
143                 }
144
145                 if (c1 == INVALID_CODEPOINT ||
146                     c2 == INVALID_CODEPOINT) {
147                         /* what else can we do?? */
148                         return strcasecmp(s1, s2);
149                 }
150
151                 if (toupper_m(c1) != toupper_m(c2)) {
152                         return c1 - c2;
153                 }
154         }
155
156         if (n == 0) {
157                 return 0;
158         }
159
160         return *s1 - *s2;
161 }
162
163 /**
164  * Compare 2 strings.
165  *
166  * @note The comparison is case-insensitive.
167  **/
168 _PUBLIC_ bool strequal_m(const char *s1, const char *s2)
169 {
170         return strcasecmp_m(s1,s2) == 0;
171 }
172
173 /**
174  Compare 2 strings (case sensitive).
175 **/
176 _PUBLIC_ bool strcsequal_m(const char *s1,const char *s2)
177 {
178         if (s1 == s2)
179                 return true;
180         if (!s1 || !s2)
181                 return false;
182         
183         return strcmp(s1,s2) == 0;
184 }
185
186
187 /**
188  String replace.
189  NOTE: oldc and newc must be 7 bit characters
190 **/
191 _PUBLIC_ void string_replace_m(char *s, char oldc, char newc)
192 {
193         struct smb_iconv_convenience *ic = get_iconv_convenience();
194         while (s && *s) {
195                 size_t size;
196                 codepoint_t c = next_codepoint_convenience(ic, s, &size);
197                 if (c == oldc) {
198                         *s = newc;
199                 }
200                 s += size;
201         }
202 }
203
204 /**
205  Paranoid strcpy into a buffer of given length (includes terminating
206  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
207  and replaces with '_'. Deliberately does *NOT* check for multibyte
208  characters. Don't change it !
209 **/
210
211 _PUBLIC_ char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
212 {
213         size_t len, i;
214
215         if (maxlength == 0) {
216                 /* can't fit any bytes at all! */
217                 return NULL;
218         }
219
220         if (!dest) {
221                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
222                 return NULL;
223         }
224
225         if (!src) {
226                 *dest = 0;
227                 return dest;
228         }  
229
230         len = strlen(src);
231         if (len >= maxlength)
232                 len = maxlength - 1;
233
234         if (!other_safe_chars)
235                 other_safe_chars = "";
236
237         for(i = 0; i < len; i++) {
238                 int val = (src[i] & 0xff);
239                 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
240                         dest[i] = src[i];
241                 else
242                         dest[i] = '_';
243         }
244
245         dest[i] = '\0';
246
247         return dest;
248 }
249
250 /**
251  Count the number of UCS2 characters in a string. Normally this will
252  be the same as the number of bytes in a string for single byte strings,
253  but will be different for multibyte.
254 **/
255 _PUBLIC_ size_t strlen_m(const char *s)
256 {
257         size_t count = 0;
258         struct smb_iconv_convenience *ic = get_iconv_convenience();
259
260         if (!s) {
261                 return 0;
262         }
263
264         while (*s && !(((uint8_t)*s) & 0x80)) {
265                 s++;
266                 count++;
267         }
268
269         if (!*s) {
270                 return count;
271         }
272
273         while (*s) {
274                 size_t c_size;
275                 codepoint_t c = next_codepoint_convenience(ic, s, &c_size);
276                 if (c < 0x10000) {
277                         count += 1;
278                 } else {
279                         count += 2;
280                 }
281                 s += c_size;
282         }
283
284         return count;
285 }
286
287 /**
288    Work out the number of multibyte chars in a string, including the NULL
289    terminator.
290 **/
291 _PUBLIC_ size_t strlen_m_term(const char *s)
292 {
293         if (!s) {
294                 return 0;
295         }
296
297         return strlen_m(s) + 1;
298 }
299
300 /*
301  * Weird helper routine for the winreg pipe: If nothing is around, return 0,
302  * if a string is there, include the terminator.
303  */
304
305 _PUBLIC_ size_t strlen_m_term_null(const char *s)
306 {
307         size_t len;
308         if (!s) {
309                 return 0;
310         }
311         len = strlen_m(s);
312         if (len == 0) {
313                 return 0;
314         }
315
316         return len+1;
317 }
318
319 /**
320  Strchr and strrchr_m are a bit complex on general multi-byte strings. 
321 **/
322 _PUBLIC_ char *strchr_m(const char *s, char c)
323 {
324         struct smb_iconv_convenience *ic = get_iconv_convenience();
325         if (s == NULL) {
326                 return NULL;
327         }
328         /* characters below 0x3F are guaranteed to not appear in
329            non-initial position in multi-byte charsets */
330         if ((c & 0xC0) == 0) {
331                 return strchr(s, c);
332         }
333
334         while (*s) {
335                 size_t size;
336                 codepoint_t c2 = next_codepoint_convenience(ic, s, &size);
337                 if (c2 == c) {
338                         return discard_const_p(char, s);
339                 }
340                 s += size;
341         }
342
343         return NULL;
344 }
345
346 /**
347  * Multibyte-character version of strrchr
348  */
349 _PUBLIC_ char *strrchr_m(const char *s, char c)
350 {
351         struct smb_iconv_convenience *ic = get_iconv_convenience();
352         char *ret = NULL;
353
354         if (s == NULL) {
355                 return NULL;
356         }
357
358         /* characters below 0x3F are guaranteed to not appear in
359            non-initial position in multi-byte charsets */
360         if ((c & 0xC0) == 0) {
361                 return strrchr(s, c);
362         }
363
364         while (*s) {
365                 size_t size;
366                 codepoint_t c2 = next_codepoint_convenience(ic, s, &size);
367                 if (c2 == c) {
368                         ret = discard_const_p(char, s);
369                 }
370                 s += size;
371         }
372
373         return ret;
374 }
375
376 /**
377   return True if any (multi-byte) character is lower case
378 */
379 _PUBLIC_ bool strhaslower(const char *string)
380 {
381         struct smb_iconv_convenience *ic = get_iconv_convenience();
382         while (*string) {
383                 size_t c_size;
384                 codepoint_t s;
385                 codepoint_t t;
386
387                 s = next_codepoint_convenience(ic, string, &c_size);
388                 string += c_size;
389
390                 t = toupper_m(s);
391
392                 if (s != t) {
393                         return true; /* that means it has lower case chars */
394                 }
395         }
396
397         return false;
398
399
400 /**
401   return True if any (multi-byte) character is upper case
402 */
403 _PUBLIC_ bool strhasupper(const char *string)
404 {
405         struct smb_iconv_convenience *ic = get_iconv_convenience();
406         while (*string) {
407                 size_t c_size;
408                 codepoint_t s;
409                 codepoint_t t;
410
411                 s = next_codepoint_convenience(ic, string, &c_size);
412                 string += c_size;
413
414                 t = tolower_m(s);
415
416                 if (s != t) {
417                         return true; /* that means it has upper case chars */
418                 }
419         }
420
421         return false;
422
423
424 /**
425  Convert a string to lower case, allocated with talloc
426 **/
427 _PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
428 {
429         size_t size=0;
430         char *dest;
431         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
432
433         /* this takes advantage of the fact that upper/lower can't
434            change the length of a character by more than 1 byte */
435         dest = talloc_array(ctx, char, 2*(strlen(src))+1);
436         if (dest == NULL) {
437                 return NULL;
438         }
439
440         while (*src) {
441                 size_t c_size;
442                 codepoint_t c = next_codepoint_convenience(iconv_convenience, src, &c_size);
443                 src += c_size;
444
445                 c = tolower_m(c);
446
447                 c_size = push_codepoint(iconv_convenience, dest+size, c);
448                 if (c_size == -1) {
449                         talloc_free(dest);
450                         return NULL;
451                 }
452                 size += c_size;
453         }
454
455         dest[size] = 0;
456
457         /* trim it so talloc_append_string() works */
458         dest = talloc_realloc(ctx, dest, char, size+1);
459
460         talloc_set_name_const(dest, dest);
461
462         return dest;
463 }
464
465 /**
466  Convert a string to UPPER case, allocated with talloc
467  source length limited to n bytes
468 **/
469 _PUBLIC_ char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n)
470 {
471         size_t size=0;
472         char *dest;
473         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
474         
475         if (!src) {
476                 return NULL;
477         }
478
479         /* this takes advantage of the fact that upper/lower can't
480            change the length of a character by more than 1 byte */
481         dest = talloc_array(ctx, char, 2*(n+1));
482         if (dest == NULL) {
483                 return NULL;
484         }
485
486         while (*src && n--) {
487                 size_t c_size;
488                 codepoint_t c = next_codepoint_convenience(iconv_convenience, src, &c_size);
489                 src += c_size;
490
491                 c = toupper_m(c);
492
493                 c_size = push_codepoint(iconv_convenience, dest+size, c);
494                 if (c_size == -1) {
495                         talloc_free(dest);
496                         return NULL;
497                 }
498                 size += c_size;
499         }
500
501         dest[size] = 0;
502
503         /* trim it so talloc_append_string() works */
504         dest = talloc_realloc(ctx, dest, char, size+1);
505
506         talloc_set_name_const(dest, dest);
507
508         return dest;
509 }
510
511 /**
512  Convert a string to UPPER case, allocated with talloc
513 **/
514 _PUBLIC_ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
515 {
516         return strupper_talloc_n(ctx, src, src?strlen(src):0);
517 }
518
519 /**
520  talloc_strdup() a unix string to upper case.
521 **/
522 _PUBLIC_ char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src)
523 {
524         return strupper_talloc(ctx, src);
525 }
526
527 /**
528  Convert a string to lower case.
529 **/
530 _PUBLIC_ void strlower_m(char *s)
531 {
532         char *d;
533         struct smb_iconv_convenience *iconv_convenience;
534
535         /* this is quite a common operation, so we want it to be
536            fast. We optimise for the ascii case, knowing that all our
537            supported multi-byte character sets are ascii-compatible
538            (ie. they match for the first 128 chars) */
539         while (*s && !(((uint8_t)*s) & 0x80)) {
540                 *s = tolower((uint8_t)*s);
541                 s++;
542         }
543
544         if (!*s)
545                 return;
546
547         iconv_convenience = get_iconv_convenience();
548
549         d = s;
550
551         while (*s) {
552                 size_t c_size, c_size2;
553                 codepoint_t c = next_codepoint_convenience(iconv_convenience, s, &c_size);
554                 c_size2 = push_codepoint(iconv_convenience, d, tolower_m(c));
555                 if (c_size2 > c_size) {
556                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
557                                  c, tolower_m(c), (int)c_size, (int)c_size2));
558                         smb_panic("codepoint expansion in strlower_m\n");
559                 }
560                 s += c_size;
561                 d += c_size2;
562         }
563         *d = 0;
564 }
565
566 /**
567  Convert a string to UPPER case.
568 **/
569 _PUBLIC_ void strupper_m(char *s)
570 {
571         char *d;
572         struct smb_iconv_convenience *iconv_convenience;
573
574         /* this is quite a common operation, so we want it to be
575            fast. We optimise for the ascii case, knowing that all our
576            supported multi-byte character sets are ascii-compatible
577            (ie. they match for the first 128 chars) */
578         while (*s && !(((uint8_t)*s) & 0x80)) {
579                 *s = toupper((uint8_t)*s);
580                 s++;
581         }
582
583         if (!*s)
584                 return;
585
586         iconv_convenience = get_iconv_convenience();
587
588         d = s;
589
590         while (*s) {
591                 size_t c_size, c_size2;
592                 codepoint_t c = next_codepoint_convenience(iconv_convenience, s, &c_size);
593                 c_size2 = push_codepoint(iconv_convenience, d, toupper_m(c));
594                 if (c_size2 > c_size) {
595                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
596                                  c, toupper_m(c), (int)c_size, (int)c_size2));
597                         smb_panic("codepoint expansion in strupper_m\n");
598                 }
599                 s += c_size;
600                 d += c_size2;
601         }
602         *d = 0;
603 }
604
605
606 /**
607  Find the number of 'c' chars in a string
608 **/
609 _PUBLIC_ size_t count_chars_m(const char *s, char c)
610 {
611         struct smb_iconv_convenience *ic = get_iconv_convenience();
612         size_t count = 0;
613
614         while (*s) {
615                 size_t size;
616                 codepoint_t c2 = next_codepoint_convenience(ic, s, &size);
617                 if (c2 == c) count++;
618                 s += size;
619         }
620
621         return count;
622 }
623
624
625 /**
626  * Copy a string from a char* unix src to a dos codepage string destination.
627  *
628  * @return the number of bytes occupied by the string in the destination.
629  *
630  * @param flags can include
631  * <dl>
632  * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
633  * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
634  * </dl>
635  *
636  * @param dest_len the maximum length in bytes allowed in the
637  * destination.  If @p dest_len is -1 then no maximum is used.
638  **/
639 static ssize_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
640 {
641         size_t src_len;
642         ssize_t ret;
643
644         if (flags & STR_UPPER) {
645                 char *tmpbuf = strupper_talloc(NULL, src);
646                 if (tmpbuf == NULL) {
647                         return -1;
648                 }
649                 ret = push_ascii(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
650                 talloc_free(tmpbuf);
651                 return ret;
652         }
653
654         src_len = strlen(src);
655
656         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
657                 src_len++;
658
659         return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, false);
660 }
661
662 /**
663  * Copy a string from a unix char* src to an ASCII destination,
664  * allocating a buffer using talloc().
665  *
666  * @param dest always set at least to NULL 
667  *
668  * @returns The number of bytes occupied by the string in the destination
669  *         or -1 in case of error.
670  **/
671 _PUBLIC_ bool push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size)
672 {
673         size_t src_len = strlen(src)+1;
674         *dest = NULL;
675         return convert_string_talloc(ctx, CH_UNIX, CH_DOS, src, src_len, (void **)dest, converted_size, false);
676 }
677
678
679 /**
680  * Copy a string from a dos codepage source to a unix char* destination.
681  *
682  * The resulting string in "dest" is always null terminated.
683  *
684  * @param flags can have:
685  * <dl>
686  * <dt>STR_TERMINATE</dt>
687  * <dd>STR_TERMINATE means the string in @p src
688  * is null terminated, and src_len is ignored.</dd>
689  * </dl>
690  *
691  * @param src_len is the length of the source area in bytes.
692  * @returns the number of bytes occupied by the string in @p src.
693  **/
694 static ssize_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
695 {
696         size_t ret;
697
698         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
699                 if (src_len == (size_t)-1) {
700                         src_len = strlen((const char *)src) + 1;
701                 } else {
702                         size_t len = strnlen((const char *)src, src_len);
703                         if (len < src_len)
704                                 len++;
705                         src_len = len;
706                 }
707         }
708
709         ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, false);
710
711         if (dest_len)
712                 dest[MIN(ret, dest_len-1)] = 0;
713
714         return src_len;
715 }
716
717 /**
718  * Copy a string from a char* src to a unicode destination.
719  *
720  * @returns the number of bytes occupied by the string in the destination.
721  *
722  * @param flags can have:
723  *
724  * <dl>
725  * <dt>STR_TERMINATE <dd>means include the null termination.
726  * <dt>STR_UPPER     <dd>means uppercase in the destination.
727  * <dt>STR_NOALIGN   <dd>means don't do alignment.
728  * </dl>
729  *
730  * @param dest_len is the maximum length allowed in the
731  * destination. If dest_len is -1 then no maxiumum is used.
732  **/
733 static ssize_t push_ucs2(void *dest, const char *src, size_t dest_len, int flags)
734 {
735         size_t len=0;
736         size_t src_len = strlen(src);
737         size_t ret;
738
739         if (flags & STR_UPPER) {
740                 char *tmpbuf = strupper_talloc(NULL, src);
741                 if (tmpbuf == NULL) {
742                         return -1;
743                 }
744                 ret = push_ucs2(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
745                 talloc_free(tmpbuf);
746                 return ret;
747         }
748
749         if (flags & STR_TERMINATE)
750                 src_len++;
751
752         if (ucs2_align(NULL, dest, flags)) {
753                 *(char *)dest = 0;
754                 dest = (void *)((char *)dest + 1);
755                 if (dest_len) dest_len--;
756                 len++;
757         }
758
759         /* ucs2 is always a multiple of 2 bytes */
760         dest_len &= ~1;
761
762         ret = convert_string(CH_UNIX, CH_UTF16, src, src_len, dest, dest_len, false);
763         if (ret == (size_t)-1) {
764                 return 0;
765         }
766
767         len += ret;
768
769         return len;
770 }
771
772
773 /**
774  * Copy a string from a unix char* src to a UCS2 destination,
775  * allocating a buffer using talloc().
776  *
777  * @param dest always set at least to NULL 
778  *
779  * @returns The number of bytes occupied by the string in the destination
780  *         or -1 in case of error.
781  **/
782 _PUBLIC_ bool push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src, size_t *converted_size)
783 {
784         size_t src_len = strlen(src)+1;
785         *dest = NULL;
786         return convert_string_talloc(ctx, CH_UNIX, CH_UTF16, src, src_len, (void **)dest, converted_size, false);
787 }
788
789
790 /**
791  * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
792  *
793  * @param dest always set at least to NULL 
794  *
795  * @returns The number of bytes occupied by the string in the destination
796  **/
797
798 _PUBLIC_ bool push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size)
799 {
800         size_t src_len = strlen(src)+1;
801         *dest = NULL;
802         return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void **)dest, converted_size, false);
803 }
804
805 /**
806  Copy a string from a ucs2 source to a unix char* destination.
807  Flags can have:
808   STR_TERMINATE means the string in src is null terminated.
809   STR_NOALIGN   means don't try to align.
810  if STR_TERMINATE is set then src_len is ignored if it is -1.
811  src_len is the length of the source area in bytes
812  Return the number of bytes occupied by the string in src.
813  The resulting string in "dest" is always null terminated.
814 **/
815
816 static size_t pull_ucs2(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
817 {
818         size_t ret;
819
820         if (ucs2_align(NULL, src, flags)) {
821                 src = (const void *)((const char *)src + 1);
822                 if (src_len > 0)
823                         src_len--;
824         }
825
826         if (flags & STR_TERMINATE) {
827                 if (src_len == (size_t)-1) {
828                         src_len = utf16_len(src);
829                 } else {
830                         src_len = utf16_len_n(src, src_len);
831                 }
832         }
833
834         /* ucs2 is always a multiple of 2 bytes */
835         if (src_len != (size_t)-1)
836                 src_len &= ~1;
837         
838         ret = convert_string(CH_UTF16, CH_UNIX, src, src_len, dest, dest_len, false);
839         if (dest_len)
840                 dest[MIN(ret, dest_len-1)] = 0;
841
842         return src_len;
843 }
844
845 /**
846  * Copy a string from a ASCII src to a unix char * destination, allocating a buffer using talloc
847  *
848  * @param dest always set at least to NULL 
849  *
850  * @returns The number of bytes occupied by the string in the destination
851  **/
852
853 _PUBLIC_ bool pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size)
854 {
855         size_t src_len = strlen(src)+1;
856         *dest = NULL;
857         return convert_string_talloc(ctx, CH_DOS, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
858 }
859
860 /**
861  * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
862  *
863  * @param dest always set at least to NULL 
864  *
865  * @returns The number of bytes occupied by the string in the destination
866  **/
867
868 _PUBLIC_ bool pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src, size_t *converted_size)
869 {
870         size_t src_len = utf16_len(src);
871         *dest = NULL;
872         return convert_string_talloc(ctx, CH_UTF16, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
873 }
874
875 /**
876  * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
877  *
878  * @param dest always set at least to NULL 
879  *
880  * @returns The number of bytes occupied by the string in the destination
881  **/
882
883 _PUBLIC_ bool pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size)
884 {
885         size_t src_len = strlen(src)+1;
886         *dest = NULL;
887         return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest, converted_size, false);
888 }
889
890 /**
891  Copy a string from a char* src to a unicode or ascii
892  dos codepage destination choosing unicode or ascii based on the 
893  flags in the SMB buffer starting at base_ptr.
894  Return the number of bytes occupied by the string in the destination.
895  flags can have:
896   STR_TERMINATE means include the null termination.
897   STR_UPPER     means uppercase in the destination.
898   STR_ASCII     use ascii even with unicode packet.
899   STR_NOALIGN   means don't do alignment.
900  dest_len is the maximum length allowed in the destination. If dest_len
901  is -1 then no maxiumum is used.
902 **/
903
904 _PUBLIC_ ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags)
905 {
906         if (flags & STR_ASCII) {
907                 return push_ascii(dest, src, dest_len, flags);
908         } else if (flags & STR_UNICODE) {
909                 return push_ucs2(dest, src, dest_len, flags);
910         } else {
911                 smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
912                 return -1;
913         }
914 }
915
916
917 /**
918  Copy a string from a unicode or ascii source (depending on
919  the packet flags) to a char* destination.
920  Flags can have:
921   STR_TERMINATE means the string in src is null terminated.
922   STR_UNICODE   means to force as unicode.
923   STR_ASCII     use ascii even with unicode packet.
924   STR_NOALIGN   means don't do alignment.
925  if STR_TERMINATE is set then src_len is ignored is it is -1
926  src_len is the length of the source area in bytes.
927  Return the number of bytes occupied by the string in src.
928  The resulting string in "dest" is always null terminated.
929 **/
930
931 _PUBLIC_ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
932 {
933         if (flags & STR_ASCII) {
934                 return pull_ascii(dest, src, dest_len, src_len, flags);
935         } else if (flags & STR_UNICODE) {
936                 return pull_ucs2(dest, src, dest_len, src_len, flags);
937         } else {
938                 smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
939                 return -1;
940         }
941 }
942
943
944 /**
945  * Convert string from one encoding to another, making error checking etc
946  *
947  * @param src pointer to source string (multibyte or singlebyte)
948  * @param srclen length of the source string in bytes
949  * @param dest pointer to destination string (multibyte or singlebyte)
950  * @param destlen maximal length allowed for string
951  * @returns the number of bytes occupied in the destination
952  **/
953 _PUBLIC_ size_t convert_string(charset_t from, charset_t to,
954                                 void const *src, size_t srclen, 
955                                 void *dest, size_t destlen, 
956                                 bool allow_badcharcnv)
957 {
958         size_t ret;
959         if (!convert_string_convenience(get_iconv_convenience(), from, to, 
960                                                                           src, srclen,
961                                                                           dest, destlen, &ret,
962                                                                           allow_badcharcnv))
963                 return -1;
964         return ret;
965 }
966
967 /**
968  * Convert between character sets, allocating a new buffer using talloc for the result.
969  *
970  * @param srclen length of source buffer.
971  * @param dest always set at least to NULL
972  * @param converted_size Size in bytes of the converted string
973  * @note -1 is not accepted for srclen.
974  *
975  * @returns boolean indication whether the conversion succeeded
976  **/
977
978 _PUBLIC_ bool convert_string_talloc(TALLOC_CTX *ctx, 
979                                        charset_t from, charset_t to, 
980                                        void const *src, size_t srclen, 
981                                        void **dest, size_t *converted_size, 
982                                            bool allow_badcharcnv)
983 {
984         return convert_string_talloc_convenience(ctx, get_iconv_convenience(),
985                                                                                          from, to, src, srclen, dest,
986                                                                                          converted_size, 
987                                                                                          allow_badcharcnv);
988 }
989
990
991 _PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
992 {
993         return next_codepoint_convenience(get_iconv_convenience(), str, size);
994 }