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/>.
26 #include "lib/param/loadparm.h"
28 static const char toupper_ascii_fast_table
[128] = {
29 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
30 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
31 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
32 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
33 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
34 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
35 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
36 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
40 * Compare 2 strings up to and including the nth char.
42 * @note The comparison is case-insensitive.
44 bool strnequal(const char *s1
,const char *s2
,size_t n
)
51 return(strncasecmp_m(s1
,s2
,n
)==0);
55 Convert a string to "normal" form.
58 bool strnorm(char *s
, int case_default
)
60 if (case_default
== CASE_UPPER
)
67 * Skip past some strings in a buffer - old version - no checks.
70 char *push_skip_string(char *buf
)
72 buf
+= strlen(buf
) + 1;
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.
82 char *skip_string(const char *base
, size_t len
, char *buf
)
84 const char *end_ptr
= base
+ len
;
86 if (end_ptr
< base
|| !base
|| !buf
|| buf
>= end_ptr
) {
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.
108 size_t str_charnum(const char *s
)
110 size_t ret
, converted_size
;
111 smb_ucs2_t
*tmpbuf2
= NULL
;
112 if (!push_ucs2_talloc(talloc_tos(), &tmpbuf2
, s
, &converted_size
)) {
115 ret
= strlen_w(tmpbuf2
);
116 TALLOC_FREE(tmpbuf2
);
120 bool trim_char(char *s
,char cfront
,char cback
)
126 /* Ignore null or empty strings. */
127 if (!s
|| (s
[0] == '\0'))
131 while (*fp
&& *fp
== cfront
)
134 /* We ate the string. */
142 ep
= fp
+ strlen(fp
) - 1;
144 /* Attempt ascii only. Bail for mb strings. */
145 while ((ep
>= fp
) && (*ep
== cback
)) {
147 if ((ep
> fp
) && (((unsigned char)ep
[-1]) & 0x80)) {
148 /* Could be mb... bail back to tim_string. */
156 return trim_string(s
, cfront
? fs
: NULL
, bs
);
162 /* We ate the string. */
169 memmove(s
, fp
, ep
-fp
+2);
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.
177 char *StrnCpy(char *dest
,const char *src
,size_t n
)
182 smb_panic("ERROR: NULL dest in StrnCpy");
190 while (n
-- && (*d
= *src
)) {
200 Check if a string is part of a list.
203 bool in_list(const char *s
, const char *list
, bool casesensitive
)
213 frame
= talloc_stackframe();
214 while (next_token_talloc(frame
, &list
, &tok
,LIST_SEP
)) {
216 if (strcmp(tok
,s
) == 0) {
221 if (strcasecmp_m(tok
,s
) == 0) {
232 * Internal guts of talloc_string_sub and talloc_all_string_sub.
233 * talloc version of string_sub2.
236 char *talloc_string_sub2(TALLOC_CTX
*mem_ctx
, const char *src
,
239 bool remove_unsafe_characters
,
241 bool allow_trailing_dollar
)
246 ssize_t ls
,lp
,li
,ld
, i
;
248 if (!insert
|| !pattern
|| !*pattern
|| !src
) {
252 string
= talloc_strdup(mem_ctx
, src
);
253 if (string
== NULL
) {
254 DEBUG(0, ("talloc_string_sub2: "
255 "talloc_strdup failed\n"));
261 in
= talloc_strdup(mem_ctx
, insert
);
263 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
266 ls
= (ssize_t
)strlen(s
);
267 lp
= (ssize_t
)strlen(pattern
);
268 li
= (ssize_t
)strlen(insert
);
274 /* allow a trailing $
275 * (as in machine accounts) */
276 if (allow_trailing_dollar
&& (i
== li
- 1 )) {
288 if (remove_unsafe_characters
) {
300 while ((p
= strstr_m(s
,pattern
))) {
302 int offset
= PTR_DIFF(s
,string
);
303 string
= (char *)TALLOC_REALLOC(mem_ctx
, string
,
306 DEBUG(0, ("talloc_string_sub: out of "
311 p
= string
+ offset
+ (p
- s
);
314 memmove(p
+li
,p
+lp
,strlen(p
+lp
)+1);
328 /* Same as string_sub, but returns a talloc'ed string */
330 char *talloc_string_sub(TALLOC_CTX
*mem_ctx
,
335 return talloc_string_sub2(mem_ctx
, src
, pattern
, insert
,
339 char *talloc_all_string_sub(TALLOC_CTX
*ctx
,
344 return talloc_string_sub2(ctx
, src
, pattern
, insert
,
345 false, false, false);
349 Write an octal as a string.
352 char *octal_string(int i
)
356 result
= talloc_strdup(talloc_tos(), "-1");
359 result
= talloc_asprintf(talloc_tos(), "0%o", i
);
361 SMB_ASSERT(result
!= NULL
);
367 Truncate a string at a specified length.
370 char *string_truncate(char *s
, unsigned int length
)
372 if (s
&& strlen(s
) > length
)
378 /***********************************************************************
379 Return the equivalent of doing strrchr 'n' times - always going
381 ***********************************************************************/
383 char *strnrchr_m(const char *s
, char c
, unsigned int n
)
385 smb_ucs2_t
*ws
= NULL
;
389 size_t converted_size
;
391 if (!push_ucs2_talloc(talloc_tos(), &ws
, s
, &converted_size
)) {
392 /* Too hard to try and get right. */
395 p
= strnrchr_w(ws
, UCS2_CHAR(c
), n
);
401 if (!pull_ucs2_talloc(talloc_tos(), &s2
, ws
, &converted_size
)) {
403 /* Too hard to try and get right. */
406 ret
= discard_const_p(char, (s
+strlen(s2
)));
412 static bool unix_strlower(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
415 smb_ucs2_t
*buffer
= NULL
;
418 if (!convert_string_talloc(talloc_tos(), CH_UNIX
, CH_UTF16LE
, src
, srclen
,
419 (void **)(void *)&buffer
, &size
))
423 if (!strlower_w(buffer
) && (dest
== src
)) {
427 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, &size
);
432 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
435 Convert a string to lower case.
437 _PUBLIC_
void strlower_m(char *s
)
440 struct smb_iconv_handle
*iconv_handle
;
442 iconv_handle
= get_iconv_handle();
447 size_t c_size
, c_size2
;
448 codepoint_t c
= next_codepoint_handle(iconv_handle
, s
, &c_size
);
449 c_size2
= push_codepoint_handle(iconv_handle
, d
, tolower_m(c
));
450 if (c_size2
> c_size
) {
451 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
452 c
, tolower_m(c
), (int)c_size
, (int)c_size2
));
453 smb_panic("codepoint expansion in strlower_m\n");
464 Convert a string to lower case.
467 bool strlower_m(char *s
)
473 /* this is quite a common operation, so we want it to be
474 fast. We optimise for the ascii case, knowing that all our
475 supported multi-byte character sets are ascii-compatible
476 (ie. they match for the first 128 chars) */
478 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
479 *s
= tolower_m((unsigned char)*s
);
486 /* I assume that lowercased string takes the same number of bytes
487 * as source string even in UTF-8 encoding. (VIV) */
491 ret
= unix_strlower(s
,len
,s
,len
);
492 /* Catch mb conversion errors that may not terminate. */
500 static bool unix_strupper(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
506 if (!push_ucs2_talloc(talloc_tos(), &buffer
, src
, &size
)) {
510 if (!strupper_w(buffer
) && (dest
== src
)) {
515 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, &size
);
520 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
523 Convert a string to UPPER case.
525 _PUBLIC_
void strupper_m(char *s
)
528 struct smb_iconv_handle
*iconv_handle
;
530 iconv_handle
= get_iconv_handle();
535 size_t c_size
, c_size2
;
536 codepoint_t c
= next_codepoint_handle(iconv_handle
, s
, &c_size
);
537 c_size2
= push_codepoint_handle(iconv_handle
, d
, toupper_m(c
));
538 if (c_size2
> c_size
) {
539 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
540 c
, toupper_m(c
), (int)c_size
, (int)c_size2
));
541 smb_panic("codepoint expansion in strupper_m\n");
552 Convert a string to upper case.
555 bool strupper_m(char *s
)
560 /* this is quite a common operation, so we want it to be
561 fast. We optimise for the ascii case, knowing that all our
562 supported multi-byte character sets are ascii-compatible
563 (ie. they match for the first 128 chars) */
565 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
566 *s
= toupper_ascii_fast_table
[(unsigned char)s
[0]];
573 /* I assume that uppercased string takes the same number of bytes
574 * as source string even in multibyte encoding. (VIV) */
576 ret
= unix_strupper(s
,len
,s
,len
);
577 /* Catch mb conversion errors that may not terminate. */
585 Just a typesafety wrapper for snprintf into a fstring.
588 int fstr_sprintf(fstring s
, const char *fmt
, ...)
594 ret
= vsnprintf(s
, FSTRING_LEN
, fmt
, ap
);
600 List of Strings manipulation functions
603 #define S_LIST_ABS 16 /* List Allocation Block Size */
605 /******************************************************************************
606 substitute a specific pattern in a string list
607 *****************************************************************************/
609 bool str_list_substitute(char **list
, const char *pattern
, const char *insert
)
611 TALLOC_CTX
*ctx
= list
;
613 ssize_t ls
, lp
, li
, ld
, i
, d
;
622 lp
= (ssize_t
)strlen(pattern
);
623 li
= (ssize_t
)strlen(insert
);
628 ls
= (ssize_t
)strlen(s
);
630 while ((p
= strstr_m(s
, pattern
))) {
634 t
= talloc_array(ctx
, char, ls
+ld
+1);
636 DEBUG(0,("str_list_substitute: "
637 "Unable to allocate memory"));
641 memcpy(t
+d
+li
, p
+lp
, ls
-d
-lp
+1);
648 for (i
= 0; i
< li
; i
++) {
673 #define IPSTR_LIST_SEP ","
674 #define IPSTR_LIST_CHAR ','
677 * Add ip string representation to ipstr list. Used also
678 * as part of @function ipstr_list_make
680 * @param ipstr_list pointer to string containing ip list;
681 * MUST BE already allocated and IS reallocated if necessary
682 * @param ipstr_size pointer to current size of ipstr_list (might be changed
683 * as a result of reallocation)
684 * @param ip IP address which is to be added to list
685 * @return pointer to string appended with new ip and possibly
686 * reallocated to new length
689 static char *ipstr_list_add(char **ipstr_list
, const struct ip_service
*service
)
691 char *new_ipstr
= NULL
;
692 char addr_buf
[INET6_ADDRSTRLEN
];
695 /* arguments checking */
696 if (!ipstr_list
|| !service
) {
700 print_sockaddr(addr_buf
,
704 /* attempt to convert ip to a string and append colon separator to it */
706 if (service
->ss
.ss_family
== AF_INET
) {
708 ret
= asprintf(&new_ipstr
, "%s%s%s:%d", *ipstr_list
,
709 IPSTR_LIST_SEP
, addr_buf
,
713 ret
= asprintf(&new_ipstr
, "%s%s[%s]:%d", *ipstr_list
,
714 IPSTR_LIST_SEP
, addr_buf
,
717 SAFE_FREE(*ipstr_list
);
719 if (service
->ss
.ss_family
== AF_INET
) {
721 ret
= asprintf(&new_ipstr
, "%s:%d", addr_buf
,
725 ret
= asprintf(&new_ipstr
, "[%s]:%d", addr_buf
,
732 *ipstr_list
= new_ipstr
;
737 * Allocate and initialise an ipstr list using ip adresses
738 * passed as arguments.
740 * @param ipstr_list pointer to string meant to be allocated and set
741 * @param ip_list array of ip addresses to place in the list
742 * @param ip_count number of addresses stored in ip_list
743 * @return pointer to allocated ip string
746 char *ipstr_list_make(char **ipstr_list
,
747 const struct ip_service
*ip_list
,
752 /* arguments checking */
753 if (!ip_list
|| !ipstr_list
) {
759 /* process ip addresses given as arguments */
760 for (i
= 0; i
< ip_count
; i
++) {
761 *ipstr_list
= ipstr_list_add(ipstr_list
, &ip_list
[i
]);
764 return (*ipstr_list
);
769 * Parse given ip string list into array of ip addresses
770 * (as ip_service structures)
771 * e.g. [IPv6]:port,192.168.1.100:389,192.168.1.78, ...
773 * @param ipstr ip string list to be parsed
774 * @param ip_list pointer to array of ip addresses which is
775 * allocated by this function and must be freed by caller
776 * @return number of successfully parsed addresses
779 int ipstr_list_parse(const char *ipstr_list
, struct ip_service
**ip_list
)
782 char *token_str
= NULL
;
786 if (!ipstr_list
|| !ip_list
)
789 count
= count_chars(ipstr_list
, IPSTR_LIST_CHAR
) + 1;
790 if ( (*ip_list
= SMB_MALLOC_ARRAY(struct ip_service
, count
)) == NULL
) {
791 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
792 (unsigned long)count
));
796 frame
= talloc_stackframe();
797 for ( i
=0; next_token_talloc(frame
, &ipstr_list
, &token_str
,
798 IPSTR_LIST_SEP
) && i
<count
; i
++ ) {
800 char *p
= strrchr(token_str
, ':');
804 (*ip_list
)[i
].port
= atoi(p
+1);
807 /* convert single token to ip address */
808 if (token_str
[0] == '[') {
811 p
= strchr(token_str
, ']');
817 if (!interpret_string_addr(&(*ip_list
)[i
].ss
,
828 * Safely free ip string list
830 * @param ipstr_list ip string list to be freed
833 void ipstr_list_free(char* ipstr_list
)
835 SAFE_FREE(ipstr_list
);
838 /* read a SMB_BIG_UINT from a string */
839 uint64_t STR_TO_SMB_BIG_UINT(const char *nptr
, const char **entptr
)
842 uint64_t val
= (uint64_t)-1;
843 const char *p
= nptr
;
852 while (*p
&& isspace(*p
))
855 sscanf(p
,"%"SCNu64
,&val
);
857 while (*p
&& isdigit(*p
))
865 /* Convert a size specification to a count of bytes. We accept the following
867 * bytes if there is no suffix
872 * pP whatever the ISO name for petabytes is
874 * Returns 0 if the string can't be converted.
876 uint64_t conv_str_size(const char * str
)
881 if (str
== NULL
|| *str
== '\0') {
885 lval
= strtoull(str
, &end
, 10 /* base */);
887 if (end
== NULL
|| end
== str
) {
895 if (strwicmp(end
, "K") == 0) {
897 } else if (strwicmp(end
, "M") == 0) {
898 lval
*= (1024ULL * 1024ULL);
899 } else if (strwicmp(end
, "G") == 0) {
900 lval
*= (1024ULL * 1024ULL *
902 } else if (strwicmp(end
, "T") == 0) {
903 lval
*= (1024ULL * 1024ULL *
905 } else if (strwicmp(end
, "P") == 0) {
906 lval
*= (1024ULL * 1024ULL *
917 * asprintf into a string and strupper_m it after that.
920 int asprintf_strupper_m(char **strp
, const char *fmt
, ...)
927 ret
= vasprintf(&result
, fmt
, ap
);
933 if (!strupper_m(result
)) {
942 char *talloc_asprintf_strupper_m(TALLOC_CTX
*t
, const char *fmt
, ...)
948 ret
= talloc_vasprintf(t
, fmt
, ap
);
954 if (!strupper_m(ret
)) {
961 char *talloc_asprintf_strlower_m(TALLOC_CTX
*t
, const char *fmt
, ...)
967 ret
= talloc_vasprintf(t
, fmt
, ap
);
973 if (!strlower_m(ret
)) {
981 /********************************************************************
982 Check a string for any occurrences of a specified list of invalid
984 ********************************************************************/
986 bool validate_net_name( const char *name
,
987 const char *invalid_chars
,
996 for ( i
=0; i
<max_len
&& name
[i
]; i
++ ) {
997 /* fail if strchr_m() finds one of the invalid characters */
998 if ( name
[i
] && strchr_m( invalid_chars
, name
[i
] ) ) {
1007 /*******************************************************************
1008 Add a shell escape character '\' to any character not in a known list
1009 of characters. UNIX charset format.
1010 *******************************************************************/
1012 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
1013 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
1015 char *escape_shell_string(const char *src
)
1017 size_t srclen
= strlen(src
);
1018 char *ret
= SMB_MALLOC_ARRAY(char, (srclen
* 2) + 1);
1020 bool in_s_quote
= false;
1021 bool in_d_quote
= false;
1022 bool next_escaped
= false;
1030 codepoint_t c
= next_codepoint(src
, &c_size
);
1032 if (c
== INVALID_CODEPOINT
) {
1038 memcpy(dest
, src
, c_size
);
1041 next_escaped
= false;
1046 * Deal with backslash escaped state.
1047 * This only lasts for one character.
1052 next_escaped
= false;
1057 * Deal with single quote state. The
1058 * only thing we care about is exiting
1071 * Deal with double quote state. The most
1072 * complex state. We must cope with \, meaning
1073 * possibly escape next char (depending what it
1074 * is), ", meaning exit this state, and possibly
1075 * add an \ escape to any unprotected character
1076 * (listed in INSIDE_DQUOTE_LIST).
1082 * Next character might be escaped.
1083 * We have to peek. Inside double
1084 * quotes only INSIDE_DQUOTE_LIST
1085 * characters are escaped by a \.
1090 c
= next_codepoint(&src
[1], &c_size
);
1091 if (c
== INVALID_CODEPOINT
) {
1097 * Don't escape the next char.
1106 if (nextchar
&& strchr(INSIDE_DQUOTE_LIST
,
1108 next_escaped
= true;
1115 /* Exit double quote state. */
1122 * We know the character isn't \ or ",
1123 * so escape it if it's any of the other
1124 * possible unprotected characters.
1127 if (strchr(INSIDE_DQUOTE_LIST
, (int)*src
)) {
1135 * From here to the end of the loop we're
1136 * not in the single or double quote state.
1140 /* Next character must be escaped. */
1141 next_escaped
= true;
1147 /* Go into single quote state. */
1154 /* Go into double quote state. */
1160 /* Check if we need to escape the character. */
1162 if (!strchr(INCLUDE_LIST
, (int)*src
)) {
1172 * This routine improves performance for operations temporarily acting on a
1173 * full path. It is equivalent to the much more expensive
1175 * talloc_asprintf(talloc_tos(), "%s/%s", dir, name)
1177 * This actually does make a difference in metadata-heavy workloads (i.e. the
1178 * "standard" client.txt nbench run.
1181 ssize_t
full_path_tos(const char *dir
, const char *name
,
1182 char *tmpbuf
, size_t tmpbuf_len
,
1183 char **pdst
, char **to_free
)
1185 size_t dirlen
, namelen
, len
;
1188 dirlen
= strlen(dir
);
1189 namelen
= strlen(name
);
1190 len
= dirlen
+ namelen
+ 1;
1192 if (len
< tmpbuf_len
) {
1196 dst
= talloc_array(talloc_tos(), char, len
+1);
1203 memcpy(dst
, dir
, dirlen
);
1205 memcpy(dst
+dirlen
+1, name
, namelen
+1);