r6149: Fixes bugs #2498 and 2484.
[samba.git] / source / lib / 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 2 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, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 #ifndef MAXUNI
25 #define MAXUNI 1024
26 #endif
27
28 /* these 3 tables define the unicode case handling.  They are loaded
29    at startup either via mmap() or read() from the lib directory */
30 static smb_ucs2_t *upcase_table;
31 static smb_ucs2_t *lowcase_table;
32 static uint8 *valid_table;
33
34 /**
35  * This table says which Unicode characters are valid dos
36  * characters.
37  *
38  * Each value is just a single bit.
39  **/
40 static uint8 doschar_table[8192]; /* 65536 characters / 8 bits/byte */
41
42
43 /**
44  * Load or generate the case handling tables.
45  *
46  * The case tables are defined in UCS2 and don't depend on any
47  * configured parameters, so they never need to be reloaded.
48  **/
49 void load_case_tables(void)
50 {
51         static int initialised;
52         int i;
53
54         if (initialised) return;
55         initialised = 1;
56
57         upcase_table = map_file(lib_path("upcase.dat"), 0x20000);
58         lowcase_table = map_file(lib_path("lowcase.dat"), 0x20000);
59
60         /* we would like Samba to limp along even if these tables are
61            not available */
62         if (!upcase_table) {
63                 DEBUG(1,("creating lame upcase table\n"));
64                 upcase_table = SMB_MALLOC(0x20000);
65                 for (i=0;i<0x10000;i++) {
66                         smb_ucs2_t v;
67                         SSVAL(&v, 0, i);
68                         upcase_table[v] = i;
69                 }
70                 for (i=0;i<256;i++) {
71                         smb_ucs2_t v;
72                         SSVAL(&v, 0, UCS2_CHAR(i));
73                         upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
74                 }
75         }
76
77         if (!lowcase_table) {
78                 DEBUG(1,("creating lame lowcase table\n"));
79                 lowcase_table = SMB_MALLOC(0x20000);
80                 for (i=0;i<0x10000;i++) {
81                         smb_ucs2_t v;
82                         SSVAL(&v, 0, i);
83                         lowcase_table[v] = i;
84                 }
85                 for (i=0;i<256;i++) {
86                         smb_ucs2_t v;
87                         SSVAL(&v, 0, UCS2_CHAR(i));
88                         lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
89                 }
90         }
91 }
92
93 /*
94   see if a ucs2 character can be mapped correctly to a dos character
95   and mapped back to the same character in ucs2
96 */
97 int check_dos_char(smb_ucs2_t c)
98 {
99         lazy_initialize_conv();
100         
101         /* Find the right byte, and right bit within the byte; return
102          * 1 or 0 */
103         return (doschar_table[(c & 0xffff) / 8] & (1 << (c & 7))) != 0;
104 }
105
106
107 static int check_dos_char_slowly(smb_ucs2_t c)
108 {
109         char buf[10];
110         smb_ucs2_t c2 = 0;
111         int len1, len2;
112         len1 = convert_string(CH_UCS2, CH_DOS, &c, 2, buf, sizeof(buf),False);
113         if (len1 == 0) return 0;
114         len2 = convert_string(CH_DOS, CH_UCS2, buf, len1, &c2, 2,False);
115         if (len2 != 2) return 0;
116         return (c == c2);
117 }
118
119
120 /**
121  * Fill out doschar table the hard way, by examining each character
122  **/
123 void init_doschar_table(void)
124 {
125         int i, j, byteval;
126
127         /* For each byte of packed table */
128         
129         for (i = 0; i <= 0xffff; i += 8) {
130                 byteval = 0;
131                 for (j = 0; j <= 7; j++) {
132                         smb_ucs2_t c;
133
134                         c = i + j;
135                         
136                         if (check_dos_char_slowly(c))
137                                 byteval |= 1 << j;
138                 }
139                 doschar_table[i/8] = byteval;
140         }
141 }
142
143
144 /**
145  * Load the valid character map table from <tt>valid.dat</tt> or
146  * create from the configured codepage.
147  *
148  * This function is called whenever the configuration is reloaded.
149  * However, the valid character table is not changed if it's loaded
150  * from a file, because we can't unmap files.
151  **/
152 void init_valid_table(void)
153 {
154         static int mapped_file;
155         int i;
156         const char *allowed = ".!#$%&'()_-@^`~";
157         uint8 *valid_file;
158
159         if (mapped_file) {
160                 /* Can't unmap files, so stick with what we have */
161                 return;
162         }
163
164         valid_file = map_file(lib_path("valid.dat"), 0x10000);
165         if (valid_file) {
166                 valid_table = valid_file;
167                 mapped_file = 1;
168                 return;
169         }
170
171         /* Otherwise, we're using a dynamically created valid_table.
172          * It might need to be regenerated if the code page changed.
173          * We know that we're not using a mapped file, so we can
174          * free() the old one. */
175         if (valid_table) free(valid_table);
176
177         DEBUG(2,("creating default valid table\n"));
178         valid_table = SMB_MALLOC(0x10000);
179         for (i=0;i<128;i++)
180                 valid_table[i] = isalnum(i) || strchr(allowed,i);
181         
182         for (;i<0x10000;i++) {
183                 smb_ucs2_t c;
184                 SSVAL(&c, 0, i);
185                 valid_table[i] = check_dos_char(c);
186         }
187 }
188
189
190
191 /*******************************************************************
192  Write a string in (little-endian) unicode format. src is in
193  the current DOS codepage. len is the length in bytes of the
194  string pointed to by dst.
195
196  if null_terminate is True then null terminate the packet (adds 2 bytes)
197
198  the return value is the length in bytes consumed by the string, including the
199  null termination if applied
200 ********************************************************************/
201
202 size_t dos_PutUniCode(char *dst,const char *src, ssize_t len, BOOL null_terminate)
203 {
204         return push_ucs2(NULL, dst, src, len, 
205                          STR_UNICODE|STR_NOALIGN | (null_terminate?STR_TERMINATE:0));
206 }
207
208
209 /*******************************************************************
210  Skip past a unicode string, but not more than len. Always move
211  past a terminating zero if found.
212 ********************************************************************/
213
214 char *skip_unibuf(char *src, size_t len)
215 {
216     char *srcend = src + len;
217
218     while (src < srcend && SVAL(src,0))
219         src += 2;
220
221     if(!SVAL(src,0))
222         src += 2;
223
224     return src;
225 }
226
227 /* Copy a string from little-endian or big-endian unicode source (depending
228  * on flags) to internal samba format destination
229  */ 
230 int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
231 {
232         if (!src) {
233                 dest[0] = 0;
234                 return 0;
235         }
236         if(dest_len==-1) dest_len=MAXUNI-3;
237         return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
238 }
239
240 /* Copy a string from a unistr2 source to internal samba format
241    destination.  Use this instead of direct calls to rpcstr_pull() to avoid
242    having to determine whether the source string is null terminated. */
243
244 int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
245 {
246         return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring),
247                          src->uni_str_len * 2, 0);
248 }
249
250 /* Converts a string from internal samba format to unicode
251  */ 
252 int rpcstr_push(void* dest, const char *src, int dest_len, int flags)
253 {
254         return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
255 }
256
257 /*******************************************************************
258  Return a DOS codepage version of a little-endian unicode string.
259  len is the filename length (ignoring any terminating zero) in uin16
260  units. Always null terminates.
261  Hack alert: uses fixed buffer(s).
262 ********************************************************************/
263 char *dos_unistrn2(const uint16 *src, int len)
264 {
265         static char lbufs[8][MAXUNI];
266         static int nexti;
267         char *lbuf = lbufs[nexti];
268         nexti = (nexti+1)%8;
269         pull_ucs2(NULL, lbuf, src, MAXUNI-3, len*2, STR_NOALIGN);
270         return lbuf;
271 }
272
273 /*******************************************************************
274  Convert a (little-endian) UNISTR2 structure to an ASCII string
275 ********************************************************************/
276 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
277 {
278         if (str == NULL) {
279                 *dest='\0';
280                 return;
281         }
282         pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
283 }
284
285 /*******************************************************************
286  Convert a (little-endian) UNISTR3 structure to an ASCII string
287 ********************************************************************/
288 void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
289 {
290         if (str == NULL) {
291                 *dest='\0';
292                 return;
293         }
294         pull_ucs2(NULL, dest, str->str.buffer, maxlen, str->uni_str_len*2,
295                   STR_NOALIGN);
296 }
297         
298 /*******************************************************************
299 give a static string for displaying a UNISTR2
300 ********************************************************************/
301 const char *unistr2_static(const UNISTR2 *str)
302 {
303         static pstring ret;
304         unistr2_to_ascii(ret, str, sizeof(ret));
305         return ret;
306 }
307
308
309 /*******************************************************************
310  duplicate a UNISTR2 string into a null terminated char*
311  using a talloc context
312 ********************************************************************/
313 char *unistr2_tdup(TALLOC_CTX *ctx, const UNISTR2 *str)
314 {
315         char *s;
316         int maxlen = (str->uni_str_len+1)*4;
317         if (!str->buffer) return NULL;
318         s = (char *)TALLOC(ctx, maxlen); /* convervative */
319         if (!s) return NULL;
320         pull_ucs2(NULL, s, str->buffer, maxlen, str->uni_str_len*2, 
321                   STR_NOALIGN);
322         return s;
323 }
324
325
326 /*******************************************************************
327  Convert a wchar to upper case.
328 ********************************************************************/
329
330 smb_ucs2_t toupper_w(smb_ucs2_t val)
331 {
332         return upcase_table[SVAL(&val,0)];
333 }
334
335 /*******************************************************************
336  Convert a wchar to lower case.
337 ********************************************************************/
338
339 smb_ucs2_t tolower_w( smb_ucs2_t val )
340 {
341         return lowcase_table[SVAL(&val,0)];
342
343 }
344
345 /*******************************************************************
346 determine if a character is lowercase
347 ********************************************************************/
348 BOOL islower_w(smb_ucs2_t c)
349 {
350         return upcase_table[SVAL(&c,0)] != c;
351 }
352
353 /*******************************************************************
354 determine if a character is uppercase
355 ********************************************************************/
356 BOOL isupper_w(smb_ucs2_t c)
357 {
358         return lowcase_table[SVAL(&c,0)] != c;
359 }
360
361
362 /*******************************************************************
363 determine if a character is valid in a 8.3 name
364 ********************************************************************/
365 BOOL isvalid83_w(smb_ucs2_t c)
366 {
367         return valid_table[SVAL(&c,0)] != 0;
368 }
369
370 /*******************************************************************
371  Count the number of characters in a smb_ucs2_t string.
372 ********************************************************************/
373 size_t strlen_w(const smb_ucs2_t *src)
374 {
375         size_t len;
376
377         for(len = 0; *src++; len++) ;
378
379         return len;
380 }
381
382 /*******************************************************************
383  Count up to max number of characters in a smb_ucs2_t string.
384 ********************************************************************/
385 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
386 {
387         size_t len;
388
389         for(len = 0; *src++ && (len < max); len++) ;
390
391         return len;
392 }
393
394 /*******************************************************************
395  Wide strchr().
396 ********************************************************************/
397
398 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
399 {
400         while (*s != 0) {
401                 if (c == *s) return CONST_DISCARD(smb_ucs2_t *, s);
402                 s++;
403         }
404         if (c == *s) return CONST_DISCARD(smb_ucs2_t *, s);
405
406         return NULL;
407 }
408
409 smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
410 {
411         return strchr_w(s, UCS2_CHAR(c));
412 }
413
414 /*******************************************************************
415  Wide strrchr().
416 ********************************************************************/
417
418 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
419 {
420         const smb_ucs2_t *p = s;
421         int len = strlen_w(s);
422         if (len == 0) return NULL;
423         p += (len - 1);
424         do {
425                 if (c == *p) return CONST_DISCARD(smb_ucs2_t *, p);
426         } while (p-- != s);
427         return NULL;
428 }
429
430 /*******************************************************************
431  Wide version of strrchr that returns after doing strrchr 'n' times.
432 ********************************************************************/
433
434 smb_ucs2_t *strnrchr_w(const smb_ucs2_t *s, smb_ucs2_t c, unsigned int n)
435 {
436         const smb_ucs2_t *p = s;
437         int len = strlen_w(s);
438         if (len == 0 || !n)
439                 return NULL;
440         p += (len - 1);
441         do {
442                 if (c == *p)
443                         n--;
444
445                 if (!n)
446                         return CONST_DISCARD(smb_ucs2_t *, p);
447         } while (p-- != s);
448         return NULL;
449 }
450
451 /*******************************************************************
452  Wide strstr().
453 ********************************************************************/
454
455 smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
456 {
457         smb_ucs2_t *r;
458         size_t inslen;
459
460         if (!s || !*s || !ins || !*ins) 
461                 return NULL;
462
463         inslen = strlen_w(ins);
464         r = CONST_DISCARD(smb_ucs2_t *, s);
465
466         while ((r = strchr_w(r, *ins))) {
467                 if (strncmp_w(r, ins, inslen) == 0) 
468                         return r;
469                 r++;
470         }
471
472         return NULL;
473 }
474
475 /*******************************************************************
476  Convert a string to lower case.
477  return True if any char is converted
478 ********************************************************************/
479 BOOL strlower_w(smb_ucs2_t *s)
480 {
481         BOOL ret = False;
482         while (*s) {
483                 smb_ucs2_t v = tolower_w(*s);
484                 if (v != *s) {
485                         *s = v;
486                         ret = True;
487                 }
488                 s++;
489         }
490         return ret;
491 }
492
493 /*******************************************************************
494  Convert a string to upper case.
495  return True if any char is converted
496 ********************************************************************/
497 BOOL strupper_w(smb_ucs2_t *s)
498 {
499         BOOL ret = False;
500         while (*s) {
501                 smb_ucs2_t v = toupper_w(*s);
502                 if (v != *s) {
503                         *s = v;
504                         ret = True;
505                 }
506                 s++;
507         }
508         return ret;
509 }
510
511 /*******************************************************************
512   convert a string to "normal" form
513 ********************************************************************/
514
515 void strnorm_w(smb_ucs2_t *s, int case_default)
516 {
517         if (case_default == CASE_UPPER)
518                 strupper_w(s);
519         else
520                 strlower_w(s);
521 }
522
523 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
524 {
525         while (*b && *a == *b) { a++; b++; }
526         return (*a - *b);
527         /* warning: if *a != *b and both are not 0 we retrun a random
528                 greater or lesser than 0 number not realted to which
529                 string is longer */
530 }
531
532 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
533 {
534         size_t n = 0;
535         while ((n < len) && *b && *a == *b) { a++; b++; n++;}
536         return (len - n)?(*a - *b):0;   
537 }
538
539 /*******************************************************************
540 case insensitive string comparison
541 ********************************************************************/
542 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
543 {
544         while (*b && toupper_w(*a) == toupper_w(*b)) { a++; b++; }
545         return (tolower_w(*a) - tolower_w(*b));
546 }
547
548 /*******************************************************************
549 case insensitive string comparison, lenght limited
550 ********************************************************************/
551 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
552 {
553         size_t n = 0;
554         while ((n < len) && *b && (toupper_w(*a) == toupper_w(*b))) { a++; b++; n++; }
555         return (len - n)?(tolower_w(*a) - tolower_w(*b)):0;
556 }
557
558 /*******************************************************************
559   compare 2 strings 
560 ********************************************************************/
561 BOOL strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
562 {
563         if (s1 == s2) return(True);
564         if (!s1 || !s2) return(False);
565   
566         return(strcasecmp_w(s1,s2)==0);
567 }
568
569 /*******************************************************************
570   compare 2 strings up to and including the nth char.
571   ******************************************************************/
572 BOOL strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
573 {
574   if (s1 == s2) return(True);
575   if (!s1 || !s2 || !n) return(False);
576   
577   return(strncasecmp_w(s1,s2,n)==0);
578 }
579
580 /*******************************************************************
581 duplicate string
582 ********************************************************************/
583 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
584 {
585         return strndup_w(src, 0);
586 }
587
588 /* if len == 0 then duplicate the whole string */
589 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
590 {
591         smb_ucs2_t *dest;
592         
593         if (!len) len = strlen_w(src);
594         dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
595         if (!dest) {
596                 DEBUG(0,("strdup_w: out of memory!\n"));
597                 return NULL;
598         }
599
600         memcpy(dest, src, len * sizeof(smb_ucs2_t));
601         dest[len] = 0;
602         
603         return dest;
604 }
605
606 /*******************************************************************
607 copy a string with max len
608 ********************************************************************/
609
610 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
611 {
612         size_t len;
613         
614         if (!dest || !src) return NULL;
615         
616         for (len = 0; (src[len] != 0) && (len < max); len++)
617                 dest[len] = src[len];
618         while (len < max)
619                 dest[len++] = 0;
620         
621         return dest;
622 }
623
624
625 /*******************************************************************
626 append a string of len bytes and add a terminator
627 ********************************************************************/
628
629 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
630 {       
631         size_t start;
632         size_t len;     
633         
634         if (!dest || !src) return NULL;
635         
636         start = strlen_w(dest);
637         len = strnlen_w(src, max);
638
639         memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));                      
640         dest[start+len] = 0;
641         
642         return dest;
643 }
644
645 smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
646 {       
647         size_t start;
648         size_t len;     
649         
650         if (!dest || !src) return NULL;
651         
652         start = strlen_w(dest);
653         len = strlen_w(src);
654
655         memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));                      
656         dest[start+len] = 0;
657         
658         return dest;
659 }
660
661
662 /*******************************************************************
663 replace any occurence of oldc with newc in unicode string
664 ********************************************************************/
665
666 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
667 {
668         for(;*s;s++) {
669                 if(*s==oldc) *s=newc;
670         }
671 }
672
673 /*******************************************************************
674 trim unicode string
675 ********************************************************************/
676
677 BOOL trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
678                                   const smb_ucs2_t *back)
679 {
680         BOOL ret = False;
681         size_t len, front_len, back_len;
682
683         if (!s || !*s) return False;
684
685         len = strlen_w(s);
686
687         if (front && *front) {
688                 front_len = strlen_w(front);
689                 while (len && strncmp_w(s, front, front_len) == 0) {
690                         memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t));
691                         len -= front_len;
692                         ret = True;
693                 }
694         }
695         
696         if (back && *back) {
697                 back_len = strlen_w(back);
698                 while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) {
699                         s[len - back_len] = 0;
700                         len -= back_len;
701                         ret = True;
702                 }
703         }
704
705         return ret;
706 }
707
708 /*
709   The *_wa() functions take a combination of 7 bit ascii
710   and wide characters They are used so that you can use string
711   functions combining C string constants with ucs2 strings
712
713   The char* arguments must NOT be multibyte - to be completely sure
714   of this only pass string constants */
715
716 int strcmp_wa(const smb_ucs2_t *a, const char *b)
717 {
718         while (*b && *a == UCS2_CHAR(*b)) { a++; b++; }
719         return (*a - UCS2_CHAR(*b));
720 }
721
722 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
723 {
724         size_t n = 0;
725         while ((n < len) && *b && *a == UCS2_CHAR(*b)) { a++; b++; n++;}
726         return (len - n)?(*a - UCS2_CHAR(*b)):0;
727 }
728
729 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
730 {
731         while (*s != 0) {
732                 int i;
733                 for (i=0; p[i] && *s != UCS2_CHAR(p[i]); i++) 
734                         ;
735                 if (p[i]) return CONST_DISCARD(smb_ucs2_t *, s);
736                 s++;
737         }
738         return NULL;
739 }
740
741 smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
742 {
743         smb_ucs2_t *r;
744         size_t inslen;
745
746         if (!s || !*s || !ins || !*ins) 
747                 return NULL;
748
749         inslen = strlen(ins);
750         r = CONST_DISCARD(smb_ucs2_t *, s);
751
752         while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
753                 if (strncmp_wa(r, ins, inslen) == 0) 
754                         return r;
755                 r++;
756         }
757
758         return NULL;
759 }
760
761 BOOL trim_string_wa(smb_ucs2_t *s, const char *front,
762                                   const char *back)
763 {
764         wpstring f, b;
765
766         if (front) push_ucs2(NULL, f, front, sizeof(wpstring) - 1, STR_TERMINATE);
767         else *f = 0;
768         if (back) push_ucs2(NULL, b, back, sizeof(wpstring) - 1, STR_TERMINATE);
769         else *b = 0;
770         return trim_string_w(s, f, b);
771 }
772
773 /*******************************************************************
774  returns the length in number of wide characters
775  ******************************************************************/
776 int unistrlen(uint16 *s)
777 {
778         int len;
779
780         if (!s)
781                 return -1;
782
783         for (len=0; *s; s++,len++);
784
785         return len;
786 }
787
788 /*******************************************************************
789  Strcpy for unicode strings.  returns length (in num of wide chars)
790 ********************************************************************/
791
792 int unistrcpy(uint16 *dst, uint16 *src)
793 {
794         int num_wchars = 0;
795
796         while (*src) {
797                 *dst++ = *src++;
798                 num_wchars++;
799         }
800         *dst = 0;
801
802         return num_wchars;
803 }
804
805 /**
806  * Samba ucs2 type to UNISTR2 conversion
807  *
808  * @param ctx Talloc context to create the dst strcture (if null) and the 
809  *            contents of the unicode string.
810  * @param dst UNISTR2 destination. If equals null, then it's allocated.
811  * @param src smb_ucs2_t source.
812  * @param max_len maximum number of unicode characters to copy. If equals
813  *        null, then null-termination of src is taken
814  *
815  * @return copied UNISTR2 destination
816  **/
817 UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
818 {
819         size_t len;
820
821         if (!src)
822                 return NULL;
823         len = strlen_w(src);
824         
825         /* allocate UNISTR2 destination if not given */
826         if (!dst) {
827                 dst = TALLOC_P(ctx, UNISTR2);
828                 if (!dst)
829                         return NULL;
830         }
831         if (!dst->buffer) {
832                 dst->buffer = TALLOC_ARRAY(ctx, uint16, len + 1);
833                 if (!dst->buffer)
834                         return NULL;
835         }
836         
837         /* set UNISTR2 parameters */
838         dst->uni_max_len = len + 1;
839         dst->offset = 0;
840         dst->uni_str_len = len;
841         
842         /* copy the actual unicode string */
843         strncpy_w(dst->buffer, src, dst->uni_max_len);
844         
845         return dst;
846 }