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_sub2, 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_sub2(char *string,
1197                         const char *pattern,
1198                         const char *insert,
1199                         bool remove_unsafe_characters,
1200                         bool allow_trailing_dollar)
1201 {
1202         char *p, *in;
1203         char *s;
1204         ssize_t ls,lp,li,ld, i;
1205
1206         if (!insert || !pattern || !*pattern || !string || !*string)
1207                 return NULL;
1208
1209         s = string;
1210
1211         in = SMB_STRDUP(insert);
1212         if (!in) {
1213                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1214                 return NULL;
1215         }
1216         ls = (ssize_t)strlen(s);
1217         lp = (ssize_t)strlen(pattern);
1218         li = (ssize_t)strlen(insert);
1219         ld = li - lp;
1220         for (i=0;i<li;i++) {
1221                 switch (in[i]) {
1222                         case '`':
1223                         case '"':
1224                         case '\'':
1225                         case ';':
1226                         case '$':
1227                                 /* allow a trailing $
1228                                  * (as in machine accounts) */
1229                                 if (allow_trailing_dollar && (i == li - 1 )) {
1230                                         break;
1231                                 }
1232                         case '%':
1233                         case '\r':
1234                         case '\n':
1235                                 if ( remove_unsafe_characters ) {
1236                                         in[i] = '_';
1237                                         break;
1238                                 }
1239                         default:
1240                                 /* ok */
1241                                 break;
1242                 }
1243         }
1244
1245         while ((p = strstr_m(s,pattern))) {
1246                 if (ld > 0) {
1247                         int offset = PTR_DIFF(s,string);
1248                         string = (char *)SMB_REALLOC(string, ls + ld + 1);
1249                         if (!string) {
1250                                 DEBUG(0, ("realloc_string_sub: "
1251                                         "out of memory!\n"));
1252                                 SAFE_FREE(in);
1253                                 return NULL;
1254                         }
1255                         p = string + offset + (p - s);
1256                 }
1257                 if (li != lp) {
1258                         memmove(p+li,p+lp,strlen(p+lp)+1);
1259                 }
1260                 memcpy(p, in, li);
1261                 s = p + li;
1262                 ls += ld;
1263         }
1264         SAFE_FREE(in);
1265         return string;
1266 }
1267
1268 char *realloc_string_sub(char *string,
1269                         const char *pattern,
1270                         const char *insert)
1271 {
1272         return realloc_string_sub2(string, pattern, insert, true, false);
1273 }
1274
1275 /*
1276  * Internal guts of talloc_string_sub and talloc_all_string_sub.
1277  * talloc version of string_sub2.
1278  */
1279
1280 char *talloc_string_sub2(TALLOC_CTX *mem_ctx, const char *src,
1281                         const char *pattern,
1282                         const char *insert,
1283                         bool remove_unsafe_characters,
1284                         bool replace_once,
1285                         bool allow_trailing_dollar)
1286 {
1287         char *p, *in;
1288         char *s;
1289         char *string;
1290         ssize_t ls,lp,li,ld, i;
1291
1292         if (!insert || !pattern || !*pattern || !src || !*src) {
1293                 return NULL;
1294         }
1295
1296         string = talloc_strdup(mem_ctx, src);
1297         if (string == NULL) {
1298                 DEBUG(0, ("talloc_string_sub2: "
1299                         "talloc_strdup failed\n"));
1300                 return NULL;
1301         }
1302
1303         s = string;
1304
1305         in = SMB_STRDUP(insert);
1306         if (!in) {
1307                 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
1308                 return NULL;
1309         }
1310         ls = (ssize_t)strlen(s);
1311         lp = (ssize_t)strlen(pattern);
1312         li = (ssize_t)strlen(insert);
1313         ld = li - lp;
1314
1315         for (i=0;i<li;i++) {
1316                 switch (in[i]) {
1317                         case '`':
1318                         case '"':
1319                         case '\'':
1320                         case ';':
1321                         case '$':
1322                                 /* allow a trailing $
1323                                  * (as in machine accounts) */
1324                                 if (allow_trailing_dollar && (i == li - 1 )) {
1325                                         break;
1326                                 }
1327                         case '%':
1328                         case '\r':
1329                         case '\n':
1330                                 if (remove_unsafe_characters) {
1331                                         in[i] = '_';
1332                                         break;
1333                                 }
1334                         default:
1335                                 /* ok */
1336                                 break;
1337                 }
1338         }
1339
1340         while ((p = strstr_m(s,pattern))) {
1341                 if (ld > 0) {
1342                         int offset = PTR_DIFF(s,string);
1343                         string = (char *)TALLOC_REALLOC(mem_ctx, string,
1344                                                         ls + ld + 1);
1345                         if (!string) {
1346                                 DEBUG(0, ("talloc_string_sub: out of "
1347                                           "memory!\n"));
1348                                 SAFE_FREE(in);
1349                                 return NULL;
1350                         }
1351                         p = string + offset + (p - s);
1352                 }
1353                 if (li != lp) {
1354                         memmove(p+li,p+lp,strlen(p+lp)+1);
1355                 }
1356                 memcpy(p, in, li);
1357                 s = p + li;
1358                 ls += ld;
1359
1360                 if (replace_once) {
1361                         break;
1362                 }
1363         }
1364         SAFE_FREE(in);
1365         return string;
1366 }
1367
1368 /* Same as string_sub, but returns a talloc'ed string */
1369
1370 char *talloc_string_sub(TALLOC_CTX *mem_ctx,
1371                         const char *src,
1372                         const char *pattern,
1373                         const char *insert)
1374 {
1375         return talloc_string_sub2(mem_ctx, src, pattern, insert,
1376                         true, false, false);
1377 }
1378
1379 /**
1380  Similar to string_sub() but allows for any character to be substituted.
1381  Use with caution!
1382  if len==0 then the string cannot be extended. This is different from the old
1383  use of len==0 which was for no length checks to be done.
1384 **/
1385
1386 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1387 {
1388         char *p;
1389         ssize_t ls,lp,li;
1390
1391         if (!insert || !pattern || !s)
1392                 return;
1393
1394         ls = (ssize_t)strlen(s);
1395         lp = (ssize_t)strlen(pattern);
1396         li = (ssize_t)strlen(insert);
1397
1398         if (!*pattern)
1399                 return;
1400
1401         if (len == 0)
1402                 len = ls + 1; /* len is number of *bytes* */
1403
1404         while (lp <= ls && (p = strstr_m(s,pattern))) {
1405                 if (ls + (li-lp) >= len) {
1406                         DEBUG(0,("ERROR: string overflow by "
1407                                 "%d in all_string_sub(%.50s, %d)\n",
1408                                  (int)(ls + (li-lp) - len),
1409                                  pattern, (int)len));
1410                         break;
1411                 }
1412                 if (li != lp) {
1413                         memmove(p+li,p+lp,strlen(p+lp)+1);
1414                 }
1415                 memcpy(p, insert, li);
1416                 s = p + li;
1417                 ls += (li-lp);
1418         }
1419 }
1420
1421 char *talloc_all_string_sub(TALLOC_CTX *ctx,
1422                                 const char *src,
1423                                 const char *pattern,
1424                                 const char *insert)
1425 {
1426         return talloc_string_sub2(ctx, src, pattern, insert,
1427                         false, false, false);
1428 }
1429
1430 #if 0
1431 /**
1432  Splits out the front and back at a separator.
1433 **/
1434
1435 static void split_at_last_component(char *path, char *front, char sep,
1436                 char *back)
1437 {
1438         char *p = strrchr_m(path, sep);
1439
1440         if (p != NULL)
1441                 *p = 0;
1442
1443         if (front != NULL)
1444                 pstrcpy(front, path);
1445
1446         if (p != NULL) {
1447                 if (back != NULL)
1448                         pstrcpy(back, p+1);
1449                 *p = '\\';
1450         } else {
1451                 if (back != NULL)
1452                         back[0] = 0;
1453         }
1454 }
1455 #endif
1456
1457 /**
1458  Write an octal as a string.
1459 **/
1460
1461 const char *octal_string(int i)
1462 {
1463         static char ret[64];
1464         if (i == -1)
1465                 return "-1";
1466         slprintf(ret, sizeof(ret)-1, "0%o", i);
1467         return ret;
1468 }
1469
1470
1471 /**
1472  Truncate a string at a specified length.
1473 **/
1474
1475 char *string_truncate(char *s, unsigned int length)
1476 {
1477         if (s && strlen(s) > length)
1478                 s[length] = 0;
1479         return s;
1480 }
1481
1482 /**
1483  Strchr and strrchr_m are very hard to do on general multi-byte strings.
1484  We convert via ucs2 for now.
1485 **/
1486
1487 char *strchr_m(const char *src, char c)
1488 {
1489         smb_ucs2_t *ws = NULL;
1490         char *s2 = NULL;
1491         smb_ucs2_t *p;
1492         const char *s;
1493         char *ret;
1494
1495         /* characters below 0x3F are guaranteed to not appear in
1496            non-initial position in multi-byte charsets */
1497         if ((c & 0xC0) == 0) {
1498                 return strchr(src, c);
1499         }
1500
1501         /* this is quite a common operation, so we want it to be
1502            fast. We optimise for the ascii case, knowing that all our
1503            supported multi-byte character sets are ascii-compatible
1504            (ie. they match for the first 128 chars) */
1505
1506         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1507                 if (*s == c)
1508                         return (char *)s;
1509         }
1510
1511         if (!*s)
1512                 return NULL;
1513
1514 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1515         /* With compose characters we must restart from the beginning. JRA. */
1516         s = src;
1517 #endif
1518
1519         if (push_ucs2_allocate(&ws, s)==(size_t)-1) {
1520                 /* Wrong answer, but what can we do... */
1521                 return strchr(src, c);
1522         }
1523         p = strchr_w(ws, UCS2_CHAR(c));
1524         if (!p) {
1525                 SAFE_FREE(ws);
1526                 return NULL;
1527         }
1528         *p = 0;
1529         if (pull_ucs2_allocate(&s2, ws)==(size_t)-1) {
1530                 SAFE_FREE(ws);
1531                 /* Wrong answer, but what can we do... */
1532                 return strchr(src, c);
1533         }
1534         ret = (char *)(s+strlen(s2));
1535         SAFE_FREE(ws);
1536         SAFE_FREE(s2);
1537         return ret;
1538 }
1539
1540 char *strrchr_m(const char *s, char c)
1541 {
1542         /* characters below 0x3F are guaranteed to not appear in
1543            non-initial position in multi-byte charsets */
1544         if ((c & 0xC0) == 0) {
1545                 return strrchr(s, c);
1546         }
1547
1548         /* this is quite a common operation, so we want it to be
1549            fast. We optimise for the ascii case, knowing that all our
1550            supported multi-byte character sets are ascii-compatible
1551            (ie. they match for the first 128 chars). Also, in Samba
1552            we only search for ascii characters in 'c' and that
1553            in all mb character sets with a compound character
1554            containing c, if 'c' is not a match at position
1555            p, then p[-1] > 0x7f. JRA. */
1556
1557         {
1558                 size_t len = strlen(s);
1559                 const char *cp = s;
1560                 bool got_mb = false;
1561
1562                 if (len == 0)
1563                         return NULL;
1564                 cp += (len - 1);
1565                 do {
1566                         if (c == *cp) {
1567                                 /* Could be a match. Part of a multibyte ? */
1568                                 if ((cp > s) &&
1569                                         (((unsigned char)cp[-1]) & 0x80)) {
1570                                         /* Yep - go slow :-( */
1571                                         got_mb = true;
1572                                         break;
1573                                 }
1574                                 /* No - we have a match ! */
1575                                 return (char *)cp;
1576                         }
1577                 } while (cp-- != s);
1578                 if (!got_mb)
1579                         return NULL;
1580         }
1581
1582         /* String contained a non-ascii char. Slow path. */
1583         {
1584                 smb_ucs2_t *ws = NULL;
1585                 char *s2 = NULL;
1586                 smb_ucs2_t *p;
1587                 char *ret;
1588
1589                 if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1590                         /* Wrong answer, but what can we do. */
1591                         return strrchr(s, c);
1592                 }
1593                 p = strrchr_w(ws, UCS2_CHAR(c));
1594                 if (!p) {
1595                         SAFE_FREE(ws);
1596                         return NULL;
1597                 }
1598                 *p = 0;
1599                 if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1600                         SAFE_FREE(ws);
1601                         /* Wrong answer, but what can we do. */
1602                         return strrchr(s, c);
1603                 }
1604                 ret = (char *)(s+strlen(s2));
1605                 SAFE_FREE(ws);
1606                 SAFE_FREE(s2);
1607                 return ret;
1608         }
1609 }
1610
1611 /***********************************************************************
1612  Return the equivalent of doing strrchr 'n' times - always going
1613  backwards.
1614 ***********************************************************************/
1615
1616 char *strnrchr_m(const char *s, char c, unsigned int n)
1617 {
1618         smb_ucs2_t *ws = NULL;
1619         char *s2 = NULL;
1620         smb_ucs2_t *p;
1621         char *ret;
1622
1623         if (push_ucs2_allocate(&ws,s)==(size_t)-1) {
1624                 /* Too hard to try and get right. */
1625                 return NULL;
1626         }
1627         p = strnrchr_w(ws, UCS2_CHAR(c), n);
1628         if (!p) {
1629                 SAFE_FREE(ws);
1630                 return NULL;
1631         }
1632         *p = 0;
1633         if (pull_ucs2_allocate(&s2,ws)==(size_t)-1) {
1634                 SAFE_FREE(ws);
1635                 /* Too hard to try and get right. */
1636                 return NULL;
1637         }
1638         ret = (char *)(s+strlen(s2));
1639         SAFE_FREE(ws);
1640         SAFE_FREE(s2);
1641         return ret;
1642 }
1643
1644 /***********************************************************************
1645  strstr_m - We convert via ucs2 for now.
1646 ***********************************************************************/
1647
1648 char *strstr_m(const char *src, const char *findstr)
1649 {
1650         smb_ucs2_t *p;
1651         smb_ucs2_t *src_w, *find_w;
1652         const char *s;
1653         char *s2;
1654         char *retp;
1655
1656         size_t findstr_len = 0;
1657
1658         /* for correctness */
1659         if (!findstr[0]) {
1660                 return (char*)src;
1661         }
1662
1663         /* Samba does single character findstr calls a *lot*. */
1664         if (findstr[1] == '\0')
1665                 return strchr_m(src, *findstr);
1666
1667         /* We optimise for the ascii case, knowing that all our
1668            supported multi-byte character sets are ascii-compatible
1669            (ie. they match for the first 128 chars) */
1670
1671         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1672                 if (*s == *findstr) {
1673                         if (!findstr_len)
1674                                 findstr_len = strlen(findstr);
1675
1676                         if (strncmp(s, findstr, findstr_len) == 0) {
1677                                 return (char *)s;
1678                         }
1679                 }
1680         }
1681
1682         if (!*s)
1683                 return NULL;
1684
1685 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1686         /* 'make check' fails unless we do this */
1687
1688         /* With compose characters we must restart from the beginning. JRA. */
1689         s = src;
1690 #endif
1691
1692         if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1693                 DEBUG(0,("strstr_m: src malloc fail\n"));
1694                 return NULL;
1695         }
1696
1697         if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1698                 SAFE_FREE(src_w);
1699                 DEBUG(0,("strstr_m: find malloc fail\n"));
1700                 return NULL;
1701         }
1702
1703         p = strstr_w(src_w, find_w);
1704
1705         if (!p) {
1706                 SAFE_FREE(src_w);
1707                 SAFE_FREE(find_w);
1708                 return NULL;
1709         }
1710
1711         *p = 0;
1712         if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1713                 SAFE_FREE(src_w);
1714                 SAFE_FREE(find_w);
1715                 DEBUG(0,("strstr_m: dest malloc fail\n"));
1716                 return NULL;
1717         }
1718         retp = (char *)(s+strlen(s2));
1719         SAFE_FREE(src_w);
1720         SAFE_FREE(find_w);
1721         SAFE_FREE(s2);
1722         return retp;
1723 }
1724
1725 /**
1726  Convert a string to lower case.
1727 **/
1728
1729 void strlower_m(char *s)
1730 {
1731         size_t len;
1732         int errno_save;
1733
1734         /* this is quite a common operation, so we want it to be
1735            fast. We optimise for the ascii case, knowing that all our
1736            supported multi-byte character sets are ascii-compatible
1737            (ie. they match for the first 128 chars) */
1738
1739         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1740                 *s = tolower_ascii((unsigned char)*s);
1741                 s++;
1742         }
1743
1744         if (!*s)
1745                 return;
1746
1747         /* I assume that lowercased string takes the same number of bytes
1748          * as source string even in UTF-8 encoding. (VIV) */
1749         len = strlen(s) + 1;
1750         errno_save = errno;
1751         errno = 0;
1752         unix_strlower(s,len,s,len);
1753         /* Catch mb conversion errors that may not terminate. */
1754         if (errno)
1755                 s[len-1] = '\0';
1756         errno = errno_save;
1757 }
1758
1759 /**
1760  Convert a string to upper case.
1761 **/
1762
1763 void strupper_m(char *s)
1764 {
1765         size_t len;
1766         int errno_save;
1767
1768         /* this is quite a common operation, so we want it to be
1769            fast. We optimise for the ascii case, knowing that all our
1770            supported multi-byte character sets are ascii-compatible
1771            (ie. they match for the first 128 chars) */
1772
1773         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1774                 *s = toupper_ascii((unsigned char)*s);
1775                 s++;
1776         }
1777
1778         if (!*s)
1779                 return;
1780
1781         /* I assume that lowercased string takes the same number of bytes
1782          * as source string even in multibyte encoding. (VIV) */
1783         len = strlen(s) + 1;
1784         errno_save = errno;
1785         errno = 0;
1786         unix_strupper(s,len,s,len);
1787         /* Catch mb conversion errors that may not terminate. */
1788         if (errno)
1789                 s[len-1] = '\0';
1790         errno = errno_save;
1791 }
1792
1793 /**
1794  Count the number of UCS2 characters in a string. Normally this will
1795  be the same as the number of bytes in a string for single byte strings,
1796  but will be different for multibyte.
1797 **/
1798
1799 size_t strlen_m(const char *s)
1800 {
1801         size_t count = 0;
1802
1803         if (!s) {
1804                 return 0;
1805         }
1806
1807         while (*s && !(((uint8_t)*s) & 0x80)) {
1808                 s++;
1809                 count++;
1810         }
1811
1812         if (!*s) {
1813                 return count;
1814         }
1815
1816         while (*s) {
1817                 size_t c_size;
1818                 codepoint_t c = next_codepoint(s, &c_size);
1819                 if (c < 0x10000) {
1820                         /* Unicode char fits into 16 bits. */
1821                         count += 1;
1822                 } else {
1823                         /* Double-width unicode char - 32 bits. */
1824                         count += 2;
1825                 }
1826                 s += c_size;
1827         }
1828
1829         return count;
1830 }
1831
1832 /**
1833  Count the number of UCS2 characters in a string including the null
1834  terminator.
1835 **/
1836
1837 size_t strlen_m_term(const char *s)
1838 {
1839         if (!s) {
1840                 return 0;
1841         }
1842         return strlen_m(s) + 1;
1843 }
1844
1845 /*
1846  * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1847  * if a string is there, include the terminator.
1848  */
1849
1850 size_t strlen_m_term_null(const char *s)
1851 {
1852         size_t len;
1853         if (!s) {
1854                 return 0;
1855         }
1856         len = strlen_m(s);
1857         if (len == 0) {
1858                 return 0;
1859         }
1860
1861         return len+1;
1862 }
1863 /**
1864  Return a RFC2254 binary string representation of a buffer.
1865  Used in LDAP filters.
1866  Caller must free.
1867 **/
1868
1869 char *binary_string_rfc2254(char *buf, int len)
1870 {
1871         char *s;
1872         int i, j;
1873         const char *hex = "0123456789ABCDEF";
1874         s = (char *)SMB_MALLOC(len * 3 + 1);
1875         if (!s)
1876                 return NULL;
1877         for (j=i=0;i<len;i++) {
1878                 s[j] = '\\';
1879                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1880                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1881                 j += 3;
1882         }
1883         s[j] = 0;
1884         return s;
1885 }
1886
1887 char *binary_string(char *buf, int len)
1888 {
1889         char *s;
1890         int i, j;
1891         const char *hex = "0123456789ABCDEF";
1892         s = (char *)SMB_MALLOC(len * 2 + 1);
1893         if (!s)
1894                 return NULL;
1895         for (j=i=0;i<len;i++) {
1896                 s[j]   = hex[((unsigned char)buf[i]) >> 4];
1897                 s[j+1] = hex[((unsigned char)buf[i]) & 0xF];
1898                 j += 2;
1899         }
1900         s[j] = 0;
1901         return s;
1902 }
1903 /**
1904  Just a typesafety wrapper for snprintf into a pstring.
1905 **/
1906
1907  int pstr_sprintf(pstring s, const char *fmt, ...)
1908 {
1909         va_list ap;
1910         int ret;
1911
1912         va_start(ap, fmt);
1913         ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1914         va_end(ap);
1915         return ret;
1916 }
1917
1918
1919 /**
1920  Just a typesafety wrapper for snprintf into a fstring.
1921 **/
1922
1923 int fstr_sprintf(fstring s, const char *fmt, ...)
1924 {
1925         va_list ap;
1926         int ret;
1927
1928         va_start(ap, fmt);
1929         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1930         va_end(ap);
1931         return ret;
1932 }
1933
1934 /**
1935  List of Strings manipulation functions
1936 **/
1937
1938 #define S_LIST_ABS 16 /* List Allocation Block Size */
1939
1940 static char **str_list_make_internal(TALLOC_CTX *mem_ctx,
1941                 const char *string,
1942                 const char *sep)
1943 {
1944         char **list, **rlist;
1945         const char *str;
1946         char *s;
1947         int num, lsize;
1948         pstring tok;
1949
1950         if (!string || !*string)
1951                 return NULL;
1952         if (mem_ctx) {
1953                 s = talloc_strdup(mem_ctx, string);
1954         } else {
1955                 s = SMB_STRDUP(string);
1956         }
1957         if (!s) {
1958                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1959                 return NULL;
1960         }
1961         if (!sep) sep = LIST_SEP;
1962
1963         num = lsize = 0;
1964         list = NULL;
1965
1966         str = s;
1967         while (next_token(&str, tok, sep, sizeof(tok))) {
1968                 if (num == lsize) {
1969                         lsize += S_LIST_ABS;
1970                         if (mem_ctx) {
1971                                 rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list,
1972                                                 char *, lsize +1);
1973                         } else {
1974                                 /* We need to keep the old list on
1975                                  * error so we can free the elements
1976                                    if the realloc fails. */
1977                                 rlist =SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
1978                                                 char *, lsize +1);
1979                         }
1980                         if (!rlist) {
1981                                 DEBUG(0,("str_list_make: "
1982                                         "Unable to allocate memory"));
1983                                 str_list_free(&list);
1984                                 if (mem_ctx) {
1985                                         TALLOC_FREE(s);
1986                                 } else {
1987                                         SAFE_FREE(s);
1988                                 }
1989                                 return NULL;
1990                         } else {
1991                                 list = rlist;
1992                         }
1993                         memset (&list[num], 0,
1994                                         ((sizeof(char**)) * (S_LIST_ABS +1)));
1995                 }
1996
1997                 if (mem_ctx) {
1998                         list[num] = talloc_strdup(mem_ctx, tok);
1999                 } else {
2000                         list[num] = SMB_STRDUP(tok);
2001                 }
2002
2003                 if (!list[num]) {
2004                         DEBUG(0,("str_list_make: Unable to allocate memory"));
2005                         str_list_free(&list);
2006                         if (mem_ctx) {
2007                                 TALLOC_FREE(s);
2008                         } else {
2009                                 SAFE_FREE(s);
2010                         }
2011                         return NULL;
2012                 }
2013
2014                 num++;
2015         }
2016
2017         if (mem_ctx) {
2018                 TALLOC_FREE(s);
2019         } else {
2020                 SAFE_FREE(s);
2021         }
2022
2023         return list;
2024 }
2025
2026 char **str_list_make_talloc(TALLOC_CTX *mem_ctx,
2027                 const char *string,
2028                 const char *sep)
2029 {
2030         return str_list_make_internal(mem_ctx, string, sep);
2031 }
2032
2033 char **str_list_make(const char *string, const char *sep)
2034 {
2035         return str_list_make_internal(NULL, string, sep);
2036 }
2037
2038 bool str_list_copy(char ***dest, const char **src)
2039 {
2040         char **list, **rlist;
2041         int num, lsize;
2042
2043         *dest = NULL;
2044         if (!src)
2045                 return false;
2046
2047         num = lsize = 0;
2048         list = NULL;
2049
2050         while (src[num]) {
2051                 if (num == lsize) {
2052                         lsize += S_LIST_ABS;
2053                         rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
2054                                         char *, lsize +1);
2055                         if (!rlist) {
2056                                 DEBUG(0,("str_list_copy: "
2057                                         "Unable to re-allocate memory"));
2058                                 str_list_free(&list);
2059                                 return false;
2060                         } else {
2061                                 list = rlist;
2062                         }
2063                         memset (&list[num], 0,
2064                                         ((sizeof(char **)) * (S_LIST_ABS +1)));
2065                 }
2066
2067                 list[num] = SMB_STRDUP(src[num]);
2068                 if (!list[num]) {
2069                         DEBUG(0,("str_list_copy: Unable to allocate memory"));
2070                         str_list_free(&list);
2071                         return false;
2072                 }
2073
2074                 num++;
2075         }
2076
2077         *dest = list;
2078         return true;
2079 }
2080
2081 /**
2082  * Return true if all the elements of the list match exactly.
2083  **/
2084 bool str_list_compare(char **list1, char **list2)
2085 {
2086         int num;
2087
2088         if (!list1 || !list2)
2089                 return (list1 == list2);
2090
2091         for (num = 0; list1[num]; num++) {
2092                 if (!list2[num])
2093                         return false;
2094                 if (!strcsequal(list1[num], list2[num]))
2095                         return false;
2096         }
2097         if (list2[num])
2098                 return false; /* if list2 has more elements than list1 fail */
2099
2100         return true;
2101 }
2102
2103 static void str_list_free_internal(TALLOC_CTX *mem_ctx, char ***list)
2104 {
2105         char **tlist;
2106
2107         if (!list || !*list)
2108                 return;
2109         tlist = *list;
2110         for(; *tlist; tlist++) {
2111                 if (mem_ctx) {
2112                         TALLOC_FREE(*tlist);
2113                 } else {
2114                         SAFE_FREE(*tlist);
2115                 }
2116         }
2117         if (mem_ctx) {
2118                 TALLOC_FREE(*tlist);
2119         } else {
2120                 SAFE_FREE(*list);
2121         }
2122 }
2123
2124 void str_list_free_talloc(TALLOC_CTX *mem_ctx, char ***list)
2125 {
2126         str_list_free_internal(mem_ctx, list);
2127 }
2128
2129 void str_list_free(char ***list)
2130 {
2131         str_list_free_internal(NULL, list);
2132 }
2133
2134 /******************************************************************************
2135  *****************************************************************************/
2136
2137 int str_list_count( const char **list )
2138 {
2139         int i = 0;
2140
2141         if ( ! list )
2142                 return 0;
2143
2144         /* count the number of list members */
2145
2146         for ( i=0; *list; i++, list++ );
2147
2148         return i;
2149 }
2150
2151 /******************************************************************************
2152  version of standard_sub_basic() for string lists; uses alloc_sub_basic()
2153  for the work
2154  *****************************************************************************/
2155
2156 bool str_list_sub_basic( char **list, const char *smb_name,
2157                          const char *domain_name )
2158 {
2159         char *s, *tmpstr;
2160
2161         while ( *list ) {
2162                 s = *list;
2163                 tmpstr = alloc_sub_basic(smb_name, domain_name, s);
2164                 if ( !tmpstr ) {
2165                         DEBUG(0,("str_list_sub_basic: "
2166                                 "alloc_sub_basic() return NULL!\n"));
2167                         return false;
2168                 }
2169
2170                 SAFE_FREE(*list);
2171                 *list = tmpstr;
2172
2173                 list++;
2174         }
2175
2176         return true;
2177 }
2178
2179 /******************************************************************************
2180  substritute a specific pattern in a string list
2181  *****************************************************************************/
2182
2183 bool str_list_substitute(char **list, const char *pattern, const char *insert)
2184 {
2185         char *p, *s, *t;
2186         ssize_t ls, lp, li, ld, i, d;
2187
2188         if (!list)
2189                 return false;
2190         if (!pattern)
2191                 return false;
2192         if (!insert)
2193                 return false;
2194
2195         lp = (ssize_t)strlen(pattern);
2196         li = (ssize_t)strlen(insert);
2197         ld = li -lp;
2198
2199         while (*list) {
2200                 s = *list;
2201                 ls = (ssize_t)strlen(s);
2202
2203                 while ((p = strstr_m(s, pattern))) {
2204                         t = *list;
2205                         d = p -t;
2206                         if (ld) {
2207                                 t = (char *) SMB_MALLOC(ls +ld +1);
2208                                 if (!t) {
2209                                         DEBUG(0,("str_list_substitute: "
2210                                                 "Unable to allocate memory"));
2211                                         return false;
2212                                 }
2213                                 memcpy(t, *list, d);
2214                                 memcpy(t +d +li, p +lp, ls -d -lp +1);
2215                                 SAFE_FREE(*list);
2216                                 *list = t;
2217                                 ls += ld;
2218                                 s = t +d +li;
2219                         }
2220
2221                         for (i = 0; i < li; i++) {
2222                                 switch (insert[i]) {
2223                                         case '`':
2224                                         case '"':
2225                                         case '\'':
2226                                         case ';':
2227                                         case '$':
2228                                         case '%':
2229                                         case '\r':
2230                                         case '\n':
2231                                                 t[d +i] = '_';
2232                                                 break;
2233                                         default:
2234                                                 t[d +i] = insert[i];
2235                                 }
2236                         }
2237                 }
2238
2239                 list++;
2240         }
2241
2242         return true;
2243 }
2244
2245
2246 #define IPSTR_LIST_SEP  ","
2247 #define IPSTR_LIST_CHAR ','
2248
2249 /**
2250  * Add ip string representation to ipstr list. Used also
2251  * as part of @function ipstr_list_make
2252  *
2253  * @param ipstr_list pointer to string containing ip list;
2254  *        MUST BE already allocated and IS reallocated if necessary
2255  * @param ipstr_size pointer to current size of ipstr_list (might be changed
2256  *        as a result of reallocation)
2257  * @param ip IP address which is to be added to list
2258  * @return pointer to string appended with new ip and possibly
2259  *         reallocated to new length
2260  **/
2261
2262 static char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
2263 {
2264         char *new_ipstr = NULL;
2265         char addr_buf[INET6_ADDRSTRLEN];
2266
2267         /* arguments checking */
2268         if (!ipstr_list || !service) {
2269                 return NULL;
2270         }
2271
2272         print_sockaddr(addr_buf,
2273                         sizeof(addr_buf),
2274                         &service->ss);
2275
2276         /* attempt to convert ip to a string and append colon separator to it */
2277         if (*ipstr_list) {
2278                 if (service->ss.ss_family == AF_INET) {
2279                         /* IPv4 */
2280                         asprintf(&new_ipstr, "%s%s%s:%d",
2281                                         *ipstr_list,
2282                                         IPSTR_LIST_SEP,
2283                                         addr_buf,
2284                                         service->port);
2285                 } else {
2286                         /* IPv6 */
2287                         asprintf(&new_ipstr, "%s%s[%s]:%d",
2288                                         *ipstr_list,
2289                                         IPSTR_LIST_SEP,
2290                                         addr_buf,
2291                                         service->port);
2292                 }
2293                 SAFE_FREE(*ipstr_list);
2294         } else {
2295                 if (service->ss.ss_family == AF_INET) {
2296                         /* IPv4 */
2297                         asprintf(&new_ipstr, "%s:%d",
2298                                 addr_buf,
2299                                 service->port);
2300                 } else {
2301                         /* IPv6 */
2302                         asprintf(&new_ipstr, "[%s]:%d",
2303                                 addr_buf,
2304                                 service->port);
2305                 }
2306         }
2307         *ipstr_list = new_ipstr;
2308         return *ipstr_list;
2309 }
2310
2311 /**
2312  * Allocate and initialise an ipstr list using ip adresses
2313  * passed as arguments.
2314  *
2315  * @param ipstr_list pointer to string meant to be allocated and set
2316  * @param ip_list array of ip addresses to place in the list
2317  * @param ip_count number of addresses stored in ip_list
2318  * @return pointer to allocated ip string
2319  **/
2320
2321 char *ipstr_list_make(char **ipstr_list,
2322                         const struct ip_service *ip_list,
2323                         int ip_count)
2324 {
2325         int i;
2326
2327         /* arguments checking */
2328         if (!ip_list || !ipstr_list) {
2329                 return 0;
2330         }
2331
2332         *ipstr_list = NULL;
2333
2334         /* process ip addresses given as arguments */
2335         for (i = 0; i < ip_count; i++) {
2336                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
2337         }
2338
2339         return (*ipstr_list);
2340 }
2341
2342
2343 /**
2344  * Parse given ip string list into array of ip addresses
2345  * (as ip_service structures)
2346  *    e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
2347  *
2348  * @param ipstr ip string list to be parsed
2349  * @param ip_list pointer to array of ip addresses which is
2350  *        allocated by this function and must be freed by caller
2351  * @return number of succesfully parsed addresses
2352  **/
2353
2354 int ipstr_list_parse(const char *ipstr_list, struct ip_service **ip_list)
2355 {
2356         fstring token_str;
2357         size_t count;
2358         int i;
2359
2360         if (!ipstr_list || !ip_list)
2361                 return 0;
2362
2363         count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
2364         if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
2365                 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
2366                                         (unsigned long)count));
2367                 return 0;
2368         }
2369
2370         for ( i=0; next_token(&ipstr_list, token_str,
2371                                 IPSTR_LIST_SEP, FSTRING_LEN) && i<count; i++ ) {
2372                 char *s = token_str;
2373                 char *p = strrchr(token_str, ':');
2374
2375                 if (p) {
2376                         *p = 0;
2377                         (*ip_list)[i].port = atoi(p+1);
2378                 }
2379
2380                 /* convert single token to ip address */
2381                 if (token_str[0] == '[') {
2382                         /* IPv6 address. */
2383                         s++;
2384                         p = strchr(token_str, ']');
2385                         if (!p) {
2386                                 continue;
2387                         }
2388                         *p = '\0';
2389                 }
2390                 if (!interpret_string_addr(&(*ip_list)[i].ss,
2391                                         s,
2392                                         AI_NUMERICHOST)) {
2393                         continue;
2394                 }
2395         }
2396
2397         return count;
2398 }
2399
2400 /**
2401  * Safely free ip string list
2402  *
2403  * @param ipstr_list ip string list to be freed
2404  **/
2405
2406 void ipstr_list_free(char* ipstr_list)
2407 {
2408         SAFE_FREE(ipstr_list);
2409 }
2410
2411 /**
2412  Unescape a URL encoded string, in place.
2413 **/
2414
2415 void rfc1738_unescape(char *buf)
2416 {
2417         char *p=buf;
2418
2419         while (p && *p && (p=strchr_m(p,'%'))) {
2420                 int c1 = p[1];
2421                 int c2 = p[2];
2422
2423                 if (c1 >= '0' && c1 <= '9')
2424                         c1 = c1 - '0';
2425                 else if (c1 >= 'A' && c1 <= 'F')
2426                         c1 = 10 + c1 - 'A';
2427                 else if (c1 >= 'a' && c1 <= 'f')
2428                         c1 = 10 + c1 - 'a';
2429                 else {p++; continue;}
2430
2431                 if (c2 >= '0' && c2 <= '9')
2432                         c2 = c2 - '0';
2433                 else if (c2 >= 'A' && c2 <= 'F')
2434                         c2 = 10 + c2 - 'A';
2435                 else if (c2 >= 'a' && c2 <= 'f')
2436                         c2 = 10 + c2 - 'a';
2437                 else {p++; continue;}
2438
2439                 *p = (c1<<4) | c2;
2440
2441                 memmove(p+1, p+3, strlen(p+3)+1);
2442                 p++;
2443         }
2444 }
2445
2446 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2447
2448 /**
2449  * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
2450  **/
2451 DATA_BLOB base64_decode_data_blob(const char *s)
2452 {
2453         int bit_offset, byte_offset, idx, i, n;
2454         DATA_BLOB decoded = data_blob(s, strlen(s)+1);
2455         unsigned char *d = decoded.data;
2456         char *p;
2457
2458         n=i=0;
2459
2460         while (*s && (p=strchr_m(b64,*s))) {
2461                 idx = (int)(p - b64);
2462                 byte_offset = (i*6)/8;
2463                 bit_offset = (i*6)%8;
2464                 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2465                 if (bit_offset < 3) {
2466                         d[byte_offset] |= (idx << (2-bit_offset));
2467                         n = byte_offset+1;
2468                 } else {
2469                         d[byte_offset] |= (idx >> (bit_offset-2));
2470                         d[byte_offset+1] = 0;
2471                         d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2472                         n = byte_offset+2;
2473                 }
2474                 s++; i++;
2475         }
2476
2477         if ((n > 0) && (*s == '=')) {
2478                 n -= 1;
2479         }
2480
2481         /* fix up length */
2482         decoded.length = n;
2483         return decoded;
2484 }
2485
2486 /**
2487  * Decode a base64 string in-place - wrapper for the above
2488  **/
2489 void base64_decode_inplace(char *s)
2490 {
2491         DATA_BLOB decoded = base64_decode_data_blob(s);
2492
2493         if ( decoded.length != 0 ) {
2494                 memcpy(s, decoded.data, decoded.length);
2495
2496                 /* null terminate */
2497                 s[decoded.length] = '\0';
2498         } else {
2499                 *s = '\0';
2500         }
2501
2502         data_blob_free(&decoded);
2503 }
2504
2505 /**
2506  * Encode a base64 string into a malloc()ed string caller to free.
2507  *
2508  * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
2509  * with adjustments
2510  **/
2511
2512 char *base64_encode_data_blob(DATA_BLOB data)
2513 {
2514         int bits = 0;
2515         int char_count = 0;
2516         size_t out_cnt, len, output_len;
2517         char *result;
2518
2519         if (!data.length || !data.data)
2520                 return NULL;
2521
2522         out_cnt = 0;
2523         len = data.length;
2524         output_len = data.length * 2;
2525         result = TALLOC_ARRAY(talloc_tos(), char, output_len); /* get us plenty of space */
2526         SMB_ASSERT(result != NULL);
2527
2528         while (len-- && out_cnt < (data.length * 2) - 5) {
2529                 int c = (unsigned char) *(data.data++);
2530                 bits += c;
2531                 char_count++;
2532                 if (char_count == 3) {
2533                         result[out_cnt++] = b64[bits >> 18];
2534                         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2535                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2536                         result[out_cnt++] = b64[bits & 0x3f];
2537                         bits = 0;
2538                         char_count = 0;
2539                 } else {
2540                         bits <<= 8;
2541                 }
2542         }
2543         if (char_count != 0) {
2544                 bits <<= 16 - (8 * char_count);
2545                 result[out_cnt++] = b64[bits >> 18];
2546                 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2547                 if (char_count == 1) {
2548                         result[out_cnt++] = '=';
2549                         result[out_cnt++] = '=';
2550                 } else {
2551                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2552                         result[out_cnt++] = '=';
2553                 }
2554         }
2555         result[out_cnt] = '\0'; /* terminate */
2556         return result;
2557 }
2558
2559 /* read a SMB_BIG_UINT from a string */
2560 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2561 {
2562
2563         SMB_BIG_UINT val = -1;
2564         const char *p = nptr;
2565
2566         if (!p) {
2567                 if (entptr) {
2568                         *entptr = p;
2569                 }
2570                 return val;
2571         }
2572
2573         while (*p && isspace(*p))
2574                 p++;
2575
2576 #ifdef LARGE_SMB_OFF_T
2577         sscanf(p,"%llu",&val);
2578 #else /* LARGE_SMB_OFF_T */
2579         sscanf(p,"%lu",&val);
2580 #endif /* LARGE_SMB_OFF_T */
2581         if (entptr) {
2582                 while (*p && isdigit(*p))
2583                         p++;
2584                 *entptr = p;
2585         }
2586
2587         return val;
2588 }
2589
2590 /* Convert a size specification to a count of bytes. We accept the following
2591  * suffixes:
2592  *          bytes if there is no suffix
2593  *      kK  kibibytes
2594  *      mM  mebibytes
2595  *      gG  gibibytes
2596  *      tT  tibibytes
2597  *      pP  whatever the ISO name for petabytes is
2598  *
2599  *  Returns 0 if the string can't be converted.
2600  */
2601 SMB_OFF_T conv_str_size(const char * str)
2602 {
2603         SMB_OFF_T lval;
2604         char * end;
2605
2606         if (str == NULL || *str == '\0') {
2607                 return 0;
2608         }
2609
2610 #ifdef HAVE_STRTOULL
2611         if (sizeof(SMB_OFF_T) == 8) {
2612             lval = strtoull(str, &end, 10 /* base */);
2613         } else {
2614             lval = strtoul(str, &end, 10 /* base */);
2615         }
2616 #else
2617         lval = strtoul(str, &end, 10 /* base */);
2618 #endif
2619
2620         if (end == NULL || end == str) {
2621                 return 0;
2622         }
2623
2624         if (*end) {
2625                 SMB_OFF_T lval_orig = lval;
2626
2627                 if (strwicmp(end, "K") == 0) {
2628                         lval *= (SMB_OFF_T)1024;
2629                 } else if (strwicmp(end, "M") == 0) {
2630                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2631                 } else if (strwicmp(end, "G") == 0) {
2632                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2633                                 (SMB_OFF_T)1024);
2634                 } else if (strwicmp(end, "T") == 0) {
2635                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2636                                 (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2637                 } else if (strwicmp(end, "P") == 0) {
2638                         lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2639                                 (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2640                                 (SMB_OFF_T)1024);
2641                 } else {
2642                         return 0;
2643                 }
2644
2645                 /* Primitive attempt to detect wrapping on platforms with
2646                  * 4-byte SMB_OFF_T. It's better to let the caller handle
2647                  * a failure than some random number.
2648                  */
2649                 if (lval_orig <= lval) {
2650                         return 0;
2651                 }
2652         }
2653
2654         return lval;
2655 }
2656
2657 void string_append(char **left, const char *right)
2658 {
2659         int new_len = strlen(right) + 1;
2660
2661         if (*left == NULL) {
2662                 *left = (char *)SMB_MALLOC(new_len);
2663                 *left[0] = '\0';
2664         } else {
2665                 new_len += strlen(*left);
2666                 *left = (char *)SMB_REALLOC(*left, new_len);
2667         }
2668
2669         if (*left == NULL) {
2670                 return;
2671         }
2672
2673         safe_strcat(*left, right, new_len-1);
2674 }
2675
2676 bool add_string_to_array(TALLOC_CTX *mem_ctx,
2677                          const char *str, const char ***strings,
2678                          int *num)
2679 {
2680         char *dup_str = talloc_strdup(mem_ctx, str);
2681
2682         *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings,
2683                         const char *, (*num)+1);
2684
2685         if ((*strings == NULL) || (dup_str == NULL)) {
2686                 *num = 0;
2687                 return false;
2688         }
2689
2690         (*strings)[*num] = dup_str;
2691         *num += 1;
2692         return true;
2693 }
2694
2695 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2696  * error checking in between. The indiation that something weird happened is
2697  * string==NULL */
2698
2699 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2700                     size_t *bufsize, const char *fmt, ...)
2701 {
2702         va_list ap;
2703         char *newstr;
2704         int ret;
2705         bool increased;
2706
2707         /* len<0 is an internal marker that something failed */
2708         if (*len < 0)
2709                 goto error;
2710
2711         if (*string == NULL) {
2712                 if (*bufsize == 0)
2713                         *bufsize = 128;
2714
2715                 *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2716                 if (*string == NULL)
2717                         goto error;
2718         }
2719
2720         va_start(ap, fmt);
2721         ret = vasprintf(&newstr, fmt, ap);
2722         va_end(ap);
2723
2724         if (ret < 0)
2725                 goto error;
2726
2727         increased = false;
2728
2729         while ((*len)+ret >= *bufsize) {
2730                 increased = true;
2731                 *bufsize *= 2;
2732                 if (*bufsize >= (1024*1024*256))
2733                         goto error;
2734         }
2735
2736         if (increased) {
2737                 *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2738                                                *bufsize);
2739                 if (*string == NULL) {
2740                         goto error;
2741                 }
2742         }
2743
2744         StrnCpy((*string)+(*len), newstr, ret);
2745         (*len) += ret;
2746         free(newstr);
2747         return;
2748
2749  error:
2750         *len = -1;
2751         *string = NULL;
2752 }
2753
2754 /*
2755    Returns the substring from src between the first occurrence of
2756    the char "front" and the first occurence of the char "back".
2757    Mallocs the return string which must be freed.  Not for use
2758    with wide character strings.
2759 */
2760 char *sstring_sub(const char *src, char front, char back)
2761 {
2762         char *temp1, *temp2, *temp3;
2763         ptrdiff_t len;
2764
2765         temp1 = strchr(src, front);
2766         if (temp1 == NULL) return NULL;
2767         temp2 = strchr(src, back);
2768         if (temp2 == NULL) return NULL;
2769         len = temp2 - temp1;
2770         if (len <= 0) return NULL;
2771         temp3 = (char*)SMB_MALLOC(len);
2772         if (temp3 == NULL) {
2773                 DEBUG(1,("Malloc failure in sstring_sub\n"));
2774                 return NULL;
2775         }
2776         memcpy(temp3, temp1+1, len-1);
2777         temp3[len-1] = '\0';
2778         return temp3;
2779 }
2780
2781 /********************************************************************
2782  Check a string for any occurrences of a specified list of invalid
2783  characters.
2784 ********************************************************************/
2785
2786 bool validate_net_name( const char *name,
2787                 const char *invalid_chars,
2788                 int max_len)
2789 {
2790         int i;
2791
2792         for ( i=0; i<max_len && name[i]; i++ ) {
2793                 /* fail if strchr_m() finds one of the invalid characters */
2794                 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
2795                         return false;
2796                 }
2797         }
2798
2799         return true;
2800 }
2801
2802
2803 /**
2804 return the number of bytes occupied by a buffer in ASCII format
2805 the result includes the null termination
2806 limited by 'n' bytes
2807 **/
2808 size_t ascii_len_n(const char *src, size_t n)
2809 {
2810         size_t len;
2811
2812         len = strnlen(src, n);
2813         if (len+1 <= n) {
2814                 len += 1;
2815         }
2816
2817         return len;
2818 }
2819
2820 /**
2821 return the number of bytes occupied by a buffer in CH_UTF16 format
2822 the result includes the null termination
2823 **/
2824 size_t utf16_len(const void *buf)
2825 {
2826         size_t len;
2827
2828         for (len = 0; SVAL(buf,len); len += 2) ;
2829
2830         return len + 2;
2831 }
2832
2833 /**
2834 return the number of bytes occupied by a buffer in CH_UTF16 format
2835 the result includes the null termination
2836 limited by 'n' bytes
2837 **/
2838 size_t utf16_len_n(const void *src, size_t n)
2839 {
2840         size_t len;
2841
2842         for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;
2843
2844         if (len+2 <= n) {
2845                 len += 2;
2846         }
2847
2848         return len;
2849 }
2850
2851 /*******************************************************************
2852  Add a shell escape character '\' to any character not in a known list
2853  of characters. UNIX charset format.
2854 *******************************************************************/
2855
2856 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
2857 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
2858
2859 char *escape_shell_string(const char *src)
2860 {
2861         size_t srclen = strlen(src);
2862         char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
2863         char *dest = ret;
2864         bool in_s_quote = false;
2865         bool in_d_quote = false;
2866         bool next_escaped = false;
2867
2868         if (!ret) {
2869                 return NULL;
2870         }
2871
2872         while (*src) {
2873                 size_t c_size;
2874                 codepoint_t c = next_codepoint(src, &c_size);
2875
2876                 if (c == INVALID_CODEPOINT) {
2877                         SAFE_FREE(ret);
2878                         return NULL;
2879                 }
2880
2881                 if (c_size > 1) {
2882                         memcpy(dest, src, c_size);
2883                         src += c_size;
2884                         dest += c_size;
2885                         next_escaped = false;
2886                         continue;
2887                 }
2888
2889                 /*
2890                  * Deal with backslash escaped state.
2891                  * This only lasts for one character.
2892                  */
2893
2894                 if (next_escaped) {
2895                         *dest++ = *src++;
2896                         next_escaped = false;
2897                         continue;
2898                 }
2899
2900                 /*
2901                  * Deal with single quote state. The
2902                  * only thing we care about is exiting
2903                  * this state.
2904                  */
2905
2906                 if (in_s_quote) {
2907                         if (*src == '\'') {
2908                                 in_s_quote = false;
2909                         }
2910                         *dest++ = *src++;
2911                         continue;
2912                 }
2913
2914                 /*
2915                  * Deal with double quote state. The most
2916                  * complex state. We must cope with \, meaning
2917                  * possibly escape next char (depending what it
2918                  * is), ", meaning exit this state, and possibly
2919                  * add an \ escape to any unprotected character
2920                  * (listed in INSIDE_DQUOTE_LIST).
2921                  */
2922
2923                 if (in_d_quote) {
2924                         if (*src == '\\') {
2925                                 /*
2926                                  * Next character might be escaped.
2927                                  * We have to peek. Inside double
2928                                  * quotes only INSIDE_DQUOTE_LIST
2929                                  * characters are escaped by a \.
2930                                  */
2931
2932                                 char nextchar;
2933
2934                                 c = next_codepoint(&src[1], &c_size);
2935                                 if (c == INVALID_CODEPOINT) {
2936                                         SAFE_FREE(ret);
2937                                         return NULL;
2938                                 }
2939                                 if (c_size > 1) {
2940                                         /*
2941                                          * Don't escape the next char.
2942                                          * Just copy the \.
2943                                          */
2944                                         *dest++ = *src++;
2945                                         continue;
2946                                 }
2947
2948                                 nextchar = src[1];
2949
2950                                 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
2951                                                         (int)nextchar)) {
2952                                         next_escaped = true;
2953                                 }
2954                                 *dest++ = *src++;
2955                                 continue;
2956                         }
2957
2958                         if (*src == '\"') {
2959                                 /* Exit double quote state. */
2960                                 in_d_quote = false;
2961                                 *dest++ = *src++;
2962                                 continue;
2963                         }
2964
2965                         /*
2966                          * We know the character isn't \ or ",
2967                          * so escape it if it's any of the other
2968                          * possible unprotected characters.
2969                          */
2970
2971                         if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
2972                                 *dest++ = '\\';
2973                         }
2974                         *dest++ = *src++;
2975                         continue;
2976                 }
2977
2978                 /*
2979                  * From here to the end of the loop we're
2980                  * not in the single or double quote state.
2981                  */
2982
2983                 if (*src == '\\') {
2984                         /* Next character must be escaped. */
2985                         next_escaped = true;
2986                         *dest++ = *src++;
2987                         continue;
2988                 }
2989
2990                 if (*src == '\'') {
2991                         /* Go into single quote state. */
2992                         in_s_quote = true;
2993                         *dest++ = *src++;
2994                         continue;
2995                 }
2996
2997                 if (*src == '\"') {
2998                         /* Go into double quote state. */
2999                         in_d_quote = true;
3000                         *dest++ = *src++;
3001                         continue;
3002                 }
3003
3004                 /* Check if we need to escape the character. */
3005
3006                 if (!strchr(INCLUDE_LIST, (int)*src)) {
3007                         *dest++ = '\\';
3008                 }
3009                 *dest++ = *src++;
3010         }
3011         *dest++ = '\0';
3012         return ret;
3013 }