2 Unix SMB/CIFS implementation.
3 Samba utility functions
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
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.
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.
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/>.
27 const char toupper_ascii_fast_table
[128] = {
28 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
29 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
30 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
31 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
32 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
33 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
34 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
35 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
39 * Case insensitive string compararison.
41 * iconv does not directly give us a way to compare strings in
42 * arbitrary unix character sets -- all we can is convert and then
43 * compare. This is expensive.
45 * As an optimization, we do a first pass that considers only the
46 * prefix of the strings that is entirely 7-bit. Within this, we
47 * check whether they have the same value.
49 * Hopefully this will often give the answer without needing to copy.
50 * In particular it should speed comparisons to literal ascii strings
51 * or comparisons of strings that are "obviously" different.
53 * If we find a non-ascii character we fall back to converting via
56 * This should never be slower than convering the whole thing, and
59 * A different optimization would be to compare for bitwise equality
60 * in the binary encoding. (It would be possible thought hairy to do
61 * both simultaneously.) But in that case if they turn out to be
62 * different, we'd need to restart the whole thing.
64 * Even better is to implement strcasecmp for each encoding and use a
67 int StrCaseCmp(const char *s
, const char *t
)
72 smb_ucs2_t
*buffer_s
, *buffer_t
;
75 for (ps
= s
, pt
= t
; ; ps
++, pt
++) {
79 return 0; /* both ended */
81 return -1; /* s is a prefix */
83 return +1; /* t is a prefix */
84 else if ((*ps
& 0x80) || (*pt
& 0x80))
85 /* not ascii anymore, do it the hard way
89 us
= toupper_ascii_fast(*ps
);
90 ut
= toupper_ascii_fast(*pt
);
99 if (!push_ucs2_talloc(talloc_tos(), &buffer_s
, ps
, &size
)) {
100 return strcmp(ps
, pt
);
101 /* Not quite the right answer, but finding the right one
102 under this failure case is expensive, and it's pretty
106 if (!push_ucs2_talloc(talloc_tos(), &buffer_t
, pt
, &size
)) {
107 TALLOC_FREE(buffer_s
);
108 return strcmp(ps
, pt
);
109 /* Not quite the right answer, but finding the right one
110 under this failure case is expensive, and it's pretty
114 ret
= strcasecmp_w(buffer_s
, buffer_t
);
115 TALLOC_FREE(buffer_s
);
116 TALLOC_FREE(buffer_t
);
122 Case insensitive string compararison, length limited.
124 int StrnCaseCmp(const char *s
, const char *t
, size_t len
)
129 smb_ucs2_t
*buffer_s
, *buffer_t
;
132 for (ps
= s
, pt
= t
; n
< len
; ps
++, pt
++, n
++) {
136 return 0; /* both ended */
138 return -1; /* s is a prefix */
140 return +1; /* t is a prefix */
141 else if ((*ps
& 0x80) || (*pt
& 0x80))
142 /* not ascii anymore, do it the
143 * hard way from here on in */
146 us
= toupper_ascii_fast(*ps
);
147 ut
= toupper_ascii_fast(*pt
);
160 if (!push_ucs2_talloc(talloc_tos(), &buffer_s
, ps
, &size
)) {
161 return strncmp(ps
, pt
, len
-n
);
162 /* Not quite the right answer, but finding the right one
163 under this failure case is expensive,
164 and it's pretty close */
167 if (!push_ucs2_talloc(talloc_tos(), &buffer_t
, pt
, &size
)) {
168 TALLOC_FREE(buffer_s
);
169 return strncmp(ps
, pt
, len
-n
);
170 /* Not quite the right answer, but finding the right one
171 under this failure case is expensive,
172 and it's pretty close */
175 ret
= strncasecmp_w(buffer_s
, buffer_t
, len
-n
);
176 TALLOC_FREE(buffer_s
);
177 TALLOC_FREE(buffer_t
);
184 * @note The comparison is case-insensitive.
186 bool strequal(const char *s1
, const char *s2
)
193 return(StrCaseCmp(s1
,s2
)==0);
197 * Compare 2 strings up to and including the nth char.
199 * @note The comparison is case-insensitive.
201 bool strnequal(const char *s1
,const char *s2
,size_t n
)
205 if (!s1
|| !s2
|| !n
)
208 return(StrnCaseCmp(s1
,s2
,n
)==0);
212 Compare 2 strings (case sensitive).
215 bool strcsequal(const char *s1
,const char *s2
)
222 return(strcmp(s1
,s2
)==0);
226 Do a case-insensitive, whitespace-ignoring string compare.
229 int strwicmp(const char *psz1
, const char *psz2
)
231 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
232 /* appropriate value. */
235 else if (psz1
== NULL
)
237 else if (psz2
== NULL
)
240 /* sync the strings on first non-whitespace */
242 while (isspace((int)*psz1
))
244 while (isspace((int)*psz2
))
246 if (toupper_ascii(*psz1
) != toupper_ascii(*psz2
) ||
247 *psz1
== '\0' || *psz2
== '\0')
252 return (*psz1
- *psz2
);
256 Convert a string to "normal" form.
259 void strnorm(char *s
, int case_default
)
261 if (case_default
== CASE_UPPER
)
268 Check if a string is in "normal" case.
271 bool strisnormal(const char *s
, int case_default
)
273 if (case_default
== CASE_UPPER
)
274 return(!strhaslower(s
));
276 return(!strhasupper(s
));
282 NOTE: oldc and newc must be 7 bit characters
284 void string_replace( char *s
, char oldc
, char newc
)
288 /* this is quite a common operation, so we want it to be
289 fast. We optimise for the ascii case, knowing that all our
290 supported multi-byte character sets are ascii-compatible
291 (ie. they match for the first 128 chars) */
293 for (p
= s
; *p
; p
++) {
294 if (*p
& 0x80) /* mb string - slow path. */
304 /* Slow (mb) path. */
305 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
306 /* With compose characters we must restart from the beginning. JRA. */
312 next_codepoint(p
, &c_size
);
324 * Skip past some strings in a buffer - old version - no checks.
327 char *push_skip_string(char *buf
)
329 buf
+= strlen(buf
) + 1;
334 Skip past a string in a buffer. Buffer may not be
335 null terminated. end_ptr points to the first byte after
336 then end of the buffer.
339 char *skip_string(const char *base
, size_t len
, char *buf
)
341 const char *end_ptr
= base
+ len
;
343 if (end_ptr
< base
|| !base
|| !buf
|| buf
>= end_ptr
) {
347 /* Skip the string */
350 if (buf
>= end_ptr
) {
360 Count the number of characters in a string. Normally this will
361 be the same as the number of bytes in a string for single byte strings,
362 but will be different for multibyte.
365 size_t str_charnum(const char *s
)
367 size_t ret
, converted_size
;
368 smb_ucs2_t
*tmpbuf2
= NULL
;
369 if (!push_ucs2_talloc(talloc_tos(), &tmpbuf2
, s
, &converted_size
)) {
372 ret
= strlen_w(tmpbuf2
);
373 TALLOC_FREE(tmpbuf2
);
378 Count the number of characters in a string. Normally this will
379 be the same as the number of bytes in a string for single byte strings,
380 but will be different for multibyte.
383 size_t str_ascii_charnum(const char *s
)
385 size_t ret
, converted_size
;
386 char *tmpbuf2
= NULL
;
387 if (!push_ascii_talloc(talloc_tos(), &tmpbuf2
, s
, &converted_size
)) {
390 ret
= strlen(tmpbuf2
);
391 TALLOC_FREE(tmpbuf2
);
395 bool trim_char(char *s
,char cfront
,char cback
)
401 /* Ignore null or empty strings. */
402 if (!s
|| (s
[0] == '\0'))
406 while (*fp
&& *fp
== cfront
)
409 /* We ate the string. */
417 ep
= fp
+ strlen(fp
) - 1;
419 /* Attempt ascii only. Bail for mb strings. */
420 while ((ep
>= fp
) && (*ep
== cback
)) {
422 if ((ep
> fp
) && (((unsigned char)ep
[-1]) & 0x80)) {
423 /* Could be mb... bail back to tim_string. */
431 return trim_string(s
, cfront
? fs
: NULL
, bs
);
437 /* We ate the string. */
444 memmove(s
, fp
, ep
-fp
+2);
449 Does a string have any uppercase chars in it?
452 bool strhasupper(const char *s
)
456 size_t converted_size
;
458 if (!push_ucs2_talloc(talloc_tos(), &tmp
, s
, &converted_size
)) {
462 for(p
= tmp
; *p
!= 0; p
++) {
474 Does a string have any lowercase chars in it?
477 bool strhaslower(const char *s
)
481 size_t converted_size
;
483 if (!push_ucs2_talloc(talloc_tos(), &tmp
, s
, &converted_size
)) {
487 for(p
= tmp
; *p
!= 0; p
++) {
499 Safe string copy into a known length string. maxlength does not
500 include the terminating zero.
503 char *safe_strcpy_fn(const char *fn
,
512 DEBUG(0,("ERROR: NULL dest in safe_strcpy, "
513 "called from [%s][%d]\n", fn
, line
));
518 clobber_region(fn
,line
,dest
, maxlength
+1);
526 len
= strnlen(src
, maxlength
+1);
528 if (len
> maxlength
) {
529 DEBUG(0,("ERROR: string overflow by "
530 "%lu (%lu - %lu) in safe_strcpy [%.50s]\n",
531 (unsigned long)(len
-maxlength
), (unsigned long)len
,
532 (unsigned long)maxlength
, src
));
536 memmove(dest
, src
, len
);
542 Safe string cat into a string. maxlength does not
543 include the terminating zero.
545 char *safe_strcat_fn(const char *fn
,
551 size_t src_len
, dest_len
;
554 DEBUG(0,("ERROR: NULL dest in safe_strcat, "
555 "called from [%s][%d]\n", fn
, line
));
562 src_len
= strnlen(src
, maxlength
+ 1);
563 dest_len
= strnlen(dest
, maxlength
+ 1);
566 clobber_region(fn
, line
, dest
+ dest_len
, maxlength
+ 1 - dest_len
);
569 if (src_len
+ dest_len
> maxlength
) {
570 DEBUG(0,("ERROR: string overflow by %d "
571 "in safe_strcat [%.50s]\n",
572 (int)(src_len
+ dest_len
- maxlength
), src
));
573 if (maxlength
> dest_len
) {
574 memcpy(&dest
[dest_len
], src
, maxlength
- dest_len
);
580 memcpy(&dest
[dest_len
], src
, src_len
);
581 dest
[dest_len
+ src_len
] = 0;
586 Paranoid strcpy into a buffer of given length (includes terminating
587 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
588 and replaces with '_'. Deliberately does *NOT* check for multibyte
589 characters. Treats src as an array of bytes, not as a multibyte
590 string. Any byte >0x7f is automatically converted to '_'.
591 other_safe_chars must also contain an ascii string (bytes<0x7f).
594 char *alpha_strcpy_fn(const char *fn
,
598 const char *other_safe_chars
,
604 clobber_region(fn
, line
, dest
, maxlength
);
608 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, "
609 "called from [%s][%d]\n", fn
, line
));
619 if (len
>= maxlength
)
622 if (!other_safe_chars
)
623 other_safe_chars
= "";
625 for(i
= 0; i
< len
; i
++) {
626 int val
= (src
[i
] & 0xff);
631 if (isupper(val
) || islower(val
) ||
632 isdigit(val
) || strchr(other_safe_chars
, val
))
644 Like strncpy but always null terminates. Make sure there is room!
645 The variable n should always be one less than the available size.
647 char *StrnCpy_fn(const char *fn
, int line
,char *dest
,const char *src
,size_t n
)
652 clobber_region(fn
, line
, dest
, n
+1);
656 DEBUG(0,("ERROR: NULL dest in StrnCpy, "
657 "called from [%s][%d]\n", fn
, line
));
666 while (n
-- && (*d
= *src
)) {
677 Like strncpy but copies up to the character marker. always null terminates.
678 returns a pointer to the character marker in the source string (src).
681 static char *strncpyn(char *dest
, const char *src
, size_t n
, char c
)
687 clobber_region(dest
, n
+1);
689 p
= strchr_m(src
, c
);
691 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c
));
695 str_len
= PTR_DIFF(p
, src
);
696 strncpy(dest
, src
, MIN(n
, str_len
));
697 dest
[str_len
] = '\0';
704 Check if a string is part of a list.
707 bool in_list(const char *s
, const char *list
, bool casesensitive
)
717 frame
= talloc_stackframe();
718 while (next_token_talloc(frame
, &list
, &tok
,LIST_SEP
)) {
720 if (strcmp(tok
,s
) == 0) {
725 if (StrCaseCmp(tok
,s
) == 0) {
735 /* this is used to prevent lots of mallocs of size 1 */
736 static const char null_string
[] = "";
739 Set a string value, allocing the space for the string
742 static bool string_init(char **dest
,const char *src
)
752 *dest
= CONST_DISCARD(char*, null_string
);
754 (*dest
) = SMB_STRDUP(src
);
755 if ((*dest
) == NULL
) {
756 DEBUG(0,("Out of memory in string_init\n"));
767 void string_free(char **s
)
771 if (*s
== null_string
)
777 Set a string value, deallocating any existing space, and allocing the space
781 bool string_set(char **dest
,const char *src
)
784 return(string_init(dest
,src
));
788 Substitute a string for a pattern in another string. Make sure there is
791 This routine looks for pattern in s and replaces it with
792 insert. It may do multiple replacements or just one.
794 Any of " ; ' $ or ` in the insert string are replaced with _
795 if len==0 then the string cannot be extended. This is different from the old
796 use of len==0 which was for no length checks to be done.
799 void string_sub2(char *s
,const char *pattern
, const char *insert
, size_t len
,
800 bool remove_unsafe_characters
, bool replace_once
,
801 bool allow_trailing_dollar
)
806 if (!insert
|| !pattern
|| !*pattern
|| !s
)
809 ls
= (ssize_t
)strlen(s
);
810 lp
= (ssize_t
)strlen(pattern
);
811 li
= (ssize_t
)strlen(insert
);
814 len
= ls
+ 1; /* len is number of *bytes* */
816 while (lp
<= ls
&& (p
= strstr_m(s
,pattern
))) {
817 if (ls
+ (li
-lp
) >= len
) {
818 DEBUG(0,("ERROR: string overflow by "
819 "%d in string_sub(%.50s, %d)\n",
820 (int)(ls
+ (li
-lp
) - len
),
825 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
834 /* allow a trailing $
835 * (as in machine accounts) */
836 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
843 if ( remove_unsafe_characters
) {
845 /* yes this break should be here
846 * since we want to fall throw if
847 * not replacing unsafe chars */
862 void string_sub_once(char *s
, const char *pattern
,
863 const char *insert
, size_t len
)
865 string_sub2( s
, pattern
, insert
, len
, true, true, false );
868 void string_sub(char *s
,const char *pattern
, const char *insert
, size_t len
)
870 string_sub2( s
, pattern
, insert
, len
, true, false, false );
873 void fstring_sub(char *s
,const char *pattern
,const char *insert
)
875 string_sub(s
, pattern
, insert
, sizeof(fstring
));
879 Similar to string_sub2, but it will accept only allocated strings
880 and may realloc them so pay attention at what you pass on no
881 pointers inside strings, no const may be passed
885 char *realloc_string_sub2(char *string
,
888 bool remove_unsafe_characters
,
889 bool allow_trailing_dollar
)
893 ssize_t ls
,lp
,li
,ld
, i
;
895 if (!insert
|| !pattern
|| !*pattern
|| !string
|| !*string
)
900 in
= SMB_STRDUP(insert
);
902 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
905 ls
= (ssize_t
)strlen(s
);
906 lp
= (ssize_t
)strlen(pattern
);
907 li
= (ssize_t
)strlen(insert
);
916 /* allow a trailing $
917 * (as in machine accounts) */
918 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
924 if ( remove_unsafe_characters
) {
934 while ((p
= strstr_m(s
,pattern
))) {
936 int offset
= PTR_DIFF(s
,string
);
937 string
= (char *)SMB_REALLOC(string
, ls
+ ld
+ 1);
939 DEBUG(0, ("realloc_string_sub: "
940 "out of memory!\n"));
944 p
= string
+ offset
+ (p
- s
);
947 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
957 char *realloc_string_sub(char *string
,
961 return realloc_string_sub2(string
, pattern
, insert
, true, false);
965 * Internal guts of talloc_string_sub and talloc_all_string_sub.
966 * talloc version of string_sub2.
969 char *talloc_string_sub2(TALLOC_CTX
*mem_ctx
, const char *src
,
972 bool remove_unsafe_characters
,
974 bool allow_trailing_dollar
)
979 ssize_t ls
,lp
,li
,ld
, i
;
981 if (!insert
|| !pattern
|| !*pattern
|| !src
) {
985 string
= talloc_strdup(mem_ctx
, src
);
986 if (string
== NULL
) {
987 DEBUG(0, ("talloc_string_sub2: "
988 "talloc_strdup failed\n"));
994 in
= SMB_STRDUP(insert
);
996 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
999 ls
= (ssize_t
)strlen(s
);
1000 lp
= (ssize_t
)strlen(pattern
);
1001 li
= (ssize_t
)strlen(insert
);
1004 for (i
=0;i
<li
;i
++) {
1011 /* allow a trailing $
1012 * (as in machine accounts) */
1013 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
1019 if (remove_unsafe_characters
) {
1029 while ((p
= strstr_m(s
,pattern
))) {
1031 int offset
= PTR_DIFF(s
,string
);
1032 string
= (char *)TALLOC_REALLOC(mem_ctx
, string
,
1035 DEBUG(0, ("talloc_string_sub: out of "
1040 p
= string
+ offset
+ (p
- s
);
1043 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1057 /* Same as string_sub, but returns a talloc'ed string */
1059 char *talloc_string_sub(TALLOC_CTX
*mem_ctx
,
1061 const char *pattern
,
1064 return talloc_string_sub2(mem_ctx
, src
, pattern
, insert
,
1065 true, false, false);
1069 Similar to string_sub() but allows for any character to be substituted.
1071 if len==0 then the string cannot be extended. This is different from the old
1072 use of len==0 which was for no length checks to be done.
1075 void all_string_sub(char *s
,const char *pattern
,const char *insert
, size_t len
)
1080 if (!insert
|| !pattern
|| !s
)
1083 ls
= (ssize_t
)strlen(s
);
1084 lp
= (ssize_t
)strlen(pattern
);
1085 li
= (ssize_t
)strlen(insert
);
1091 len
= ls
+ 1; /* len is number of *bytes* */
1093 while (lp
<= ls
&& (p
= strstr_m(s
,pattern
))) {
1094 if (ls
+ (li
-lp
) >= len
) {
1095 DEBUG(0,("ERROR: string overflow by "
1096 "%d in all_string_sub(%.50s, %d)\n",
1097 (int)(ls
+ (li
-lp
) - len
),
1098 pattern
, (int)len
));
1102 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1104 memcpy(p
, insert
, li
);
1110 char *talloc_all_string_sub(TALLOC_CTX
*ctx
,
1112 const char *pattern
,
1115 return talloc_string_sub2(ctx
, src
, pattern
, insert
,
1116 false, false, false);
1120 Write an octal as a string.
1123 char *octal_string(int i
)
1127 result
= talloc_strdup(talloc_tos(), "-1");
1130 result
= talloc_asprintf(talloc_tos(), "0%o", i
);
1132 SMB_ASSERT(result
!= NULL
);
1138 Truncate a string at a specified length.
1141 char *string_truncate(char *s
, unsigned int length
)
1143 if (s
&& strlen(s
) > length
)
1149 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1150 We convert via ucs2 for now.
1153 char *strchr_m(const char *src
, char c
)
1155 smb_ucs2_t
*ws
= NULL
;
1160 size_t converted_size
;
1162 /* characters below 0x3F are guaranteed to not appear in
1163 non-initial position in multi-byte charsets */
1164 if ((c
& 0xC0) == 0) {
1165 return strchr(src
, c
);
1168 /* this is quite a common operation, so we want it to be
1169 fast. We optimise for the ascii case, knowing that all our
1170 supported multi-byte character sets are ascii-compatible
1171 (ie. they match for the first 128 chars) */
1173 for (s
= src
; *s
&& !(((unsigned char)s
[0]) & 0x80); s
++) {
1181 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1182 /* With compose characters we must restart from the beginning. JRA. */
1186 if (!push_ucs2_talloc(talloc_tos(), &ws
, s
, &converted_size
)) {
1187 /* Wrong answer, but what can we do... */
1188 return strchr(src
, c
);
1190 p
= strchr_w(ws
, UCS2_CHAR(c
));
1196 if (!pull_ucs2_talloc(talloc_tos(), &s2
, ws
, &converted_size
)) {
1198 /* Wrong answer, but what can we do... */
1199 return strchr(src
, c
);
1201 ret
= (char *)(s
+strlen(s2
));
1207 char *strrchr_m(const char *s
, char c
)
1209 /* characters below 0x3F are guaranteed to not appear in
1210 non-initial position in multi-byte charsets */
1211 if ((c
& 0xC0) == 0) {
1212 return strrchr(s
, c
);
1215 /* this is quite a common operation, so we want it to be
1216 fast. We optimise for the ascii case, knowing that all our
1217 supported multi-byte character sets are ascii-compatible
1218 (ie. they match for the first 128 chars). Also, in Samba
1219 we only search for ascii characters in 'c' and that
1220 in all mb character sets with a compound character
1221 containing c, if 'c' is not a match at position
1222 p, then p[-1] > 0x7f. JRA. */
1225 size_t len
= strlen(s
);
1227 bool got_mb
= false;
1234 /* Could be a match. Part of a multibyte ? */
1236 (((unsigned char)cp
[-1]) & 0x80)) {
1237 /* Yep - go slow :-( */
1241 /* No - we have a match ! */
1244 } while (cp
-- != s
);
1249 /* String contained a non-ascii char. Slow path. */
1251 smb_ucs2_t
*ws
= NULL
;
1255 size_t converted_size
;
1257 if (!push_ucs2_talloc(talloc_tos(), &ws
, s
, &converted_size
)) {
1258 /* Wrong answer, but what can we do. */
1259 return strrchr(s
, c
);
1261 p
= strrchr_w(ws
, UCS2_CHAR(c
));
1267 if (!pull_ucs2_talloc(talloc_tos(), &s2
, ws
, &converted_size
)) {
1269 /* Wrong answer, but what can we do. */
1270 return strrchr(s
, c
);
1272 ret
= (char *)(s
+strlen(s2
));
1279 /***********************************************************************
1280 Return the equivalent of doing strrchr 'n' times - always going
1282 ***********************************************************************/
1284 char *strnrchr_m(const char *s
, char c
, unsigned int n
)
1286 smb_ucs2_t
*ws
= NULL
;
1290 size_t converted_size
;
1292 if (!push_ucs2_talloc(talloc_tos(), &ws
, s
, &converted_size
)) {
1293 /* Too hard to try and get right. */
1296 p
= strnrchr_w(ws
, UCS2_CHAR(c
), n
);
1302 if (!pull_ucs2_talloc(talloc_tos(), &s2
, ws
, &converted_size
)) {
1304 /* Too hard to try and get right. */
1307 ret
= (char *)(s
+strlen(s2
));
1313 /***********************************************************************
1314 strstr_m - We convert via ucs2 for now.
1315 ***********************************************************************/
1317 char *strstr_m(const char *src
, const char *findstr
)
1320 smb_ucs2_t
*src_w
, *find_w
;
1325 size_t converted_size
, findstr_len
= 0;
1327 /* for correctness */
1332 /* Samba does single character findstr calls a *lot*. */
1333 if (findstr
[1] == '\0')
1334 return strchr_m(src
, *findstr
);
1336 /* We optimise for the ascii case, knowing that all our
1337 supported multi-byte character sets are ascii-compatible
1338 (ie. they match for the first 128 chars) */
1340 for (s
= src
; *s
&& !(((unsigned char)s
[0]) & 0x80); s
++) {
1341 if (*s
== *findstr
) {
1343 findstr_len
= strlen(findstr
);
1345 if (strncmp(s
, findstr
, findstr_len
) == 0) {
1354 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1355 /* 'make check' fails unless we do this */
1357 /* With compose characters we must restart from the beginning. JRA. */
1361 if (!push_ucs2_talloc(talloc_tos(), &src_w
, src
, &converted_size
)) {
1362 DEBUG(0,("strstr_m: src malloc fail\n"));
1366 if (!push_ucs2_talloc(talloc_tos(), &find_w
, findstr
, &converted_size
)) {
1368 DEBUG(0,("strstr_m: find malloc fail\n"));
1372 p
= strstr_w(src_w
, find_w
);
1376 TALLOC_FREE(find_w
);
1381 if (!pull_ucs2_talloc(talloc_tos(), &s2
, src_w
, &converted_size
)) {
1383 TALLOC_FREE(find_w
);
1384 DEBUG(0,("strstr_m: dest malloc fail\n"));
1387 retp
= (char *)(s
+strlen(s2
));
1389 TALLOC_FREE(find_w
);
1395 Convert a string to lower case.
1398 void strlower_m(char *s
)
1403 /* this is quite a common operation, so we want it to be
1404 fast. We optimise for the ascii case, knowing that all our
1405 supported multi-byte character sets are ascii-compatible
1406 (ie. they match for the first 128 chars) */
1408 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
1409 *s
= tolower_ascii((unsigned char)*s
);
1416 /* I assume that lowercased string takes the same number of bytes
1417 * as source string even in UTF-8 encoding. (VIV) */
1418 len
= strlen(s
) + 1;
1421 unix_strlower(s
,len
,s
,len
);
1422 /* Catch mb conversion errors that may not terminate. */
1429 Convert a string to upper case.
1432 void strupper_m(char *s
)
1437 /* this is quite a common operation, so we want it to be
1438 fast. We optimise for the ascii case, knowing that all our
1439 supported multi-byte character sets are ascii-compatible
1440 (ie. they match for the first 128 chars) */
1442 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
1443 *s
= toupper_ascii_fast((unsigned char)*s
);
1450 /* I assume that lowercased string takes the same number of bytes
1451 * as source string even in multibyte encoding. (VIV) */
1452 len
= strlen(s
) + 1;
1455 unix_strupper(s
,len
,s
,len
);
1456 /* Catch mb conversion errors that may not terminate. */
1463 * Calculate the number of units (8 or 16-bit, depending on the
1464 * destination charset), that would be needed to convert the input
1465 * string which is expected to be in in CH_UNIX encoding to the
1466 * destination charset (which should be a unicode charset).
1468 size_t strlen_m_ext(const char *s
, const charset_t dst_charset
)
1476 while (*s
&& !(((uint8_t)*s
) & 0x80)) {
1487 codepoint_t c
= next_codepoint(s
, &c_size
);
1490 switch(dst_charset
) {
1493 case CH_UTF16MUNGED
:
1495 /* Unicode char fits into 16 bits. */
1498 /* Double-width unicode char - 32 bits. */
1504 * this only checks ranges, and does not
1505 * check for invalid codepoints
1509 } else if (c
< 0x800) {
1511 } else if (c
< 0x1000) {
1519 * non-unicode encoding:
1520 * assume that each codepoint fits into
1521 * one unit in the destination encoding.
1530 size_t strlen_m_ext_term(const char *s
, const charset_t dst_charset
)
1535 return strlen_m_ext(s
, dst_charset
) + 1;
1539 Count the number of UCS2 characters in a string. Normally this will
1540 be the same as the number of bytes in a string for single byte strings,
1541 but will be different for multibyte.
1544 size_t strlen_m(const char *s
)
1546 return strlen_m_ext(s
, CH_UTF16LE
);
1550 Count the number of UCS2 characters in a string including the null
1554 size_t strlen_m_term(const char *s
)
1559 return strlen_m(s
) + 1;
1563 * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1564 * if a string is there, include the terminator.
1567 size_t strlen_m_term_null(const char *s
)
1581 Return a RFC2254 binary string representation of a buffer.
1582 Used in LDAP filters.
1586 char *binary_string_rfc2254(TALLOC_CTX
*mem_ctx
, const uint8_t *buf
, int len
)
1590 const char *hex
= "0123456789ABCDEF";
1591 s
= talloc_array(mem_ctx
, char, len
* 3 + 1);
1595 for (j
=i
=0;i
<len
;i
++) {
1597 s
[j
+1] = hex
[((unsigned char)buf
[i
]) >> 4];
1598 s
[j
+2] = hex
[((unsigned char)buf
[i
]) & 0xF];
1605 char *binary_string(char *buf
, int len
)
1609 const char *hex
= "0123456789ABCDEF";
1610 s
= (char *)SMB_MALLOC(len
* 2 + 1);
1613 for (j
=i
=0;i
<len
;i
++) {
1614 s
[j
] = hex
[((unsigned char)buf
[i
]) >> 4];
1615 s
[j
+1] = hex
[((unsigned char)buf
[i
]) & 0xF];
1623 Just a typesafety wrapper for snprintf into a fstring.
1626 int fstr_sprintf(fstring s
, const char *fmt
, ...)
1632 ret
= vsnprintf(s
, FSTRING_LEN
, fmt
, ap
);
1638 List of Strings manipulation functions
1641 #define S_LIST_ABS 16 /* List Allocation Block Size */
1643 /******************************************************************************
1644 version of standard_sub_basic() for string lists; uses talloc_sub_basic()
1646 *****************************************************************************/
1648 bool str_list_sub_basic( char **list
, const char *smb_name
,
1649 const char *domain_name
)
1651 TALLOC_CTX
*ctx
= list
;
1656 tmpstr
= talloc_sub_basic(ctx
, smb_name
, domain_name
, s
);
1658 DEBUG(0,("str_list_sub_basic: "
1659 "alloc_sub_basic() return NULL!\n"));
1672 /******************************************************************************
1673 substitute a specific pattern in a string list
1674 *****************************************************************************/
1676 bool str_list_substitute(char **list
, const char *pattern
, const char *insert
)
1678 TALLOC_CTX
*ctx
= list
;
1680 ssize_t ls
, lp
, li
, ld
, i
, d
;
1689 lp
= (ssize_t
)strlen(pattern
);
1690 li
= (ssize_t
)strlen(insert
);
1695 ls
= (ssize_t
)strlen(s
);
1697 while ((p
= strstr_m(s
, pattern
))) {
1701 t
= TALLOC_ARRAY(ctx
, char, ls
+ld
+1);
1703 DEBUG(0,("str_list_substitute: "
1704 "Unable to allocate memory"));
1707 memcpy(t
, *list
, d
);
1708 memcpy(t
+d
+li
, p
+lp
, ls
-d
-lp
+1);
1715 for (i
= 0; i
< li
; i
++) {
1716 switch (insert
[i
]) {
1728 t
[d
+i
] = insert
[i
];
1740 #define IPSTR_LIST_SEP ","
1741 #define IPSTR_LIST_CHAR ','
1744 * Add ip string representation to ipstr list. Used also
1745 * as part of @function ipstr_list_make
1747 * @param ipstr_list pointer to string containing ip list;
1748 * MUST BE already allocated and IS reallocated if necessary
1749 * @param ipstr_size pointer to current size of ipstr_list (might be changed
1750 * as a result of reallocation)
1751 * @param ip IP address which is to be added to list
1752 * @return pointer to string appended with new ip and possibly
1753 * reallocated to new length
1756 static char *ipstr_list_add(char **ipstr_list
, const struct ip_service
*service
)
1758 char *new_ipstr
= NULL
;
1759 char addr_buf
[INET6_ADDRSTRLEN
];
1762 /* arguments checking */
1763 if (!ipstr_list
|| !service
) {
1767 print_sockaddr(addr_buf
,
1771 /* attempt to convert ip to a string and append colon separator to it */
1773 if (service
->ss
.ss_family
== AF_INET
) {
1775 ret
= asprintf(&new_ipstr
, "%s%s%s:%d", *ipstr_list
,
1776 IPSTR_LIST_SEP
, addr_buf
,
1780 ret
= asprintf(&new_ipstr
, "%s%s[%s]:%d", *ipstr_list
,
1781 IPSTR_LIST_SEP
, addr_buf
,
1784 SAFE_FREE(*ipstr_list
);
1786 if (service
->ss
.ss_family
== AF_INET
) {
1788 ret
= asprintf(&new_ipstr
, "%s:%d", addr_buf
,
1792 ret
= asprintf(&new_ipstr
, "[%s]:%d", addr_buf
,
1799 *ipstr_list
= new_ipstr
;
1804 * Allocate and initialise an ipstr list using ip adresses
1805 * passed as arguments.
1807 * @param ipstr_list pointer to string meant to be allocated and set
1808 * @param ip_list array of ip addresses to place in the list
1809 * @param ip_count number of addresses stored in ip_list
1810 * @return pointer to allocated ip string
1813 char *ipstr_list_make(char **ipstr_list
,
1814 const struct ip_service
*ip_list
,
1819 /* arguments checking */
1820 if (!ip_list
|| !ipstr_list
) {
1826 /* process ip addresses given as arguments */
1827 for (i
= 0; i
< ip_count
; i
++) {
1828 *ipstr_list
= ipstr_list_add(ipstr_list
, &ip_list
[i
]);
1831 return (*ipstr_list
);
1836 * Parse given ip string list into array of ip addresses
1837 * (as ip_service structures)
1838 * e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
1840 * @param ipstr ip string list to be parsed
1841 * @param ip_list pointer to array of ip addresses which is
1842 * allocated by this function and must be freed by caller
1843 * @return number of successfully parsed addresses
1846 int ipstr_list_parse(const char *ipstr_list
, struct ip_service
**ip_list
)
1849 char *token_str
= NULL
;
1853 if (!ipstr_list
|| !ip_list
)
1856 count
= count_chars(ipstr_list
, IPSTR_LIST_CHAR
) + 1;
1857 if ( (*ip_list
= SMB_MALLOC_ARRAY(struct ip_service
, count
)) == NULL
) {
1858 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
1859 (unsigned long)count
));
1863 frame
= talloc_stackframe();
1864 for ( i
=0; next_token_talloc(frame
, &ipstr_list
, &token_str
,
1865 IPSTR_LIST_SEP
) && i
<count
; i
++ ) {
1866 char *s
= token_str
;
1867 char *p
= strrchr(token_str
, ':');
1871 (*ip_list
)[i
].port
= atoi(p
+1);
1874 /* convert single token to ip address */
1875 if (token_str
[0] == '[') {
1878 p
= strchr(token_str
, ']');
1884 if (!interpret_string_addr(&(*ip_list
)[i
].ss
,
1895 * Safely free ip string list
1897 * @param ipstr_list ip string list to be freed
1900 void ipstr_list_free(char* ipstr_list
)
1902 SAFE_FREE(ipstr_list
);
1905 static const char b64
[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1908 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1910 DATA_BLOB
base64_decode_data_blob(const char *s
)
1912 int bit_offset
, byte_offset
, idx
, i
, n
;
1913 DATA_BLOB decoded
= data_blob(s
, strlen(s
)+1);
1914 unsigned char *d
= decoded
.data
;
1919 while (*s
&& (p
=strchr_m(b64
,*s
))) {
1920 idx
= (int)(p
- b64
);
1921 byte_offset
= (i
*6)/8;
1922 bit_offset
= (i
*6)%8;
1923 d
[byte_offset
] &= ~((1<<(8-bit_offset
))-1);
1924 if (bit_offset
< 3) {
1925 d
[byte_offset
] |= (idx
<< (2-bit_offset
));
1928 d
[byte_offset
] |= (idx
>> (bit_offset
-2));
1929 d
[byte_offset
+1] = 0;
1930 d
[byte_offset
+1] |= (idx
<< (8-(bit_offset
-2))) & 0xFF;
1936 if ((n
> 0) && (*s
== '=')) {
1946 * Decode a base64 string in-place - wrapper for the above
1948 void base64_decode_inplace(char *s
)
1950 DATA_BLOB decoded
= base64_decode_data_blob(s
);
1952 if ( decoded
.length
!= 0 ) {
1953 memcpy(s
, decoded
.data
, decoded
.length
);
1955 /* null terminate */
1956 s
[decoded
.length
] = '\0';
1961 data_blob_free(&decoded
);
1965 * Encode a base64 string into a talloc()ed string caller to free.
1967 * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
1971 char *base64_encode_data_blob(TALLOC_CTX
*mem_ctx
, DATA_BLOB data
)
1975 size_t out_cnt
, len
, output_len
;
1978 if (!data
.length
|| !data
.data
)
1983 output_len
= data
.length
* 2 + 4; /* Account for closing bytes. 4 is
1984 * random but should be enough for
1986 result
= TALLOC_ARRAY(mem_ctx
, char, output_len
); /* get us plenty of space */
1987 SMB_ASSERT(result
!= NULL
);
1990 int c
= (unsigned char) *(data
.data
++);
1993 if (char_count
== 3) {
1994 result
[out_cnt
++] = b64
[bits
>> 18];
1995 result
[out_cnt
++] = b64
[(bits
>> 12) & 0x3f];
1996 result
[out_cnt
++] = b64
[(bits
>> 6) & 0x3f];
1997 result
[out_cnt
++] = b64
[bits
& 0x3f];
2004 if (char_count
!= 0) {
2005 bits
<<= 16 - (8 * char_count
);
2006 result
[out_cnt
++] = b64
[bits
>> 18];
2007 result
[out_cnt
++] = b64
[(bits
>> 12) & 0x3f];
2008 if (char_count
== 1) {
2009 result
[out_cnt
++] = '=';
2010 result
[out_cnt
++] = '=';
2012 result
[out_cnt
++] = b64
[(bits
>> 6) & 0x3f];
2013 result
[out_cnt
++] = '=';
2016 result
[out_cnt
] = '\0'; /* terminate */
2020 /* read a SMB_BIG_UINT from a string */
2021 uint64_t STR_TO_SMB_BIG_UINT(const char *nptr
, const char **entptr
)
2025 const char *p
= nptr
;
2034 while (*p
&& isspace(*p
))
2037 sscanf(p
,"%"PRIu64
,&val
);
2039 while (*p
&& isdigit(*p
))
2047 /* Convert a size specification to a count of bytes. We accept the following
2049 * bytes if there is no suffix
2054 * pP whatever the ISO name for petabytes is
2056 * Returns 0 if the string can't be converted.
2058 SMB_OFF_T
conv_str_size(const char * str
)
2063 if (str
== NULL
|| *str
== '\0') {
2067 #ifdef HAVE_STRTOULL
2068 if (sizeof(SMB_OFF_T
) == 8) {
2069 lval
= strtoull(str
, &end
, 10 /* base */);
2071 lval
= strtoul(str
, &end
, 10 /* base */);
2074 lval
= strtoul(str
, &end
, 10 /* base */);
2077 if (end
== NULL
|| end
== str
) {
2082 SMB_OFF_T lval_orig
= lval
;
2084 if (strwicmp(end
, "K") == 0) {
2085 lval
*= (SMB_OFF_T
)1024;
2086 } else if (strwicmp(end
, "M") == 0) {
2087 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024);
2088 } else if (strwicmp(end
, "G") == 0) {
2089 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2091 } else if (strwicmp(end
, "T") == 0) {
2092 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2093 (SMB_OFF_T
)1024 * (SMB_OFF_T
)1024);
2094 } else if (strwicmp(end
, "P") == 0) {
2095 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2096 (SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2102 /* Primitive attempt to detect wrapping on platforms with
2103 * 4-byte SMB_OFF_T. It's better to let the caller handle
2104 * a failure than some random number.
2106 if (lval_orig
<= lval
) {
2114 void string_append(char **left
, const char *right
)
2116 int new_len
= strlen(right
) + 1;
2118 if (*left
== NULL
) {
2119 *left
= (char *)SMB_MALLOC(new_len
);
2122 new_len
+= strlen(*left
);
2123 *left
= (char *)SMB_REALLOC(*left
, new_len
);
2126 if (*left
== NULL
) {
2130 safe_strcat(*left
, right
, new_len
-1);
2133 bool add_string_to_array(TALLOC_CTX
*mem_ctx
,
2134 const char *str
, const char ***strings
,
2137 char *dup_str
= talloc_strdup(mem_ctx
, str
);
2139 *strings
= TALLOC_REALLOC_ARRAY(mem_ctx
, *strings
,
2140 const char *, (*num
)+1);
2142 if ((*strings
== NULL
) || (dup_str
== NULL
)) {
2147 (*strings
)[*num
] = dup_str
;
2152 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2153 * error checking in between. The indiation that something weird happened is
2156 void sprintf_append(TALLOC_CTX
*mem_ctx
, char **string
, ssize_t
*len
,
2157 size_t *bufsize
, const char *fmt
, ...)
2164 /* len<0 is an internal marker that something failed */
2168 if (*string
== NULL
) {
2172 *string
= TALLOC_ARRAY(mem_ctx
, char, *bufsize
);
2173 if (*string
== NULL
)
2178 ret
= vasprintf(&newstr
, fmt
, ap
);
2186 while ((*len
)+ret
>= *bufsize
) {
2189 if (*bufsize
>= (1024*1024*256))
2194 *string
= TALLOC_REALLOC_ARRAY(mem_ctx
, *string
, char,
2196 if (*string
== NULL
) {
2201 StrnCpy((*string
)+(*len
), newstr
, ret
);
2212 * asprintf into a string and strupper_m it after that.
2215 int asprintf_strupper_m(char **strp
, const char *fmt
, ...)
2222 ret
= vasprintf(&result
, fmt
, ap
);
2233 char *talloc_asprintf_strupper_m(TALLOC_CTX
*t
, const char *fmt
, ...)
2239 ret
= talloc_vasprintf(t
, fmt
, ap
);
2249 char *talloc_asprintf_strlower_m(TALLOC_CTX
*t
, const char *fmt
, ...)
2255 ret
= talloc_vasprintf(t
, fmt
, ap
);
2267 Returns the substring from src between the first occurrence of
2268 the char "front" and the first occurence of the char "back".
2269 Mallocs the return string which must be freed. Not for use
2270 with wide character strings.
2272 char *sstring_sub(const char *src
, char front
, char back
)
2274 char *temp1
, *temp2
, *temp3
;
2277 temp1
= strchr(src
, front
);
2278 if (temp1
== NULL
) return NULL
;
2279 temp2
= strchr(src
, back
);
2280 if (temp2
== NULL
) return NULL
;
2281 len
= temp2
- temp1
;
2282 if (len
<= 0) return NULL
;
2283 temp3
= (char*)SMB_MALLOC(len
);
2284 if (temp3
== NULL
) {
2285 DEBUG(1,("Malloc failure in sstring_sub\n"));
2288 memcpy(temp3
, temp1
+1, len
-1);
2289 temp3
[len
-1] = '\0';
2293 /********************************************************************
2294 Check a string for any occurrences of a specified list of invalid
2296 ********************************************************************/
2298 bool validate_net_name( const char *name
,
2299 const char *invalid_chars
,
2304 for ( i
=0; i
<max_len
&& name
[i
]; i
++ ) {
2305 /* fail if strchr_m() finds one of the invalid characters */
2306 if ( name
[i
] && strchr_m( invalid_chars
, name
[i
] ) ) {
2315 /*******************************************************************
2316 Add a shell escape character '\' to any character not in a known list
2317 of characters. UNIX charset format.
2318 *******************************************************************/
2320 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
2321 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
2323 char *escape_shell_string(const char *src
)
2325 size_t srclen
= strlen(src
);
2326 char *ret
= SMB_MALLOC_ARRAY(char, (srclen
* 2) + 1);
2328 bool in_s_quote
= false;
2329 bool in_d_quote
= false;
2330 bool next_escaped
= false;
2338 codepoint_t c
= next_codepoint(src
, &c_size
);
2340 if (c
== INVALID_CODEPOINT
) {
2346 memcpy(dest
, src
, c_size
);
2349 next_escaped
= false;
2354 * Deal with backslash escaped state.
2355 * This only lasts for one character.
2360 next_escaped
= false;
2365 * Deal with single quote state. The
2366 * only thing we care about is exiting
2379 * Deal with double quote state. The most
2380 * complex state. We must cope with \, meaning
2381 * possibly escape next char (depending what it
2382 * is), ", meaning exit this state, and possibly
2383 * add an \ escape to any unprotected character
2384 * (listed in INSIDE_DQUOTE_LIST).
2390 * Next character might be escaped.
2391 * We have to peek. Inside double
2392 * quotes only INSIDE_DQUOTE_LIST
2393 * characters are escaped by a \.
2398 c
= next_codepoint(&src
[1], &c_size
);
2399 if (c
== INVALID_CODEPOINT
) {
2405 * Don't escape the next char.
2414 if (nextchar
&& strchr(INSIDE_DQUOTE_LIST
,
2416 next_escaped
= true;
2423 /* Exit double quote state. */
2430 * We know the character isn't \ or ",
2431 * so escape it if it's any of the other
2432 * possible unprotected characters.
2435 if (strchr(INSIDE_DQUOTE_LIST
, (int)*src
)) {
2443 * From here to the end of the loop we're
2444 * not in the single or double quote state.
2448 /* Next character must be escaped. */
2449 next_escaped
= true;
2455 /* Go into single quote state. */
2462 /* Go into double quote state. */
2468 /* Check if we need to escape the character. */
2470 if (!strchr(INCLUDE_LIST
, (int)*src
)) {
2479 /***************************************************
2480 str_list_make, v3 version. The v4 version does not
2481 look at quoted strings with embedded blanks, so
2482 do NOT merge this function please!
2483 ***************************************************/
2485 #define S_LIST_ABS 16 /* List Allocation Block Size */
2487 char **str_list_make_v3(TALLOC_CTX
*mem_ctx
, const char *string
,
2495 if (!string
|| !*string
)
2498 list
= TALLOC_ARRAY(mem_ctx
, char *, S_LIST_ABS
+1);
2504 s
= talloc_strdup(list
, string
);
2506 DEBUG(0,("str_list_make: Unable to allocate memory"));
2510 if (!sep
) sep
= LIST_SEP
;
2515 while (next_token_talloc(list
, &str
, &tok
, sep
)) {
2520 lsize
+= S_LIST_ABS
;
2522 tmp
= TALLOC_REALLOC_ARRAY(mem_ctx
, list
, char *,
2525 DEBUG(0,("str_list_make: "
2526 "Unable to allocate memory"));
2533 memset (&list
[num
], 0,
2534 ((sizeof(char**)) * (S_LIST_ABS
+1)));