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 /*******************************************************************
 441   convert a string to "normal" form
 442 ********************************************************************/
 443 void strnorm(char *s)
 444 {
 445   extern int case_default;
 446   if (case_default == CASE_UPPER)
 447     strupper(s);
 448   else
 449     strlower(s);
 450 }
 451
 452 /*******************************************************************
 453 check if a string is in "normal" case
 454 ********************************************************************/
 455 BOOL strisnormal(char *s)
 456 {
 457   extern int case_default;
 458   if (case_default == CASE_UPPER)
 459     return(!strhaslower(s));
 460
 461   return(!strhasupper(s));
 462 }
 463
 464
 465 /****************************************************************************
 466   string replace
 467 ****************************************************************************/
 468 void string_replace(char *s,char oldc,char newc)
 469 {
 470   size_t skip;
 471
 472   /*
 473    * sbcs optimization.
 474    */
 475   if(!global_is_multibyte_codepage) {
 476     while (*s) {
 477       if (oldc == *s)
 478         *s = newc;
 479       s++;
 480     }
 481   } else {
 482     while (*s)
 483     {
 484       skip = get_character_len( *s );
 485       if( skip != 0 )
 486         s += skip;
 487       else
 488       {
 489         if (oldc == *s)
 490           *s = newc;
 491         s++;
 492       }
 493     }
 494   }
 495 }
 496
 497
 498 /*******************************************************************
 499 skip past some strings in a buffer
 500 ********************************************************************/
 501 char *skip_string(char *buf,size_t n)
 502 {
 503   while (n--)
 504     buf += strlen(buf) + 1;
 505   return(buf);
 506 }
 507
 508 /*******************************************************************
 509  Count the number of characters in a string. Normally this will
 510  be the same as the number of bytes in a string for single byte strings,
 511  but will be different for multibyte.
 512  16.oct.98, jdblair@cobaltnet.com.
 513 ********************************************************************/
 514
 515 size_t str_charnum(const char *s)
 516 {
 517   size_t len = 0;
 518
 519   /*
 520    * sbcs optimization.
 521    */
 522   if(!global_is_multibyte_codepage) {
 523     return strlen(s);
 524   } else {
 525     while (*s != '\0') {
 526       int skip = get_character_len(*s);
 527       s += (skip ? skip : 1);
 528       len++;
 529     }
 530   }
 531   return len;
 532 }
 533
 534 /*******************************************************************
 535 trim the specified elements off the front and back of a string
 536 ********************************************************************/
 537
 538 BOOL trim_string(char *s,const char *front,const char *back)
 539 {
 540     BOOL ret = False;
 541     size_t s_len;
 542     size_t front_len;
 543     size_t back_len;
 544     char        *sP;
 545
 546         /* Ignore null or empty strings. */
 547
 548     if ( !s || (s[0] == '\0'))
 549         return False;
 550
 551     sP  = s;
 552     s_len       = strlen( s ) + 1;
 553     front_len   = (front) ? strlen( front ) + 1 : 0;
 554     back_len    = (back) ? strlen( back ) + 1 : 0;
 555
 556     /*
 557      * remove "front" string from given "s", if it matches front part,
 558      * repeatedly.
 559      */
 560     if ( front && front_len > 1 ) {
 561         while (( s_len >= front_len )&&
 562                ( memcmp( sP, front, front_len - 1 )) == 0 ) {
 563             ret         = True;
 564             sP          += ( front_len - 1 );
 565             s_len       -= ( front_len - 1 );
 566         }
 567     }
 568
 569     /*
 570      * we'll memmove sP to s later, after we're done with
 571      * back part removal, for minimizing copy.
 572      */
 573
 574
 575     /*
 576      * We split out the multibyte code page
 577      * case here for speed purposes. Under a
 578      * multibyte code page we need to walk the
 579      * string forwards only and multiple times.
 580      * Thanks to John Blair for finding this
 581      * one. JRA.
 582      */
 583     /*
 584      * This JRA's comment is partly correct, but partly wrong.
 585      * You can always check from "end" part, and if it did not match,
 586      * it means there is no possibility of finding one.
 587      * If you found matching point, mark them, then look from front
 588      * if marking point suits multi-byte string rule.
 589      * Kenichi Okuyama.
 590      */
 591
 592     if ( back && back_len > 1 && s_len >= back_len) {
 593         char    *bP     = sP + s_len - back_len;
 594         long    b_len   = s_len;
 595
 596         while (( b_len >= back_len )&&
 597                ( memcmp( bP, back, back_len - 1 ) == 0 )) {
 598             bP          -= ( back_len - 1 );
 599             b_len       -= ( back_len - 1 );
 600         }
 601
 602         /*
 603          * You're here, means you ether have found match multiple times,
 604          * or you found none. If you've found match, then bP should be
 605          * moving.
 606          */
 607         if ( bP != sP + s_len - back_len ) {
 608             bP  += ( back_len - 1 ); /* slide bP to first matching point. */
 609
 610             if( !global_is_multibyte_codepage ) {
 611                 /* simply terminate */
 612                 (*bP)   = '\0';
 613                 s_len   = b_len;
 614                 ret     = True;
 615             } else {
 616                 /* trace string from start. */
 617                 char    *cP     = sP;
 618                 while ( cP < sP + s_len - back_len ) {
 619                     size_t      skip;
 620                     skip        = skip_multibyte_char( *cP );
 621                     cP  += ( skip ? skip : 1 );
 622                     if ( cP == bP ) {
 623                         /* you found the match */
 624                         (*bP)   = '\0';
 625                         ret     = True;
 626                         s_len   = b_len;
 627                         break;
 628                     }
 629                     while (( cP > bP )&&( bP < sP + s_len - back_len )) {
 630                         bP      += ( back_len - 1 );
 631                         b_len   += ( back_len - 1 );
 632                     }
 633                 }
 634             }
 635         }
 636     }
 637
 638     /* if front found matching point */
 639     if ( sP != s ) {
 640         /* slide string to buffer top */
 641         memmove( s, sP, s_len );
 642     }
 643     return ret;
 644 }
 645
 646
 647 /****************************************************************************
 648 does a string have any uppercase chars in it?
 649 ****************************************************************************/
 650 BOOL strhasupper(const char *s)
 651 {
 652   while (*s)
 653   {
 654 #if !defined(KANJI_WIN95_COMPATIBILITY)
 655   /*
 656    * For completeness we should put in equivalent code for code pages
 657    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 658    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 659    * here. They both treat full width ascii characters as case senstive
 660    * filenames (ie. they don't do the work we do here).
 661    * JRA.
 662    */
 663
 664     if(lp_client_code_page() == KANJI_CODEPAGE)
 665     {
 666       /* Win95 treats full width ascii characters as case sensitive. */
 667       if (is_shift_jis (*s))
 668         s += 2;
 669       else if (is_kana (*s))
 670         s++;
 671       else
 672       {
 673         if (isupper(*s))
 674           return(True);
 675         s++;
 676       }
 677     }
 678     else
 679 #endif /* KANJI_WIN95_COMPATIBILITY */
 680     {
 681       size_t skip = get_character_len( *s );
 682       if( skip != 0 )
 683         s += skip;
 684       else {
 685         if (isupper(*s))
 686           return(True);
 687         s++;
 688       }
 689     }
 690   }
 691   return(False);
 692 }
 693
 694 /****************************************************************************
 695 does a string have any lowercase chars in it?
 696 ****************************************************************************/
 697 BOOL strhaslower(const char *s)
 698 {
 699   while (*s)
 700   {
 701 #if !defined(KANJI_WIN95_COMPATIBILITY)
 702   /*
 703    * For completeness we should put in equivalent code for code pages
 704    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 705    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 706    * here. They both treat full width ascii characters as case senstive
 707    * filenames (ie. they don't do the work we do here).
 708    * JRA.
 709    */
 710
 711     if(lp_client_code_page() == KANJI_CODEPAGE)
 712     {
 713       /* Win95 treats full width ascii characters as case sensitive. */
 714       if (is_shift_jis (*s))
 715       {
 716         if (is_sj_upper (s[0], s[1]))
 717           return(True);
 718         if (is_sj_lower (s[0], s[1]))
 719           return (True);
 720         s += 2;
 721       }
 722       else if (is_kana (*s))
 723       {
 724         s++;
 725       }
 726       else
 727       {
 728         if (islower(*s))
 729           return(True);
 730         s++;
 731       }
 732     }
 733     else
 734 #endif /* KANJI_WIN95_COMPATIBILITY */
 735     {
 736       size_t skip = get_character_len( *s );
 737       if( skip != 0 )
 738         s += skip;
 739       else {
 740         if (islower(*s))
 741           return(True);
 742         s++;
 743       }
 744     }
 745   }
 746   return(False);
 747 }
 748
 749 /****************************************************************************
 750 find the number of chars in a string
 751 ****************************************************************************/
 752 size_t count_chars(const char *s,char c)
 753 {
 754   size_t count=0;
 755
 756 #if !defined(KANJI_WIN95_COMPATIBILITY)
 757   /*
 758    * For completeness we should put in equivalent code for code pages
 759    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 760    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 761    * here. They both treat full width ascii characters as case senstive
 762    * filenames (ie. they don't do the work we do here).
 763    * JRA.
 764    */
 765
 766   if(lp_client_code_page() == KANJI_CODEPAGE)
 767   {
 768     /* Win95 treats full width ascii characters as case sensitive. */
 769     while (*s)
 770     {
 771       if (is_shift_jis (*s))
 772         s += 2;
 773       else
 774       {
 775         if (*s == c)
 776           count++;
 777         s++;
 778       }
 779     }
 780   }
 781   else
 782 #endif /* KANJI_WIN95_COMPATIBILITY */
 783   {
 784     while (*s)
 785     {
 786       size_t skip = get_character_len( *s );
 787       if( skip != 0 )
 788         s += skip;
 789       else {
 790         if (*s == c)
 791           count++;
 792         s++;
 793       }
 794     }
 795   }
 796   return(count);
 797 }
 798
 799 /*******************************************************************
 800 Return True if a string consists only of one particular character.
 801 ********************************************************************/
 802
 803 BOOL str_is_all(const char *s,char c)
 804 {
 805   if(s == NULL)
 806     return False;
 807   if(!*s)
 808     return False;
 809
 810 #if !defined(KANJI_WIN95_COMPATIBILITY)
 811   /*
 812    * For completeness we should put in equivalent code for code pages
 813    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 814    * doubt anyone wants Samba to behave differently from Win95 and WinNT
 815    * here. They both treat full width ascii characters as case senstive
 816    * filenames (ie. they don't do the work we do here).
 817    * JRA.
 818    */
 819
 820   if(lp_client_code_page() == KANJI_CODEPAGE)
 821   {
 822     /* Win95 treats full width ascii characters as case sensitive. */
 823     while (*s)
 824     {
 825       if (is_shift_jis (*s))
 826         s += 2;
 827       else
 828       {
 829         if (*s != c)
 830           return False;
 831         s++;
 832       }
 833     }
 834   }
 835   else
 836 #endif /* KANJI_WIN95_COMPATIBILITY */
 837   {
 838     while (*s)
 839     {
 840       size_t skip = get_character_len( *s );
 841       if( skip != 0 )
 842         s += skip;
 843       else {
 844         if (*s != c)
 845           return False;
 846         s++;
 847       }
 848     }
 849   }
 850   return True;
 851 }
 852
 853 /*******************************************************************
 854 safe string copy into a known length string. maxlength does not
 855 include the terminating zero.
 856 ********************************************************************/
 857
 858 char *safe_strcpy(char *dest,const char *src, size_t maxlength)
 859 {
 860         size_t len;
 861
 862         if (!dest) {
 863                 DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
 864                 return NULL;
 865         }
 866
 867         if (!src) {
 868                 *dest = 0;
 869                 return dest;
 870         }
 871
 872         len = strlen(src);
 873
 874         if (len > maxlength) {
 875                 DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
 876                         (int)(len-maxlength), src));
 877                 len = maxlength;
 878         }
 879
 880         memcpy(dest, src, len);
 881         dest[len] = 0;
 882         return dest;
 883 }
 884
 885 /*******************************************************************
 886 safe string cat into a string. maxlength does not
 887 include the terminating zero.
 888 ********************************************************************/
 889
 890 char *safe_strcat(char *dest, const char *src, size_t maxlength)
 891 {
 892         size_t src_len, dest_len;
 893
 894         if (!dest) {
 895                 DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
 896                 return NULL;
 897         }
 898
 899         if (!src)
 900                 return dest;
 901
 902         src_len = strlen(src);
 903         dest_len = strlen(dest);
 904
 905         if (src_len + dest_len > maxlength) {
 906                 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
 907                         (int)(src_len + dest_len - maxlength), src));
 908                 if (dest_len >= maxlength)
 909                         return dest;
 910                 src_len = maxlength - dest_len;
 911         }
 912
 913         memcpy(&dest[dest_len], src, src_len);
 914         dest[dest_len + src_len] = 0;
 915         return dest;
 916 }
 917
 918 /*******************************************************************
 919  Paranoid strcpy into a buffer of given length (includes terminating
 920  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 921  and replaces with '_'. Deliberately does *NOT* check for multibyte
 922  characters. Don't change it !
 923 ********************************************************************/
 924
 925 char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
 926 {
 927         size_t len, i;
 928         size_t buflen;
 929         smb_ucs2_t *str_ucs, *other_ucs;
 930
 931         if (!dest) {
 932                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
 933                 return NULL;
 934         }
 935
 936         if (!src) {
 937                 *dest = 0;
 938                 return dest;
 939         }
 940
 941         /* Get UCS2 version of src string*/
 942
 943         buflen=2*strlen(src)+2;
 944         if (buflen >= (2*maxlength))
 945                 buflen = 2*(maxlength - 1);
 946
 947         str_ucs = (smb_ucs2_t*)malloc(buflen);
 948         if(!str_ucs) {
 949                 *dest=0;
 950                 return dest;
 951         }
 952         unix_to_unicode(str_ucs, src, buflen);
 953         len = strlen_w(str_ucs);
 954
 955         if (!other_safe_chars)
 956                 other_safe_chars = "";
 957
 958         /* Get UCS2 version of other_safe_chars string*/
 959         buflen=2*strlen(other_safe_chars)+2;
 960         other_ucs = (smb_ucs2_t*)malloc(buflen);
 961         if(!other_ucs) {
 962                 *dest=0;
 963                 SAFE_FREE(str_ucs);
 964                 return dest;
 965         }
 966         unix_to_unicode(other_ucs, other_safe_chars, buflen);
 967
 968         for(i = 0; i < len; i++) {
 969                 if(isupper_w(str_ucs[i]) || islower_w(str_ucs[i]) || isdigit_w(str_ucs[i]) || strchr_w(other_ucs, str_ucs[i]))
 970                         ;
 971                 else
 972                         str_ucs[i] = (smb_ucs2_t)'_'; /*This will work*/
 973
 974         }
 975         unicode_to_unix(dest, str_ucs, maxlength);
 976
 977         SAFE_FREE(other_ucs);
 978         SAFE_FREE(str_ucs);
 979
 980         return dest;
 981 }
 982
 983 /****************************************************************************
 984  Like strncpy but always null terminates. Make sure there is room!
 985  The variable n should always be one less than the available size.
 986 ****************************************************************************/
 987
 988 char *StrnCpy(char *dest,const char *src,size_t n)
 989 {
 990   char *d = dest;
 991   if (!dest) return(NULL);
 992   if (!src) {
 993     *dest = 0;
 994     return(dest);
 995   }
 996   while (n-- && (*d++ = *src++)) ;
 997   *d = 0;
 998   return(dest);
 999 }
1000
1001 /****************************************************************************
1002 like strncpy but copies up to the character marker.  always null terminates.
1003 returns a pointer to the character marker in the source string (src).
1004 ****************************************************************************/
1005 char *strncpyn(char *dest, const char *src,size_t n, char c)
1006 {
1007         char *p;
1008         size_t str_len;
1009
1010         p = strchr(src, c);
1011         if (p == NULL)
1012         {
1013                 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
1014                 return NULL;
1015         }
1016
1017         str_len = PTR_DIFF(p, src);
1018         strncpy(dest, src, MIN(n, str_len));
1019         dest[str_len] = '\0';
1020
1021         return p;
1022 }
1023
1024
1025 /*************************************************************
1026  Routine to get hex characters and turn them into a 16 byte array.
1027  the array can be variable length, and any non-hex-numeric
1028  characters are skipped.  "0xnn" or "0Xnn" is specially catered
1029  for.
1030
1031  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
1032
1033 **************************************************************/
1034 size_t strhex_to_str(char *p, size_t len, const char *strhex)
1035 {
1036         size_t i;
1037         size_t num_chars = 0;
1038         unsigned char   lonybble, hinybble;
1039         char           *hexchars = "0123456789ABCDEF";
1040         char           *p1 = NULL, *p2 = NULL;
1041
1042         for (i = 0; i < len && strhex[i] != 0; i++)
1043         {
1044                 if (strnequal(hexchars, "0x", 2))
1045                 {
1046                         i++; /* skip two chars */
1047                         continue;
1048                 }
1049
1050                 if (!(p1 = strchr(hexchars, toupper(strhex[i]))))
1051                 {
1052                         break;
1053                 }
1054
1055                 i++; /* next hex digit */
1056
1057                 if (!(p2 = strchr(hexchars, toupper(strhex[i]))))
1058                 {
1059                         break;
1060                 }
1061
1062                 /* get the two nybbles */
1063                 hinybble = PTR_DIFF(p1, hexchars);
1064                 lonybble = PTR_DIFF(p2, hexchars);
1065
1066                 p[num_chars] = (hinybble << 4) | lonybble;
1067                 num_chars++;
1068
1069                 p1 = NULL;
1070                 p2 = NULL;
1071         }
1072         return num_chars;
1073 }
1074
1075 /****************************************************************************
1076 check if a string is part of a list
1077 ****************************************************************************/
1078 BOOL in_list(char *s,char *list,BOOL casesensitive)
1079 {
1080   pstring tok;
1081   char *p=list;
1082
1083   if (!list) return(False);
1084
1085   while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
1086     if (casesensitive) {
1087       if (strcmp(tok,s) == 0)
1088         return(True);
1089     } else {
1090       if (StrCaseCmp(tok,s) == 0)
1091         return(True);
1092     }
1093   }
1094   return(False);
1095 }
1096
1097 /* this is used to prevent lots of mallocs of size 1 */
1098 static char *null_string = NULL;
1099
1100 /****************************************************************************
1101 set a string value, allocing the space for the string
1102 ****************************************************************************/
1103 static BOOL string_init(char **dest,const char *src)
1104 {
1105   size_t l;
1106   if (!src)
1107     src = "";
1108
1109   l = strlen(src);
1110
1111   if (l == 0)
1112     {
1113       if (!null_string) {
1114         if((null_string = (char *)malloc(1)) == NULL) {
1115           DEBUG(0,("string_init: malloc fail for null_string.\n"));
1116           return False;
1117         }
1118         *null_string = 0;
1119       }
1120       *dest = null_string;
1121     }
1122   else
1123     {
1124       (*dest) = (char *)malloc(l+1);
1125       if ((*dest) == NULL) {
1126               DEBUG(0,("Out of memory in string_init\n"));
1127               return False;
1128       }
1129
1130       pstrcpy(*dest,src);
1131     }
1132   return(True);
1133 }
1134
1135 /****************************************************************************
1136 free a string value
1137 ****************************************************************************/
1138 void string_free(char **s)
1139 {
1140   if (!s || !(*s)) return;
1141   if (*s == null_string)
1142     *s = NULL;
1143   SAFE_FREE(*s);
1144 }
1145
1146 /****************************************************************************
1147 set a string value, allocing the space for the string, and deallocating any
1148 existing space
1149 ****************************************************************************/
1150 BOOL string_set(char **dest,const char *src)
1151 {
1152   string_free(dest);
1153
1154   return(string_init(dest,src));
1155 }
1156
1157
1158 /****************************************************************************
1159 substitute a string for a pattern in another string. Make sure there is
1160 enough room!
1161
1162 This routine looks for pattern in s and replaces it with
1163 insert. It may do multiple replacements.
1164
1165 any of " ; ' $ or ` in the insert string are replaced with _
1166 if len==0 then no expansion is permitted.
1167 ****************************************************************************/
1168 void string_sub(char *s,const char *pattern,const char *insert, size_t len)
1169 {
1170         char *p;
1171         ssize_t ls,lp,li, i;
1172
1173         if (!insert || !pattern || !s) return;
1174
1175         ls = (ssize_t)strlen(s);
1176         lp = (ssize_t)strlen(pattern);
1177         li = (ssize_t)strlen(insert);
1178
1179         if (!*pattern) return;
1180
1181         if (len == 0)
1182                 len = ls + 1; /* len is number of *bytes* */
1183
1184         while (lp <= ls && (p = strstr(s,pattern))) {
1185                 if (ls + (li-lp) >= len) {
1186                         DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
1187                                  (int)(ls + (li-lp) - len),
1188                                  pattern, (int)len));
1189                         break;
1190                 }
1191                 if (li != lp) {
1192                         memmove(p+li,p+lp,strlen(p+lp)+1);
1193                 }
1194                 for (i=0;i<li;i++) {
1195                         switch (insert[i]) {
1196                         case '`':
1197                         case '"':
1198                         case '\'':
1199                         case ';':
1200                         case '$':
1201                         case '%':
1202                         case '\r':
1203                         case '\n':
1204                                 p[i] = '_';
1205                                 break;
1206                         default:
1207                                 p[i] = insert[i];
1208                         }
1209                 }
1210                 s = p + li;
1211                 ls += (li-lp);
1212         }
1213 }
1214
1215 void fstring_sub(char *s,const char *pattern,const char *insert)
1216 {
1217         string_sub(s, pattern, insert, sizeof(fstring));
1218 }
1219
1220 void pstring_sub(char *s,const char *pattern,const char *insert)
1221 {
1222         string_sub(s, pattern, insert, sizeof(pstring));
1223 }
1224
1225 /****************************************************************************
1226 similar to string_sub() but allows for any character to be substituted.
1227 Use with caution!
1228 if len==0 then no expansion is permitted.
1229 ****************************************************************************/
1230 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1231 {
1232         char *p;
1233         ssize_t ls,lp,li;
1234
1235         if (!insert || !pattern || !s) return;
1236
1237         ls = (ssize_t)strlen(s);
1238         lp = (ssize_t)strlen(pattern);
1239         li = (ssize_t)strlen(insert);
1240
1241         if (!*pattern) return;
1242
1243         if (len == 0)
1244                 len = ls + 1; /* len is number of *bytes* */
1245
1246         while (lp <= ls && (p = strstr(s,pattern))) {
1247                 if (ls + (li-lp) >= len) {
1248                         DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1249                                  (int)(ls + (li-lp) - len),
1250                                  pattern, (int)len));
1251                         break;
1252                 }
1253                 if (li != lp) {
1254                         memmove(p+li,p+lp,strlen(p+lp)+1);
1255                 }
1256                 memcpy(p, insert, li);
1257                 s = p + li;
1258                 ls += (li-lp);
1259         }
1260 }
1261
1262 /****************************************************************************
1263  splits out the front and back at a separator.
1264 ****************************************************************************/
1265 void split_at_last_component(char *path, char *front, char sep, char *back)
1266 {
1267         char *p = strrchr(path, sep);
1268
1269         if (p != NULL)
1270         {
1271                 *p = 0;
1272         }
1273         if (front != NULL)
1274         {
1275                 pstrcpy(front, path);
1276         }
1277         if (p != NULL)
1278         {
1279                 if (back != NULL)
1280                 {
1281                         pstrcpy(back, p+1);
1282                 }
1283                 *p = '\\';
1284         }
1285         else
1286         {
1287                 if (back != NULL)
1288                 {
1289                         back[0] = 0;
1290                 }
1291         }
1292 }
1293
1294
1295 /****************************************************************************
1296 write an octal as a string
1297 ****************************************************************************/
1298 char *octal_string(int i)
1299 {
1300         static char ret[64];
1301         if (i == -1) {
1302                 return "-1";
1303         }
1304         slprintf(ret, sizeof(ret)-1, "0%o", i);
1305         return ret;
1306 }
1307
1308
1309 /****************************************************************************
1310 truncate a string at a specified length
1311 ****************************************************************************/
1312 char *string_truncate(char *s, int length)
1313 {
1314         if (s && strlen(s) > length) {
1315                 s[length] = 0;
1316         }
1317         return s;
1318 }
1319
1320 /*
1321   return a RFC2254 binary string representation of a buffer
1322   used in LDAP filters
1323   caller must free
1324 */
1325 char *binary_string(char *buf, int len)
1326 {
1327         char *s;
1328         int i, j;
1329         const char *hex = "0123456789ABCDEF";
1330         s = malloc(len * 3 + 1);
1331         if (!s) return NULL;
1332         for (j=i=0;i<len;i++) {
1333                 s[j] = '\\';
1334                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1335                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1336                 j += 3;
1337         }
1338         s[j] = 0;
1339         return s;
1340 }
1341
1342 #ifndef HAVE_STRNLEN
1343 /*******************************************************************
1344  Some platforms don't have strnlen
1345 ********************************************************************/
1346
1347  size_t strnlen(const char *s, size_t n)
1348 {
1349         int i;
1350         for (i=0; s[i] && i<n; i++)
1351                 /* noop */ ;
1352         return i;
1353 }
1354 #endif
1355
1356 #ifndef HAVE_STRNDUP
1357 /*******************************************************************
1358  Some platforms don't have strndup.
1359 ********************************************************************/
1360
1361  char *strndup(const char *s, size_t n)
1362 {
1363         char *ret;
1364
1365         n = strnlen(s, n);
1366         ret = malloc(n+1);
1367         if (!ret)
1368                 return NULL;
1369         memcpy(ret, s, n);
1370         ret[n] = 0;
1371
1372         return ret;
1373 }
1374 #endif