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
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26 /**
  27  * @file
  28  * @brief String utilities.
  29  **/
  30
  31 /**
  32  * Get the next token from a string, return False if none found.
  33  * Handles double-quotes.
  34  *
  35  * Based on a routine by GJC@VILLAGE.COM.
  36  * Extensively modified by Andrew.Tridgell@anu.edu.au
  37  **/
  38 BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
  39 {
  40         char *s;
  41         char *pbuf;
  42         BOOL quoted;
  43         size_t len=1;
  44
  45         if (!ptr)
  46                 return(False);
  47
  48         s = (char *)*ptr;
  49
  50         /* default to simple separators */
  51         if (!sep)
  52                 sep = " \t\n\r";
  53
  54         /* find the first non sep char */
  55         while (*s && strchr_m(sep,*s))
  56                 s++;
  57
  58         /* nothing left? */
  59         if (! *s)
  60                 return(False);
  61
  62         /* copy over the token */
  63         pbuf = buff;
  64         for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
  65                 if ( *s == '\"' ) {
  66                         quoted = !quoted;
  67                 } else {
  68                         len++;
  69                         *pbuf++ = *s;
  70                 }
  71         }
  72
  73         *ptr = (*s) ? s+1 : s;
  74         *pbuf = 0;
  75
  76         return(True);
  77 }
  78
  79 /**
  80 This is like next_token but is not re-entrant and "remembers" the first
  81 parameter so you can pass NULL. This is useful for user interface code
  82 but beware the fact that it is not re-entrant!
  83 **/
  84
  85 static const char *last_ptr=NULL;
  86
  87 BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
  88 {
  89         BOOL ret;
  90         if (!ptr)
  91                 ptr = &last_ptr;
  92
  93         ret = next_token(ptr, buff, sep, bufsize);
  94         last_ptr = *ptr;
  95         return ret;
  96 }
  97
  98 static uint16 tmpbuf[sizeof(pstring)];
  99
 100 void set_first_token(char *ptr)
 101 {
 102         last_ptr = ptr;
 103 }
 104
 105 /**
 106  Convert list of tokens to array; dependent on above routine.
 107  Uses last_ptr from above - bit of a hack.
 108 **/
 109
 110 char **toktocliplist(int *ctok, const char *sep)
 111 {
 112         char *s=(char *)last_ptr;
 113         int ictok=0;
 114         char **ret, **iret;
 115
 116         if (!sep)
 117                 sep = " \t\n\r";
 118
 119         while(*s && strchr_m(sep,*s))
 120                 s++;
 121
 122         /* nothing left? */
 123         if (!*s)
 124                 return(NULL);
 125
 126         do {
 127                 ictok++;
 128                 while(*s && (!strchr_m(sep,*s)))
 129                         s++;
 130                 while(*s && strchr_m(sep,*s))
 131                         *s++=0;
 132         } while(*s);
 133
 134         *ctok=ictok;
 135         s=(char *)last_ptr;
 136
 137         if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
 138                 return NULL;
 139
 140         while(ictok--) {
 141                 *iret++=s;
 142                 if (ictok > 0) {
 143                         while(*s++)
 144                                 ;
 145                         while(!*s)
 146                                 s++;
 147                 }
 148         }
 149
 150         ret[*ctok] = NULL;
 151         return ret;
 152 }
 153
 154 /**
 155  * Case insensitive string compararison.
 156  *
 157  * iconv does not directly give us a way to compare strings in
 158  * arbitrary unix character sets -- all we can is convert and then
 159  * compare.  This is expensive.
 160  *
 161  * As an optimization, we do a first pass that considers only the
 162  * prefix of the strings that is entirely 7-bit.  Within this, we
 163  * check whether they have the same value.
 164  *
 165  * Hopefully this will often give the answer without needing to copy.
 166  * In particular it should speed comparisons to literal ascii strings
 167  * or comparisons of strings that are "obviously" different.
 168  *
 169  * If we find a non-ascii character we fall back to converting via
 170  * iconv.
 171  *
 172  * This should never be slower than convering the whole thing, and
 173  * often faster.
 174  *
 175  * A different optimization would be to compare for bitwise equality
 176  * in the binary encoding.  (It would be possible thought hairy to do
 177  * both simultaneously.)  But in that case if they turn out to be
 178  * different, we'd need to restart the whole thing.
 179  *
 180  * Even better is to implement strcasecmp for each encoding and use a
 181  * function pointer.
 182  **/
 183 int StrCaseCmp(const char *s, const char *t)
 184 {
 185
 186         const char * ps, * pt;
 187         size_t size;
 188         smb_ucs2_t *buffer_s, *buffer_t;
 189         int ret;
 190
 191         for (ps = s, pt = t; ; ps++, pt++) {
 192                 char us, ut;
 193
 194                 if (!*ps && !*pt)
 195                         return 0; /* both ended */
 196                 else if (!*ps)
 197                         return -1; /* s is a prefix */
 198                 else if (!*pt)
 199                         return +1; /* t is a prefix */
 200                 else if ((*ps & 0x80) || (*pt & 0x80))
 201                         /* not ascii anymore, do it the hard way from here on in */
 202                         break;
 203
 204                 us = toupper(*ps);
 205                 ut = toupper(*pt);
 206                 if (us == ut)
 207                         continue;
 208                 else if (us < ut)
 209                         return -1;
 210                 else if (us > ut)
 211                         return +1;
 212         }
 213
 214         size = push_ucs2_allocate(&buffer_s, s);
 215         if (size == (size_t)-1) {
 216                 return strcmp(s, t);
 217                 /* Not quite the right answer, but finding the right one
 218                    under this failure case is expensive, and it's pretty close */
 219         }
 220
 221         size = push_ucs2_allocate(&buffer_t, t);
 222         if (size == (size_t)-1) {
 223                 SAFE_FREE(buffer_s);
 224                 return strcmp(s, t);
 225                 /* Not quite the right answer, but finding the right one
 226                    under this failure case is expensive, and it's pretty close */
 227         }
 228
 229         ret = strcasecmp_w(buffer_s, buffer_t);
 230         SAFE_FREE(buffer_s);
 231         SAFE_FREE(buffer_t);
 232         return ret;
 233 }
 234
 235
 236 /**
 237  Case insensitive string compararison, length limited.
 238 **/
 239 int StrnCaseCmp(const char *s, const char *t, size_t n)
 240 {
 241         pstring buf1, buf2;
 242         unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
 243         unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
 244         return strncmp(buf1,buf2,n);
 245 }
 246
 247 /**
 248  * Compare 2 strings.
 249  *
 250  * @note The comparison is case-insensitive.
 251  **/
 252 BOOL strequal(const char *s1, const char *s2)
 253 {
 254         if (s1 == s2)
 255                 return(True);
 256         if (!s1 || !s2)
 257                 return(False);
 258
 259         return(StrCaseCmp(s1,s2)==0);
 260 }
 261
 262 /**
 263  * Compare 2 strings up to and including the nth char.
 264  *
 265  * @note The comparison is case-insensitive.
 266  **/
 267 BOOL strnequal(const char *s1,const char *s2,size_t n)
 268 {
 269   if (s1 == s2)
 270           return(True);
 271   if (!s1 || !s2 || !n)
 272           return(False);
 273
 274   return(StrnCaseCmp(s1,s2,n)==0);
 275 }
 276
 277 /**
 278  Compare 2 strings (case sensitive).
 279 **/
 280
 281 BOOL strcsequal(const char *s1,const char *s2)
 282 {
 283   if (s1 == s2)
 284           return(True);
 285   if (!s1 || !s2)
 286           return(False);
 287
 288   return(strcmp(s1,s2)==0);
 289 }
 290
 291 /**
 292 Do a case-insensitive, whitespace-ignoring string compare.
 293 **/
 294
 295 int strwicmp(const char *psz1, const char *psz2)
 296 {
 297         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 298         /* appropriate value. */
 299         if (psz1 == psz2)
 300                 return (0);
 301         else if (psz1 == NULL)
 302                 return (-1);
 303         else if (psz2 == NULL)
 304                 return (1);
 305
 306         /* sync the strings on first non-whitespace */
 307         while (1) {
 308                 while (isspace((int)*psz1))
 309                         psz1++;
 310                 while (isspace((int)*psz2))
 311                         psz2++;
 312                 if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0'
 313                     || *psz2 == '\0')
 314                         break;
 315                 psz1++;
 316                 psz2++;
 317         }
 318         return (*psz1 - *psz2);
 319 }
 320
 321
 322 /**
 323  Convert a string to upper case, but don't modify it.
 324 **/
 325
 326 char *strupper_static(const char *s)
 327 {
 328         static pstring str;
 329
 330         pstrcpy(str, s);
 331         strupper_m(str);
 332
 333         return str;
 334 }
 335
 336 /**
 337  Convert a string to "normal" form.
 338 **/
 339
 340 void strnorm(char *s, int case_default)
 341 {
 342         if (case_default == CASE_UPPER)
 343                 strupper_m(s);
 344         else
 345                 strlower_m(s);
 346 }
 347
 348 /**
 349  Check if a string is in "normal" case.
 350 **/
 351
 352 BOOL strisnormal(const char *s, int case_default)
 353 {
 354         if (case_default == CASE_UPPER)
 355                 return(!strhaslower(s));
 356
 357         return(!strhasupper(s));
 358 }
 359
 360
 361 /**
 362  String replace.
 363  NOTE: oldc and newc must be 7 bit characters
 364 **/
 365
 366 void string_replace( pstring s, char oldc, char newc )
 367 {
 368         char *p;
 369
 370         /* this is quite a common operation, so we want it to be
 371            fast. We optimise for the ascii case, knowing that all our
 372            supported multi-byte character sets are ascii-compatible
 373            (ie. they match for the first 128 chars) */
 374
 375         for (p = s; *p; p++) {
 376                 if (*p & 0x80) /* mb string - slow path. */
 377                         break;
 378                 if (*p == oldc)
 379                         *p = newc;
 380         }
 381
 382         if (!*p)
 383                 return;
 384
 385         /* Slow (mb) path. */
 386 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
 387         /* With compose characters we must restart from the beginning. JRA. */
 388         p = s;
 389 #endif
 390         push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
 391         string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
 392         pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
 393 }
 394
 395 /**
 396  Skip past some strings in a buffer.
 397 **/
 398
 399 char *skip_string(char *buf,size_t n)
 400 {
 401         while (n--)
 402                 buf += strlen(buf) + 1;
 403         return(buf);
 404 }
 405
 406 /**
 407  Count the number of characters in a string. Normally this will
 408  be the same as the number of bytes in a string for single byte strings,
 409  but will be different for multibyte.
 410 **/
 411
 412 size_t str_charnum(const char *s)
 413 {
 414         uint16 tmpbuf2[sizeof(pstring)];
 415         push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
 416         return strlen_w(tmpbuf2);
 417 }
 418
 419 /**
 420  Count the number of characters in a string. Normally this will
 421  be the same as the number of bytes in a string for single byte strings,
 422  but will be different for multibyte.
 423 **/
 424
 425 size_t str_ascii_charnum(const char *s)
 426 {
 427         pstring tmpbuf2;
 428         push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
 429         return strlen(tmpbuf2);
 430 }
 431
 432 BOOL trim_char(char *s,char cfront,char cback)
 433 {
 434         BOOL ret = False;
 435         char *ep;
 436         char *fp = s;
 437
 438         /* Ignore null or empty strings. */
 439         if (!s || (s[0] == '\0'))
 440                 return False;
 441
 442         if (cfront) {
 443                 while (*fp && *fp == cfront)
 444                         fp++;
 445                 if (!*fp) {
 446                         /* We ate the string. */
 447                         s[0] = '\0';
 448                         return True;
 449                 }
 450                 if (fp != s)
 451                         ret = True;
 452         }
 453
 454         ep = fp + strlen(fp) - 1;
 455         if (cback) {
 456                 /* Attempt ascii only. Bail for mb strings. */
 457                 while ((ep >= fp) && (*ep == cback)) {
 458                         ret = True;
 459                         if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
 460                                 /* Could be mb... bail back to tim_string. */
 461                                 char fs[2], bs[2];
 462                                 if (cfront) {
 463                                         fs[0] = cfront;
 464                                         fs[1] = '\0';
 465                                 }
 466                                 bs[0] = cback;
 467                                 bs[1] = '\0';
 468                                 return trim_string(s, cfront ? fs : NULL, bs);
 469                         } else {
 470                                 ep--;
 471                         }
 472                 }
 473                 if (ep < fp) {
 474                         /* We ate the string. */
 475                         s[0] = '\0';
 476                         return True;
 477                 }
 478         }
 479
 480         ep[1] = '\0';
 481         memmove(s, fp, ep-fp+2);
 482         return ret;
 483 }
 484
 485 /**
 486  Trim the specified elements off the front and back of a string.
 487 **/
 488
 489 BOOL trim_string(char *s,const char *front,const char *back)
 490 {
 491         BOOL ret = False;
 492         size_t front_len;
 493         size_t back_len;
 494         size_t len;
 495
 496         /* Ignore null or empty strings. */
 497         if (!s || (s[0] == '\0'))
 498                 return False;
 499
 500         front_len       = front? strlen(front) : 0;
 501         back_len        = back? strlen(back) : 0;
 502
 503         len = strlen(s);
 504
 505         if (front_len) {
 506                 while (len && strncmp(s, front, front_len)==0) {
 507                         /* Must use memmove here as src & dest can
 508                          * easily overlap. Found by valgrind. JRA. */
 509                         memmove(s, s+front_len, (len-front_len)+1);
 510                         len -= front_len;
 511                         ret=True;
 512                 }
 513         }
 514
 515         if (back_len) {
 516                 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
 517                         s[len-back_len]='\0';
 518                         len -= back_len;
 519                         ret=True;
 520                 }
 521         }
 522         return ret;
 523 }
 524
 525 /**
 526  Does a string have any uppercase chars in it?
 527 **/
 528
 529 BOOL strhasupper(const char *s)
 530 {
 531         smb_ucs2_t *ptr;
 532         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 533         for(ptr=tmpbuf;*ptr;ptr++)
 534                 if(isupper_w(*ptr))
 535                         return True;
 536         return(False);
 537 }
 538
 539 /**
 540  Does a string have any lowercase chars in it?
 541 **/
 542
 543 BOOL strhaslower(const char *s)
 544 {
 545         smb_ucs2_t *ptr;
 546         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 547         for(ptr=tmpbuf;*ptr;ptr++)
 548                 if(islower_w(*ptr))
 549                         return True;
 550         return(False);
 551 }
 552
 553 /**
 554  Find the number of 'c' chars in a string
 555 **/
 556
 557 size_t count_chars(const char *s,char c)
 558 {
 559         smb_ucs2_t *ptr;
 560         int count;
 561         smb_ucs2_t *alloc_tmpbuf = NULL;
 562
 563         if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
 564                 return 0;
 565         }
 566
 567         for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
 568                 if(*ptr==UCS2_CHAR(c))
 569                         count++;
 570
 571         SAFE_FREE(alloc_tmpbuf);
 572         return(count);
 573 }
 574
 575 /**
 576  Safe string copy into a known length string. maxlength does not
 577  include the terminating zero.
 578 **/
 579
 580 char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
 581 {
 582         size_t len;
 583
 584         if (!dest) {
 585                 DEBUG(0,("ERROR: NULL dest in safe_strcpy, called from [%s][%d]\n", fn, line));
 586                 return NULL;
 587         }
 588
 589 #ifdef DEVELOPER
 590         clobber_region(fn,line,dest, maxlength+1);
 591 #endif
 592
 593         if (!src) {
 594                 *dest = 0;
 595                 return dest;
 596         }
 597
 598         len = strnlen(src, maxlength+1);
 599
 600         if (len > maxlength) {
 601                 DEBUG(0,("ERROR: string overflow by %lu (%lu - %lu) in safe_strcpy [%.50s]\n",
 602                          (unsigned long)(len-maxlength), (unsigned long)len,
 603                          (unsigned long)maxlength, src));
 604                 len = maxlength;
 605         }
 606
 607         memmove(dest, src, len);
 608         dest[len] = 0;
 609         return dest;
 610 }
 611
 612 /**
 613  Safe string cat into a string. maxlength does not
 614  include the terminating zero.
 615 **/
 616 char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size_t maxlength)
 617 {
 618         size_t src_len, dest_len;
 619
 620         if (!dest) {
 621                 DEBUG(0,("ERROR: NULL dest in safe_strcat, called from [%s][%d]\n", fn, line));
 622                 return NULL;
 623         }
 624
 625         if (!src)
 626                 return dest;
 627
 628         src_len = strnlen(src, maxlength + 1);
 629         dest_len = strnlen(dest, maxlength + 1);
 630
 631 #ifdef DEVELOPER
 632         clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
 633 #endif
 634
 635         if (src_len + dest_len > maxlength) {
 636                 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
 637                          (int)(src_len + dest_len - maxlength), src));
 638                 if (maxlength > dest_len) {
 639                         memcpy(&dest[dest_len], src, maxlength - dest_len);
 640                 }
 641                 dest[maxlength] = 0;
 642                 return NULL;
 643         }
 644
 645         memcpy(&dest[dest_len], src, src_len);
 646         dest[dest_len + src_len] = 0;
 647         return dest;
 648 }
 649
 650 /**
 651  Paranoid strcpy into a buffer of given length (includes terminating
 652  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 653  and replaces with '_'. Deliberately does *NOT* check for multibyte
 654  characters. Don't change it !
 655 **/
 656 char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
 657 {
 658         size_t len, i;
 659
 660 #ifdef DEVELOPER
 661         clobber_region(fn, line, dest, maxlength);
 662 #endif
 663
 664         if (!dest) {
 665                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, called from [%s][%d]\n", fn, line));
 666                 return NULL;
 667         }
 668
 669         if (!src) {
 670                 *dest = 0;
 671                 return dest;
 672         }
 673
 674         len = strlen(src);
 675         if (len >= maxlength)
 676                 len = maxlength - 1;
 677
 678         if (!other_safe_chars)
 679                 other_safe_chars = "";
 680
 681         for(i = 0; i < len; i++) {
 682                 int val = (src[i] & 0xff);
 683                 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
 684                         dest[i] = src[i];
 685                 else
 686                         dest[i] = '_';
 687         }
 688
 689         dest[i] = '\0';
 690
 691         return dest;
 692 }
 693
 694 /**
 695  Like strncpy but always null terminates. Make sure there is room!
 696  The variable n should always be one less than the available size.
 697 **/
 698 char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
 699 {
 700         char *d = dest;
 701
 702 #ifdef DEVELOPER
 703         clobber_region(fn, line, dest, n+1);
 704 #endif
 705
 706         if (!dest) {
 707                 DEBUG(0,("ERROR: NULL dest in StrnCpy, called from [%s][%d]\n", fn, line));
 708                 return(NULL);
 709         }
 710
 711         if (!src) {
 712                 *dest = 0;
 713                 return(dest);
 714         }
 715
 716         while (n-- && (*d = *src)) {
 717                 d++;
 718                 src++;
 719         }
 720
 721         *d = 0;
 722         return(dest);
 723 }
 724
 725 #if 0
 726 /**
 727  Like strncpy but copies up to the character marker.  always null terminates.
 728  returns a pointer to the character marker in the source string (src).
 729 **/
 730
 731 static char *strncpyn(char *dest, const char *src, size_t n, char c)
 732 {
 733         char *p;
 734         size_t str_len;
 735
 736 #ifdef DEVELOPER
 737         clobber_region(dest, n+1);
 738 #endif
 739         p = strchr_m(src, c);
 740         if (p == NULL) {
 741                 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
 742                 return NULL;
 743         }
 744
 745         str_len = PTR_DIFF(p, src);
 746         strncpy(dest, src, MIN(n, str_len));
 747         dest[str_len] = '\0';
 748
 749         return p;
 750 }
 751 #endif
 752
 753 /**
 754  Routine to get hex characters and turn them into a 16 byte array.
 755  the array can be variable length, and any non-hex-numeric
 756  characters are skipped.  "0xnn" or "0Xnn" is specially catered
 757  for.
 758
 759  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
 760
 761 **/
 762
 763 size_t strhex_to_str(char *p, size_t len, const char *strhex)
 764 {
 765         size_t i;
 766         size_t num_chars = 0;
 767         unsigned char   lonybble, hinybble;
 768         const char     *hexchars = "0123456789ABCDEF";
 769         char           *p1 = NULL, *p2 = NULL;
 770
 771         for (i = 0; i < len && strhex[i] != 0; i++) {
 772                 if (strnequal(hexchars, "0x", 2)) {
 773                         i++; /* skip two chars */
 774                         continue;
 775                 }
 776
 777                 if (!(p1 = strchr_m(hexchars, toupper(strhex[i]))))
 778                         break;
 779
 780                 i++; /* next hex digit */
 781
 782                 if (!(p2 = strchr_m(hexchars, toupper(strhex[i]))))
 783                         break;
 784
 785                 /* get the two nybbles */
 786                 hinybble = PTR_DIFF(p1, hexchars);
 787                 lonybble = PTR_DIFF(p2, hexchars);
 788
 789                 p[num_chars] = (hinybble << 4) | lonybble;
 790                 num_chars++;
 791
 792                 p1 = NULL;
 793                 p2 = NULL;
 794         }
 795         return num_chars;
 796 }
 797
 798 DATA_BLOB strhex_to_data_blob(const char *strhex)
 799 {
 800         DATA_BLOB ret_blob = data_blob(NULL, strlen(strhex)/2+1);
 801
 802         ret_blob.length = strhex_to_str((char*)ret_blob.data,
 803                                         strlen(strhex),
 804                                         strhex);
 805
 806         return ret_blob;
 807 }
 808
 809 /**
 810  * Routine to print a buffer as HEX digits, into an allocated string.
 811  */
 812
 813 void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
 814 {
 815         int i;
 816         char *hex_buffer;
 817
 818         *out_hex_buffer = SMB_XMALLOC_ARRAY(char, (len*2)+1);
 819         hex_buffer = *out_hex_buffer;
 820
 821         for (i = 0; i < len; i++)
 822                 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
 823 }
 824
 825 /**
 826  Check if a string is part of a list.
 827 **/
 828
 829 BOOL in_list(const char *s, const char *list, BOOL casesensitive)
 830 {
 831         pstring tok;
 832         const char *p=list;
 833
 834         if (!list)
 835                 return(False);
 836
 837         while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
 838                 if (casesensitive) {
 839                         if (strcmp(tok,s) == 0)
 840                                 return(True);
 841                 } else {
 842                         if (StrCaseCmp(tok,s) == 0)
 843                                 return(True);
 844                 }
 845         }
 846         return(False);
 847 }
 848
 849 /* this is used to prevent lots of mallocs of size 1 */
 850 static char *null_string = NULL;
 851
 852 /**
 853  Set a string value, allocing the space for the string
 854 **/
 855
 856 static BOOL string_init(char **dest,const char *src)
 857 {
 858         size_t l;
 859         if (!src)
 860                 src = "";
 861
 862         l = strlen(src);
 863
 864         if (l == 0) {
 865                 if (!null_string) {
 866                         if((null_string = (char *)SMB_MALLOC(1)) == NULL) {
 867                                 DEBUG(0,("string_init: malloc fail for null_string.\n"));
 868                                 return False;
 869                         }
 870                         *null_string = 0;
 871                 }
 872                 *dest = null_string;
 873         } else {
 874                 (*dest) = SMB_STRDUP(src);
 875                 if ((*dest) == NULL) {
 876                         DEBUG(0,("Out of memory in string_init\n"));
 877                         return False;
 878                 }
 879         }
 880         return(True);
 881 }
 882
 883 /**
 884  Free a string value.
 885 **/
 886
 887 void string_free(char **s)
 888 {
 889         if (!s || !(*s))
 890                 return;
 891         if (*s == null_string)
 892                 *s = NULL;
 893         SAFE_FREE(*s);
 894 }
 895
 896 /**
 897  Set a string value, deallocating any existing space, and allocing the space
 898  for the string
 899 **/
 900
 901 BOOL string_set(char **dest,const char *src)
 902 {
 903         string_free(dest);
 904         return(string_init(dest,src));
 905 }
 906
 907 /**
 908  Substitute a string for a pattern in another string. Make sure there is
 909  enough room!
 910
 911  This routine looks for pattern in s and replaces it with
 912  insert. It may do multiple replacements.
 913
 914  Any of " ; ' $ or ` in the insert string are replaced with _
 915  if len==0 then the string cannot be extended. This is different from the old
 916  use of len==0 which was for no length checks to be done.
 917 **/
 918
 919 void string_sub2(char *s,const char *pattern, const char *insert, size_t len, BOOL remove_unsafe_characters)
 920 {
 921         char *p;
 922         ssize_t ls,lp,li, i;
 923
 924         if (!insert || !pattern || !*pattern || !s)
 925                 return;
 926
 927         ls = (ssize_t)strlen(s);
 928         lp = (ssize_t)strlen(pattern);
 929         li = (ssize_t)strlen(insert);
 930
 931         if (len == 0)
 932                 len = ls + 1; /* len is number of *bytes* */
 933
 934         while (lp <= ls && (p = strstr_m(s,pattern))) {
 935                 if (ls + (li-lp) >= len) {
 936                         DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
 937                                  (int)(ls + (li-lp) - len),
 938                                  pattern, (int)len));
 939                         break;
 940                 }
 941                 if (li != lp) {
 942                         memmove(p+li,p+lp,strlen(p+lp)+1);
 943                 }
 944                 for (i=0;i<li;i++) {
 945                         switch (insert[i]) {
 946                         case '`':
 947                         case '"':
 948                         case '\'':
 949                         case ';':
 950                         case '$':
 951                         case '%':
 952                         case '\r':
 953                         case '\n':
 954                                 if ( remove_unsafe_characters ) {
 955                                         p[i] = '_';
 956                                         /* yes this break should be here since we want to
 957                                            fall throw if not replacing unsafe chars */
 958                                         break;
 959                                 }
 960                         default:
 961                                 p[i] = insert[i];
 962                         }
 963                 }
 964                 s = p + li;
 965                 ls += (li-lp);
 966         }
 967 }
 968
 969 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 970 {
 971         string_sub2( s, pattern, insert, len, True );
 972 }
 973
 974 void fstring_sub(char *s,const char *pattern,const char *insert)
 975 {
 976         string_sub(s, pattern, insert, sizeof(fstring));
 977 }
 978
 979 void pstring_sub(char *s,const char *pattern,const char *insert)
 980 {
 981         string_sub(s, pattern, insert, sizeof(pstring));
 982 }
 983
 984 /**
 985  Similar to string_sub, but it will accept only allocated strings
 986  and may realloc them so pay attention at what you pass on no
 987  pointers inside strings, no pstrings or const may be passed
 988  as string.
 989 **/
 990
 991 char *realloc_string_sub(char *string, const char *pattern, const char *insert)
 992 {
 993         char *p, *in;
 994         char *s;
 995         ssize_t ls,lp,li,ld, i;
 996
 997         if (!insert || !pattern || !*pattern || !string || !*string)
 998                 return NULL;
 999
1000         s = string;
1001
1002         in = SMB_STRDUP(insert);
1003         if (!in) {
1004                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1005                 return NULL;
1006         }
1007         ls = (ssize_t)strlen(s);
1008         lp = (ssize_t)strlen(pattern);
1009         li = (ssize_t)strlen(insert);
1010         ld = li - lp;
1011         for (i=0;i<li;i++) {
1012                 switch (in[i]) {
1013                         case '`':
1014                         case '"':
1015                         case '\'':
1016                         case ';':
1017                         case '$':
1018                         case '%':
1019                         case '\r':
1020                         case '\n':
1021                                 in[i] = '_';
1022                         default:
1023                                 /* ok */
1024                                 break;
1025                 }
1026         }
1027
1028         while ((p = strstr_m(s,pattern))) {
1029                 if (ld > 0) {
1030                         int offset = PTR_DIFF(s,string);
1031                         char *t = SMB_REALLOC(string, ls + ld + 1);
1032                         if (!t) {
1033                                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1034                                 SAFE_FREE(in);
1035                                 return NULL;
1036                         }
1037                         string = t;
1038                         p = t + offset + (p - s);
1039                 }
1040                 if (li != lp) {
1041                         memmove(p+li,p+lp,strlen(p+lp)+1);
1042                 }
1043                 memcpy(p, in, li);
1044                 s = p + li;
1045                 ls += ld;
1046         }
1047         SAFE_FREE(in);
1048         return string;
1049 }
1050
1051 /**
1052  Similar to string_sub() but allows for any character to be substituted.
1053  Use with caution!
1054  if len==0 then the string cannot be extended. This is different from the old
1055  use of len==0 which was for no length checks to be done.
1056 **/
1057
1058 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1059 {
1060         char *p;
1061         ssize_t ls,lp,li;
1062
1063         if (!insert || !pattern || !s)
1064                 return;
1065
1066         ls = (ssize_t)strlen(s);
1067         lp = (ssize_t)strlen(pattern);
1068         li = (ssize_t)strlen(insert);
1069
1070         if (!*pattern)
1071                 return;
1072
1073         if (len == 0)
1074                 len = ls + 1; /* len is number of *bytes* */
1075
1076         while (lp <= ls && (p = strstr_m(s,pattern))) {
1077                 if (ls + (li-lp) >= len) {
1078                         DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1079                                  (int)(ls + (li-lp) - len),
1080                                  pattern, (int)len));
1081                         break;
1082                 }
1083                 if (li != lp) {
1084                         memmove(p+li,p+lp,strlen(p+lp)+1);
1085                 }
1086                 memcpy(p, insert, li);
1087                 s = p + li;
1088                 ls += (li-lp);
1089         }
1090 }
1091
1092 /**
1093  Similar to all_string_sub but for unicode strings.
1094  Return a new allocated unicode string.
1095  similar to string_sub() but allows for any character to be substituted.
1096  Use with caution!
1097 **/
1098
1099 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
1100                                 const smb_ucs2_t *insert)
1101 {
1102         smb_ucs2_t *r, *rp;
1103         const smb_ucs2_t *sp;
1104         size_t  lr, lp, li, lt;
1105
1106         if (!insert || !pattern || !*pattern || !s)
1107                 return NULL;
1108
1109         lt = (size_t)strlen_w(s);
1110         lp = (size_t)strlen_w(pattern);
1111         li = (size_t)strlen_w(insert);
1112
1113         if (li > lp) {
1114                 const smb_ucs2_t *st = s;
1115                 int ld = li - lp;
1116                 while ((sp = strstr_w(st, pattern))) {
1117                         st = sp + lp;
1118                         lt += ld;
1119                 }
1120         }
1121
1122         r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
1123         if (!r) {
1124                 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1125                 return NULL;
1126         }
1127
1128         while ((sp = strstr_w(s, pattern))) {
1129                 memcpy(rp, s, (sp - s));
1130                 rp += ((sp - s) / sizeof(smb_ucs2_t));
1131                 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1132                 s = sp + lp;
1133                 rp += li;
1134         }
1135         lr = ((rp - r) / sizeof(smb_ucs2_t));
1136         if (lr < lt) {
1137                 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1138                 rp += (lt - lr);
1139         }
1140         *rp = 0;
1141
1142         return r;
1143 }
1144
1145 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1146                                              const char *insert)
1147 {
1148         wpstring p, i;
1149
1150         if (!insert || !pattern || !s)
1151                 return NULL;
1152         push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1153         push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1154         return all_string_sub_w(s, p, i);
1155 }
1156
1157 #if 0
1158 /**
1159  Splits out the front and back at a separator.
1160 **/
1161
1162 static void split_at_last_component(char *path, char *front, char sep, char *back)
1163 {
1164         char *p = strrchr_m(path, sep);
1165
1166         if (p != NULL)
1167                 *p = 0;
1168
1169         if (front != NULL)
1170                 pstrcpy(front, path);
1171
1172         if (p != NULL) {
1173                 if (back != NULL)
1174                         pstrcpy(back, p+1);
1175                 *p = '\\';
1176         } else {
1177                 if (back != NULL)
1178                         back[0] = 0;
1179         }
1180 }
1181 #endif
1182
1183 /**
1184  Write an octal as a string.
1185 **/
1186
1187 const char *octal_string(int i)
1188 {
1189         static char ret[64];
1190         if (i == -1)
1191                 return "-1";
1192         slprintf(ret, sizeof(ret)-1, "0%o", i);
1193         return ret;
1194 }
1195
1196
1197 /**
1198  Truncate a string at a specified length.
1199 **/
1200
1201 char *string_truncate(char *s, unsigned int length)
1202 {
1203         if (s && strlen(s) > length)
1204                 s[length] = 0;
1205         return s;
1206 }
1207
1208 /**
1209  Strchr and strrchr_m are very hard to do on general multi-byte strings.
1210  We convert via ucs2 for now.
1211 **/
1212
1213 char *strchr_m(const char *src, char c)
1214 {
1215         wpstring ws;
1216         pstring s2;
1217         smb_ucs2_t *p;
1218         const char *s;
1219
1220         /* characters below 0x3F are guaranteed to not appear in
1221            non-initial position in multi-byte charsets */
1222         if ((c & 0xC0) == 0) {
1223                 return strchr(src, c);
1224         }
1225
1226         /* this is quite a common operation, so we want it to be
1227            fast. We optimise for the ascii case, knowing that all our
1228            supported multi-byte character sets are ascii-compatible
1229            (ie. they match for the first 128 chars) */
1230
1231         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1232                 if (*s == c)
1233                         return (char *)s;
1234         }
1235
1236         if (!*s)
1237                 return NULL;
1238
1239 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1240         /* With compose characters we must restart from the beginning. JRA. */
1241         s = src;
1242 #endif
1243
1244         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1245         p = strchr_w(ws, UCS2_CHAR(c));
1246         if (!p)
1247                 return NULL;
1248         *p = 0;
1249         pull_ucs2_pstring(s2, ws);
1250         return (char *)(s+strlen(s2));
1251 }
1252
1253 char *strrchr_m(const char *s, char c)
1254 {
1255         /* characters below 0x3F are guaranteed to not appear in
1256            non-initial position in multi-byte charsets */
1257         if ((c & 0xC0) == 0) {
1258                 return strrchr(s, c);
1259         }
1260
1261         /* this is quite a common operation, so we want it to be
1262            fast. We optimise for the ascii case, knowing that all our
1263            supported multi-byte character sets are ascii-compatible
1264            (ie. they match for the first 128 chars). Also, in Samba
1265            we only search for ascii characters in 'c' and that
1266            in all mb character sets with a compound character
1267            containing c, if 'c' is not a match at position
1268            p, then p[-1] > 0x7f. JRA. */
1269
1270         {
1271                 size_t len = strlen(s);
1272                 const char *cp = s;
1273                 BOOL got_mb = False;
1274
1275                 if (len == 0)
1276                         return NULL;
1277                 cp += (len - 1);
1278                 do {
1279                         if (c == *cp) {
1280                                 /* Could be a match. Part of a multibyte ? */
1281                                 if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
1282                                         /* Yep - go slow :-( */
1283                                         got_mb = True;
1284                                         break;
1285                                 }
1286                                 /* No - we have a match ! */
1287                                 return (char *)cp;
1288                         }
1289                 } while (cp-- != s);
1290                 if (!got_mb)
1291                         return NULL;
1292         }
1293
1294         /* String contained a non-ascii char. Slow path. */
1295         {
1296                 wpstring ws;
1297                 pstring s2;
1298                 smb_ucs2_t *p;
1299
1300                 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1301                 p = strrchr_w(ws, UCS2_CHAR(c));
1302                 if (!p)
1303                         return NULL;
1304                 *p = 0;
1305                 pull_ucs2_pstring(s2, ws);
1306                 return (char *)(s+strlen(s2));
1307         }
1308 }
1309
1310 /***********************************************************************
1311  Return the equivalent of doing strrchr 'n' times - always going
1312  backwards.
1313 ***********************************************************************/
1314
1315 char *strnrchr_m(const char *s, char c, unsigned int n)
1316 {
1317         wpstring ws;
1318         pstring s2;
1319         smb_ucs2_t *p;
1320
1321         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1322         p = strnrchr_w(ws, UCS2_CHAR(c), n);
1323         if (!p)
1324                 return NULL;
1325         *p = 0;
1326         pull_ucs2_pstring(s2, ws);
1327         return (char *)(s+strlen(s2));
1328 }
1329
1330 /***********************************************************************
1331  strstr_m - We convert via ucs2 for now.
1332 ***********************************************************************/
1333
1334 char *strstr_m(const char *src, const char *findstr)
1335 {
1336         smb_ucs2_t *p;
1337         smb_ucs2_t *src_w, *find_w;
1338         const char *s;
1339         char *s2;
1340         char *retp;
1341
1342         size_t findstr_len = 0;
1343
1344         /* for correctness */
1345         if (!findstr[0]) {
1346                 return (char*)src;
1347         }
1348
1349         /* Samba does single character findstr calls a *lot*. */
1350         if (findstr[1] == '\0')
1351                 return strchr_m(src, *findstr);
1352
1353         /* We optimise for the ascii case, knowing that all our
1354            supported multi-byte character sets are ascii-compatible
1355            (ie. they match for the first 128 chars) */
1356
1357         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1358                 if (*s == *findstr) {
1359                         if (!findstr_len)
1360                                 findstr_len = strlen(findstr);
1361
1362                         if (strncmp(s, findstr, findstr_len) == 0) {
1363                                 return (char *)s;
1364                         }
1365                 }
1366         }
1367
1368         if (!*s)
1369                 return NULL;
1370
1371 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1372         /* 'make check' fails unless we do this */
1373
1374         /* With compose characters we must restart from the beginning. JRA. */
1375         s = src;
1376 #endif
1377
1378         if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1379                 DEBUG(0,("strstr_m: src malloc fail\n"));
1380                 return NULL;
1381         }
1382
1383         if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1384                 SAFE_FREE(src_w);
1385                 DEBUG(0,("strstr_m: find malloc fail\n"));
1386                 return NULL;
1387         }
1388
1389         p = strstr_w(src_w, find_w);
1390
1391         if (!p) {
1392                 SAFE_FREE(src_w);
1393                 SAFE_FREE(find_w);
1394                 return NULL;
1395         }
1396
1397         *p = 0;
1398         if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1399                 SAFE_FREE(src_w);
1400                 SAFE_FREE(find_w);
1401                 DEBUG(0,("strstr_m: dest malloc fail\n"));
1402                 return NULL;
1403         }
1404         retp = (char *)(s+strlen(s2));
1405         SAFE_FREE(src_w);
1406         SAFE_FREE(find_w);
1407         SAFE_FREE(s2);
1408         return retp;
1409 }
1410
1411 /**
1412  Convert a string to lower case.
1413 **/
1414
1415 void strlower_m(char *s)
1416 {
1417         size_t len;
1418         int errno_save;
1419
1420         /* this is quite a common operation, so we want it to be
1421            fast. We optimise for the ascii case, knowing that all our
1422            supported multi-byte character sets are ascii-compatible
1423            (ie. they match for the first 128 chars) */
1424
1425         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1426                 *s = tolower((unsigned char)*s);
1427                 s++;
1428         }
1429
1430         if (!*s)
1431                 return;
1432
1433         /* I assume that lowercased string takes the same number of bytes
1434          * as source string even in UTF-8 encoding. (VIV) */
1435         len = strlen(s) + 1;
1436         errno_save = errno;
1437         errno = 0;
1438         unix_strlower(s,len,s,len);
1439         /* Catch mb conversion errors that may not terminate. */
1440         if (errno)
1441                 s[len-1] = '\0';
1442         errno = errno_save;
1443 }
1444
1445 /**
1446  Convert a string to upper case.
1447 **/
1448
1449 void strupper_m(char *s)
1450 {
1451         size_t len;
1452         int errno_save;
1453
1454         /* this is quite a common operation, so we want it to be
1455            fast. We optimise for the ascii case, knowing that all our
1456            supported multi-byte character sets are ascii-compatible
1457            (ie. they match for the first 128 chars) */
1458
1459         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1460                 *s = toupper((unsigned char)*s);
1461                 s++;
1462         }
1463
1464         if (!*s)
1465                 return;
1466
1467         /* I assume that lowercased string takes the same number of bytes
1468          * as source string even in multibyte encoding. (VIV) */
1469         len = strlen(s) + 1;
1470         errno_save = errno;
1471         errno = 0;
1472         unix_strupper(s,len,s,len);
1473         /* Catch mb conversion errors that may not terminate. */
1474         if (errno)
1475                 s[len-1] = '\0';
1476         errno = errno_save;
1477 }
1478
1479 /**
1480  Return a RFC2254 binary string representation of a buffer.
1481  Used in LDAP filters.
1482  Caller must free.
1483 **/
1484
1485 char *binary_string(char *buf, int len)
1486 {
1487         char *s;
1488         int i, j;
1489         const char *hex = "0123456789ABCDEF";
1490         s = SMB_MALLOC(len * 3 + 1);
1491         if (!s)
1492                 return NULL;
1493         for (j=i=0;i<len;i++) {
1494                 s[j] = '\\';
1495                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1496                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1497                 j += 3;
1498         }
1499         s[j] = 0;
1500         return s;
1501 }
1502
1503 /**
1504  Just a typesafety wrapper for snprintf into a pstring.
1505 **/
1506
1507  int pstr_sprintf(pstring s, const char *fmt, ...)
1508 {
1509         va_list ap;
1510         int ret;
1511
1512         va_start(ap, fmt);
1513         ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1514         va_end(ap);
1515         return ret;
1516 }
1517
1518
1519 /**
1520  Just a typesafety wrapper for snprintf into a fstring.
1521 **/
1522
1523 int fstr_sprintf(fstring s, const char *fmt, ...)
1524 {
1525         va_list ap;
1526         int ret;
1527
1528         va_start(ap, fmt);
1529         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1530         va_end(ap);
1531         return ret;
1532 }
1533
1534
1535 #if !defined(HAVE_STRNDUP) || defined(BROKEN_STRNDUP)
1536 /**
1537  Some platforms don't have strndup.
1538 **/
1539 #if defined(PARANOID_MALLOC_CHECKER)
1540 #undef strndup
1541 #endif
1542
1543  char *strndup(const char *s, size_t n)
1544 {
1545         char *ret;
1546
1547         n = strnlen(s, n);
1548         ret = SMB_MALLOC(n+1);
1549         if (!ret)
1550                 return NULL;
1551         memcpy(ret, s, n);
1552         ret[n] = 0;
1553
1554         return ret;
1555 }
1556
1557 #if defined(PARANOID_MALLOC_CHECKER)
1558 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
1559 #endif
1560
1561 #endif
1562
1563 #if !defined(HAVE_STRNLEN) || defined(BROKEN_STRNLEN)
1564 /**
1565  Some platforms don't have strnlen
1566 **/
1567
1568  size_t strnlen(const char *s, size_t n)
1569 {
1570         size_t i;
1571         for (i=0; i<n && s[i] != '\0'; i++)
1572                 /* noop */ ;
1573         return i;
1574 }
1575 #endif
1576
1577 /**
1578  List of Strings manipulation functions
1579 **/
1580
1581 #define S_LIST_ABS 16 /* List Allocation Block Size */
1582
1583 char **str_list_make(const char *string, const char *sep)
1584 {
1585         char **list, **rlist;
1586         const char *str;
1587         char *s;
1588         int num, lsize;
1589         pstring tok;
1590
1591         if (!string || !*string)
1592                 return NULL;
1593         s = SMB_STRDUP(string);
1594         if (!s) {
1595                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1596                 return NULL;
1597         }
1598         if (!sep) sep = LIST_SEP;
1599
1600         num = lsize = 0;
1601         list = NULL;
1602
1603         str = s;
1604         while (next_token(&str, tok, sep, sizeof(tok))) {
1605                 if (num == lsize) {
1606                         lsize += S_LIST_ABS;
1607                         rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
1608                         if (!rlist) {
1609                                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1610                                 str_list_free(&list);
1611                                 SAFE_FREE(s);
1612                                 return NULL;
1613                         } else
1614                                 list = rlist;
1615                         memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1616                 }
1617
1618                 list[num] = SMB_STRDUP(tok);
1619                 if (!list[num]) {
1620                         DEBUG(0,("str_list_make: Unable to allocate memory"));
1621                         str_list_free(&list);
1622                         SAFE_FREE(s);
1623                         return NULL;
1624                 }
1625
1626                 num++;
1627         }
1628
1629         SAFE_FREE(s);
1630         return list;
1631 }
1632
1633 BOOL str_list_copy(char ***dest, const char **src)
1634 {
1635         char **list, **rlist;
1636         int num, lsize;
1637
1638         *dest = NULL;
1639         if (!src)
1640                 return False;
1641
1642         num = lsize = 0;
1643         list = NULL;
1644
1645         while (src[num]) {
1646                 if (num == lsize) {
1647                         lsize += S_LIST_ABS;
1648                         rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
1649                         if (!rlist) {
1650                                 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1651                                 str_list_free(&list);
1652                                 return False;
1653                         } else
1654                                 list = rlist;
1655                         memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1656                 }
1657
1658                 list[num] = SMB_STRDUP(src[num]);
1659                 if (!list[num]) {
1660                         DEBUG(0,("str_list_copy: Unable to allocate memory"));
1661                         str_list_free(&list);
1662                         return False;
1663                 }
1664
1665                 num++;
1666         }
1667
1668         *dest = list;
1669         return True;
1670 }
1671
1672 /**
1673  * Return true if all the elements of the list match exactly.
1674  **/
1675 BOOL str_list_compare(char **list1, char **list2)
1676 {
1677         int num;
1678
1679         if (!list1 || !list2)
1680                 return (list1 == list2);
1681
1682         for (num = 0; list1[num]; num++) {
1683                 if (!list2[num])
1684                         return False;
1685                 if (!strcsequal(list1[num], list2[num]))
1686                         return False;
1687         }
1688         if (list2[num])
1689                 return False; /* if list2 has more elements than list1 fail */
1690
1691         return True;
1692 }
1693
1694 void str_list_free(char ***list)
1695 {
1696         char **tlist;
1697
1698         if (!list || !*list)
1699                 return;
1700         tlist = *list;
1701         for(; *tlist; tlist++)
1702                 SAFE_FREE(*tlist);
1703         SAFE_FREE(*list);
1704 }
1705
1706 /******************************************************************************
1707  *****************************************************************************/
1708
1709 int str_list_count( const char **list )
1710 {
1711         int i = 0;
1712
1713         /* count the number of list members */
1714
1715         for ( i=0; *list; i++, list++ );
1716
1717         return i;
1718 }
1719
1720 /******************************************************************************
1721  version of standard_sub_basic() for string lists; uses alloc_sub_basic()
1722  for the work
1723  *****************************************************************************/
1724
1725 BOOL str_list_sub_basic( char **list, const char *smb_name )
1726 {
1727         char *s, *tmpstr;
1728
1729         while ( *list ) {
1730                 s = *list;
1731                 tmpstr = alloc_sub_basic(smb_name, s);
1732                 if ( !tmpstr ) {
1733                         DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
1734                         return False;
1735                 }
1736
1737                 SAFE_FREE(*list);
1738                 *list = tmpstr;
1739
1740                 list++;
1741         }
1742
1743         return True;
1744 }
1745
1746 /******************************************************************************
1747  substritute a specific pattern in a string list
1748  *****************************************************************************/
1749
1750 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1751 {
1752         char *p, *s, *t;
1753         ssize_t ls, lp, li, ld, i, d;
1754
1755         if (!list)
1756                 return False;
1757         if (!pattern)
1758                 return False;
1759         if (!insert)
1760                 return False;
1761
1762         lp = (ssize_t)strlen(pattern);
1763         li = (ssize_t)strlen(insert);
1764         ld = li -lp;
1765
1766         while (*list) {
1767                 s = *list;
1768                 ls = (ssize_t)strlen(s);
1769
1770                 while ((p = strstr_m(s, pattern))) {
1771                         t = *list;
1772                         d = p -t;
1773                         if (ld) {
1774                                 t = (char *) SMB_MALLOC(ls +ld +1);
1775                                 if (!t) {
1776                                         DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1777                                         return False;
1778                                 }
1779                                 memcpy(t, *list, d);
1780                                 memcpy(t +d +li, p +lp, ls -d -lp +1);
1781                                 SAFE_FREE(*list);
1782                                 *list = t;
1783                                 ls += ld;
1784                                 s = t +d +li;
1785                         }
1786
1787                         for (i = 0; i < li; i++) {
1788                                 switch (insert[i]) {
1789                                         case '`':
1790                                         case '"':
1791                                         case '\'':
1792                                         case ';':
1793                                         case '$':
1794                                         case '%':
1795                                         case '\r':
1796                                         case '\n':
1797                                                 t[d +i] = '_';
1798                                                 break;
1799                                         default:
1800                                                 t[d +i] = insert[i];
1801                                 }
1802                         }
1803                 }
1804
1805
1806                 list++;
1807         }
1808
1809         return True;
1810 }
1811
1812
1813 #define IPSTR_LIST_SEP  ","
1814 #define IPSTR_LIST_CHAR ','
1815
1816 /**
1817  * Add ip string representation to ipstr list. Used also
1818  * as part of @function ipstr_list_make
1819  *
1820  * @param ipstr_list pointer to string containing ip list;
1821  *        MUST BE already allocated and IS reallocated if necessary
1822  * @param ipstr_size pointer to current size of ipstr_list (might be changed
1823  *        as a result of reallocation)
1824  * @param ip IP address which is to be added to list
1825  * @return pointer to string appended with new ip and possibly
1826  *         reallocated to new length
1827  **/
1828
1829 char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
1830 {
1831         char* new_ipstr = NULL;
1832
1833         /* arguments checking */
1834         if (!ipstr_list || !service) return NULL;
1835
1836         /* attempt to convert ip to a string and append colon separator to it */
1837         if (*ipstr_list) {
1838                 asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list, IPSTR_LIST_SEP,
1839                         inet_ntoa(service->ip), service->port);
1840                 SAFE_FREE(*ipstr_list);
1841         } else {
1842                 asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
1843         }
1844         *ipstr_list = new_ipstr;
1845         return *ipstr_list;
1846 }
1847
1848
1849 /**
1850  * Allocate and initialise an ipstr list using ip adresses
1851  * passed as arguments.
1852  *
1853  * @param ipstr_list pointer to string meant to be allocated and set
1854  * @param ip_list array of ip addresses to place in the list
1855  * @param ip_count number of addresses stored in ip_list
1856  * @return pointer to allocated ip string
1857  **/
1858
1859 char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
1860 {
1861         int i;
1862
1863         /* arguments checking */
1864         if (!ip_list && !ipstr_list) return 0;
1865
1866         *ipstr_list = NULL;
1867
1868         /* process ip addresses given as arguments */
1869         for (i = 0; i < ip_count; i++)
1870                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
1871
1872         return (*ipstr_list);
1873 }
1874
1875
1876 /**
1877  * Parse given ip string list into array of ip addresses
1878  * (as ip_service structures)
1879  *    e.g. 192.168.1.100:389,192.168.1.78, ...
1880  *
1881  * @param ipstr ip string list to be parsed
1882  * @param ip_list pointer to array of ip addresses which is
1883  *        allocated by this function and must be freed by caller
1884  * @return number of succesfully parsed addresses
1885  **/
1886
1887 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
1888 {
1889         fstring token_str;
1890         size_t count;
1891         int i;
1892
1893         if (!ipstr_list || !ip_list)
1894                 return 0;
1895
1896         count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
1897         if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
1898                 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
1899                 return 0;
1900         }
1901
1902         for ( i=0;
1903                 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count;
1904                 i++ )
1905         {
1906                 struct in_addr addr;
1907                 unsigned port = 0;
1908                 char *p = strchr(token_str, ':');
1909
1910                 if (p) {
1911                         *p = 0;
1912                         port = atoi(p+1);
1913                 }
1914
1915                 /* convert single token to ip address */
1916                 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
1917                         break;
1918
1919                 (*ip_list)[i].ip = addr;
1920                 (*ip_list)[i].port = port;
1921         }
1922
1923         return count;
1924 }
1925
1926
1927 /**
1928  * Safely free ip string list
1929  *
1930  * @param ipstr_list ip string list to be freed
1931  **/
1932
1933 void ipstr_list_free(char* ipstr_list)
1934 {
1935         SAFE_FREE(ipstr_list);
1936 }
1937
1938
1939 /**
1940  Unescape a URL encoded string, in place.
1941 **/
1942
1943 void rfc1738_unescape(char *buf)
1944 {
1945         char *p=buf;
1946
1947         while (p && *p && (p=strchr_m(p,'%'))) {
1948                 int c1 = p[1];
1949                 int c2 = p[2];
1950
1951                 if (c1 >= '0' && c1 <= '9')
1952                         c1 = c1 - '0';
1953                 else if (c1 >= 'A' && c1 <= 'F')
1954                         c1 = 10 + c1 - 'A';
1955                 else if (c1 >= 'a' && c1 <= 'f')
1956                         c1 = 10 + c1 - 'a';
1957                 else {p++; continue;}
1958
1959                 if (c2 >= '0' && c2 <= '9')
1960                         c2 = c2 - '0';
1961                 else if (c2 >= 'A' && c2 <= 'F')
1962                         c2 = 10 + c2 - 'A';
1963                 else if (c2 >= 'a' && c2 <= 'f')
1964                         c2 = 10 + c2 - 'a';
1965                 else {p++; continue;}
1966
1967                 *p = (c1<<4) | c2;
1968
1969                 memmove(p+1, p+3, strlen(p+3)+1);
1970                 p++;
1971         }
1972 }
1973
1974 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1975
1976 /**
1977  * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1978  **/
1979 DATA_BLOB base64_decode_data_blob(const char *s)
1980 {
1981         int bit_offset, byte_offset, idx, i, n;
1982         DATA_BLOB decoded = data_blob(s, strlen(s)+1);
1983         unsigned char *d = decoded.data;
1984         char *p;
1985
1986         n=i=0;
1987
1988         while (*s && (p=strchr_m(b64,*s))) {
1989                 idx = (int)(p - b64);
1990                 byte_offset = (i*6)/8;
1991                 bit_offset = (i*6)%8;
1992                 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
1993                 if (bit_offset < 3) {
1994                         d[byte_offset] |= (idx << (2-bit_offset));
1995                         n = byte_offset+1;
1996                 } else {
1997                         d[byte_offset] |= (idx >> (bit_offset-2));
1998                         d[byte_offset+1] = 0;
1999                         d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2000                         n = byte_offset+2;
2001                 }
2002                 s++; i++;
2003         }
2004
2005         if ((n > 0) && (*s == '=')) {
2006                 n -= 1;
2007         }
2008
2009         /* fix up length */
2010         decoded.length = n;
2011         return decoded;
2012 }
2013
2014 /**
2015  * Decode a base64 string in-place - wrapper for the above
2016  **/
2017 void base64_decode_inplace(char *s)
2018 {
2019         DATA_BLOB decoded = base64_decode_data_blob(s);
2020
2021         if ( decoded.length != 0 ) {
2022                 memcpy(s, decoded.data, decoded.length);
2023
2024                 /* null terminate */
2025                 s[decoded.length] = '\0';
2026         } else {
2027                 *s = '\0';
2028         }
2029
2030         data_blob_free(&decoded);
2031 }
2032
2033 /**
2034  * Encode a base64 string into a malloc()ed string caller to free.
2035  *
2036  *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
2037  **/
2038 char * base64_encode_data_blob(DATA_BLOB data)
2039 {
2040         int bits = 0;
2041         int char_count = 0;
2042         size_t out_cnt, len, output_len;
2043         char *result;
2044
2045         if (!data.length || !data.data)
2046                 return NULL;
2047
2048         out_cnt = 0;
2049         len = data.length;
2050         output_len = data.length * 2;
2051         result = SMB_MALLOC(output_len); /* get us plenty of space */
2052
2053         while (len-- && out_cnt < (data.length * 2) - 5) {
2054                 int c = (unsigned char) *(data.data++);
2055                 bits += c;
2056                 char_count++;
2057                 if (char_count == 3) {
2058                         result[out_cnt++] = b64[bits >> 18];
2059                         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2060                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2061             result[out_cnt++] = b64[bits & 0x3f];
2062             bits = 0;
2063             char_count = 0;
2064         } else {
2065             bits <<= 8;
2066         }
2067     }
2068     if (char_count != 0) {
2069         bits <<= 16 - (8 * char_count);
2070         result[out_cnt++] = b64[bits >> 18];
2071         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2072         if (char_count == 1) {
2073             result[out_cnt++] = '=';
2074             result[out_cnt++] = '=';
2075         } else {
2076             result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2077             result[out_cnt++] = '=';
2078         }
2079     }
2080     result[out_cnt] = '\0';     /* terminate */
2081     return result;
2082 }
2083
2084 /* read a SMB_BIG_UINT from a string */
2085 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2086 {
2087
2088         SMB_BIG_UINT val = -1;
2089         const char *p = nptr;
2090
2091         while (p && *p && isspace(*p))
2092                 p++;
2093 #ifdef LARGE_SMB_OFF_T
2094         sscanf(p,"%llu",&val);
2095 #else /* LARGE_SMB_OFF_T */
2096         sscanf(p,"%lu",&val);
2097 #endif /* LARGE_SMB_OFF_T */
2098         if (entptr) {
2099                 while (p && *p && isdigit(*p))
2100                         p++;
2101                 *entptr = p;
2102         }
2103
2104         return val;
2105 }
2106
2107 void string_append(char **left, const char *right)
2108 {
2109         int new_len = strlen(right) + 1;
2110
2111         if (*left == NULL) {
2112                 *left = SMB_MALLOC(new_len);
2113                 *left[0] = '\0';
2114         } else {
2115                 new_len += strlen(*left);
2116                 *left = SMB_REALLOC(*left, new_len);
2117         }
2118
2119         if (*left == NULL)
2120                 return;
2121
2122         safe_strcat(*left, right, new_len-1);
2123 }
2124
2125 BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
2126                          const char *str, const char ***strings,
2127                          int *num)
2128 {
2129         char *dup_str = talloc_strdup(mem_ctx, str);
2130
2131         *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings, const char *, (*num)+1);
2132
2133         if ((*strings == NULL) || (dup_str == NULL))
2134                 return False;
2135
2136         (*strings)[*num] = dup_str;
2137         *num += 1;
2138         return True;
2139 }
2140
2141 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2142  * error checking in between. The indiation that something weird happened is
2143  * string==NULL */
2144
2145 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2146                     size_t *bufsize, const char *fmt, ...)
2147 {
2148         va_list ap;
2149         char *newstr;
2150         int ret;
2151         BOOL increased;
2152
2153         /* len<0 is an internal marker that something failed */
2154         if (*len < 0)
2155                 goto error;
2156
2157         if (*string == NULL) {
2158                 if (*bufsize == 0)
2159                         *bufsize = 128;
2160
2161                 if (mem_ctx != NULL)
2162                         *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2163                 else
2164                         *string = SMB_MALLOC_ARRAY(char, *bufsize);
2165
2166                 if (*string == NULL)
2167                         goto error;
2168         }
2169
2170         va_start(ap, fmt);
2171         ret = vasprintf(&newstr, fmt, ap);
2172         va_end(ap);
2173
2174         if (ret < 0)
2175                 goto error;
2176
2177         increased = False;
2178
2179         while ((*len)+ret >= *bufsize) {
2180                 increased = True;
2181                 *bufsize *= 2;
2182                 if (*bufsize >= (1024*1024*256))
2183                         goto error;
2184         }
2185
2186         if (increased) {
2187                 if (mem_ctx != NULL)
2188                         *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2189                                                        *bufsize);
2190                 else
2191                         *string = SMB_REALLOC_ARRAY(*string, char, *bufsize);
2192
2193                 if (*string == NULL)
2194                         goto error;
2195         }
2196
2197         StrnCpy((*string)+(*len), newstr, ret);
2198         (*len) += ret;
2199         free(newstr);
2200         return;
2201
2202  error:
2203         *len = -1;
2204         *string = NULL;
2205 }
2206
2207 /*
2208    Returns the substring from src between the first occurrence of
2209    the char "front" and the first occurence of the char "back".
2210    Mallocs the return string which must be freed.  Not for use
2211    with wide character strings.
2212 */
2213 char *sstring_sub(const char *src, char front, char back)
2214 {
2215         char *temp1, *temp2, *temp3;
2216         ptrdiff_t len;
2217
2218         temp1 = strchr(src, front);
2219         if (temp1 == NULL) return NULL;
2220         temp2 = strchr(src, back);
2221         if (temp2 == NULL) return NULL;
2222         len = temp2 - temp1;
2223         if (len <= 0) return NULL;
2224         temp3 = (char*)SMB_MALLOC(len);
2225         if (temp3 == NULL) {
2226                 DEBUG(1,("Malloc failure in sstring_sub\n"));
2227                 return NULL;
2228         }
2229         memcpy(temp3, temp1+1, len-1);
2230         temp3[len-1] = '\0';
2231         return temp3;
2232 }