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
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 * @brief String utilities.
33 * Internal function to get the next token from a string, return False if none
34 * found. Handles double-quotes. This is the work horse function called by
35 * next_token() and next_token_no_ltrim().
37 * Based on a routine by GJC@VILLAGE.COM.
38 * Extensively modified by Andrew.Tridgell@anu.edu.au
40 static BOOL next_token_internal(const char **ptr,
56 /* default to simple separators */
60 /* find the first non sep char, if left-trimming is requested */
62 while (*s && strchr_m(sep,*s))
70 /* copy over the token */
72 for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
81 *ptr = (*s) ? s+1 : s;
88 * Get the next token from a string, return False if none found. Handles
89 * double-quotes. This version trims leading separator characters before
90 * looking for a token.
92 BOOL next_token(const char **ptr, char *buff, const char *sep, size_t bufsize)
94 return next_token_internal(ptr, buff, sep, bufsize, True);
98 * Get the next token from a string, return False if none found. Handles
99 * double-quotes. This version does not trim leading separator characters
100 * before looking for a token.
102 BOOL next_token_no_ltrim(const char **ptr,
107 return next_token_internal(ptr, buff, sep, bufsize, False);
111 This is like next_token but is not re-entrant and "remembers" the first
112 parameter so you can pass NULL. This is useful for user interface code
113 but beware the fact that it is not re-entrant!
116 static const char *last_ptr=NULL;
118 BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
124 ret = next_token(ptr, buff, sep, bufsize);
129 static uint16 tmpbuf[sizeof(pstring)];
131 void set_first_token(char *ptr)
137 Convert list of tokens to array; dependent on above routine.
138 Uses last_ptr from above - bit of a hack.
141 char **toktocliplist(int *ctok, const char *sep)
143 char *s=(char *)last_ptr;
150 while(*s && strchr_m(sep,*s))
159 while(*s && (!strchr_m(sep,*s)))
161 while(*s && strchr_m(sep,*s))
168 if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
186 * Case insensitive string compararison.
188 * iconv does not directly give us a way to compare strings in
189 * arbitrary unix character sets -- all we can is convert and then
190 * compare. This is expensive.
192 * As an optimization, we do a first pass that considers only the
193 * prefix of the strings that is entirely 7-bit. Within this, we
194 * check whether they have the same value.
196 * Hopefully this will often give the answer without needing to copy.
197 * In particular it should speed comparisons to literal ascii strings
198 * or comparisons of strings that are "obviously" different.
200 * If we find a non-ascii character we fall back to converting via
203 * This should never be slower than convering the whole thing, and
206 * A different optimization would be to compare for bitwise equality
207 * in the binary encoding. (It would be possible thought hairy to do
208 * both simultaneously.) But in that case if they turn out to be
209 * different, we'd need to restart the whole thing.
211 * Even better is to implement strcasecmp for each encoding and use a
214 int StrCaseCmp(const char *s, const char *t)
219 smb_ucs2_t *buffer_s, *buffer_t;
222 for (ps = s, pt = t; ; ps++, pt++) {
226 return 0; /* both ended */
228 return -1; /* s is a prefix */
230 return +1; /* t is a prefix */
231 else if ((*ps & 0x80) || (*pt & 0x80))
232 /* not ascii anymore, do it the hard way from here on in */
235 us = toupper_ascii(*ps);
236 ut = toupper_ascii(*pt);
245 size = push_ucs2_allocate(&buffer_s, ps);
246 if (size == (size_t)-1) {
247 return strcmp(ps, pt);
248 /* Not quite the right answer, but finding the right one
249 under this failure case is expensive, and it's pretty close */
252 size = push_ucs2_allocate(&buffer_t, pt);
253 if (size == (size_t)-1) {
255 return strcmp(ps, pt);
256 /* Not quite the right answer, but finding the right one
257 under this failure case is expensive, and it's pretty close */
260 ret = strcasecmp_w(buffer_s, buffer_t);
268 Case insensitive string compararison, length limited.
270 int StrnCaseCmp(const char *s, const char *t, size_t n)
273 unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
274 unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
275 return strncmp(buf1,buf2,n);
281 * @note The comparison is case-insensitive.
283 BOOL strequal(const char *s1, const char *s2)
290 return(StrCaseCmp(s1,s2)==0);
294 * Compare 2 strings up to and including the nth char.
296 * @note The comparison is case-insensitive.
298 BOOL strnequal(const char *s1,const char *s2,size_t n)
302 if (!s1 || !s2 || !n)
305 return(StrnCaseCmp(s1,s2,n)==0);
309 Compare 2 strings (case sensitive).
312 BOOL strcsequal(const char *s1,const char *s2)
319 return(strcmp(s1,s2)==0);
323 Do a case-insensitive, whitespace-ignoring string compare.
326 int strwicmp(const char *psz1, const char *psz2)
328 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
329 /* appropriate value. */
332 else if (psz1 == NULL)
334 else if (psz2 == NULL)
337 /* sync the strings on first non-whitespace */
339 while (isspace((int)*psz1))
341 while (isspace((int)*psz2))
343 if (toupper_ascii(*psz1) != toupper_ascii(*psz2) || *psz1 == '\0'
349 return (*psz1 - *psz2);
354 Convert a string to upper case, but don't modify it.
357 char *strupper_static(const char *s)
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
397 void string_replace( pstring s, char oldc, char newc )
401 /* this is quite a common operation, so we want it to be
402 fast. We optimise for the ascii case, knowing that all our
403 supported multi-byte character sets are ascii-compatible
404 (ie. they match for the first 128 chars) */
406 for (p = s; *p; p++) {
407 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. */
421 push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
422 string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
423 pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
427 Skip past some strings in a buffer.
430 char *skip_string(char *buf,size_t n)
433 buf += strlen(buf) + 1;
438 Count the number of characters in a string. Normally this will
439 be the same as the number of bytes in a string for single byte strings,
440 but will be different for multibyte.
443 size_t str_charnum(const char *s)
445 uint16 tmpbuf2[sizeof(pstring)];
446 push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
447 return strlen_w(tmpbuf2);
451 Count the number of characters in a string. Normally this will
452 be the same as the number of bytes in a string for single byte strings,
453 but will be different for multibyte.
456 size_t str_ascii_charnum(const char *s)
459 push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
460 return strlen(tmpbuf2);
463 BOOL trim_char(char *s,char cfront,char cback)
469 /* Ignore null or empty strings. */
470 if (!s || (s[0] == '\0'))
474 while (*fp && *fp == cfront)
477 /* We ate the string. */
485 ep = fp + strlen(fp) - 1;
487 /* Attempt ascii only. Bail for mb strings. */
488 while ((ep >= fp) && (*ep == cback)) {
490 if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
491 /* Could be mb... bail back to tim_string. */
499 return trim_string(s, cfront ? fs : NULL, bs);
505 /* We ate the string. */
512 memmove(s, fp, ep-fp+2);
517 Trim the specified elements off the front and back of a string.
520 BOOL trim_string(char *s,const char *front,const char *back)
527 /* Ignore null or empty strings. */
528 if (!s || (s[0] == '\0'))
531 front_len = front? strlen(front) : 0;
532 back_len = back? strlen(back) : 0;
537 while (len && strncmp(s, front, front_len)==0) {
538 /* Must use memmove here as src & dest can
539 * easily overlap. Found by valgrind. JRA. */
540 memmove(s, s+front_len, (len-front_len)+1);
547 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
548 s[len-back_len]='\0';
557 Does a string have any uppercase chars in it?
560 BOOL strhasupper(const char *s)
563 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
564 for(ptr=tmpbuf;*ptr;ptr++)
571 Does a string have any lowercase chars in it?
574 BOOL strhaslower(const char *s)
577 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
578 for(ptr=tmpbuf;*ptr;ptr++)
585 Find the number of 'c' chars in a string
588 size_t count_chars(const char *s,char c)
592 smb_ucs2_t *alloc_tmpbuf = NULL;
594 if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
598 for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
599 if(*ptr==UCS2_CHAR(c))
602 SAFE_FREE(alloc_tmpbuf);
607 Safe string copy into a known length string. maxlength does not
608 include the terminating zero.
611 char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
616 DEBUG(0,("ERROR: NULL dest in safe_strcpy, called from [%s][%d]\n", fn, line));
621 clobber_region(fn,line,dest, maxlength+1);
629 len = strnlen(src, maxlength+1);
631 if (len > maxlength) {
632 DEBUG(0,("ERROR: string overflow by %lu (%lu - %lu) in safe_strcpy [%.50s]\n",
633 (unsigned long)(len-maxlength), (unsigned long)len,
634 (unsigned long)maxlength, src));
638 memmove(dest, src, len);
644 Safe string cat into a string. maxlength does not
645 include the terminating zero.
647 char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size_t maxlength)
649 size_t src_len, dest_len;
652 DEBUG(0,("ERROR: NULL dest in safe_strcat, called from [%s][%d]\n", fn, line));
659 src_len = strnlen(src, maxlength + 1);
660 dest_len = strnlen(dest, maxlength + 1);
663 clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
666 if (src_len + dest_len > maxlength) {
667 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
668 (int)(src_len + dest_len - maxlength), src));
669 if (maxlength > dest_len) {
670 memcpy(&dest[dest_len], src, maxlength - dest_len);
676 memcpy(&dest[dest_len], src, src_len);
677 dest[dest_len + src_len] = 0;
682 Paranoid strcpy into a buffer of given length (includes terminating
683 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
684 and replaces with '_'. Deliberately does *NOT* check for multibyte
685 characters. Don't change it !
687 char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
692 clobber_region(fn, line, dest, maxlength);
696 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, called from [%s][%d]\n", fn, line));
706 if (len >= maxlength)
709 if (!other_safe_chars)
710 other_safe_chars = "";
712 for(i = 0; i < len; i++) {
713 int val = (src[i] & 0xff);
714 if (isupper_ascii(val) || islower_ascii(val) || isdigit(val) || strchr_m(other_safe_chars, val))
726 Like strncpy but always null terminates. Make sure there is room!
727 The variable n should always be one less than the available size.
729 char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
734 clobber_region(fn, line, dest, n+1);
738 DEBUG(0,("ERROR: NULL dest in StrnCpy, called from [%s][%d]\n", fn, line));
747 while (n-- && (*d = *src)) {
758 Like strncpy but copies up to the character marker. always null terminates.
759 returns a pointer to the character marker in the source string (src).
762 static char *strncpyn(char *dest, const char *src, size_t n, char c)
768 clobber_region(dest, n+1);
770 p = strchr_m(src, c);
772 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
776 str_len = PTR_DIFF(p, src);
777 strncpy(dest, src, MIN(n, str_len));
778 dest[str_len] = '\0';
785 Routine to get hex characters and turn them into a 16 byte array.
786 the array can be variable length, and any non-hex-numeric
787 characters are skipped. "0xnn" or "0Xnn" is specially catered
790 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
794 size_t strhex_to_str(char *p, size_t len, const char *strhex)
797 size_t num_chars = 0;
798 unsigned char lonybble, hinybble;
799 const char *hexchars = "0123456789ABCDEF";
800 char *p1 = NULL, *p2 = NULL;
802 for (i = 0; i < len && strhex[i] != 0; i++) {
803 if (strnequal(hexchars, "0x", 2)) {
804 i++; /* skip two chars */
808 if (!(p1 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
811 i++; /* next hex digit */
813 if (!(p2 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
816 /* get the two nybbles */
817 hinybble = PTR_DIFF(p1, hexchars);
818 lonybble = PTR_DIFF(p2, hexchars);
820 p[num_chars] = (hinybble << 4) | lonybble;
829 DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
834 ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
836 ret_blob = data_blob(NULL, strlen(strhex)/2+1);
838 ret_blob.length = strhex_to_str((char*)ret_blob.data,
846 * Routine to print a buffer as HEX digits, into an allocated string.
849 char *hex_encode(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
854 hex_buffer = TALLOC_ARRAY(mem_ctx, char, (len*2)+1);
856 for (i = 0; i < len; i++)
857 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
863 Check if a string is part of a list.
866 BOOL in_list(const char *s, const char *list, BOOL casesensitive)
874 while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
876 if (strcmp(tok,s) == 0)
879 if (StrCaseCmp(tok,s) == 0)
886 /* this is used to prevent lots of mallocs of size 1 */
887 static const char *null_string = "";
890 Set a string value, allocing the space for the string
893 static BOOL string_init(char **dest,const char *src)
903 *dest = CONST_DISCARD(char*, null_string);
905 (*dest) = SMB_STRDUP(src);
906 if ((*dest) == NULL) {
907 DEBUG(0,("Out of memory in string_init\n"));
918 void string_free(char **s)
922 if (*s == null_string)
928 Set a string value, deallocating any existing space, and allocing the space
932 BOOL string_set(char **dest,const char *src)
935 return(string_init(dest,src));
939 Substitute a string for a pattern in another string. Make sure there is
942 This routine looks for pattern in s and replaces it with
943 insert. It may do multiple replacements or just one.
945 Any of " ; ' $ or ` in the insert string are replaced with _
946 if len==0 then the string cannot be extended. This is different from the old
947 use of len==0 which was for no length checks to be done.
950 void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
951 BOOL remove_unsafe_characters, BOOL replace_once, BOOL allow_trailing_dollar)
956 if (!insert || !pattern || !*pattern || !s)
959 ls = (ssize_t)strlen(s);
960 lp = (ssize_t)strlen(pattern);
961 li = (ssize_t)strlen(insert);
964 len = ls + 1; /* len is number of *bytes* */
966 while (lp <= ls && (p = strstr_m(s,pattern))) {
967 if (ls + (li-lp) >= len) {
968 DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
969 (int)(ls + (li-lp) - len),
974 memmove(p+li,p+lp,strlen(p+lp)+1);
983 /* allow a trailing $ (as in machine accounts) */
984 if (allow_trailing_dollar && (i == li - 1 )) {
991 if ( remove_unsafe_characters ) {
993 /* yes this break should be here since we want to
994 fall throw if not replacing unsafe chars */
1009 void string_sub_once(char *s, const char *pattern, const char *insert, size_t len)
1011 string_sub2( s, pattern, insert, len, True, True, False );
1014 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
1016 string_sub2( s, pattern, insert, len, True, False, False );
1019 void fstring_sub(char *s,const char *pattern,const char *insert)
1021 string_sub(s, pattern, insert, sizeof(fstring));
1024 void pstring_sub(char *s,const char *pattern,const char *insert)
1026 string_sub(s, pattern, insert, sizeof(pstring));
1030 Similar to string_sub, but it will accept only allocated strings
1031 and may realloc them so pay attention at what you pass on no
1032 pointers inside strings, no pstrings or const may be passed
1036 char *realloc_string_sub(char *string, const char *pattern,
1041 ssize_t ls,lp,li,ld, i;
1043 if (!insert || !pattern || !*pattern || !string || !*string)
1048 in = SMB_STRDUP(insert);
1050 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1053 ls = (ssize_t)strlen(s);
1054 lp = (ssize_t)strlen(pattern);
1055 li = (ssize_t)strlen(insert);
1057 for (i=0;i<li;i++) {
1074 while ((p = strstr_m(s,pattern))) {
1076 int offset = PTR_DIFF(s,string);
1077 string = (char *)SMB_REALLOC(string, ls + ld + 1);
1079 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1083 p = string + offset + (p - s);
1086 memmove(p+li,p+lp,strlen(p+lp)+1);
1096 /* Same as string_sub, but returns a talloc'ed string */
1098 char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
1099 const char *pattern, const char *insert)
1104 ssize_t ls,lp,li,ld, i;
1106 if (!insert || !pattern || !*pattern || !src || !*src)
1109 string = talloc_strdup(mem_ctx, src);
1110 if (string == NULL) {
1111 DEBUG(0, ("talloc_strdup failed\n"));
1117 in = SMB_STRDUP(insert);
1119 DEBUG(0, ("talloc_string_sub: out of memory!\n"));
1122 ls = (ssize_t)strlen(s);
1123 lp = (ssize_t)strlen(pattern);
1124 li = (ssize_t)strlen(insert);
1126 for (i=0;i<li;i++) {
1143 while ((p = strstr_m(s,pattern))) {
1145 int offset = PTR_DIFF(s,string);
1146 string = (char *)TALLOC_REALLOC(mem_ctx, string,
1149 DEBUG(0, ("talloc_string_sub: out of "
1154 p = string + offset + (p - s);
1157 memmove(p+li,p+lp,strlen(p+lp)+1);
1168 Similar to string_sub() but allows for any character to be substituted.
1170 if len==0 then the string cannot be extended. This is different from the old
1171 use of len==0 which was for no length checks to be done.
1174 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1179 if (!insert || !pattern || !s)
1182 ls = (ssize_t)strlen(s);
1183 lp = (ssize_t)strlen(pattern);
1184 li = (ssize_t)strlen(insert);
1190 len = ls + 1; /* len is number of *bytes* */
1192 while (lp <= ls && (p = strstr_m(s,pattern))) {
1193 if (ls + (li-lp) >= len) {
1194 DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1195 (int)(ls + (li-lp) - len),
1196 pattern, (int)len));
1200 memmove(p+li,p+lp,strlen(p+lp)+1);
1202 memcpy(p, insert, li);
1209 Similar to all_string_sub but for unicode strings.
1210 Return a new allocated unicode string.
1211 similar to string_sub() but allows for any character to be substituted.
1215 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
1216 const smb_ucs2_t *insert)
1219 const smb_ucs2_t *sp;
1220 size_t lr, lp, li, lt;
1222 if (!insert || !pattern || !*pattern || !s)
1225 lt = (size_t)strlen_w(s);
1226 lp = (size_t)strlen_w(pattern);
1227 li = (size_t)strlen_w(insert);
1230 const smb_ucs2_t *st = s;
1232 while ((sp = strstr_w(st, pattern))) {
1238 r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
1240 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1244 while ((sp = strstr_w(s, pattern))) {
1245 memcpy(rp, s, (sp - s));
1246 rp += ((sp - s) / sizeof(smb_ucs2_t));
1247 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1251 lr = ((rp - r) / sizeof(smb_ucs2_t));
1253 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1261 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1266 if (!insert || !pattern || !s)
1268 push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1269 push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1270 return all_string_sub_w(s, p, i);
1275 Splits out the front and back at a separator.
1278 static void split_at_last_component(char *path, char *front, char sep, char *back)
1280 char *p = strrchr_m(path, sep);
1286 pstrcpy(front, path);
1300 Write an octal as a string.
1303 const char *octal_string(int i)
1305 static char ret[64];
1308 slprintf(ret, sizeof(ret)-1, "0%o", i);
1314 Truncate a string at a specified length.
1317 char *string_truncate(char *s, unsigned int length)
1319 if (s && strlen(s) > length)
1325 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1326 We convert via ucs2 for now.
1329 char *strchr_m(const char *src, char c)
1336 /* characters below 0x3F are guaranteed to not appear in
1337 non-initial position in multi-byte charsets */
1338 if ((c & 0xC0) == 0) {
1339 return strchr(src, c);
1342 /* this is quite a common operation, so we want it to be
1343 fast. We optimise for the ascii case, knowing that all our
1344 supported multi-byte character sets are ascii-compatible
1345 (ie. they match for the first 128 chars) */
1347 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1355 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1356 /* With compose characters we must restart from the beginning. JRA. */
1360 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1361 p = strchr_w(ws, UCS2_CHAR(c));
1365 pull_ucs2_pstring(s2, ws);
1366 return (char *)(s+strlen(s2));
1369 char *strrchr_m(const char *s, char c)
1371 /* characters below 0x3F are guaranteed to not appear in
1372 non-initial position in multi-byte charsets */
1373 if ((c & 0xC0) == 0) {
1374 return strrchr(s, c);
1377 /* this is quite a common operation, so we want it to be
1378 fast. We optimise for the ascii case, knowing that all our
1379 supported multi-byte character sets are ascii-compatible
1380 (ie. they match for the first 128 chars). Also, in Samba
1381 we only search for ascii characters in 'c' and that
1382 in all mb character sets with a compound character
1383 containing c, if 'c' is not a match at position
1384 p, then p[-1] > 0x7f. JRA. */
1387 size_t len = strlen(s);
1389 BOOL got_mb = False;
1396 /* Could be a match. Part of a multibyte ? */
1397 if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
1398 /* Yep - go slow :-( */
1402 /* No - we have a match ! */
1405 } while (cp-- != s);
1410 /* String contained a non-ascii char. Slow path. */
1416 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1417 p = strrchr_w(ws, UCS2_CHAR(c));
1421 pull_ucs2_pstring(s2, ws);
1422 return (char *)(s+strlen(s2));
1426 /***********************************************************************
1427 Return the equivalent of doing strrchr 'n' times - always going
1429 ***********************************************************************/
1431 char *strnrchr_m(const char *s, char c, unsigned int n)
1437 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1438 p = strnrchr_w(ws, UCS2_CHAR(c), n);
1442 pull_ucs2_pstring(s2, ws);
1443 return (char *)(s+strlen(s2));
1446 /***********************************************************************
1447 strstr_m - We convert via ucs2 for now.
1448 ***********************************************************************/
1450 char *strstr_m(const char *src, const char *findstr)
1453 smb_ucs2_t *src_w, *find_w;
1458 size_t findstr_len = 0;
1460 /* for correctness */
1465 /* Samba does single character findstr calls a *lot*. */
1466 if (findstr[1] == '\0')
1467 return strchr_m(src, *findstr);
1469 /* We optimise for the ascii case, knowing that all our
1470 supported multi-byte character sets are ascii-compatible
1471 (ie. they match for the first 128 chars) */
1473 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1474 if (*s == *findstr) {
1476 findstr_len = strlen(findstr);
1478 if (strncmp(s, findstr, findstr_len) == 0) {
1487 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1488 /* 'make check' fails unless we do this */
1490 /* With compose characters we must restart from the beginning. JRA. */
1494 if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1495 DEBUG(0,("strstr_m: src malloc fail\n"));
1499 if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1501 DEBUG(0,("strstr_m: find malloc fail\n"));
1505 p = strstr_w(src_w, find_w);
1514 if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1517 DEBUG(0,("strstr_m: dest malloc fail\n"));
1520 retp = (char *)(s+strlen(s2));
1528 Convert a string to lower case.
1531 void strlower_m(char *s)
1536 /* this is quite a common operation, so we want it to be
1537 fast. We optimise for the ascii case, knowing that all our
1538 supported multi-byte character sets are ascii-compatible
1539 (ie. they match for the first 128 chars) */
1541 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1542 *s = tolower_ascii((unsigned char)*s);
1549 /* I assume that lowercased string takes the same number of bytes
1550 * as source string even in UTF-8 encoding. (VIV) */
1551 len = strlen(s) + 1;
1554 unix_strlower(s,len,s,len);
1555 /* Catch mb conversion errors that may not terminate. */
1562 Convert a string to upper case.
1565 void strupper_m(char *s)
1570 /* this is quite a common operation, so we want it to be
1571 fast. We optimise for the ascii case, knowing that all our
1572 supported multi-byte character sets are ascii-compatible
1573 (ie. they match for the first 128 chars) */
1575 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1576 *s = toupper_ascii((unsigned char)*s);
1583 /* I assume that lowercased string takes the same number of bytes
1584 * as source string even in multibyte encoding. (VIV) */
1585 len = strlen(s) + 1;
1588 unix_strupper(s,len,s,len);
1589 /* Catch mb conversion errors that may not terminate. */
1596 Count the number of UCS2 characters in a string. Normally this will
1597 be the same as the number of bytes in a string for single byte strings,
1598 but will be different for multibyte.
1601 size_t strlen_m(const char *s)
1609 while (*s && !(((uint8_t)*s) & 0x80)) {
1620 codepoint_t c = next_codepoint(s, &c_size);
1622 /* Unicode char fits into 16 bits. */
1625 /* Double-width unicode char - 32 bits. */
1635 Count the number of UCS2 characters in a string including the null
1639 size_t strlen_m_term(const char *s)
1644 return strlen_m(s) + 1;
1648 * Weird helper routine for the winreg pipe: If nothing is around, return 0,
1649 * if a string is there, include the terminator.
1652 size_t strlen_m_term_null(const char *s)
1666 Return a RFC2254 binary string representation of a buffer.
1667 Used in LDAP filters.
1671 char *binary_string_rfc2254(char *buf, int len)
1675 const char *hex = "0123456789ABCDEF";
1676 s = (char *)SMB_MALLOC(len * 3 + 1);
1679 for (j=i=0;i<len;i++) {
1681 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1682 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1689 char *binary_string(char *buf, int len)
1693 const char *hex = "0123456789ABCDEF";
1694 s = (char *)SMB_MALLOC(len * 2 + 1);
1697 for (j=i=0;i<len;i++) {
1698 s[j] = hex[((unsigned char)buf[i]) >> 4];
1699 s[j+1] = hex[((unsigned char)buf[i]) & 0xF];
1706 Just a typesafety wrapper for snprintf into a pstring.
1709 int pstr_sprintf(pstring s, const char *fmt, ...)
1715 ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1722 Just a typesafety wrapper for snprintf into a fstring.
1725 int fstr_sprintf(fstring s, const char *fmt, ...)
1731 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1737 List of Strings manipulation functions
1740 #define S_LIST_ABS 16 /* List Allocation Block Size */
1742 static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
1744 char **list, **rlist;
1750 if (!string || !*string)
1753 s = talloc_strdup(mem_ctx, string);
1755 s = SMB_STRDUP(string);
1758 DEBUG(0,("str_list_make: Unable to allocate memory"));
1761 if (!sep) sep = LIST_SEP;
1767 while (next_token(&str, tok, sep, sizeof(tok))) {
1769 lsize += S_LIST_ABS;
1771 rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list, char *, lsize +1);
1773 /* We need to keep the old list on error so we can free the elements
1774 if the realloc fails. */
1775 rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
1778 DEBUG(0,("str_list_make: Unable to allocate memory"));
1779 str_list_free(&list);
1789 memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1793 list[num] = talloc_strdup(mem_ctx, tok);
1795 list[num] = SMB_STRDUP(tok);
1799 DEBUG(0,("str_list_make: Unable to allocate memory"));
1800 str_list_free(&list);
1821 char **str_list_make_talloc(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
1823 return str_list_make_internal(mem_ctx, string, sep);
1826 char **str_list_make(const char *string, const char *sep)
1828 return str_list_make_internal(NULL, string, sep);
1831 BOOL str_list_copy(char ***dest, const char **src)
1833 char **list, **rlist;
1845 lsize += S_LIST_ABS;
1846 rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
1848 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1849 str_list_free(&list);
1854 memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1857 list[num] = SMB_STRDUP(src[num]);
1859 DEBUG(0,("str_list_copy: Unable to allocate memory"));
1860 str_list_free(&list);
1872 * Return true if all the elements of the list match exactly.
1874 BOOL str_list_compare(char **list1, char **list2)
1878 if (!list1 || !list2)
1879 return (list1 == list2);
1881 for (num = 0; list1[num]; num++) {
1884 if (!strcsequal(list1[num], list2[num]))
1888 return False; /* if list2 has more elements than list1 fail */
1893 static void str_list_free_internal(TALLOC_CTX *mem_ctx, char ***list)
1897 if (!list || !*list)
1900 for(; *tlist; tlist++) {
1902 TALLOC_FREE(*tlist);
1908 TALLOC_FREE(*tlist);
1914 void str_list_free_talloc(TALLOC_CTX *mem_ctx, char ***list)
1916 str_list_free_internal(mem_ctx, list);
1919 void str_list_free(char ***list)
1921 str_list_free_internal(NULL, list);
1924 /******************************************************************************
1925 *****************************************************************************/
1927 int str_list_count( const char **list )
1934 /* count the number of list members */
1936 for ( i=0; *list; i++, list++ );
1941 /******************************************************************************
1942 version of standard_sub_basic() for string lists; uses alloc_sub_basic()
1944 *****************************************************************************/
1946 BOOL str_list_sub_basic( char **list, const char *smb_name,
1947 const char *domain_name )
1953 tmpstr = alloc_sub_basic(smb_name, domain_name, s);
1955 DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
1968 /******************************************************************************
1969 substritute a specific pattern in a string list
1970 *****************************************************************************/
1972 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1975 ssize_t ls, lp, li, ld, i, d;
1984 lp = (ssize_t)strlen(pattern);
1985 li = (ssize_t)strlen(insert);
1990 ls = (ssize_t)strlen(s);
1992 while ((p = strstr_m(s, pattern))) {
1996 t = (char *) SMB_MALLOC(ls +ld +1);
1998 DEBUG(0,("str_list_substitute: Unable to allocate memory"));
2001 memcpy(t, *list, d);
2002 memcpy(t +d +li, p +lp, ls -d -lp +1);
2009 for (i = 0; i < li; i++) {
2010 switch (insert[i]) {
2022 t[d +i] = insert[i];
2035 #define IPSTR_LIST_SEP ","
2036 #define IPSTR_LIST_CHAR ','
2039 * Add ip string representation to ipstr list. Used also
2040 * as part of @function ipstr_list_make
2042 * @param ipstr_list pointer to string containing ip list;
2043 * MUST BE already allocated and IS reallocated if necessary
2044 * @param ipstr_size pointer to current size of ipstr_list (might be changed
2045 * as a result of reallocation)
2046 * @param ip IP address which is to be added to list
2047 * @return pointer to string appended with new ip and possibly
2048 * reallocated to new length
2051 char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
2053 char* new_ipstr = NULL;
2055 /* arguments checking */
2056 if (!ipstr_list || !service) return NULL;
2058 /* attempt to convert ip to a string and append colon separator to it */
2060 asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list, IPSTR_LIST_SEP,
2061 inet_ntoa(service->ip), service->port);
2062 SAFE_FREE(*ipstr_list);
2064 asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
2066 *ipstr_list = new_ipstr;
2072 * Allocate and initialise an ipstr list using ip adresses
2073 * passed as arguments.
2075 * @param ipstr_list pointer to string meant to be allocated and set
2076 * @param ip_list array of ip addresses to place in the list
2077 * @param ip_count number of addresses stored in ip_list
2078 * @return pointer to allocated ip string
2081 char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
2085 /* arguments checking */
2086 if (!ip_list || !ipstr_list) return 0;
2090 /* process ip addresses given as arguments */
2091 for (i = 0; i < ip_count; i++)
2092 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
2094 return (*ipstr_list);
2099 * Parse given ip string list into array of ip addresses
2100 * (as ip_service structures)
2101 * e.g. 192.168.1.100:389,192.168.1.78, ...
2103 * @param ipstr ip string list to be parsed
2104 * @param ip_list pointer to array of ip addresses which is
2105 * allocated by this function and must be freed by caller
2106 * @return number of succesfully parsed addresses
2109 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
2115 if (!ipstr_list || !ip_list)
2118 count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
2119 if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
2120 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
2125 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count;
2128 struct in_addr addr;
2130 char *p = strchr(token_str, ':');
2137 /* convert single token to ip address */
2138 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
2141 (*ip_list)[i].ip = addr;
2142 (*ip_list)[i].port = port;
2150 * Safely free ip string list
2152 * @param ipstr_list ip string list to be freed
2155 void ipstr_list_free(char* ipstr_list)
2157 SAFE_FREE(ipstr_list);
2162 Unescape a URL encoded string, in place.
2165 void rfc1738_unescape(char *buf)
2169 while (p && *p && (p=strchr_m(p,'%'))) {
2173 if (c1 >= '0' && c1 <= '9')
2175 else if (c1 >= 'A' && c1 <= 'F')
2177 else if (c1 >= 'a' && c1 <= 'f')
2179 else {p++; continue;}
2181 if (c2 >= '0' && c2 <= '9')
2183 else if (c2 >= 'A' && c2 <= 'F')
2185 else if (c2 >= 'a' && c2 <= 'f')
2187 else {p++; continue;}
2191 memmove(p+1, p+3, strlen(p+3)+1);
2196 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2199 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
2201 DATA_BLOB base64_decode_data_blob(const char *s)
2203 int bit_offset, byte_offset, idx, i, n;
2204 DATA_BLOB decoded = data_blob(s, strlen(s)+1);
2205 unsigned char *d = decoded.data;
2210 while (*s && (p=strchr_m(b64,*s))) {
2211 idx = (int)(p - b64);
2212 byte_offset = (i*6)/8;
2213 bit_offset = (i*6)%8;
2214 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2215 if (bit_offset < 3) {
2216 d[byte_offset] |= (idx << (2-bit_offset));
2219 d[byte_offset] |= (idx >> (bit_offset-2));
2220 d[byte_offset+1] = 0;
2221 d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2227 if ((n > 0) && (*s == '=')) {
2237 * Decode a base64 string in-place - wrapper for the above
2239 void base64_decode_inplace(char *s)
2241 DATA_BLOB decoded = base64_decode_data_blob(s);
2243 if ( decoded.length != 0 ) {
2244 memcpy(s, decoded.data, decoded.length);
2246 /* null terminate */
2247 s[decoded.length] = '\0';
2252 data_blob_free(&decoded);
2256 * Encode a base64 string into a malloc()ed string caller to free.
2258 *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
2260 char * base64_encode_data_blob(DATA_BLOB data)
2264 size_t out_cnt, len, output_len;
2267 if (!data.length || !data.data)
2272 output_len = data.length * 2;
2273 result = (char *)SMB_MALLOC(output_len); /* get us plenty of space */
2275 while (len-- && out_cnt < (data.length * 2) - 5) {
2276 int c = (unsigned char) *(data.data++);
2279 if (char_count == 3) {
2280 result[out_cnt++] = b64[bits >> 18];
2281 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2282 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2283 result[out_cnt++] = b64[bits & 0x3f];
2290 if (char_count != 0) {
2291 bits <<= 16 - (8 * char_count);
2292 result[out_cnt++] = b64[bits >> 18];
2293 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2294 if (char_count == 1) {
2295 result[out_cnt++] = '=';
2296 result[out_cnt++] = '=';
2298 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2299 result[out_cnt++] = '=';
2302 result[out_cnt] = '\0'; /* terminate */
2306 /* read a SMB_BIG_UINT from a string */
2307 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2310 SMB_BIG_UINT val = -1;
2311 const char *p = nptr;
2320 while (*p && isspace(*p))
2323 #ifdef LARGE_SMB_OFF_T
2324 sscanf(p,"%llu",&val);
2325 #else /* LARGE_SMB_OFF_T */
2326 sscanf(p,"%lu",&val);
2327 #endif /* LARGE_SMB_OFF_T */
2329 while (*p && isdigit(*p))
2337 /* Convert a size specification to a count of bytes. We accept the following
2339 * bytes if there is no suffix
2344 * pP whatever the ISO name for petabytes is
2346 * Returns 0 if the string can't be converted.
2348 SMB_OFF_T conv_str_size(const char * str)
2353 if (str == NULL || *str == '\0') {
2357 #ifdef HAVE_STRTOULL
2358 if (sizeof(SMB_OFF_T) == 8) {
2359 lval = strtoull(str, &end, 10 /* base */);
2361 lval = strtoul(str, &end, 10 /* base */);
2364 lval = strtoul(str, &end, 10 /* base */);
2367 if (end == NULL || end == str) {
2372 SMB_OFF_T lval_orig = lval;
2374 if (strwicmp(end, "K") == 0) {
2375 lval *= (SMB_OFF_T)1024;
2376 } else if (strwicmp(end, "M") == 0) {
2377 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2378 } else if (strwicmp(end, "G") == 0) {
2379 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2381 } else if (strwicmp(end, "T") == 0) {
2382 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2383 (SMB_OFF_T)1024 * (SMB_OFF_T)1024);
2384 } else if (strwicmp(end, "P") == 0) {
2385 lval *= ((SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2386 (SMB_OFF_T)1024 * (SMB_OFF_T)1024 *
2392 /* Primitive attempt to detect wrapping on platforms with
2393 * 4-byte SMB_OFF_T. It's better to let the caller handle
2394 * a failure than some random number.
2396 if (lval_orig <= lval) {
2404 void string_append(char **left, const char *right)
2406 int new_len = strlen(right) + 1;
2408 if (*left == NULL) {
2409 *left = (char *)SMB_MALLOC(new_len);
2412 new_len += strlen(*left);
2413 *left = (char *)SMB_REALLOC(*left, new_len);
2416 if (*left == NULL) {
2420 safe_strcat(*left, right, new_len-1);
2423 BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
2424 const char *str, const char ***strings,
2427 char *dup_str = talloc_strdup(mem_ctx, str);
2429 *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings, const char *, (*num)+1);
2431 if ((*strings == NULL) || (dup_str == NULL)) {
2436 (*strings)[*num] = dup_str;
2441 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2442 * error checking in between. The indiation that something weird happened is
2445 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2446 size_t *bufsize, const char *fmt, ...)
2453 /* len<0 is an internal marker that something failed */
2457 if (*string == NULL) {
2461 *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2462 if (*string == NULL)
2467 ret = vasprintf(&newstr, fmt, ap);
2475 while ((*len)+ret >= *bufsize) {
2478 if (*bufsize >= (1024*1024*256))
2483 *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2485 if (*string == NULL) {
2490 StrnCpy((*string)+(*len), newstr, ret);
2501 Returns the substring from src between the first occurrence of
2502 the char "front" and the first occurence of the char "back".
2503 Mallocs the return string which must be freed. Not for use
2504 with wide character strings.
2506 char *sstring_sub(const char *src, char front, char back)
2508 char *temp1, *temp2, *temp3;
2511 temp1 = strchr(src, front);
2512 if (temp1 == NULL) return NULL;
2513 temp2 = strchr(src, back);
2514 if (temp2 == NULL) return NULL;
2515 len = temp2 - temp1;
2516 if (len <= 0) return NULL;
2517 temp3 = (char*)SMB_MALLOC(len);
2518 if (temp3 == NULL) {
2519 DEBUG(1,("Malloc failure in sstring_sub\n"));
2522 memcpy(temp3, temp1+1, len-1);
2523 temp3[len-1] = '\0';
2527 /********************************************************************
2528 Check a string for any occurrences of a specified list of invalid
2530 ********************************************************************/
2532 BOOL validate_net_name( const char *name, const char *invalid_chars, int max_len )
2536 for ( i=0; i<max_len && name[i]; i++ ) {
2537 /* fail if strchr_m() finds one of the invalid characters */
2538 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
2548 return the number of bytes occupied by a buffer in ASCII format
2549 the result includes the null termination
2550 limited by 'n' bytes
2552 size_t ascii_len_n(const char *src, size_t n)
2556 len = strnlen(src, n);
2565 return the number of bytes occupied by a buffer in CH_UTF16 format
2566 the result includes the null termination
2568 size_t utf16_len(const void *buf)
2572 for (len = 0; SVAL(buf,len); len += 2) ;
2578 return the number of bytes occupied by a buffer in CH_UTF16 format
2579 the result includes the null termination
2580 limited by 'n' bytes
2582 size_t utf16_len_n(const void *src, size_t n)
2586 for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;