source/lib/util_str.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1998
   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 static char *last_ptr=NULL;
  25
  26 void set_first_token(char *ptr)
  27 {
  28         last_ptr = ptr;
  29 }
  30
  31 /****************************************************************************
  32   Get the next token from a string, return False if none found
  33   handles double-quotes.
  34 Based on a routine by GJC@VILLAGE.COM.
  35 Extensively modified by Andrew.Tridgell@anu.edu.au
  36 ****************************************************************************/
  37 BOOL next_token(char **ptr,char *buff,char *sep, size_t bufsize)
  38 {
  39   char *s;
  40   BOOL quoted;
  41   size_t len=1;
  42
  43   if (!ptr) ptr = &last_ptr;
  44   if (!ptr) return(False);
  45
  46   s = *ptr;
  47
  48   /* default to simple separators */
  49   if (!sep) sep = " \t\n\r";
  50
  51   /* find the first non sep char */
  52   while(*s && strchr(sep,*s)) s++;
  53
  54   /* nothing left? */
  55   if (! *s) return(False);
  56
  57   /* copy over the token */
  58   for (quoted = False; len < bufsize && *s && (quoted || !strchr(sep,*s)); s++)
  59     {
  60             if (*s == '\"') {
  61                     quoted = !quoted;
  62             } else {
  63                     len++;
  64                     *buff++ = *s;
  65             }
  66     }
  67
  68   *ptr = (*s) ? s+1 : s;
  69   *buff = 0;
  70   last_ptr = *ptr;
  71
  72   return(True);
  73 }
  74
  75 /****************************************************************************
  76 Convert list of tokens to array; dependent on above routine.
  77 Uses last_ptr from above - bit of a hack.
  78 ****************************************************************************/
  79 char **toktocliplist(int *ctok, char *sep)
  80 {
  81   char *s=last_ptr;
  82   int ictok=0;
  83   char **ret, **iret;
  84
  85   if (!sep) sep = " \t\n\r";
  86
  87   while(*s && strchr(sep,*s)) s++;
  88
  89   /* nothing left? */
  90   if (!*s) return(NULL);
  91
  92   do {
  93     ictok++;
  94     while(*s && (!strchr(sep,*s))) s++;
  95     while(*s && strchr(sep,*s)) *s++=0;
  96   } while(*s);
  97
  98   *ctok=ictok;
  99   s=last_ptr;
 100
 101   if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
 102
 103   while(ictok--) {
 104     *iret++=s;
 105     while(*s++);
 106     while(!*s) s++;
 107   }
 108
 109   return ret;
 110 }
 111
 112
 113 /*******************************************************************
 114   case insensitive string compararison
 115 ********************************************************************/
 116 int StrCaseCmp(const char *s, const char *t)
 117 {
 118   /* compare until we run out of string, either t or s, or find a difference */
 119   /* We *must* use toupper rather than tolower here due to the
 120      asynchronous upper to lower mapping.
 121    */
 122 #if !defined(KANJI_WIN95_COMPATIBILITY)
 123   /*
 124    * For completeness we should put in equivalent code for code pages
 125    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 126    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 127    * here. They both treat full width ascii characters as case senstive
 128    * filenames (ie. they don't do the work we do here).
 129    * JRA.
 130    */
 131
 132   if(lp_client_code_page() == KANJI_CODEPAGE)
 133   {
 134     /* Win95 treats full width ascii characters as case sensitive. */
 135     int diff;
 136     for (;;)
 137     {
 138       if (!*s || !*t)
 139             return toupper (*s) - toupper (*t);
 140       else if (is_sj_alph (*s) && is_sj_alph (*t))
 141       {
 142         diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
 143         if (diff)
 144           return diff;
 145         s += 2;
 146         t += 2;
 147       }
 148       else if (is_shift_jis (*s) && is_shift_jis (*t))
 149       {
 150         diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
 151         if (diff)
 152           return diff;
 153         diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
 154         if (diff)
 155           return diff;
 156         s += 2;
 157         t += 2;
 158       }
 159       else if (is_shift_jis (*s))
 160         return 1;
 161       else if (is_shift_jis (*t))
 162         return -1;
 163       else
 164       {
 165         diff = toupper (*s) - toupper (*t);
 166         if (diff)
 167           return diff;
 168         s++;
 169         t++;
 170       }
 171     }
 172   }
 173   else
 174 #endif /* KANJI_WIN95_COMPATIBILITY */
 175   {
 176     while (*s && *t && toupper(*s) == toupper(*t))
 177     {
 178       s++;
 179       t++;
 180     }
 181
 182     return(toupper(*s) - toupper(*t));
 183   }
 184 }
 185
 186 /*******************************************************************
 187   case insensitive string compararison, length limited
 188 ********************************************************************/
 189 int StrnCaseCmp(const char *s, const char *t, size_t n)
 190 {
 191   /* compare until we run out of string, either t or s, or chars */
 192   /* We *must* use toupper rather than tolower here due to the
 193      asynchronous upper to lower mapping.
 194    */
 195 #if !defined(KANJI_WIN95_COMPATIBILITY)
 196   /*
 197    * For completeness we should put in equivalent code for code pages
 198    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 199    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 200    * here. They both treat full width ascii characters as case senstive
 201    * filenames (ie. they don't do the work we do here).
 202    * JRA.
 203    */
 204
 205   if(lp_client_code_page() == KANJI_CODEPAGE)
 206   {
 207     /* Win95 treats full width ascii characters as case sensitive. */
 208     int diff;
 209     for (;n > 0;)
 210     {
 211       if (!*s || !*t)
 212         return toupper (*s) - toupper (*t);
 213       else if (is_sj_alph (*s) && is_sj_alph (*t))
 214       {
 215         diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
 216         if (diff)
 217           return diff;
 218         s += 2;
 219         t += 2;
 220         n -= 2;
 221       }
 222       else if (is_shift_jis (*s) && is_shift_jis (*t))
 223       {
 224         diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
 225         if (diff)
 226           return diff;
 227         diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
 228         if (diff)
 229           return diff;
 230         s += 2;
 231         t += 2;
 232         n -= 2;
 233       }
 234       else if (is_shift_jis (*s))
 235         return 1;
 236       else if (is_shift_jis (*t))
 237         return -1;
 238       else
 239       {
 240         diff = toupper (*s) - toupper (*t);
 241         if (diff)
 242           return diff;
 243         s++;
 244         t++;
 245         n--;
 246       }
 247     }
 248     return 0;
 249   }
 250   else
 251 #endif /* KANJI_WIN95_COMPATIBILITY */
 252   {
 253     while (n && *s && *t && toupper(*s) == toupper(*t))
 254     {
 255       s++;
 256       t++;
 257       n--;
 258     }
 259
 260     /* not run out of chars - strings are different lengths */
 261     if (n)
 262       return(toupper(*s) - toupper(*t));
 263
 264     /* identical up to where we run out of chars,
 265        and strings are same length */
 266     return(0);
 267   }
 268 }
 269
 270 /*******************************************************************
 271   compare 2 strings
 272 ********************************************************************/
 273 BOOL strequal(const char *s1, const char *s2)
 274 {
 275   if (s1 == s2) return(True);
 276   if (!s1 || !s2) return(False);
 277
 278   return(StrCaseCmp(s1,s2)==0);
 279 }
 280
 281 /*******************************************************************
 282   compare 2 strings up to and including the nth char.
 283   ******************************************************************/
 284 BOOL strnequal(const char *s1,const char *s2,size_t n)
 285 {
 286   if (s1 == s2) return(True);
 287   if (!s1 || !s2 || !n) return(False);
 288
 289   return(StrnCaseCmp(s1,s2,n)==0);
 290 }
 291
 292 /*******************************************************************
 293   compare 2 strings (case sensitive)
 294 ********************************************************************/
 295 BOOL strcsequal(const char *s1,const char *s2)
 296 {
 297   if (s1 == s2) return(True);
 298   if (!s1 || !s2) return(False);
 299
 300   return(strcmp(s1,s2)==0);
 301 }
 302
 303 /***************************************************************************
 304 Do a case-insensitive, whitespace-ignoring string compare.
 305 ***************************************************************************/
 306 int strwicmp(char *psz1, char *psz2)
 307 {
 308         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 309         /* appropriate value. */
 310         if (psz1 == psz2)
 311                 return (0);
 312         else if (psz1 == NULL)
 313                 return (-1);
 314         else if (psz2 == NULL)
 315                 return (1);
 316
 317         /* sync the strings on first non-whitespace */
 318         while (1)
 319         {
 320                 while (isspace((int)*psz1))
 321                         psz1++;
 322                 while (isspace((int)*psz2))
 323                         psz2++;
 324                 if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0'
 325                     || *psz2 == '\0')
 326                         break;
 327                 psz1++;
 328                 psz2++;
 329         }
 330         return (*psz1 - *psz2);
 331 }
 332
 333
 334 /*******************************************************************
 335   convert a string to lower case
 336 ********************************************************************/
 337 void strlower(char *s)
 338 {
 339   while (*s)
 340   {
 341 #if !defined(KANJI_WIN95_COMPATIBILITY)
 342   /*
 343    * For completeness we should put in equivalent code for code pages
 344    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 345    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 346    * here. They both treat full width ascii characters as case senstive
 347    * filenames (ie. they don't do the work we do here).
 348    * JRA.
 349    */
 350
 351     if(lp_client_code_page() == KANJI_CODEPAGE)
 352     {
 353       /* Win95 treats full width ascii characters as case sensitive. */
 354       if (is_shift_jis (*s))
 355       {
 356         if (is_sj_upper (s[0], s[1]))
 357           s[1] = sj_tolower2 (s[1]);
 358         s += 2;
 359       }
 360       else if (is_kana (*s))
 361       {
 362         s++;
 363       }
 364       else
 365       {
 366         if (isupper(*s))
 367           *s = tolower(*s);
 368         s++;
 369       }
 370     }
 371     else
 372 #endif /* KANJI_WIN95_COMPATIBILITY */
 373     {
 374       size_t skip = get_character_len( *s );
 375       if( skip != 0 )
 376         s += skip;
 377       else
 378       {
 379         if (isupper(*s))
 380           *s = tolower(*s);
 381         s++;
 382       }
 383     }
 384   }
 385 }
 386
 387 /*******************************************************************
 388   convert a string to upper case
 389 ********************************************************************/
 390 void strupper(char *s)
 391 {
 392   while (*s)
 393   {
 394 #if !defined(KANJI_WIN95_COMPATIBILITY)
 395   /*
 396    * For completeness we should put in equivalent code for code pages
 397    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 398    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 399    * here. They both treat full width ascii characters as case senstive
 400    * filenames (ie. they don't do the work we do here).
 401    * JRA.
 402    */
 403
 404     if(lp_client_code_page() == KANJI_CODEPAGE)
 405     {
 406       /* Win95 treats full width ascii characters as case sensitive. */
 407       if (is_shift_jis (*s))
 408       {
 409         if (is_sj_lower (s[0], s[1]))
 410           s[1] = sj_toupper2 (s[1]);
 411         s += 2;
 412       }
 413       else if (is_kana (*s))
 414       {
 415         s++;
 416       }
 417       else
 418       {
 419         if (islower(*s))
 420           *s = toupper(*s);
 421         s++;
 422       }
 423     }
 424     else
 425 #endif /* KANJI_WIN95_COMPATIBILITY */
 426     {
 427       size_t skip = get_character_len( *s );
 428       if( skip != 0 )
 429         s += skip;
 430       else
 431       {
 432         if (islower(*s))
 433           *s = toupper(*s);
 434         s++;
 435       }
 436     }
 437   }
 438 }
 439
 440 /* Convert a string to upper case, but don't modify it */
 441
 442 char *strupper_static(const char *s)
 443 {
 444         static pstring str;
 445
 446         pstrcpy(str, s);
 447         strupper(str);
 448
 449         return str;
 450 }
 451
 452 /*******************************************************************
 453   convert a string to "normal" form
 454 ********************************************************************/
 455 void strnorm(char *s)
 456 {
 457   extern int case_default;
 458   if (case_default == CASE_UPPER)
 459     strupper(s);
 460   else
 461     strlower(s);
 462 }
 463
 464 /*******************************************************************
 465 check if a string is in "normal" case
 466 ********************************************************************/
 467 BOOL strisnormal(char *s)
 468 {
 469   extern int case_default;
 470   if (case_default == CASE_UPPER)
 471     return(!strhaslower(s));
 472
 473   return(!strhasupper(s));
 474 }
 475
 476
 477 /****************************************************************************
 478   string replace
 479 ****************************************************************************/
 480 void string_replace(char *s,char oldc,char newc)
 481 {
 482   size_t skip;
 483
 484   /*
 485    * sbcs optimization.
 486    */
 487   if(!global_is_multibyte_codepage) {
 488     while (*s) {
 489       if (oldc == *s)
 490         *s = newc;
 491       s++;
 492     }
 493   } else {
 494     while (*s)
 495     {
 496       skip = get_character_len( *s );
 497       if( skip != 0 )
 498         s += skip;
 499       else
 500       {
 501         if (oldc == *s)
 502           *s = newc;
 503         s++;
 504       }
 505     }
 506   }
 507 }
 508
 509
 510 /*******************************************************************
 511 skip past some strings in a buffer
 512 ********************************************************************/
 513 char *skip_string(char *buf,size_t n)
 514 {
 515   while (n--)
 516     buf += strlen(buf) + 1;
 517   return(buf);
 518 }
 519
 520 /*******************************************************************
 521  Count the number of characters in a string. Normally this will
 522  be the same as the number of bytes in a string for single byte strings,
 523  but will be different for multibyte.
 524  16.oct.98, jdblair@cobaltnet.com.
 525 ********************************************************************/
 526
 527 size_t str_charnum(const char *s)
 528 {
 529   size_t len = 0;
 530
 531   /*
 532    * sbcs optimization.
 533    */
 534   if(!global_is_multibyte_codepage) {
 535     return strlen(s);
 536   } else {
 537     while (*s != '\0') {
 538       int skip = get_character_len(*s);
 539       s += (skip ? skip : 1);
 540       len++;
 541     }
 542   }
 543   return len;
 544 }
 545
 546 /*******************************************************************
 547 trim the specified elements off the front and back of a string
 548 ********************************************************************/
 549
 550 BOOL trim_string(char *s,const char *front,const char *back)
 551 {
 552     BOOL ret = False;
 553     size_t s_len;
 554     size_t front_len;
 555     size_t back_len;
 556     char        *sP;
 557
 558         /* Ignore null or empty strings. */
 559
 560     if ( !s || (s[0] == '\0'))
 561         return False;
 562
 563     sP  = s;
 564     s_len       = strlen( s ) + 1;
 565     front_len   = (front) ? strlen( front ) + 1 : 0;
 566     back_len    = (back) ? strlen( back ) + 1 : 0;
 567
 568     /*
 569      * remove "front" string from given "s", if it matches front part,
 570      * repeatedly.
 571      */
 572     if ( front && front_len > 1 ) {
 573         while (( s_len >= front_len )&&
 574                ( memcmp( sP, front, front_len - 1 )) == 0 ) {
 575             ret         = True;
 576             sP          += ( front_len - 1 );
 577             s_len       -= ( front_len - 1 );
 578         }
 579     }
 580
 581     /*
 582      * we'll memmove sP to s later, after we're done with
 583      * back part removal, for minimizing copy.
 584      */
 585
 586
 587     /*
 588      * We split out the multibyte code page
 589      * case here for speed purposes. Under a
 590      * multibyte code page we need to walk the
 591      * string forwards only and multiple times.
 592      * Thanks to John Blair for finding this
 593      * one. JRA.
 594      */
 595     /*
 596      * This JRA's comment is partly correct, but partly wrong.
 597      * You can always check from "end" part, and if it did not match,
 598      * it means there is no possibility of finding one.
 599      * If you found matching point, mark them, then look from front
 600      * if marking point suits multi-byte string rule.
 601      * Kenichi Okuyama.
 602      */
 603
 604     if ( back && back_len > 1 && s_len >= back_len) {
 605         char    *bP     = sP + s_len - back_len;
 606         long    b_len   = s_len;
 607
 608         while (( b_len >= back_len )&&
 609                ( memcmp( bP, back, back_len - 1 ) == 0 )) {
 610             bP          -= ( back_len - 1 );
 611             b_len       -= ( back_len - 1 );
 612         }
 613
 614         /*
 615          * You're here, means you ether have found match multiple times,
 616          * or you found none. If you've found match, then bP should be
 617          * moving.
 618          */
 619         if ( bP != sP + s_len - back_len ) {
 620             bP  += ( back_len - 1 ); /* slide bP to first matching point. */
 621
 622             if( !global_is_multibyte_codepage ) {
 623                 /* simply terminate */
 624                 (*bP)   = '\0';
 625                 s_len   = b_len;
 626                 ret     = True;
 627             } else {
 628                 /* trace string from start. */
 629                 char    *cP     = sP;
 630                 while ( cP < sP + s_len - back_len ) {
 631                     size_t      skip;
 632                     skip        = skip_multibyte_char( *cP );
 633                     cP  += ( skip ? skip : 1 );
 634                     if ( cP == bP ) {
 635                         /* you found the match */
 636                         (*bP)   = '\0';
 637                         ret     = True;
 638                         s_len   = b_len;
 639                         break;
 640                     }
 641                     while (( cP > bP )&&( bP < sP + s_len - back_len )) {
 642                         bP      += ( back_len - 1 );
 643                         b_len   += ( back_len - 1 );
 644                     }
 645                 }
 646             }
 647         }
 648     }
 649
 650     /* if front found matching point */
 651     if ( sP != s ) {
 652         /* slide string to buffer top */
 653         memmove( s, sP, s_len );
 654     }
 655     return ret;
 656 }
 657
 658
 659 /****************************************************************************
 660 does a string have any uppercase chars in it?
 661 ****************************************************************************/
 662 BOOL strhasupper(const char *s)
 663 {
 664   while (*s)
 665   {
 666 #if !defined(KANJI_WIN95_COMPATIBILITY)
 667   /*
 668    * For completeness we should put in equivalent code for code pages
 669    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 670    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 671    * here. They both treat full width ascii characters as case senstive
 672    * filenames (ie. they don't do the work we do here).
 673    * JRA.
 674    */
 675
 676     if(lp_client_code_page() == KANJI_CODEPAGE)
 677     {
 678       /* Win95 treats full width ascii characters as case sensitive. */
 679       if (is_shift_jis (*s))
 680         s += 2;
 681       else if (is_kana (*s))
 682         s++;
 683       else
 684       {
 685         if (isupper(*s))
 686           return(True);
 687         s++;
 688       }
 689     }
 690     else
 691 #endif /* KANJI_WIN95_COMPATIBILITY */
 692     {
 693       size_t skip = get_character_len( *s );
 694       if( skip != 0 )
 695         s += skip;
 696       else {
 697         if (isupper(*s))
 698           return(True);
 699         s++;
 700       }
 701     }
 702   }
 703   return(False);
 704 }
 705
 706 /****************************************************************************
 707 does a string have any lowercase chars in it?
 708 ****************************************************************************/
 709 BOOL strhaslower(const char *s)
 710 {
 711   while (*s)
 712   {
 713 #if !defined(KANJI_WIN95_COMPATIBILITY)
 714   /*
 715    * For completeness we should put in equivalent code for code pages
 716    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 717    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 718    * here. They both treat full width ascii characters as case senstive
 719    * filenames (ie. they don't do the work we do here).
 720    * JRA.
 721    */
 722
 723     if(lp_client_code_page() == KANJI_CODEPAGE)
 724     {
 725       /* Win95 treats full width ascii characters as case sensitive. */
 726       if (is_shift_jis (*s))
 727       {
 728         if (is_sj_upper (s[0], s[1]))
 729           return(True);
 730         if (is_sj_lower (s[0], s[1]))
 731           return (True);
 732         s += 2;
 733       }
 734       else if (is_kana (*s))
 735       {
 736         s++;
 737       }
 738       else
 739       {
 740         if (islower(*s))
 741           return(True);
 742         s++;
 743       }
 744     }
 745     else
 746 #endif /* KANJI_WIN95_COMPATIBILITY */
 747     {
 748       size_t skip = get_character_len( *s );
 749       if( skip != 0 )
 750         s += skip;
 751       else {
 752         if (islower(*s))
 753           return(True);
 754         s++;
 755       }
 756     }
 757   }
 758   return(False);
 759 }
 760
 761 /****************************************************************************
 762 find the number of chars in a string
 763 ****************************************************************************/
 764 size_t count_chars(const char *s,char c)
 765 {
 766   size_t count=0;
 767
 768 #if !defined(KANJI_WIN95_COMPATIBILITY)
 769   /*
 770    * For completeness we should put in equivalent code for code pages
 771    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 772    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 773    * here. They both treat full width ascii characters as case senstive
 774    * filenames (ie. they don't do the work we do here).
 775    * JRA.
 776    */
 777
 778   if(lp_client_code_page() == KANJI_CODEPAGE)
 779   {
 780     /* Win95 treats full width ascii characters as case sensitive. */
 781     while (*s)
 782     {
 783       if (is_shift_jis (*s))
 784         s += 2;
 785       else
 786       {
 787         if (*s == c)
 788           count++;
 789         s++;
 790       }
 791     }
 792   }
 793   else
 794 #endif /* KANJI_WIN95_COMPATIBILITY */
 795   {
 796     while (*s)
 797     {
 798       size_t skip = get_character_len( *s );
 799       if( skip != 0 )
 800         s += skip;
 801       else {
 802         if (*s == c)
 803           count++;
 804         s++;
 805       }
 806     }
 807   }
 808   return(count);
 809 }
 810
 811 /*******************************************************************
 812 Return True if a string consists only of one particular character.
 813 ********************************************************************/
 814
 815 BOOL str_is_all(const char *s,char c)
 816 {
 817   if(s == NULL)
 818     return False;
 819   if(!*s)
 820     return False;
 821
 822 #if !defined(KANJI_WIN95_COMPATIBILITY)
 823   /*
 824    * For completeness we should put in equivalent code for code pages
 825    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 826    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 827    * here. They both treat full width ascii characters as case senstive
 828    * filenames (ie. they don't do the work we do here).
 829    * JRA.
 830    */
 831
 832   if(lp_client_code_page() == KANJI_CODEPAGE)
 833   {
 834     /* Win95 treats full width ascii characters as case sensitive. */
 835     while (*s)
 836     {
 837       if (is_shift_jis (*s))
 838         s += 2;
 839       else
 840       {
 841         if (*s != c)
 842           return False;
 843         s++;
 844       }
 845     }
 846   }
 847   else
 848 #endif /* KANJI_WIN95_COMPATIBILITY */
 849   {
 850     while (*s)
 851     {
 852       size_t skip = get_character_len( *s );
 853       if( skip != 0 )
 854         s += skip;
 855       else {
 856         if (*s != c)
 857           return False;
 858         s++;
 859       }
 860     }
 861   }
 862   return True;
 863 }
 864
 865 /*******************************************************************
 866 safe string copy into a known length string. maxlength does not
 867 include the terminating zero.
 868 ********************************************************************/
 869
 870 char *safe_strcpy(char *dest,const char *src, size_t maxlength)
 871 {
 872         size_t len;
 873
 874         if (!dest) {
 875                 DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
 876                 return NULL;
 877         }
 878
 879         if (!src) {
 880                 *dest = 0;
 881                 return dest;
 882         }
 883
 884         len = strlen(src);
 885
 886         if (len > maxlength) {
 887                 DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
 888                         (int)(len-maxlength), src));
 889                 len = maxlength;
 890         }
 891
 892         memcpy(dest, src, len);
 893         dest[len] = 0;
 894         return dest;
 895 }
 896
 897 /*******************************************************************
 898 safe string cat into a string. maxlength does not
 899 include the terminating zero.
 900 ********************************************************************/
 901
 902 char *safe_strcat(char *dest, const char *src, size_t maxlength)
 903 {
 904         size_t src_len, dest_len;
 905
 906         if (!dest) {
 907                 DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
 908                 return NULL;
 909         }
 910
 911         if (!src)
 912                 return dest;
 913
 914         src_len = strlen(src);
 915         dest_len = strlen(dest);
 916
 917         if (src_len + dest_len > maxlength) {
 918                 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
 919                         (int)(src_len + dest_len - maxlength), src));
 920                 if (dest_len >= maxlength)
 921                         return dest;
 922                 src_len = maxlength - dest_len;
 923         }
 924
 925         memcpy(&dest[dest_len], src, src_len);
 926         dest[dest_len + src_len] = 0;
 927         return dest;
 928 }
 929
 930 /*******************************************************************
 931  Paranoid strcpy into a buffer of given length (includes terminating
 932  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 933  and replaces with '_'. Deliberately does *NOT* check for multibyte
 934  characters. Don't change it !
 935 ********************************************************************/
 936
 937 char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
 938 {
 939         size_t len, i;
 940         size_t buflen;
 941         smb_ucs2_t *str_ucs, *other_ucs;
 942
 943         if (!dest) {
 944                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
 945                 return NULL;
 946         }
 947
 948         if (!src) {
 949                 *dest = 0;
 950                 return dest;
 951         }
 952
 953         /* Get UCS2 version of src string*/
 954
 955         buflen=2*strlen(src)+2;
 956         if (buflen >= (2*maxlength))
 957                 buflen = 2*(maxlength - 1);
 958
 959         str_ucs = (smb_ucs2_t*)malloc(buflen);
 960         if(!str_ucs) {
 961                 *dest=0;
 962                 return dest;
 963         }
 964         unix_to_unicode(str_ucs, src, buflen);
 965         len = strlen_w(str_ucs);
 966
 967         if (!other_safe_chars)
 968                 other_safe_chars = "";
 969
 970         /* Get UCS2 version of other_safe_chars string*/
 971         buflen=2*strlen(other_safe_chars)+2;
 972         other_ucs = (smb_ucs2_t*)malloc(buflen);
 973         if(!other_ucs) {
 974                 *dest=0;
 975                 SAFE_FREE(str_ucs);
 976                 return dest;
 977         }
 978         unix_to_unicode(other_ucs, other_safe_chars, buflen);
 979
 980         for(i = 0; i < len; i++) {
 981                 if(isupper_w(str_ucs[i]) || islower_w(str_ucs[i]) || isdigit_w(str_ucs[i]) || strchr_w(other_ucs, str_ucs[i]))
 982                         ;
 983                 else
 984                         str_ucs[i] = (smb_ucs2_t)'_'; /*This will work*/
 985
 986         }
 987         unicode_to_unix(dest, str_ucs, maxlength);
 988
 989         SAFE_FREE(other_ucs);
 990         SAFE_FREE(str_ucs);
 991
 992         return dest;
 993 }
 994
 995 /****************************************************************************
 996  Like strncpy but always null terminates. Make sure there is room!
 997  The variable n should always be one less than the available size.
 998 ****************************************************************************/
 999
1000 char *StrnCpy(char *dest,const char *src,size_t n)
1001 {
1002   char *d = dest;
1003   if (!dest) return(NULL);
1004   if (!src) {
1005     *dest = 0;
1006     return(dest);
1007   }
1008   while (n-- && (*d++ = *src++)) ;
1009   *d = 0;
1010   return(dest);
1011 }
1012
1013 /****************************************************************************
1014 like strncpy but copies up to the character marker.  always null terminates.
1015 returns a pointer to the character marker in the source string (src).
1016 ****************************************************************************/
1017 char *strncpyn(char *dest, const char *src,size_t n, char c)
1018 {
1019         char *p;
1020         size_t str_len;
1021
1022         p = strchr(src, c);
1023         if (p == NULL)
1024         {
1025                 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
1026                 return NULL;
1027         }
1028
1029         str_len = PTR_DIFF(p, src);
1030         strncpy(dest, src, MIN(n, str_len));
1031         dest[str_len] = '\0';
1032
1033         return p;
1034 }
1035
1036
1037 /*************************************************************
1038  Routine to get hex characters and turn them into a 16 byte array.
1039  the array can be variable length, and any non-hex-numeric
1040  characters are skipped.  "0xnn" or "0Xnn" is specially catered
1041  for.
1042
1043  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
1044
1045 **************************************************************/
1046 size_t strhex_to_str(char *p, size_t len, const char *strhex)
1047 {
1048         size_t i;
1049         size_t num_chars = 0;
1050         unsigned char   lonybble, hinybble;
1051         char           *hexchars = "0123456789ABCDEF";
1052         char           *p1 = NULL, *p2 = NULL;
1053
1054         for (i = 0; i < len && strhex[i] != 0; i++)
1055         {
1056                 if (strnequal(hexchars, "0x", 2))
1057                 {
1058                         i++; /* skip two chars */
1059                         continue;
1060                 }
1061
1062                 if (!(p1 = strchr(hexchars, toupper(strhex[i]))))
1063                 {
1064                         break;
1065                 }
1066
1067                 i++; /* next hex digit */
1068
1069                 if (!(p2 = strchr(hexchars, toupper(strhex[i]))))
1070                 {
1071                         break;
1072                 }
1073
1074                 /* get the two nybbles */
1075                 hinybble = PTR_DIFF(p1, hexchars);
1076                 lonybble = PTR_DIFF(p2, hexchars);
1077
1078                 p[num_chars] = (hinybble << 4) | lonybble;
1079                 num_chars++;
1080
1081                 p1 = NULL;
1082                 p2 = NULL;
1083         }
1084         return num_chars;
1085 }
1086
1087 /****************************************************************************
1088 check if a string is part of a list
1089 ****************************************************************************/
1090 BOOL in_list(char *s,char *list,BOOL casesensitive)
1091 {
1092   pstring tok;
1093   char *p=list;
1094
1095   if (!list) return(False);
1096
1097   while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
1098     if (casesensitive) {
1099       if (strcmp(tok,s) == 0)
1100         return(True);
1101     } else {
1102       if (StrCaseCmp(tok,s) == 0)
1103         return(True);
1104     }
1105   }
1106   return(False);
1107 }
1108
1109 /* this is used to prevent lots of mallocs of size 1 */
1110 static char *null_string = NULL;
1111
1112 /****************************************************************************
1113 set a string value, allocing the space for the string
1114 ****************************************************************************/
1115 static BOOL string_init(char **dest,const char *src)
1116 {
1117   size_t l;
1118   if (!src)
1119     src = "";
1120
1121   l = strlen(src);
1122
1123   if (l == 0)
1124     {
1125       if (!null_string) {
1126         if((null_string = (char *)malloc(1)) == NULL) {
1127           DEBUG(0,("string_init: malloc fail for null_string.\n"));
1128           return False;
1129         }
1130         *null_string = 0;
1131       }
1132       *dest = null_string;
1133     }
1134   else
1135     {
1136       (*dest) = (char *)malloc(l+1);
1137       if ((*dest) == NULL) {
1138               DEBUG(0,("Out of memory in string_init\n"));
1139               return False;
1140       }
1141
1142       pstrcpy(*dest,src);
1143     }
1144   return(True);
1145 }
1146
1147 /****************************************************************************
1148 free a string value
1149 ****************************************************************************/
1150 void string_free(char **s)
1151 {
1152   if (!s || !(*s)) return;
1153   if (*s == null_string)
1154     *s = NULL;
1155   SAFE_FREE(*s);
1156 }
1157
1158 /****************************************************************************
1159 set a string value, allocing the space for the string, and deallocating any
1160 existing space
1161 ****************************************************************************/
1162 BOOL string_set(char **dest,const char *src)
1163 {
1164   string_free(dest);
1165
1166   return(string_init(dest,src));
1167 }
1168
1169
1170 /****************************************************************************
1171 substitute a string for a pattern in another string. Make sure there is
1172 enough room!
1173
1174 This routine looks for pattern in s and replaces it with
1175 insert. It may do multiple replacements.
1176
1177 any of " ; ' $ or ` in the insert string are replaced with _
1178 if len==0 then no expansion is permitted.
1179 ****************************************************************************/
1180 void string_sub(char *s,const char *pattern,const char *insert, size_t len)
1181 {
1182         char *p;
1183         ssize_t ls,lp,li, i;
1184
1185         if (!insert || !pattern || !s) return;
1186
1187         ls = (ssize_t)strlen(s);
1188         lp = (ssize_t)strlen(pattern);
1189         li = (ssize_t)strlen(insert);
1190
1191         if (!*pattern) return;
1192
1193         if (len == 0)
1194                 len = ls + 1; /* len is number of *bytes* */
1195
1196         while (lp <= ls && (p = strstr(s,pattern))) {
1197                 if (ls + (li-lp) >= len) {
1198                         DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
1199                                  (int)(ls + (li-lp) - len),
1200                                  pattern, (int)len));
1201                         break;
1202                 }
1203                 if (li != lp) {
1204                         memmove(p+li,p+lp,strlen(p+lp)+1);
1205                 }
1206                 for (i=0;i<li;i++) {
1207                         switch (insert[i]) {
1208                         case '`':
1209                         case '"':
1210                         case '\'':
1211                         case ';':
1212                         case '$':
1213                         case '%':
1214                         case '\r':
1215                         case '\n':
1216                                 p[i] = '_';
1217                                 break;
1218                         default:
1219                                 p[i] = insert[i];
1220                         }
1221                 }
1222                 s = p + li;
1223                 ls += (li-lp);
1224         }
1225 }
1226
1227 void fstring_sub(char *s,const char *pattern,const char *insert)
1228 {
1229         string_sub(s, pattern, insert, sizeof(fstring));
1230 }
1231
1232 void pstring_sub(char *s,const char *pattern,const char *insert)
1233 {
1234         string_sub(s, pattern, insert, sizeof(pstring));
1235 }
1236
1237 /****************************************************************************
1238 similar to string_sub() but allows for any character to be substituted.
1239 Use with caution!
1240 if len==0 then no expansion is permitted.
1241 ****************************************************************************/
1242 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1243 {
1244         char *p;
1245         ssize_t ls,lp,li;
1246
1247         if (!insert || !pattern || !s) return;
1248
1249         ls = (ssize_t)strlen(s);
1250         lp = (ssize_t)strlen(pattern);
1251         li = (ssize_t)strlen(insert);
1252
1253         if (!*pattern) return;
1254
1255         if (len == 0)
1256                 len = ls + 1; /* len is number of *bytes* */
1257
1258         while (lp <= ls && (p = strstr(s,pattern))) {
1259                 if (ls + (li-lp) >= len) {
1260                         DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1261                                  (int)(ls + (li-lp) - len),
1262                                  pattern, (int)len));
1263                         break;
1264                 }
1265                 if (li != lp) {
1266                         memmove(p+li,p+lp,strlen(p+lp)+1);
1267                 }
1268                 memcpy(p, insert, li);
1269                 s = p + li;
1270                 ls += (li-lp);
1271         }
1272 }
1273
1274 /****************************************************************************
1275  splits out the front and back at a separator.
1276 ****************************************************************************/
1277 void split_at_last_component(char *path, char *front, char sep, char *back)
1278 {
1279         char *p = strrchr(path, sep);
1280
1281         if (p != NULL)
1282         {
1283                 *p = 0;
1284         }
1285         if (front != NULL)
1286         {
1287                 pstrcpy(front, path);
1288         }
1289         if (p != NULL)
1290         {
1291                 if (back != NULL)
1292                 {
1293                         pstrcpy(back, p+1);
1294                 }
1295                 *p = '\\';
1296         }
1297         else
1298         {
1299                 if (back != NULL)
1300                 {
1301                         back[0] = 0;
1302                 }
1303         }
1304 }
1305
1306
1307 /****************************************************************************
1308 write an octal as a string
1309 ****************************************************************************/
1310 char *octal_string(int i)
1311 {
1312         static char ret[64];
1313         if (i == -1) {
1314                 return "-1";
1315         }
1316         slprintf(ret, sizeof(ret)-1, "0%o", i);
1317         return ret;
1318 }
1319
1320
1321 /****************************************************************************
1322 truncate a string at a specified length
1323 ****************************************************************************/
1324 char *string_truncate(char *s, int length)
1325 {
1326         if (s && strlen(s) > length) {
1327                 s[length] = 0;
1328         }
1329         return s;
1330 }
1331
1332 /*
1333   return a RFC2254 binary string representation of a buffer
1334   used in LDAP filters
1335   caller must free
1336 */
1337 char *binary_string(char *buf, int len)
1338 {
1339         char *s;
1340         int i, j;
1341         const char *hex = "0123456789ABCDEF";
1342         s = malloc(len * 3 + 1);
1343         if (!s) return NULL;
1344         for (j=i=0;i<len;i++) {
1345                 s[j] = '\\';
1346                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1347                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1348                 j += 3;
1349         }
1350         s[j] = 0;
1351         return s;
1352 }
1353
1354 #ifndef HAVE_STRNLEN
1355 /*******************************************************************
1356  Some platforms don't have strnlen
1357 ********************************************************************/
1358
1359  size_t strnlen(const char *s, size_t n)
1360 {
1361         int i;
1362         for (i=0; s[i] && i<n; i++)
1363                 /* noop */ ;
1364         return i;
1365 }
1366 #endif
1367
1368 #ifndef HAVE_STRNDUP
1369 /*******************************************************************
1370  Some platforms don't have strndup.
1371 ********************************************************************/
1372
1373  char *strndup(const char *s, size_t n)
1374 {
1375         char *ret;
1376
1377         n = strnlen(s, n);
1378         ret = malloc(n+1);
1379         if (!ret)
1380                 return NULL;
1381         memcpy(ret, s, n);
1382         ret[n] = 0;
1383
1384         return ret;
1385 }
1386 #endif