85f9755557fd726cc9d355b9483eab7b5b0431c5
[kai/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 #include "param/param.h"
24
25 static inline struct smb_iconv_convenience *get_iconv_convenience(void)
26 {
27         static struct smb_iconv_convenience *ic = NULL;
28         if (ic == NULL)
29                 ic = lp_iconv_convenience(global_loadparm);
30         return ic;
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(iconv_convenience, s1, &size1);
49                 c2 = next_codepoint(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(iconv_convenience, s1, &size1);
136                 c2 = next_codepoint(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         while (s && *s) {
194                 size_t size;
195                 codepoint_t c = next_codepoint(get_iconv_convenience(), s, &size);
196                 if (c == oldc) {
197                         *s = newc;
198                 }
199                 s += size;
200         }
201 }
202
203 /**
204  Paranoid strcpy into a buffer of given length (includes terminating
205  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
206  and replaces with '_'. Deliberately does *NOT* check for multibyte
207  characters. Don't change it !
208 **/
209
210 _PUBLIC_ char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
211 {
212         size_t len, i;
213
214         if (maxlength == 0) {
215                 /* can't fit any bytes at all! */
216                 return NULL;
217         }
218
219         if (!dest) {
220                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
221                 return NULL;
222         }
223
224         if (!src) {
225                 *dest = 0;
226                 return dest;
227         }  
228
229         len = strlen(src);
230         if (len >= maxlength)
231                 len = maxlength - 1;
232
233         if (!other_safe_chars)
234                 other_safe_chars = "";
235
236         for(i = 0; i < len; i++) {
237                 int val = (src[i] & 0xff);
238                 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
239                         dest[i] = src[i];
240                 else
241                         dest[i] = '_';
242         }
243
244         dest[i] = '\0';
245
246         return dest;
247 }
248
249 /**
250  Count the number of UCS2 characters in a string. Normally this will
251  be the same as the number of bytes in a string for single byte strings,
252  but will be different for multibyte.
253 **/
254 _PUBLIC_ size_t strlen_m(const char *s)
255 {
256         size_t count = 0;
257
258         if (!s) {
259                 return 0;
260         }
261
262         while (*s && !(((uint8_t)*s) & 0x80)) {
263                 s++;
264                 count++;
265         }
266
267         if (!*s) {
268                 return count;
269         }
270
271         while (*s) {
272                 size_t c_size;
273                 codepoint_t c = next_codepoint(get_iconv_convenience(), s, &c_size);
274                 if (c < 0x10000) {
275                         count += 1;
276                 } else {
277                         count += 2;
278                 }
279                 s += c_size;
280         }
281
282         return count;
283 }
284
285 /**
286    Work out the number of multibyte chars in a string, including the NULL
287    terminator.
288 **/
289 _PUBLIC_ size_t strlen_m_term(const char *s)
290 {
291         if (!s) {
292                 return 0;
293         }
294
295         return strlen_m(s) + 1;
296 }
297
298 /**
299  Strchr and strrchr_m are a bit complex on general multi-byte strings. 
300 **/
301 _PUBLIC_ char *strchr_m(const char *s, char c)
302 {
303         if (s == NULL) {
304                 return NULL;
305         }
306         /* characters below 0x3F are guaranteed to not appear in
307            non-initial position in multi-byte charsets */
308         if ((c & 0xC0) == 0) {
309                 return strchr(s, c);
310         }
311
312         while (*s) {
313                 size_t size;
314                 codepoint_t c2 = next_codepoint(get_iconv_convenience(), s, &size);
315                 if (c2 == c) {
316                         return discard_const_p(char, s);
317                 }
318                 s += size;
319         }
320
321         return NULL;
322 }
323
324 /**
325  * Multibyte-character version of strrchr
326  */
327 _PUBLIC_ char *strrchr_m(const char *s, char c)
328 {
329         char *ret = NULL;
330
331         if (s == NULL) {
332                 return NULL;
333         }
334
335         /* characters below 0x3F are guaranteed to not appear in
336            non-initial position in multi-byte charsets */
337         if ((c & 0xC0) == 0) {
338                 return strrchr(s, c);
339         }
340
341         while (*s) {
342                 size_t size;
343                 codepoint_t c2 = next_codepoint(get_iconv_convenience(), s, &size);
344                 if (c2 == c) {
345                         ret = discard_const_p(char, s);
346                 }
347                 s += size;
348         }
349
350         return ret;
351 }
352
353 /**
354   return True if any (multi-byte) character is lower case
355 */
356 _PUBLIC_ bool strhaslower(const char *string)
357 {
358         while (*string) {
359                 size_t c_size;
360                 codepoint_t s;
361                 codepoint_t t;
362
363                 s = next_codepoint(get_iconv_convenience(), string, &c_size);
364                 string += c_size;
365
366                 t = toupper_m(s);
367
368                 if (s != t) {
369                         return true; /* that means it has lower case chars */
370                 }
371         }
372
373         return false;
374
375
376 /**
377   return True if any (multi-byte) character is upper case
378 */
379 _PUBLIC_ bool strhasupper(const char *string)
380 {
381         while (*string) {
382                 size_t c_size;
383                 codepoint_t s;
384                 codepoint_t t;
385
386                 s = next_codepoint(get_iconv_convenience(), string, &c_size);
387                 string += c_size;
388
389                 t = tolower_m(s);
390
391                 if (s != t) {
392                         return true; /* that means it has upper case chars */
393                 }
394         }
395
396         return false;
397
398
399 /**
400  Convert a string to lower case, allocated with talloc
401 **/
402 _PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
403 {
404         size_t size=0;
405         char *dest;
406         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
407
408         /* this takes advantage of the fact that upper/lower can't
409            change the length of a character by more than 1 byte */
410         dest = talloc_array(ctx, char, 2*(strlen(src))+1);
411         if (dest == NULL) {
412                 return NULL;
413         }
414
415         while (*src) {
416                 size_t c_size;
417                 codepoint_t c = next_codepoint(iconv_convenience, src, &c_size);
418                 src += c_size;
419
420                 c = tolower_m(c);
421
422                 c_size = push_codepoint(iconv_convenience, dest+size, c);
423                 if (c_size == -1) {
424                         talloc_free(dest);
425                         return NULL;
426                 }
427                 size += c_size;
428         }
429
430         dest[size] = 0;
431
432         /* trim it so talloc_append_string() works */
433         dest = talloc_realloc(ctx, dest, char, size+1);
434
435         talloc_set_name_const(dest, dest);
436
437         return dest;
438 }
439
440 /**
441  Convert a string to UPPER case, allocated with talloc
442  source length limited to n bytes
443 **/
444 _PUBLIC_ char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n)
445 {
446         size_t size=0;
447         char *dest;
448         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
449         
450         if (!src) {
451                 return NULL;
452         }
453
454         /* this takes advantage of the fact that upper/lower can't
455            change the length of a character by more than 1 byte */
456         dest = talloc_array(ctx, char, 2*(n+1));
457         if (dest == NULL) {
458                 return NULL;
459         }
460
461         while (*src && n--) {
462                 size_t c_size;
463                 codepoint_t c = next_codepoint(iconv_convenience, src, &c_size);
464                 src += c_size;
465
466                 c = toupper_m(c);
467
468                 c_size = push_codepoint(iconv_convenience, dest+size, c);
469                 if (c_size == -1) {
470                         talloc_free(dest);
471                         return NULL;
472                 }
473                 size += c_size;
474         }
475
476         dest[size] = 0;
477
478         /* trim it so talloc_append_string() works */
479         dest = talloc_realloc(ctx, dest, char, size+1);
480
481         talloc_set_name_const(dest, dest);
482
483         return dest;
484 }
485
486 /**
487  Convert a string to UPPER case, allocated with talloc
488 **/
489 _PUBLIC_ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
490 {
491         return strupper_talloc_n(ctx, src, src?strlen(src):0);
492 }
493
494 /**
495  talloc_strdup() a unix string to upper case.
496 **/
497 _PUBLIC_ char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src)
498 {
499         return strupper_talloc(ctx, src);
500 }
501
502 /**
503  Convert a string to lower case.
504 **/
505 _PUBLIC_ void strlower_m(char *s)
506 {
507         char *d;
508         struct smb_iconv_convenience *iconv_convenience;
509
510         /* this is quite a common operation, so we want it to be
511            fast. We optimise for the ascii case, knowing that all our
512            supported multi-byte character sets are ascii-compatible
513            (ie. they match for the first 128 chars) */
514         while (*s && !(((uint8_t)*s) & 0x80)) {
515                 *s = tolower((uint8_t)*s);
516                 s++;
517         }
518
519         if (!*s)
520                 return;
521
522         iconv_convenience = get_iconv_convenience();
523
524         d = s;
525
526         while (*s) {
527                 size_t c_size, c_size2;
528                 codepoint_t c = next_codepoint(iconv_convenience, s, &c_size);
529                 c_size2 = push_codepoint(iconv_convenience, d, tolower_m(c));
530                 if (c_size2 > c_size) {
531                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
532                                  c, tolower_m(c), (int)c_size, (int)c_size2));
533                         smb_panic("codepoint expansion in strlower_m\n");
534                 }
535                 s += c_size;
536                 d += c_size2;
537         }
538         *d = 0;
539 }
540
541 /**
542  Convert a string to UPPER case.
543 **/
544 _PUBLIC_ void strupper_m(char *s)
545 {
546         char *d;
547         struct smb_iconv_convenience *iconv_convenience;
548
549         /* this is quite a common operation, so we want it to be
550            fast. We optimise for the ascii case, knowing that all our
551            supported multi-byte character sets are ascii-compatible
552            (ie. they match for the first 128 chars) */
553         while (*s && !(((uint8_t)*s) & 0x80)) {
554                 *s = toupper((uint8_t)*s);
555                 s++;
556         }
557
558         if (!*s)
559                 return;
560
561         iconv_convenience = get_iconv_convenience();
562
563         d = s;
564
565         while (*s) {
566                 size_t c_size, c_size2;
567                 codepoint_t c = next_codepoint(iconv_convenience, s, &c_size);
568                 c_size2 = push_codepoint(iconv_convenience, d, toupper_m(c));
569                 if (c_size2 > c_size) {
570                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
571                                  c, toupper_m(c), (int)c_size, (int)c_size2));
572                         smb_panic("codepoint expansion in strupper_m\n");
573                 }
574                 s += c_size;
575                 d += c_size2;
576         }
577         *d = 0;
578 }
579
580
581 /**
582  Find the number of 'c' chars in a string
583 **/
584 _PUBLIC_ size_t count_chars_m(const char *s, char c)
585 {
586         size_t count = 0;
587
588         while (*s) {
589                 size_t size;
590                 codepoint_t c2 = next_codepoint(get_iconv_convenience(), s, &size);
591                 if (c2 == c) count++;
592                 s += size;
593         }
594
595         return count;
596 }
597
598
599 /**
600  * Copy a string from a char* unix src to a dos codepage string destination.
601  *
602  * @return the number of bytes occupied by the string in the destination.
603  *
604  * @param flags can include
605  * <dl>
606  * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
607  * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
608  * </dl>
609  *
610  * @param dest_len the maximum length in bytes allowed in the
611  * destination.  If @p dest_len is -1 then no maximum is used.
612  **/
613 static ssize_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
614 {
615         size_t src_len;
616         ssize_t ret;
617         struct smb_iconv_convenience *ic = get_iconv_convenience();
618
619         if (flags & STR_UPPER) {
620                 char *tmpbuf = strupper_talloc(NULL, src);
621                 if (tmpbuf == NULL) {
622                         return -1;
623                 }
624                 ret = push_ascii(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
625                 talloc_free(tmpbuf);
626                 return ret;
627         }
628
629         src_len = strlen(src);
630
631         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
632                 src_len++;
633
634         return convert_string(ic, CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
635 }
636
637 /**
638  * Copy a string from a unix char* src to an ASCII destination,
639  * allocating a buffer using talloc().
640  *
641  * @param dest always set at least to NULL 
642  *
643  * @returns The number of bytes occupied by the string in the destination
644  *         or -1 in case of error.
645  **/
646 _PUBLIC_ ssize_t push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
647 {
648         struct smb_iconv_convenience *ic = get_iconv_convenience();
649         size_t src_len = strlen(src)+1;
650         *dest = NULL;
651         return convert_string_talloc(ctx, ic, CH_UNIX, CH_DOS, src, src_len, (void **)dest);
652 }
653
654
655 /**
656  * Copy a string from a dos codepage source to a unix char* destination.
657  *
658  * The resulting string in "dest" is always null terminated.
659  *
660  * @param flags can have:
661  * <dl>
662  * <dt>STR_TERMINATE</dt>
663  * <dd>STR_TERMINATE means the string in @p src
664  * is null terminated, and src_len is ignored.</dd>
665  * </dl>
666  *
667  * @param src_len is the length of the source area in bytes.
668  * @returns the number of bytes occupied by the string in @p src.
669  **/
670 static ssize_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
671 {
672         struct smb_iconv_convenience *ic = get_iconv_convenience();
673         size_t ret;
674
675         if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
676                 if (src_len == (size_t)-1) {
677                         src_len = strlen((const char *)src) + 1;
678                 } else {
679                         size_t len = strnlen((const char *)src, src_len);
680                         if (len < src_len)
681                                 len++;
682                         src_len = len;
683                 }
684         }
685
686         ret = convert_string(ic, CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
687
688         if (dest_len)
689                 dest[MIN(ret, dest_len-1)] = 0;
690
691         return src_len;
692 }
693
694 /**
695  * Copy a string from a char* src to a unicode destination.
696  *
697  * @returns the number of bytes occupied by the string in the destination.
698  *
699  * @param flags can have:
700  *
701  * <dl>
702  * <dt>STR_TERMINATE <dd>means include the null termination.
703  * <dt>STR_UPPER     <dd>means uppercase in the destination.
704  * <dt>STR_NOALIGN   <dd>means don't do alignment.
705  * </dl>
706  *
707  * @param dest_len is the maximum length allowed in the
708  * destination. If dest_len is -1 then no maxiumum is used.
709  **/
710 static ssize_t push_ucs2(void *dest, const char *src, size_t dest_len, int flags)
711 {
712         struct smb_iconv_convenience *ic = get_iconv_convenience();
713         size_t len=0;
714         size_t src_len = strlen(src);
715         size_t ret;
716
717         if (flags & STR_UPPER) {
718                 char *tmpbuf = strupper_talloc(NULL, src);
719                 if (tmpbuf == NULL) {
720                         return -1;
721                 }
722                 ret = push_ucs2(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
723                 talloc_free(tmpbuf);
724                 return ret;
725         }
726
727         if (flags & STR_TERMINATE)
728                 src_len++;
729
730         if (ucs2_align(NULL, dest, flags)) {
731                 *(char *)dest = 0;
732                 dest = (void *)((char *)dest + 1);
733                 if (dest_len) dest_len--;
734                 len++;
735         }
736
737         /* ucs2 is always a multiple of 2 bytes */
738         dest_len &= ~1;
739
740         ret = convert_string(ic, CH_UNIX, CH_UTF16, src, src_len, dest, dest_len);
741         if (ret == (size_t)-1) {
742                 return 0;
743         }
744
745         len += ret;
746
747         return len;
748 }
749
750
751 /**
752  * Copy a string from a unix char* src to a UCS2 destination,
753  * allocating a buffer using talloc().
754  *
755  * @param dest always set at least to NULL 
756  *
757  * @returns The number of bytes occupied by the string in the destination
758  *         or -1 in case of error.
759  **/
760 _PUBLIC_ ssize_t push_ucs2_talloc(TALLOC_CTX *ctx, void **dest, const char *src)
761 {
762         struct smb_iconv_convenience *ic = get_iconv_convenience();
763         size_t src_len = strlen(src)+1;
764         *dest = NULL;
765         return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF16, src, src_len, dest);
766 }
767
768
769 /**
770  * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
771  *
772  * @param dest always set at least to NULL 
773  *
774  * @returns The number of bytes occupied by the string in the destination
775  **/
776
777 _PUBLIC_ ssize_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
778 {
779         struct smb_iconv_convenience *ic = get_iconv_convenience();
780         size_t src_len = strlen(src)+1;
781         *dest = NULL;
782         return convert_string_talloc(ctx, ic, CH_UNIX, CH_UTF8, src, src_len, (void **)dest);
783 }
784
785 /**
786  Copy a string from a ucs2 source to a unix char* destination.
787  Flags can have:
788   STR_TERMINATE means the string in src is null terminated.
789   STR_NOALIGN   means don't try to align.
790  if STR_TERMINATE is set then src_len is ignored if it is -1.
791  src_len is the length of the source area in bytes
792  Return the number of bytes occupied by the string in src.
793  The resulting string in "dest" is always null terminated.
794 **/
795
796 static size_t pull_ucs2(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
797 {
798         struct smb_iconv_convenience *ic = get_iconv_convenience();
799         size_t ret;
800
801         if (ucs2_align(NULL, src, flags)) {
802                 src = (const void *)((const char *)src + 1);
803                 if (src_len > 0)
804                         src_len--;
805         }
806
807         if (flags & STR_TERMINATE) {
808                 if (src_len == (size_t)-1) {
809                         src_len = utf16_len(src);
810                 } else {
811                         src_len = utf16_len_n(src, src_len);
812                 }
813         }
814
815         /* ucs2 is always a multiple of 2 bytes */
816         if (src_len != (size_t)-1)
817                 src_len &= ~1;
818         
819         ret = convert_string(ic, CH_UTF16, CH_UNIX, src, src_len, dest, dest_len);
820         if (dest_len)
821                 dest[MIN(ret, dest_len-1)] = 0;
822
823         return src_len;
824 }
825
826 /**
827  * Copy a string from a ASCII src to a unix char * destination, allocating a buffer using talloc
828  *
829  * @param dest always set at least to NULL 
830  *
831  * @returns The number of bytes occupied by the string in the destination
832  **/
833
834 _PUBLIC_ ssize_t pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
835 {
836         struct smb_iconv_convenience *ic = get_iconv_convenience();
837         size_t src_len = strlen(src)+1;
838         *dest = NULL;
839         return convert_string_talloc(ctx, ic, CH_DOS, CH_UNIX, src, src_len, (void **)dest);
840 }
841
842 /**
843  * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
844  *
845  * @param dest always set at least to NULL 
846  *
847  * @returns The number of bytes occupied by the string in the destination
848  **/
849
850 _PUBLIC_ ssize_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const void *src)
851 {
852         struct smb_iconv_convenience *ic = get_iconv_convenience();
853         size_t src_len = utf16_len(src);
854         *dest = NULL;
855         return convert_string_talloc(ctx, ic, CH_UTF16, CH_UNIX, src, src_len, (void **)dest);
856 }
857
858 /**
859  * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
860  *
861  * @param dest always set at least to NULL 
862  *
863  * @returns The number of bytes occupied by the string in the destination
864  **/
865
866 _PUBLIC_ ssize_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
867 {
868         struct smb_iconv_convenience *ic = get_iconv_convenience();
869         size_t src_len = strlen(src)+1;
870         *dest = NULL;
871         return convert_string_talloc(ctx, ic, CH_UTF8, CH_UNIX, src, src_len, (void **)dest);
872 }
873
874 /**
875  Copy a string from a char* src to a unicode or ascii
876  dos codepage destination choosing unicode or ascii based on the 
877  flags in the SMB buffer starting at base_ptr.
878  Return the number of bytes occupied by the string in the destination.
879  flags can have:
880   STR_TERMINATE means include the null termination.
881   STR_UPPER     means uppercase in the destination.
882   STR_ASCII     use ascii even with unicode packet.
883   STR_NOALIGN   means don't do alignment.
884  dest_len is the maximum length allowed in the destination. If dest_len
885  is -1 then no maxiumum is used.
886 **/
887
888 _PUBLIC_ ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags)
889 {
890         if (flags & STR_ASCII) {
891                 return push_ascii(dest, src, dest_len, flags);
892         } else if (flags & STR_UNICODE) {
893                 return push_ucs2(dest, src, dest_len, flags);
894         } else {
895                 smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
896                 return -1;
897         }
898 }
899
900
901 /**
902  Copy a string from a unicode or ascii source (depending on
903  the packet flags) to a char* destination.
904  Flags can have:
905   STR_TERMINATE means the string in src is null terminated.
906   STR_UNICODE   means to force as unicode.
907   STR_ASCII     use ascii even with unicode packet.
908   STR_NOALIGN   means don't do alignment.
909  if STR_TERMINATE is set then src_len is ignored is it is -1
910  src_len is the length of the source area in bytes.
911  Return the number of bytes occupied by the string in src.
912  The resulting string in "dest" is always null terminated.
913 **/
914
915 _PUBLIC_ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
916 {
917         if (flags & STR_ASCII) {
918                 return pull_ascii(dest, src, dest_len, src_len, flags);
919         } else if (flags & STR_UNICODE) {
920                 return pull_ucs2(dest, src, dest_len, src_len, flags);
921         } else {
922                 smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
923                 return -1;
924         }
925 }
926
927