source3/lib/util_str.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1992-2001
   5    Copyright (C) Simo Sorce      2001-2002
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 /****************************************************************************
  25  Get the next token from a string, return False if none found.
  26  Handles double-quotes.
  27  Based on a routine by GJC@VILLAGE.COM.
  28  Extensively modified by Andrew.Tridgell@anu.edu.au
  29 ****************************************************************************/
  30
  31 BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
  32 {
  33         const char *s;
  34         BOOL quoted;
  35         size_t len=1;
  36
  37         if (!ptr)
  38                 return(False);
  39
  40         s = *ptr;
  41
  42         /* default to simple separators */
  43         if (!sep)
  44                 sep = " \t\n\r";
  45
  46         /* find the first non sep char */
  47         while (*s && strchr_m(sep,*s))
  48                 s++;
  49
  50         /* nothing left? */
  51         if (! *s)
  52                 return(False);
  53
  54         /* copy over the token */
  55         for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
  56                 if (*s == '\"') {
  57                         quoted = !quoted;
  58                 } else {
  59                         len++;
  60                         *buff++ = *s;
  61                 }
  62         }
  63
  64         *ptr = (*s) ? s+1 : s;
  65         *buff = 0;
  66
  67         return(True);
  68 }
  69
  70 /****************************************************************************
  71 This is like next_token but is not re-entrant and "remembers" the first
  72 parameter so you can pass NULL. This is useful for user interface code
  73 but beware the fact that it is not re-entrant!
  74 ****************************************************************************/
  75
  76 static char *last_ptr=NULL;
  77
  78 BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
  79 {
  80         BOOL ret;
  81         if (!ptr)
  82                 ptr = (const char **)&last_ptr;
  83
  84         ret = next_token(ptr, buff, sep, bufsize);
  85         last_ptr = *ptr;
  86         return ret;
  87 }
  88
  89 static uint16 tmpbuf[sizeof(pstring)];
  90
  91 void set_first_token(char *ptr)
  92 {
  93         last_ptr = ptr;
  94 }
  95
  96 /****************************************************************************
  97  Convert list of tokens to array; dependent on above routine.
  98  Uses last_ptr from above - bit of a hack.
  99 ****************************************************************************/
 100
 101 char **toktocliplist(int *ctok, const char *sep)
 102 {
 103         char *s=last_ptr;
 104         int ictok=0;
 105         char **ret, **iret;
 106
 107         if (!sep)
 108                 sep = " \t\n\r";
 109
 110         while(*s && strchr_m(sep,*s))
 111                 s++;
 112
 113         /* nothing left? */
 114         if (!*s)
 115                 return(NULL);
 116
 117         do {
 118                 ictok++;
 119                 while(*s && (!strchr_m(sep,*s)))
 120                         s++;
 121                 while(*s && strchr_m(sep,*s))
 122                         *s++=0;
 123         } while(*s);
 124
 125         *ctok=ictok;
 126         s=last_ptr;
 127
 128         if (!(ret=iret=malloc(ictok*sizeof(char *))))
 129                 return NULL;
 130
 131         while(ictok--) {
 132                 *iret++=s;
 133                 while(*s++)
 134                         ;
 135                 while(!*s)
 136                         s++;
 137         }
 138
 139         return ret;
 140 }
 141
 142 /*******************************************************************
 143  Case insensitive string compararison.
 144 ********************************************************************/
 145
 146 int StrCaseCmp(const char *s, const char *t)
 147 {
 148         pstring buf1, buf2;
 149         unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
 150         unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
 151         return strcmp(buf1,buf2);
 152 }
 153
 154 /*******************************************************************
 155  Case insensitive string compararison, length limited.
 156 ********************************************************************/
 157
 158 int StrnCaseCmp(const char *s, const char *t, size_t n)
 159 {
 160         pstring buf1, buf2;
 161         unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
 162         unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
 163         return strncmp(buf1,buf2,n);
 164 }
 165
 166 /*******************************************************************
 167  Compare 2 strings.
 168 ********************************************************************/
 169
 170 BOOL strequal(const char *s1, const char *s2)
 171 {
 172         if (s1 == s2)
 173                 return(True);
 174         if (!s1 || !s2)
 175                 return(False);
 176
 177         return(StrCaseCmp(s1,s2)==0);
 178 }
 179
 180 /*******************************************************************
 181  Compare 2 strings up to and including the nth char.
 182 ******************************************************************/
 183
 184 BOOL strnequal(const char *s1,const char *s2,size_t n)
 185 {
 186   if (s1 == s2)
 187           return(True);
 188   if (!s1 || !s2 || !n)
 189           return(False);
 190
 191   return(StrnCaseCmp(s1,s2,n)==0);
 192 }
 193
 194 /*******************************************************************
 195  Compare 2 strings (case sensitive).
 196 ********************************************************************/
 197
 198 BOOL strcsequal(const char *s1,const char *s2)
 199 {
 200   if (s1 == s2)
 201           return(True);
 202   if (!s1 || !s2)
 203           return(False);
 204
 205   return(strcmp(s1,s2)==0);
 206 }
 207
 208 /***************************************************************************
 209 Do a case-insensitive, whitespace-ignoring string compare.
 210 ***************************************************************************/
 211
 212 int strwicmp(const char *psz1, const char *psz2)
 213 {
 214         /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 215         /* appropriate value. */
 216         if (psz1 == psz2)
 217                 return (0);
 218         else if (psz1 == NULL)
 219                 return (-1);
 220         else if (psz2 == NULL)
 221                 return (1);
 222
 223         /* sync the strings on first non-whitespace */
 224         while (1) {
 225                 while (isspace((int)*psz1))
 226                         psz1++;
 227                 while (isspace((int)*psz2))
 228                         psz2++;
 229                 if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0'
 230                     || *psz2 == '\0')
 231                         break;
 232                 psz1++;
 233                 psz2++;
 234         }
 235         return (*psz1 - *psz2);
 236 }
 237
 238
 239 /*******************************************************************
 240  Convert a string to upper case, but don't modify it.
 241 ********************************************************************/
 242
 243 char *strupper_static(const char *s)
 244 {
 245         static pstring str;
 246
 247         pstrcpy(str, s);
 248         strupper(str);
 249
 250         return str;
 251 }
 252
 253 /*******************************************************************
 254  Convert a string to "normal" form.
 255 ********************************************************************/
 256
 257 void strnorm(char *s)
 258 {
 259         extern int case_default;
 260         if (case_default == CASE_UPPER)
 261                 strupper(s);
 262         else
 263                 strlower(s);
 264 }
 265
 266 /*******************************************************************
 267  Check if a string is in "normal" case.
 268 ********************************************************************/
 269
 270 BOOL strisnormal(const char *s)
 271 {
 272         extern int case_default;
 273         if (case_default == CASE_UPPER)
 274                 return(!strhaslower(s));
 275
 276         return(!strhasupper(s));
 277 }
 278
 279
 280 /****************************************************************************
 281  String replace.
 282  NOTE: oldc and newc must be 7 bit characters
 283 ****************************************************************************/
 284
 285 void string_replace(char *s,char oldc,char newc)
 286 {
 287         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 288         string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
 289         pull_ucs2(NULL, s, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
 290 }
 291
 292 /*******************************************************************
 293  Skip past some strings in a buffer.
 294 ********************************************************************/
 295
 296 char *skip_string(char *buf,size_t n)
 297 {
 298         while (n--)
 299                 buf += strlen(buf) + 1;
 300         return(buf);
 301 }
 302
 303 /*******************************************************************
 304  Count the number of characters in a string. Normally this will
 305  be the same as the number of bytes in a string for single byte strings,
 306  but will be different for multibyte.
 307 ********************************************************************/
 308
 309 size_t str_charnum(const char *s)
 310 {
 311         uint16 tmpbuf2[sizeof(pstring)];
 312         push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
 313         return strlen_w(tmpbuf2);
 314 }
 315
 316 /*******************************************************************
 317  Count the number of characters in a string. Normally this will
 318  be the same as the number of bytes in a string for single byte strings,
 319  but will be different for multibyte.
 320 ********************************************************************/
 321
 322 size_t str_ascii_charnum(const char *s)
 323 {
 324         pstring tmpbuf2;
 325         push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
 326         return strlen(tmpbuf2);
 327 }
 328
 329 /*******************************************************************
 330  Trim the specified elements off the front and back of a string.
 331 ********************************************************************/
 332
 333 BOOL trim_string(char *s,const char *front,const char *back)
 334 {
 335         BOOL ret = False;
 336         size_t front_len;
 337         size_t back_len;
 338         size_t len;
 339
 340         /* Ignore null or empty strings. */
 341         if (!s || (s[0] == '\0'))
 342                 return False;
 343
 344         front_len       = front? strlen(front) : 0;
 345         back_len        = back? strlen(back) : 0;
 346
 347         len = strlen(s);
 348
 349         if (front_len) {
 350                 while (len && strncmp(s, front, front_len)==0) {
 351                         memcpy(s, s+front_len, (len-front_len)+1);
 352                         len -= front_len;
 353                         ret=True;
 354                 }
 355         }
 356
 357         if (back_len) {
 358                 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
 359                         s[len-back_len]='\0';
 360                         len -= back_len;
 361                         ret=True;
 362                 }
 363         }
 364         return ret;
 365 }
 366
 367 /****************************************************************************
 368  Does a string have any uppercase chars in it?
 369 ****************************************************************************/
 370
 371 BOOL strhasupper(const char *s)
 372 {
 373         smb_ucs2_t *ptr;
 374         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 375         for(ptr=tmpbuf;*ptr;ptr++)
 376                 if(isupper_w(*ptr))
 377                         return True;
 378         return(False);
 379 }
 380
 381 /****************************************************************************
 382  Does a string have any lowercase chars in it?
 383 ****************************************************************************/
 384
 385 BOOL strhaslower(const char *s)
 386 {
 387         smb_ucs2_t *ptr;
 388         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 389         for(ptr=tmpbuf;*ptr;ptr++)
 390                 if(islower_w(*ptr))
 391                         return True;
 392         return(False);
 393 }
 394
 395 /****************************************************************************
 396  Find the number of 'c' chars in a string
 397 ****************************************************************************/
 398
 399 size_t count_chars(const char *s,char c)
 400 {
 401         smb_ucs2_t *ptr;
 402         int count;
 403         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 404         for(count=0,ptr=tmpbuf;*ptr;ptr++)
 405                 if(*ptr==UCS2_CHAR(c))
 406                         count++;
 407         return(count);
 408 }
 409
 410 /*******************************************************************
 411 Return True if a string consists only of one particular character.
 412 ********************************************************************/
 413
 414 BOOL str_is_all(const char *s,char c)
 415 {
 416         smb_ucs2_t *ptr;
 417
 418         if(s == NULL)
 419                 return False;
 420         if(!*s)
 421                 return False;
 422
 423         push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
 424         for(ptr=tmpbuf;*ptr;ptr++)
 425                 if(*ptr!=UCS2_CHAR(c))
 426                         return False;
 427
 428         return True;
 429 }
 430
 431 /*******************************************************************
 432  Safe string copy into a known length string. maxlength does not
 433  include the terminating zero.
 434 ********************************************************************/
 435
 436 char *safe_strcpy(char *dest,const char *src, size_t maxlength)
 437 {
 438         size_t len;
 439
 440         if (!dest) {
 441                 DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
 442                 return NULL;
 443         }
 444
 445         if (!src) {
 446                 *dest = 0;
 447                 return dest;
 448         }
 449
 450         len = strlen(src);
 451
 452         if (len > maxlength) {
 453                 DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
 454                          (int)(len-maxlength), src));
 455                 len = maxlength;
 456         }
 457
 458         memmove(dest, src, len);
 459         dest[len] = 0;
 460         return dest;
 461 }
 462
 463 /*******************************************************************
 464  Safe string cat into a string. maxlength does not
 465  include the terminating zero.
 466 ********************************************************************/
 467
 468 char *safe_strcat(char *dest, const char *src, size_t maxlength)
 469 {
 470         size_t src_len, dest_len;
 471
 472         if (!dest) {
 473                 DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
 474                 return NULL;
 475         }
 476
 477         if (!src)
 478                 return dest;
 479
 480         src_len = strlen(src);
 481         dest_len = strlen(dest);
 482
 483         if (src_len + dest_len > maxlength) {
 484                 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
 485                          (int)(src_len + dest_len - maxlength), src));
 486                 src_len = maxlength - dest_len;
 487         }
 488
 489         memcpy(&dest[dest_len], src, src_len);
 490         dest[dest_len + src_len] = 0;
 491         return dest;
 492 }
 493
 494 /*******************************************************************
 495  Paranoid strcpy into a buffer of given length (includes terminating
 496  zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
 497  and replaces with '_'. Deliberately does *NOT* check for multibyte
 498  characters. Don't change it !
 499 ********************************************************************/
 500
 501 char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
 502 {
 503         size_t len, i;
 504
 505         if (!dest) {
 506                 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
 507                 return NULL;
 508         }
 509
 510         if (!src) {
 511                 *dest = 0;
 512                 return dest;
 513         }
 514
 515         len = strlen(src);
 516         if (len >= maxlength)
 517                 len = maxlength - 1;
 518
 519         if (!other_safe_chars)
 520                 other_safe_chars = "";
 521
 522         for(i = 0; i < len; i++) {
 523                 int val = (src[i] & 0xff);
 524                 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
 525                         dest[i] = src[i];
 526                 else
 527                         dest[i] = '_';
 528         }
 529
 530         dest[i] = '\0';
 531
 532         return dest;
 533 }
 534
 535 /****************************************************************************
 536  Like strncpy but always null terminates. Make sure there is room!
 537  The variable n should always be one less than the available size.
 538 ****************************************************************************/
 539
 540 char *StrnCpy(char *dest,const char *src,size_t n)
 541 {
 542         char *d = dest;
 543         if (!dest)
 544                 return(NULL);
 545         if (!src) {
 546                 *dest = 0;
 547                 return(dest);
 548         }
 549         while (n-- && (*d++ = *src++))
 550                 ;
 551         *d = 0;
 552         return(dest);
 553 }
 554
 555 /****************************************************************************
 556  Like strncpy but copies up to the character marker.  always null terminates.
 557  returns a pointer to the character marker in the source string (src).
 558 ****************************************************************************/
 559
 560 char *strncpyn(char *dest, const char *src, size_t n, char c)
 561 {
 562         char *p;
 563         size_t str_len;
 564
 565         p = strchr_m(src, c);
 566         if (p == NULL) {
 567                 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
 568                 return NULL;
 569         }
 570
 571         str_len = PTR_DIFF(p, src);
 572         strncpy(dest, src, MIN(n, str_len));
 573         dest[str_len] = '\0';
 574
 575         return p;
 576 }
 577
 578 /*************************************************************
 579  Routine to get hex characters and turn them into a 16 byte array.
 580  the array can be variable length, and any non-hex-numeric
 581  characters are skipped.  "0xnn" or "0Xnn" is specially catered
 582  for.
 583
 584  valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
 585
 586 **************************************************************/
 587
 588 size_t strhex_to_str(char *p, size_t len, const char *strhex)
 589 {
 590         size_t i;
 591         size_t num_chars = 0;
 592         unsigned char   lonybble, hinybble;
 593         const char     *hexchars = "0123456789ABCDEF";
 594         char           *p1 = NULL, *p2 = NULL;
 595
 596         for (i = 0; i < len && strhex[i] != 0; i++) {
 597                 if (strnequal(hexchars, "0x", 2)) {
 598                         i++; /* skip two chars */
 599                         continue;
 600                 }
 601
 602                 if (!(p1 = strchr_m(hexchars, toupper(strhex[i]))))
 603                         break;
 604
 605                 i++; /* next hex digit */
 606
 607                 if (!(p2 = strchr_m(hexchars, toupper(strhex[i]))))
 608                         break;
 609
 610                 /* get the two nybbles */
 611                 hinybble = PTR_DIFF(p1, hexchars);
 612                 lonybble = PTR_DIFF(p2, hexchars);
 613
 614                 p[num_chars] = (hinybble << 4) | lonybble;
 615                 num_chars++;
 616
 617                 p1 = NULL;
 618                 p2 = NULL;
 619         }
 620         return num_chars;
 621 }
 622
 623 /****************************************************************************
 624  Check if a string is part of a list.
 625 ****************************************************************************/
 626
 627 BOOL in_list(char *s,char *list,BOOL casesensitive)
 628 {
 629         pstring tok;
 630         const char *p=list;
 631
 632         if (!list)
 633                 return(False);
 634
 635         while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
 636                 if (casesensitive) {
 637                         if (strcmp(tok,s) == 0)
 638                                 return(True);
 639                 } else {
 640                         if (StrCaseCmp(tok,s) == 0)
 641                                 return(True);
 642                 }
 643         }
 644         return(False);
 645 }
 646
 647 /* this is used to prevent lots of mallocs of size 1 */
 648 static char *null_string = NULL;
 649
 650 /****************************************************************************
 651  Set a string value, allocing the space for the string
 652 ****************************************************************************/
 653
 654 static BOOL string_init(char **dest,const char *src)
 655 {
 656         size_t l;
 657         if (!src)
 658                 src = "";
 659
 660         l = strlen(src);
 661
 662         if (l == 0) {
 663                 if (!null_string) {
 664                         if((null_string = (char *)malloc(1)) == NULL) {
 665                                 DEBUG(0,("string_init: malloc fail for null_string.\n"));
 666                                 return False;
 667                         }
 668                         *null_string = 0;
 669                 }
 670                 *dest = null_string;
 671         } else {
 672                 (*dest) = strdup(src);
 673                 if ((*dest) == NULL) {
 674                         DEBUG(0,("Out of memory in string_init\n"));
 675                         return False;
 676                 }
 677         }
 678         return(True);
 679 }
 680
 681 /****************************************************************************
 682  Free a string value.
 683 ****************************************************************************/
 684
 685 void string_free(char **s)
 686 {
 687         if (!s || !(*s))
 688                 return;
 689         if (*s == null_string)
 690                 *s = NULL;
 691         SAFE_FREE(*s);
 692 }
 693
 694 /****************************************************************************
 695  Set a string value, deallocating any existing space, and allocing the space
 696  for the string
 697 ****************************************************************************/
 698
 699 BOOL string_set(char **dest,const char *src)
 700 {
 701         string_free(dest);
 702         return(string_init(dest,src));
 703 }
 704
 705 /****************************************************************************
 706  Substitute a string for a pattern in another string. Make sure there is
 707  enough room!
 708
 709  This routine looks for pattern in s and replaces it with
 710  insert. It may do multiple replacements.
 711
 712  Any of " ; ' $ or ` in the insert string are replaced with _
 713  if len==0 then the string cannot be extended. This is different from the old
 714  use of len==0 which was for no length checks to be done.
 715 ****************************************************************************/
 716
 717 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 718 {
 719         char *p;
 720         ssize_t ls,lp,li, i;
 721
 722         if (!insert || !pattern || !*pattern || !s)
 723                 return;
 724
 725         ls = (ssize_t)strlen(s);
 726         lp = (ssize_t)strlen(pattern);
 727         li = (ssize_t)strlen(insert);
 728
 729         if (len == 0)
 730                 len = ls + 1; /* len is number of *bytes* */
 731
 732         while (lp <= ls && (p = strstr(s,pattern))) {
 733                 if (ls + (li-lp) >= len) {
 734                         DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
 735                                  (int)(ls + (li-lp) - len),
 736                                  pattern, (int)len));
 737                         break;
 738                 }
 739                 if (li != lp) {
 740                         memmove(p+li,p+lp,strlen(p+lp)+1);
 741                 }
 742                 for (i=0;i<li;i++) {
 743                         switch (insert[i]) {
 744                         case '`':
 745                         case '"':
 746                         case '\'':
 747                         case ';':
 748                         case '$':
 749                         case '%':
 750                         case '\r':
 751                         case '\n':
 752                                 p[i] = '_';
 753                                 break;
 754                         default:
 755                                 p[i] = insert[i];
 756                         }
 757                 }
 758                 s = p + li;
 759                 ls += (li-lp);
 760         }
 761 }
 762
 763 void fstring_sub(char *s,const char *pattern,const char *insert)
 764 {
 765         string_sub(s, pattern, insert, sizeof(fstring));
 766 }
 767
 768 void pstring_sub(char *s,const char *pattern,const char *insert)
 769 {
 770         string_sub(s, pattern, insert, sizeof(pstring));
 771 }
 772
 773 /****************************************************************************
 774  Similar to string_sub, but it will accept only allocated strings
 775  and may realloc them so pay attention at what you pass on no
 776  pointers inside strings, no pstrings or const may be passed
 777  as string.
 778 ****************************************************************************/
 779
 780 char *realloc_string_sub(char *string, const char *pattern, const char *insert)
 781 {
 782         char *p, *in;
 783         char *s;
 784         ssize_t ls,lp,li,ld, i;
 785
 786         if (!insert || !pattern || !*pattern || !string || !*string)
 787                 return NULL;
 788
 789         s = string;
 790
 791         in = strdup(insert);
 792         if (!in) {
 793                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
 794                 return NULL;
 795         }
 796         ls = (ssize_t)strlen(s);
 797         lp = (ssize_t)strlen(pattern);
 798         li = (ssize_t)strlen(insert);
 799         ld = li - lp;
 800         for (i=0;i<li;i++) {
 801                 switch (in[i]) {
 802                         case '`':
 803                         case '"':
 804                         case '\'':
 805                         case ';':
 806                         case '$':
 807                         case '%':
 808                         case '\r':
 809                         case '\n':
 810                                 in[i] = '_';
 811                         default:
 812                                 /* ok */
 813                                 break;
 814                 }
 815         }
 816
 817         while ((p = strstr(s,pattern))) {
 818                 if (ld > 0) {
 819                         char *t = Realloc(string, ls + ld + 1);
 820                         if (!t) {
 821                                 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
 822                                 SAFE_FREE(in);
 823                                 return NULL;
 824                         }
 825                         string = t;
 826                         p = t + (p - s);
 827                 }
 828                 if (li != lp) {
 829                         memmove(p+li,p+lp,strlen(p+lp)+1);
 830                 }
 831                 memcpy(p, in, li);
 832                 s = p + li;
 833                 ls += ld;
 834         }
 835         SAFE_FREE(in);
 836         return string;
 837 }
 838
 839 /****************************************************************************
 840  Similar to string_sub() but allows for any character to be substituted.
 841  Use with caution!
 842  if len==0 then the string cannot be extended. This is different from the old
 843  use of len==0 which was for no length checks to be done.
 844 ****************************************************************************/
 845
 846 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
 847 {
 848         char *p;
 849         ssize_t ls,lp,li;
 850
 851         if (!insert || !pattern || !s)
 852                 return;
 853
 854         ls = (ssize_t)strlen(s);
 855         lp = (ssize_t)strlen(pattern);
 856         li = (ssize_t)strlen(insert);
 857
 858         if (!*pattern)
 859                 return;
 860
 861         if (len == 0)
 862                 len = ls + 1; /* len is number of *bytes* */
 863
 864         while (lp <= ls && (p = strstr(s,pattern))) {
 865                 if (ls + (li-lp) >= len) {
 866                         DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
 867                                  (int)(ls + (li-lp) - len),
 868                                  pattern, (int)len));
 869                         break;
 870                 }
 871                 if (li != lp) {
 872                         memmove(p+li,p+lp,strlen(p+lp)+1);
 873                 }
 874                 memcpy(p, insert, li);
 875                 s = p + li;
 876                 ls += (li-lp);
 877         }
 878 }
 879
 880 /****************************************************************************
 881  Similar to all_string_sub but for unicode strings.
 882  Return a new allocated unicode string.
 883  similar to string_sub() but allows for any character to be substituted.
 884  Use with caution!
 885 ****************************************************************************/
 886
 887 smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
 888                                 const smb_ucs2_t *insert)
 889 {
 890         smb_ucs2_t *r, *rp;
 891         const smb_ucs2_t *sp;
 892         size_t  lr, lp, li, lt;
 893
 894         if (!insert || !pattern || !*pattern || !s)
 895                 return NULL;
 896
 897         lt = (size_t)strlen_w(s);
 898         lp = (size_t)strlen_w(pattern);
 899         li = (size_t)strlen_w(insert);
 900
 901         if (li > lp) {
 902                 const smb_ucs2_t *st = s;
 903                 int ld = li - lp;
 904                 while ((sp = strstr_w(st, pattern))) {
 905                         st = sp + lp;
 906                         lt += ld;
 907                 }
 908         }
 909
 910         r = rp = (smb_ucs2_t *)malloc((lt + 1)*(sizeof(smb_ucs2_t)));
 911         if (!r) {
 912                 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
 913                 return NULL;
 914         }
 915
 916         while ((sp = strstr_w(s, pattern))) {
 917                 memcpy(rp, s, (sp - s));
 918                 rp += ((sp - s) / sizeof(smb_ucs2_t));
 919                 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
 920                 s = sp + lp;
 921                 rp += li;
 922         }
 923         lr = ((rp - r) / sizeof(smb_ucs2_t));
 924         if (lr < lt) {
 925                 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
 926                 rp += (lt - lr);
 927         }
 928         *rp = 0;
 929
 930         return r;
 931 }
 932
 933 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
 934                                              const char *insert)
 935 {
 936         wpstring p, i;
 937
 938         if (!insert || !pattern || !s)
 939                 return NULL;
 940         push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
 941         push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
 942         return all_string_sub_w(s, p, i);
 943 }
 944
 945 /****************************************************************************
 946  Splits out the front and back at a separator.
 947 ****************************************************************************/
 948
 949 void split_at_last_component(char *path, char *front, char sep, char *back)
 950 {
 951         char *p = strrchr_m(path, sep);
 952
 953         if (p != NULL)
 954                 *p = 0;
 955
 956         if (front != NULL)
 957                 pstrcpy(front, path);
 958
 959         if (p != NULL) {
 960                 if (back != NULL)
 961                         pstrcpy(back, p+1);
 962                 *p = '\\';
 963         } else {
 964                 if (back != NULL)
 965                         back[0] = 0;
 966         }
 967 }
 968
 969 /****************************************************************************
 970  Write an octal as a string.
 971 ****************************************************************************/
 972
 973 const char *octal_string(int i)
 974 {
 975         static char ret[64];
 976         if (i == -1)
 977                 return "-1";
 978         slprintf(ret, sizeof(ret)-1, "0%o", i);
 979         return ret;
 980 }
 981
 982
 983 /****************************************************************************
 984  Truncate a string at a specified length.
 985 ****************************************************************************/
 986
 987 char *string_truncate(char *s, int length)
 988 {
 989         if (s && strlen(s) > length)
 990                 s[length] = 0;
 991         return s;
 992 }
 993
 994 /****************************************************************************
 995  Strchr and strrchr_m are very hard to do on general multi-byte strings.
 996  We convert via ucs2 for now.
 997 ****************************************************************************/
 998
 999 char *strchr_m(const char *s, char c)
1000 {
1001         wpstring ws;
1002         pstring s2;
1003         smb_ucs2_t *p;
1004
1005         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1006         p = strchr_w(ws, UCS2_CHAR(c));
1007         if (!p)
1008                 return NULL;
1009         *p = 0;
1010         pull_ucs2_pstring(s2, ws);
1011         return (char *)(s+strlen(s2));
1012 }
1013
1014 char *strrchr_m(const char *s, char c)
1015 {
1016         wpstring ws;
1017         pstring s2;
1018         smb_ucs2_t *p;
1019
1020         push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1021         p = strrchr_w(ws, UCS2_CHAR(c));
1022         if (!p)
1023                 return NULL;
1024         *p = 0;
1025         pull_ucs2_pstring(s2, ws);
1026         return (char *)(s+strlen(s2));
1027 }
1028
1029 /*******************************************************************
1030  Convert a string to lower case.
1031 ********************************************************************/
1032
1033 void strlower_m(char *s)
1034 {
1035         /* this is quite a common operation, so we want it to be
1036            fast. We optimise for the ascii case, knowing that all our
1037            supported multi-byte character sets are ascii-compatible
1038            (ie. they match for the first 128 chars) */
1039
1040         while (*s && !(((unsigned char)s[0]) & 0x7F))
1041                 *s++ = tolower((unsigned char)*s);
1042
1043         if (!*s)
1044                 return;
1045
1046         /* I assume that lowercased string takes the same number of bytes
1047          * as source string even in UTF-8 encoding. (VIV) */
1048         unix_strlower(s,strlen(s)+1,s,strlen(s)+1);
1049 }
1050
1051 /*******************************************************************
1052  Duplicate convert a string to lower case.
1053 ********************************************************************/
1054
1055 char *strdup_lower(const char *s)
1056 {
1057         char *t = strdup(s);
1058         if (t == NULL) {
1059                 DEBUG(0, ("strdup_lower: Out of memory!\n"));
1060                 return NULL;
1061         }
1062         strlower_m(t);
1063         return t;
1064 }
1065
1066 /*******************************************************************
1067  Convert a string to upper case.
1068 ********************************************************************/
1069
1070 void strupper_m(char *s)
1071 {
1072         /* this is quite a common operation, so we want it to be
1073            fast. We optimise for the ascii case, knowing that all our
1074            supported multi-byte character sets are ascii-compatible
1075            (ie. they match for the first 128 chars) */
1076
1077         while (*s && !(((unsigned char)s[0]) & 0x7F))
1078                 *s++ = toupper((unsigned char)*s);
1079
1080         if (!*s)
1081                 return;
1082
1083         /* I assume that lowercased string takes the same number of bytes
1084          * as source string even in multibyte encoding. (VIV) */
1085         unix_strupper(s,strlen(s)+1,s,strlen(s)+1);
1086 }
1087
1088 /*******************************************************************
1089  Convert a string to upper case.
1090 ********************************************************************/
1091
1092 char *strdup_upper(const char *s)
1093 {
1094         char *t = strdup(s);
1095         if (t == NULL) {
1096                 DEBUG(0, ("strdup_upper: Out of memory!\n"));
1097                 return NULL;
1098         }
1099         strupper_m(t);
1100         return t;
1101 }
1102
1103 /*******************************************************************
1104  Return a RFC2254 binary string representation of a buffer.
1105  Used in LDAP filters.
1106  Caller must free.
1107 ********************************************************************/
1108
1109 char *binary_string(char *buf, int len)
1110 {
1111         char *s;
1112         int i, j;
1113         const char *hex = "0123456789ABCDEF";
1114         s = malloc(len * 3 + 1);
1115         if (!s)
1116                 return NULL;
1117         for (j=i=0;i<len;i++) {
1118                 s[j] = '\\';
1119                 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1120                 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1121                 j += 3;
1122         }
1123         s[j] = 0;
1124         return s;
1125 }
1126
1127 /*******************************************************************
1128  Just a typesafety wrapper for snprintf into a pstring.
1129 ********************************************************************/
1130
1131  int pstr_sprintf(pstring s, const char *fmt, ...)
1132 {
1133         va_list ap;
1134         int ret;
1135
1136         va_start(ap, fmt);
1137         ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1138         va_end(ap);
1139         return ret;
1140 }
1141
1142 /*******************************************************************
1143  Just a typesafety wrapper for snprintf into a fstring.
1144 ********************************************************************/
1145
1146  int fstr_sprintf(fstring s, const char *fmt, ...)
1147 {
1148         va_list ap;
1149         int ret;
1150
1151         va_start(ap, fmt);
1152         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1153         va_end(ap);
1154         return ret;
1155 }
1156
1157 #ifndef HAVE_STRNDUP
1158 /*******************************************************************
1159  Some platforms don't have strndup.
1160 ********************************************************************/
1161
1162  char *strndup(const char *s, size_t n)
1163 {
1164         char *ret;
1165
1166         n = strnlen(s, n);
1167         ret = malloc(n+1);
1168         if (!ret)
1169                 return NULL;
1170         memcpy(ret, s, n);
1171         ret[n] = 0;
1172
1173         return ret;
1174 }
1175 #endif
1176
1177 #ifndef HAVE_STRNLEN
1178 /*******************************************************************
1179  Some platforms don't have strnlen
1180 ********************************************************************/
1181
1182  size_t strnlen(const char *s, size_t n)
1183 {
1184         int i;
1185         for (i=0; s[i] && i<n; i++)
1186                 /* noop */ ;
1187         return i;
1188 }
1189 #endif
1190
1191 /***********************************************************
1192  List of Strings manipulation functions
1193 ***********************************************************/
1194
1195 #define S_LIST_ABS 16 /* List Allocation Block Size */
1196
1197 char **str_list_make(const char *string, const char *sep)
1198 {
1199         char **list, **rlist;
1200         const char *str;
1201         char *s;
1202         int num, lsize;
1203         pstring tok;
1204
1205         if (!string || !*string)
1206                 return NULL;
1207         s = strdup(string);
1208         if (!s) {
1209                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1210                 return NULL;
1211         }
1212         if (!sep) sep = LIST_SEP;
1213
1214         num = lsize = 0;
1215         list = NULL;
1216
1217         str = s;
1218         while (next_token(&str, tok, sep, sizeof(tok))) {
1219                 if (num == lsize) {
1220                         lsize += S_LIST_ABS;
1221                         rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1222                         if (!rlist) {
1223                                 DEBUG(0,("str_list_make: Unable to allocate memory"));
1224                                 str_list_free(&list);
1225                                 SAFE_FREE(s);
1226                                 return NULL;
1227                         } else
1228                                 list = rlist;
1229                         memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1230                 }
1231
1232                 list[num] = strdup(tok);
1233                 if (!list[num]) {
1234                         DEBUG(0,("str_list_make: Unable to allocate memory"));
1235                         str_list_free(&list);
1236                         SAFE_FREE(s);
1237                         return NULL;
1238                 }
1239
1240                 num++;
1241         }
1242
1243         SAFE_FREE(s);
1244         return list;
1245 }
1246
1247 BOOL str_list_copy(char ***dest, const char **src)
1248 {
1249         char **list, **rlist;
1250         int num, lsize;
1251
1252         *dest = NULL;
1253         if (!src)
1254                 return False;
1255
1256         num = lsize = 0;
1257         list = NULL;
1258
1259         while (src[num]) {
1260                 if (num == lsize) {
1261                         lsize += S_LIST_ABS;
1262                         rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1263                         if (!rlist) {
1264                                 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1265                                 str_list_free(&list);
1266                                 return False;
1267                         } else
1268                                 list = rlist;
1269                         memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1270                 }
1271
1272                 list[num] = strdup(src[num]);
1273                 if (!list[num]) {
1274                         DEBUG(0,("str_list_copy: Unable to allocate memory"));
1275                         str_list_free(&list);
1276                         return False;
1277                 }
1278
1279                 num++;
1280         }
1281
1282         *dest = list;
1283         return True;
1284 }
1285
1286 /***********************************************************
1287  Return true if all the elements of the list match exactly.
1288 ***********************************************************/
1289
1290 BOOL str_list_compare(char **list1, char **list2)
1291 {
1292         int num;
1293
1294         if (!list1 || !list2)
1295                 return (list1 == list2);
1296
1297         for (num = 0; list1[num]; num++) {
1298                 if (!list2[num])
1299                         return False;
1300                 if (!strcsequal(list1[num], list2[num]))
1301                         return False;
1302         }
1303         if (list2[num])
1304                 return False; /* if list2 has more elements than list1 fail */
1305
1306         return True;
1307 }
1308
1309 void str_list_free(char ***list)
1310 {
1311         char **tlist;
1312
1313         if (!list || !*list)
1314                 return;
1315         tlist = *list;
1316         for(; *tlist; tlist++)
1317                 SAFE_FREE(*tlist);
1318         SAFE_FREE(*list);
1319 }
1320
1321 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1322 {
1323         char *p, *s, *t;
1324         ssize_t ls, lp, li, ld, i, d;
1325
1326         if (!list)
1327                 return False;
1328         if (!pattern)
1329                 return False;
1330         if (!insert)
1331                 return False;
1332
1333         lp = (ssize_t)strlen(pattern);
1334         li = (ssize_t)strlen(insert);
1335         ld = li -lp;
1336
1337         while (*list) {
1338                 s = *list;
1339                 ls = (ssize_t)strlen(s);
1340
1341                 while ((p = strstr(s, pattern))) {
1342                         t = *list;
1343                         d = p -t;
1344                         if (ld) {
1345                                 t = (char *) malloc(ls +ld +1);
1346                                 if (!t) {
1347                                         DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1348                                         return False;
1349                                 }
1350                                 memcpy(t, *list, d);
1351                                 memcpy(t +d +li, p +lp, ls -d -lp +1);
1352                                 SAFE_FREE(*list);
1353                                 *list = t;
1354                                 ls += ld;
1355                                 s = t +d +li;
1356                         }
1357
1358                         for (i = 0; i < li; i++) {
1359                                 switch (insert[i]) {
1360                                         case '`':
1361                                         case '"':
1362                                         case '\'':
1363                                         case ';':
1364                                         case '$':
1365                                         case '%':
1366                                         case '\r':
1367                                         case '\n':
1368                                                 t[d +i] = '_';
1369                                                 break;
1370                                         default:
1371                                                 t[d +i] = insert[i];
1372                                 }
1373                         }
1374                 }
1375
1376                 list++;
1377         }
1378
1379         return True;
1380 }
1381
1382
1383 #define IPSTR_LIST_SEP  ","
1384
1385 /**
1386  * Add ip string representation to ipstr list. Used also
1387  * as part of @function ipstr_list_make
1388  *
1389  * @param ipstr_list pointer to string containing ip list;
1390  *        MUST BE already allocated and IS reallocated if necessary
1391  * @param ipstr_size pointer to current size of ipstr_list (might be changed
1392  *        as a result of reallocation)
1393  * @param ip IP address which is to be added to list
1394  * @return pointer to string appended with new ip and possibly
1395  *         reallocated to new length
1396  **/
1397
1398 char* ipstr_list_add(char** ipstr_list, const struct in_addr *ip)
1399 {
1400         char* new_ipstr = NULL;
1401
1402         /* arguments checking */
1403         if (!ipstr_list || !ip) return NULL;
1404
1405         /* attempt to convert ip to a string and append colon separator to it */
1406         if (*ipstr_list) {
1407                 asprintf(&new_ipstr, "%s%s%s", *ipstr_list, IPSTR_LIST_SEP,inet_ntoa(*ip));
1408                 SAFE_FREE(*ipstr_list);
1409         } else {
1410                 asprintf(&new_ipstr, "%s", inet_ntoa(*ip));
1411         }
1412         *ipstr_list = new_ipstr;
1413         return *ipstr_list;
1414 }
1415
1416
1417 /**
1418  * Allocate and initialise an ipstr list using ip adresses
1419  * passed as arguments.
1420  *
1421  * @param ipstr_list pointer to string meant to be allocated and set
1422  * @param ip_list array of ip addresses to place in the list
1423  * @param ip_count number of addresses stored in ip_list
1424  * @return pointer to allocated ip string
1425  **/
1426
1427 char* ipstr_list_make(char** ipstr_list, const struct in_addr* ip_list, int ip_count)
1428 {
1429         int i;
1430
1431         /* arguments checking */
1432         if (!ip_list && !ipstr_list) return 0;
1433
1434         *ipstr_list = NULL;
1435
1436         /* process ip addresses given as arguments */
1437         for (i = 0; i < ip_count; i++)
1438                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
1439
1440         return (*ipstr_list);
1441 }
1442
1443
1444 /**
1445  * Parse given ip string list into array of ip addresses
1446  * (as in_addr structures)
1447  *
1448  * @param ipstr ip string list to be parsed
1449  * @param ip_list pointer to array of ip addresses which is
1450  *        allocated by this function and must be freed by caller
1451  * @return number of succesfully parsed addresses
1452  **/
1453
1454 int ipstr_list_parse(const char* ipstr_list, struct in_addr** ip_list)
1455 {
1456         fstring token_str;
1457         int count;
1458
1459         if (!ipstr_list || !ip_list) return 0;
1460
1461         for (*ip_list = NULL, count = 0;
1462              next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN);
1463              count++) {
1464
1465                 struct in_addr addr;
1466
1467                 /* convert single token to ip address */
1468                 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
1469                         break;
1470
1471                 /* prepare place for another in_addr structure */
1472                 *ip_list = Realloc(*ip_list, (count + 1) * sizeof(struct in_addr));
1473                 if (!*ip_list) return -1;
1474
1475                 (*ip_list)[count] = addr;
1476         }
1477
1478         return count;
1479 }
1480
1481
1482 /**
1483  * Safely free ip string list
1484  *
1485  * @param ipstr_list ip string list to be freed
1486  **/
1487
1488 void ipstr_list_free(char* ipstr_list)
1489 {
1490         SAFE_FREE(ipstr_list);
1491 }
1492
1493
1494 /***********************************************************
1495  Unescape a URL encoded string, in place.
1496 ***********************************************************/
1497
1498 void rfc1738_unescape(char *buf)
1499 {
1500         char *p=buf;
1501
1502         while ((p=strchr_m(p,'+')))
1503                 *p = ' ';
1504
1505         p = buf;
1506
1507         while (p && *p && (p=strchr_m(p,'%'))) {
1508                 int c1 = p[1];
1509                 int c2 = p[2];
1510
1511                 if (c1 >= '0' && c1 <= '9')
1512                         c1 = c1 - '0';
1513                 else if (c1 >= 'A' && c1 <= 'F')
1514                         c1 = 10 + c1 - 'A';
1515                 else if (c1 >= 'a' && c1 <= 'f')
1516                         c1 = 10 + c1 - 'a';
1517                 else {p++; continue;}
1518
1519                 if (c2 >= '0' && c2 <= '9')
1520                         c2 = c2 - '0';
1521                 else if (c2 >= 'A' && c2 <= 'F')
1522                         c2 = 10 + c2 - 'A';
1523                 else if (c2 >= 'a' && c2 <= 'f')
1524                         c2 = 10 + c2 - 'a';
1525                 else {p++; continue;}
1526
1527                 *p = (c1<<4) | c2;
1528
1529                 memmove(p+1, p+3, strlen(p+3)+1);
1530                 p++;
1531         }
1532 }
1533
1534 #ifdef VALGRIND
1535 size_t valgrind_strlen(const char *s)
1536 {
1537         size_t count;
1538         for(count = 0; *s++; count++)
1539                 ;
1540         return count;
1541 }
1542 #endif