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    Copyright (C) Jeremy Allison 2005
   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 3 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, see <http://www.gnu.org/licenses/>.
  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 static bool upcase_table_use_unmap;
  34 static bool lowcase_table_use_unmap;
  35 static bool valid_table_use_unmap;
  36 static bool initialized;
  37
  38 /**
  39  * Destroy global objects allocated by load_case_tables()
  40  **/
  41 void gfree_case_tables(void)
  42 {
  43         if ( upcase_table ) {
  44                 if ( upcase_table_use_unmap )
  45                         unmap_file(upcase_table, 0x20000);
  46                 else
  47                         SAFE_FREE(upcase_table);
  48         }
  49
  50         if ( lowcase_table ) {
  51                 if ( lowcase_table_use_unmap )
  52                         unmap_file(lowcase_table, 0x20000);
  53                 else
  54                         SAFE_FREE(lowcase_table);
  55         }
  56
  57         if ( valid_table ) {
  58                 if ( valid_table_use_unmap )
  59                         unmap_file(valid_table, 0x10000);
  60                 else
  61                         SAFE_FREE(valid_table);
  62         }
  63         initialized = false;
  64 }
  65
  66 /**
  67  * Load or generate the case handling tables.
  68  *
  69  * The case tables are defined in UCS2 and don't depend on any
  70  * configured parameters, so they never need to be reloaded.
  71  **/
  72
  73 void load_case_tables(void)
  74 {
  75         char *old_locale = NULL, *saved_locale = NULL;
  76         int i;
  77         TALLOC_CTX *frame = NULL;
  78
  79         if (initialized) {
  80                 return;
  81         }
  82         initialized = true;
  83
  84         frame = talloc_stackframe();
  85
  86         upcase_table = (smb_ucs2_t *)map_file(data_path("upcase.dat"),
  87                                               0x20000);
  88         upcase_table_use_unmap = ( upcase_table != NULL );
  89
  90         lowcase_table = (smb_ucs2_t *)map_file(data_path("lowcase.dat"),
  91                                                0x20000);
  92         lowcase_table_use_unmap = ( lowcase_table != NULL );
  93
  94 #ifdef HAVE_SETLOCALE
  95         /* Get the name of the current locale.  */
  96         old_locale = setlocale(LC_ALL, NULL);
  97
  98         if (old_locale) {
  99                 /* Save it as it is in static storage. */
 100                 saved_locale = SMB_STRDUP(old_locale);
 101         }
 102
 103         /* We set back the locale to C to get ASCII-compatible toupper/lower functions. */
 104         setlocale(LC_ALL, "C");
 105 #endif
 106
 107         /* we would like Samba to limp along even if these tables are
 108            not available */
 109         if (!upcase_table) {
 110                 DEBUG(1,("creating lame upcase table\n"));
 111                 upcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
 112                 for (i=0;i<0x10000;i++) {
 113                         smb_ucs2_t v;
 114                         SSVAL(&v, 0, i);
 115                         upcase_table[v] = i;
 116                 }
 117                 for (i=0;i<256;i++) {
 118                         smb_ucs2_t v;
 119                         SSVAL(&v, 0, UCS2_CHAR(i));
 120                         upcase_table[v] = UCS2_CHAR(islower(i)?toupper(i):i);
 121                 }
 122         }
 123
 124         if (!lowcase_table) {
 125                 DEBUG(1,("creating lame lowcase table\n"));
 126                 lowcase_table = (smb_ucs2_t *)SMB_MALLOC(0x20000);
 127                 for (i=0;i<0x10000;i++) {
 128                         smb_ucs2_t v;
 129                         SSVAL(&v, 0, i);
 130                         lowcase_table[v] = i;
 131                 }
 132                 for (i=0;i<256;i++) {
 133                         smb_ucs2_t v;
 134                         SSVAL(&v, 0, UCS2_CHAR(i));
 135                         lowcase_table[v] = UCS2_CHAR(isupper(i)?tolower(i):i);
 136                 }
 137         }
 138
 139 #ifdef HAVE_SETLOCALE
 140         /* Restore the old locale. */
 141         if (saved_locale) {
 142                 setlocale (LC_ALL, saved_locale);
 143                 SAFE_FREE(saved_locale);
 144         }
 145 #endif
 146         TALLOC_FREE(frame);
 147 }
 148
 149 static int check_dos_char_slowly(smb_ucs2_t c)
 150 {
 151         char buf[10];
 152         smb_ucs2_t c2 = 0;
 153         int len1, len2;
 154
 155         len1 = convert_string(CH_UTF16LE, CH_DOS, &c, 2, buf, sizeof(buf),False);
 156         if (len1 == 0) {
 157                 return 0;
 158         }
 159         len2 = convert_string(CH_DOS, CH_UTF16LE, buf, len1, &c2, 2,False);
 160         if (len2 != 2) {
 161                 return 0;
 162         }
 163         return (c == c2);
 164 }
 165
 166 /**
 167  * Load the valid character map table from <tt>valid.dat</tt> or
 168  * create from the configured codepage.
 169  *
 170  * This function is called whenever the configuration is reloaded.
 171  * However, the valid character table is not changed if it's loaded
 172  * from a file, because we can't unmap files.
 173  **/
 174
 175 void init_valid_table(void)
 176 {
 177         static int mapped_file;
 178         int i;
 179         const char *allowed = ".!#$%&'()_-@^`~";
 180         uint8 *valid_file;
 181
 182         if (mapped_file) {
 183                 /* Can't unmap files, so stick with what we have */
 184                 return;
 185         }
 186
 187         valid_file = (uint8 *)map_file(data_path("valid.dat"), 0x10000);
 188         if (valid_file) {
 189                 valid_table = valid_file;
 190                 mapped_file = 1;
 191                 valid_table_use_unmap = True;
 192                 return;
 193         }
 194
 195         /* Otherwise, we're using a dynamically created valid_table.
 196          * It might need to be regenerated if the code page changed.
 197          * We know that we're not using a mapped file, so we can
 198          * free() the old one. */
 199         SAFE_FREE(valid_table);
 200
 201         /* use free rather than unmap */
 202         valid_table_use_unmap = False;
 203
 204         DEBUG(2,("creating default valid table\n"));
 205         valid_table = (uint8 *)SMB_MALLOC(0x10000);
 206         SMB_ASSERT(valid_table != NULL);
 207         for (i=0;i<128;i++) {
 208                 valid_table[i] = isalnum(i) || strchr(allowed,i);
 209         }
 210
 211         lazy_initialize_conv();
 212
 213         for (;i<0x10000;i++) {
 214                 smb_ucs2_t c;
 215                 SSVAL(&c, 0, i);
 216                 valid_table[i] = check_dos_char_slowly(c);
 217         }
 218 }
 219
 220 /*******************************************************************
 221  Write a string in (little-endian) unicode format. src is in
 222  the current DOS codepage. len is the length in bytes of the
 223  string pointed to by dst.
 224
 225  if null_terminate is True then null terminate the packet (adds 2 bytes)
 226
 227  the return value is the length in bytes consumed by the string, including the
 228  null termination if applied
 229 ********************************************************************/
 230
 231 size_t dos_PutUniCode(char *dst,const char *src, size_t len, bool null_terminate)
 232 {
 233         int flags = null_terminate ? STR_UNICODE|STR_NOALIGN|STR_TERMINATE
 234                                    : STR_UNICODE|STR_NOALIGN;
 235         return push_ucs2(NULL, dst, src, len, flags);
 236 }
 237
 238
 239 /*******************************************************************
 240  Skip past a unicode string, but not more than len. Always move
 241  past a terminating zero if found.
 242 ********************************************************************/
 243
 244 char *skip_unibuf(char *src, size_t len)
 245 {
 246         char *srcend = src + len;
 247
 248         while (src < srcend && SVAL(src,0)) {
 249                 src += 2;
 250         }
 251
 252         if(!SVAL(src,0)) {
 253                 src += 2;
 254         }
 255
 256         return src;
 257 }
 258
 259 /* Copy a string from little-endian or big-endian unicode source (depending
 260  * on flags) to internal samba format destination
 261  */
 262
 263 int rpcstr_pull(char* dest, void *src, int dest_len, int src_len, int flags)
 264 {
 265         if (!src) {
 266                 dest[0] = 0;
 267                 return 0;
 268         }
 269         if(dest_len==-1) {
 270                 dest_len=MAXUNI-3;
 271         }
 272         return pull_ucs2(NULL, dest, src, dest_len, src_len, flags|STR_UNICODE|STR_NOALIGN);
 273 }
 274
 275 /* Copy a string from little-endian or big-endian unicode source (depending
 276  * on flags) to internal samba format destination. Allocates on talloc ctx.
 277  */
 278
 279 int rpcstr_pull_talloc(TALLOC_CTX *ctx,
 280                         char **dest,
 281                         void *src,
 282                         int src_len,
 283                         int flags)
 284 {
 285         return pull_ucs2_base_talloc(ctx,
 286                         NULL,
 287                         dest,
 288                         src,
 289                         src_len,
 290                         flags|STR_UNICODE|STR_NOALIGN);
 291
 292 }
 293
 294 /* Copy a string from a unistr2 source to internal samba format
 295    destination.  Use this instead of direct calls to rpcstr_pull() to avoid
 296    having to determine whether the source string is null terminated. */
 297
 298 int rpcstr_pull_unistr2_fstring(char *dest, UNISTR2 *src)
 299 {
 300         return pull_ucs2(NULL, dest, src->buffer, sizeof(fstring),
 301                          src->uni_str_len * 2, 0);
 302 }
 303
 304 /* Helper function to return a talloc'ed string. I have implemented it with a
 305  * copy because I don't really know how pull_ucs2 and friends calculate the
 306  * target size. If this turns out to be a major bottleneck someone with deeper
 307  * multi-byte knowledge needs to revisit this.
 308  * I just did (JRA :-). No longer uses copy.
 309  * My (VL) use is dsr_getdcname, which returns 6 strings, the alternative would
 310  * have been to manually talloc_strdup them in rpc_client/cli_netlogon.c.
 311  */
 312
 313 char *rpcstr_pull_unistr2_talloc(TALLOC_CTX *ctx, const UNISTR2 *src)
 314 {
 315         char *dest = NULL;
 316         size_t dest_len;
 317
 318         if (!convert_string_talloc(ctx, CH_UTF16LE, CH_UNIX, src->buffer,
 319                                    src->uni_str_len * 2, (void *)&dest,
 320                                    &dest_len, true))
 321         {
 322                 return NULL;
 323         }
 324
 325         /* Ensure we're returning a null terminated string. */
 326         if (dest_len) {
 327                 /* Did we already process the terminating zero ? */
 328                 if (dest[dest_len-1] != 0) {
 329                         size_t size = talloc_get_size(dest);
 330                         /* Have we got space to append the '\0' ? */
 331                         if (size <= dest_len) {
 332                                 /* No, realloc. */
 333                                 dest = TALLOC_REALLOC_ARRAY(ctx, dest, char,
 334                                                 dest_len+1);
 335                                 if (!dest) {
 336                                         /* talloc fail. */
 337                                         dest_len = (size_t)-1;
 338                                         return NULL;
 339                                 }
 340                         }
 341                         /* Yay - space ! */
 342                         dest[dest_len] = '\0';
 343                         dest_len++;
 344                 }
 345         } else if (dest) {
 346                 dest[0] = 0;
 347         }
 348
 349         return dest;
 350 }
 351
 352 /* Converts a string from internal samba format to unicode
 353  */
 354
 355 int rpcstr_push(void *dest, const char *src, size_t dest_len, int flags)
 356 {
 357         return push_ucs2(NULL, dest, src, dest_len, flags|STR_UNICODE|STR_NOALIGN);
 358 }
 359
 360 /* Converts a string from internal samba format to unicode. Always terminates.
 361  * Actually just a wrapper round push_ucs2_talloc().
 362  */
 363
 364 int rpcstr_push_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src)
 365 {
 366         size_t size;
 367         if (push_ucs2_talloc(ctx, dest, src, &size))
 368                 return size;
 369         else
 370                 return -1;
 371 }
 372
 373 /*******************************************************************
 374  Convert a (little-endian) UNISTR2 structure to an ASCII string.
 375 ********************************************************************/
 376
 377 void unistr2_to_ascii(char *dest, const UNISTR2 *str, size_t maxlen)
 378 {
 379         if ((str == NULL) || (str->uni_str_len == 0)) {
 380                 *dest='\0';
 381                 return;
 382         }
 383         pull_ucs2(NULL, dest, str->buffer, maxlen, str->uni_str_len*2, STR_NOALIGN);
 384 }
 385
 386 #if 0
 387 /*******************************************************************
 388  Convert a (little-endian) UNISTR3 structure to an ASCII string.
 389 ********************************************************************/
 390
 391 void unistr3_to_ascii(char *dest, const UNISTR3 *str, size_t maxlen)
 392 {
 393         if ((str == NULL) || (str->uni_str_len == 0)) {
 394                 *dest='\0';
 395                 return;
 396         }
 397         pull_ucs2(NULL, dest, str->str.buffer, maxlen, str->uni_str_len*2,
 398                   STR_NOALIGN);
 399 }
 400 #endif
 401
 402 /*******************************************************************
 403  Duplicate a UNISTR2 string into a null terminated char*
 404  using a talloc context.
 405 ********************************************************************/
 406
 407 char *unistr2_to_ascii_talloc(TALLOC_CTX *ctx, const UNISTR2 *str)
 408 {
 409         char *s = NULL;
 410
 411         if (!str || !str->buffer) {
 412                 return NULL;
 413         }
 414         if (pull_ucs2_base_talloc(ctx,
 415                                 NULL,
 416                                 &s,
 417                                 str->buffer,
 418                                 str->uni_str_len*2,
 419                                 STR_NOALIGN) == (size_t)-1) {
 420                 return NULL;
 421         }
 422         return s;
 423 }
 424
 425 /*******************************************************************
 426  Return a string for displaying a UNISTR2. Guarentees to return a
 427  valid string - "" if nothing else.
 428  Changed to use talloc_tos() under the covers.... JRA.
 429 ********************************************************************/
 430
 431 const char *unistr2_static(const UNISTR2 *str)
 432 {
 433         char *dest = NULL;
 434
 435         if ((str == NULL) || (str->uni_str_len == 0)) {
 436                 return "";
 437         }
 438
 439         dest = unistr2_to_ascii_talloc(talloc_tos(), str);
 440         if (!dest) {
 441                 return "";
 442         }
 443
 444         return dest;
 445 }
 446
 447 /*******************************************************************
 448  Convert a wchar to upper case.
 449 ********************************************************************/
 450
 451 smb_ucs2_t toupper_w(smb_ucs2_t val)
 452 {
 453         return upcase_table[SVAL(&val,0)];
 454 }
 455
 456 /*******************************************************************
 457  Convert a wchar to lower case.
 458 ********************************************************************/
 459
 460 smb_ucs2_t tolower_w( smb_ucs2_t val )
 461 {
 462         return lowcase_table[SVAL(&val,0)];
 463 }
 464
 465 /*******************************************************************
 466  Determine if a character is lowercase.
 467 ********************************************************************/
 468
 469 bool islower_w(smb_ucs2_t c)
 470 {
 471         return upcase_table[SVAL(&c,0)] != c;
 472 }
 473
 474 /*******************************************************************
 475  Determine if a character is uppercase.
 476 ********************************************************************/
 477
 478 bool isupper_w(smb_ucs2_t c)
 479 {
 480         return lowcase_table[SVAL(&c,0)] != c;
 481 }
 482
 483 /*******************************************************************
 484  Determine if a character is valid in a 8.3 name.
 485 ********************************************************************/
 486
 487 bool isvalid83_w(smb_ucs2_t c)
 488 {
 489         return valid_table[SVAL(&c,0)] != 0;
 490 }
 491
 492 /*******************************************************************
 493  Count the number of characters in a smb_ucs2_t string.
 494 ********************************************************************/
 495
 496 size_t strlen_w(const smb_ucs2_t *src)
 497 {
 498         size_t len;
 499         smb_ucs2_t c;
 500
 501         for(len = 0; *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
 502                 ;
 503         }
 504
 505         return len;
 506 }
 507
 508 /*******************************************************************
 509  Count up to max number of characters in a smb_ucs2_t string.
 510 ********************************************************************/
 511
 512 size_t strnlen_w(const smb_ucs2_t *src, size_t max)
 513 {
 514         size_t len;
 515         smb_ucs2_t c;
 516
 517         for(len = 0; (len < max) && *(COPY_UCS2_CHAR(&c,src)); src++, len++) {
 518                 ;
 519         }
 520
 521         return len;
 522 }
 523
 524 /*******************************************************************
 525  Wide strchr().
 526 ********************************************************************/
 527
 528 smb_ucs2_t *strchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 529 {
 530         smb_ucs2_t cp;
 531         while (*(COPY_UCS2_CHAR(&cp,s))) {
 532                 if (c == cp) {
 533                         return (smb_ucs2_t *)s;
 534                 }
 535                 s++;
 536         }
 537         if (c == cp) {
 538                 return (smb_ucs2_t *)s;
 539         }
 540
 541         return NULL;
 542 }
 543
 544 smb_ucs2_t *strchr_wa(const smb_ucs2_t *s, char c)
 545 {
 546         return strchr_w(s, UCS2_CHAR(c));
 547 }
 548
 549 /*******************************************************************
 550  Wide strrchr().
 551 ********************************************************************/
 552
 553 smb_ucs2_t *strrchr_w(const smb_ucs2_t *s, smb_ucs2_t c)
 554 {
 555         smb_ucs2_t cp;
 556         const smb_ucs2_t *p = s;
 557         int len = strlen_w(s);
 558
 559         if (len == 0) {
 560                 return NULL;
 561         }
 562         p += (len - 1);
 563         do {
 564                 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
 565                         return (smb_ucs2_t *)p;
 566                 }
 567         } while (p-- != s);
 568         return NULL;
 569 }
 570
 571 /*******************************************************************
 572  Wide version of strrchr that returns after doing strrchr 'n' times.
 573 ********************************************************************/
 574
 575 smb_ucs2_t *strnrchr_w(const smb_ucs2_t *s, smb_ucs2_t c, unsigned int n)
 576 {
 577         smb_ucs2_t cp;
 578         const smb_ucs2_t *p = s;
 579         int len = strlen_w(s);
 580
 581         if (len == 0 || !n) {
 582                 return NULL;
 583         }
 584         p += (len - 1);
 585         do {
 586                 if (c == *(COPY_UCS2_CHAR(&cp,p))) {
 587                         n--;
 588                 }
 589
 590                 if (!n) {
 591                         return (smb_ucs2_t *)p;
 592                 }
 593         } while (p-- != s);
 594         return NULL;
 595 }
 596
 597 /*******************************************************************
 598  Wide strstr().
 599 ********************************************************************/
 600
 601 smb_ucs2_t *strstr_w(const smb_ucs2_t *s, const smb_ucs2_t *ins)
 602 {
 603         smb_ucs2_t *r;
 604         size_t inslen;
 605
 606         if (!s || !*s || !ins || !*ins) {
 607                 return NULL;
 608         }
 609
 610         inslen = strlen_w(ins);
 611         r = (smb_ucs2_t *)s;
 612
 613         while ((r = strchr_w(r, *ins))) {
 614                 if (strncmp_w(r, ins, inslen) == 0) {
 615                         return r;
 616                 }
 617                 r++;
 618         }
 619
 620         return NULL;
 621 }
 622
 623 /*******************************************************************
 624  Convert a string to lower case.
 625  return True if any char is converted
 626 ********************************************************************/
 627
 628 bool strlower_w(smb_ucs2_t *s)
 629 {
 630         smb_ucs2_t cp;
 631         bool ret = False;
 632
 633         while (*(COPY_UCS2_CHAR(&cp,s))) {
 634                 smb_ucs2_t v = tolower_w(cp);
 635                 if (v != cp) {
 636                         COPY_UCS2_CHAR(s,&v);
 637                         ret = True;
 638                 }
 639                 s++;
 640         }
 641         return ret;
 642 }
 643
 644 /*******************************************************************
 645  Convert a string to upper case.
 646  return True if any char is converted
 647 ********************************************************************/
 648
 649 bool strupper_w(smb_ucs2_t *s)
 650 {
 651         smb_ucs2_t cp;
 652         bool ret = False;
 653         while (*(COPY_UCS2_CHAR(&cp,s))) {
 654                 smb_ucs2_t v = toupper_w(cp);
 655                 if (v != cp) {
 656                         COPY_UCS2_CHAR(s,&v);
 657                         ret = True;
 658                 }
 659                 s++;
 660         }
 661         return ret;
 662 }
 663
 664 /*******************************************************************
 665  Convert a string to "normal" form.
 666 ********************************************************************/
 667
 668 void strnorm_w(smb_ucs2_t *s, int case_default)
 669 {
 670         if (case_default == CASE_UPPER) {
 671                 strupper_w(s);
 672         } else {
 673                 strlower_w(s);
 674         }
 675 }
 676
 677 int strcmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
 678 {
 679         smb_ucs2_t cpa, cpb;
 680
 681         while ((*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
 682                 a++;
 683                 b++;
 684         }
 685         return (*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b)));
 686         /* warning: if *a != *b and both are not 0 we return a random
 687                 greater or lesser than 0 number not realted to which
 688                 string is longer */
 689 }
 690
 691 int strncmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
 692 {
 693         smb_ucs2_t cpa, cpb;
 694         size_t n = 0;
 695
 696         while ((n < len) && (*(COPY_UCS2_CHAR(&cpb,b))) && (*(COPY_UCS2_CHAR(&cpa,a)) == cpb)) {
 697                 a++;
 698                 b++;
 699                 n++;
 700         }
 701         return (len - n)?(*(COPY_UCS2_CHAR(&cpa,a)) - *(COPY_UCS2_CHAR(&cpb,b))):0;
 702 }
 703
 704 /*******************************************************************
 705  Case insensitive string comparison.
 706 ********************************************************************/
 707
 708 int strcasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b)
 709 {
 710         smb_ucs2_t cpa, cpb;
 711
 712         while ((*COPY_UCS2_CHAR(&cpb,b)) && toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb)) {
 713                 a++;
 714                 b++;
 715         }
 716         return (tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b))));
 717 }
 718
 719 /*******************************************************************
 720  Case insensitive string comparison, length limited.
 721 ********************************************************************/
 722
 723 int strncasecmp_w(const smb_ucs2_t *a, const smb_ucs2_t *b, size_t len)
 724 {
 725         smb_ucs2_t cpa, cpb;
 726         size_t n = 0;
 727
 728         while ((n < len) && *COPY_UCS2_CHAR(&cpb,b) && (toupper_w(*(COPY_UCS2_CHAR(&cpa,a))) == toupper_w(cpb))) {
 729                 a++;
 730                 b++;
 731                 n++;
 732         }
 733         return (len - n)?(tolower_w(*(COPY_UCS2_CHAR(&cpa,a))) - tolower_w(*(COPY_UCS2_CHAR(&cpb,b)))):0;
 734 }
 735
 736 /*******************************************************************
 737  Compare 2 strings.
 738 ********************************************************************/
 739
 740 bool strequal_w(const smb_ucs2_t *s1, const smb_ucs2_t *s2)
 741 {
 742         if (s1 == s2) {
 743                 return(True);
 744         }
 745         if (!s1 || !s2) {
 746                 return(False);
 747         }
 748
 749         return(strcasecmp_w(s1,s2)==0);
 750 }
 751
 752 /*******************************************************************
 753  Compare 2 strings up to and including the nth char.
 754 ******************************************************************/
 755
 756 bool strnequal_w(const smb_ucs2_t *s1,const smb_ucs2_t *s2,size_t n)
 757 {
 758         if (s1 == s2) {
 759                 return(True);
 760         }
 761         if (!s1 || !s2 || !n) {
 762                 return(False);
 763         }
 764
 765         return(strncasecmp_w(s1,s2,n)==0);
 766 }
 767
 768 /*******************************************************************
 769  Duplicate string.
 770 ********************************************************************/
 771
 772 smb_ucs2_t *strdup_w(const smb_ucs2_t *src)
 773 {
 774         return strndup_w(src, 0);
 775 }
 776
 777 /* if len == 0 then duplicate the whole string */
 778
 779 smb_ucs2_t *strndup_w(const smb_ucs2_t *src, size_t len)
 780 {
 781         smb_ucs2_t *dest;
 782
 783         if (!len) {
 784                 len = strlen_w(src);
 785         }
 786         dest = SMB_MALLOC_ARRAY(smb_ucs2_t, len + 1);
 787         if (!dest) {
 788                 DEBUG(0,("strdup_w: out of memory!\n"));
 789                 return NULL;
 790         }
 791
 792         memcpy(dest, src, len * sizeof(smb_ucs2_t));
 793         dest[len] = 0;
 794         return dest;
 795 }
 796
 797 /*******************************************************************
 798  Copy a string with max len.
 799 ********************************************************************/
 800
 801 smb_ucs2_t *strncpy_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
 802 {
 803         smb_ucs2_t cp;
 804         size_t len;
 805
 806         if (!dest || !src) {
 807                 return NULL;
 808         }
 809
 810         for (len = 0; (*COPY_UCS2_CHAR(&cp,(src+len))) && (len < max); len++) {
 811                 cp = *COPY_UCS2_CHAR(dest+len,src+len);
 812         }
 813         cp = 0;
 814         for ( /*nothing*/ ; len < max; len++ ) {
 815                 cp = *COPY_UCS2_CHAR(dest+len,&cp);
 816         }
 817
 818         return dest;
 819 }
 820
 821 /*******************************************************************
 822  Append a string of len bytes and add a terminator.
 823 ********************************************************************/
 824
 825 smb_ucs2_t *strncat_w(smb_ucs2_t *dest, const smb_ucs2_t *src, const size_t max)
 826 {
 827         size_t start;
 828         size_t len;
 829         smb_ucs2_t z = 0;
 830
 831         if (!dest || !src) {
 832                 return NULL;
 833         }
 834
 835         start = strlen_w(dest);
 836         len = strnlen_w(src, max);
 837
 838         memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
 839         z = *COPY_UCS2_CHAR(dest+start+len,&z);
 840
 841         return dest;
 842 }
 843
 844 smb_ucs2_t *strcat_w(smb_ucs2_t *dest, const smb_ucs2_t *src)
 845 {
 846         size_t start;
 847         size_t len;
 848         smb_ucs2_t z = 0;
 849
 850         if (!dest || !src) {
 851                 return NULL;
 852         }
 853
 854         start = strlen_w(dest);
 855         len = strlen_w(src);
 856
 857         memcpy(&dest[start], src, len*sizeof(smb_ucs2_t));
 858         z = *COPY_UCS2_CHAR(dest+start+len,&z);
 859
 860         return dest;
 861 }
 862
 863
 864 /*******************************************************************
 865  Replace any occurence of oldc with newc in unicode string.
 866 ********************************************************************/
 867
 868 void string_replace_w(smb_ucs2_t *s, smb_ucs2_t oldc, smb_ucs2_t newc)
 869 {
 870         smb_ucs2_t cp;
 871
 872         for(;*(COPY_UCS2_CHAR(&cp,s));s++) {
 873                 if(cp==oldc) {
 874                         COPY_UCS2_CHAR(s,&newc);
 875                 }
 876         }
 877 }
 878
 879 /*******************************************************************
 880  Trim unicode string.
 881 ********************************************************************/
 882
 883 bool trim_string_w(smb_ucs2_t *s, const smb_ucs2_t *front,
 884                                   const smb_ucs2_t *back)
 885 {
 886         bool ret = False;
 887         size_t len, front_len, back_len;
 888
 889         if (!s) {
 890                 return False;
 891         }
 892
 893         len = strlen_w(s);
 894
 895         if (front && *front) {
 896                 front_len = strlen_w(front);
 897                 while (len && strncmp_w(s, front, front_len) == 0) {
 898                         memmove(s, (s + front_len), (len - front_len + 1) * sizeof(smb_ucs2_t));
 899                         len -= front_len;
 900                         ret = True;
 901                 }
 902         }
 903
 904         if (back && *back) {
 905                 back_len = strlen_w(back);
 906                 while (len && strncmp_w((s + (len - back_len)), back, back_len) == 0) {
 907                         s[len - back_len] = 0;
 908                         len -= back_len;
 909                         ret = True;
 910                 }
 911         }
 912
 913         return ret;
 914 }
 915
 916 /*
 917   The *_wa() functions take a combination of 7 bit ascii
 918   and wide characters They are used so that you can use string
 919   functions combining C string constants with ucs2 strings
 920
 921   The char* arguments must NOT be multibyte - to be completely sure
 922   of this only pass string constants */
 923
 924 int strcmp_wa(const smb_ucs2_t *a, const char *b)
 925 {
 926         smb_ucs2_t cp = 0;
 927
 928         while (*b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
 929                 a++;
 930                 b++;
 931         }
 932         return (*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b));
 933 }
 934
 935 int strncmp_wa(const smb_ucs2_t *a, const char *b, size_t len)
 936 {
 937         smb_ucs2_t cp = 0;
 938         size_t n = 0;
 939
 940         while ((n < len) && *b && *(COPY_UCS2_CHAR(&cp,a)) == UCS2_CHAR(*b)) {
 941                 a++;
 942                 b++;
 943                 n++;
 944         }
 945         return (len - n)?(*(COPY_UCS2_CHAR(&cp,a)) - UCS2_CHAR(*b)):0;
 946 }
 947
 948 smb_ucs2_t *strpbrk_wa(const smb_ucs2_t *s, const char *p)
 949 {
 950         smb_ucs2_t cp;
 951
 952         while (*(COPY_UCS2_CHAR(&cp,s))) {
 953                 int i;
 954                 for (i=0; p[i] && cp != UCS2_CHAR(p[i]); i++)
 955                         ;
 956                 if (p[i]) {
 957                         return (smb_ucs2_t *)s;
 958                 }
 959                 s++;
 960         }
 961         return NULL;
 962 }
 963
 964 smb_ucs2_t *strstr_wa(const smb_ucs2_t *s, const char *ins)
 965 {
 966         smb_ucs2_t *r;
 967         size_t inslen;
 968
 969         if (!s || !ins) {
 970                 return NULL;
 971         }
 972
 973         inslen = strlen(ins);
 974         r = (smb_ucs2_t *)s;
 975
 976         while ((r = strchr_w(r, UCS2_CHAR(*ins)))) {
 977                 if (strncmp_wa(r, ins, inslen) == 0)
 978                         return r;
 979                 r++;
 980         }
 981
 982         return NULL;
 983 }
 984
 985 /*******************************************************************
 986  Returns the length in number of wide characters.
 987 ******************************************************************/
 988
 989 int unistrlen(uint16 *s)
 990 {
 991         int len;
 992
 993         if (!s) {
 994                 return -1;
 995         }
 996
 997         for (len=0; SVAL(s,0); s++,len++) {
 998                 ;
 999         }
1000
1001         return len;
1002 }
1003
1004 /*******************************************************************
1005  Strcpy for unicode strings. Returns length (in num of wide chars).
1006  Not odd align safe.
1007 ********************************************************************/
1008
1009 int unistrcpy(uint16 *dst, uint16 *src)
1010 {
1011         int num_wchars = 0;
1012
1013         while (SVAL(src,0)) {
1014                 *dst++ = *src++;
1015                 num_wchars++;
1016         }
1017         *dst = 0;
1018
1019         return num_wchars;
1020 }
1021
1022 /**
1023  * Samba ucs2 type to UNISTR2 conversion
1024  *
1025  * @param ctx Talloc context to create the dst strcture (if null) and the
1026  *            contents of the unicode string.
1027  * @param dst UNISTR2 destination. If equals null, then it's allocated.
1028  * @param src smb_ucs2_t source.
1029  * @param max_len maximum number of unicode characters to copy. If equals
1030  *        null, then null-termination of src is taken
1031  *
1032  * @return copied UNISTR2 destination
1033  **/
1034
1035 UNISTR2* ucs2_to_unistr2(TALLOC_CTX *ctx, UNISTR2* dst, smb_ucs2_t* src)
1036 {
1037         size_t len;
1038
1039         if (!src) {
1040                 return NULL;
1041         }
1042
1043         len = strlen_w(src);
1044
1045         /* allocate UNISTR2 destination if not given */
1046         if (!dst) {
1047                 dst = TALLOC_P(ctx, UNISTR2);
1048                 if (!dst)
1049                         return NULL;
1050         }
1051         if (!dst->buffer) {
1052                 dst->buffer = TALLOC_ARRAY(ctx, uint16, len + 1);
1053                 if (!dst->buffer)
1054                         return NULL;
1055         }
1056
1057         /* set UNISTR2 parameters */
1058         dst->uni_max_len = len + 1;
1059         dst->offset = 0;
1060         dst->uni_str_len = len;
1061
1062         /* copy the actual unicode string */
1063         strncpy_w(dst->buffer, src, dst->uni_max_len);
1064
1065         return dst;
1066 }
1067
1068 /*************************************************************
1069  ascii only toupper - saves the need for smbd to be in C locale.
1070 *************************************************************/
1071
1072 int toupper_ascii(int c)
1073 {
1074         smb_ucs2_t uc = toupper_w(UCS2_CHAR(c));
1075         return UCS2_TO_CHAR(uc);
1076 }
1077
1078 /*************************************************************
1079  ascii only tolower - saves the need for smbd to be in C locale.
1080 *************************************************************/
1081
1082 int tolower_ascii(int c)
1083 {
1084         smb_ucs2_t uc = tolower_w(UCS2_CHAR(c));
1085         return UCS2_TO_CHAR(uc);
1086 }
1087
1088 /*************************************************************
1089  ascii only isupper - saves the need for smbd to be in C locale.
1090 *************************************************************/
1091
1092 int isupper_ascii(int c)
1093 {
1094         return isupper_w(UCS2_CHAR(c));
1095 }
1096
1097 /*************************************************************
1098  ascii only islower - saves the need for smbd to be in C locale.
1099 *************************************************************/
1100
1101 int islower_ascii(int c)
1102 {
1103         return islower_w(UCS2_CHAR(c));
1104 }