source/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, ps);
 215         if (size == (size_t)-1) {
 216                 return strcmp(ps, pt);
 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, pt);
 222         if (size == (size_t)-1) {
 223                 SAFE_FREE(buffer_s);
 224                 return strcmp(ps, pt);
 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 or just one.
 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,
 920                  BOOL remove_unsafe_characters, BOOL replace_once)
 921 {
 922         char *p;
 923         ssize_t ls,lp,li, i;
 924
 925         if (!insert || !pattern || !*pattern || !s)
 926                 return;
 927
 928         ls = (ssize_t)strlen(s);
 929         lp = (ssize_t)strlen(pattern);
 930         li = (ssize_t)strlen(insert);
 931
 932         if (len == 0)
 933                 len = ls + 1; /* len is number of *bytes* */
 934
 935         while (lp <= ls && (p = strstr_m(s,pattern))) {
 936                 if (ls + (li-lp) >= len) {
 937                         DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
 938                                  (int)(ls + (li-lp) - len),
 939                                  pattern, (int)len));
 940                         break;
 941                 }
 942                 if (li != lp) {
 943                         memmove(p+li,p+lp,strlen(p+lp)+1);
 944                 }
 945                 for (i=0;i<li;i++) {
 946                         switch (insert[i]) {
 947                         case '`':
 948                         case '"':
 949                         case '\'':
 950                         case ';':
 951                         case '$':
 952                         case '%':
 953                         case '\r':
 954                         case '\n':
 955                                 if ( remove_unsafe_characters ) {
 956                                         p[i] = '_';
 957                                         /* yes this break should be here since we want to
 958                                            fall throw if not replacing unsafe chars */
 959                                         break;
 960                                 }
 961                         default:
 962                                 p[i] = insert[i];
 963                         }
 964                 }
 965                 s = p + li;
 966                 ls += (li-lp);
 967
 968                 if (replace_once)
 969                         break;
 970         }
 971 }
 972
 973 void string_sub_once(char *s, const char *pattern, const char *insert, size_t len)
 974 {
 975         string_sub2( s, pattern, insert, len, True, True );
 976 }
 977
 978 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 979 {
 980         string_sub2( s, pattern, insert, len, True, False );
 981 }
 982
 983 void fstring_sub(char *s,const char *pattern,const char *insert)
 984 {
 985         string_sub(s, pattern, insert, sizeof(fstring));
 986 }
 987
 988 void pstring_sub(char *s,const char *pattern,const char *insert)
 989 {
 990         string_sub(s, pattern, insert, sizeof(pstring));
 991 }
 992
 993 /**
 994  Similar to string_sub, but it will accept only allocated strings
 995  and may realloc them so pay attention at what you pass on no
 996  pointers inside strings, no pstrings or const may be passed
 997  as string.
 998 **/
 999
1000 char *realloc_string_sub(char *string, const char *pattern, const char *insert)
1001 {
1002         char *p, *in;
1003         char *s;
1004         ssize_t ls,lp,li,ld, i;
1005
1006         if (!insert || !pattern || !*pattern || !string || !*string)
1007                 return NULL;
1008
1009         s = string;
1010
1011         in = SMB_STRDUP(insert);
1012         if (!in) {
1013                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1014                 return NULL;
1015         }
1016         ls = (ssize_t)strlen(s);
1017         lp = (ssize_t)strlen(pattern);
1018         li = (ssize_t)strlen(insert);
1019         ld = li - lp;
1020         for (i=0;i<li;i++) {
1021                 switch (in[i]) {
1022                         case '`':
1023                         case '"':
1024                         case '\'':
1025                         case ';':
1026                         case '$':
1027                         case '%':
1028                         case '\r':
1029                         case '\n':
1030                                 in[i] = '_';
1031                         default:
1032                                 /* ok */
1033                                 break;
1034                 }
1035         }
1036
1037         while ((p = strstr_m(s,pattern))) {
1038                 if (ld > 0) {
1039                         int offset = PTR_DIFF(s,string);
1040                         char *t = SMB_REALLOC(string, ls + ld + 1);
1041                         if (!t) {
1042                                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1043                                 SAFE_FREE(in);
1044                                 return NULL;
1045                         }
1046                         string = t;
1047                         p = t + offset + (p - s);
1048                 }
1049                 if (li != lp) {
1050                         memmove(p+li,p+lp,strlen(p+lp)+1);
1051                 }
1052                 memcpy(p, in, li);
1053                 s = p + li;
1054                 ls += ld;
1055         }
1056         SAFE_FREE(in);
1057         return string;
1058 }
1059
1060 /**
1061  Similar to string_sub() but allows for any character to be substituted.
1062  Use with caution!
1063  if len==0 then the string cannot be extended. This is different from the old
1064  use of len==0 which was for no length checks to be done.
1065 **/
1066
1067 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1068 {
1069         char *p;
1070         ssize_t ls,lp,li;
1071
1072         if (!insert || !pattern || !s)
1073                 return;
1074
1075         ls = (ssize_t)strlen(s);
1076         lp = (ssize_t)strlen(pattern);
1077         li = (ssize_t)strlen(insert);
1078
1079         if (!*pattern)
1080                 return;
1081
1082         if (len == 0)
1083                 len = ls + 1; /* len is number of *bytes* */
1084
1085         while (lp <= ls && (p = strstr_m(s,pattern))) {
1086                 if (ls + (li-lp) >= len) {
1087                         DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1088                                  (int)(ls + (li-lp) - len),
1089                                  pattern, (int)len));
1090                         break;
1091                 }
1092                 if (li != lp) {
1093                         memmove(p+li,p+lp,strlen(p+lp)+1);
1094                 }
1095                 memcpy(p, insert, li);
1096                 s = p + li;
1097                 ls += (li-lp);
1098         }
1099 }
1100
1101 /**
1102  Similar to all_string_sub but for unicode strings.
1103  Return a new allocated unicode string.
1104  similar to string_sub() but allows for any character to be substituted.
1105  Use with caution!
1106 **/
1107
1108 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
1109                                 const smb_ucs2_t *insert)
1110 {
1111         smb_ucs2_t *r, *rp;
1112         const smb_ucs2_t *sp;
1113         size_t  lr, lp, li, lt;
1114
1115         if (!insert || !pattern || !*pattern || !s)
1116                 return NULL;
1117
1118         lt = (size_t)strlen_w(s);
1119         lp = (size_t)strlen_w(pattern);
1120         li = (size_t)strlen_w(insert);
1121
1122         if (li > lp) {
1123                 const smb_ucs2_t *st = s;
1124                 int ld = li - lp;
1125                 while ((sp = strstr_w(st, pattern))) {
1126                         st = sp + lp;
1127                         lt += ld;
1128                 }
1129         }
1130
1131         r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
1132         if (!r) {
1133                 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1134                 return NULL;
1135         }
1136
1137         while ((sp = strstr_w(s, pattern))) {
1138                 memcpy(rp, s, (sp - s));
1139                 rp += ((sp - s) / sizeof(smb_ucs2_t));
1140                 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1141                 s = sp + lp;
1142                 rp += li;
1143         }
1144         lr = ((rp - r) / sizeof(smb_ucs2_t));
1145         if (lr < lt) {
1146                 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1147                 rp += (lt - lr);
1148         }
1149         *rp = 0;
1150
1151         return r;
1152 }
1153
1154 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1155                                              const char *insert)
1156 {
1157         wpstring p, i;
1158
1159         if (!insert || !pattern || !s)
1160                 return NULL;
1161         push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1162         push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1163         return all_string_sub_w(s, p, i);
1164 }
1165
1166 #if 0
1167 /**
1168  Splits out the front and back at a separator.
1169 **/
1170
1171 static void split_at_last_component(char *path, char *front, char sep, char *back)
1172 {
1173         char *p = strrchr_m(path, sep);
1174
1175         if (p != NULL)
1176                 *p = 0;
1177
1178         if (front != NULL)
1179                 pstrcpy(front, path);
1180
1181         if (p != NULL) {
1182                 if (back != NULL)
1183                         pstrcpy(back, p+1);
1184                 *p = '\\';
1185         } else {
1186                 if (back != NULL)
1187                         back[0] = 0;
1188         }
1189 }
1190 #endif
1191
1192 /**
1193  Write an octal as a string.
1194 **/
1195
1196 const char *octal_string(int i)
1197 {
1198         static char ret[64];
1199         if (i == -1)
1200                 return "-1";
1201         slprintf(ret, sizeof(ret)-1, "0%o", i);
1202         return ret;
1203 }
1204
1205
1206 /**
1207  Truncate a string at a specified length.
1208 **/
1209
1210 char *string_truncate(char *s, unsigned int length)
1211 {
1212         if (s && strlen(s) > length)
1213                 s[length] = 0;
1214         return s;
1215 }
1216
1217 /**
1218  Strchr and strrchr_m are very hard to do on general multi-byte strings.
1219  We convert via ucs2 for now.
1220 **/
1221
1222 char *strchr_m(const char *src, char c)
1223 {
1224         wpstring ws;
1225         pstring s2;
1226         smb_ucs2_t *p;
1227         const char *s;
1228
1229         /* characters below 0x3F are guaranteed to not appear in
1230            non-initial position in multi-byte charsets */
1231         if ((c & 0xC0) == 0) {
1232                 return strchr(src, c);
1233         }
1234
1235         /* this is quite a common operation, so we want it to be
1236            fast. We optimise for the ascii case, knowing that all our
1237            supported multi-byte character sets are ascii-compatible
1238            (ie. they match for the first 128 chars) */
1239
1240         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1241                 if (*s == c)
1242                         return (char *)s;
1243         }
1244
1245         if (!*s)
1246                 return NULL;
1247
1248 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1249         /* With compose characters we must restart from the beginning. JRA. */
1250         s = src;
1251 #endif
1252
1253         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1254         p = strchr_w(ws, UCS2_CHAR(c));
1255         if (!p)
1256                 return NULL;
1257         *p = 0;
1258         pull_ucs2_pstring(s2, ws);
1259         return (char *)(s+strlen(s2));
1260 }
1261
1262 char *strrchr_m(const char *s, char c)
1263 {
1264         /* characters below 0x3F are guaranteed to not appear in
1265            non-initial position in multi-byte charsets */
1266         if ((c & 0xC0) == 0) {
1267                 return strrchr(s, c);
1268         }
1269
1270         /* this is quite a common operation, so we want it to be
1271            fast. We optimise for the ascii case, knowing that all our
1272            supported multi-byte character sets are ascii-compatible
1273            (ie. they match for the first 128 chars). Also, in Samba
1274            we only search for ascii characters in 'c' and that
1275            in all mb character sets with a compound character
1276            containing c, if 'c' is not a match at position
1277            p, then p[-1] > 0x7f. JRA. */
1278
1279         {
1280                 size_t len = strlen(s);
1281                 const char *cp = s;
1282                 BOOL got_mb = False;
1283
1284                 if (len == 0)
1285                         return NULL;
1286                 cp += (len - 1);
1287                 do {
1288                         if (c == *cp) {
1289                                 /* Could be a match. Part of a multibyte ? */
1290                                 if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
1291                                         /* Yep - go slow :-( */
1292                                         got_mb = True;
1293                                         break;
1294                                 }
1295                                 /* No - we have a match ! */
1296                                 return (char *)cp;
1297                         }
1298                 } while (cp-- != s);
1299                 if (!got_mb)
1300                         return NULL;
1301         }
1302
1303         /* String contained a non-ascii char. Slow path. */
1304         {
1305                 wpstring ws;
1306                 pstring s2;
1307                 smb_ucs2_t *p;
1308
1309                 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1310                 p = strrchr_w(ws, UCS2_CHAR(c));
1311                 if (!p)
1312                         return NULL;
1313                 *p = 0;
1314                 pull_ucs2_pstring(s2, ws);
1315                 return (char *)(s+strlen(s2));
1316         }
1317 }
1318
1319 /***********************************************************************
1320  Return the equivalent of doing strrchr 'n' times - always going
1321  backwards.
1322 ***********************************************************************/
1323
1324 char *strnrchr_m(const char *s, char c, unsigned int n)
1325 {
1326         wpstring ws;
1327         pstring s2;
1328         smb_ucs2_t *p;
1329
1330         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1331         p = strnrchr_w(ws, UCS2_CHAR(c), n);
1332         if (!p)
1333                 return NULL;
1334         *p = 0;
1335         pull_ucs2_pstring(s2, ws);
1336         return (char *)(s+strlen(s2));
1337 }
1338
1339 /***********************************************************************
1340  strstr_m - We convert via ucs2 for now.
1341 ***********************************************************************/
1342
1343 char *strstr_m(const char *src, const char *findstr)
1344 {
1345         smb_ucs2_t *p;
1346         smb_ucs2_t *src_w, *find_w;
1347         const char *s;
1348         char *s2;
1349         char *retp;
1350
1351         size_t findstr_len = 0;
1352
1353         /* for correctness */
1354         if (!findstr[0]) {
1355                 return (char*)src;
1356         }
1357
1358         /* Samba does single character findstr calls a *lot*. */
1359         if (findstr[1] == '\0')
1360                 return strchr_m(src, *findstr);
1361
1362         /* We optimise for the ascii case, knowing that all our
1363            supported multi-byte character sets are ascii-compatible
1364            (ie. they match for the first 128 chars) */
1365
1366         for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1367                 if (*s == *findstr) {
1368                         if (!findstr_len)
1369                                 findstr_len = strlen(findstr);
1370
1371                         if (strncmp(s, findstr, findstr_len) == 0) {
1372                                 return (char *)s;
1373                         }
1374                 }
1375         }
1376
1377         if (!*s)
1378                 return NULL;
1379
1380 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1381         /* 'make check' fails unless we do this */
1382
1383         /* With compose characters we must restart from the beginning. JRA. */
1384         s = src;
1385 #endif
1386
1387         if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1388                 DEBUG(0,("strstr_m: src malloc fail\n"));
1389                 return NULL;
1390         }
1391
1392         if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1393                 SAFE_FREE(src_w);
1394                 DEBUG(0,("strstr_m: find malloc fail\n"));
1395                 return NULL;
1396         }
1397
1398         p = strstr_w(src_w, find_w);
1399
1400         if (!p) {
1401                 SAFE_FREE(src_w);
1402                 SAFE_FREE(find_w);
1403                 return NULL;
1404         }
1405
1406         *p = 0;
1407         if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1408                 SAFE_FREE(src_w);
1409                 SAFE_FREE(find_w);
1410                 DEBUG(0,("strstr_m: dest malloc fail\n"));
1411                 return NULL;
1412         }
1413         retp = (char *)(s+strlen(s2));
1414         SAFE_FREE(src_w);
1415         SAFE_FREE(find_w);
1416         SAFE_FREE(s2);
1417         return retp;
1418 }
1419
1420 /**
1421  Convert a string to lower case.
1422 **/
1423
1424 void strlower_m(char *s)
1425 {
1426         size_t len;
1427         int errno_save;
1428
1429         /* this is quite a common operation, so we want it to be
1430            fast. We optimise for the ascii case, knowing that all our
1431            supported multi-byte character sets are ascii-compatible
1432            (ie. they match for the first 128 chars) */
1433
1434         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1435                 *s = tolower((unsigned char)*s);
1436                 s++;
1437         }
1438
1439         if (!*s)
1440                 return;
1441
1442         /* I assume that lowercased string takes the same number of bytes
1443          * as source string even in UTF-8 encoding. (VIV) */
1444         len = strlen(s) + 1;
1445         errno_save = errno;
1446         errno = 0;
1447         unix_strlower(s,len,s,len);
1448         /* Catch mb conversion errors that may not terminate. */
1449         if (errno)
1450                 s[len-1] = '\0';
1451         errno = errno_save;
1452 }
1453
1454 /**
1455  Convert a string to upper case.
1456 **/
1457
1458 void strupper_m(char *s)
1459 {
1460         size_t len;
1461         int errno_save;
1462
1463         /* this is quite a common operation, so we want it to be
1464            fast. We optimise for the ascii case, knowing that all our
1465            supported multi-byte character sets are ascii-compatible
1466            (ie. they match for the first 128 chars) */
1467
1468         while (*s && !(((unsigned char)s[0]) & 0x80)) {
1469                 *s = toupper((unsigned char)*s);
1470                 s++;
1471         }
1472
1473         if (!*s)
1474                 return;
1475
1476         /* I assume that lowercased string takes the same number of bytes
1477          * as source string even in multibyte encoding. (VIV) */
1478         len = strlen(s) + 1;
1479         errno_save = errno;
1480         errno = 0;
1481         unix_strupper(s,len,s,len);
1482         /* Catch mb conversion errors that may not terminate. */
1483         if (errno)
1484                 s[len-1] = '\0';
1485         errno = errno_save;
1486 }
1487
1488 /**
1489  Return a RFC2254 binary string representation of a buffer.
1490  Used in LDAP filters.
1491  Caller must free.
1492 **/
1493
1494 char *binary_string(char *buf, int len)
1495 {
1496         char *s;
1497         int i, j;
1498         const char *hex = "0123456789ABCDEF";
1499         s = SMB_MALLOC(len * 3 + 1);
1500         if (!s)
1501                 return NULL;
1502         for (j=i=0;i<len;i++) {
1503                 s[j] = '\\';
1504                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1505                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1506                 j += 3;
1507         }
1508         s[j] = 0;
1509         return s;
1510 }
1511
1512 /**
1513  Just a typesafety wrapper for snprintf into a pstring.
1514 **/
1515
1516  int pstr_sprintf(pstring s, const char *fmt, ...)
1517 {
1518         va_list ap;
1519         int ret;
1520
1521         va_start(ap, fmt);
1522         ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1523         va_end(ap);
1524         return ret;
1525 }
1526
1527
1528 /**
1529  Just a typesafety wrapper for snprintf into a fstring.
1530 **/
1531
1532 int fstr_sprintf(fstring s, const char *fmt, ...)
1533 {
1534         va_list ap;
1535         int ret;
1536
1537         va_start(ap, fmt);
1538         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1539         va_end(ap);
1540         return ret;
1541 }
1542
1543
1544 #if !defined(HAVE_STRNDUP) || defined(BROKEN_STRNDUP)
1545 /**
1546  Some platforms don't have strndup.
1547 **/
1548 #if defined(PARANOID_MALLOC_CHECKER)
1549 #undef strndup
1550 #endif
1551
1552  char *strndup(const char *s, size_t n)
1553 {
1554         char *ret;
1555
1556         n = strnlen(s, n);
1557         ret = SMB_MALLOC(n+1);
1558         if (!ret)
1559                 return NULL;
1560         memcpy(ret, s, n);
1561         ret[n] = 0;
1562
1563         return ret;
1564 }
1565
1566 #if defined(PARANOID_MALLOC_CHECKER)
1567 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
1568 #endif
1569
1570 #endif
1571
1572 #if !defined(HAVE_STRNLEN) || defined(BROKEN_STRNLEN)
1573 /**
1574  Some platforms don't have strnlen
1575 **/
1576
1577  size_t strnlen(const char *s, size_t n)
1578 {
1579         size_t i;
1580         for (i=0; i<n && s[i] != '\0'; i++)
1581                 /* noop */ ;
1582         return i;
1583 }
1584 #endif
1585
1586 /**
1587  List of Strings manipulation functions
1588 **/
1589
1590 #define S_LIST_ABS 16 /* List Allocation Block Size */
1591
1592 char **str_list_make(const char *string, const char *sep)
1593 {
1594         char **list, **rlist;
1595         const char *str;
1596         char *s;
1597         int num, lsize;
1598         pstring tok;
1599
1600         if (!string || !*string)
1601                 return NULL;
1602         s = SMB_STRDUP(string);
1603         if (!s) {
1604                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1605                 return NULL;
1606         }
1607         if (!sep) sep = LIST_SEP;
1608
1609         num = lsize = 0;
1610         list = NULL;
1611
1612         str = s;
1613         while (next_token(&str, tok, sep, sizeof(tok))) {
1614                 if (num == lsize) {
1615                         lsize += S_LIST_ABS;
1616                         rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
1617                         if (!rlist) {
1618                                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1619                                 str_list_free(&list);
1620                                 SAFE_FREE(s);
1621                                 return NULL;
1622                         } else
1623                                 list = rlist;
1624                         memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1625                 }
1626
1627                 list[num] = SMB_STRDUP(tok);
1628                 if (!list[num]) {
1629                         DEBUG(0,("str_list_make: Unable to allocate memory"));
1630                         str_list_free(&list);
1631                         SAFE_FREE(s);
1632                         return NULL;
1633                 }
1634
1635                 num++;
1636         }
1637
1638         SAFE_FREE(s);
1639         return list;
1640 }
1641
1642 BOOL str_list_copy(char ***dest, const char **src)
1643 {
1644         char **list, **rlist;
1645         int num, lsize;
1646
1647         *dest = NULL;
1648         if (!src)
1649                 return False;
1650
1651         num = lsize = 0;
1652         list = NULL;
1653
1654         while (src[num]) {
1655                 if (num == lsize) {
1656                         lsize += S_LIST_ABS;
1657                         rlist = SMB_REALLOC_ARRAY(list, char *, lsize +1);
1658                         if (!rlist) {
1659                                 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1660                                 str_list_free(&list);
1661                                 return False;
1662                         } else
1663                                 list = rlist;
1664                         memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1665                 }
1666
1667                 list[num] = SMB_STRDUP(src[num]);
1668                 if (!list[num]) {
1669                         DEBUG(0,("str_list_copy: Unable to allocate memory"));
1670                         str_list_free(&list);
1671                         return False;
1672                 }
1673
1674                 num++;
1675         }
1676
1677         *dest = list;
1678         return True;
1679 }
1680
1681 /**
1682  * Return true if all the elements of the list match exactly.
1683  **/
1684 BOOL str_list_compare(char **list1, char **list2)
1685 {
1686         int num;
1687
1688         if (!list1 || !list2)
1689                 return (list1 == list2);
1690
1691         for (num = 0; list1[num]; num++) {
1692                 if (!list2[num])
1693                         return False;
1694                 if (!strcsequal(list1[num], list2[num]))
1695                         return False;
1696         }
1697         if (list2[num])
1698                 return False; /* if list2 has more elements than list1 fail */
1699
1700         return True;
1701 }
1702
1703 void str_list_free(char ***list)
1704 {
1705         char **tlist;
1706
1707         if (!list || !*list)
1708                 return;
1709         tlist = *list;
1710         for(; *tlist; tlist++)
1711                 SAFE_FREE(*tlist);
1712         SAFE_FREE(*list);
1713 }
1714
1715 /******************************************************************************
1716  *****************************************************************************/
1717
1718 int str_list_count( const char **list )
1719 {
1720         int i = 0;
1721
1722         /* count the number of list members */
1723
1724         for ( i=0; *list; i++, list++ );
1725
1726         return i;
1727 }
1728
1729 /******************************************************************************
1730  version of standard_sub_basic() for string lists; uses alloc_sub_basic()
1731  for the work
1732  *****************************************************************************/
1733
1734 BOOL str_list_sub_basic( char **list, const char *smb_name )
1735 {
1736         char *s, *tmpstr;
1737
1738         while ( *list ) {
1739                 s = *list;
1740                 tmpstr = alloc_sub_basic(smb_name, s);
1741                 if ( !tmpstr ) {
1742                         DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
1743                         return False;
1744                 }
1745
1746                 SAFE_FREE(*list);
1747                 *list = tmpstr;
1748
1749                 list++;
1750         }
1751
1752         return True;
1753 }
1754
1755 /******************************************************************************
1756  substritute a specific pattern in a string list
1757  *****************************************************************************/
1758
1759 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1760 {
1761         char *p, *s, *t;
1762         ssize_t ls, lp, li, ld, i, d;
1763
1764         if (!list)
1765                 return False;
1766         if (!pattern)
1767                 return False;
1768         if (!insert)
1769                 return False;
1770
1771         lp = (ssize_t)strlen(pattern);
1772         li = (ssize_t)strlen(insert);
1773         ld = li -lp;
1774
1775         while (*list) {
1776                 s = *list;
1777                 ls = (ssize_t)strlen(s);
1778
1779                 while ((p = strstr_m(s, pattern))) {
1780                         t = *list;
1781                         d = p -t;
1782                         if (ld) {
1783                                 t = (char *) SMB_MALLOC(ls +ld +1);
1784                                 if (!t) {
1785                                         DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1786                                         return False;
1787                                 }
1788                                 memcpy(t, *list, d);
1789                                 memcpy(t +d +li, p +lp, ls -d -lp +1);
1790                                 SAFE_FREE(*list);
1791                                 *list = t;
1792                                 ls += ld;
1793                                 s = t +d +li;
1794                         }
1795
1796                         for (i = 0; i < li; i++) {
1797                                 switch (insert[i]) {
1798                                         case '`':
1799                                         case '"':
1800                                         case '\'':
1801                                         case ';':
1802                                         case '$':
1803                                         case '%':
1804                                         case '\r':
1805                                         case '\n':
1806                                                 t[d +i] = '_';
1807                                                 break;
1808                                         default:
1809                                                 t[d +i] = insert[i];
1810                                 }
1811                         }
1812                 }
1813
1814
1815                 list++;
1816         }
1817
1818         return True;
1819 }
1820
1821
1822 #define IPSTR_LIST_SEP  ","
1823 #define IPSTR_LIST_CHAR ','
1824
1825 /**
1826  * Add ip string representation to ipstr list. Used also
1827  * as part of @function ipstr_list_make
1828  *
1829  * @param ipstr_list pointer to string containing ip list;
1830  *        MUST BE already allocated and IS reallocated if necessary
1831  * @param ipstr_size pointer to current size of ipstr_list (might be changed
1832  *        as a result of reallocation)
1833  * @param ip IP address which is to be added to list
1834  * @return pointer to string appended with new ip and possibly
1835  *         reallocated to new length
1836  **/
1837
1838 char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
1839 {
1840         char* new_ipstr = NULL;
1841
1842         /* arguments checking */
1843         if (!ipstr_list || !service) return NULL;
1844
1845         /* attempt to convert ip to a string and append colon separator to it */
1846         if (*ipstr_list) {
1847                 asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list, IPSTR_LIST_SEP,
1848                         inet_ntoa(service->ip), service->port);
1849                 SAFE_FREE(*ipstr_list);
1850         } else {
1851                 asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
1852         }
1853         *ipstr_list = new_ipstr;
1854         return *ipstr_list;
1855 }
1856
1857
1858 /**
1859  * Allocate and initialise an ipstr list using ip adresses
1860  * passed as arguments.
1861  *
1862  * @param ipstr_list pointer to string meant to be allocated and set
1863  * @param ip_list array of ip addresses to place in the list
1864  * @param ip_count number of addresses stored in ip_list
1865  * @return pointer to allocated ip string
1866  **/
1867
1868 char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
1869 {
1870         int i;
1871
1872         /* arguments checking */
1873         if (!ip_list && !ipstr_list) return 0;
1874
1875         *ipstr_list = NULL;
1876
1877         /* process ip addresses given as arguments */
1878         for (i = 0; i < ip_count; i++)
1879                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
1880
1881         return (*ipstr_list);
1882 }
1883
1884
1885 /**
1886  * Parse given ip string list into array of ip addresses
1887  * (as ip_service structures)
1888  *    e.g. 192.168.1.100:389,192.168.1.78, ...
1889  *
1890  * @param ipstr ip string list to be parsed
1891  * @param ip_list pointer to array of ip addresses which is
1892  *        allocated by this function and must be freed by caller
1893  * @return number of succesfully parsed addresses
1894  **/
1895
1896 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
1897 {
1898         fstring token_str;
1899         size_t count;
1900         int i;
1901
1902         if (!ipstr_list || !ip_list)
1903                 return 0;
1904
1905         count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
1906         if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
1907                 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
1908                 return 0;
1909         }
1910
1911         for ( i=0;
1912                 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count;
1913                 i++ )
1914         {
1915                 struct in_addr addr;
1916                 unsigned port = 0;
1917                 char *p = strchr(token_str, ':');
1918
1919                 if (p) {
1920                         *p = 0;
1921                         port = atoi(p+1);
1922                 }
1923
1924                 /* convert single token to ip address */
1925                 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
1926                         break;
1927
1928                 (*ip_list)[i].ip = addr;
1929                 (*ip_list)[i].port = port;
1930         }
1931
1932         return count;
1933 }
1934
1935
1936 /**
1937  * Safely free ip string list
1938  *
1939  * @param ipstr_list ip string list to be freed
1940  **/
1941
1942 void ipstr_list_free(char* ipstr_list)
1943 {
1944         SAFE_FREE(ipstr_list);
1945 }
1946
1947
1948 /**
1949  Unescape a URL encoded string, in place.
1950 **/
1951
1952 void rfc1738_unescape(char *buf)
1953 {
1954         char *p=buf;
1955
1956         while (p && *p && (p=strchr_m(p,'%'))) {
1957                 int c1 = p[1];
1958                 int c2 = p[2];
1959
1960                 if (c1 >= '0' && c1 <= '9')
1961                         c1 = c1 - '0';
1962                 else if (c1 >= 'A' && c1 <= 'F')
1963                         c1 = 10 + c1 - 'A';
1964                 else if (c1 >= 'a' && c1 <= 'f')
1965                         c1 = 10 + c1 - 'a';
1966                 else {p++; continue;}
1967
1968                 if (c2 >= '0' && c2 <= '9')
1969                         c2 = c2 - '0';
1970                 else if (c2 >= 'A' && c2 <= 'F')
1971                         c2 = 10 + c2 - 'A';
1972                 else if (c2 >= 'a' && c2 <= 'f')
1973                         c2 = 10 + c2 - 'a';
1974                 else {p++; continue;}
1975
1976                 *p = (c1<<4) | c2;
1977
1978                 memmove(p+1, p+3, strlen(p+3)+1);
1979                 p++;
1980         }
1981 }
1982
1983 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1984
1985 /**
1986  * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1987  **/
1988 DATA_BLOB base64_decode_data_blob(const char *s)
1989 {
1990         int bit_offset, byte_offset, idx, i, n;
1991         DATA_BLOB decoded = data_blob(s, strlen(s)+1);
1992         unsigned char *d = decoded.data;
1993         char *p;
1994
1995         n=i=0;
1996
1997         while (*s && (p=strchr_m(b64,*s))) {
1998                 idx = (int)(p - b64);
1999                 byte_offset = (i*6)/8;
2000                 bit_offset = (i*6)%8;
2001                 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2002                 if (bit_offset < 3) {
2003                         d[byte_offset] |= (idx << (2-bit_offset));
2004                         n = byte_offset+1;
2005                 } else {
2006                         d[byte_offset] |= (idx >> (bit_offset-2));
2007                         d[byte_offset+1] = 0;
2008                         d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2009                         n = byte_offset+2;
2010                 }
2011                 s++; i++;
2012         }
2013
2014         if ((n > 0) && (*s == '=')) {
2015                 n -= 1;
2016         }
2017
2018         /* fix up length */
2019         decoded.length = n;
2020         return decoded;
2021 }
2022
2023 /**
2024  * Decode a base64 string in-place - wrapper for the above
2025  **/
2026 void base64_decode_inplace(char *s)
2027 {
2028         DATA_BLOB decoded = base64_decode_data_blob(s);
2029
2030         if ( decoded.length != 0 ) {
2031                 memcpy(s, decoded.data, decoded.length);
2032
2033                 /* null terminate */
2034                 s[decoded.length] = '\0';
2035         } else {
2036                 *s = '\0';
2037         }
2038
2039         data_blob_free(&decoded);
2040 }
2041
2042 /**
2043  * Encode a base64 string into a malloc()ed string caller to free.
2044  *
2045  *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
2046  **/
2047 char * base64_encode_data_blob(DATA_BLOB data)
2048 {
2049         int bits = 0;
2050         int char_count = 0;
2051         size_t out_cnt, len, output_len;
2052         char *result;
2053
2054         if (!data.length || !data.data)
2055                 return NULL;
2056
2057         out_cnt = 0;
2058         len = data.length;
2059         output_len = data.length * 2;
2060         result = SMB_MALLOC(output_len); /* get us plenty of space */
2061
2062         while (len-- && out_cnt < (data.length * 2) - 5) {
2063                 int c = (unsigned char) *(data.data++);
2064                 bits += c;
2065                 char_count++;
2066                 if (char_count == 3) {
2067                         result[out_cnt++] = b64[bits >> 18];
2068                         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2069                         result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2070             result[out_cnt++] = b64[bits & 0x3f];
2071             bits = 0;
2072             char_count = 0;
2073         } else {
2074             bits <<= 8;
2075         }
2076     }
2077     if (char_count != 0) {
2078         bits <<= 16 - (8 * char_count);
2079         result[out_cnt++] = b64[bits >> 18];
2080         result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2081         if (char_count == 1) {
2082             result[out_cnt++] = '=';
2083             result[out_cnt++] = '=';
2084         } else {
2085             result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2086             result[out_cnt++] = '=';
2087         }
2088     }
2089     result[out_cnt] = '\0';     /* terminate */
2090     return result;
2091 }
2092
2093 /* read a SMB_BIG_UINT from a string */
2094 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2095 {
2096
2097         SMB_BIG_UINT val = -1;
2098         const char *p = nptr;
2099
2100         while (p && *p && isspace(*p))
2101                 p++;
2102 #ifdef LARGE_SMB_OFF_T
2103         sscanf(p,"%llu",&val);
2104 #else /* LARGE_SMB_OFF_T */
2105         sscanf(p,"%lu",&val);
2106 #endif /* LARGE_SMB_OFF_T */
2107         if (entptr) {
2108                 while (p && *p && isdigit(*p))
2109                         p++;
2110                 *entptr = p;
2111         }
2112
2113         return val;
2114 }
2115
2116 void string_append(char **left, const char *right)
2117 {
2118         int new_len = strlen(right) + 1;
2119
2120         if (*left == NULL) {
2121                 *left = SMB_MALLOC(new_len);
2122                 *left[0] = '\0';
2123         } else {
2124                 new_len += strlen(*left);
2125                 *left = SMB_REALLOC(*left, new_len);
2126         }
2127
2128         if (*left == NULL)
2129                 return;
2130
2131         safe_strcat(*left, right, new_len-1);
2132 }
2133
2134 BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
2135                          const char *str, const char ***strings,
2136                          int *num)
2137 {
2138         char *dup_str = talloc_strdup(mem_ctx, str);
2139
2140         *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings, const char *, (*num)+1);
2141
2142         if ((*strings == NULL) || (dup_str == NULL))
2143                 return False;
2144
2145         (*strings)[*num] = dup_str;
2146         *num += 1;
2147         return True;
2148 }
2149
2150 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2151  * error checking in between. The indiation that something weird happened is
2152  * string==NULL */
2153
2154 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2155                     size_t *bufsize, const char *fmt, ...)
2156 {
2157         va_list ap;
2158         char *newstr;
2159         int ret;
2160         BOOL increased;
2161
2162         /* len<0 is an internal marker that something failed */
2163         if (*len < 0)
2164                 goto error;
2165
2166         if (*string == NULL) {
2167                 if (*bufsize == 0)
2168                         *bufsize = 128;
2169
2170                 if (mem_ctx != NULL)
2171                         *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2172                 else
2173                         *string = SMB_MALLOC_ARRAY(char, *bufsize);
2174
2175                 if (*string == NULL)
2176                         goto error;
2177         }
2178
2179         va_start(ap, fmt);
2180         ret = vasprintf(&newstr, fmt, ap);
2181         va_end(ap);
2182
2183         if (ret < 0)
2184                 goto error;
2185
2186         increased = False;
2187
2188         while ((*len)+ret >= *bufsize) {
2189                 increased = True;
2190                 *bufsize *= 2;
2191                 if (*bufsize >= (1024*1024*256))
2192                         goto error;
2193         }
2194
2195         if (increased) {
2196                 if (mem_ctx != NULL)
2197                         *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2198                                                        *bufsize);
2199                 else
2200                         *string = SMB_REALLOC_ARRAY(*string, char, *bufsize);
2201
2202                 if (*string == NULL)
2203                         goto error;
2204         }
2205
2206         StrnCpy((*string)+(*len), newstr, ret);
2207         (*len) += ret;
2208         free(newstr);
2209         return;
2210
2211  error:
2212         *len = -1;
2213         *string = NULL;
2214 }
2215
2216 /*
2217    Returns the substring from src between the first occurrence of
2218    the char "front" and the first occurence of the char "back".
2219    Mallocs the return string which must be freed.  Not for use
2220    with wide character strings.
2221 */
2222 char *sstring_sub(const char *src, char front, char back)
2223 {
2224         char *temp1, *temp2, *temp3;
2225         ptrdiff_t len;
2226
2227         temp1 = strchr(src, front);
2228         if (temp1 == NULL) return NULL;
2229         temp2 = strchr(src, back);
2230         if (temp2 == NULL) return NULL;
2231         len = temp2 - temp1;
2232         if (len <= 0) return NULL;
2233         temp3 = (char*)SMB_MALLOC(len);
2234         if (temp3 == NULL) {
2235                 DEBUG(1,("Malloc failure in sstring_sub\n"));
2236                 return NULL;
2237         }
2238         memcpy(temp3, temp1+1, len-1);
2239         temp3[len-1] = '\0';
2240         return temp3;
2241 }