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