source3/lib/util_str.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Andrew Tridgell 1992-2001
   6    Copyright (C) Simo Sorce      2001-2002
   7    Copyright (C) Martin Pool     2003
   8    Copyright (C) James Peach     2006
   9    Copyright (C) Jeremy Allison  1992-2007
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26
  27 /**
  28  * @file
  29  * @brief String utilities.
  30  **/
  31
  32 /**
  33  * Internal function to get the next token from a string, return false if none
  34  * found.  Handles double-quotes.  This is the work horse function called by
  35  * next_token() and next_token_no_ltrim().
  36  *
  37  * Based on a routine by GJC@VILLAGE.COM.
  38  * Extensively modified by Andrew.Tridgell@anu.edu.au
  39  */
  40 static bool next_token_internal(const char **ptr,
  41                                 char *buff,
  42                                 const char *sep,
  43                                 size_t bufsize,
  44                                 bool ltrim)
  45 {
  46         char *s;
  47         char *pbuf;
  48         bool quoted;
  49         size_t len=1;
  50
  51         if (!ptr)
  52                 return(false);
  53
  54         s = (char *)*ptr;
  55
  56         /* default to simple separators */
  57         if (!sep)
  58                 sep = " \t\n\r";
  59
  60         /* find the first non sep char, if left-trimming is requested */
  61         if (ltrim) {
  62                 while (*s && strchr_m(sep,*s))
  63                         s++;
  64         }
  65
  66         /* nothing left? */
  67         if (! *s)
  68                 return(false);
  69
  70         /* copy over the token */
  71         pbuf = buff;
  72         for (quoted = false; len < bufsize && *s &&
  73                         (quoted || !strchr_m(sep,*s)); s++) {
  74                 if ( *s == '\"' ) {
  75                         quoted = !quoted;
  76                 } else {
  77                         len++;
  78                         *pbuf++ = *s;
  79                 }
  80         }
  81
  82         *ptr = (*s) ? s+1 : s;
  83         *pbuf = 0;
  84
  85         return(true);
  86 }
  87
  88 /*
  89  * Get the next token from a string, return false if none found.  Handles
  90  * double-quotes.  This version trims leading separator characters before
  91  * looking for a token.
  92  */
  93 bool next_token(const char **ptr, char *buff, const char *sep, size_t bufsize)
  94 {
  95     return next_token_internal(ptr, buff, sep, bufsize, true);
  96 }
  97
  98 /*
  99  * Get the next token from a string, return false if none found.  Handles
 100  * double-quotes.  This version does not trim leading separator characters
 101  * before looking for a token.
 102  */
 103 bool next_token_no_ltrim(const char **ptr,
 104                          char *buff,
 105                          const char *sep,
 106                          size_t bufsize)
 107 {
 108     return next_token_internal(ptr, buff, sep, bufsize, false);
 109 }
 110
 111 /**
 112 This is like next_token but is not re-entrant and "remembers" the first
 113 parameter so you can pass NULL. This is useful for user interface code
 114 but beware the fact that it is not re-entrant!
 115 **/
 116
 117 static const char *last_ptr=NULL;
 118
 119 bool next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
 120 {
 121         bool ret;
 122         if (!ptr)
 123                 ptr = &last_ptr;
 124
 125         ret = next_token(ptr, buff, sep, bufsize);
 126         last_ptr = *ptr;
 127         return ret;
 128 }
 129
 130 void set_first_token(char *ptr)
 131 {
 132         last_ptr = ptr;
 133 }
 134
 135 /**
 136  Convert list of tokens to array; dependent on above routine.
 137  Uses last_ptr from above - bit of a hack.
 138 **/
 139
 140 char **toktocliplist(int *ctok, const char *sep)
 141 {
 142         char *s=(char *)last_ptr;
 143         int ictok=0;
 144         char **ret, **iret;
 145
 146         if (!sep)
 147                 sep = " \t\n\r";
 148
 149         while(*s && strchr_m(sep,*s))
 150                 s++;
 151
 152         /* nothing left? */
 153         if (!*s)
 154                 return(NULL);
 155
 156         do {
 157                 ictok++;
 158                 while(*s && (!strchr_m(sep,*s)))
 159                         s++;
 160                 while(*s && strchr_m(sep,*s))
 161                         *s++=0;
 162         } while(*s);
 163
 164         *ctok=ictok;
 165         s=(char *)last_ptr;
 166
 167         if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
 168                 return NULL;
 169
 170         while(ictok--) {
 171                 *iret++=s;
 172                 if (ictok > 0) {
 173                         while(*s++)
 174                                 ;
 175                         while(!*s)
 176                                 s++;
 177                 }
 178         }
 179
 180         ret[*ctok] = NULL;
 181         return ret;
 182 }
 183
 184 /**
 185  * Case insensitive string compararison.
 186  *
 187  * iconv does not directly give us a way to compare strings in
 188  * arbitrary unix character sets -- all we can is convert and then
 189  * compare.  This is expensive.
 190  *
 191  * As an optimization, we do a first pass that considers only the
 192  * prefix of the strings that is entirely 7-bit.  Within this, we
 193  * check whether they have the same value.
 194  *
 195  * Hopefully this will often give the answer without needing to copy.
 196  * In particular it should speed comparisons to literal ascii strings
 197  * or comparisons of strings that are "obviously" different.
 198  *
 199  * If we find a non-ascii character we fall back to converting via
 200  * iconv.
 201  *
 202  * This should never be slower than convering the whole thing, and
 203  * often faster.
 204  *
 205  * A different optimization would be to compare for bitwise equality
 206  * in the binary encoding.  (It would be possible thought hairy to do
 207  * both simultaneously.)  But in that case if they turn out to be
 208  * different, we'd need to restart the whole thing.
 209  *
 210  * Even better is to implement strcasecmp for each encoding and use a
 211  * function pointer.
 212  **/
 213 int StrCaseCmp(const char *s, const char *t)
 214 {
 215
 216         const char *ps, *pt;
 217         size_t size;
 218         smb_ucs2_t *buffer_s, *buffer_t;
 219         int ret;
 220
 221         for (ps = s, pt = t; ; ps++, pt++) {
 222                 char us, ut;
 223
 224                 if (!*ps && !*pt)
 225                         return 0; /* both ended */
 226                 else if (!*ps)
 227                         return -1; /* s is a prefix */
 228                 else if (!*pt)
 229                         return +1; /* t is a prefix */
 230                 else if ((*ps & 0x80) || (*pt & 0x80))
 231                         /* not ascii anymore, do it the hard way
 232                          * from here on in */
 233                         break;
 234
 235                 us = toupper_ascii(*ps);
 236                 ut = toupper_ascii(*pt);
 237                 if (us == ut)
 238                         continue;
 239                 else if (us < ut)
 240                         return -1;
 241                 else if (us > ut)
 242                         return +1;
 243         }
 244
 245         size = push_ucs2_allocate(&buffer_s, ps);
 246         if (size == (size_t)-1) {
 247                 return strcmp(ps, pt);
 248                 /* Not quite the right answer, but finding the right one
 249                    under this failure case is expensive, and it's pretty
 250                    close */
 251         }
 252
 253         size = push_ucs2_allocate(&buffer_t, pt);
 254         if (size == (size_t)-1) {
 255                 SAFE_FREE(buffer_s);
 256                 return strcmp(ps, pt);
 257                 /* Not quite the right answer, but finding the right one
 258                    under this failure case is expensive, and it's pretty
 259                    close */
 260         }
 261
 262         ret = strcasecmp_w(buffer_s, buffer_t);
 263         SAFE_FREE(buffer_s);
 264         SAFE_FREE(buffer_t);
 265         return ret;
 266 }
 267
 268
 269 /**
 270  Case insensitive string compararison, length limited.
 271 **/
 272 int StrnCaseCmp(const char *s, const char *t, size_t len)
 273 {
 274         size_t n = 0;
 275         const char *ps, *pt;
 276         size_t size;
 277         smb_ucs2_t *buffer_s, *buffer_t;
 278         int ret;
 279
 280         for (ps = s, pt = t; n < len ; ps++, pt++, n++) {
 281                 char us, ut;
 282
 283                 if (!*ps && !*pt)
 284                         return 0; /* both ended */
 285                 else if (!*ps)
 286                         return -1; /* s is a prefix */
 287                 else if (!*pt)
 288                         return +1; /* t is a prefix */
 289                 else if ((*ps & 0x80) || (*pt & 0x80))
 290                         /* not ascii anymore, do it the
 291                          * hard way from here on in */
 292                         break;
 293
 294                 us = toupper_ascii(*ps);
 295                 ut = toupper_ascii(*pt);
 296                 if (us == ut)
 297                         continue;
 298                 else if (us < ut)
 299                         return -1;
 300                 else if (us > ut)
 301                         return +1;
 302         }
 303
 304         if (n == len) {
 305                 return 0;
 306         }
 307
 308         size = push_ucs2_allocate(&buffer_s, ps);
 309         if (size == (size_t)-1) {
 310                 return strncmp(ps, pt, len-n);
 311                 /* Not quite the right answer, but finding the right one
 312                    under this failure case is expensive,
 313                    and it's pretty close */
 314         }
 315
 316         size = push_ucs2_allocate(&buffer_t, pt);
 317         if (size == (size_t)-1) {
 318                 SAFE_FREE(buffer_s);
 319                 return strncmp(ps, pt, len-n);
 320                 /* Not quite the right answer, but finding the right one
 321                    under this failure case is expensive,
 322                    and it's pretty close */
 323         }
 324
 325         ret = strncasecmp_w(buffer_s, buffer_t, len-n);
 326         SAFE_FREE(buffer_s);
 327         SAFE_FREE(buffer_t);
 328         return ret;
 329 }
 330
 331 /**
 332  * Compare 2 strings.
 333  *
 334  * @note The comparison is case-insensitive.
 335  **/
 336 bool strequal(const char *s1, const char *s2)
 337 {
 338         if (s1 == s2)
 339                 return(true);
 340         if (!s1 || !s2)
 341                 return(false);
 342
 343         return(StrCaseCmp(s1,s2)==0);
 344 }
 345
 346 /**
 347  * Compare 2 strings up to and including the nth char.
 348  *
 349  * @note The comparison is case-insensitive.
 350  **/
 351 bool strnequal(const char *s1,const char *s2,size_t n)
 352 {
 353         if (s1 == s2)
 354                 return(true);
 355         if (!s1 || !s2 || !n)
 356                 return(false);
 357
 358         return(StrnCaseCmp(s1,s2,n)==0);
 359 }
 360
 361 /**
 362  Compare 2 strings (case sensitive).
 363 **/
 364
 365 bool strcsequal(const char *s1,const char *s2)
 366 {
 367         if (s1 == s2)
 368                 return(true);
 369         if (!s1 || !s2)
 370                 return(false);
 371
 372         return(strcmp(s1,s2)==0);
 373 }
 374
 375 /**
 376 Do a case-insensitive, whitespace-ignoring string compare.
 377 **/
 378
 379 int strwicmp(const char *psz1, const char *psz2)
 380 {
 381         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 382         /* appropriate value. */
 383         if (psz1 == psz2)
 384                 return (0);
 385         else if (psz1 == NULL)
 386                 return (-1);
 387         else if (psz2 == NULL)
 388                 return (1);
 389
 390         /* sync the strings on first non-whitespace */
 391         while (1) {
 392                 while (isspace((int)*psz1))
 393                         psz1++;
 394                 while (isspace((int)*psz2))
 395                         psz2++;
 396                 if (toupper_ascii(*psz1) != toupper_ascii(*psz2) ||
 397                                 *psz1 == '\0' || *psz2 == '\0')
 398                         break;
 399                 psz1++;
 400                 psz2++;
 401         }
 402         return (*psz1 - *psz2);
 403 }
 404
 405
 406 /**
 407  Convert a string to upper case, but don't modify it.
 408 **/
 409
 410 char *strupper_static(const char *s)
 411 {
 412         static char *str = NULL;
 413
 414         SAFE_FREE(str);
 415         str = SMB_STRDUP(s);
 416         strupper_m(str);
 417         return str;
 418 }
 419
 420 /**
 421  Convert a string to "normal" form.
 422 **/
 423
 424 void strnorm(char *s, int case_default)
 425 {
 426         if (case_default == CASE_UPPER)
 427                 strupper_m(s);
 428         else
 429                 strlower_m(s);
 430 }
 431
 432 /**
 433  Check if a string is in "normal" case.
 434 **/
 435
 436 bool strisnormal(const char *s, int case_default)
 437 {
 438         if (case_default == CASE_UPPER)
 439                 return(!strhaslower(s));
 440
 441         return(!strhasupper(s));
 442 }
 443
 444
 445 /**
 446  String replace.
 447  NOTE: oldc and newc must be 7 bit characters
 448 **/
 449 void string_replace( char *s, char oldc, char newc )
 450 {
 451         char *p;
 452
 453         /* this is quite a common operation, so we want it to be
 454            fast. We optimise for the ascii case, knowing that all our
 455            supported multi-byte character sets are ascii-compatible
 456            (ie. they match for the first 128 chars) */
 457
 458         for (p = s; *p; p++) {
 459                 if (*p & 0x80) /* mb string - slow path. */
 460                         break;
 461                 if (*p == oldc) {
 462                         *p = newc;
 463                 }
 464         }
 465
 466         if (!*p)
 467                 return;
 468
 469         /* Slow (mb) path. */
 470 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
 471         /* With compose characters we must restart from the beginning. JRA. */
 472         p = s;
 473 #endif
 474
 475         while (*p) {
 476                 size_t c_size;
 477                 next_codepoint(p, &c_size);
 478
 479                 if (c_size == 1) {
 480                         if (*p == oldc) {
 481                                 *p = newc;
 482                         }
 483                 }
 484                 p += c_size;
 485         }
 486 }
 487
 488 /**
 489  *  Skip past some strings in a buffer - old version - no checks.
 490  *  **/
 491
 492 char *push_skip_string(char *buf)
 493 {
 494         buf += strlen(buf) + 1;
 495         return(buf);
 496 }
 497
 498 /**
 499  Skip past a string in a buffer. Buffer may not be
 500  null terminated. end_ptr points to the first byte after
 501  then end of the buffer.
 502 **/
 503
 504 char *skip_string(const char *base, size_t len, char *buf)
 505 {
 506         const char *end_ptr = base + len;
 507
 508         if (end_ptr < base || !base || !buf || buf >= end_ptr) {
 509                 return NULL;
 510         }
 511
 512         /* Skip the string */
 513         while (*buf) {
 514                 buf++;
 515                 if (buf >= end_ptr) {
 516                         return NULL;
 517                 }
 518         }
 519         /* Skip the '\0' */
 520         buf++;
 521         return buf;
 522 }
 523
 524 /**
 525  Count the number of characters in a string. Normally this will
 526  be the same as the number of bytes in a string for single byte strings,
 527  but will be different for multibyte.
 528 **/
 529
 530 size_t str_charnum(const char *s)
 531 {
 532         size_t ret;
 533         smb_ucs2_t *tmpbuf2 = NULL;
 534         if (push_ucs2_allocate(&tmpbuf2, s) == (size_t)-1) {
 535                 return 0;
 536         }
 537         ret = strlen_w(tmpbuf2);
 538         SAFE_FREE(tmpbuf2);
 539         return ret;
 540 }
 541
 542 /**
 543  Count the number of characters in a string. Normally this will
 544  be the same as the number of bytes in a string for single byte strings,
 545  but will be different for multibyte.
 546 **/
 547
 548 size_t str_ascii_charnum(const char *s)
 549 {
 550         size_t ret;
 551         char *tmpbuf2 = NULL;
 552         if (push_ascii_allocate(&tmpbuf2, s) == (size_t)-1) {
 553                 return 0;
 554         }
 555         ret = strlen(tmpbuf2);
 556         SAFE_FREE(tmpbuf2);
 557         return ret;
 558 }
 559
 560 bool trim_char(char *s,char cfront,char cback)
 561 {
 562         bool ret = false;
 563         char *ep;
 564         char *fp = s;
 565
 566         /* Ignore null or empty strings. */
 567         if (!s || (s[0] == '\0'))
 568                 return false;
 569
 570         if (cfront) {
 571                 while (*fp && *fp == cfront)
 572                         fp++;
 573                 if (!*fp) {
 574                         /* We ate the string. */
 575                         s[0] = '\0';
 576                         return true;
 577                 }
 578                 if (fp != s)
 579                         ret = true;
 580         }
 581
 582         ep = fp + strlen(fp) - 1;
 583         if (cback) {
 584                 /* Attempt ascii only. Bail for mb strings. */
 585                 while ((ep >= fp) && (*ep == cback)) {
 586                         ret = true;
 587                         if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
 588                                 /* Could be mb... bail back to tim_string. */
 589                                 char fs[2], bs[2];
 590                                 if (cfront) {
 591                                         fs[0] = cfront;
 592                                         fs[1] = '\0';
 593                                 }
 594                                 bs[0] = cback;
 595                                 bs[1] = '\0';
 596                                 return trim_string(s, cfront ? fs : NULL, bs);
 597                         } else {
 598                                 ep--;
 599                         }
 600                 }
 601                 if (ep < fp) {
 602                         /* We ate the string. */
 603                         s[0] = '\0';
 604                         return true;
 605                 }
 606         }
 607
 608         ep[1] = '\0';
 609         memmove(s, fp, ep-fp+2);
 610         return ret;
 611 }
 612
 613 /**
 614  Trim the specified elements off the front and back of a string.
 615 **/
 616
 617 bool trim_string(char *s,const char *front,const char *back)
 618 {
 619         bool ret = false;
 620         size_t front_len;
 621         size_t back_len;
 622         size_t len;
 623
 624         /* Ignore null or empty strings. */
 625         if (!s || (s[0] == '\0'))
 626                 return false;
 627
 628         front_len       = front? strlen(front) : 0;
 629         back_len        = back? strlen(back) : 0;
 630
 631         len = strlen(s);
 632
 633         if (front_len) {
 634                 while (len && strncmp(s, front, front_len)==0) {
 635                         /* Must use memmove here as src & dest can
 636                          * easily overlap. Found by valgrind. JRA. */
 637                         memmove(s, s+front_len, (len-front_len)+1);
 638                         len -= front_len;
 639                         ret=true;
 640                 }
 641         }
 642
 643         if (back_len) {
 644                 while ((len >= back_len) &&
 645                                 strncmp(s+len-back_len,back,back_len)==0) {
 646                         s[len-back_len]='\0';
 647                         len -= back_len;
 648                         ret=true;
 649                 }
 650         }
 651         return ret;
 652 }
 653
 654 /**
 655  Does a string have any uppercase chars in it?
 656 **/
 657
 658 bool strhasupper(const char *s)
 659 {
 660         smb_ucs2_t *tmp, *p;
 661         bool ret;
 662
 663         if (push_ucs2_allocate(&tmp, s) == -1) {
 664                 return false;
 665         }
 666
 667         for(p = tmp; *p != 0; p++) {
 668                 if(isupper_w(*p)) {
 669                         break;
 670                 }
 671         }
 672
 673         ret = (*p != 0);
 674         SAFE_FREE(tmp);
 675         return ret;
 676 }
 677
 678 /**
 679  Does a string have any lowercase chars in it?
 680 **/
 681
 682 bool strhaslower(const char *s)
 683 {
 684         smb_ucs2_t *tmp, *p;
 685         bool ret;
 686
 687         if (push_ucs2_allocate(&tmp, s) == -1) {
 688                 return false;
 689         }
 690
 691         for(p = tmp; *p != 0; p++) {
 692                 if(islower_w(*p)) {
 693                         break;
 694                 }
 695         }
 696
 697         ret = (*p != 0);
 698         SAFE_FREE(tmp);
 699         return ret;
 700 }
 701
 702 /**
 703  Find the number of 'c' chars in a string
 704 **/
 705
 706 size_t count_chars(const char *s,char c)
 707 {
 708         smb_ucs2_t *ptr;
 709         int count;
 710         smb_ucs2_t *alloc_tmpbuf = NULL;
 711
 712         if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
 713                 return 0;
 714         }
 715
 716         for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
 717                 if(*ptr==UCS2_CHAR(c))
 718                         count++;
 719
 720         SAFE_FREE(alloc_tmpbuf);
 721         return(count);
 722 }
 723
 724 /**
 725  Safe string copy into a known length string. maxlength does not
 726  include the terminating zero.
 727 **/
 728
 729 char *safe_strcpy_fn(const char *fn,
 730                 int line,
 731                 char *dest,
 732                 const char *src,
 733                 size_t maxlength)
 734 {
 735         size_t len;
 736
 737         if (!dest) {
 738                 DEBUG(0,("ERROR: NULL dest in safe_strcpy, "
 739                         "called from [%s][%d]\n", fn, line));
 740                 return NULL;
 741         }
 742
 743 #ifdef DEVELOPER
 744         clobber_region(fn,line,dest, maxlength+1);
 745 #endif
 746
 747         if (!src) {
 748                 *dest = 0;
 749                 return dest;
 750         }
 751
 752         len = strnlen(src, maxlength+1);
 753
 754         if (len > maxlength) {
 755                 DEBUG(0,("ERROR: string overflow by "
 756                         "%lu (%lu - %lu) in safe_strcpy [%.50s]\n",
 757                          (unsigned long)(len-maxlength), (unsigned long)len,
 758                          (unsigned long)maxlength, src));
 759                 len = maxlength;
 760         }
 761
 762         memmove(dest, src, len);
 763         dest[len] = 0;
 764         return dest;
 765 }
 766
 767 /**
 768  Safe string cat into a string. maxlength does not
 769  include the terminating zero.
 770 **/
 771 char *safe_strcat_fn(const char *fn,
 772                 int line,
 773                 char *dest,
 774                 const char *src,
 775                 size_t maxlength)
 776 {
 777         size_t src_len, dest_len;
 778
 779         if (!dest) {
 780                 DEBUG(0,("ERROR: NULL dest in safe_strcat, "
 781                         "called from [%s][%d]\n", fn, line));
 782                 return NULL;
 783         }
 784
 785         if (!src)
 786                 return dest;
 787
 788         src_len = strnlen(src, maxlength + 1);
 789         dest_len = strnlen(dest, maxlength + 1);
 790
 791 #ifdef DEVELOPER
 792         clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
 793 #endif
 794
 795         if (src_len + dest_len > maxlength) {
 796                 DEBUG(0,("ERROR: string overflow by %d "
 797                         "in safe_strcat [%.50s]\n",
 798                          (int)(src_len + dest_len - maxlength), src));
 799                 if (maxlength > dest_len) {
 800                         memcpy(&dest[dest_len], src, maxlength - dest_len);
 801                 }
 802                 dest[maxlength] = 0;
 803                 return NULL;
 804         }
 805
 806         memcpy(&dest[dest_len], src, src_len);
 807         dest[dest_len + src_len] = 0;
 808         return dest;
 809 }
 810
 811 /**
 812  Paranoid strcpy into a buffer of given length (includes terminating
 813  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 814  and replaces with '_'. Deliberately does *NOT* check for multibyte
 815  characters. Don't change it !
 816 **/
 817
 818 char *alpha_strcpy_fn(const char *fn,
 819                 int line,
 820                 char *dest,
 821                 const char *src,
 822                 const char *other_safe_chars,
 823                 size_t maxlength)
 824 {
 825         size_t len, i;
 826
 827 #ifdef DEVELOPER
 828         clobber_region(fn, line, dest, maxlength);
 829 #endif
 830
 831         if (!dest) {
 832                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, "
 833                         "called from [%s][%d]\n", fn, line));
 834                 return NULL;
 835         }
 836
 837         if (!src) {
 838                 *dest = 0;
 839                 return dest;
 840         }
 841
 842         len = strlen(src);
 843         if (len >= maxlength)
 844                 len = maxlength - 1;
 845
 846         if (!other_safe_chars)
 847                 other_safe_chars = "";
 848
 849         for(i = 0; i < len; i++) {
 850                 int val = (src[i] & 0xff);
 851                 if (isupper_ascii(val) || islower_ascii(val) ||
 852                                 isdigit(val) || strchr_m(other_safe_chars, val))
 853                         dest[i] = src[i];
 854                 else
 855                         dest[i] = '_';
 856         }
 857
 858         dest[i] = '\0';
 859
 860         return dest;
 861 }
 862
 863 /**
 864  Like strncpy but always null terminates. Make sure there is room!
 865  The variable n should always be one less than the available size.
 866 **/
 867 char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
 868 {
 869         char *d = dest;
 870
 871 #ifdef DEVELOPER
 872         clobber_region(fn, line, dest, n+1);
 873 #endif
 874
 875         if (!dest) {
 876                 DEBUG(0,("ERROR: NULL dest in StrnCpy, "
 877                         "called from [%s][%d]\n", fn, line));
 878                 return(NULL);
 879         }
 880
 881         if (!src) {
 882                 *dest = 0;
 883                 return(dest);
 884         }
 885
 886         while (n-- && (*d = *src)) {
 887                 d++;
 888                 src++;
 889         }
 890
 891         *d = 0;
 892         return(dest);
 893 }
 894
 895 #if 0
 896 /**
 897  Like strncpy but copies up to the character marker.  always null terminates.
 898  returns a pointer to the character marker in the source string (src).
 899 **/
 900
 901 static char *strncpyn(char *dest, const char *src, size_t n, char c)
 902 {
 903         char *p;
 904         size_t str_len;
 905
 906 #ifdef DEVELOPER
 907         clobber_region(dest, n+1);
 908 #endif
 909         p = strchr_m(src, c);
 910         if (p == NULL) {
 911                 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
 912                 return NULL;
 913         }
 914
 915         str_len = PTR_DIFF(p, src);
 916         strncpy(dest, src, MIN(n, str_len));
 917         dest[str_len] = '\0';
 918
 919         return p;
 920 }
 921 #endif
 922
 923 /**
 924  Routine to get hex characters and turn them into a 16 byte array.
 925  the array can be variable length, and any non-hex-numeric
 926  characters are skipped.  "0xnn" or "0Xnn" is specially catered
 927  for.
 928
 929  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
 930
 931 **/
 932
 933 size_t strhex_to_str(char *p, size_t len, const char *strhex)
 934 {
 935         size_t i;
 936         size_t num_chars = 0;
 937         unsigned char   lonybble, hinybble;
 938         const char     *hexchars = "0123456789ABCDEF";
 939         char           *p1 = NULL, *p2 = NULL;
 940
 941         for (i = 0; i < len && strhex[i] != 0; i++) {
 942                 if (strnequal(hexchars, "0x", 2)) {
 943                         i++; /* skip two chars */
 944                         continue;
 945                 }
 946
 947                 if (!(p1 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
 948                         break;
 949
 950                 i++; /* next hex digit */
 951
 952                 if (!(p2 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
 953                         break;
 954
 955                 /* get the two nybbles */
 956                 hinybble = PTR_DIFF(p1, hexchars);
 957                 lonybble = PTR_DIFF(p2, hexchars);
 958
 959                 p[num_chars] = (hinybble << 4) | lonybble;
 960                 num_chars++;
 961
 962                 p1 = NULL;
 963                 p2 = NULL;
 964         }
 965         return num_chars;
 966 }
 967
 968 DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
 969 {
 970         DATA_BLOB ret_blob;
 971
 972         if (mem_ctx != NULL)
 973                 ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
 974         else
 975                 ret_blob = data_blob(NULL, strlen(strhex)/2+1);
 976
 977         ret_blob.length = strhex_to_str((char*)ret_blob.data,
 978                                         strlen(strhex),
 979                                         strhex);
 980
 981         return ret_blob;
 982 }
 983
 984 /**
 985  * Routine to print a buffer as HEX digits, into an allocated string.
 986  */
 987
 988 char *hex_encode(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
 989 {
 990         int i;
 991         char *hex_buffer;
 992
 993         hex_buffer = TALLOC_ARRAY(mem_ctx, char, (len*2)+1);
 994
 995         for (i = 0; i < len; i++)
 996                 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
 997
 998         return hex_buffer;
 999 }
1000
1001 /**
1002  Check if a string is part of a list.
1003 **/
1004
1005 bool in_list(const char *s, const char *list, bool casesensitive)
1006 {
1007         char *tok;
1008         const char *p=list;
1009         size_t bufsize = strlen(list);
1010         bool ret = false;
1011
1012         if (!list)
1013                 return(false);
1014
1015         /* We know a token can't be larger
1016          * than the entire list. */
1017
1018         tok = SMB_MALLOC_ARRAY(char, bufsize+1);
1019         if (!tok) {
1020                 return false;
1021         }
1022
1023         while (next_token(&p,tok,LIST_SEP,bufsize+1)) {
1024                 if (casesensitive) {
1025                         if (strcmp(tok,s) == 0) {
1026                                 ret = true;
1027                                 break;
1028                         }
1029                 } else {
1030                         if (StrCaseCmp(tok,s) == 0) {
1031                                 ret = true;
1032                                 break;
1033                         }
1034                 }
1035         }
1036
1037         SAFE_FREE(tok);
1038         return ret;
1039 }
1040
1041 /* this is used to prevent lots of mallocs of size 1 */
1042 static const char *null_string = "";
1043
1044 /**
1045  Set a string value, allocing the space for the string
1046 **/
1047
1048 static bool string_init(char **dest,const char *src)
1049 {
1050         size_t l;
1051
1052         if (!src)
1053                 src = "";
1054
1055         l = strlen(src);
1056
1057         if (l == 0) {
1058                 *dest = CONST_DISCARD(char*, null_string);
1059         } else {
1060                 (*dest) = SMB_STRDUP(src);
1061                 if ((*dest) == NULL) {
1062                         DEBUG(0,("Out of memory in string_init\n"));
1063                         return false;
1064                 }
1065         }
1066         return(true);
1067 }
1068
1069 /**
1070  Free a string value.
1071 **/
1072
1073 void string_free(char **s)
1074 {
1075         if (!s || !(*s))
1076                 return;
1077         if (*s == null_string)
1078                 *s = NULL;
1079         SAFE_FREE(*s);
1080 }
1081
1082 /**
1083  Set a string value, deallocating any existing space, and allocing the space
1084  for the string
1085 **/
1086
1087 bool string_set(char **dest,const char *src)
1088 {
1089         string_free(dest);
1090         return(string_init(dest,src));
1091 }
1092
1093 /**
1094  Substitute a string for a pattern in another string. Make sure there is
1095  enough room!
1096
1097  This routine looks for pattern in s and replaces it with
1098  insert. It may do multiple replacements or just one.
1099
1100  Any of " ; ' $ or ` in the insert string are replaced with _
1101  if len==0 then the string cannot be extended. This is different from the old
1102  use of len==0 which was for no length checks to be done.
1103 **/
1104
1105 void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
1106                  bool remove_unsafe_characters, bool replace_once,
1107                  bool allow_trailing_dollar)
1108 {
1109         char *p;
1110         ssize_t ls,lp,li, i;
1111
1112         if (!insert || !pattern || !*pattern || !s)
1113                 return;
1114
1115         ls = (ssize_t)strlen(s);
1116         lp = (ssize_t)strlen(pattern);
1117         li = (ssize_t)strlen(insert);
1118
1119         if (len == 0)
1120                 len = ls + 1; /* len is number of *bytes* */
1121
1122         while (lp <= ls && (p = strstr_m(s,pattern))) {
1123                 if (ls + (li-lp) >= len) {
1124                         DEBUG(0,("ERROR: string overflow by "
1125                                 "%d in string_sub(%.50s, %d)\n",
1126                                  (int)(ls + (li-lp) - len),
1127                                  pattern, (int)len));
1128                         break;
1129                 }
1130                 if (li != lp) {
1131                         memmove(p+li,p+lp,strlen(p+lp)+1);
1132                 }
1133                 for (i=0;i<li;i++) {
1134                         switch (insert[i]) {
1135                         case '`':
1136                         case '"':
1137                         case '\'':
1138                         case ';':
1139                         case '$':
1140                                 /* allow a trailing $
1141                                  * (as in machine accounts) */
1142                                 if (allow_trailing_dollar && (i == li - 1 )) {
1143                                         p[i] = insert[i];
1144                                         break;
1145                                 }
1146                         case '%':
1147                         case '\r':
1148                         case '\n':
1149                                 if ( remove_unsafe_characters ) {
1150                                         p[i] = '_';
1151                                         /* yes this break should be here
1152                                          * since we want to fall throw if
1153                                          * not replacing unsafe chars */
1154                                         break;
1155                                 }
1156                         default:
1157                                 p[i] = insert[i];
1158                         }
1159                 }
1160                 s = p + li;
1161                 ls += (li-lp);
1162
1163                 if (replace_once)
1164                         break;
1165         }
1166 }
1167
1168 void string_sub_once(char *s, const char *pattern,
1169                 const char *insert, size_t len)
1170 {
1171         string_sub2( s, pattern, insert, len, true, true, false );
1172 }
1173
1174 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
1175 {
1176         string_sub2( s, pattern, insert, len, true, false, false );
1177 }
1178
1179 void fstring_sub(char *s,const char *pattern,const char *insert)
1180 {
1181         string_sub(s, pattern, insert, sizeof(fstring));
1182 }
1183
1184 void pstring_sub(char *s,const char *pattern,const char *insert)
1185 {
1186         string_sub(s, pattern, insert, sizeof(pstring));
1187 }
1188
1189 /**
1190  Similar to string_sub, but it will accept only allocated strings
1191  and may realloc them so pay attention at what you pass on no
1192  pointers inside strings, no pstrings or const may be passed
1193  as string.
1194 **/
1195
1196 char *realloc_string_sub(char *string, const char *pattern,
1197                          const char *insert)
1198 {
1199         char *p, *in;
1200         char *s;
1201         ssize_t ls,lp,li,ld, i;
1202
1203         if (!insert || !pattern || !*pattern || !string || !*string)
1204                 return NULL;
1205
1206         s = string;
1207
1208         in = SMB_STRDUP(insert);
1209         if (!in) {
1210                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1211                 return NULL;
1212         }
1213         ls = (ssize_t)strlen(s);
1214         lp = (ssize_t)strlen(pattern);
1215         li = (ssize_t)strlen(insert);
1216         ld = li - lp;
1217         for (i=0;i<li;i++) {
1218                 switch (in[i]) {
1219                         case '`':
1220                         case '"':
1221                         case '\'':
1222                         case ';':
1223                         case '$':
1224                         case '%':
1225                         case '\r':
1226                         case '\n':
1227                                 in[i] = '_';
1228                         default:
1229                                 /* ok */
1230                                 break;
1231                 }
1232         }
1233
1234         while ((p = strstr_m(s,pattern))) {
1235                 if (ld > 0) {
1236                         int offset = PTR_DIFF(s,string);
1237                         string = (char *)SMB_REALLOC(string, ls + ld + 1);
1238                         if (!string) {
1239                                 DEBUG(0, ("realloc_string_sub: "
1240                                         "out of memory!\n"));
1241                                 SAFE_FREE(in);
1242                                 return NULL;
1243                         }
1244                         p = string + offset + (p - s);
1245                 }
1246                 if (li != lp) {
1247                         memmove(p+li,p+lp,strlen(p+lp)+1);
1248                 }
1249                 memcpy(p, in, li);
1250                 s = p + li;
1251                 ls += ld;
1252         }
1253         SAFE_FREE(in);
1254         return string;
1255 }
1256
1257 /*
1258  * Internal guts of talloc_string_sub and talloc_all_string_sub.
1259  * 'filter' differentiates between them.
1260  */
1261
1262 static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
1263                         const char *pattern, const char *insert, bool filter)
1264 {
1265         char *p, *in;
1266         char *s;
1267         char *string;
1268         ssize_t ls,lp,li,ld, i;
1269
1270         if (!insert || !pattern || !*pattern || !src || !*src) {
1271                 return NULL;
1272         }
1273
1274         string = talloc_strdup(mem_ctx, src);
1275         if (string == NULL) {
1276                 DEBUG(0, ("talloc_string_sub_internal: "
1277                         "talloc_strdup failed\n"));
1278                 return NULL;
1279         }
1280
1281         s = string;
1282
1283         in = SMB_STRDUP(insert);
1284         if (!in) {
1285                 DEBUG(0, ("talloc_string_sub_internal: ENOMEM\n"));
1286                 return NULL;
1287         }
1288         ls = (ssize_t)strlen(s);
1289         lp = (ssize_t)strlen(pattern);
1290         li = (ssize_t)strlen(insert);
1291         ld = li - lp;
1292
1293         if (filter) {
1294                 for (i=0;i<li;i++) {
1295                         switch (in[i]) {
1296                                 case '`':
1297                                 case '"':
1298                                 case '\'':
1299                                 case ';':
1300                                 case '$':
1301                                 case '%':
1302                                 case '\r':
1303                                 case '\n':
1304                                         in[i] = '_';
1305                                 default:
1306                                         /* ok */
1307                                         break;
1308                         }
1309                 }
1310         }
1311
1312         while ((p = strstr_m(s,pattern))) {
1313                 if (ld > 0) {
1314                         int offset = PTR_DIFF(s,string);
1315                         string = (char *)TALLOC_REALLOC(mem_ctx, string,
1316                                                         ls + ld + 1);
1317                         if (!string) {
1318                                 DEBUG(0, ("talloc_string_sub: out of "
1319                                           "memory!\n"));
1320                                 SAFE_FREE(in);
1321                                 return NULL;
1322                         }
1323                         p = string + offset + (p - s);
1324                 }
1325                 if (li != lp) {
1326                         memmove(p+li,p+lp,strlen(p+lp)+1);
1327                 }
1328                 memcpy(p, in, li);
1329                 s = p + li;
1330                 ls += ld;
1331         }
1332         SAFE_FREE(in);
1333         return string;
1334 }
1335
1336 /* Same as string_sub, but returns a talloc'ed string */
1337
1338 char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
1339                         const char *pattern, const char *insert)
1340 {
1341         return talloc_string_sub_internal(mem_ctx, src, pattern, insert, true);
1342 }
1343
1344 /**
1345  Similar to string_sub() but allows for any character to be substituted.
1346  Use with caution!
1347  if len==0 then the string cannot be extended. This is different from the old
1348  use of len==0 which was for no length checks to be done.
1349 **/
1350
1351 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1352 {
1353         char *p;
1354         ssize_t ls,lp,li;
1355
1356         if (!insert || !pattern || !s)
1357                 return;
1358
1359         ls = (ssize_t)strlen(s);
1360         lp = (ssize_t)strlen(pattern);
1361         li = (ssize_t)strlen(insert);
1362
1363         if (!*pattern)
1364                 return;
1365
1366         if (len == 0)
1367                 len = ls + 1; /* len is number of *bytes* */
1368
1369         while (lp <= ls && (p = strstr_m(s,pattern))) {
1370                 if (ls + (li-lp) >= len) {
1371                         DEBUG(0,("ERROR: string overflow by "
1372                                 "%d in all_string_sub(%.50s, %d)\n",
1373                                  (int)(ls + (li-lp) - len),
1374                                  pattern, (int)len));
1375                         break;
1376                 }
1377                 if (li != lp) {
1378                         memmove(p+li,p+lp,strlen(p+lp)+1);
1379                 }
1380                 memcpy(p, insert, li);
1381                 s = p + li;
1382                 ls += (li-lp);
1383         }
1384 }
1385
1386 char *talloc_all_string_sub(TALLOC_CTX *ctx,
1387                                 const char *src,
1388                                 const char *pattern,
1389                                 const char *insert)
1390 {
1391         return talloc_string_sub_internal(ctx, src, pattern, insert, false);
1392 }
1393
1394 /**
1395  Similar to all_string_sub but for unicode strings.
1396  Return a new allocated unicode string.
1397  similar to string_sub() but allows for any character to be substituted.
1398  Use with caution!
1399 **/
1400
1401 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s,
1402                                 const smb_ucs2_t *pattern,
1403                                 const smb_ucs2_t *insert)
1404 {
1405         smb_ucs2_t *r, *rp;
1406         const smb_ucs2_t *sp;
1407         size_t  lr, lp, li, lt;
1408
1409         if (!insert || !pattern || !*pattern || !s)
1410                 return NULL;
1411
1412         lt = (size_t)strlen_w(s);
1413         lp = (size_t)strlen_w(pattern);
1414         li = (size_t)strlen_w(insert);
1415
1416         if (li > lp) {
1417                 const smb_ucs2_t *st = s;
1418                 int ld = li - lp;
1419                 while ((sp = strstr_w(st, pattern))) {
1420                         st = sp + lp;
1421                         lt += ld;
1422                 }
1423         }
1424
1425         r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
1426         if (!r) {
1427                 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1428                 return NULL;
1429         }
1430
1431         while ((sp = strstr_w(s, pattern))) {
1432                 memcpy(rp, s, (sp - s));
1433                 rp += ((sp - s) / sizeof(smb_ucs2_t));
1434                 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1435                 s = sp + lp;
1436                 rp += li;
1437         }
1438         lr = ((rp - r) / sizeof(smb_ucs2_t));
1439         if (lr < lt) {
1440                 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1441                 rp += (lt - lr);
1442         }
1443         *rp = 0;
1444
1445         return r;
1446 }
1447
1448 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1449                                              const char *insert)
1450 {
1451         wpstring p, i;
1452
1453         if (!insert || !pattern || !s)
1454                 return NULL;
1455         push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1456         push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1457         return all_string_sub_w(s, p, i);
1458 }
1459
1460 #if 0
1461 /**
1462  Splits out the front and back at a separator.
1463 **/
1464
1465 static void split_at_last_component(char *path, char *front, char sep,
1466                 char *back)
1467 {
1468         char *p = strrchr_m(path, sep);
1469
1470         if (p != NULL)
1471                 *p = 0;
1472
1473         if (front != NULL)
1474                 pstrcpy(front, path);
1475
1476         if (p != NULL) {
1477                 if (back != NULL)
1478                         pstrcpy(back, p+1);
1479                 *p = '\\';
1480         } else {
1481                 if (back != NULL)
1482                         back[0] = 0;
1483         }
1484 }
1485 #endif
1486
1487 /**
1488  Write an octal as a string.
1489 **/
1490
1491 const char *octal_string(int i)
1492 {
1493         static char ret[64];
1494         if (i == -1)
1495                 return "-1";
1496         slprintf(ret, sizeof(ret)-1, "0%o", i);
1497         return ret;
1498 }
1499
1500
1501 /**
1502  Truncate a string at a specified length.
1503 **/
1504
1505 char *string_truncate(char *s, unsigned int length)
1506 {
1507         if (s && strlen(s) > length)
1508                 s[length] = 0;
1509         return s;
1510 }
1511
1512 /**
1513  Strchr and strrchr_m are very hard to do on general multi-byte strings.
1514  We convert via ucs2 for now.
1515 **/
1516
1517 char *strchr_m(const char *src, char c)
1518 {
1519         smb_ucs2_t *ws = NULL;
1520         char *s2 = NULL;
1521         smb_ucs2_t *p;
1522         const char *s;
1523         char *ret;
1524
1525         /* characters below 0x3F are guaranteed to not appear in
1526            non-initial position in multi-byte charsets */
1527         if ((c & 0xC0) == 0) {
1528                 return strchr(src, c);
1529         }
1530
1531         /* this is quite a common operation, so we want it to be
1532            fast. We optimise for the ascii case, knowing that all our
1533            supported multi-byte character sets are ascii-compatible
1534            (ie. they match for the first 128 chars) */
1535
1536         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1537                 if (*s == c)
1538                         return (char *)s;
1539         }
1540
1541         if (!*s)
1542                 return NULL;
1543
1544 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1545         /* With compose characters we must restart from the beginning. JRA. */
1546         s = src;
1547 #endif
1548
1549         if (push_ucs2_allocate(&ws, s)==(size_t)-1) {
1550                 /* Wrong answer, but what can we do... */
1551                 return strchr(src, c);
1552         }
1553         p = strchr_w(ws, UCS2_CHAR(c));
1554         if (!p) {
1555                 SAFE_FREE(ws);
1556                 return NULL;
1557         }
1558         *p = 0;
1559         if (pull_ucs2_allocate(&s2, ws)==(size_t)-1) {
1560                 SAFE_FREE(ws);
1561                 /* Wrong answer, but what can we do... */
1562                 return strchr(src, c);
1563         }
1564         ret = (char *)(s+strlen(s2));
1565         SAFE_FREE(ws);
1566         SAFE_FREE(s2);
1567         return ret;
1568 }
1569
1570 char *strrchr_m(const char *s, char c)
1571 {
1572         /* characters below 0x3F are guaranteed to not appear in
1573            non-initial position in multi-byte charsets */
1574         if ((c & 0xC0) == 0) {
1575                 return strrchr(s, c);
1576         }
1577
1578         /* this is quite a common operation, so we want it to be
1579            fast. We optimise for the ascii case, knowing that all our
1580            supported multi-byte character sets are ascii-compatible
1581            (ie. they match for the first 128 chars). Also, in Samba
1582            we only search for ascii characters in 'c' and that
1583            in all mb character sets with a compound character
1584            containing c, if 'c' is not a match at position
1585            p, then p[-1] > 0x7f. JRA. */
1586
1587         {
1588                 size_t len = strlen(s);
1589                 const char *cp = s;
1590                 bool got_mb = false;
1591
1592                 if (len == 0)
1593                         return NULL;
1594                 cp += (len - 1);
1595                 do {
1596                         if (c == *cp) {
1597                                 /* Could be a match. Part of a multibyte ? */
1598                                 if ((cp > s) &&
1599                                         (((unsigned char)cp[-1]) & 0x80)) {
1600                                         /* Yep - go slow :-( */
1601                                         got_mb = true;
1602                                         break;
1603                                 }
1604                                 /* No - we have a match ! */
1605                                 return (char *)cp;
1606                         }
1607                 } while (cp-- != s);
1608                 if (!got_mb)
1609                         return NULL;
1610         }
1611
1612         /* String contained a non-ascii char. Slow path. */
1613         {
1614                 smb_ucs2_t *ws = NULL;
1615                 char *s2 = NULL;
1616                 smb_ucs2_t *p;
1617                 char *ret;
1618
1619                 if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1620                         /* Wrong answer, but what can we do. */
1621                         return strrchr(s, c);
1622                 }
1623                 p = strrchr_w(ws, UCS2_CHAR(c));
1624                 if (!p) {
1625                         SAFE_FREE(ws);
1626                         return NULL;
1627                 }
1628                 *p = 0;
1629                 if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1630                         SAFE_FREE(ws);
1631                         /* Wrong answer, but what can we do. */
1632                         return strrchr(s, c);
1633                 }
1634                 ret = (char *)(s+strlen(s2));
1635                 SAFE_FREE(ws);
1636                 SAFE_FREE(s2);
1637                 return ret;
1638         }
1639 }
1640
1641 /***********************************************************************
1642  Return the equivalent of doing strrchr 'n' times - always going
1643  backwards.
1644 ***********************************************************************/
1645
1646 char *strnrchr_m(const char *s, char c, unsigned int n)
1647 {
1648         smb_ucs2_t *ws = NULL;
1649         char *s2 = NULL;
1650         smb_ucs2_t *p;
1651         char *ret;
1652
1653         if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1654                 /* Too hard to try and get right. */
1655                 return NULL;
1656         }
1657         p = strnrchr_w(ws, UCS2_CHAR(c), n);
1658         if (!p) {
1659                 SAFE_FREE(ws);
1660                 return NULL;
1661         }
1662         *p = 0;
1663         if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1664                 SAFE_FREE(ws);
1665                 /* Too hard to try and get right. */
1666                 return NULL;
1667         }
1668         ret = (char *)(s+strlen(s2));
1669         SAFE_FREE(ws);
1670         SAFE_FREE(s2);
1671         return ret;
1672 }
1673
1674 /***********************************************************************
1675  strstr_m - We convert via ucs2 for now.
1676 ***********************************************************************/
1677
1678 char *strstr_m(const char *src, const char *findstr)
1679 {
1680         smb_ucs2_t *p;
1681         smb_ucs2_t *src_w, *find_w;
1682         const char *s;
1683         char *s2;
1684         char *retp;
1685
1686         size_t findstr_len = 0;
1687
1688         /* for correctness */
1689         if (!findstr[0]) {
1690                 return (char*)src;
1691         }
1692
1693         /* Samba does single character findstr calls a *lot*. */
1694         if (findstr[1] == '\0')
1695                 return strchr_m(src, *findstr);
1696
1697         /* We optimise for the ascii case, knowing that all our
1698            supported multi-byte character sets are ascii-compatible
1699            (ie. they match for the first 128 chars) */
1700
1701         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1702                 if (*s == *findstr) {
1703                         if (!findstr_len)
1704                                 findstr_len = strlen(findstr);
1705
1706                         if (strncmp(s, findstr, findstr_len) == 0) {
1707                                 return (char *)s;
1708                         }
1709                 }
1710         }
1711
1712         if (!*s)
1713                 return NULL;
1714
1715 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1716         /* 'make check' fails unless we do this */
1717
1718         /* With compose characters we must restart from the beginning. JRA. */
1719         s = src;
1720 #endif
1721
1722         if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1723                 DEBUG(0,("strstr_m: src malloc fail\n"));
1724                 return NULL;
1725         }
1726
1727         if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1728                 SAFE_FREE(src_w);
1729                 DEBUG(0,("strstr_m: find malloc fail\n"));
1730                 return NULL;
1731         }
1732
1733         p = strstr_w(src_w, find_w);
1734
1735         if (!p) {
1736                 SAFE_FREE(src_w);
1737                 SAFE_FREE(find_w);
1738                 return NULL;
1739         }
1740
1741         *p = 0;
1742         if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1743                 SAFE_FREE(src_w);
1744                 SAFE_FREE(find_w);
1745                 DEBUG(0,("strstr_m: dest malloc fail\n"));
1746                 return NULL;
1747         }
1748         retp = (char *)(s+strlen(s2));
1749         SAFE_FREE(src_w);
1750         SAFE_FREE(find_w);
1751         SAFE_FREE(s2);
1752         return retp;
1753 }
1754
1755 /**
1756  Convert a string to lower case.
1757 **/
1758
1759 void strlower_m(char *s)
1760 {
1761         size_t len;
1762         int errno_save;
1763
1764         /* this is quite a common operation, so we want it to be
1765            fast. We optimise for the ascii case, knowing that all our
1766            supported multi-byte character sets are ascii-compatible
1767            (ie. they match for the first 128 chars) */
1768
1769         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1770                 *s = tolower_ascii((unsigned char)*s);
1771                 s++;
1772         }
1773
1774         if (!*s)
1775                 return;
1776
1777         /* I assume that lowercased string takes the same number of bytes
1778          * as source string even in UTF-8 encoding. (VIV) */
1779         len = strlen(s) + 1;
1780         errno_save = errno;
1781         errno = 0;
1782         unix_strlower(s,len,s,len);
1783         /* Catch mb conversion errors that may not terminate. */
1784         if (errno)
1785                 s[len-1] = '\0';
1786         errno = errno_save;
1787 }
1788
1789 /**
1790  Convert a string to upper case.
1791 **/
1792
1793 void strupper_m(char *s)
1794 {
1795         size_t len;
1796         int errno_save;
1797
1798         /* this is quite a common operation, so we want it to be
1799            fast. We optimise for the ascii case, knowing that all our
1800            supported multi-byte character sets are ascii-compatible
1801            (ie. they match for the first 128 chars) */
1802
1803         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1804                 *s = toupper_ascii((unsigned char)*s);
1805                 s++;
1806         }
1807
1808         if (!*s)
1809                 return;
1810
1811         /* I assume that lowercased string takes the same number of bytes
1812          * as source string even in multibyte encoding. (VIV) */
1813         len = strlen(s) + 1;
1814         errno_save = errno;
1815         errno = 0;
1816         unix_strupper(s,len,s,len);
1817         /* Catch mb conversion errors that may not terminate. */
1818         if (errno)
1819                 s[len-1] = '\0';
1820         errno = errno_save;
1821 }
1822
1823 /**
1824  Count the number of UCS2 characters in a string. Normally this will
1825  be the same as the number of bytes in a string for single byte strings,
1826  but will be different for multibyte.
1827 **/
1828
1829 size_t strlen_m(const char *s)
1830 {
1831         size_t count = 0;
1832
1833         if (!s) {
1834                 return 0;
1835         }
1836
1837         while (*s && !(((uint8_t)*s) & 0x80)) {
1838                 s++;
1839                 count++;
1840         }
1841
1842         if (!*s) {
1843                 return count;
1844         }
1845
1846         while (*s) {
1847                 size_t c_size;
1848                 codepoint_t c = next_codepoint(s, &c_size);
1849                 if (c < 0x10000) {
1850                         /* Unicode char fits into 16 bits. */
1851                         count += 1;
1852                 } else {
1853                         /* Double-width unicode char - 32 bits. */
1854                         count += 2;
1855                 }
1856                 s += c_size;
1857         }
1858
1859         return count;
1860 }
1861
1862 /**
1863  Count the number of UCS2 characters in a string including the null
1864  terminator.
1865 **/
1866
1867 size_t strlen_m_term(const char *s)
1868 {
1869         if (!s) {
1870                 return 0;
1871         }
1872         return strlen_m(s) + 1;
1873 }
1874
1875 /*
1876  * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1877  * if a string is there, include the terminator.
1878  */
1879
1880 size_t strlen_m_term_null(const char *s)
1881 {
1882         size_t len;
1883         if (!s) {
1884                 return 0;
1885         }
1886         len = strlen_m(s);
1887         if (len == 0) {
1888                 return 0;
1889         }
1890
1891         return len+1;
1892 }
1893 /**
1894  Return a RFC2254 binary string representation of a buffer.
1895  Used in LDAP filters.
1896  Caller must free.
1897 **/
1898
1899 char *binary_string_rfc2254(char *buf, int len)
1900 {
1901         char *s;
1902         int i, j;
1903         const char *hex = "0123456789ABCDEF";
1904         s = (char *)SMB_MALLOC(len * 3 + 1);
1905         if (!s)
1906                 return NULL;
1907         for (j=i=0;i<len;i++) {
1908                 s[j] = '\\';
1909                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1910                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1911                 j += 3;
1912         }
1913         s[j] = 0;
1914         return s;
1915 }
1916
1917 char *binary_string(char *buf, int len)
1918 {
1919         char *s;
1920         int i, j;
1921         const char *hex = "0123456789ABCDEF";
1922         s = (char *)SMB_MALLOC(len * 2 + 1);
1923         if (!s)
1924                 return NULL;
1925         for (j=i=0;i<len;i++) {
1926                 s[j]   = hex[((unsigned char)buf[i]) >> 4];
1927                 s[j+1] = hex[((unsigned char)buf[i]) & 0xF];
1928                 j += 2;
1929         }
1930         s[j] = 0;
1931         return s;
1932 }
1933 /**
1934  Just a typesafety wrapper for snprintf into a pstring.
1935 **/
1936
1937  int pstr_sprintf(pstring s, const char *fmt, ...)
1938 {
1939         va_list ap;
1940         int ret;
1941
1942         va_start(ap, fmt);
1943         ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1944         va_end(ap);
1945         return ret;
1946 }
1947
1948
1949 /**
1950  Just a typesafety wrapper for snprintf into a fstring.
1951 **/
1952
1953 int fstr_sprintf(fstring s, const char *fmt, ...)
1954 {
1955         va_list ap;
1956         int ret;
1957
1958         va_start(ap, fmt);
1959         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1960         va_end(ap);
1961         return ret;
1962 }
1963
1964 /**
1965  List of Strings manipulation functions
1966 **/
1967
1968 #define S_LIST_ABS 16 /* List Allocation Block Size */
1969
1970 static char **str_list_make_internal(TALLOC_CTX *mem_ctx,
1971                 const char *string,
1972                 const char *sep)
1973 {
1974         char **list, **rlist;
1975         const char *str;
1976         char *s;
1977         int num, lsize;
1978         pstring tok;
1979
1980         if (!string || !*string)
1981                 return NULL;
1982         if (mem_ctx) {
1983                 s = talloc_strdup(mem_ctx, string);
1984         } else {
1985                 s = SMB_STRDUP(string);
1986         }
1987         if (!s) {
1988                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1989                 return NULL;
1990         }
1991         if (!sep) sep = LIST_SEP;
1992
1993         num = lsize = 0;
1994         list = NULL;
1995
1996         str = s;
1997         while (next_token(&str, tok, sep, sizeof(tok))) {
1998                 if (num == lsize) {
1999                         lsize += S_LIST_ABS;
2000                         if (mem_ctx) {
2001                                 rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list,
2002                                                 char *, lsize +1);
2003                         } else {
2004                                 /* We need to keep the old list on
2005                                  * error so we can free the elements
2006                                    if the realloc fails. */
2007                                 rlist =SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
2008                                                 char *, lsize +1);
2009                         }
2010                         if (!rlist) {
2011                                 DEBUG(0,("str_list_make: "
2012                                         "Unable to allocate memory"));
2013                                 str_list_free(&list);
2014                                 if (mem_ctx) {
2015                                         TALLOC_FREE(s);
2016                                 } else {
2017                                         SAFE_FREE(s);
2018                                 }
2019                                 return NULL;
2020                         } else {
2021                                 list = rlist;
2022                         }
2023                         memset (&list[num], 0,
2024                                         ((sizeof(char**)) * (S_LIST_ABS +1)));
2025                 }
2026
2027                 if (mem_ctx) {
2028                         list[num] = talloc_strdup(mem_ctx, tok);
2029                 } else {
2030                         list[num] = SMB_STRDUP(tok);
2031                 }
2032
2033                 if (!list[num]) {
2034                         DEBUG(0,("str_list_make: Unable to allocate memory"));
2035                         str_list_free(&list);
2036                         if (mem_ctx) {
2037                                 TALLOC_FREE(s);
2038                         } else {
2039                                 SAFE_FREE(s);
2040                         }
2041                         return NULL;
2042                 }
2043
2044                 num++;
2045         }
2046
2047         if (mem_ctx) {
2048                 TALLOC_FREE(s);
2049         } else {
2050                 SAFE_FREE(s);
2051         }
2052
2053         return list;
2054 }
2055
2056 char **str_list_make_talloc(TALLOC_CTX *mem_ctx,
2057                 const char *string,
2058                 const char *sep)
2059 {
2060         return str_list_make_internal(mem_ctx, string, sep);
2061 }
2062
2063 char **str_list_make(const char *string, const char *sep)
2064 {
2065         return str_list_make_internal(NULL, string, sep);
2066 }
2067
2068 bool str_list_copy(char ***dest, const char **src)
2069 {
2070         char **list, **rlist;
2071         int num, lsize;
2072
2073         *dest = NULL;
2074         if (!src)
2075                 return false;
2076
2077         num = lsize = 0;
2078         list = NULL;
2079
2080         while (src[num]) {
2081                 if (num == lsize) {
2082                         lsize += S_LIST_ABS;
2083                         rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
2084                                         char *, lsize +1);
2085                         if (!rlist) {
2086                                 DEBUG(0,("str_list_copy: "
2087                                         "Unable to re-allocate memory"));
2088                                 str_list_free(&list);
2089                                 return false;
2090                         } else {
2091                                 list = rlist;
2092                         }
2093                         memset (&list[num], 0,
2094                                         ((sizeof(char **)) * (S_LIST_ABS +1)));
2095                 }
2096
2097                 list[num] = SMB_STRDUP(src[num]);
2098                 if (!list[num]) {
2099                         DEBUG(0,("str_list_copy: Unable to allocate memory"));
2100                         str_list_free(&list);
2101                         return false;
2102                 }
2103
2104                 num++;
2105         }
2106
2107         *dest = list;
2108         return true;
2109 }
2110
2111 /**
2112  * Return true if all the elements of the list match exactly.
2113  **/
2114 bool str_list_compare(char **list1, char **list2)
2115 {
2116         int num;
2117
2118         if (!list1 || !list2)
2119                 return (list1 == list2);
2120
2121         for (num = 0; list1[num]; num++) {
2122                 if (!list2[num])
2123                         return false;
2124                 if (!strcsequal(list1[num], list2[num]))
2125                         return false;
2126         }
2127         if (list2[num])
2128                 return false; /* if list2 has more elements than list1 fail */
2129
2130         return true;
2131 }
2132
2133 static void str_list_free_internal(TALLOC_CTX *mem_ctx, char ***list)
2134 {
2135         char **tlist;
2136
2137         if (!list || !*list)
2138                 return;
2139         tlist = *list;
2140         for(; *tlist; tlist++) {
2141                 if (mem_ctx) {
2142                         TALLOC_FREE(*tlist);
2143                 } else {
2144                         SAFE_FREE(*tlist);
2145                 }
2146         }
2147         if (mem_ctx) {
2148                 TALLOC_FREE(*tlist);
2149         } else {
2150                 SAFE_FREE(*list);
2151         }
2152 }
2153
2154 void str_list_free_talloc(TALLOC_CTX *mem_ctx, char ***list)
2155 {
2156         str_list_free_internal(mem_ctx, list);
2157 }
2158
2159 void str_list_free(char ***list)
2160 {
2161         str_list_free_internal(NULL, list);
2162 }
2163
2164 /******************************************************************************
2165  *****************************************************************************/
2166
2167 int str_list_count( const char **list )
2168 {
2169         int i = 0;
2170
2171         if ( ! list )
2172                 return 0;
2173
2174         /* count the number of list members */
2175
2176         for ( i=0; *list; i++, list++ );
2177
2178         return i;
2179 }
2180
2181 /******************************************************************************
2182  version of standard_sub_basic() for string lists; uses alloc_sub_basic()
2183  for the work
2184  *****************************************************************************/
2185
2186 bool str_list_sub_basic( char **list, const char *smb_name,
2187                          const char *domain_name )
2188 {
2189         char *s, *tmpstr;
2190
2191         while ( *list ) {
2192                 s = *list;
2193                 tmpstr = alloc_sub_basic(smb_name, domain_name, s);
2194                 if ( !tmpstr ) {
2195                         DEBUG(0,("str_list_sub_basic: "
2196                                 "alloc_sub_basic() return NULL!\n"));
2197                         return false;
2198                 }
2199
2200                 SAFE_FREE(*list);
2201                 *list = tmpstr;
2202
2203                 list++;
2204         }
2205
2206         return true;
2207 }
2208
2209 /******************************************************************************
2210  substritute a specific pattern in a string list
2211  *****************************************************************************/
2212
2213 bool str_list_substitute(char **list, const char *pattern, const char *insert)
2214 {
2215         char *p, *s, *t;
2216         ssize_t ls, lp, li, ld, i, d;
2217
2218         if (!list)
2219                 return false;
2220         if (!pattern)
2221                 return false;
2222         if (!insert)
2223                 return false;
2224
2225         lp = (ssize_t)strlen(pattern);
2226         li = (ssize_t)strlen(insert);
2227         ld = li -lp;
2228
2229         while (*list) {
2230                 s = *list;
2231                 ls = (ssize_t)strlen(s);
2232
2233                 while ((p = strstr_m(s, pattern))) {
2234                         t = *list;
2235                         d = p -t;
2236                         if (ld) {
2237                                 t = (char *) SMB_MALLOC(ls +ld +1);
2238                                 if (!t) {
2239                                         DEBUG(0,("str_list_substitute: "
2240                                                 "Unable to allocate memory"));
2241                                         return false;
2242                                 }
2243                                 memcpy(t, *list, d);
2244                                 memcpy(t +d +li, p +lp, ls -d -lp +1);
2245                                 SAFE_FREE(*list);
2246                                 *list = t;
2247                                 ls += ld;
2248                                 s = t +d +li;
2249                         }
2250
2251                         for (i = 0; i < li; i++) {
2252                                 switch (insert[i]) {
2253                                         case '`':
2254                                         case '"':
2255                                         case '\'':
2256                                         case ';':
2257                                         case '$':
2258                                         case '%':
2259                                         case '\r':
2260                                         case '\n':
2261                                                 t[d +i] = '_';
2262                                                 break;
2263                                         default:
2264                                                 t[d +i] = insert[i];
2265                                 }
2266                         }
2267                 }
2268
2269                 list++;
2270         }
2271
2272         return true;
2273 }
2274
2275
2276 #define IPSTR_LIST_SEP  ","
2277 #define IPSTR_LIST_CHAR ','
2278
2279 /**
2280  * Add ip string representation to ipstr list. Used also
2281  * as part of @function ipstr_list_make
2282  *
2283  * @param ipstr_list pointer to string containing ip list;
2284  *        MUST BE already allocated and IS reallocated if necessary
2285  * @param ipstr_size pointer to current size of ipstr_list (might be changed
2286  *        as a result of reallocation)
2287  * @param ip IP address which is to be added to list
2288  * @return pointer to string appended with new ip and possibly
2289  *         reallocated to new length
2290  **/
2291
2292 static char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
2293 {
2294         char *new_ipstr = NULL;
2295         char addr_buf[INET6_ADDRSTRLEN];
2296
2297         /* arguments checking */
2298         if (!ipstr_list || !service) {
2299                 return NULL;
2300         }
2301
2302         print_sockaddr(addr_buf,
2303                         sizeof(addr_buf),
2304                         &service->ss);
2305
2306         /* attempt to convert ip to a string and append colon separator to it */
2307         if (*ipstr_list) {
2308                 if (service->ss.ss_family == AF_INET) {
2309                         /* IPv4 */
2310                         asprintf(&new_ipstr, "%s%s%s:%d",
2311                                         *ipstr_list,
2312                                         IPSTR_LIST_SEP,
2313                                         addr_buf,
2314                                         service->port);
2315                 } else {
2316                         /* IPv6 */
2317                         asprintf(&new_ipstr, "%s%s[%s]:%d",
2318                                         *ipstr_list,
2319                                         IPSTR_LIST_SEP,
2320                                         addr_buf,
2321                                         service->port);
2322                 }
2323                 SAFE_FREE(*ipstr_list);
2324         } else {
2325                 if (service->ss.ss_family == AF_INET) {
2326                         /* IPv4 */
2327                         asprintf(&new_ipstr, "%s:%d",
2328                                 addr_buf,
2329                                 service->port);
2330                 } else {
2331                         /* IPv6 */
2332                         asprintf(&new_ipstr, "[%s]:%d",
2333                                 addr_buf,
2334                                 service->port);
2335                 }
2336         }
2337         *ipstr_list = new_ipstr;
2338         return *ipstr_list;
2339 }
2340
2341 /**
2342  * Allocate and initialise an ipstr list using ip adresses
2343  * passed as arguments.
2344  *
2345  * @param ipstr_list pointer to string meant to be allocated and set
2346  * @param ip_list array of ip addresses to place in the list
2347  * @param ip_count number of addresses stored in ip_list
2348  * @return pointer to allocated ip string
2349  **/
2350
2351 char *ipstr_list_make(char **ipstr_list,
2352                         const struct ip_service *ip_list,
2353                         int ip_count)
2354 {
2355         int i;
2356
2357         /* arguments checking */
2358         if (!ip_list || !ipstr_list) {
2359                 return 0;
2360         }
2361
2362         *ipstr_list = NULL;
2363
2364         /* process ip addresses given as arguments */
2365         for (i = 0; i < ip_count; i++) {
2366                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
2367         }
2368
2369         return (*ipstr_list);
2370 }
2371
2372
2373 /**
2374  * Parse given ip string list into array of ip addresses
2375  * (as ip_service structures)
2376  *    e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
2377  *
2378  * @param ipstr ip string list to be parsed
2379  * @param ip_list pointer to array of ip addresses which is
2380  *        allocated by this function and must be freed by caller
2381  * @return number of succesfully parsed addresses
2382  **/
2383
2384 int ipstr_list_parse(const char *ipstr_list, struct ip_service **ip_list)
2385 {
2386         fstring token_str;
2387         size_t count;
2388         int i;
2389
2390         if (!ipstr_list || !ip_list)
2391                 return 0;
2392
2393         count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
2394         if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
2395                 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
2396                                         (unsigned long)count));
2397                 return 0;
2398         }
2399
2400         for ( i=0; next_token(&ipstr_list, token_str,
2401                                 IPSTR_LIST_SEP, FSTRING_LEN) && i<count; i++ ) {
2402                 char *s = token_str;
2403                 char *p = strrchr(token_str, ':');
2404
2405                 if (p) {
2406                         *p = 0;
2407                         (*ip_list)[i].port = atoi(p+1);
2408                 }
2409
2410                 /* convert single token to ip address */
2411                 if (token_str[0] == '[') {
2412                         /* IPv6 address. */
2413                         s++;
2414                         p = strchr(token_str, ']');
2415                         if (!p) {
2416                                 continue;
2417                         }
2418                         *p = '\0';
2419                 }
2420                 if (!interpret_string_addr(&(*ip_list)[i].ss,
2421                                         s,
2422                                         AI_NUMERICHOST)) {
2423                         continue;
2424                 }
2425         }
2426
2427         return count;
2428 }
2429
2430 /**
2431  * Safely free ip string list
2432  *
2433  * @param ipstr_list ip string list to be freed
2434  **/
2435
2436 void ipstr_list_free(char* ipstr_list)
2437 {
2438         SAFE_FREE(ipstr_list);
2439 }
2440
2441 /**
2442  Unescape a URL encoded string, in place.
2443 **/
2444
2445 void rfc1738_unescape(char *buf)
2446 {
2447         char *p=buf;
2448
2449         while (p && *p && (p=strchr_m(p,'%'))) {
2450                 int c1 = p[1];
2451                 int c2 = p[2];
2452
2453                 if (c1 >= '0' && c1 <= '9')
2454                         c1 = c1 - '0';
2455                 else if (c1 >= 'A' && c1 <= 'F')
2456                         c1 = 10 + c1 - 'A';
2457                 else if (c1 >= 'a' && c1 <= 'f')
2458                         c1 = 10 + c1 - 'a';
2459                 else {p++; continue;}
2460
2461                 if (c2 >= '0' && c2 <= '9')
2462                         c2 = c2 - '0';
2463                 else if (c2 >= 'A' && c2 <= 'F')
2464                         c2 = 10 + c2 - 'A';
2465                 else if (c2 >= 'a' && c2 <= 'f')
2466                         c2 = 10 + c2 - 'a';
2467                 else {p++; continue;}
2468
2469                 *p = (c1<<4) | c2;
2470
2471                 memmove(p+1, p+3, strlen(p+3)+1);
2472                 p++;
2473         }
2474 }
2475
2476 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2477
2478 /**
2479  * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
2480  **/
2481 DATA_BLOB base64_decode_data_blob(const char *s)
2482 {
2483         int bit_offset, byte_offset, idx, i, n;
2484         DATA_BLOB decoded = data_blob(s, strlen(s)+1);
2485         unsigned char *d = decoded.data;
2486         char *p;
2487
2488         n=i=0;
2489
2490         while (*s && (p=strchr_m(b64,*s))) {
2491                 idx = (int)(p - b64);
2492                 byte_offset = (i*6)/8;
2493                 bit_offset = (i*6)%8;
2494                 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2495                 if (bit_offset < 3) {
2496                         d[byte_offset] |= (idx << (2-bit_offset));
2497                         n = byte_offset+1;
2498                 } else {
2499                         d[byte_offset] |= (idx >> (bit_offset-2));
2500                         d[byte_offset+1] = 0;
2501                         d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2502                         n = byte_offset+2;
2503                 }
2504                 s++; i++;
2505         }
2506
2507         if ((n > 0) && (*s == '=')) {
2508                 n -= 1;
2509         }
2510
2511         /* fix up length */
2512         decoded.length = n;
2513         return decoded;
2514 }
2515
2516 /**
2517  * Decode a base64 string in-place - wrapper for the above
2518  **/
2519 void base64_decode_inplace(char *s)
2520 {
2521         DATA_BLOB decoded = base64_decode_data_blob(s);
2522
2523         if ( decoded.length != 0 ) {
2524                 memcpy(s, decoded.data, decoded.length);
2525
2526                 /* null terminate */
2527                 s[decoded.length] = '\0';
2528         } else {
2529                 *s = '\0';
2530         }
2531
2532         data_blob_free(&decoded);
2533 }
2534
2535 /**
2536  * Encode a base64 string into a malloc()ed string caller to free.
2537  *
2538  * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
2539  * with adjustments
2540  **/
2541
2542 char *base64_encode_data_blob(DATA_BLOB data)
2543 {
2544         int bits = 0;
2545         int char_count = 0;
2546         size_t out_cnt, len, output_len;
2547         char *result;
2548
2549         if (!data.length || !data.data)
2550                 return NULL;
2551
2552         out_cnt = 0;
2553         len = data.length;
2554         output_len = data.length * 2;
2555         result = TALLOC_ARRAY(talloc_tos(), char, output_len); /* get us plenty of space */
2556         SMB_ASSERT(result != NULL);
2557
2558         while (len-- && out_cnt < (data.length * 2) - 5) {
2559                 int c = (unsigned char) *(data.data++);
2560                 bits += c;
2561                 char_count++;
2562                 if (char_count == 3) {
2563                         result[out_cnt++] = b64[bits >> 18];
2564                         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2565                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2566                         result[out_cnt++] = b64[bits & 0x3f];
2567                         bits = 0;
2568                         char_count = 0;
2569                 } else {
2570                         bits <<= 8;
2571                 }
2572         }
2573         if (char_count != 0) {
2574                 bits <<= 16 - (8 * char_count);
2575                 result[out_cnt++] = b64[bits >> 18];
2576                 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2577                 if (char_count == 1) {
2578                         result[out_cnt++] = '=';
2579                         result[out_cnt++] = '=';
2580                 } else {
2581                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2582                         result[out_cnt++] = '=';
2583                 }
2584         }
2585         result[out_cnt] = '\0'; /* terminate */
2586         return result;
2587 }
2588
2589 /* read a SMB_BIG_UINT from a string */
2590 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2591 {
2592
2593         SMB_BIG_UINT val = -1;
2594         const char *p = nptr;
2595
2596         if (!p) {
2597                 if (entptr) {
2598                         *entptr = p;
2599                 }
2600                 return val;
2601         }
2602
2603         while (*p && isspace(*p))
2604                 p++;
2605
2606 #ifdef LARGE_SMB_OFF_T
2607         sscanf(p,"%llu",&val);
2608 #else /* LARGE_SMB_OFF_T */
2609         sscanf(p,"%lu",&val);
2610 #endif /* LARGE_SMB_OFF_T */
2611         if (entptr) {
2612                 while (*p && isdigit(*p))
2613                         p++;
2614                 *entptr = p;
2615         }
2616
2617         return val;
2618 }
2619
2620 /* Convert a size specification to a count of bytes. We accept the following
2621  * suffixes:
2622  *          bytes if there is no suffix
2623  *      kK  kibibytes
2624  *      mM  mebibytes
2625  *      gG  gibibytes
2626  *      tT  tibibytes
2627  *      pP  whatever the ISO name for petabytes is
2628  *
2629  *  Returns 0 if the string can't be converted.
2630  */
2631 SMB_OFF_T conv_str_size(const char * str)
2632 {
2633         SMB_OFF_T lval;
2634         char * end;
2635
2636         if (str == NULL || *str == '\0') {
2637                 return 0;
2638         }
2639
2640 #ifdef HAVE_STRTOULL
2641         if (sizeof(SMB_OFF_T) == 8) {
2642             lval = strtoull(str, &end, 10 /* base */);
2643         } else {
2644             lval = strtoul(str, &end, 10 /* base */);
2645         }
2646 #else
2647         lval = strtoul(str, &end, 10 /* base */);
2648 #endif
2649
2650         if (end == NULL || end == str) {
2651                 return 0;
2652         }
2653
2654         if (*end) {
2655                 SMB_OFF_T lval_orig = lval;
2656
2657                 if (strwicmp(end, "K") == 0) {
2658                         lval *= (SMB_OFF_T)1024;
2659                 } else if (strwicmp(end, "M") == 0) {
2660                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2661                 } else if (strwicmp(end, "G") == 0) {
2662                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2663                                 (SMB_OFF_T)1024);
2664                 } else if (strwicmp(end, "T") == 0) {
2665                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2666                                 (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2667                 } else if (strwicmp(end, "P") == 0) {
2668                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2669                                 (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2670                                 (SMB_OFF_T)1024);
2671                 } else {
2672                         return 0;
2673                 }
2674
2675                 /* Primitive attempt to detect wrapping on platforms with
2676                  * 4-byte SMB_OFF_T. It's better to let the caller handle
2677                  * a failure than some random number.
2678                  */
2679                 if (lval_orig <= lval) {
2680                         return 0;
2681                 }
2682         }
2683
2684         return lval;
2685 }
2686
2687 void string_append(char **left, const char *right)
2688 {
2689         int new_len = strlen(right) + 1;
2690
2691         if (*left == NULL) {
2692                 *left = (char *)SMB_MALLOC(new_len);
2693                 *left[0] = '\0';
2694         } else {
2695                 new_len += strlen(*left);
2696                 *left = (char *)SMB_REALLOC(*left, new_len);
2697         }
2698
2699         if (*left == NULL) {
2700                 return;
2701         }
2702
2703         safe_strcat(*left, right, new_len-1);
2704 }
2705
2706 bool add_string_to_array(TALLOC_CTX *mem_ctx,
2707                          const char *str, const char ***strings,
2708                          int *num)
2709 {
2710         char *dup_str = talloc_strdup(mem_ctx, str);
2711
2712         *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings,
2713                         const char *, (*num)+1);
2714
2715         if ((*strings == NULL) || (dup_str == NULL)) {
2716                 *num = 0;
2717                 return false;
2718         }
2719
2720         (*strings)[*num] = dup_str;
2721         *num += 1;
2722         return true;
2723 }
2724
2725 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2726  * error checking in between. The indiation that something weird happened is
2727  * string==NULL */
2728
2729 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2730                     size_t *bufsize, const char *fmt, ...)
2731 {
2732         va_list ap;
2733         char *newstr;
2734         int ret;
2735         bool increased;
2736
2737         /* len<0 is an internal marker that something failed */
2738         if (*len < 0)
2739                 goto error;
2740
2741         if (*string == NULL) {
2742                 if (*bufsize == 0)
2743                         *bufsize = 128;
2744
2745                 *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2746                 if (*string == NULL)
2747                         goto error;
2748         }
2749
2750         va_start(ap, fmt);
2751         ret = vasprintf(&newstr, fmt, ap);
2752         va_end(ap);
2753
2754         if (ret < 0)
2755                 goto error;
2756
2757         increased = false;
2758
2759         while ((*len)+ret >= *bufsize) {
2760                 increased = true;
2761                 *bufsize *= 2;
2762                 if (*bufsize >= (1024*1024*256))
2763                         goto error;
2764         }
2765
2766         if (increased) {
2767                 *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2768                                                *bufsize);
2769                 if (*string == NULL) {
2770                         goto error;
2771                 }
2772         }
2773
2774         StrnCpy((*string)+(*len), newstr, ret);
2775         (*len) += ret;
2776         free(newstr);
2777         return;
2778
2779  error:
2780         *len = -1;
2781         *string = NULL;
2782 }
2783
2784 /*
2785    Returns the substring from src between the first occurrence of
2786    the char "front" and the first occurence of the char "back".
2787    Mallocs the return string which must be freed.  Not for use
2788    with wide character strings.
2789 */
2790 char *sstring_sub(const char *src, char front, char back)
2791 {
2792         char *temp1, *temp2, *temp3;
2793         ptrdiff_t len;
2794
2795         temp1 = strchr(src, front);
2796         if (temp1 == NULL) return NULL;
2797         temp2 = strchr(src, back);
2798         if (temp2 == NULL) return NULL;
2799         len = temp2 - temp1;
2800         if (len <= 0) return NULL;
2801         temp3 = (char*)SMB_MALLOC(len);
2802         if (temp3 == NULL) {
2803                 DEBUG(1,("Malloc failure in sstring_sub\n"));
2804                 return NULL;
2805         }
2806         memcpy(temp3, temp1+1, len-1);
2807         temp3[len-1] = '\0';
2808         return temp3;
2809 }
2810
2811 /********************************************************************
2812  Check a string for any occurrences of a specified list of invalid
2813  characters.
2814 ********************************************************************/
2815
2816 bool validate_net_name( const char *name,
2817                 const char *invalid_chars,
2818                 int max_len)
2819 {
2820         int i;
2821
2822         for ( i=0; i<max_len && name[i]; i++ ) {
2823                 /* fail if strchr_m() finds one of the invalid characters */
2824                 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
2825                         return false;
2826                 }
2827         }
2828
2829         return true;
2830 }
2831
2832
2833 /**
2834 return the number of bytes occupied by a buffer in ASCII format
2835 the result includes the null termination
2836 limited by 'n' bytes
2837 **/
2838 size_t ascii_len_n(const char *src, size_t n)
2839 {
2840         size_t len;
2841
2842         len = strnlen(src, n);
2843         if (len+1 <= n) {
2844                 len += 1;
2845         }
2846
2847         return len;
2848 }
2849
2850 /**
2851 return the number of bytes occupied by a buffer in CH_UTF16 format
2852 the result includes the null termination
2853 **/
2854 size_t utf16_len(const void *buf)
2855 {
2856         size_t len;
2857
2858         for (len = 0; SVAL(buf,len); len += 2) ;
2859
2860         return len + 2;
2861 }
2862
2863 /**
2864 return the number of bytes occupied by a buffer in CH_UTF16 format
2865 the result includes the null termination
2866 limited by 'n' bytes
2867 **/
2868 size_t utf16_len_n(const void *src, size_t n)
2869 {
2870         size_t len;
2871
2872         for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;
2873
2874         if (len+2 <= n) {
2875                 len += 2;
2876         }
2877
2878         return len;
2879 }
2880
2881 /*******************************************************************
2882  Add a shell escape character '\' to any character not in a known list
2883  of characters. UNIX charset format.
2884 *******************************************************************/
2885
2886 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
2887 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
2888
2889 char *escape_shell_string(const char *src)
2890 {
2891         size_t srclen = strlen(src);
2892         char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
2893         char *dest = ret;
2894         bool in_s_quote = false;
2895         bool in_d_quote = false;
2896         bool next_escaped = false;
2897
2898         if (!ret) {
2899                 return NULL;
2900         }
2901
2902         while (*src) {
2903                 size_t c_size;
2904                 codepoint_t c = next_codepoint(src, &c_size);
2905
2906                 if (c == INVALID_CODEPOINT) {
2907                         SAFE_FREE(ret);
2908                         return NULL;
2909                 }
2910
2911                 if (c_size > 1) {
2912                         memcpy(dest, src, c_size);
2913                         src += c_size;
2914                         dest += c_size;
2915                         next_escaped = false;
2916                         continue;
2917                 }
2918
2919                 /*
2920                  * Deal with backslash escaped state.
2921                  * This only lasts for one character.
2922                  */
2923
2924                 if (next_escaped) {
2925                         *dest++ = *src++;
2926                         next_escaped = false;
2927                         continue;
2928                 }
2929
2930                 /*
2931                  * Deal with single quote state. The
2932                  * only thing we care about is exiting
2933                  * this state.
2934                  */
2935
2936                 if (in_s_quote) {
2937                         if (*src == '\'') {
2938                                 in_s_quote = false;
2939                         }
2940                         *dest++ = *src++;
2941                         continue;
2942                 }
2943
2944                 /*
2945                  * Deal with double quote state. The most
2946                  * complex state. We must cope with \, meaning
2947                  * possibly escape next char (depending what it
2948                  * is), ", meaning exit this state, and possibly
2949                  * add an \ escape to any unprotected character
2950                  * (listed in INSIDE_DQUOTE_LIST).
2951                  */
2952
2953                 if (in_d_quote) {
2954                         if (*src == '\\') {
2955                                 /*
2956                                  * Next character might be escaped.
2957                                  * We have to peek. Inside double
2958                                  * quotes only INSIDE_DQUOTE_LIST
2959                                  * characters are escaped by a \.
2960                                  */
2961
2962                                 char nextchar;
2963
2964                                 c = next_codepoint(&src[1], &c_size);
2965                                 if (c == INVALID_CODEPOINT) {
2966                                         SAFE_FREE(ret);
2967                                         return NULL;
2968                                 }
2969                                 if (c_size > 1) {
2970                                         /*
2971                                          * Don't escape the next char.
2972                                          * Just copy the \.
2973                                          */
2974                                         *dest++ = *src++;
2975                                         continue;
2976                                 }
2977
2978                                 nextchar = src[1];
2979
2980                                 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
2981                                                         (int)nextchar)) {
2982                                         next_escaped = true;
2983                                 }
2984                                 *dest++ = *src++;
2985                                 continue;
2986                         }
2987
2988                         if (*src == '\"') {
2989                                 /* Exit double quote state. */
2990                                 in_d_quote = false;
2991                                 *dest++ = *src++;
2992                                 continue;
2993                         }
2994
2995                         /*
2996                          * We know the character isn't \ or ",
2997                          * so escape it if it's any of the other
2998                          * possible unprotected characters.
2999                          */
3000
3001                         if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
3002                                 *dest++ = '\\';
3003                         }
3004                         *dest++ = *src++;
3005                         continue;
3006                 }
3007
3008                 /*
3009                  * From here to the end of the loop we're
3010                  * not in the single or double quote state.
3011                  */
3012
3013                 if (*src == '\\') {
3014                         /* Next character must be escaped. */
3015                         next_escaped = true;
3016                         *dest++ = *src++;
3017                         continue;
3018                 }
3019
3020                 if (*src == '\'') {
3021                         /* Go into single quote state. */
3022                         in_s_quote = true;
3023                         *dest++ = *src++;
3024                         continue;
3025                 }
3026
3027                 if (*src == '\"') {
3028                         /* Go into double quote state. */
3029                         in_d_quote = true;
3030                         *dest++ = *src++;
3031                         continue;
3032                 }
3033
3034                 /* Check if we need to escape the character. */
3035
3036                 if (!strchr(INCLUDE_LIST, (int)*src)) {
3037                         *dest++ = '\\';
3038                 }
3039                 *dest++ = *src++;
3040         }
3041         *dest++ = '\0';
3042         return ret;
3043 }