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