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