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"
27 #include "lib/util/smb_strtox.h"
29 static const char toupper_ascii_fast_table
[128] = {
30 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
31 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
32 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
33 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
34 0x40, 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, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
36 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
37 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f
41 * Compare 2 strings up to and including the nth char.
43 * @note The comparison is case-insensitive.
45 bool strnequal(const char *s1
,const char *s2
,size_t n
)
52 return(strncasecmp_m(s1
,s2
,n
)==0);
56 Skip past a string in a buffer. Buffer may not be
57 null terminated. end_ptr points to the first byte after
58 then end of the buffer.
61 char *skip_string(const char *base
, size_t len
, char *buf
)
63 const char *end_ptr
= base
+ len
;
65 if (end_ptr
< base
|| !base
|| !buf
|| buf
>= end_ptr
) {
82 Count the number of characters in a string. Normally this will
83 be the same as the number of bytes in a string for single byte strings,
84 but will be different for multibyte.
87 size_t str_charnum(const char *s
)
89 size_t ret
, converted_size
;
90 smb_ucs2_t
*tmpbuf2
= NULL
;
91 if (!push_ucs2_talloc(talloc_tos(), &tmpbuf2
, s
, &converted_size
)) {
94 ret
= strlen_w(tmpbuf2
);
99 bool trim_char(char *s
,char cfront
,char cback
)
105 /* Ignore null or empty strings. */
106 if (!s
|| (s
[0] == '\0'))
110 while (*fp
&& *fp
== cfront
)
113 /* We ate the string. */
121 ep
= fp
+ strlen(fp
) - 1;
123 /* Attempt ascii only. Bail for mb strings. */
124 while ((ep
>= fp
) && (*ep
== cback
)) {
126 if ((ep
> fp
) && (((unsigned char)ep
[-1]) & 0x80)) {
127 /* Could be mb... bail back to tim_string. */
135 return trim_string(s
, cfront
? fs
: NULL
, bs
);
141 /* We ate the string. */
148 memmove(s
, fp
, ep
-fp
+2);
153 Check if a string is part of a list.
156 bool in_list(const char *s
, const char *list
, bool casesensitive
)
166 frame
= talloc_stackframe();
167 while (next_token_talloc(frame
, &list
, &tok
,LIST_SEP
)) {
169 if (strcmp(tok
,s
) == 0) {
174 if (strcasecmp_m(tok
,s
) == 0) {
185 Truncate a string at a specified length.
188 char *string_truncate(char *s
, unsigned int length
)
190 if (s
&& strlen(s
) > length
)
196 /***********************************************************************
197 Return the equivalent of doing strrchr 'n' times - always going
199 ***********************************************************************/
201 char *strnrchr_m(const char *s
, char c
, unsigned int n
)
203 smb_ucs2_t
*ws
= NULL
;
207 size_t converted_size
;
209 if (!push_ucs2_talloc(talloc_tos(), &ws
, s
, &converted_size
)) {
210 /* Too hard to try and get right. */
213 p
= strnrchr_w(ws
, UCS2_CHAR(c
), n
);
219 if (!pull_ucs2_talloc(talloc_tos(), &s2
, ws
, &converted_size
)) {
221 /* Too hard to try and get right. */
224 ret
= discard_const_p(char, (s
+strlen(s2
)));
230 static bool unix_strlower(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
233 smb_ucs2_t
*buffer
= NULL
;
236 if (!convert_string_talloc(talloc_tos(), CH_UNIX
, CH_UTF16LE
, src
, srclen
,
237 (void **)(void *)&buffer
, &size
))
241 if (!strlower_w(buffer
) && (dest
== src
)) {
245 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, &size
);
250 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
253 Convert a string to lower case.
255 _PUBLIC_
void strlower_m(char *s
)
258 struct smb_iconv_handle
*iconv_handle
;
260 iconv_handle
= get_iconv_handle();
265 size_t c_size
, c_size2
;
266 codepoint_t c
= next_codepoint_handle(iconv_handle
, s
, &c_size
);
267 c_size2
= push_codepoint_handle(iconv_handle
, d
, tolower_m(c
));
268 if (c_size2
> c_size
) {
269 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
270 c
, tolower_m(c
), (int)c_size
, (int)c_size2
));
271 smb_panic("codepoint expansion in strlower_m\n");
282 Convert a string to lower case.
285 bool strlower_m(char *s
)
291 /* this is quite a common operation, so we want it to be
292 fast. We optimise for the ascii case, knowing that all our
293 supported multi-byte character sets are ascii-compatible
294 (ie. they match for the first 128 chars) */
296 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
297 *s
= tolower_m((unsigned char)*s
);
304 /* I assume that lowercased string takes the same number of bytes
305 * as source string even in UTF-8 encoding. (VIV) */
309 ret
= unix_strlower(s
,len
,s
,len
);
310 /* Catch mb conversion errors that may not terminate. */
318 static bool unix_strupper(const char *src
, size_t srclen
, char *dest
, size_t destlen
)
324 if (!push_ucs2_talloc(talloc_tos(), &buffer
, src
, &size
)) {
328 if (!strupper_w(buffer
) && (dest
== src
)) {
333 ret
= convert_string(CH_UTF16LE
, CH_UNIX
, buffer
, size
, dest
, destlen
, &size
);
338 #if 0 /* Alternate function that avoid talloc calls for ASCII and non ASCII */
341 Convert a string to UPPER case.
343 _PUBLIC_
void strupper_m(char *s
)
346 struct smb_iconv_handle
*iconv_handle
;
348 iconv_handle
= get_iconv_handle();
353 size_t c_size
, c_size2
;
354 codepoint_t c
= next_codepoint_handle(iconv_handle
, s
, &c_size
);
355 c_size2
= push_codepoint_handle(iconv_handle
, d
, toupper_m(c
));
356 if (c_size2
> c_size
) {
357 DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
358 c
, toupper_m(c
), (int)c_size
, (int)c_size2
));
359 smb_panic("codepoint expansion in strupper_m\n");
370 Convert a string to upper case.
373 bool strupper_m(char *s
)
378 /* this is quite a common operation, so we want it to be
379 fast. We optimise for the ascii case, knowing that all our
380 supported multi-byte character sets are ascii-compatible
381 (ie. they match for the first 128 chars) */
383 while (*s
&& !(((unsigned char)s
[0]) & 0x80)) {
384 *s
= toupper_ascii_fast_table
[(unsigned char)s
[0]];
391 /* I assume that uppercased string takes the same number of bytes
392 * as source string even in multibyte encoding. (VIV) */
394 ret
= unix_strupper(s
,len
,s
,len
);
395 /* Catch mb conversion errors that may not terminate. */
403 Just a typesafety wrapper for snprintf into a fstring.
406 int fstr_sprintf(fstring s
, const char *fmt
, ...)
412 ret
= vsnprintf(s
, FSTRING_LEN
, fmt
, ap
);
417 /* read a SMB_BIG_UINT from a string */
418 uint64_t STR_TO_SMB_BIG_UINT(const char *nptr
, const char **entptr
)
421 uint64_t val
= (uint64_t)-1;
422 const char *p
= nptr
;
431 while (*p
&& isspace(*p
))
434 sscanf(p
,"%"SCNu64
,&val
);
436 while (*p
&& isdigit(*p
))
444 /* Convert a size specification to a count of bytes. We accept the following
446 * bytes if there is no suffix
451 * pP whatever the ISO name for petabytes is
453 * Returns 0 if the string can't be converted.
455 uint64_t conv_str_size(const char * str
)
461 if (str
== NULL
|| *str
== '\0') {
465 lval
= smb_strtoull(str
, &end
, 10, &error
, SMB_STR_STANDARD
);
475 if (strwicmp(end
, "K") == 0) {
477 } else if (strwicmp(end
, "M") == 0) {
478 lval
*= (1024ULL * 1024ULL);
479 } else if (strwicmp(end
, "G") == 0) {
480 lval
*= (1024ULL * 1024ULL *
482 } else if (strwicmp(end
, "T") == 0) {
483 lval
*= (1024ULL * 1024ULL *
485 } else if (strwicmp(end
, "P") == 0) {
486 lval
*= (1024ULL * 1024ULL *
496 char *talloc_asprintf_strupper_m(TALLOC_CTX
*t
, const char *fmt
, ...)
502 ret
= talloc_vasprintf(t
, fmt
, ap
);
508 if (!strupper_m(ret
)) {
515 char *talloc_asprintf_strlower_m(TALLOC_CTX
*t
, const char *fmt
, ...)
521 ret
= talloc_vasprintf(t
, fmt
, ap
);
527 if (!strlower_m(ret
)) {
535 /********************************************************************
536 Check a string for any occurrences of a specified list of invalid
538 ********************************************************************/
540 bool validate_net_name( const char *name
,
541 const char *invalid_chars
,
550 for ( i
=0; i
<max_len
&& name
[i
]; i
++ ) {
551 /* fail if strchr_m() finds one of the invalid characters */
552 if ( name
[i
] && strchr_m( invalid_chars
, name
[i
] ) ) {
561 /*******************************************************************
562 Add a shell escape character '\' to any character not in a known list
563 of characters. UNIX charset format.
564 *******************************************************************/
566 #define INCLUDE_LIST "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_/ \t.,"
567 #define INSIDE_DQUOTE_LIST "$`\n\"\\"
569 char *escape_shell_string(const char *src
)
571 size_t srclen
= strlen(src
);
572 char *ret
= SMB_MALLOC_ARRAY(char, (srclen
* 2) + 1);
574 bool in_s_quote
= false;
575 bool in_d_quote
= false;
576 bool next_escaped
= false;
584 codepoint_t c
= next_codepoint(src
, &c_size
);
586 if (c
== INVALID_CODEPOINT
) {
592 memcpy(dest
, src
, c_size
);
595 next_escaped
= false;
600 * Deal with backslash escaped state.
601 * This only lasts for one character.
606 next_escaped
= false;
611 * Deal with single quote state. The
612 * only thing we care about is exiting
625 * Deal with double quote state. The most
626 * complex state. We must cope with \, meaning
627 * possibly escape next char (depending what it
628 * is), ", meaning exit this state, and possibly
629 * add an \ escape to any unprotected character
630 * (listed in INSIDE_DQUOTE_LIST).
636 * Next character might be escaped.
637 * We have to peek. Inside double
638 * quotes only INSIDE_DQUOTE_LIST
639 * characters are escaped by a \.
644 c
= next_codepoint(&src
[1], &c_size
);
645 if (c
== INVALID_CODEPOINT
) {
651 * Don't escape the next char.
660 if (nextchar
&& strchr(INSIDE_DQUOTE_LIST
,
669 /* Exit double quote state. */
676 * We know the character isn't \ or ",
677 * so escape it if it's any of the other
678 * possible unprotected characters.
681 if (strchr(INSIDE_DQUOTE_LIST
, (int)*src
)) {
689 * From here to the end of the loop we're
690 * not in the single or double quote state.
694 /* Next character must be escaped. */
701 /* Go into single quote state. */
708 /* Go into double quote state. */
714 /* Check if we need to escape the character. */
716 if (!strchr(INCLUDE_LIST
, (int)*src
)) {
726 * This routine improves performance for operations temporarily acting on a
727 * full path. It is equivalent to the much more expensive
729 * talloc_asprintf(talloc_tos(), "%s/%s", dir, name)
731 * This actually does make a difference in metadata-heavy workloads (i.e. the
732 * "standard" client.txt nbench run.
735 ssize_t
full_path_tos(const char *dir
, const char *name
,
736 char *tmpbuf
, size_t tmpbuf_len
,
737 char **pdst
, char **to_free
)
739 size_t dirlen
, namelen
, len
;
742 dirlen
= strlen(dir
);
743 namelen
= strlen(name
);
744 len
= dirlen
+ namelen
+ 1;
746 if (len
< tmpbuf_len
) {
750 dst
= talloc_array(talloc_tos(), char, len
+1);
757 memcpy(dst
, dir
, dirlen
);
759 memcpy(dst
+dirlen
+1, name
, namelen
+1);