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 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)
64 return true; /* FIXME - return strlower_m value later. */
68 * Skip past some strings in a buffer - old version - no checks.
71 char *push_skip_string(char *buf)
73 buf += strlen(buf) + 1;
78 Skip past a string in a buffer. Buffer may not be
79 null terminated. end_ptr points to the first byte after
80 then end of the buffer.
83 char *skip_string(const char *base, size_t len, char *buf)
85 const char *end_ptr = base + len;
87 if (end_ptr < base || !base || !buf || buf >= end_ptr) {
104 Count the number of characters in a string. Normally this will
105 be the same as the number of bytes in a string for single byte strings,
106 but will be different for multibyte.
109 size_t str_charnum(const char *s)
111 size_t ret, converted_size;
112 smb_ucs2_t *tmpbuf2 = NULL;
113 if (!push_ucs2_talloc(talloc_tos(), &tmpbuf2, s, &converted_size)) {
116 ret = strlen_w(tmpbuf2);
117 TALLOC_FREE(tmpbuf2);
121 bool trim_char(char *s,char cfront,char cback)
127 /* Ignore null or empty strings. */
128 if (!s || (s[0] == '\0'))
132 while (*fp && *fp == cfront)
135 /* We ate the string. */
143 ep = fp + strlen(fp) - 1;
145 /* Attempt ascii only. Bail for mb strings. */
146 while ((ep >= fp) && (*ep == cback)) {
148 if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
149 /* Could be mb... bail back to tim_string. */
157 return trim_string(s, cfront ? fs : NULL, bs);
163 /* We ate the string. */
170 memmove(s, fp, ep-fp+2);
175 Like strncpy but always null terminates. Make sure there is room!
176 The variable n should always be one less than the available size.
178 char *StrnCpy(char *dest,const char *src,size_t n)
183 smb_panic("ERROR: NULL dest in StrnCpy");
191 while (n-- && (*d = *src)) {
201 Check if a string is part of a list.
204 bool in_list(const char *s, const char *list, bool casesensitive)
214 frame = talloc_stackframe();
215 while (next_token_talloc(frame, &list, &tok,LIST_SEP)) {
217 if (strcmp(tok,s) == 0) {
222 if (strcasecmp_m(tok,s) == 0) {
233 * Internal guts of talloc_string_sub and talloc_all_string_sub.
234 * talloc version of string_sub2.
237 char *talloc_string_sub2(TALLOC_CTX *mem_ctx, const char *src,
240 bool remove_unsafe_characters,
242 bool allow_trailing_dollar)
247 ssize_t ls,lp,li,ld, i;
249 if (!insert || !pattern || !*pattern || !src) {
253 string = talloc_strdup(mem_ctx, src);
254 if (string == NULL) {
255 DEBUG(0, ("talloc_string_sub2: "
256 "talloc_strdup failed\n"));
262 in = talloc_strdup(mem_ctx, insert);
264 DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
267 ls = (ssize_t)strlen(s);
268 lp = (ssize_t)strlen(pattern);
269 li = (ssize_t)strlen(insert);
275 /* allow a trailing $
276 * (as in machine accounts) */
277 if (allow_trailing_dollar && (i == li - 1 )) {
287 if (remove_unsafe_characters) {
297 while ((p = strstr_m(s,pattern))) {
299 int offset = PTR_DIFF(s,string);
300 string = (char *)TALLOC_REALLOC(mem_ctx, string,
303 DEBUG(0, ("talloc_string_sub: out of "
308 p = string + offset + (p - s);
311 memmove(p+li,p+lp,strlen(p+lp)+1);
325 /* Same as string_sub, but returns a talloc'ed string */
327 char *talloc_string_sub(TALLOC_CTX *mem_ctx,
332 return talloc_string_sub2(mem_ctx, src, pattern, insert,
336 char *talloc_all_string_sub(TALLOC_CTX *ctx,
341 return talloc_string_sub2(ctx, src, pattern, insert,
342 false, false, false);
346 Write an octal as a string.
349 char *octal_string(int i)
353 result = talloc_strdup(talloc_tos(), "-1");
356 result = talloc_asprintf(talloc_tos(), "0%o", i);
358 SMB_ASSERT(result != NULL);
364 Truncate a string at a specified length.
367 char *string_truncate(char *s, unsigned int length)
369 if (s && strlen(s) > length)
375 /***********************************************************************
376 Return the equivalent of doing strrchr 'n' times - always going
378 ***********************************************************************/
380 char *strnrchr_m(const char *s, char c, unsigned int n)
382 smb_ucs2_t *ws = NULL;
386 size_t converted_size;
388 if (!push_ucs2_talloc(talloc_tos(), &ws, s, &converted_size)) {
389 /* Too hard to try and get right. */
392 p = strnrchr_w(ws, UCS2_CHAR(c), n);
398 if (!pull_ucs2_talloc(talloc_tos(), &s2, ws, &converted_size)) {
400 /* Too hard to try and get right. */
403 ret = discard_const_p(char, (s+strlen(s2)));
409 static bool unix_strlower(const char *src, size_t srclen, char *dest, size_t destlen)
412 smb_ucs2_t *buffer = NULL;
415 if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF16LE, src, srclen,
416 (void **)(void *)&buffer, &size))
418 smb_panic("failed to create UCS2 buffer");
419 /* NOTREACHED. Yet. */
422 if (!strlower_w(buffer) && (dest == src)) {
426 ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
431 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
434 Convert a string to lower case.
436 _PUBLIC_ void strlower_m(char *s)
439 struct smb_iconv_handle *iconv_handle;
441 iconv_handle = get_iconv_handle();
446 size_t c_size, c_size2;
447 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
448 c_size2 = push_codepoint_handle(iconv_handle, d, tolower_m(c));
449 if (c_size2 > c_size) {
450 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
451 c, tolower_m(c), (int)c_size, (int)c_size2));
452 smb_panic("codepoint expansion in strlower_m\n");
463 Convert a string to lower case.
466 void strlower_m(char *s)
471 /* this is quite a common operation, so we want it to be
472 fast. We optimise for the ascii case, knowing that all our
473 supported multi-byte character sets are ascii-compatible
474 (ie. they match for the first 128 chars) */
476 while (*s && !(((unsigned char)s[0]) & 0x80)) {
477 *s = tolower_m((unsigned char)*s);
484 /* I assume that lowercased string takes the same number of bytes
485 * as source string even in UTF-8 encoding. (VIV) */
489 unix_strlower(s,len,s,len);
490 /* Catch mb conversion errors that may not terminate. */
496 static bool unix_strupper(const char *src, size_t srclen, char *dest, size_t destlen)
502 if (!push_ucs2_talloc(talloc_tos(), &buffer, src, &size)) {
506 if (!strupper_w(buffer) && (dest == src)) {
511 ret = convert_string(CH_UTF16LE, CH_UNIX, buffer, size, dest, destlen, &size);
516 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
519 Convert a string to UPPER case.
521 _PUBLIC_ void strupper_m(char *s)
524 struct smb_iconv_handle *iconv_handle;
526 iconv_handle = get_iconv_handle();
531 size_t c_size, c_size2;
532 codepoint_t c = next_codepoint_handle(iconv_handle, s, &c_size);
533 c_size2 = push_codepoint_handle(iconv_handle, d, toupper_m(c));
534 if (c_size2 > c_size) {
535 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
536 c, toupper_m(c), (int)c_size, (int)c_size2));
537 smb_panic("codepoint expansion in strupper_m\n");
548 Convert a string to upper case.
551 bool strupper_m(char *s)
557 /* this is quite a common operation, so we want it to be
558 fast. We optimise for the ascii case, knowing that all our
559 supported multi-byte character sets are ascii-compatible
560 (ie. they match for the first 128 chars) */
562 while (*s && !(((unsigned char)s[0]) & 0x80)) {
563 *s = toupper_ascii_fast((unsigned char)*s);
570 /* I assume that lowercased string takes the same number of bytes
571 * as source string even in multibyte encoding. (VIV) */
575 ret = unix_strupper(s,len,s,len);
576 /* 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,"%"PRIu64,&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 *
916 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
917 * error checking in between. The indiation that something weird happened is
920 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
921 size_t *bufsize, const char *fmt, ...)
928 /* len<0 is an internal marker that something failed */
932 if (*string == NULL) {
936 *string = talloc_array(mem_ctx, char, *bufsize);
942 ret = vasprintf(&newstr, fmt, ap);
950 while ((*len)+ret >= *bufsize) {
953 if (*bufsize >= (1024*1024*256))
958 *string = talloc_realloc(mem_ctx, *string, char,
960 if (*string == NULL) {
965 StrnCpy((*string)+(*len), newstr, ret);
976 * asprintf into a string and strupper_m it after that.
979 int asprintf_strupper_m(char **strp, const char *fmt, ...)
986 ret = vasprintf(&result, fmt, ap);
992 if (!strupper_m(result)) {
1001 char *talloc_asprintf_strupper_m(TALLOC_CTX *t, const char *fmt, ...)
1007 ret = talloc_vasprintf(t, fmt, ap);
1013 if (!strupper_m(ret)) {
1020 char *talloc_asprintf_strlower_m(TALLOC_CTX *t, const char *fmt, ...)
1026 ret = talloc_vasprintf(t, fmt, ap);
1037 /********************************************************************
1038 Check a string for any occurrences of a specified list of invalid
1040 ********************************************************************/
1042 bool validate_net_name( const char *name,
1043 const char *invalid_chars,
1052 for ( i=0; i<max_len && name[i]; i++ ) {
1053 /* fail if strchr_m() finds one of the invalid characters */
1054 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
1063 /*******************************************************************
1064 Add a shell escape character '\' to any character not in a known list
1065 of characters. UNIX charset format.
1066 *******************************************************************/
1068 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
1069 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
1071 char *escape_shell_string(const char *src)
1073 size_t srclen = strlen(src);
1074 char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
1076 bool in_s_quote = false;
1077 bool in_d_quote = false;
1078 bool next_escaped = false;
1086 codepoint_t c = next_codepoint(src, &c_size);
1088 if (c == INVALID_CODEPOINT) {
1094 memcpy(dest, src, c_size);
1097 next_escaped = false;
1102 * Deal with backslash escaped state.
1103 * This only lasts for one character.
1108 next_escaped = false;
1113 * Deal with single quote state. The
1114 * only thing we care about is exiting
1127 * Deal with double quote state. The most
1128 * complex state. We must cope with \, meaning
1129 * possibly escape next char (depending what it
1130 * is), ", meaning exit this state, and possibly
1131 * add an \ escape to any unprotected character
1132 * (listed in INSIDE_DQUOTE_LIST).
1138 * Next character might be escaped.
1139 * We have to peek. Inside double
1140 * quotes only INSIDE_DQUOTE_LIST
1141 * characters are escaped by a \.
1146 c = next_codepoint(&src[1], &c_size);
1147 if (c == INVALID_CODEPOINT) {
1153 * Don't escape the next char.
1162 if (nextchar && strchr(INSIDE_DQUOTE_LIST,
1164 next_escaped = true;
1171 /* Exit double quote state. */
1178 * We know the character isn't \ or ",
1179 * so escape it if it's any of the other
1180 * possible unprotected characters.
1183 if (strchr(INSIDE_DQUOTE_LIST, (int)*src)) {
1191 * From here to the end of the loop we're
1192 * not in the single or double quote state.
1196 /* Next character must be escaped. */
1197 next_escaped = true;
1203 /* Go into single quote state. */
1210 /* Go into double quote state. */
1216 /* Check if we need to escape the character. */
1218 if (!strchr(INCLUDE_LIST, (int)*src)) {
1227 /***************************************************
1228 str_list_make, v3 version. The v4 version does not
1229 look at quoted strings with embedded blanks, so
1230 do NOT merge this function please!
1231 ***************************************************/
1233 #define S_LIST_ABS 16 /* List Allocation Block Size */
1235 char **str_list_make_v3(TALLOC_CTX *mem_ctx, const char *string,
1243 if (!string || !*string)
1246 list = talloc_array(mem_ctx, char *, S_LIST_ABS+1);
1252 s = talloc_strdup(list, string);
1254 DEBUG(0,("str_list_make: Unable to allocate memory"));
1258 if (!sep) sep = LIST_SEP;
1263 while (next_token_talloc(list, &str, &tok, sep)) {
1268 lsize += S_LIST_ABS;
1270 tmp = talloc_realloc(mem_ctx, list, char *,
1273 DEBUG(0,("str_list_make: "
1274 "Unable to allocate memory"));
1281 memset (&list[num], 0,
1282 ((sizeof(char**)) * (S_LIST_ABS +1)));