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
40 * @brief String utilities.
43 static bool next_token_internal_talloc(TALLOC_CTX
*ctx
,
62 /* default to simple separators */
67 /* find the first non sep char, if left-trimming is requested */
69 while (*s
&& strchr_m(sep
,*s
)) {
79 /* When restarting we need to go from here. */
82 /* Work out the length needed. */
83 for (quoted
= false; *s
&&
84 (quoted
|| !strchr_m(sep
,*s
)); s
++) {
92 /* We started with len = 1 so we have space for the nul. */
93 *pp_buff
= TALLOC_ARRAY(ctx
, char, len
);
98 /* copy over the token */
101 for (quoted
= false; *s
&&
102 (quoted
|| !strchr_m(sep
,*s
)); s
++) {
110 *ptr
= (*s
) ? s
+1 : s
;
118 * Get the next token from a string, return false if none found. Handles
119 * double-quotes. This version trims leading separator characters before
120 * looking for a token.
122 bool next_token(const char **ptr
, char *buff
, const char *sep
, size_t bufsize
)
124 return next_token_internal(ptr
, buff
, sep
, bufsize
, true);
128 bool next_token_talloc(TALLOC_CTX
*ctx
,
133 return next_token_internal_talloc(ctx
, ptr
, pp_buff
, sep
, true);
137 * Get the next token from a string, return false if none found. Handles
138 * double-quotes. This version does not trim leading separator characters
139 * before looking for a token.
142 bool next_token_no_ltrim_talloc(TALLOC_CTX
*ctx
,
147 return next_token_internal_talloc(ctx
, ptr
, pp_buff
, sep
, false);
151 * Case insensitive string compararison.
153 * iconv does not directly give us a way to compare strings in
154 * arbitrary unix character sets -- all we can is convert and then
155 * compare. This is expensive.
157 * As an optimization, we do a first pass that considers only the
158 * prefix of the strings that is entirely 7-bit. Within this, we
159 * check whether they have the same value.
161 * Hopefully this will often give the answer without needing to copy.
162 * In particular it should speed comparisons to literal ascii strings
163 * or comparisons of strings that are "obviously" different.
165 * If we find a non-ascii character we fall back to converting via
168 * This should never be slower than convering the whole thing, and
171 * A different optimization would be to compare for bitwise equality
172 * in the binary encoding. (It would be possible thought hairy to do
173 * both simultaneously.) But in that case if they turn out to be
174 * different, we'd need to restart the whole thing.
176 * Even better is to implement strcasecmp for each encoding and use a
179 int StrCaseCmp(const char *s
, const char *t
)
184 smb_ucs2_t
*buffer_s
, *buffer_t
;
187 for (ps
= s
, pt
= t
; ; ps
++, pt
++) {
191 return 0; /* both ended */
193 return -1; /* s is a prefix */
195 return +1; /* t is a prefix */
196 else if ((*ps
& 0x80) || (*pt
& 0x80))
197 /* not ascii anymore, do it the hard way
201 us
= toupper_ascii_fast(*ps
);
202 ut
= toupper_ascii_fast(*pt
);
211 if (!push_ucs2_allocate(&buffer_s
, ps
, &size
)) {
212 return strcmp(ps
, pt
);
213 /* Not quite the right answer, but finding the right one
214 under this failure case is expensive, and it's pretty
218 if (!push_ucs2_allocate(&buffer_t
, pt
, &size
)) {
220 return strcmp(ps
, pt
);
221 /* Not quite the right answer, but finding the right one
222 under this failure case is expensive, and it's pretty
226 ret
= strcasecmp_w(buffer_s
, buffer_t
);
234 Case insensitive string compararison, length limited.
236 int StrnCaseCmp(const char *s
, const char *t
, size_t len
)
241 smb_ucs2_t
*buffer_s
, *buffer_t
;
244 for (ps
= s
, pt
= t
; n
< len
; ps
++, pt
++, n
++) {
248 return 0; /* both ended */
250 return -1; /* s is a prefix */
252 return +1; /* t is a prefix */
253 else if ((*ps
& 0x80) || (*pt
& 0x80))
254 /* not ascii anymore, do it the
255 * hard way from here on in */
258 us
= toupper_ascii_fast(*ps
);
259 ut
= toupper_ascii_fast(*pt
);
272 if (!push_ucs2_allocate(&buffer_s
, ps
, &size
)) {
273 return strncmp(ps
, pt
, len
-n
);
274 /* Not quite the right answer, but finding the right one
275 under this failure case is expensive,
276 and it's pretty close */
279 if (!push_ucs2_allocate(&buffer_t
, pt
, &size
)) {
281 return strncmp(ps
, pt
, len
-n
);
282 /* Not quite the right answer, but finding the right one
283 under this failure case is expensive,
284 and it's pretty close */
287 ret
= strncasecmp_w(buffer_s
, buffer_t
, len
-n
);
296 * @note The comparison is case-insensitive.
298 bool strequal(const char *s1
, const char *s2
)
305 return(StrCaseCmp(s1
,s2
)==0);
309 * Compare 2 strings up to and including the nth char.
311 * @note The comparison is case-insensitive.
313 bool strnequal(const char *s1
,const char *s2
,size_t n
)
317 if (!s1
|| !s2
|| !n
)
320 return(StrnCaseCmp(s1
,s2
,n
)==0);
324 Compare 2 strings (case sensitive).
327 bool strcsequal(const char *s1
,const char *s2
)
334 return(strcmp(s1
,s2
)==0);
338 Do a case-insensitive, whitespace-ignoring string compare.
341 int strwicmp(const char *psz1
, const char *psz2
)
343 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
344 /* appropriate value. */
347 else if (psz1
== NULL
)
349 else if (psz2
== NULL
)
352 /* sync the strings on first non-whitespace */
354 while (isspace((int)*psz1
))
356 while (isspace((int)*psz2
))
358 if (toupper_ascii(*psz1
) != toupper_ascii(*psz2
) ||
359 *psz1
== '\0' || *psz2
== '\0')
364 return (*psz1
- *psz2
);
368 Convert a string to "normal" form.
371 void strnorm(char *s
, int case_default
)
373 if (case_default
== CASE_UPPER
)
380 Check if a string is in "normal" case.
383 bool strisnormal(const char *s
, int case_default
)
385 if (case_default
== CASE_UPPER
)
386 return(!strhaslower(s
));
388 return(!strhasupper(s
));
394 NOTE: oldc and newc must be 7 bit characters
396 void string_replace( char *s
, char oldc
, char newc
)
400 /* this is quite a common operation, so we want it to be
401 fast. We optimise for the ascii case, knowing that all our
402 supported multi-byte character sets are ascii-compatible
403 (ie. they match for the first 128 chars) */
405 for (p
= s
; *p
; p
++) {
406 if (*p
& 0x80) /* mb string - slow path. */
416 /* Slow (mb) path. */
417 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
418 /* With compose characters we must restart from the beginning. JRA. */
424 next_codepoint(p
, &c_size
);
436 * Skip past some strings in a buffer - old version - no checks.
439 char *push_skip_string(char *buf
)
441 buf
+= strlen(buf
) + 1;
446 Skip past a string in a buffer. Buffer may not be
447 null terminated. end_ptr points to the first byte after
448 then end of the buffer.
451 char *skip_string(const char *base
, size_t len
, char *buf
)
453 const char *end_ptr
= base
+ len
;
455 if (end_ptr
< base
|| !base
|| !buf
|| buf
>= end_ptr
) {
459 /* Skip the string */
462 if (buf
>= end_ptr
) {
472 Count the number of characters in a string. Normally this will
473 be the same as the number of bytes in a string for single byte strings,
474 but will be different for multibyte.
477 size_t str_charnum(const char *s
)
479 size_t ret
, converted_size
;
480 smb_ucs2_t
*tmpbuf2
= NULL
;
481 if (!push_ucs2_allocate(&tmpbuf2
, s
, &converted_size
)) {
484 ret
= strlen_w(tmpbuf2
);
490 Count the number of characters in a string. Normally this will
491 be the same as the number of bytes in a string for single byte strings,
492 but will be different for multibyte.
495 size_t str_ascii_charnum(const char *s
)
497 size_t ret
, converted_size
;
498 char *tmpbuf2
= NULL
;
499 if (!push_ascii_allocate(&tmpbuf2
, s
, &converted_size
)) {
502 ret
= strlen(tmpbuf2
);
507 bool trim_char(char *s
,char cfront
,char cback
)
513 /* Ignore null or empty strings. */
514 if (!s
|| (s
[0] == '\0'))
518 while (*fp
&& *fp
== cfront
)
521 /* We ate the string. */
529 ep
= fp
+ strlen(fp
) - 1;
531 /* Attempt ascii only. Bail for mb strings. */
532 while ((ep
>= fp
) && (*ep
== cback
)) {
534 if ((ep
> fp
) && (((unsigned char)ep
[-1]) & 0x80)) {
535 /* Could be mb... bail back to tim_string. */
543 return trim_string(s
, cfront
? fs
: NULL
, bs
);
549 /* We ate the string. */
556 memmove(s
, fp
, ep
-fp
+2);
561 Does a string have any uppercase chars in it?
564 bool strhasupper(const char *s
)
568 size_t converted_size
;
570 if (!push_ucs2_allocate(&tmp
, s
, &converted_size
)) {
574 for(p
= tmp
; *p
!= 0; p
++) {
586 Does a string have any lowercase chars in it?
589 bool strhaslower(const char *s
)
593 size_t converted_size
;
595 if (!push_ucs2_allocate(&tmp
, s
, &converted_size
)) {
599 for(p
= tmp
; *p
!= 0; p
++) {
611 Safe string copy into a known length string. maxlength does not
612 include the terminating zero.
615 char *safe_strcpy_fn(const char *fn
,
624 DEBUG(0,("ERROR: NULL dest in safe_strcpy, "
625 "called from [%s][%d]\n", fn
, line
));
630 clobber_region(fn
,line
,dest
, maxlength
+1);
638 len
= strnlen(src
, maxlength
+1);
640 if (len
> maxlength
) {
641 DEBUG(0,("ERROR: string overflow by "
642 "%lu (%lu - %lu) in safe_strcpy [%.50s]\n",
643 (unsigned long)(len
-maxlength
), (unsigned long)len
,
644 (unsigned long)maxlength
, src
));
648 memmove(dest
, src
, len
);
654 Safe string cat into a string. maxlength does not
655 include the terminating zero.
657 char *safe_strcat_fn(const char *fn
,
663 size_t src_len
, dest_len
;
666 DEBUG(0,("ERROR: NULL dest in safe_strcat, "
667 "called from [%s][%d]\n", fn
, line
));
674 src_len
= strnlen(src
, maxlength
+ 1);
675 dest_len
= strnlen(dest
, maxlength
+ 1);
678 clobber_region(fn
, line
, dest
+ dest_len
, maxlength
+ 1 - dest_len
);
681 if (src_len
+ dest_len
> maxlength
) {
682 DEBUG(0,("ERROR: string overflow by %d "
683 "in safe_strcat [%.50s]\n",
684 (int)(src_len
+ dest_len
- maxlength
), src
));
685 if (maxlength
> dest_len
) {
686 memcpy(&dest
[dest_len
], src
, maxlength
- dest_len
);
692 memcpy(&dest
[dest_len
], src
, src_len
);
693 dest
[dest_len
+ src_len
] = 0;
698 Paranoid strcpy into a buffer of given length (includes terminating
699 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
700 and replaces with '_'. Deliberately does *NOT* check for multibyte
701 characters. Don't change it !
704 char *alpha_strcpy_fn(const char *fn
,
708 const char *other_safe_chars
,
714 clobber_region(fn
, line
, dest
, maxlength
);
718 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, "
719 "called from [%s][%d]\n", fn
, line
));
729 if (len
>= maxlength
)
732 if (!other_safe_chars
)
733 other_safe_chars
= "";
735 for(i
= 0; i
< len
; i
++) {
736 int val
= (src
[i
] & 0xff);
737 if (isupper_ascii(val
) || islower_ascii(val
) ||
738 isdigit(val
) || strchr_m(other_safe_chars
, val
))
750 Like strncpy but always null terminates. Make sure there is room!
751 The variable n should always be one less than the available size.
753 char *StrnCpy_fn(const char *fn
, int line
,char *dest
,const char *src
,size_t n
)
758 clobber_region(fn
, line
, dest
, n
+1);
762 DEBUG(0,("ERROR: NULL dest in StrnCpy, "
763 "called from [%s][%d]\n", fn
, line
));
772 while (n
-- && (*d
= *src
)) {
783 Like strncpy but copies up to the character marker. always null terminates.
784 returns a pointer to the character marker in the source string (src).
787 static char *strncpyn(char *dest
, const char *src
, size_t n
, char c
)
793 clobber_region(dest
, n
+1);
795 p
= strchr_m(src
, c
);
797 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c
));
801 str_len
= PTR_DIFF(p
, src
);
802 strncpy(dest
, src
, MIN(n
, str_len
));
803 dest
[str_len
] = '\0';
810 Check if a string is part of a list.
813 bool in_list(const char *s
, const char *list
, bool casesensitive
)
823 frame
= talloc_stackframe();
824 while (next_token_talloc(frame
, &list
, &tok
,LIST_SEP
)) {
826 if (strcmp(tok
,s
) == 0) {
831 if (StrCaseCmp(tok
,s
) == 0) {
841 /* this is used to prevent lots of mallocs of size 1 */
842 static const char null_string
[] = "";
845 Set a string value, allocing the space for the string
848 static bool string_init(char **dest
,const char *src
)
858 *dest
= CONST_DISCARD(char*, null_string
);
860 (*dest
) = SMB_STRDUP(src
);
861 if ((*dest
) == NULL
) {
862 DEBUG(0,("Out of memory in string_init\n"));
873 void string_free(char **s
)
877 if (*s
== null_string
)
883 Set a string value, deallocating any existing space, and allocing the space
887 bool string_set(char **dest
,const char *src
)
890 return(string_init(dest
,src
));
894 Substitute a string for a pattern in another string. Make sure there is
897 This routine looks for pattern in s and replaces it with
898 insert. It may do multiple replacements or just one.
900 Any of " ; ' $ or ` in the insert string are replaced with _
901 if len==0 then the string cannot be extended. This is different from the old
902 use of len==0 which was for no length checks to be done.
905 void string_sub2(char *s
,const char *pattern
, const char *insert
, size_t len
,
906 bool remove_unsafe_characters
, bool replace_once
,
907 bool allow_trailing_dollar
)
912 if (!insert
|| !pattern
|| !*pattern
|| !s
)
915 ls
= (ssize_t
)strlen(s
);
916 lp
= (ssize_t
)strlen(pattern
);
917 li
= (ssize_t
)strlen(insert
);
920 len
= ls
+ 1; /* len is number of *bytes* */
922 while (lp
<= ls
&& (p
= strstr_m(s
,pattern
))) {
923 if (ls
+ (li
-lp
) >= len
) {
924 DEBUG(0,("ERROR: string overflow by "
925 "%d in string_sub(%.50s, %d)\n",
926 (int)(ls
+ (li
-lp
) - len
),
931 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
940 /* allow a trailing $
941 * (as in machine accounts) */
942 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
949 if ( remove_unsafe_characters
) {
951 /* yes this break should be here
952 * since we want to fall throw if
953 * not replacing unsafe chars */
968 void string_sub_once(char *s
, const char *pattern
,
969 const char *insert
, size_t len
)
971 string_sub2( s
, pattern
, insert
, len
, true, true, false );
974 void string_sub(char *s
,const char *pattern
, const char *insert
, size_t len
)
976 string_sub2( s
, pattern
, insert
, len
, true, false, false );
979 void fstring_sub(char *s
,const char *pattern
,const char *insert
)
981 string_sub(s
, pattern
, insert
, sizeof(fstring
));
985 Similar to string_sub2, but it will accept only allocated strings
986 and may realloc them so pay attention at what you pass on no
987 pointers inside strings, no const may be passed
991 char *realloc_string_sub2(char *string
,
994 bool remove_unsafe_characters
,
995 bool allow_trailing_dollar
)
999 ssize_t ls
,lp
,li
,ld
, i
;
1001 if (!insert
|| !pattern
|| !*pattern
|| !string
|| !*string
)
1006 in
= SMB_STRDUP(insert
);
1008 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1011 ls
= (ssize_t
)strlen(s
);
1012 lp
= (ssize_t
)strlen(pattern
);
1013 li
= (ssize_t
)strlen(insert
);
1015 for (i
=0;i
<li
;i
++) {
1022 /* allow a trailing $
1023 * (as in machine accounts) */
1024 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
1030 if ( remove_unsafe_characters
) {
1040 while ((p
= strstr_m(s
,pattern
))) {
1042 int offset
= PTR_DIFF(s
,string
);
1043 string
= (char *)SMB_REALLOC(string
, ls
+ ld
+ 1);
1045 DEBUG(0, ("realloc_string_sub: "
1046 "out of memory!\n"));
1050 p
= string
+ offset
+ (p
- s
);
1053 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1063 char *realloc_string_sub(char *string
,
1064 const char *pattern
,
1067 return realloc_string_sub2(string
, pattern
, insert
, true, false);
1071 * Internal guts of talloc_string_sub and talloc_all_string_sub.
1072 * talloc version of string_sub2.
1075 char *talloc_string_sub2(TALLOC_CTX
*mem_ctx
, const char *src
,
1076 const char *pattern
,
1078 bool remove_unsafe_characters
,
1080 bool allow_trailing_dollar
)
1085 ssize_t ls
,lp
,li
,ld
, i
;
1087 if (!insert
|| !pattern
|| !*pattern
|| !src
) {
1091 string
= talloc_strdup(mem_ctx
, src
);
1092 if (string
== NULL
) {
1093 DEBUG(0, ("talloc_string_sub2: "
1094 "talloc_strdup failed\n"));
1100 in
= SMB_STRDUP(insert
);
1102 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
1105 ls
= (ssize_t
)strlen(s
);
1106 lp
= (ssize_t
)strlen(pattern
);
1107 li
= (ssize_t
)strlen(insert
);
1110 for (i
=0;i
<li
;i
++) {
1117 /* allow a trailing $
1118 * (as in machine accounts) */
1119 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
1125 if (remove_unsafe_characters
) {
1135 while ((p
= strstr_m(s
,pattern
))) {
1137 int offset
= PTR_DIFF(s
,string
);
1138 string
= (char *)TALLOC_REALLOC(mem_ctx
, string
,
1141 DEBUG(0, ("talloc_string_sub: out of "
1146 p
= string
+ offset
+ (p
- s
);
1149 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1163 /* Same as string_sub, but returns a talloc'ed string */
1165 char *talloc_string_sub(TALLOC_CTX
*mem_ctx
,
1167 const char *pattern
,
1170 return talloc_string_sub2(mem_ctx
, src
, pattern
, insert
,
1171 true, false, false);
1175 Similar to string_sub() but allows for any character to be substituted.
1177 if len==0 then the string cannot be extended. This is different from the old
1178 use of len==0 which was for no length checks to be done.
1181 void all_string_sub(char *s
,const char *pattern
,const char *insert
, size_t len
)
1186 if (!insert
|| !pattern
|| !s
)
1189 ls
= (ssize_t
)strlen(s
);
1190 lp
= (ssize_t
)strlen(pattern
);
1191 li
= (ssize_t
)strlen(insert
);
1197 len
= ls
+ 1; /* len is number of *bytes* */
1199 while (lp
<= ls
&& (p
= strstr_m(s
,pattern
))) {
1200 if (ls
+ (li
-lp
) >= len
) {
1201 DEBUG(0,("ERROR: string overflow by "
1202 "%d in all_string_sub(%.50s, %d)\n",
1203 (int)(ls
+ (li
-lp
) - len
),
1204 pattern
, (int)len
));
1208 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
1210 memcpy(p
, insert
, li
);
1216 char *talloc_all_string_sub(TALLOC_CTX
*ctx
,
1218 const char *pattern
,
1221 return talloc_string_sub2(ctx
, src
, pattern
, insert
,
1222 false, false, false);
1226 Write an octal as a string.
1229 char *octal_string(int i
)
1233 result
= talloc_strdup(talloc_tos(), "-1");
1236 result
= talloc_asprintf(talloc_tos(), "0%o", i
);
1238 SMB_ASSERT(result
!= NULL
);
1244 Truncate a string at a specified length.
1247 char *string_truncate(char *s
, unsigned int length
)
1249 if (s
&& strlen(s
) > length
)
1255 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1256 We convert via ucs2 for now.
1259 char *strchr_m(const char *src
, char c
)
1261 smb_ucs2_t
*ws
= NULL
;
1266 size_t converted_size
;
1268 /* characters below 0x3F are guaranteed to not appear in
1269 non-initial position in multi-byte charsets */
1270 if ((c
& 0xC0) == 0) {
1271 return strchr(src
, c
);
1274 /* this is quite a common operation, so we want it to be
1275 fast. We optimise for the ascii case, knowing that all our
1276 supported multi-byte character sets are ascii-compatible
1277 (ie. they match for the first 128 chars) */
1279 for (s
= src
; *s
&& !(((unsigned char)s
[0]) & 0x80); s
++) {
1287 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1288 /* With compose characters we must restart from the beginning. JRA. */
1292 if (!push_ucs2_allocate(&ws
, s
, &converted_size
)) {
1293 /* Wrong answer, but what can we do... */
1294 return strchr(src
, c
);
1296 p
= strchr_w(ws
, UCS2_CHAR(c
));
1302 if (!pull_ucs2_allocate(&s2
, ws
, &converted_size
)) {
1304 /* Wrong answer, but what can we do... */
1305 return strchr(src
, c
);
1307 ret
= (char *)(s
+strlen(s2
));
1313 char *strrchr_m(const char *s
, char c
)
1315 /* characters below 0x3F are guaranteed to not appear in
1316 non-initial position in multi-byte charsets */
1317 if ((c
& 0xC0) == 0) {
1318 return strrchr(s
, c
);
1321 /* this is quite a common operation, so we want it to be
1322 fast. We optimise for the ascii case, knowing that all our
1323 supported multi-byte character sets are ascii-compatible
1324 (ie. they match for the first 128 chars). Also, in Samba
1325 we only search for ascii characters in 'c' and that
1326 in all mb character sets with a compound character
1327 containing c, if 'c' is not a match at position
1328 p, then p[-1] > 0x7f. JRA. */
1331 size_t len
= strlen(s
);
1333 bool got_mb
= false;
1340 /* Could be a match. Part of a multibyte ? */
1342 (((unsigned char)cp
[-1]) & 0x80)) {
1343 /* Yep - go slow :-( */
1347 /* No - we have a match ! */
1350 } while (cp
-- != s
);
1355 /* String contained a non-ascii char. Slow path. */
1357 smb_ucs2_t
*ws
= NULL
;
1361 size_t converted_size
;
1363 if (!push_ucs2_allocate(&ws
, s
, &converted_size
)) {
1364 /* Wrong answer, but what can we do. */
1365 return strrchr(s
, c
);
1367 p
= strrchr_w(ws
, UCS2_CHAR(c
));
1373 if (!pull_ucs2_allocate(&s2
, ws
, &converted_size
)) {
1375 /* Wrong answer, but what can we do. */
1376 return strrchr(s
, c
);
1378 ret
= (char *)(s
+strlen(s2
));
1385 /***********************************************************************
1386 Return the equivalent of doing strrchr 'n' times - always going
1388 ***********************************************************************/
1390 char *strnrchr_m(const char *s
, char c
, unsigned int n
)
1392 smb_ucs2_t
*ws
= NULL
;
1396 size_t converted_size
;
1398 if (!push_ucs2_allocate(&ws
, s
, &converted_size
)) {
1399 /* Too hard to try and get right. */
1402 p
= strnrchr_w(ws
, UCS2_CHAR(c
), n
);
1408 if (!pull_ucs2_allocate(&s2
, ws
, &converted_size
)) {
1410 /* Too hard to try and get right. */
1413 ret
= (char *)(s
+strlen(s2
));
1419 /***********************************************************************
1420 strstr_m - We convert via ucs2 for now.
1421 ***********************************************************************/
1423 char *strstr_m(const char *src
, const char *findstr
)
1426 smb_ucs2_t
*src_w
, *find_w
;
1431 size_t converted_size
, findstr_len
= 0;
1433 /* for correctness */
1438 /* Samba does single character findstr calls a *lot*. */
1439 if (findstr
[1] == '\0')
1440 return strchr_m(src
, *findstr
);
1442 /* We optimise for the ascii case, knowing that all our
1443 supported multi-byte character sets are ascii-compatible
1444 (ie. they match for the first 128 chars) */
1446 for (s
= src
; *s
&& !(((unsigned char)s
[0]) & 0x80); s
++) {
1447 if (*s
== *findstr
) {
1449 findstr_len
= strlen(findstr
);
1451 if (strncmp(s
, findstr
, findstr_len
) == 0) {
1460 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1461 /* 'make check' fails unless we do this */
1463 /* With compose characters we must restart from the beginning. JRA. */
1467 if (!push_ucs2_allocate(&src_w
, src
, &converted_size
)) {
1468 DEBUG(0,("strstr_m: src malloc fail\n"));
1472 if (!push_ucs2_allocate(&find_w
, findstr
, &converted_size
)) {
1474 DEBUG(0,("strstr_m: find malloc fail\n"));
1478 p
= strstr_w(src_w
, find_w
);
1487 if (!pull_ucs2_allocate(&s2
, src_w
, &converted_size
)) {
1490 DEBUG(0,("strstr_m: dest malloc fail\n"));
1493 retp
= (char *)(s
+strlen(s2
));
1501 Convert a string to lower case.
1504 void strlower_m(char *s
)
1509 /* this is quite a common operation, so we want it to be
1510 fast. We optimise for the ascii case, knowing that all our
1511 supported multi-byte character sets are ascii-compatible
1512 (ie. they match for the first 128 chars) */
1514 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
1515 *s
= tolower_ascii((unsigned char)*s
);
1522 /* I assume that lowercased string takes the same number of bytes
1523 * as source string even in UTF-8 encoding. (VIV) */
1524 len
= strlen(s
) + 1;
1527 unix_strlower(s
,len
,s
,len
);
1528 /* Catch mb conversion errors that may not terminate. */
1535 Convert a string to upper case.
1538 void strupper_m(char *s
)
1543 /* this is quite a common operation, so we want it to be
1544 fast. We optimise for the ascii case, knowing that all our
1545 supported multi-byte character sets are ascii-compatible
1546 (ie. they match for the first 128 chars) */
1548 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
1549 *s
= toupper_ascii_fast((unsigned char)*s
);
1556 /* I assume that lowercased string takes the same number of bytes
1557 * as source string even in multibyte encoding. (VIV) */
1558 len
= strlen(s
) + 1;
1561 unix_strupper(s
,len
,s
,len
);
1562 /* Catch mb conversion errors that may not terminate. */
1569 Count the number of UCS2 characters in a string. Normally this will
1570 be the same as the number of bytes in a string for single byte strings,
1571 but will be different for multibyte.
1574 size_t strlen_m(const char *s
)
1582 while (*s
&& !(((uint8_t)*s
) & 0x80)) {
1593 codepoint_t c
= next_codepoint(s
, &c_size
);
1595 /* Unicode char fits into 16 bits. */
1598 /* Double-width unicode char - 32 bits. */
1608 Count the number of UCS2 characters in a string including the null
1612 size_t strlen_m_term(const char *s
)
1617 return strlen_m(s
) + 1;
1621 * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1622 * if a string is there, include the terminator.
1625 size_t strlen_m_term_null(const char *s
)
1639 Return a RFC2254 binary string representation of a buffer.
1640 Used in LDAP filters.
1644 char *binary_string_rfc2254(char *buf
, int len
)
1648 const char *hex
= "0123456789ABCDEF";
1649 s
= (char *)SMB_MALLOC(len
* 3 + 1);
1652 for (j
=i
=0;i
<len
;i
++) {
1654 s
[j
+1] = hex
[((unsigned char)buf
[i
]) >> 4];
1655 s
[j
+2] = hex
[((unsigned char)buf
[i
]) & 0xF];
1662 char *binary_string(char *buf
, int len
)
1666 const char *hex
= "0123456789ABCDEF";
1667 s
= (char *)SMB_MALLOC(len
* 2 + 1);
1670 for (j
=i
=0;i
<len
;i
++) {
1671 s
[j
] = hex
[((unsigned char)buf
[i
]) >> 4];
1672 s
[j
+1] = hex
[((unsigned char)buf
[i
]) & 0xF];
1680 Just a typesafety wrapper for snprintf into a fstring.
1683 int fstr_sprintf(fstring s
, const char *fmt
, ...)
1689 ret
= vsnprintf(s
, FSTRING_LEN
, fmt
, ap
);
1695 List of Strings manipulation functions
1698 #define S_LIST_ABS 16 /* List Allocation Block Size */
1700 /******************************************************************************
1701 version of standard_sub_basic() for string lists; uses talloc_sub_basic()
1703 *****************************************************************************/
1705 bool str_list_sub_basic( char **list
, const char *smb_name
,
1706 const char *domain_name
)
1708 TALLOC_CTX
*ctx
= list
;
1713 tmpstr
= talloc_sub_basic(ctx
, smb_name
, domain_name
, s
);
1715 DEBUG(0,("str_list_sub_basic: "
1716 "alloc_sub_basic() return NULL!\n"));
1729 /******************************************************************************
1730 substritute a specific pattern in a string list
1731 *****************************************************************************/
1733 bool str_list_substitute(char **list
, const char *pattern
, const char *insert
)
1735 TALLOC_CTX
*ctx
= list
;
1737 ssize_t ls
, lp
, li
, ld
, i
, d
;
1746 lp
= (ssize_t
)strlen(pattern
);
1747 li
= (ssize_t
)strlen(insert
);
1752 ls
= (ssize_t
)strlen(s
);
1754 while ((p
= strstr_m(s
, pattern
))) {
1758 t
= TALLOC_ARRAY(ctx
, char, ls
+ld
+1);
1760 DEBUG(0,("str_list_substitute: "
1761 "Unable to allocate memory"));
1764 memcpy(t
, *list
, d
);
1765 memcpy(t
+d
+li
, p
+lp
, ls
-d
-lp
+1);
1772 for (i
= 0; i
< li
; i
++) {
1773 switch (insert
[i
]) {
1785 t
[d
+i
] = insert
[i
];
1797 #define IPSTR_LIST_SEP ","
1798 #define IPSTR_LIST_CHAR ','
1801 * Add ip string representation to ipstr list. Used also
1802 * as part of @function ipstr_list_make
1804 * @param ipstr_list pointer to string containing ip list;
1805 * MUST BE already allocated and IS reallocated if necessary
1806 * @param ipstr_size pointer to current size of ipstr_list (might be changed
1807 * as a result of reallocation)
1808 * @param ip IP address which is to be added to list
1809 * @return pointer to string appended with new ip and possibly
1810 * reallocated to new length
1813 static char *ipstr_list_add(char **ipstr_list
, const struct ip_service
*service
)
1815 char *new_ipstr
= NULL
;
1816 char addr_buf
[INET6_ADDRSTRLEN
];
1819 /* arguments checking */
1820 if (!ipstr_list
|| !service
) {
1824 print_sockaddr(addr_buf
,
1828 /* attempt to convert ip to a string and append colon separator to it */
1830 if (service
->ss
.ss_family
== AF_INET
) {
1832 ret
= asprintf(&new_ipstr
, "%s%s%s:%d", *ipstr_list
,
1833 IPSTR_LIST_SEP
, addr_buf
,
1837 ret
= asprintf(&new_ipstr
, "%s%s[%s]:%d", *ipstr_list
,
1838 IPSTR_LIST_SEP
, addr_buf
,
1841 SAFE_FREE(*ipstr_list
);
1843 if (service
->ss
.ss_family
== AF_INET
) {
1845 ret
= asprintf(&new_ipstr
, "%s:%d", addr_buf
,
1849 ret
= asprintf(&new_ipstr
, "[%s]:%d", addr_buf
,
1856 *ipstr_list
= new_ipstr
;
1861 * Allocate and initialise an ipstr list using ip adresses
1862 * passed as arguments.
1864 * @param ipstr_list pointer to string meant to be allocated and set
1865 * @param ip_list array of ip addresses to place in the list
1866 * @param ip_count number of addresses stored in ip_list
1867 * @return pointer to allocated ip string
1870 char *ipstr_list_make(char **ipstr_list
,
1871 const struct ip_service
*ip_list
,
1876 /* arguments checking */
1877 if (!ip_list
|| !ipstr_list
) {
1883 /* process ip addresses given as arguments */
1884 for (i
= 0; i
< ip_count
; i
++) {
1885 *ipstr_list
= ipstr_list_add(ipstr_list
, &ip_list
[i
]);
1888 return (*ipstr_list
);
1893 * Parse given ip string list into array of ip addresses
1894 * (as ip_service structures)
1895 * e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
1897 * @param ipstr ip string list to be parsed
1898 * @param ip_list pointer to array of ip addresses which is
1899 * allocated by this function and must be freed by caller
1900 * @return number of successfully parsed addresses
1903 int ipstr_list_parse(const char *ipstr_list
, struct ip_service
**ip_list
)
1906 char *token_str
= NULL
;
1910 if (!ipstr_list
|| !ip_list
)
1913 count
= count_chars(ipstr_list
, IPSTR_LIST_CHAR
) + 1;
1914 if ( (*ip_list
= SMB_MALLOC_ARRAY(struct ip_service
, count
)) == NULL
) {
1915 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
1916 (unsigned long)count
));
1920 frame
= talloc_stackframe();
1921 for ( i
=0; next_token_talloc(frame
, &ipstr_list
, &token_str
,
1922 IPSTR_LIST_SEP
) && i
<count
; i
++ ) {
1923 char *s
= token_str
;
1924 char *p
= strrchr(token_str
, ':');
1928 (*ip_list
)[i
].port
= atoi(p
+1);
1931 /* convert single token to ip address */
1932 if (token_str
[0] == '[') {
1935 p
= strchr(token_str
, ']');
1941 if (!interpret_string_addr(&(*ip_list
)[i
].ss
,
1952 * Safely free ip string list
1954 * @param ipstr_list ip string list to be freed
1957 void ipstr_list_free(char* ipstr_list
)
1959 SAFE_FREE(ipstr_list
);
1962 static const char b64
[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1965 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1967 DATA_BLOB
base64_decode_data_blob(const char *s
)
1969 int bit_offset
, byte_offset
, idx
, i
, n
;
1970 DATA_BLOB decoded
= data_blob(s
, strlen(s
)+1);
1971 unsigned char *d
= decoded
.data
;
1976 while (*s
&& (p
=strchr_m(b64
,*s
))) {
1977 idx
= (int)(p
- b64
);
1978 byte_offset
= (i
*6)/8;
1979 bit_offset
= (i
*6)%8;
1980 d
[byte_offset
] &= ~((1<<(8-bit_offset
))-1);
1981 if (bit_offset
< 3) {
1982 d
[byte_offset
] |= (idx
<< (2-bit_offset
));
1985 d
[byte_offset
] |= (idx
>> (bit_offset
-2));
1986 d
[byte_offset
+1] = 0;
1987 d
[byte_offset
+1] |= (idx
<< (8-(bit_offset
-2))) & 0xFF;
1993 if ((n
> 0) && (*s
== '=')) {
2003 * Decode a base64 string in-place - wrapper for the above
2005 void base64_decode_inplace(char *s
)
2007 DATA_BLOB decoded
= base64_decode_data_blob(s
);
2009 if ( decoded
.length
!= 0 ) {
2010 memcpy(s
, decoded
.data
, decoded
.length
);
2012 /* null terminate */
2013 s
[decoded
.length
] = '\0';
2018 data_blob_free(&decoded
);
2022 * Encode a base64 string into a talloc()ed string caller to free.
2024 * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
2028 char *base64_encode_data_blob(TALLOC_CTX
*mem_ctx
, DATA_BLOB data
)
2032 size_t out_cnt
, len
, output_len
;
2035 if (!data
.length
|| !data
.data
)
2040 output_len
= data
.length
* 2 + 4; /* Account for closing bytes. 4 is
2041 * random but should be enough for
2043 result
= TALLOC_ARRAY(mem_ctx
, char, output_len
); /* get us plenty of space */
2044 SMB_ASSERT(result
!= NULL
);
2046 while (len
-- && out_cnt
< (data
.length
* 2) - 5) {
2047 int c
= (unsigned char) *(data
.data
++);
2050 if (char_count
== 3) {
2051 result
[out_cnt
++] = b64
[bits
>> 18];
2052 result
[out_cnt
++] = b64
[(bits
>> 12) & 0x3f];
2053 result
[out_cnt
++] = b64
[(bits
>> 6) & 0x3f];
2054 result
[out_cnt
++] = b64
[bits
& 0x3f];
2061 if (char_count
!= 0) {
2062 bits
<<= 16 - (8 * char_count
);
2063 result
[out_cnt
++] = b64
[bits
>> 18];
2064 result
[out_cnt
++] = b64
[(bits
>> 12) & 0x3f];
2065 if (char_count
== 1) {
2066 result
[out_cnt
++] = '=';
2067 result
[out_cnt
++] = '=';
2069 result
[out_cnt
++] = b64
[(bits
>> 6) & 0x3f];
2070 result
[out_cnt
++] = '=';
2073 result
[out_cnt
] = '\0'; /* terminate */
2077 /* read a SMB_BIG_UINT from a string */
2078 uint64_t STR_TO_SMB_BIG_UINT(const char *nptr
, const char **entptr
)
2082 const char *p
= nptr
;
2091 while (*p
&& isspace(*p
))
2094 sscanf(p
,"%"PRIu64
,&val
);
2096 while (*p
&& isdigit(*p
))
2104 /* Convert a size specification to a count of bytes. We accept the following
2106 * bytes if there is no suffix
2111 * pP whatever the ISO name for petabytes is
2113 * Returns 0 if the string can't be converted.
2115 SMB_OFF_T
conv_str_size(const char * str
)
2120 if (str
== NULL
|| *str
== '\0') {
2124 #ifdef HAVE_STRTOULL
2125 if (sizeof(SMB_OFF_T
) == 8) {
2126 lval
= strtoull(str
, &end
, 10 /* base */);
2128 lval
= strtoul(str
, &end
, 10 /* base */);
2131 lval
= strtoul(str
, &end
, 10 /* base */);
2134 if (end
== NULL
|| end
== str
) {
2139 SMB_OFF_T lval_orig
= lval
;
2141 if (strwicmp(end
, "K") == 0) {
2142 lval
*= (SMB_OFF_T
)1024;
2143 } else if (strwicmp(end
, "M") == 0) {
2144 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024);
2145 } else if (strwicmp(end
, "G") == 0) {
2146 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2148 } else if (strwicmp(end
, "T") == 0) {
2149 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2150 (SMB_OFF_T
)1024 * (SMB_OFF_T
)1024);
2151 } else if (strwicmp(end
, "P") == 0) {
2152 lval
*= ((SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2153 (SMB_OFF_T
)1024 * (SMB_OFF_T
)1024 *
2159 /* Primitive attempt to detect wrapping on platforms with
2160 * 4-byte SMB_OFF_T. It's better to let the caller handle
2161 * a failure than some random number.
2163 if (lval_orig
<= lval
) {
2171 void string_append(char **left
, const char *right
)
2173 int new_len
= strlen(right
) + 1;
2175 if (*left
== NULL
) {
2176 *left
= (char *)SMB_MALLOC(new_len
);
2179 new_len
+= strlen(*left
);
2180 *left
= (char *)SMB_REALLOC(*left
, new_len
);
2183 if (*left
== NULL
) {
2187 safe_strcat(*left
, right
, new_len
-1);
2190 bool add_string_to_array(TALLOC_CTX
*mem_ctx
,
2191 const char *str
, const char ***strings
,
2194 char *dup_str
= talloc_strdup(mem_ctx
, str
);
2196 *strings
= TALLOC_REALLOC_ARRAY(mem_ctx
, *strings
,
2197 const char *, (*num
)+1);
2199 if ((*strings
== NULL
) || (dup_str
== NULL
)) {
2204 (*strings
)[*num
] = dup_str
;
2209 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2210 * error checking in between. The indiation that something weird happened is
2213 void sprintf_append(TALLOC_CTX
*mem_ctx
, char **string
, ssize_t
*len
,
2214 size_t *bufsize
, const char *fmt
, ...)
2221 /* len<0 is an internal marker that something failed */
2225 if (*string
== NULL
) {
2229 *string
= TALLOC_ARRAY(mem_ctx
, char, *bufsize
);
2230 if (*string
== NULL
)
2235 ret
= vasprintf(&newstr
, fmt
, ap
);
2243 while ((*len
)+ret
>= *bufsize
) {
2246 if (*bufsize
>= (1024*1024*256))
2251 *string
= TALLOC_REALLOC_ARRAY(mem_ctx
, *string
, char,
2253 if (*string
== NULL
) {
2258 StrnCpy((*string
)+(*len
), newstr
, ret
);
2269 * asprintf into a string and strupper_m it after that.
2272 int asprintf_strupper_m(char **strp
, const char *fmt
, ...)
2279 ret
= vasprintf(&result
, fmt
, ap
);
2290 char *talloc_asprintf_strupper_m(TALLOC_CTX
*t
, const char *fmt
, ...)
2296 ret
= talloc_vasprintf(t
, fmt
, ap
);
2306 char *talloc_asprintf_strlower_m(TALLOC_CTX
*t
, const char *fmt
, ...)
2312 ret
= talloc_vasprintf(t
, fmt
, ap
);
2324 Returns the substring from src between the first occurrence of
2325 the char "front" and the first occurence of the char "back".
2326 Mallocs the return string which must be freed. Not for use
2327 with wide character strings.
2329 char *sstring_sub(const char *src
, char front
, char back
)
2331 char *temp1
, *temp2
, *temp3
;
2334 temp1
= strchr(src
, front
);
2335 if (temp1
== NULL
) return NULL
;
2336 temp2
= strchr(src
, back
);
2337 if (temp2
== NULL
) return NULL
;
2338 len
= temp2
- temp1
;
2339 if (len
<= 0) return NULL
;
2340 temp3
= (char*)SMB_MALLOC(len
);
2341 if (temp3
== NULL
) {
2342 DEBUG(1,("Malloc failure in sstring_sub\n"));
2345 memcpy(temp3
, temp1
+1, len
-1);
2346 temp3
[len
-1] = '\0';
2350 /********************************************************************
2351 Check a string for any occurrences of a specified list of invalid
2353 ********************************************************************/
2355 bool validate_net_name( const char *name
,
2356 const char *invalid_chars
,
2361 for ( i
=0; i
<max_len
&& name
[i
]; i
++ ) {
2362 /* fail if strchr_m() finds one of the invalid characters */
2363 if ( name
[i
] && strchr_m( invalid_chars
, name
[i
] ) ) {
2372 /*******************************************************************
2373 Add a shell escape character '\' to any character not in a known list
2374 of characters. UNIX charset format.
2375 *******************************************************************/
2377 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
2378 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
2380 char *escape_shell_string(const char *src
)
2382 size_t srclen
= strlen(src
);
2383 char *ret
= SMB_MALLOC_ARRAY(char, (srclen
* 2) + 1);
2385 bool in_s_quote
= false;
2386 bool in_d_quote
= false;
2387 bool next_escaped
= false;
2395 codepoint_t c
= next_codepoint(src
, &c_size
);
2397 if (c
== INVALID_CODEPOINT
) {
2403 memcpy(dest
, src
, c_size
);
2406 next_escaped
= false;
2411 * Deal with backslash escaped state.
2412 * This only lasts for one character.
2417 next_escaped
= false;
2422 * Deal with single quote state. The
2423 * only thing we care about is exiting
2436 * Deal with double quote state. The most
2437 * complex state. We must cope with \, meaning
2438 * possibly escape next char (depending what it
2439 * is), ", meaning exit this state, and possibly
2440 * add an \ escape to any unprotected character
2441 * (listed in INSIDE_DQUOTE_LIST).
2447 * Next character might be escaped.
2448 * We have to peek. Inside double
2449 * quotes only INSIDE_DQUOTE_LIST
2450 * characters are escaped by a \.
2455 c
= next_codepoint(&src
[1], &c_size
);
2456 if (c
== INVALID_CODEPOINT
) {
2462 * Don't escape the next char.
2471 if (nextchar
&& strchr(INSIDE_DQUOTE_LIST
,
2473 next_escaped
= true;
2480 /* Exit double quote state. */
2487 * We know the character isn't \ or ",
2488 * so escape it if it's any of the other
2489 * possible unprotected characters.
2492 if (strchr(INSIDE_DQUOTE_LIST
, (int)*src
)) {
2500 * From here to the end of the loop we're
2501 * not in the single or double quote state.
2505 /* Next character must be escaped. */
2506 next_escaped
= true;
2512 /* Go into single quote state. */
2519 /* Go into double quote state. */
2525 /* Check if we need to escape the character. */
2527 if (!strchr(INCLUDE_LIST
, (int)*src
)) {
2536 /***************************************************
2537 Wrapper for str_list_make() to restore the s3 behavior.
2538 In samba 3.2 passing NULL or an empty string returned NULL.
2540 In master, it now returns a list of length 1 with the first string set
2541 to NULL (an empty list)
2542 ***************************************************/
2544 char **str_list_make_v3(TALLOC_CTX
*mem_ctx
, const char *string
, const char *sep
)
2546 if (!string
|| !*string
) {
2549 return str_list_make(mem_ctx
, string
, sep
);