Merge in the developer string options from HEAD. We need to ensure 3.0
[kai/samba.git] / source3 / lib / charcnv.c
1 /* 
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    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22 */
23 #include "includes.h"
24
25 /**
26  * @file
27  *
28  * @brief Character-set conversion routines built on our iconv.
29  * 
30  * @note Samba's internal character set (at least in the 3.0 series)
31  * is always the same as the one for the Unix filesystem.  It is
32  * <b>not</b> necessarily UTF-8 and may be different on machines that
33  * need i18n filenames to be compatible with Unix software.  It does
34  * have to be a superset of ASCII.  All multibyte sequences must start
35  * with a byte with the high bit set.
36  *
37  * @sa lib/iconv.c
38  */
39
40 static pstring cvtbuf;
41
42 static smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
43
44
45 /**
46  * Return the name of a charset to give to iconv().
47  **/
48 static const char *charset_name(charset_t ch)
49 {
50         const char *ret = NULL;
51
52         if (ch == CH_UCS2) ret = "UCS-2LE";
53         else if (ch == CH_UNIX) ret = lp_unix_charset();
54         else if (ch == CH_DOS) ret = lp_dos_charset();
55         else if (ch == CH_DISPLAY) ret = lp_display_charset();
56         else if (ch == CH_UTF8) ret = "UTF8";
57
58         if (!ret || !*ret) ret = "ASCII";
59         return ret;
60 }
61
62 static void lazy_initialize_conv(void)
63 {
64         static int initialized = False;
65
66         if (!initialized) {
67                 initialized = True;
68                 load_case_tables();
69                 init_iconv();
70                 init_valid_table();
71         }
72 }
73
74 /**
75  Initialize iconv conversion descriptors.
76 **/
77
78 void init_iconv(void)
79 {
80         int c1, c2;
81         BOOL did_reload = False;
82
83         /* so that charset_name() works we need to get the UNIX<->UCS2 going
84            first */
85         if (!conv_handles[CH_UNIX][CH_UCS2])
86                 conv_handles[CH_UNIX][CH_UCS2] = smb_iconv_open("UCS-2LE", "ASCII");
87
88         if (!conv_handles[CH_UCS2][CH_UNIX])
89                 conv_handles[CH_UCS2][CH_UNIX] = smb_iconv_open("ASCII", "UCS-2LE");
90
91         for (c1=0;c1<NUM_CHARSETS;c1++) {
92                 for (c2=0;c2<NUM_CHARSETS;c2++) {
93                         const char *n1 = charset_name((charset_t)c1);
94                         const char *n2 = charset_name((charset_t)c2);
95                         if (conv_handles[c1][c2] &&
96                             strcmp(n1, conv_handles[c1][c2]->from_name) == 0 &&
97                             strcmp(n2, conv_handles[c1][c2]->to_name) == 0)
98                                 continue;
99
100                         did_reload = True;
101
102                         if (conv_handles[c1][c2])
103                                 smb_iconv_close(conv_handles[c1][c2]);
104
105                         conv_handles[c1][c2] = smb_iconv_open(n2,n1);
106                         if (conv_handles[c1][c2] == (smb_iconv_t)-1) {
107                                 DEBUG(0,("Conversion from %s to %s not supported\n",
108                                          charset_name((charset_t)c1), charset_name((charset_t)c2)));
109                                 conv_handles[c1][c2] = NULL;
110                         }
111                 }
112         }
113
114         if (did_reload) {
115                 init_valid_table();
116         }
117 }
118
119 /**
120  * Convert string from one encoding to another, making error checking etc
121  *
122  * @param src pointer to source string (multibyte or singlebyte)
123  * @param srclen length of the source string in bytes
124  * @param dest pointer to destination string (multibyte or singlebyte)
125  * @param destlen maximal length allowed for string
126  * @returns the number of bytes occupied in the destination
127  **/
128 size_t convert_string(charset_t from, charset_t to,
129                       void const *src, size_t srclen, 
130                       void *dest, size_t destlen)
131 {
132         size_t i_len, o_len;
133         size_t retval;
134         const char* inbuf = (const char*)src;
135         char* outbuf = (char*)dest;
136         smb_iconv_t descriptor;
137
138         if (srclen == (size_t)-1)
139                 srclen = strlen(src)+1;
140
141         lazy_initialize_conv();
142
143         descriptor = conv_handles[from][to];
144
145         if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
146                 /* conversion not supported, use as is */
147                 size_t len = MIN(srclen,destlen);
148                 memcpy(dest,src,len);
149                 return len;
150         }
151
152         i_len=srclen;
153         o_len=destlen;
154         retval = smb_iconv(descriptor,  &inbuf, &i_len, &outbuf, &o_len);
155         if(retval==(size_t)-1) {
156                 const char *reason="unknown error";
157                 switch(errno) {
158                         case EINVAL:
159                                 reason="Incomplete multibyte sequence";
160                                 break;
161                         case E2BIG:
162                                 reason="No more room"; 
163                                 DEBUG(0, ("convert_string: Required %d, available %d\n",
164                                         srclen, destlen));
165                                 /* we are not sure we need srclen bytes,
166                                   may be more, may be less.
167                                   We only know we need more than destlen
168                                   bytes ---simo */
169                                break;
170                         case EILSEQ:
171                                reason="Illegal multibyte sequence";
172                                break;
173                 }
174                 /* smb_panic(reason); */
175         }
176         return destlen-o_len;
177 }
178
179 /**
180  * Convert between character sets, allocating a new buffer for the result.
181  *
182  * @param srclen length of source buffer.
183  * @param dest always set at least to NULL
184  * @note -1 is not accepted for srclen.
185  *
186  * @returns Size in bytes of the converted string; or -1 in case of error.
187  **/
188
189 static size_t convert_string_allocate(charset_t from, charset_t to,
190                                 void const *src, size_t srclen, void **dest)
191 {
192         size_t i_len, o_len, destlen;
193         size_t retval;
194         const char *inbuf = (const char *)src;
195         char *outbuf, *ob;
196         smb_iconv_t descriptor;
197
198         *dest = NULL;
199
200         if (src == NULL || srclen == (size_t)-1)
201                 return (size_t)-1;
202
203         lazy_initialize_conv();
204
205         descriptor = conv_handles[from][to];
206
207         if (descriptor == (smb_iconv_t)-1 || descriptor == (smb_iconv_t)0) {
208                 /* conversion not supported, return -1*/
209                 DEBUG(3, ("convert_string_allocate: conversion not supported!\n"));
210                 return -1;
211         }
212
213         destlen = MAX(srclen, 512);
214         outbuf = NULL;
215 convert:
216         destlen = destlen * 2;
217         ob = (char *)realloc(outbuf, destlen);
218         if (!ob) {
219                 DEBUG(0, ("convert_string_allocate: realloc failed!\n"));
220                 SAFE_FREE(outbuf);
221                 return (size_t)-1;
222         }
223         else
224                 outbuf = ob;
225         i_len = srclen;
226         o_len = destlen;
227         retval = smb_iconv(descriptor,
228                            &inbuf, &i_len,
229                            &outbuf, &o_len);
230         if(retval == (size_t)-1)                {
231                 const char *reason="unknown error";
232                 switch(errno) {
233                         case EINVAL:
234                                 reason="Incomplete multibyte sequence";
235                                 break;
236                         case E2BIG:
237                                 goto convert;           
238                         case EILSEQ:
239                                 reason="Illegal multibyte sequence";
240                                 break;
241                 }
242                 DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
243                 /* smb_panic(reason); */
244                 return (size_t)-1;
245         }
246         
247         destlen = destlen - o_len;
248         *dest = (char *)Realloc(ob,destlen);
249         if (!*dest) {
250                 DEBUG(0, ("convert_string_allocate: out of memory!\n"));
251                 SAFE_FREE(ob);
252                 return (size_t)-1;
253         }
254
255         return destlen;
256 }
257
258
259 /**
260  * Convert between character sets, allocating a new buffer using talloc for the result.
261  *
262  * @param srclen length of source buffer.
263  * @param dest always set at least to NULL 
264  * @note -1 is not accepted for srclen.
265  *
266  * @returns Size in bytes of the converted string; or -1 in case of error.
267  **/
268 static size_t convert_string_talloc(TALLOC_CTX *ctx, charset_t from, charset_t to,
269                                 void const *src, size_t srclen, void **dest)
270 {
271         void *alloced_string;
272         size_t dest_len;
273
274         *dest = NULL;
275         dest_len=convert_string_allocate(from, to, src, srclen, &alloced_string);
276         if (dest_len == (size_t)-1)
277                 return (size_t)-1;
278         *dest = talloc_memdup(ctx, alloced_string, dest_len);
279         SAFE_FREE(alloced_string);
280         if (*dest == NULL)
281                 return (size_t)-1;
282         return dest_len;
283 }
284
285 size_t unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
286 {
287         size_t size;
288         smb_ucs2_t *buffer=(smb_ucs2_t*)cvtbuf;
289         size=convert_string(CH_UNIX, CH_UCS2, src, srclen, buffer, sizeof(cvtbuf));
290         if (!strupper_w(buffer) && (dest == src))
291                 return srclen;
292         return convert_string(CH_UCS2, CH_UNIX, buffer, size, dest, destlen);
293 }
294
295 size_t unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
296 {
297         size_t size;
298         smb_ucs2_t *buffer=(smb_ucs2_t*)cvtbuf;
299         size=convert_string(CH_UNIX, CH_UCS2, src, srclen, buffer, sizeof(cvtbuf));
300         if (!strlower_w(buffer) && (dest == src))
301                 return srclen;
302         return convert_string(CH_UCS2, CH_UNIX, buffer, size, dest, destlen);
303 }
304
305
306 static size_t ucs2_align(const void *base_ptr, const void *p, int flags)
307 {
308         if (flags & (STR_NOALIGN|STR_ASCII))
309                 return 0;
310         return PTR_DIFF(p, base_ptr) & 1;
311 }
312
313
314 /**
315  * Copy a string from a char* unix src to a dos codepage string destination.
316  *
317  * @return the number of bytes occupied by the string in the destination.
318  *
319  * @param flags can include
320  * <dl>
321  * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
322  * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
323  * </dl>
324  *
325  * @param dest_len the maximum length in bytes allowed in the
326  * destination.  If @p dest_len is -1 then no maximum is used.
327  **/
328 size_t push_ascii(void *dest, const char *src, size_t dest_len, int flags)
329 {
330         size_t src_len = strlen(src);
331         pstring tmpbuf;
332
333         /* treat a pstring as "unlimited" length */
334         if (dest_len == (size_t)-1)
335                 dest_len = sizeof(pstring);
336
337         if (flags & STR_UPPER) {
338                 pstrcpy(tmpbuf, src);
339                 strupper(tmpbuf);
340                 src = tmpbuf;
341         }
342
343         if (flags & STR_TERMINATE)
344                 src_len++;
345
346         return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len);
347 }
348
349 size_t push_ascii_fstring(void *dest, const char *src)
350 {
351         return push_ascii(dest, src, sizeof(fstring), STR_TERMINATE);
352 }
353
354 size_t push_ascii_pstring(void *dest, const char *src)
355 {
356         return push_ascii(dest, src, sizeof(pstring), STR_TERMINATE);
357 }
358
359 /**
360  * Copy a string from a dos codepage source to a unix char* destination.
361  *
362  * The resulting string in "dest" is always null terminated.
363  *
364  * @param flags can have:
365  * <dl>
366  * <dt>STR_TERMINATE</dt>
367  * <dd>STR_TERMINATE means the string in @p src
368  * is null terminated, and src_len is ignored.</dd>
369  * </dl>
370  *
371  * @param src_len is the length of the source area in bytes.
372  * @returns the number of bytes occupied by the string in @p src.
373  **/
374 size_t pull_ascii(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
375 {
376         size_t ret;
377
378         if (dest_len == (size_t)-1)
379                 dest_len = sizeof(pstring);
380
381         if (flags & STR_TERMINATE) {
382                 if (src_len == (size_t)-1) {
383                         src_len = strlen(src) + 1;
384                 } else {
385                         size_t len = strnlen(src, src_len);
386                         if (len < src_len)
387                                 len++;
388                         src_len = len;
389                 }
390         }
391
392         ret = convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len);
393
394         if (dest_len)
395                 dest[MIN(ret, dest_len-1)] = 0;
396
397         return src_len;
398 }
399
400 size_t pull_ascii_pstring(char *dest, const void *src)
401 {
402         return pull_ascii(dest, src, sizeof(pstring), -1, STR_TERMINATE);
403 }
404
405 size_t pull_ascii_fstring(char *dest, const void *src)
406 {
407         return pull_ascii(dest, src, sizeof(fstring), -1, STR_TERMINATE);
408 }
409
410 /**
411  * Copy a string from a char* src to a unicode destination.
412  *
413  * @returns the number of bytes occupied by the string in the destination.
414  *
415  * @param flags can have:
416  *
417  * <dl>
418  * <dt>STR_TERMINATE <dd>means include the null termination.
419  * <dt>STR_UPPER     <dd>means uppercase in the destination.
420  * <dt>STR_NOALIGN   <dd>means don't do alignment.
421  * </dl>
422  *
423  * @param dest_len is the maximum length allowed in the
424  * destination. If dest_len is -1 then no maxiumum is used.
425  **/
426 size_t push_ucs2(const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
427 {
428         size_t len=0;
429         size_t src_len = strlen(src);
430         pstring tmpbuf;
431
432         /* treat a pstring as "unlimited" length */
433         if (dest_len == (size_t)-1)
434                 dest_len = sizeof(pstring);
435
436         if (flags & STR_UPPER) {
437                 pstrcpy(tmpbuf, src);
438                 strupper(tmpbuf);
439                 src = tmpbuf;
440         }
441
442         if (flags & STR_TERMINATE)
443                 src_len++;
444
445         if (ucs2_align(base_ptr, dest, flags)) {
446                 *(char *)dest = 0;
447                 dest = (void *)((char *)dest + 1);
448                 if (dest_len) dest_len--;
449                 len++;
450         }
451
452         /* ucs2 is always a multiple of 2 bytes */
453         dest_len &= ~1;
454
455         len += convert_string(CH_UNIX, CH_UCS2, src, src_len, dest, dest_len);
456         return len;
457 }
458
459
460 /**
461  * Copy a string from a unix char* src to a UCS2 destination,
462  * allocating a buffer using talloc().
463  *
464  * @param dest always set at least to NULL 
465  *
466  * @returns The number of bytes occupied by the string in the destination
467  *         or -1 in case of error.
468  **/
469 size_t push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
470 {
471         size_t src_len = strlen(src)+1;
472
473         *dest = NULL;
474         return convert_string_talloc(ctx, CH_UNIX, CH_UCS2, src, src_len, (void **)dest);
475 }
476
477
478 /**
479  * Copy a string from a unix char* src to a UCS2 destination, allocating a buffer
480  *
481  * @param dest always set at least to NULL 
482  *
483  * @returns The number of bytes occupied by the string in the destination
484  *         or -1 in case of error.
485  **/
486
487 size_t push_ucs2_allocate(smb_ucs2_t **dest, const char *src)
488 {
489         size_t src_len = strlen(src)+1;
490
491         *dest = NULL;
492         return convert_string_allocate(CH_UNIX, CH_UCS2, src, src_len, (void **)dest);  
493 }
494
495 /**
496  Copy a string from a char* src to a UTF-8 destination.
497  Return the number of bytes occupied by the string in the destination
498  Flags can have:
499   STR_TERMINATE means include the null termination
500   STR_UPPER     means uppercase in the destination
501  dest_len is the maximum length allowed in the destination. If dest_len
502  is -1 then no maxiumum is used.
503 **/
504
505 static size_t push_utf8(void *dest, const char *src, size_t dest_len, int flags)
506 {
507         size_t src_len = strlen(src);
508         pstring tmpbuf;
509
510         /* treat a pstring as "unlimited" length */
511         if (dest_len == (size_t)-1)
512                 dest_len = sizeof(pstring);
513
514         if (flags & STR_UPPER) {
515                 pstrcpy(tmpbuf, src);
516                 strupper(tmpbuf);
517                 src = tmpbuf;
518         }
519
520         if (flags & STR_TERMINATE)
521                 src_len++;
522
523         return convert_string(CH_UNIX, CH_UTF8, src, src_len, dest, dest_len);
524 }
525
526 size_t push_utf8_fstring(void *dest, const char *src)
527 {
528         return push_utf8(dest, src, sizeof(fstring), STR_TERMINATE);
529 }
530
531 /**
532  * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer using talloc
533  *
534  * @param dest always set at least to NULL 
535  *
536  * @returns The number of bytes occupied by the string in the destination
537  **/
538
539 size_t push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
540 {
541         size_t src_len = strlen(src)+1;
542
543         *dest = NULL;
544         return convert_string_talloc(ctx, CH_UNIX, CH_UTF8, src, src_len, (void**)dest);
545 }
546
547 /**
548  * Copy a string from a unix char* src to a UTF-8 destination, allocating a buffer
549  *
550  * @param dest always set at least to NULL 
551  *
552  * @returns The number of bytes occupied by the string in the destination
553  **/
554
555 size_t push_utf8_allocate(char **dest, const char *src)
556 {
557         size_t src_len = strlen(src)+1;
558
559         *dest = NULL;
560         return convert_string_allocate(CH_UNIX, CH_UTF8, src, src_len, (void **)dest);  
561 }
562
563 /**
564  Copy a string from a ucs2 source to a unix char* destination.
565  Flags can have:
566   STR_TERMINATE means the string in src is null terminated.
567   STR_NOALIGN   means don't try to align.
568  if STR_TERMINATE is set then src_len is ignored if it is -1.
569  src_len is the length of the source area in bytes
570  Return the number of bytes occupied by the string in src.
571  The resulting string in "dest" is always null terminated.
572 **/
573
574 size_t pull_ucs2(const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
575 {
576         size_t ret;
577
578         if (dest_len == (size_t)-1)
579                 dest_len = sizeof(pstring);
580
581         if (ucs2_align(base_ptr, src, flags)) {
582                 src = (const void *)((const char *)src + 1);
583                 if (src_len > 0)
584                         src_len--;
585         }
586
587         if (flags & STR_TERMINATE) {
588                 if (src_len == (size_t)-1) {
589                         src_len = strlen_w(src)*2 + 2;
590                 } else {
591                         size_t len = strnlen_w(src, src_len/2);
592                         if (len < src_len/2)
593                                 len++;
594                         src_len = len*2;
595                 }
596         }
597
598         /* ucs2 is always a multiple of 2 bytes */
599         if (src_len != (size_t)-1)
600                 src_len &= ~1;
601         
602         ret = convert_string(CH_UCS2, CH_UNIX, src, src_len, dest, dest_len);
603         if (dest_len)
604                 dest[MIN(ret, dest_len-1)] = 0;
605
606         return src_len;
607 }
608
609 size_t pull_ucs2_pstring(char *dest, const void *src)
610 {
611         return pull_ucs2(NULL, dest, src, sizeof(pstring), -1, STR_TERMINATE);
612 }
613
614 size_t pull_ucs2_fstring(char *dest, const void *src)
615 {
616         return pull_ucs2(NULL, dest, src, sizeof(fstring), -1, STR_TERMINATE);
617 }
618
619 /**
620  * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer using talloc
621  *
622  * @param dest always set at least to NULL 
623  *
624  * @returns The number of bytes occupied by the string in the destination
625  **/
626
627 size_t pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src)
628 {
629         size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
630         *dest = NULL;
631         return convert_string_talloc(ctx, CH_UCS2, CH_UNIX, src, src_len, (void **)dest);
632 }
633
634 /**
635  * Copy a string from a UCS2 src to a unix char * destination, allocating a buffer
636  *
637  * @param dest always set at least to NULL 
638  *
639  * @returns The number of bytes occupied by the string in the destination
640  **/
641
642 size_t pull_ucs2_allocate(void **dest, const smb_ucs2_t *src)
643 {
644         size_t src_len = (strlen_w(src)+1) * sizeof(smb_ucs2_t);
645         *dest = NULL;
646         return convert_string_allocate(CH_UCS2, CH_UNIX, src, src_len, dest);   
647 }
648
649 /**
650  * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer using talloc
651  *
652  * @param dest always set at least to NULL 
653  *
654  * @returns The number of bytes occupied by the string in the destination
655  **/
656
657 size_t pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src)
658 {
659         size_t src_len = strlen(src)+1;
660         *dest = NULL;
661         return convert_string_talloc(ctx, CH_UTF8, CH_UNIX, src, src_len, (void **)dest);       
662 }
663
664 /**
665  * Copy a string from a UTF-8 src to a unix char * destination, allocating a buffer
666  *
667  * @param dest always set at least to NULL 
668  *
669  * @returns The number of bytes occupied by the string in the destination
670  **/
671
672 size_t pull_utf8_allocate(void **dest, const char *src)
673 {
674         size_t src_len = strlen(src)+1;
675         *dest = NULL;
676         return convert_string_allocate(CH_UTF8, CH_UNIX, src, src_len, dest);   
677 }
678  
679 /**
680  Copy a string from a char* src to a unicode or ascii
681  dos codepage destination choosing unicode or ascii based on the 
682  flags in the SMB buffer starting at base_ptr.
683  Return the number of bytes occupied by the string in the destination.
684  flags can have:
685   STR_TERMINATE means include the null termination.
686   STR_UPPER     means uppercase in the destination.
687   STR_ASCII     use ascii even with unicode packet.
688   STR_NOALIGN   means don't do alignment.
689  dest_len is the maximum length allowed in the destination. If dest_len
690  is -1 then no maxiumum is used.
691 **/
692
693 size_t push_string_fn(const char *function, unsigned int line, const void *base_ptr, void *dest, const char *src, size_t dest_len, int flags)
694 {
695         if (dest_len != (size_t)-1)
696                 clobber_region(function, line, dest, dest_len);
697
698         if (!(flags & STR_ASCII) && \
699             ((flags & STR_UNICODE || \
700               (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
701                 return push_ucs2(base_ptr, dest, src, dest_len, flags);
702         }
703         return push_ascii(dest, src, dest_len, flags);
704 }
705
706
707 /**
708  Copy a string from a unicode or ascii source (depending on
709  the packet flags) to a char* destination.
710  Flags can have:
711   STR_TERMINATE means the string in src is null terminated.
712   STR_UNICODE   means to force as unicode.
713   STR_ASCII     use ascii even with unicode packet.
714   STR_NOALIGN   means don't do alignment.
715  if STR_TERMINATE is set then src_len is ignored is it is -1
716  src_len is the length of the source area in bytes.
717  Return the number of bytes occupied by the string in src.
718  The resulting string in "dest" is always null terminated.
719 **/
720
721 size_t pull_string_fn(const char *function, unsigned int line, const void *base_ptr, char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
722 {
723         if (dest_len != (size_t)-1)
724                 clobber_region(function, line, dest, dest_len);
725
726         if (!(flags & STR_ASCII) && \
727             ((flags & STR_UNICODE || \
728               (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
729                 return pull_ucs2(base_ptr, dest, src, dest_len, src_len, flags);
730         }
731         return pull_ascii(dest, src, dest_len, src_len, flags);
732 }
733
734 size_t align_string(const void *base_ptr, const char *p, int flags)
735 {
736         if (!(flags & STR_ASCII) && \
737             ((flags & STR_UNICODE || \
738               (SVAL(base_ptr, smb_flg2) & FLAGS2_UNICODE_STRINGS)))) {
739                 return ucs2_align(base_ptr, p, flags);
740         }
741         return 0;
742 }
743
744 /**
745  Convert from unix to ucs2 charset and return the
746  allocated and converted string or NULL if an error occurred.
747  You must provide a zero terminated string.
748  The returning string will be zero terminated.
749 **/
750
751 smb_ucs2_t *acnv_uxu2(const char *src)
752 {
753         size_t slen;
754         size_t dlen;
755         void *dest;
756         
757         slen = strlen(src) + 1;
758         dlen = convert_string_allocate(CH_UNIX, CH_UCS2, src, slen, &dest);
759         if (dlen == (size_t)-1)
760                 return NULL;
761         else
762                 return dest;
763 }
764
765 /**
766  Convert from dos to ucs2 charset and return the
767  allocated and converted string or NULL if an error occurred.
768  You must provide a zero terminated string.
769  The returning string will be zero terminated.
770 **/
771
772 smb_ucs2_t *acnv_dosu2(const char *src)
773 {
774         size_t slen;
775         size_t dlen;
776         void *dest;
777         
778         slen = strlen(src) + 1;
779         dlen = convert_string_allocate(CH_DOS, CH_UCS2, src, slen, &dest);
780         if (dlen == (size_t)-1)
781                 return NULL;
782         else
783                 return dest;
784 }