src/vfs/smbfs/helpers/lib/util_str.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5
   6    Copyright (C) Andrew Tridgell 1992-1998
   7
   8    Copyright (C) 2011
   9    The Free Software Foundation, Inc.
  10
  11    This file is part of the Midnight Commander.
  12
  13    The Midnight Commander is free software: you can redistribute it
  14    and/or modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation, either version 3 of the License,
  16    or (at your option) any later version.
  17
  18    The Midnight Commander is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 #include "includes.h"
  28
  29 extern int DEBUGLEVEL;
  30
  31 static char *last_ptr = NULL;
  32
  33 void
  34 set_first_token (char *ptr)
  35 {
  36     last_ptr = ptr;
  37 }
  38
  39 /****************************************************************************
  40   Get the next token from a string, return False if none found
  41   handles double-quotes.
  42 Based on a routine by GJC@VILLAGE.COM.
  43 Extensively modified by Andrew.Tridgell@anu.edu.au
  44 ****************************************************************************/
  45 BOOL
  46 next_token (char **ptr, char *buff, const char *sep, size_t bufsize)
  47 {
  48     char *s;
  49     BOOL quoted;
  50     size_t len = 1;
  51
  52     if (!ptr)
  53         ptr = &last_ptr;
  54     if (!ptr)
  55         return (False);
  56
  57     s = *ptr;
  58
  59     /* default to simple separators */
  60     if (!sep)
  61         sep = " \t\n\r";
  62
  63     /* find the first non sep char */
  64     while (*s && strchr (sep, *s))
  65         s++;
  66
  67     /* nothing left? */
  68     if (!*s)
  69         return (False);
  70
  71     /* copy over the token */
  72     for (quoted = False; len < bufsize && *s && (quoted || !strchr (sep, *s)); s++)
  73     {
  74         if (*s == '\"')
  75         {
  76             quoted = !quoted;
  77         }
  78         else
  79         {
  80             len++;
  81             *buff++ = *s;
  82         }
  83     }
  84
  85     *ptr = (*s) ? s + 1 : s;
  86     *buff = 0;
  87     last_ptr = *ptr;
  88
  89     return (True);
  90 }
  91
  92 #if 0
  93 /****************************************************************************
  94 Convert list of tokens to array; dependent on above routine.
  95 Uses last_ptr from above - bit of a hack.
  96 ****************************************************************************/
  97 char **
  98 toktocliplist (int *ctok, char *sep)
  99 {
 100     char *s = last_ptr;
 101     int ictok = 0;
 102     char **ret, **iret;
 103
 104     if (!sep)
 105         sep = " \t\n\r";
 106
 107     while (*s && strchr (sep, *s))
 108         s++;
 109
 110     /* nothing left? */
 111     if (!*s)
 112         return (NULL);
 113
 114     do
 115     {
 116         ictok++;
 117         while (*s && (!strchr (sep, *s)))
 118             s++;
 119         while (*s && strchr (sep, *s))
 120             *s++ = 0;
 121     }
 122     while (*s);
 123
 124     *ctok = ictok;
 125     s = last_ptr;
 126
 127     if (!(ret = iret = malloc (ictok * sizeof (char *))))
 128         return NULL;
 129
 130     while (ictok--)
 131     {
 132         *iret++ = s;
 133         while (*s++);
 134         while (!*s)
 135             s++;
 136     }
 137
 138     return ret;
 139 }
 140 #endif /*0 */
 141
 142 /*******************************************************************
 143   case insensitive string compararison
 144 ********************************************************************/
 145 int
 146 StrCaseCmp (const char *s, const char *t)
 147 {
 148     /* compare until we run out of string, either t or s, or find a difference */
 149     /* We *must* use toupper rather than tolower here due to the
 150        asynchronous upper to lower mapping.
 151      */
 152 #if !defined(KANJI_WIN95_COMPATIBILITY)
 153     /*
 154      * For completeness we should put in equivalent code for code pages
 155      * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 156      * doubt anyone wants Samba to behave differently from Win95 and WinNT
 157      * here. They both treat full width ascii characters as case senstive
 158      * filenames (ie. they don't do the work we do here).
 159      * JRA.
 160      */
 161
 162     if (lp_client_code_page () == KANJI_CODEPAGE)
 163     {
 164         /* Win95 treats full width ascii characters as case sensitive. */
 165         int diff;
 166         for (;;)
 167         {
 168             if (!*s || !*t)
 169                 return toupper (*s) - toupper (*t);
 170             else if (is_sj_alph (*s) && is_sj_alph (*t))
 171             {
 172                 diff = sj_toupper2 (*(s + 1)) - sj_toupper2 (*(t + 1));
 173                 if (diff)
 174                     return diff;
 175                 s += 2;
 176                 t += 2;
 177             }
 178             else if (is_shift_jis (*s) && is_shift_jis (*t))
 179             {
 180                 diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
 181                 if (diff)
 182                     return diff;
 183                 diff = ((int) (unsigned char) *(s + 1)) - ((int) (unsigned char) *(t + 1));
 184                 if (diff)
 185                     return diff;
 186                 s += 2;
 187                 t += 2;
 188             }
 189             else if (is_shift_jis (*s))
 190                 return 1;
 191             else if (is_shift_jis (*t))
 192                 return -1;
 193             else
 194             {
 195                 diff = toupper (*s) - toupper (*t);
 196                 if (diff)
 197                     return diff;
 198                 s++;
 199                 t++;
 200             }
 201         }
 202     }
 203     else
 204 #endif /* KANJI_WIN95_COMPATIBILITY */
 205     {
 206         while (*s && *t && toupper (*s) == toupper (*t))
 207         {
 208             s++;
 209             t++;
 210         }
 211
 212         return (toupper (*s) - toupper (*t));
 213     }
 214 }
 215
 216 /*******************************************************************
 217   case insensitive string compararison, length limited
 218 ********************************************************************/
 219 int
 220 StrnCaseCmp (const char *s, const char *t, size_t n)
 221 {
 222     /* compare until we run out of string, either t or s, or chars */
 223     /* We *must* use toupper rather than tolower here due to the
 224        asynchronous upper to lower mapping.
 225      */
 226 #if !defined(KANJI_WIN95_COMPATIBILITY)
 227     /*
 228      * For completeness we should put in equivalent code for code pages
 229      * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 230      * doubt anyone wants Samba to behave differently from Win95 and WinNT
 231      * here. They both treat full width ascii characters as case senstive
 232      * filenames (ie. they don't do the work we do here).
 233      * JRA.
 234      */
 235
 236     if (lp_client_code_page () == KANJI_CODEPAGE)
 237     {
 238         /* Win95 treats full width ascii characters as case sensitive. */
 239         int diff;
 240         for (; n > 0;)
 241         {
 242             if (!*s || !*t)
 243                 return toupper (*s) - toupper (*t);
 244             else if (is_sj_alph (*s) && is_sj_alph (*t))
 245             {
 246                 diff = sj_toupper2 (*(s + 1)) - sj_toupper2 (*(t + 1));
 247                 if (diff)
 248                     return diff;
 249                 s += 2;
 250                 t += 2;
 251                 n -= 2;
 252             }
 253             else if (is_shift_jis (*s) && is_shift_jis (*t))
 254             {
 255                 diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
 256                 if (diff)
 257                     return diff;
 258                 diff = ((int) (unsigned char) *(s + 1)) - ((int) (unsigned char) *(t + 1));
 259                 if (diff)
 260                     return diff;
 261                 s += 2;
 262                 t += 2;
 263                 n -= 2;
 264             }
 265             else if (is_shift_jis (*s))
 266                 return 1;
 267             else if (is_shift_jis (*t))
 268                 return -1;
 269             else
 270             {
 271                 diff = toupper (*s) - toupper (*t);
 272                 if (diff)
 273                     return diff;
 274                 s++;
 275                 t++;
 276                 n--;
 277             }
 278         }
 279         return 0;
 280     }
 281     else
 282 #endif /* KANJI_WIN95_COMPATIBILITY */
 283     {
 284         while (n && *s && *t && toupper (*s) == toupper (*t))
 285         {
 286             s++;
 287             t++;
 288             n--;
 289         }
 290
 291         /* not run out of chars - strings are different lengths */
 292         if (n)
 293             return (toupper (*s) - toupper (*t));
 294
 295         /* identical up to where we run out of chars,
 296            and strings are same length */
 297         return (0);
 298     }
 299 }
 300
 301 /*******************************************************************
 302   compare 2 strings
 303 ********************************************************************/
 304 BOOL
 305 strequal (const char *s1, const char *s2)
 306 {
 307     if (s1 == s2)
 308         return (True);
 309     if (!s1 || !s2)
 310         return (False);
 311
 312     return (StrCaseCmp (s1, s2) == 0);
 313 }
 314
 315 /*******************************************************************
 316   compare 2 strings up to and including the nth char.
 317   ******************************************************************/
 318 BOOL
 319 strnequal (const char *s1, const char *s2, size_t n)
 320 {
 321     if (s1 == s2)
 322         return (True);
 323     if (!s1 || !s2 || !n)
 324         return (False);
 325
 326     return (StrnCaseCmp (s1, s2, n) == 0);
 327 }
 328
 329 /*******************************************************************
 330   compare 2 strings (case sensitive)
 331 ********************************************************************/
 332 BOOL
 333 strcsequal (const char *s1, const char *s2)
 334 {
 335     if (s1 == s2)
 336         return (True);
 337     if (!s1 || !s2)
 338         return (False);
 339
 340     return (strcmp (s1, s2) == 0);
 341 }
 342
 343
 344 /*******************************************************************
 345   convert a string to lower case
 346 ********************************************************************/
 347 void
 348 strlower (char *s)
 349 {
 350     while (*s)
 351     {
 352 #if !defined(KANJI_WIN95_COMPATIBILITY)
 353         /*
 354          * For completeness we should put in equivalent code for code pages
 355          * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 356          * doubt anyone wants Samba to behave differently from Win95 and WinNT
 357          * here. They both treat full width ascii characters as case senstive
 358          * filenames (ie. they don't do the work we do here).
 359          * JRA.
 360          */
 361
 362         if (lp_client_code_page () == KANJI_CODEPAGE)
 363         {
 364             /* Win95 treats full width ascii characters as case sensitive. */
 365             if (is_shift_jis (*s))
 366             {
 367                 if (is_sj_upper (s[0], s[1]))
 368                     s[1] = sj_tolower2 (s[1]);
 369                 s += 2;
 370             }
 371             else if (is_kana (*s))
 372             {
 373                 s++;
 374             }
 375             else
 376             {
 377                 if (isupper (*s))
 378                     *s = tolower (*s);
 379                 s++;
 380             }
 381         }
 382         else
 383 #endif /* KANJI_WIN95_COMPATIBILITY */
 384         {
 385             size_t skip = skip_multibyte_char (*s);
 386             if (skip != 0)
 387                 s += skip;
 388             else
 389             {
 390                 if (isupper (*s))
 391                     *s = tolower (*s);
 392                 s++;
 393             }
 394         }
 395     }
 396 }
 397
 398 /*******************************************************************
 399   convert a string to upper case
 400 ********************************************************************/
 401 void
 402 strupper (char *s)
 403 {
 404     while (*s)
 405     {
 406 #if !defined(KANJI_WIN95_COMPATIBILITY)
 407         /*
 408          * For completeness we should put in equivalent code for code pages
 409          * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 410          * doubt anyone wants Samba to behave differently from Win95 and WinNT
 411          * here. They both treat full width ascii characters as case senstive
 412          * filenames (ie. they don't do the work we do here).
 413          * JRA.
 414          */
 415
 416         if (lp_client_code_page () == KANJI_CODEPAGE)
 417         {
 418             /* Win95 treats full width ascii characters as case sensitive. */
 419             if (is_shift_jis (*s))
 420             {
 421                 if (is_sj_lower (s[0], s[1]))
 422                     s[1] = sj_toupper2 (s[1]);
 423                 s += 2;
 424             }
 425             else if (is_kana (*s))
 426             {
 427                 s++;
 428             }
 429             else
 430             {
 431                 if (islower (*s))
 432                     *s = toupper (*s);
 433                 s++;
 434             }
 435         }
 436         else
 437 #endif /* KANJI_WIN95_COMPATIBILITY */
 438         {
 439             size_t skip = skip_multibyte_char (*s);
 440             if (skip != 0)
 441                 s += skip;
 442             else
 443             {
 444                 if (islower (*s))
 445                     *s = toupper (*s);
 446                 s++;
 447             }
 448         }
 449     }
 450 }
 451
 452 #if 0
 453 /*******************************************************************
 454   convert a string to "normal" form
 455 ********************************************************************/
 456 void
 457 strnorm (char *s)
 458 {
 459     extern int case_default;
 460     if (case_default == CASE_UPPER)
 461         strupper (s);
 462     else
 463         strlower (s);
 464 }
 465
 466 /*******************************************************************
 467 check if a string is in "normal" case
 468 ********************************************************************/
 469 BOOL
 470 strisnormal (char *s)
 471 {
 472     extern int case_default;
 473     if (case_default == CASE_UPPER)
 474         return (!strhaslower (s));
 475
 476     return (!strhasupper (s));
 477 }
 478 #endif /* 0 */
 479
 480 /****************************************************************************
 481   string replace
 482 ****************************************************************************/
 483 void
 484 string_replace (char *s, char oldc, char newc)
 485 {
 486     size_t skip;
 487     while (*s)
 488     {
 489         skip = skip_multibyte_char (*s);
 490         if (skip != 0)
 491             s += skip;
 492         else
 493         {
 494             if (oldc == *s)
 495                 *s = newc;
 496             s++;
 497         }
 498     }
 499 }
 500
 501
 502 /*******************************************************************
 503 skip past some strings in a buffer
 504 ********************************************************************/
 505 char *
 506 skip_string (char *buf, size_t n)
 507 {
 508     while (n--)
 509         buf += strlen (buf) + 1;
 510     return (buf);
 511 }
 512
 513 /*******************************************************************
 514  Count the number of characters in a string. Normally this will
 515  be the same as the number of bytes in a string for single byte strings,
 516  but will be different for multibyte.
 517  16.oct.98, jdblair@cobaltnet.com.
 518 ********************************************************************/
 519
 520 size_t
 521 str_charnum (const char *s)
 522 {
 523     size_t len = 0;
 524
 525     while (*s != '\0')
 526     {
 527         int skip = skip_multibyte_char (*s);
 528         s += (skip ? skip : 1);
 529         len++;
 530     }
 531     return len;
 532 }
 533
 534 /*******************************************************************
 535 trim the specified elements off the front and back of a string
 536 ********************************************************************/
 537
 538 BOOL
 539 trim_string (char *s, const char *front, const char *back)
 540 {
 541     BOOL ret = False;
 542     size_t front_len = (front && *front) ? strlen (front) : 0;
 543     size_t back_len = (back && *back) ? strlen (back) : 0;
 544     size_t s_len;
 545
 546     while (front_len && strncmp (s, front, front_len) == 0)
 547     {
 548         char *p = s;
 549         ret = True;
 550         while (1)
 551         {
 552             if (!(*p = p[front_len]))
 553                 break;
 554             p++;
 555         }
 556     }
 557
 558     /*
 559      * We split out the multibyte code page
 560      * case here for speed purposes. Under a
 561      * multibyte code page we need to walk the
 562      * string forwards only and multiple times.
 563      * Thanks to John Blair for finding this
 564      * one. JRA.
 565      */
 566
 567     if (back_len)
 568     {
 569         if (!is_multibyte_codepage ())
 570         {
 571             s_len = strlen (s);
 572             while ((s_len >= back_len) && (strncmp (s + s_len - back_len, back, back_len) == 0))
 573             {
 574                 ret = True;
 575                 s[s_len - back_len] = '\0';
 576                 s_len = strlen (s);
 577             }
 578         }
 579         else
 580         {
 581
 582             /*
 583              * Multibyte code page case.
 584              * Keep going through the string, trying
 585              * to match the 'back' string with the end
 586              * of the string. If we get a match, truncate
 587              * 'back' off the end of the string and
 588              * go through the string again from the
 589              * start. Keep doing this until we have
 590              * gone through the string with no match
 591              * at the string end.
 592              */
 593
 594             size_t mb_back_len = str_charnum (back);
 595             size_t mb_s_len = str_charnum (s);
 596
 597             while (mb_s_len >= mb_back_len)
 598             {
 599                 size_t charcount = 0;
 600                 char *mbp = s;
 601
 602                 while (charcount < (mb_s_len - mb_back_len))
 603                 {
 604                     size_t skip = skip_multibyte_char (*mbp);
 605                     mbp += (skip ? skip : 1);
 606                     charcount++;
 607                 }
 608
 609                 /*
 610                  * mbp now points at mb_back_len multibyte
 611                  * characters from the end of s.
 612                  */
 613
 614                 if (strcmp (mbp, back) == 0)
 615                 {
 616                     ret = True;
 617                     *mbp = '\0';
 618                     mb_s_len = str_charnum (s);
 619                     mbp = s;
 620                 }
 621                 else
 622                     break;
 623             }                   /* end while mb_s_len... */
 624         }                       /* end else .. */
 625     }                           /* end if back_len .. */
 626
 627     return (ret);
 628 }
 629
 630 #if 0
 631 /****************************************************************************
 632 does a string have any uppercase chars in it?
 633 ****************************************************************************/
 634 BOOL
 635 strhasupper (const char *s)
 636 {
 637     while (*s)
 638     {
 639 #if !defined(KANJI_WIN95_COMPATIBILITY)
 640         /*
 641          * For completeness we should put in equivalent code for code pages
 642          * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 643          * doubt anyone wants Samba to behave differently from Win95 and WinNT
 644          * here. They both treat full width ascii characters as case senstive
 645          * filenames (ie. they don't do the work we do here).
 646          * JRA.
 647          */
 648
 649         if (lp_client_code_page () == KANJI_CODEPAGE)
 650         {
 651             /* Win95 treats full width ascii characters as case sensitive. */
 652             if (is_shift_jis (*s))
 653                 s += 2;
 654             else if (is_kana (*s))
 655                 s++;
 656             else
 657             {
 658                 if (isupper (*s))
 659                     return (True);
 660                 s++;
 661             }
 662         }
 663         else
 664 #endif /* KANJI_WIN95_COMPATIBILITY */
 665         {
 666             size_t skip = skip_multibyte_char (*s);
 667             if (skip != 0)
 668                 s += skip;
 669             else
 670             {
 671                 if (isupper (*s))
 672                     return (True);
 673                 s++;
 674             }
 675         }
 676     }
 677     return (False);
 678 }
 679
 680
 681 /****************************************************************************
 682 does a string have any lowercase chars in it?
 683 ****************************************************************************/
 684 BOOL
 685 strhaslower (const char *s)
 686 {
 687     while (*s)
 688     {
 689 #if !defined(KANJI_WIN95_COMPATIBILITY)
 690         /*
 691          * For completeness we should put in equivalent code for code pages
 692          * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 693          * doubt anyone wants Samba to behave differently from Win95 and WinNT
 694          * here. They both treat full width ascii characters as case senstive
 695          * filenames (ie. they don't do the work we do here).
 696          * JRA.
 697          */
 698
 699         if (lp_client_code_page () == KANJI_CODEPAGE)
 700         {
 701             /* Win95 treats full width ascii characters as case sensitive. */
 702             if (is_shift_jis (*s))
 703             {
 704                 if (is_sj_upper (s[0], s[1]))
 705                     return (True);
 706                 if (is_sj_lower (s[0], s[1]))
 707                     return (True);
 708                 s += 2;
 709             }
 710             else if (is_kana (*s))
 711             {
 712                 s++;
 713             }
 714             else
 715             {
 716                 if (islower (*s))
 717                     return (True);
 718                 s++;
 719             }
 720         }
 721         else
 722 #endif /* KANJI_WIN95_COMPATIBILITY */
 723         {
 724             size_t skip = skip_multibyte_char (*s);
 725             if (skip != 0)
 726                 s += skip;
 727             else
 728             {
 729                 if (islower (*s))
 730                     return (True);
 731                 s++;
 732             }
 733         }
 734     }
 735     return (False);
 736 }
 737 #endif /*0 */
 738
 739 /****************************************************************************
 740 find the number of chars in a string
 741 ****************************************************************************/
 742 size_t
 743 count_chars (const char *s, char c)
 744 {
 745     size_t count = 0;
 746
 747 #if !defined(KANJI_WIN95_COMPATIBILITY)
 748     /*
 749      * For completeness we should put in equivalent code for code pages
 750      * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
 751      * doubt anyone wants Samba to behave differently from Win95 and WinNT
 752      * here. They both treat full width ascii characters as case senstive
 753      * filenames (ie. they don't do the work we do here).
 754      * JRA.
 755      */
 756
 757     if (lp_client_code_page () == KANJI_CODEPAGE)
 758     {
 759         /* Win95 treats full width ascii characters as case sensitive. */
 760         while (*s)
 761         {
 762             if (is_shift_jis (*s))
 763                 s += 2;
 764             else
 765             {
 766                 if (*s == c)
 767                     count++;
 768                 s++;
 769             }
 770         }
 771     }
 772     else
 773 #endif /* KANJI_WIN95_COMPATIBILITY */
 774     {
 775         while (*s)
 776         {
 777             size_t skip = skip_multibyte_char (*s);
 778             if (skip != 0)
 779                 s += skip;
 780             else
 781             {
 782                 if (*s == c)
 783                     count++;
 784                 s++;
 785             }
 786         }
 787     }
 788     return (count);
 789 }
 790
 791
 792
 793 /*******************************************************************
 794 safe string copy into a known length string. maxlength does not
 795 include the terminating zero.
 796 ********************************************************************/
 797 char *
 798 safe_strcpy (char *dest, const char *src, size_t maxlength)
 799 {
 800     size_t len;
 801
 802     if (!dest)
 803     {
 804         DEBUG (0, ("ERROR: NULL dest in safe_strcpy\n"));
 805         return NULL;
 806     }
 807
 808     if (!src)
 809     {
 810         *dest = 0;
 811         return dest;
 812     }
 813
 814     len = strlen (src);
 815
 816     if (len > maxlength)
 817     {
 818         DEBUG (0, ("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
 819                    (int) (len - maxlength), src));
 820         len = maxlength;
 821     }
 822
 823     memcpy (dest, src, len);
 824     dest[len] = 0;
 825     return dest;
 826 }
 827
 828 /*******************************************************************
 829 safe string cat into a string. maxlength does not
 830 include the terminating zero.
 831 ********************************************************************/
 832 char *
 833 safe_strcat (char *dest, const char *src, size_t maxlength)
 834 {
 835     size_t src_len, dest_len;
 836
 837     if (!dest)
 838     {
 839         DEBUG (0, ("ERROR: NULL dest in safe_strcat\n"));
 840         return NULL;
 841     }
 842
 843     if (!src)
 844     {
 845         return dest;
 846     }
 847
 848     src_len = strlen (src);
 849     dest_len = strlen (dest);
 850
 851     if (src_len + dest_len > maxlength)
 852     {
 853         DEBUG (0, ("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
 854                    (int) (src_len + dest_len - maxlength), src));
 855         src_len = maxlength - dest_len;
 856     }
 857
 858     memcpy (&dest[dest_len], src, src_len);
 859     dest[dest_len + src_len] = 0;
 860     return dest;
 861 }
 862
 863 /****************************************************************************
 864 this is a safer strcpy(), meant to prevent core dumps when nasty things happen
 865 ****************************************************************************/
 866 char *
 867 StrCpy (char *dest, const char *src)
 868 {
 869     char *d = dest;
 870
 871     /* I don't want to get lazy with these ... */
 872     SMB_ASSERT (dest && src);
 873
 874     if (!dest)
 875         return (NULL);
 876     if (!src)
 877     {
 878         *dest = 0;
 879         return (dest);
 880     }
 881     while ((*d++ = *src++));
 882     return (dest);
 883 }
 884
 885 /****************************************************************************
 886 like strncpy but always null terminates. Make sure there is room!
 887 ****************************************************************************/
 888 char *
 889 StrnCpy (char *dest, const char *src, size_t n)
 890 {
 891     char *d = dest;
 892     if (!dest)
 893         return (NULL);
 894     if (!src)
 895     {
 896         *dest = 0;
 897         return (dest);
 898     }
 899     while (n-- && (*d++ = *src++));
 900     *d = 0;
 901     return (dest);
 902 }
 903
 904 #if 0
 905 /****************************************************************************
 906 like strncpy but copies up to the character marker.  always null terminates.
 907 returns a pointer to the character marker in the source string (src).
 908 ****************************************************************************/
 909 char *
 910 strncpyn (char *dest, const char *src, size_t n, char c)
 911 {
 912     char *p;
 913     size_t str_len;
 914
 915     p = strchr (src, c);
 916     if (p == NULL)
 917     {
 918         DEBUG (5, ("strncpyn: separator character (%c) not found\n", c));
 919         return NULL;
 920     }
 921
 922     str_len = PTR_DIFF (p, src);
 923     strncpy (dest, src, MIN (n, str_len));
 924     dest[str_len] = '\0';
 925
 926     return p;
 927 }
 928
 929
 930 /*************************************************************
 931  Routine to get hex characters and turn them into a 16 byte array.
 932  the array can be variable length, and any non-hex-numeric
 933  characters are skipped.  "0xnn" or "0Xnn" is specially catered
 934  for.
 935
 936  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
 937
 938 **************************************************************/
 939 size_t
 940 strhex_to_str (char *p, size_t len, const char *strhex)
 941 {
 942     size_t i;
 943     size_t num_chars = 0;
 944     unsigned char lonybble, hinybble;
 945     char *hexchars = "0123456789ABCDEF";
 946     char *p1 = NULL, *p2 = NULL;
 947
 948     for (i = 0; i < len && strhex[i] != 0; i++)
 949     {
 950         if (strnequal (hexchars, "0x", 2))
 951         {
 952             i++;                /* skip two chars */
 953             continue;
 954         }
 955
 956         if (!(p1 = strchr (hexchars, toupper (strhex[i]))))
 957         {
 958             break;
 959         }
 960
 961         i++;                    /* next hex digit */
 962
 963         if (!(p2 = strchr (hexchars, toupper (strhex[i]))))
 964         {
 965             break;
 966         }
 967
 968         /* get the two nybbles */
 969         hinybble = PTR_DIFF (p1, hexchars);
 970         lonybble = PTR_DIFF (p2, hexchars);
 971
 972         p[num_chars] = (hinybble << 4) | lonybble;
 973         num_chars++;
 974
 975         p1 = NULL;
 976         p2 = NULL;
 977     }
 978     return num_chars;
 979 }
 980
 981 /****************************************************************************
 982 check if a string is part of a list
 983 ****************************************************************************/
 984 BOOL
 985 in_list (char *s, char *list, BOOL casesensitive)
 986 {
 987     pstring tok;
 988     char *p = list;
 989
 990     if (!list)
 991         return (False);
 992
 993     while (next_token (&p, tok, LIST_SEP, sizeof (tok)))
 994     {
 995         if (casesensitive)
 996         {
 997             if (strcmp (tok, s) == 0)
 998                 return (True);
 999         }
1000         else
1001         {
1002             if (StrCaseCmp (tok, s) == 0)
1003                 return (True);
1004         }
1005     }
1006     return (False);
1007 }
1008 #endif /*0 */
1009
1010 /* this is used to prevent lots of mallocs of size 1 */
1011 static char *null_string = NULL;
1012
1013 /****************************************************************************
1014 set a string value, allocing the space for the string
1015 ****************************************************************************/
1016 BOOL
1017 string_init (char **dest, const char *src)
1018 {
1019     size_t l;
1020     if (!src)
1021         src = "";
1022
1023     l = strlen (src);
1024
1025     if (l == 0)
1026     {
1027         if (!null_string)
1028         {
1029             if ((null_string = (char *) malloc (1)) == NULL)
1030             {
1031                 DEBUG (0, ("string_init: malloc fail for null_string.\n"));
1032                 return False;
1033             }
1034             *null_string = 0;
1035         }
1036         *dest = null_string;
1037     }
1038     else
1039     {
1040         (*dest) = (char *) malloc (l + 1);
1041         if ((*dest) == NULL)
1042         {
1043             DEBUG (0, ("Out of memory in string_init\n"));
1044             return False;
1045         }
1046
1047         pstrcpy (*dest, src);
1048     }
1049     return (True);
1050 }
1051
1052 /****************************************************************************
1053 free a string value
1054 ****************************************************************************/
1055 void
1056 string_free (char **s)
1057 {
1058     if (!s || !(*s))
1059         return;
1060     if (*s == null_string)
1061         *s = NULL;
1062     if (*s)
1063         free (*s);
1064     *s = NULL;
1065 }
1066
1067 /****************************************************************************
1068 set a string value, allocing the space for the string, and deallocating any
1069 existing space
1070 ****************************************************************************/
1071 BOOL
1072 string_set (char **dest, const char *src)
1073 {
1074     string_free (dest);
1075
1076     return (string_init (dest, src));
1077 }
1078
1079
1080 /****************************************************************************
1081 substitute a string for a pattern in another string. Make sure there is
1082 enough room!
1083
1084 This routine looks for pattern in s and replaces it with
1085 insert. It may do multiple replacements.
1086
1087 any of " ; ' or ` in the insert string are replaced with _
1088 ****************************************************************************/
1089 void
1090 string_sub (char *s, const char *pattern, const char *insert)
1091 {
1092     char *p;
1093     size_t ls, lp, li, i;
1094
1095     if (!insert || !pattern || !s)
1096         return;
1097
1098     ls = strlen (s);
1099     lp = strlen (pattern);
1100     li = strlen (insert);
1101
1102     if (!*pattern)
1103         return;
1104
1105     while (lp <= ls && (p = strstr (s, pattern)))
1106     {
1107         memmove (p + li, p + lp, ls + 1 - (PTR_DIFF (p, s) + lp));
1108         for (i = 0; i < li; i++)
1109         {
1110             switch (insert[i])
1111             {
1112             case '`':
1113             case '"':
1114             case '\'':
1115             case ';':
1116                 p[i] = '_';
1117                 break;
1118             default:
1119                 p[i] = insert[i];
1120             }
1121         }
1122         s = p + li;
1123         ls += (li - lp);
1124     }
1125 }
1126
1127 #if 0
1128 /****************************************************************************
1129 similar to string_sub() but allows for any character to be substituted.
1130 Use with caution!
1131 ****************************************************************************/
1132 void
1133 all_string_sub (char *s, const char *pattern, const char *insert)
1134 {
1135     char *p;
1136     size_t ls, lp, li;
1137
1138     if (!insert || !pattern || !s)
1139         return;
1140
1141     ls = strlen (s);
1142     lp = strlen (pattern);
1143     li = strlen (insert);
1144
1145     if (!*pattern)
1146         return;
1147
1148     while (lp <= ls && (p = strstr (s, pattern)))
1149     {
1150         memmove (p + li, p + lp, ls + 1 - (PTR_DIFF (p, s) + lp));
1151         memcpy (p, insert, li);
1152         s = p + li;
1153         ls += (li - lp);
1154     }
1155 }
1156
1157
1158 /****************************************************************************
1159  splits out the front and back at a separator.
1160 ****************************************************************************/
1161 void
1162 split_at_last_component (char *path, char *front, char sep, char *back)
1163 {
1164     char *p = strrchr (path, sep);
1165
1166     if (p != NULL)
1167     {
1168         *p = 0;
1169     }
1170     if (front != NULL)
1171     {
1172         pstrcpy (front, path);
1173     }
1174     if (p != NULL)
1175     {
1176         if (back != NULL)
1177         {
1178             pstrcpy (back, p + 1);
1179         }
1180         *p = '\\';
1181     }
1182     else
1183     {
1184         if (back != NULL)
1185         {
1186             back[0] = 0;
1187         }
1188     }
1189 }
1190 #endif /*0 */