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