source: vendor/current/source3/lib/util_str.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 25.6 KB
Line 
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
28static 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 **/
44bool 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
58bool 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
70char *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
82char *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
108size_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
120bool 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**/
177char *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
203bool 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
236char *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
326char *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
335char *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
348char *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
366char *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
379char *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
408static 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 return false;
418 }
419 if (!strlower_w(buffer) && (dest == src)) {
420 TALLOC_FREE(buffer);
421 return true;
422 }
423 ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
424 TALLOC_FREE(buffer);
425 return ret;
426}
427
428#if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
429
430/**
431 Convert a string to lower case.
432**/
433_PUBLIC_ void strlower_m(char *s)
434{
435 char *d;
436 struct smb_iconv_handle *iconv_handle;
437
438 iconv_handle = get_iconv_handle();
439
440 d = s;
441
442 while (*s) {
443 size_t c_size, c_size2;
444 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
445 c_size2 = push_codepoint_handle(iconv_handle, d, tolower_m(c));
446 if (c_size2 > c_size) {
447 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
448 c, tolower_m(c), (int)c_size, (int)c_size2));
449 smb_panic("codepoint expansion in strlower_m\n");
450 }
451 s += c_size;
452 d += c_size2;
453 }
454 *d = 0;
455}
456
457#endif
458
459/**
460 Convert a string to lower case.
461**/
462
463bool strlower_m(char *s)
464{
465 size_t len;
466 int errno_save;
467 bool ret = false;
468
469 /* this is quite a common operation, so we want it to be
470 fast. We optimise for the ascii case, knowing that all our
471 supported multi-byte character sets are ascii-compatible
472 (ie. they match for the first 128 chars) */
473
474 while (*s && !(((unsigned char)s[0]) & 0x80)) {
475 *s = tolower_m((unsigned char)*s);
476 s++;
477 }
478
479 if (!*s)
480 return true;
481
482 /* I assume that lowercased string takes the same number of bytes
483 * as source string even in UTF-8 encoding. (VIV) */
484 len = strlen(s) + 1;
485 errno_save = errno;
486 errno = 0;
487 ret = unix_strlower(s,len,s,len);
488 /* Catch mb conversion errors that may not terminate. */
489 if (errno) {
490 s[len-1] = '\0';
491 }
492 errno = errno_save;
493 return ret;
494}
495
496static bool unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
497{
498 size_t size;
499 smb_ucs2_t *buffer;
500 bool ret;
501
502 if (!push_ucs2_talloc(talloc_tos(), &buffer, src, &size)) {
503 return false;
504 }
505
506 if (!strupper_w(buffer) && (dest == src)) {
507 TALLOC_FREE(buffer);
508 return true;
509 }
510
511 ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
512 TALLOC_FREE(buffer);
513 return ret;
514}
515
516#if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
517
518/**
519 Convert a string to UPPER case.
520**/
521_PUBLIC_ void strupper_m(char *s)
522{
523 char *d;
524 struct smb_iconv_handle *iconv_handle;
525
526 iconv_handle = get_iconv_handle();
527
528 d = s;
529
530 while (*s) {
531 size_t c_size, c_size2;
532 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
533 c_size2 = push_codepoint_handle(iconv_handle, d, toupper_m(c));
534 if (c_size2 > c_size) {
535 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
536 c, toupper_m(c), (int)c_size, (int)c_size2));
537 smb_panic("codepoint expansion in strupper_m\n");
538 }
539 s += c_size;
540 d += c_size2;
541 }
542 *d = 0;
543}
544
545#endif
546
547/**
548 Convert a string to upper case.
549**/
550
551bool strupper_m(char *s)
552{
553 size_t len;
554 bool ret = false;
555
556 /* this is quite a common operation, so we want it to be
557 fast. We optimise for the ascii case, knowing that all our
558 supported multi-byte character sets are ascii-compatible
559 (ie. they match for the first 128 chars) */
560
561 while (*s && !(((unsigned char)s[0]) & 0x80)) {
562 *s = toupper_ascii_fast_table[(unsigned char)s[0]];
563 s++;
564 }
565
566 if (!*s)
567 return true;
568
569 /* I assume that uppercased string takes the same number of bytes
570 * as source string even in multibyte encoding. (VIV) */
571 len = strlen(s) + 1;
572 ret = unix_strupper(s,len,s,len);
573 /* Catch mb conversion errors that may not terminate. */
574 if (!ret) {
575 s[len-1] = '\0';
576 }
577 return ret;
578}
579
580/**
581 Just a typesafety wrapper for snprintf into a fstring.
582**/
583
584int fstr_sprintf(fstring s, const char *fmt, ...)
585{
586 va_list ap;
587 int ret;
588
589 va_start(ap, fmt);
590 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
591 va_end(ap);
592 return ret;
593}
594
595/**
596 List of Strings manipulation functions
597**/
598
599#define S_LIST_ABS 16 /* List Allocation Block Size */
600
601/******************************************************************************
602 substitute a specific pattern in a string list
603 *****************************************************************************/
604
605bool str_list_substitute(char **list, const char *pattern, const char *insert)
606{
607 TALLOC_CTX *ctx = list;
608 char *p, *s, *t;
609 ssize_t ls, lp, li, ld, i, d;
610
611 if (!list)
612 return false;
613 if (!pattern)
614 return false;
615 if (!insert)
616 return false;
617
618 lp = (ssize_t)strlen(pattern);
619 li = (ssize_t)strlen(insert);
620 ld = li -lp;
621
622 while (*list) {
623 s = *list;
624 ls = (ssize_t)strlen(s);
625
626 while ((p = strstr_m(s, pattern))) {
627 t = *list;
628 d = p -t;
629 if (ld) {
630 t = talloc_array(ctx, char, ls +ld +1);
631 if (!t) {
632 DEBUG(0,("str_list_substitute: "
633 "Unable to allocate memory"));
634 return false;
635 }
636 memcpy(t, *list, d);
637 memcpy(t +d +li, p +lp, ls -d -lp +1);
638 TALLOC_FREE(*list);
639 *list = t;
640 ls += ld;
641 s = t +d +li;
642 }
643
644 for (i = 0; i < li; i++) {
645 switch (insert[i]) {
646 case '`':
647 case '"':
648 case '\'':
649 case ';':
650 case '$':
651 case '%':
652 case '\r':
653 case '\n':
654 t[d +i] = '_';
655 break;
656 default:
657 t[d +i] = insert[i];
658 }
659 }
660 }
661
662 list++;
663 }
664
665 return true;
666}
667
668
669#define IPSTR_LIST_SEP ","
670#define IPSTR_LIST_CHAR ','
671
672/**
673 * Add ip string representation to ipstr list. Used also
674 * as part of @function ipstr_list_make
675 *
676 * @param ipstr_list pointer to string containing ip list;
677 * MUST BE already allocated and IS reallocated if necessary
678 * @param ipstr_size pointer to current size of ipstr_list (might be changed
679 * as a result of reallocation)
680 * @param ip IP address which is to be added to list
681 * @return pointer to string appended with new ip and possibly
682 * reallocated to new length
683 **/
684
685static char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
686{
687 char *new_ipstr = NULL;
688 char addr_buf[INET6_ADDRSTRLEN];
689 int ret;
690
691 /* arguments checking */
692 if (!ipstr_list || !service) {
693 return NULL;
694 }
695
696 print_sockaddr(addr_buf,
697 sizeof(addr_buf),
698 &service->ss);
699
700 /* attempt to convert ip to a string and append colon separator to it */
701 if (*ipstr_list) {
702 if (service->ss.ss_family == AF_INET) {
703 /* IPv4 */
704 ret = asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list,
705 IPSTR_LIST_SEP, addr_buf,
706 service->port);
707 } else {
708 /* IPv6 */
709 ret = asprintf(&new_ipstr, "%s%s[%s]:%d", *ipstr_list,
710 IPSTR_LIST_SEP, addr_buf,
711 service->port);
712 }
713 SAFE_FREE(*ipstr_list);
714 } else {
715 if (service->ss.ss_family == AF_INET) {
716 /* IPv4 */
717 ret = asprintf(&new_ipstr, "%s:%d", addr_buf,
718 service->port);
719 } else {
720 /* IPv6 */
721 ret = asprintf(&new_ipstr, "[%s]:%d", addr_buf,
722 service->port);
723 }
724 }
725 if (ret == -1) {
726 return NULL;
727 }
728 *ipstr_list = new_ipstr;
729 return *ipstr_list;
730}
731
732/**
733 * Allocate and initialise an ipstr list using ip adresses
734 * passed as arguments.
735 *
736 * @param ipstr_list pointer to string meant to be allocated and set
737 * @param ip_list array of ip addresses to place in the list
738 * @param ip_count number of addresses stored in ip_list
739 * @return pointer to allocated ip string
740 **/
741
742char *ipstr_list_make(char **ipstr_list,
743 const struct ip_service *ip_list,
744 int ip_count)
745{
746 int i;
747
748 /* arguments checking */
749 if (!ip_list || !ipstr_list) {
750 return 0;
751 }
752
753 *ipstr_list = NULL;
754
755 /* process ip addresses given as arguments */
756 for (i = 0; i < ip_count; i++) {
757 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
758 }
759
760 return (*ipstr_list);
761}
762
763
764/**
765 * Parse given ip string list into array of ip addresses
766 * (as ip_service structures)
767 * e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
768 *
769 * @param ipstr ip string list to be parsed
770 * @param ip_list pointer to array of ip addresses which is
771 * allocated by this function and must be freed by caller
772 * @return number of successfully parsed addresses
773 **/
774
775int ipstr_list_parse(const char *ipstr_list, struct ip_service **ip_list)
776{
777 TALLOC_CTX *frame;
778 char *token_str = NULL;
779 size_t count;
780 int i;
781
782 if (!ipstr_list || !ip_list)
783 return 0;
784
785 count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
786 if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
787 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
788 (unsigned long)count));
789 return 0;
790 }
791
792 frame = talloc_stackframe();
793 for ( i=0; next_token_talloc(frame, &ipstr_list, &token_str,
794 IPSTR_LIST_SEP) && i<count; i++ ) {
795 char *s = token_str;
796 char *p = strrchr(token_str, ':');
797
798 if (p) {
799 *p = 0;
800 (*ip_list)[i].port = atoi(p+1);
801 }
802
803 /* convert single token to ip address */
804 if (token_str[0] == '[') {
805 /* IPv6 address. */
806 s++;
807 p = strchr(token_str, ']');
808 if (!p) {
809 continue;
810 }
811 *p = '\0';
812 }
813 if (!interpret_string_addr(&(*ip_list)[i].ss,
814 s,
815 AI_NUMERICHOST)) {
816 continue;
817 }
818 }
819 TALLOC_FREE(frame);
820 return count;
821}
822
823/**
824 * Safely free ip string list
825 *
826 * @param ipstr_list ip string list to be freed
827 **/
828
829void ipstr_list_free(char* ipstr_list)
830{
831 SAFE_FREE(ipstr_list);
832}
833
834/* read a SMB_BIG_UINT from a string */
835uint64_t STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
836{
837
838 uint64_t val = (uint64_t)-1;
839 const char *p = nptr;
840
841 if (!p) {
842 if (entptr) {
843 *entptr = p;
844 }
845 return val;
846 }
847
848 while (*p && isspace(*p))
849 p++;
850
851 sscanf(p,"%"SCNu64,&val);
852 if (entptr) {
853 while (*p && isdigit(*p))
854 p++;
855 *entptr = p;
856 }
857
858 return val;
859}
860
861/* Convert a size specification to a count of bytes. We accept the following
862 * suffixes:
863 * bytes if there is no suffix
864 * kK kibibytes
865 * mM mebibytes
866 * gG gibibytes
867 * tT tibibytes
868 * pP whatever the ISO name for petabytes is
869 *
870 * Returns 0 if the string can't be converted.
871 */
872uint64_t conv_str_size(const char * str)
873{
874 uint64_t lval;
875 char * end;
876
877 if (str == NULL || *str == '\0') {
878 return 0;
879 }
880
881 lval = strtoull(str, &end, 10 /* base */);
882
883 if (end == NULL || end == str) {
884 return 0;
885 }
886
887 if (*end == '\0') {
888 return lval;
889 }
890
891 if (strwicmp(end, "K") == 0) {
892 lval *= 1024ULL;
893 } else if (strwicmp(end, "M") == 0) {
894 lval *= (1024ULL * 1024ULL);
895 } else if (strwicmp(end, "G") == 0) {
896 lval *= (1024ULL * 1024ULL *
897 1024ULL);
898 } else if (strwicmp(end, "T") == 0) {
899 lval *= (1024ULL * 1024ULL *
900 1024ULL * 1024ULL);
901 } else if (strwicmp(end, "P") == 0) {
902 lval *= (1024ULL * 1024ULL *
903 1024ULL * 1024ULL *
904 1024ULL);
905 } else {
906 return 0;
907 }
908
909 return lval;
910}
911
912/* Append an sprintf'ed string. Double buffer size on demand. Usable without
913 * error checking in between. The indication that something weird happened is
914 * string==NULL */
915
916void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
917 size_t *bufsize, const char *fmt, ...)
918{
919 va_list ap;
920 char *newstr;
921 int ret;
922 bool increased;
923
924 /* len<0 is an internal marker that something failed */
925 if (*len < 0)
926 goto error;
927
928 if (*string == NULL) {
929 if (*bufsize == 0)
930 *bufsize = 128;
931
932 *string = talloc_array(mem_ctx, char, *bufsize);
933 if (*string == NULL)
934 goto error;
935 }
936
937 va_start(ap, fmt);
938 ret = vasprintf(&newstr, fmt, ap);
939 va_end(ap);
940
941 if (ret < 0)
942 goto error;
943
944 increased = false;
945
946 while ((*len)+ret >= *bufsize) {
947 increased = true;
948 *bufsize *= 2;
949 if (*bufsize >= (1024*1024*256))
950 goto error;
951 }
952
953 if (increased) {
954 *string = talloc_realloc(mem_ctx, *string, char,
955 *bufsize);
956 if (*string == NULL) {
957 goto error;
958 }
959 }
960
961 StrnCpy((*string)+(*len), newstr, ret);
962 (*len) += ret;
963 free(newstr);
964 return;
965
966 error:
967 *len = -1;
968 *string = NULL;
969}
970
971/*
972 * asprintf into a string and strupper_m it after that.
973 */
974
975int asprintf_strupper_m(char **strp, const char *fmt, ...)
976{
977 va_list ap;
978 char *result;
979 int ret;
980
981 va_start(ap, fmt);
982 ret = vasprintf(&result, fmt, ap);
983 va_end(ap);
984
985 if (ret == -1)
986 return -1;
987
988 if (!strupper_m(result)) {
989 SAFE_FREE(result);
990 return -1;
991 }
992
993 *strp = result;
994 return ret;
995}
996
997char *talloc_asprintf_strupper_m(TALLOC_CTX *t, const char *fmt, ...)
998{
999 va_list ap;
1000 char *ret;
1001
1002 va_start(ap, fmt);
1003 ret = talloc_vasprintf(t, fmt, ap);
1004 va_end(ap);
1005
1006 if (ret == NULL) {
1007 return NULL;
1008 }
1009 if (!strupper_m(ret)) {
1010 TALLOC_FREE(ret);
1011 return NULL;
1012 }
1013 return ret;
1014}
1015
1016char *talloc_asprintf_strlower_m(TALLOC_CTX *t, const char *fmt, ...)
1017{
1018 va_list ap;
1019 char *ret;
1020
1021 va_start(ap, fmt);
1022 ret = talloc_vasprintf(t, fmt, ap);
1023 va_end(ap);
1024
1025 if (ret == NULL) {
1026 return NULL;
1027 }
1028 if (!strlower_m(ret)) {
1029 TALLOC_FREE(ret);
1030 return NULL;
1031 }
1032 return ret;
1033}
1034
1035
1036/********************************************************************
1037 Check a string for any occurrences of a specified list of invalid
1038 characters.
1039********************************************************************/
1040
1041bool validate_net_name( const char *name,
1042 const char *invalid_chars,
1043 int max_len)
1044{
1045 int i;
1046
1047 if (!name) {
1048 return false;
1049 }
1050
1051 for ( i=0; i<max_len && name[i]; i++ ) {
1052 /* fail if strchr_m() finds one of the invalid characters */
1053 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
1054 return false;
1055 }
1056 }
1057
1058 return true;
1059}
1060
1061
1062/*******************************************************************
1063 Add a shell escape character '\' to any character not in a known list
1064 of characters. UNIX charset format.
1065*******************************************************************/
1066
1067#define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
1068#define INSIDE_DQUOTE_LIST "$`\n\"\\"
1069
1070char *escape_shell_string(const char *src)
1071{
1072 size_t srclen = strlen(src);
1073 char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
1074 char *dest = ret;
1075 bool in_s_quote = false;
1076 bool in_d_quote = false;
1077 bool next_escaped = false;
1078
1079 if (!ret) {
1080 return NULL;
1081 }
1082
1083 while (*src) {
1084 size_t c_size;
1085 codepoint_t c = next_codepoint(src, &c_size);
1086
1087 if (c == INVALID_CODEPOINT) {
1088 SAFE_FREE(ret);
1089 return NULL;
1090 }
1091
1092 if (c_size > 1) {
1093 memcpy(dest, src, c_size);
1094 src += c_size;
1095 dest += c_size;
1096 next_escaped = false;
1097 continue;
1098 }
1099
1100 /*
1101 * Deal with backslash escaped state.
1102 * This only lasts for one character.
1103 */
1104
1105 if (next_escaped) {
1106 *dest++ = *src++;
1107 next_escaped = false;
1108 continue;
1109 }
1110
1111 /*
1112 * Deal with single quote state. The
1113 * only thing we care about is exiting
1114 * this state.
1115 */
1116
1117 if (in_s_quote) {
1118 if (*src == '\'') {
1119 in_s_quote = false;
1120 }
1121 *dest++ = *src++;
1122 continue;
1123 }
1124
1125 /*
1126 * Deal with double quote state. The most
1127 * complex state. We must cope with \, meaning
1128 * possibly escape next char (depending what it
1129 * is), ", meaning exit this state, and possibly
1130 * add an \ escape to any unprotected character
1131 * (listed in INSIDE_DQUOTE_LIST).
1132 */
1133
1134 if (in_d_quote) {
1135 if (*src == '\\') {
1136 /*
1137 * Next character might be escaped.
1138 * We have to peek. Inside double
1139 * quotes only INSIDE_DQUOTE_LIST
1140 * characters are escaped by a \.
1141 */
1142
1143 char nextchar;
1144
1145 c = next_codepoint(&src[1], &c_size);
1146 if (c == INVALID_CODEPOINT) {
1147 SAFE_FREE(ret);
1148 return NULL;
1149 }
1150 if (c_size > 1) {
1151 /*
1152 * Don't escape the next char.
1153 * Just copy the \.
1154 */
1155 *dest++ = *src++;
1156 continue;
1157 }
1158
1159 nextchar = src[1];
1160
1161 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
1162 (int)nextchar)) {
1163 next_escaped = true;
1164 }
1165 *dest++ = *src++;
1166 continue;
1167 }
1168
1169 if (*src == '\"') {
1170 /* Exit double quote state. */
1171 in_d_quote = false;
1172 *dest++ = *src++;
1173 continue;
1174 }
1175
1176 /*
1177 * We know the character isn't \ or ",
1178 * so escape it if it's any of the other
1179 * possible unprotected characters.
1180 */
1181
1182 if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
1183 *dest++ = '\\';
1184 }
1185 *dest++ = *src++;
1186 continue;
1187 }
1188
1189 /*
1190 * From here to the end of the loop we're
1191 * not in the single or double quote state.
1192 */
1193
1194 if (*src == '\\') {
1195 /* Next character must be escaped. */
1196 next_escaped = true;
1197 *dest++ = *src++;
1198 continue;
1199 }
1200
1201 if (*src == '\'') {
1202 /* Go into single quote state. */
1203 in_s_quote = true;
1204 *dest++ = *src++;
1205 continue;
1206 }
1207
1208 if (*src == '\"') {
1209 /* Go into double quote state. */
1210 in_d_quote = true;
1211 *dest++ = *src++;
1212 continue;
1213 }
1214
1215 /* Check if we need to escape the character. */
1216
1217 if (!strchr(INCLUDE_LIST, (int)*src)) {
1218 *dest++ = '\\';
1219 }
1220 *dest++ = *src++;
1221 }
1222 *dest++ = '\0';
1223 return ret;
1224}
1225
1226/*
1227 * This routine improves performance for operations temporarily acting on a
1228 * full path. It is equivalent to the much more expensive
1229 *
1230 * talloc_asprintf(talloc_tos(), "%s/%s", dir, name)
1231 *
1232 * This actually does make a difference in metadata-heavy workloads (i.e. the
1233 * "standard" client.txt nbench run.
1234 */
1235
1236ssize_t full_path_tos(const char *dir, const char *name,
1237 char *tmpbuf, size_t tmpbuf_len,
1238 char **pdst, char **to_free)
1239{
1240 size_t dirlen, namelen, len;
1241 char *dst;
1242
1243 dirlen = strlen(dir);
1244 namelen = strlen(name);
1245 len = dirlen + namelen + 1;
1246
1247 if (len < tmpbuf_len) {
1248 dst = tmpbuf;
1249 *to_free = NULL;
1250 } else {
1251 dst = talloc_array(talloc_tos(), char, len+1);
1252 if (dst == NULL) {
1253 return -1;
1254 }
1255 *to_free = dst;
1256 }
1257
1258 memcpy(dst, dir, dirlen);
1259 dst[dirlen] = '/';
1260 memcpy(dst+dirlen+1, name, namelen+1);
1261 *pdst = dst;
1262 return len;
1263}
Note: See TracBrowser for help on using the repository browser.