source3/lib/util_str.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Andrew Tridgell 1992-2001
   6    Copyright (C) Simo Sorce      2001-2002
   7    Copyright (C) Martin Pool     2003
   8    Copyright (C) James Peach     2006
   9    Copyright (C) Jeremy Allison  1992-2007
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "lib/param/loadparm.h"
  27
  28 static const char toupper_ascii_fast_table[128] = {
  29         0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
  30         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  31         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  32         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  33         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  34         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  35         0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  36         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
  37 };
  38
  39 /**
  40  * Compare 2 strings up to and including the nth char.
  41  *
  42  * @note The comparison is case-insensitive.
  43  **/
  44 bool strnequal(const char *s1,const char *s2,size_t n)
  45 {
  46         if (s1 == s2)
  47                 return(true);
  48         if (!s1 || !s2 || !n)
  49                 return(false);
  50
  51         return(strncasecmp_m(s1,s2,n)==0);
  52 }
  53
  54 /**
  55  Convert a string to "normal" form.
  56 **/
  57
  58 bool strnorm(char *s, int case_default)
  59 {
  60         if (case_default == CASE_UPPER)
  61                 return strupper_m(s);
  62         else
  63                 return strlower_m(s);
  64 }
  65
  66 /**
  67  Skip past a string in a buffer. Buffer may not be
  68  null terminated. end_ptr points to the first byte after
  69  then end of the buffer.
  70 **/
  71
  72 char *skip_string(const char *base, size_t len, char *buf)
  73 {
  74         const char *end_ptr = base + len;
  75
  76         if (end_ptr < base || !base || !buf || buf >= end_ptr) {
  77                 return NULL;
  78         }
  79
  80         /* Skip the string */
  81         while (*buf) {
  82                 buf++;
  83                 if (buf >= end_ptr) {
  84                         return NULL;
  85                 }
  86         }
  87         /* Skip the '\0' */
  88         buf++;
  89         return buf;
  90 }
  91
  92 /**
  93  Count the number of characters in a string. Normally this will
  94  be the same as the number of bytes in a string for single byte strings,
  95  but will be different for multibyte.
  96 **/
  97
  98 size_t str_charnum(const char *s)
  99 {
 100         size_t ret, converted_size;
 101         smb_ucs2_t *tmpbuf2 = NULL;
 102         if (!push_ucs2_talloc(talloc_tos(), &tmpbuf2, s, &converted_size)) {
 103                 return 0;
 104         }
 105         ret = strlen_w(tmpbuf2);
 106         TALLOC_FREE(tmpbuf2);
 107         return ret;
 108 }
 109
 110 bool trim_char(char *s,char cfront,char cback)
 111 {
 112         bool ret = false;
 113         char *ep;
 114         char *fp = s;
 115
 116         /* Ignore null or empty strings. */
 117         if (!s || (s[0] == '\0'))
 118                 return false;
 119
 120         if (cfront) {
 121                 while (*fp && *fp == cfront)
 122                         fp++;
 123                 if (!*fp) {
 124                         /* We ate the string. */
 125                         s[0] = '\0';
 126                         return true;
 127                 }
 128                 if (fp != s)
 129                         ret = true;
 130         }
 131
 132         ep = fp + strlen(fp) - 1;
 133         if (cback) {
 134                 /* Attempt ascii only. Bail for mb strings. */
 135                 while ((ep >= fp) && (*ep == cback)) {
 136                         ret = true;
 137                         if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
 138                                 /* Could be mb... bail back to tim_string. */
 139                                 char fs[2], bs[2];
 140                                 if (cfront) {
 141                                         fs[0] = cfront;
 142                                         fs[1] = '\0';
 143                                 }
 144                                 bs[0] = cback;
 145                                 bs[1] = '\0';
 146                                 return trim_string(s, cfront ? fs : NULL, bs);
 147                         } else {
 148                                 ep--;
 149                         }
 150                 }
 151                 if (ep < fp) {
 152                         /* We ate the string. */
 153                         s[0] = '\0';
 154                         return true;
 155                 }
 156         }
 157
 158         ep[1] = '\0';
 159         memmove(s, fp, ep-fp+2);
 160         return ret;
 161 }
 162
 163 /**
 164  Check if a string is part of a list.
 165 **/
 166
 167 bool in_list(const char *s, const char *list, bool casesensitive)
 168 {
 169         char *tok = NULL;
 170         bool ret = false;
 171         TALLOC_CTX *frame;
 172
 173         if (!list) {
 174                 return false;
 175         }
 176
 177         frame = talloc_stackframe();
 178         while (next_token_talloc(frame, &list, &tok,LIST_SEP)) {
 179                 if (casesensitive) {
 180                         if (strcmp(tok,s) == 0) {
 181                                 ret = true;
 182                                 break;
 183                         }
 184                 } else {
 185                         if (strcasecmp_m(tok,s) == 0) {
 186                                 ret = true;
 187                                 break;
 188                         }
 189                 }
 190         }
 191         TALLOC_FREE(frame);
 192         return ret;
 193 }
 194
 195 /*
 196  * Internal guts of talloc_string_sub and talloc_all_string_sub.
 197  * talloc version of string_sub2.
 198  */
 199
 200 char *talloc_string_sub2(TALLOC_CTX *mem_ctx, const char *src,
 201                         const char *pattern,
 202                         const char *insert,
 203                         bool remove_unsafe_characters,
 204                         bool replace_once,
 205                         bool allow_trailing_dollar)
 206 {
 207         char *p, *in;
 208         char *s;
 209         char *string;
 210         ssize_t ls,lp,li,ld, i;
 211
 212         if (!insert || !pattern || !*pattern || !src) {
 213                 return NULL;
 214         }
 215
 216         string = talloc_strdup(mem_ctx, src);
 217         if (string == NULL) {
 218                 DEBUG(0, ("talloc_string_sub2: "
 219                         "talloc_strdup failed\n"));
 220                 return NULL;
 221         }
 222
 223         s = string;
 224
 225         in = talloc_strdup(mem_ctx, insert);
 226         if (!in) {
 227                 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
 228                 return NULL;
 229         }
 230         ls = (ssize_t)strlen(s);
 231         lp = (ssize_t)strlen(pattern);
 232         li = (ssize_t)strlen(insert);
 233         ld = li - lp;
 234
 235         for (i=0;i<li;i++) {
 236                 switch (in[i]) {
 237                         case '$':
 238                                 /* allow a trailing $
 239                                  * (as in machine accounts) */
 240                                 if (allow_trailing_dollar && (i == li - 1 )) {
 241                                         break;
 242                                 }
 243
 244                                 FALL_THROUGH;
 245                         case '`':
 246                         case '"':
 247                         case '\'':
 248                         case ';':
 249                         case '%':
 250                         case '\r':
 251                         case '\n':
 252                                 if (remove_unsafe_characters) {
 253                                         in[i] = '_';
 254                                         break;
 255                                 }
 256
 257                                 FALL_THROUGH;
 258                         default:
 259                                 /* ok */
 260                                 break;
 261                 }
 262         }
 263
 264         while ((p = strstr_m(s,pattern))) {
 265                 if (ld > 0) {
 266                         int offset = PTR_DIFF(s,string);
 267                         string = (char *)TALLOC_REALLOC(mem_ctx, string,
 268                                                         ls + ld + 1);
 269                         if (!string) {
 270                                 DEBUG(0, ("talloc_string_sub: out of "
 271                                           "memory!\n"));
 272                                 TALLOC_FREE(in);
 273                                 return NULL;
 274                         }
 275                         p = string + offset + (p - s);
 276                 }
 277                 if (li != lp) {
 278                         memmove(p+li,p+lp,strlen(p+lp)+1);
 279                 }
 280                 memcpy(p, in, li);
 281                 s = p + li;
 282                 ls += ld;
 283
 284                 if (replace_once) {
 285                         break;
 286                 }
 287         }
 288         TALLOC_FREE(in);
 289         return string;
 290 }
 291
 292 /* Same as string_sub, but returns a talloc'ed string */
 293
 294 char *talloc_string_sub(TALLOC_CTX *mem_ctx,
 295                         const char *src,
 296                         const char *pattern,
 297                         const char *insert)
 298 {
 299         return talloc_string_sub2(mem_ctx, src, pattern, insert,
 300                         true, false, false);
 301 }
 302
 303 char *talloc_all_string_sub(TALLOC_CTX *ctx,
 304                                 const char *src,
 305                                 const char *pattern,
 306                                 const char *insert)
 307 {
 308         return talloc_string_sub2(ctx, src, pattern, insert,
 309                         false, false, false);
 310 }
 311
 312 /**
 313  Write an octal as a string.
 314 **/
 315
 316 char *octal_string(int i)
 317 {
 318         char *result;
 319         if (i == -1) {
 320                 result = talloc_strdup(talloc_tos(), "-1");
 321         }
 322         else {
 323                 result = talloc_asprintf(talloc_tos(), "0%o", i);
 324         }
 325         SMB_ASSERT(result != NULL);
 326         return result;
 327 }
 328
 329
 330 /**
 331  Truncate a string at a specified length.
 332 **/
 333
 334 char *string_truncate(char *s, unsigned int length)
 335 {
 336         if (s && strlen(s) > length)
 337                 s[length] = 0;
 338         return s;
 339 }
 340
 341
 342 /***********************************************************************
 343  Return the equivalent of doing strrchr 'n' times - always going
 344  backwards.
 345 ***********************************************************************/
 346
 347 char *strnrchr_m(const char *s, char c, unsigned int n)
 348 {
 349         smb_ucs2_t *ws = NULL;
 350         char *s2 = NULL;
 351         smb_ucs2_t *p;
 352         char *ret;
 353         size_t converted_size;
 354
 355         if (!push_ucs2_talloc(talloc_tos(), &ws, s, &converted_size)) {
 356                 /* Too hard to try and get right. */
 357                 return NULL;
 358         }
 359         p = strnrchr_w(ws, UCS2_CHAR(c), n);
 360         if (!p) {
 361                 TALLOC_FREE(ws);
 362                 return NULL;
 363         }
 364         *p = 0;
 365         if (!pull_ucs2_talloc(talloc_tos(), &s2, ws, &converted_size)) {
 366                 TALLOC_FREE(ws);
 367                 /* Too hard to try and get right. */
 368                 return NULL;
 369         }
 370         ret = discard_const_p(char, (s+strlen(s2)));
 371         TALLOC_FREE(ws);
 372         TALLOC_FREE(s2);
 373         return ret;
 374 }
 375
 376 static bool unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
 377 {
 378         size_t size;
 379         smb_ucs2_t *buffer = NULL;
 380         bool ret;
 381
 382         if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF16LE, src, srclen,
 383                                    (void **)(void *)&buffer, &size))
 384         {
 385                 return false;
 386         }
 387         if (!strlower_w(buffer) && (dest == src)) {
 388                 TALLOC_FREE(buffer);
 389                 return true;
 390         }
 391         ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
 392         TALLOC_FREE(buffer);
 393         return ret;
 394 }
 395
 396 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
 397
 398 /**
 399  Convert a string to lower case.
 400 **/
 401 _PUBLIC_ void strlower_m(char *s)
 402 {
 403         char *d;
 404         struct smb_iconv_handle *iconv_handle;
 405
 406         iconv_handle = get_iconv_handle();
 407
 408         d = s;
 409
 410         while (*s) {
 411                 size_t c_size, c_size2;
 412                 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
 413                 c_size2 = push_codepoint_handle(iconv_handle, d, tolower_m(c));
 414                 if (c_size2 > c_size) {
 415                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
 416                                  c, tolower_m(c), (int)c_size, (int)c_size2));
 417                         smb_panic("codepoint expansion in strlower_m\n");
 418                 }
 419                 s += c_size;
 420                 d += c_size2;
 421         }
 422         *d = 0;
 423 }
 424
 425 #endif
 426
 427 /**
 428  Convert a string to lower case.
 429 **/
 430
 431 bool strlower_m(char *s)
 432 {
 433         size_t len;
 434         int errno_save;
 435         bool ret = false;
 436
 437         /* this is quite a common operation, so we want it to be
 438            fast. We optimise for the ascii case, knowing that all our
 439            supported multi-byte character sets are ascii-compatible
 440            (ie. they match for the first 128 chars) */
 441
 442         while (*s && !(((unsigned char)s[0]) & 0x80)) {
 443                 *s = tolower_m((unsigned char)*s);
 444                 s++;
 445         }
 446
 447         if (!*s)
 448                 return true;
 449
 450         /* I assume that lowercased string takes the same number of bytes
 451          * as source string even in UTF-8 encoding. (VIV) */
 452         len = strlen(s) + 1;
 453         errno_save = errno;
 454         errno = 0;
 455         ret = unix_strlower(s,len,s,len);
 456         /* Catch mb conversion errors that may not terminate. */
 457         if (errno) {
 458                 s[len-1] = '\0';
 459         }
 460         errno = errno_save;
 461         return ret;
 462 }
 463
 464 static bool unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
 465 {
 466         size_t size;
 467         smb_ucs2_t *buffer;
 468         bool ret;
 469
 470         if (!push_ucs2_talloc(talloc_tos(), &buffer, src, &size)) {
 471                 return false;
 472         }
 473
 474         if (!strupper_w(buffer) && (dest == src)) {
 475                 TALLOC_FREE(buffer);
 476                 return true;
 477         }
 478
 479         ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
 480         TALLOC_FREE(buffer);
 481         return ret;
 482 }
 483
 484 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
 485
 486 /**
 487  Convert a string to UPPER case.
 488 **/
 489 _PUBLIC_ void strupper_m(char *s)
 490 {
 491         char *d;
 492         struct smb_iconv_handle *iconv_handle;
 493
 494         iconv_handle = get_iconv_handle();
 495
 496         d = s;
 497
 498         while (*s) {
 499                 size_t c_size, c_size2;
 500                 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
 501                 c_size2 = push_codepoint_handle(iconv_handle, d, toupper_m(c));
 502                 if (c_size2 > c_size) {
 503                         DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
 504                                  c, toupper_m(c), (int)c_size, (int)c_size2));
 505                         smb_panic("codepoint expansion in strupper_m\n");
 506                 }
 507                 s += c_size;
 508                 d += c_size2;
 509         }
 510         *d = 0;
 511 }
 512
 513 #endif
 514
 515 /**
 516  Convert a string to upper case.
 517 **/
 518
 519 bool strupper_m(char *s)
 520 {
 521         size_t len;
 522         bool ret = false;
 523
 524         /* this is quite a common operation, so we want it to be
 525            fast. We optimise for the ascii case, knowing that all our
 526            supported multi-byte character sets are ascii-compatible
 527            (ie. they match for the first 128 chars) */
 528
 529         while (*s && !(((unsigned char)s[0]) & 0x80)) {
 530                 *s = toupper_ascii_fast_table[(unsigned char)s[0]];
 531                 s++;
 532         }
 533
 534         if (!*s)
 535                 return true;
 536
 537         /* I assume that uppercased string takes the same number of bytes
 538          * as source string even in multibyte encoding. (VIV) */
 539         len = strlen(s) + 1;
 540         ret = unix_strupper(s,len,s,len);
 541         /* Catch mb conversion errors that may not terminate. */
 542         if (!ret) {
 543                 s[len-1] = '\0';
 544         }
 545         return ret;
 546 }
 547
 548 /**
 549  Just a typesafety wrapper for snprintf into a fstring.
 550 **/
 551
 552 int fstr_sprintf(fstring s, const char *fmt, ...)
 553 {
 554         va_list ap;
 555         int ret;
 556
 557         va_start(ap, fmt);
 558         ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
 559         va_end(ap);
 560         return ret;
 561 }
 562
 563 #define IPSTR_LIST_SEP  ","
 564 #define IPSTR_LIST_CHAR ','
 565
 566 /**
 567  * Add ip string representation to ipstr list. Used also
 568  * as part of @function ipstr_list_make
 569  *
 570  * @param ipstr_list pointer to string containing ip list;
 571  *        MUST BE already allocated and IS reallocated if necessary
 572  * @param ipstr_size pointer to current size of ipstr_list (might be changed
 573  *        as a result of reallocation)
 574  * @param ip IP address which is to be added to list
 575  * @return pointer to string appended with new ip and possibly
 576  *         reallocated to new length
 577  **/
 578
 579 static char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
 580 {
 581         char *new_ipstr = NULL;
 582         char addr_buf[INET6_ADDRSTRLEN];
 583         int ret;
 584
 585         /* arguments checking */
 586         if (!ipstr_list || !service) {
 587                 return NULL;
 588         }
 589
 590         print_sockaddr(addr_buf,
 591                         sizeof(addr_buf),
 592                         &service->ss);
 593
 594         /* attempt to convert ip to a string and append colon separator to it */
 595         if (*ipstr_list) {
 596                 if (service->ss.ss_family == AF_INET) {
 597                         /* IPv4 */
 598                         ret = asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list,
 599                                        IPSTR_LIST_SEP, addr_buf,
 600                                        service->port);
 601                 } else {
 602                         /* IPv6 */
 603                         ret = asprintf(&new_ipstr, "%s%s[%s]:%d", *ipstr_list,
 604                                        IPSTR_LIST_SEP, addr_buf,
 605                                        service->port);
 606                 }
 607                 SAFE_FREE(*ipstr_list);
 608         } else {
 609                 if (service->ss.ss_family == AF_INET) {
 610                         /* IPv4 */
 611                         ret = asprintf(&new_ipstr, "%s:%d", addr_buf,
 612                                        service->port);
 613                 } else {
 614                         /* IPv6 */
 615                         ret = asprintf(&new_ipstr, "[%s]:%d", addr_buf,
 616                                        service->port);
 617                 }
 618         }
 619         if (ret == -1) {
 620                 return NULL;
 621         }
 622         *ipstr_list = new_ipstr;
 623         return *ipstr_list;
 624 }
 625
 626 /**
 627  * Allocate and initialise an ipstr list using ip adresses
 628  * passed as arguments.
 629  *
 630  * @param ipstr_list pointer to string meant to be allocated and set
 631  * @param ip_list array of ip addresses to place in the list
 632  * @param ip_count number of addresses stored in ip_list
 633  * @return pointer to allocated ip string
 634  **/
 635
 636 char *ipstr_list_make(char **ipstr_list,
 637                         const struct ip_service *ip_list,
 638                         int ip_count)
 639 {
 640         int i;
 641
 642         /* arguments checking */
 643         if (!ip_list || !ipstr_list) {
 644                 return 0;
 645         }
 646
 647         *ipstr_list = NULL;
 648
 649         /* process ip addresses given as arguments */
 650         for (i = 0; i < ip_count; i++) {
 651                 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
 652         }
 653
 654         return (*ipstr_list);
 655 }
 656
 657
 658 /**
 659  * Parse given ip string list into array of ip addresses
 660  * (as ip_service structures)
 661  *    e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
 662  *
 663  * @param ipstr ip string list to be parsed
 664  * @param ip_list pointer to array of ip addresses which is
 665  *        allocated by this function and must be freed by caller
 666  * @return number of successfully parsed addresses
 667  **/
 668
 669 int ipstr_list_parse(const char *ipstr_list, struct ip_service **ip_list)
 670 {
 671         TALLOC_CTX *frame;
 672         char *token_str = NULL;
 673         size_t i, count;
 674
 675         if (!ipstr_list || !ip_list)
 676                 return 0;
 677
 678         count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
 679         if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
 680                 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
 681                                         (unsigned long)count));
 682                 return 0;
 683         }
 684
 685         frame = talloc_stackframe();
 686         for ( i=0; next_token_talloc(frame, &ipstr_list, &token_str,
 687                                 IPSTR_LIST_SEP) && i<count; i++ ) {
 688                 char *s = token_str;
 689                 char *p = strrchr(token_str, ':');
 690
 691                 if (p) {
 692                         *p = 0;
 693                         (*ip_list)[i].port = atoi(p+1);
 694                 }
 695
 696                 /* convert single token to ip address */
 697                 if (token_str[0] == '[') {
 698                         /* IPv6 address. */
 699                         s++;
 700                         p = strchr(token_str, ']');
 701                         if (!p) {
 702                                 continue;
 703                         }
 704                         *p = '\0';
 705                 }
 706                 if (!interpret_string_addr(&(*ip_list)[i].ss,
 707                                         s,
 708                                         AI_NUMERICHOST)) {
 709                         continue;
 710                 }
 711         }
 712         TALLOC_FREE(frame);
 713         return count;
 714 }
 715
 716 /**
 717  * Safely free ip string list
 718  *
 719  * @param ipstr_list ip string list to be freed
 720  **/
 721
 722 void ipstr_list_free(char* ipstr_list)
 723 {
 724         SAFE_FREE(ipstr_list);
 725 }
 726
 727 /* read a SMB_BIG_UINT from a string */
 728 uint64_t STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
 729 {
 730
 731         uint64_t val = (uint64_t)-1;
 732         const char *p = nptr;
 733
 734         if (!p) {
 735                 if (entptr) {
 736                         *entptr = p;
 737                 }
 738                 return val;
 739         }
 740
 741         while (*p && isspace(*p))
 742                 p++;
 743
 744         sscanf(p,"%"SCNu64,&val);
 745         if (entptr) {
 746                 while (*p && isdigit(*p))
 747                         p++;
 748                 *entptr = p;
 749         }
 750
 751         return val;
 752 }
 753
 754 /* Convert a size specification to a count of bytes. We accept the following
 755  * suffixes:
 756  *          bytes if there is no suffix
 757  *      kK  kibibytes
 758  *      mM  mebibytes
 759  *      gG  gibibytes
 760  *      tT  tibibytes
 761  *      pP  whatever the ISO name for petabytes is
 762  *
 763  *  Returns 0 if the string can't be converted.
 764  */
 765 uint64_t conv_str_size(const char * str)
 766 {
 767         uint64_t lval;
 768         char *end;
 769         int error = 0;
 770
 771         if (str == NULL || *str == '\0') {
 772                 return 0;
 773         }
 774
 775         lval = smb_strtoull(str, &end, 10, &error, SMB_STR_STANDARD);
 776
 777         if (error != 0) {
 778                 return 0;
 779         }
 780
 781         if (*end == '\0') {
 782                 return lval;
 783         }
 784
 785         if (strwicmp(end, "K") == 0) {
 786                 lval *= 1024ULL;
 787         } else if (strwicmp(end, "M") == 0) {
 788                 lval *= (1024ULL * 1024ULL);
 789         } else if (strwicmp(end, "G") == 0) {
 790                 lval *= (1024ULL * 1024ULL *
 791                          1024ULL);
 792         } else if (strwicmp(end, "T") == 0) {
 793                 lval *= (1024ULL * 1024ULL *
 794                          1024ULL * 1024ULL);
 795         } else if (strwicmp(end, "P") == 0) {
 796                 lval *= (1024ULL * 1024ULL *
 797                          1024ULL * 1024ULL *
 798                          1024ULL);
 799         } else {
 800                 return 0;
 801         }
 802
 803         return lval;
 804 }
 805
 806 /*
 807  * asprintf into a string and strupper_m it after that.
 808  */
 809
 810 int asprintf_strupper_m(char **strp, const char *fmt, ...)
 811 {
 812         va_list ap;
 813         char *result;
 814         int ret;
 815
 816         va_start(ap, fmt);
 817         ret = vasprintf(&result, fmt, ap);
 818         va_end(ap);
 819
 820         if (ret == -1)
 821                 return -1;
 822
 823         if (!strupper_m(result)) {
 824                 SAFE_FREE(result);
 825                 return -1;
 826         }
 827
 828         *strp = result;
 829         return ret;
 830 }
 831
 832 char *talloc_asprintf_strupper_m(TALLOC_CTX *t, const char *fmt, ...)
 833 {
 834         va_list ap;
 835         char *ret;
 836
 837         va_start(ap, fmt);
 838         ret = talloc_vasprintf(t, fmt, ap);
 839         va_end(ap);
 840
 841         if (ret == NULL) {
 842                 return NULL;
 843         }
 844         if (!strupper_m(ret)) {
 845                 TALLOC_FREE(ret);
 846                 return NULL;
 847         }
 848         return ret;
 849 }
 850
 851 char *talloc_asprintf_strlower_m(TALLOC_CTX *t, const char *fmt, ...)
 852 {
 853         va_list ap;
 854         char *ret;
 855
 856         va_start(ap, fmt);
 857         ret = talloc_vasprintf(t, fmt, ap);
 858         va_end(ap);
 859
 860         if (ret == NULL) {
 861                 return NULL;
 862         }
 863         if (!strlower_m(ret)) {
 864                 TALLOC_FREE(ret);
 865                 return NULL;
 866         }
 867         return ret;
 868 }
 869
 870
 871 /********************************************************************
 872  Check a string for any occurrences of a specified list of invalid
 873  characters.
 874 ********************************************************************/
 875
 876 bool validate_net_name( const char *name,
 877                 const char *invalid_chars,
 878                 int max_len)
 879 {
 880         int i;
 881
 882         if (!name) {
 883                 return false;
 884         }
 885
 886         for ( i=0; i<max_len && name[i]; i++ ) {
 887                 /* fail if strchr_m() finds one of the invalid characters */
 888                 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
 889                         return false;
 890                 }
 891         }
 892
 893         return true;
 894 }
 895
 896
 897 /*******************************************************************
 898  Add a shell escape character '\' to any character not in a known list
 899  of characters. UNIX charset format.
 900 *******************************************************************/
 901
 902 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
 903 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
 904
 905 char *escape_shell_string(const char *src)
 906 {
 907         size_t srclen = strlen(src);
 908         char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
 909         char *dest = ret;
 910         bool in_s_quote = false;
 911         bool in_d_quote = false;
 912         bool next_escaped = false;
 913
 914         if (!ret) {
 915                 return NULL;
 916         }
 917
 918         while (*src) {
 919                 size_t c_size;
 920                 codepoint_t c = next_codepoint(src, &c_size);
 921
 922                 if (c == INVALID_CODEPOINT) {
 923                         SAFE_FREE(ret);
 924                         return NULL;
 925                 }
 926
 927                 if (c_size > 1) {
 928                         memcpy(dest, src, c_size);
 929                         src += c_size;
 930                         dest += c_size;
 931                         next_escaped = false;
 932                         continue;
 933                 }
 934
 935                 /*
 936                  * Deal with backslash escaped state.
 937                  * This only lasts for one character.
 938                  */
 939
 940                 if (next_escaped) {
 941                         *dest++ = *src++;
 942                         next_escaped = false;
 943                         continue;
 944                 }
 945
 946                 /*
 947                  * Deal with single quote state. The
 948                  * only thing we care about is exiting
 949                  * this state.
 950                  */
 951
 952                 if (in_s_quote) {
 953                         if (*src == '\'') {
 954                                 in_s_quote = false;
 955                         }
 956                         *dest++ = *src++;
 957                         continue;
 958                 }
 959
 960                 /*
 961                  * Deal with double quote state. The most
 962                  * complex state. We must cope with \, meaning
 963                  * possibly escape next char (depending what it
 964                  * is), ", meaning exit this state, and possibly
 965                  * add an \ escape to any unprotected character
 966                  * (listed in INSIDE_DQUOTE_LIST).
 967                  */
 968
 969                 if (in_d_quote) {
 970                         if (*src == '\\') {
 971                                 /*
 972                                  * Next character might be escaped.
 973                                  * We have to peek. Inside double
 974                                  * quotes only INSIDE_DQUOTE_LIST
 975                                  * characters are escaped by a \.
 976                                  */
 977
 978                                 char nextchar;
 979
 980                                 c = next_codepoint(&src[1], &c_size);
 981                                 if (c == INVALID_CODEPOINT) {
 982                                         SAFE_FREE(ret);
 983                                         return NULL;
 984                                 }
 985                                 if (c_size > 1) {
 986                                         /*
 987                                          * Don't escape the next char.
 988                                          * Just copy the \.
 989                                          */
 990                                         *dest++ = *src++;
 991                                         continue;
 992                                 }
 993
 994                                 nextchar = src[1];
 995
 996                                 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
 997                                                         (int)nextchar)) {
 998                                         next_escaped = true;
 999                                 }
1000                                 *dest++ = *src++;
1001                                 continue;
1002                         }
1003
1004                         if (*src == '\"') {
1005                                 /* Exit double quote state. */
1006                                 in_d_quote = false;
1007                                 *dest++ = *src++;
1008                                 continue;
1009                         }
1010
1011                         /*
1012                          * We know the character isn't \ or ",
1013                          * so escape it if it's any of the other
1014                          * possible unprotected characters.
1015                          */
1016
1017                         if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
1018                                 *dest++ = '\\';
1019                         }
1020                         *dest++ = *src++;
1021                         continue;
1022                 }
1023
1024                 /*
1025                  * From here to the end of the loop we're
1026                  * not in the single or double quote state.
1027                  */
1028
1029                 if (*src == '\\') {
1030                         /* Next character must be escaped. */
1031                         next_escaped = true;
1032                         *dest++ = *src++;
1033                         continue;
1034                 }
1035
1036                 if (*src == '\'') {
1037                         /* Go into single quote state. */
1038                         in_s_quote = true;
1039                         *dest++ = *src++;
1040                         continue;
1041                 }
1042
1043                 if (*src == '\"') {
1044                         /* Go into double quote state. */
1045                         in_d_quote = true;
1046                         *dest++ = *src++;
1047                         continue;
1048                 }
1049
1050                 /* Check if we need to escape the character. */
1051
1052                 if (!strchr(INCLUDE_LIST, (int)*src)) {
1053                         *dest++ = '\\';
1054                 }
1055                 *dest++ = *src++;
1056         }
1057         *dest++ = '\0';
1058         return ret;
1059 }
1060
1061 /*
1062  * This routine improves performance for operations temporarily acting on a
1063  * full path. It is equivalent to the much more expensive
1064  *
1065  * talloc_asprintf(talloc_tos(), "%s/%s", dir, name)
1066  *
1067  * This actually does make a difference in metadata-heavy workloads (i.e. the
1068  * "standard" client.txt nbench run.
1069  */
1070
1071 ssize_t full_path_tos(const char *dir, const char *name,
1072                       char *tmpbuf, size_t tmpbuf_len,
1073                       char **pdst, char **to_free)
1074 {
1075         size_t dirlen, namelen, len;
1076         char *dst;
1077
1078         dirlen = strlen(dir);
1079         namelen = strlen(name);
1080         len = dirlen + namelen + 1;
1081
1082         if (len < tmpbuf_len) {
1083                 dst = tmpbuf;
1084                 *to_free = NULL;
1085         } else {
1086                 dst = talloc_array(talloc_tos(), char, len+1);
1087                 if (dst == NULL) {
1088                         return -1;
1089                 }
1090                 *to_free = dst;
1091         }
1092
1093         memcpy(dst, dir, dirlen);
1094         dst[dirlen] = '/';
1095         memcpy(dst+dirlen+1, name, namelen+1);
1096         *pdst = dst;
1097         return len;
1098 }