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