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
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 * @brief String utilities.
32 * Get the next token from a string, return False if none found.
33 * Handles double-quotes.
35 * Based on a routine by GJC@VILLAGE.COM.
36 * Extensively modified by Andrew.Tridgell@anu.edu.au
38 BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
50 /* default to simple separators */
54 /* find the first non sep char */
55 while (*s && strchr_m(sep,*s))
62 /* copy over the token */
64 for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
73 *ptr = (*s) ? s+1 : s;
80 This is like next_token but is not re-entrant and "remembers" the first
81 parameter so you can pass NULL. This is useful for user interface code
82 but beware the fact that it is not re-entrant!
85 static const char *last_ptr=NULL;
87 BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
93 ret = next_token(ptr, buff, sep, bufsize);
98 static uint16 tmpbuf[sizeof(pstring)];
100 void set_first_token(char *ptr)
106 Convert list of tokens to array; dependent on above routine.
107 Uses last_ptr from above - bit of a hack.
110 char **toktocliplist(int *ctok, const char *sep)
112 char *s=(char *)last_ptr;
119 while(*s && strchr_m(sep,*s))
128 while(*s && (!strchr_m(sep,*s)))
130 while(*s && strchr_m(sep,*s))
137 if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
155 * Case insensitive string compararison.
157 * iconv does not directly give us a way to compare strings in
158 * arbitrary unix character sets -- all we can is convert and then
159 * compare. This is expensive.
161 * As an optimization, we do a first pass that considers only the
162 * prefix of the strings that is entirely 7-bit. Within this, we
163 * check whether they have the same value.
165 * Hopefully this will often give the answer without needing to copy.
166 * In particular it should speed comparisons to literal ascii strings
167 * or comparisons of strings that are "obviously" different.
169 * If we find a non-ascii character we fall back to converting via
172 * This should never be slower than convering the whole thing, and
175 * A different optimization would be to compare for bitwise equality
176 * in the binary encoding. (It would be possible thought hairy to do
177 * both simultaneously.) But in that case if they turn out to be
178 * different, we'd need to restart the whole thing.
180 * Even better is to implement strcasecmp for each encoding and use a
183 int StrCaseCmp(const char *s, const char *t)
188 smb_ucs2_t *buffer_s, *buffer_t;
191 for (ps = s, pt = t; ; ps++, pt++) {
195 return 0; /* both ended */
197 return -1; /* s is a prefix */
199 return +1; /* t is a prefix */
200 else if ((*ps & 0x80) || (*pt & 0x80))
201 /* not ascii anymore, do it the hard way from here on in */
204 us = toupper_ascii(*ps);
205 ut = toupper_ascii(*pt);
214 size = push_ucs2_allocate(&buffer_s, ps);
215 if (size == (size_t)-1) {
216 return strcmp(ps, pt);
217 /* Not quite the right answer, but finding the right one
218 under this failure case is expensive, and it's pretty close */
221 size = push_ucs2_allocate(&buffer_t, pt);
222 if (size == (size_t)-1) {
224 return strcmp(ps, pt);
225 /* Not quite the right answer, but finding the right one
226 under this failure case is expensive, and it's pretty close */
229 ret = strcasecmp_w(buffer_s, buffer_t);
237 Case insensitive string compararison, length limited.
239 int StrnCaseCmp(const char *s, const char *t, size_t n)
242 unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
243 unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
244 return strncmp(buf1,buf2,n);
250 * @note The comparison is case-insensitive.
252 BOOL strequal(const char *s1, const char *s2)
259 return(StrCaseCmp(s1,s2)==0);
263 * Compare 2 strings up to and including the nth char.
265 * @note The comparison is case-insensitive.
267 BOOL strnequal(const char *s1,const char *s2,size_t n)
271 if (!s1 || !s2 || !n)
274 return(StrnCaseCmp(s1,s2,n)==0);
278 Compare 2 strings (case sensitive).
281 BOOL strcsequal(const char *s1,const char *s2)
288 return(strcmp(s1,s2)==0);
292 Do a case-insensitive, whitespace-ignoring string compare.
295 int strwicmp(const char *psz1, const char *psz2)
297 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
298 /* appropriate value. */
301 else if (psz1 == NULL)
303 else if (psz2 == NULL)
306 /* sync the strings on first non-whitespace */
308 while (isspace((int)*psz1))
310 while (isspace((int)*psz2))
312 if (toupper_ascii(*psz1) != toupper_ascii(*psz2) || *psz1 == '\0'
318 return (*psz1 - *psz2);
323 Convert a string to upper case, but don't modify it.
326 char *strupper_static(const char *s)
337 Convert a string to "normal" form.
340 void strnorm(char *s, int case_default)
342 if (case_default == CASE_UPPER)
349 Check if a string is in "normal" case.
352 BOOL strisnormal(const char *s, int case_default)
354 if (case_default == CASE_UPPER)
355 return(!strhaslower(s));
357 return(!strhasupper(s));
363 NOTE: oldc and newc must be 7 bit characters
366 void string_replace( pstring s, char oldc, char newc )
370 /* this is quite a common operation, so we want it to be
371 fast. We optimise for the ascii case, knowing that all our
372 supported multi-byte character sets are ascii-compatible
373 (ie. they match for the first 128 chars) */
375 for (p = s; *p; p++) {
376 if (*p & 0x80) /* mb string - slow path. */
385 /* Slow (mb) path. */
386 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
387 /* With compose characters we must restart from the beginning. JRA. */
390 push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
391 string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
392 pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
396 Skip past some strings in a buffer.
399 char *skip_string(char *buf,size_t n)
402 buf += strlen(buf) + 1;
407 Count the number of characters in a string. Normally this will
408 be the same as the number of bytes in a string for single byte strings,
409 but will be different for multibyte.
412 size_t str_charnum(const char *s)
414 uint16 tmpbuf2[sizeof(pstring)];
415 push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
416 return strlen_w(tmpbuf2);
420 Count the number of characters in a string. Normally this will
421 be the same as the number of bytes in a string for single byte strings,
422 but will be different for multibyte.
425 size_t str_ascii_charnum(const char *s)
428 push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
429 return strlen(tmpbuf2);
432 BOOL trim_char(char *s,char cfront,char cback)
438 /* Ignore null or empty strings. */
439 if (!s || (s[0] == '\0'))
443 while (*fp && *fp == cfront)
446 /* We ate the string. */
454 ep = fp + strlen(fp) - 1;
456 /* Attempt ascii only. Bail for mb strings. */
457 while ((ep >= fp) && (*ep == cback)) {
459 if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
460 /* Could be mb... bail back to tim_string. */
468 return trim_string(s, cfront ? fs : NULL, bs);
474 /* We ate the string. */
481 memmove(s, fp, ep-fp+2);
486 Trim the specified elements off the front and back of a string.
489 BOOL trim_string(char *s,const char *front,const char *back)
496 /* Ignore null or empty strings. */
497 if (!s || (s[0] == '\0'))
500 front_len = front? strlen(front) : 0;
501 back_len = back? strlen(back) : 0;
506 while (len && strncmp(s, front, front_len)==0) {
507 /* Must use memmove here as src & dest can
508 * easily overlap. Found by valgrind. JRA. */
509 memmove(s, s+front_len, (len-front_len)+1);
516 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
517 s[len-back_len]='\0';
526 Does a string have any uppercase chars in it?
529 BOOL strhasupper(const char *s)
532 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
533 for(ptr=tmpbuf;*ptr;ptr++)
540 Does a string have any lowercase chars in it?
543 BOOL strhaslower(const char *s)
546 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
547 for(ptr=tmpbuf;*ptr;ptr++)
554 Find the number of 'c' chars in a string
557 size_t count_chars(const char *s,char c)
561 smb_ucs2_t *alloc_tmpbuf = NULL;
563 if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
567 for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
568 if(*ptr==UCS2_CHAR(c))
571 SAFE_FREE(alloc_tmpbuf);
576 Safe string copy into a known length string. maxlength does not
577 include the terminating zero.
580 char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
585 DEBUG(0,("ERROR: NULL dest in safe_strcpy, called from [%s][%d]\n", fn, line));
590 clobber_region(fn,line,dest, maxlength+1);
598 len = strnlen(src, maxlength+1);
600 if (len > maxlength) {
601 DEBUG(0,("ERROR: string overflow by %lu (%lu - %lu) in safe_strcpy [%.50s]\n",
602 (unsigned long)(len-maxlength), (unsigned long)len,
603 (unsigned long)maxlength, src));
607 memmove(dest, src, len);
613 Safe string cat into a string. maxlength does not
614 include the terminating zero.
616 char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size_t maxlength)
618 size_t src_len, dest_len;
621 DEBUG(0,("ERROR: NULL dest in safe_strcat, called from [%s][%d]\n", fn, line));
628 src_len = strnlen(src, maxlength + 1);
629 dest_len = strnlen(dest, maxlength + 1);
632 clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
635 if (src_len + dest_len > maxlength) {
636 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
637 (int)(src_len + dest_len - maxlength), src));
638 if (maxlength > dest_len) {
639 memcpy(&dest[dest_len], src, maxlength - dest_len);
645 memcpy(&dest[dest_len], src, src_len);
646 dest[dest_len + src_len] = 0;
651 Paranoid strcpy into a buffer of given length (includes terminating
652 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
653 and replaces with '_'. Deliberately does *NOT* check for multibyte
654 characters. Don't change it !
656 char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
661 clobber_region(fn, line, dest, maxlength);
665 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, called from [%s][%d]\n", fn, line));
675 if (len >= maxlength)
678 if (!other_safe_chars)
679 other_safe_chars = "";
681 for(i = 0; i < len; i++) {
682 int val = (src[i] & 0xff);
683 if (isupper_ascii(val) || islower_ascii(val) || isdigit(val) || strchr_m(other_safe_chars, val))
695 Like strncpy but always null terminates. Make sure there is room!
696 The variable n should always be one less than the available size.
698 char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
703 clobber_region(fn, line, dest, n+1);
707 DEBUG(0,("ERROR: NULL dest in StrnCpy, called from [%s][%d]\n", fn, line));
716 while (n-- && (*d = *src)) {
727 Like strncpy but copies up to the character marker. always null terminates.
728 returns a pointer to the character marker in the source string (src).
731 static char *strncpyn(char *dest, const char *src, size_t n, char c)
737 clobber_region(dest, n+1);
739 p = strchr_m(src, c);
741 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
745 str_len = PTR_DIFF(p, src);
746 strncpy(dest, src, MIN(n, str_len));
747 dest[str_len] = '\0';
754 Routine to get hex characters and turn them into a 16 byte array.
755 the array can be variable length, and any non-hex-numeric
756 characters are skipped. "0xnn" or "0Xnn" is specially catered
759 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
763 size_t strhex_to_str(char *p, size_t len, const char *strhex)
766 size_t num_chars = 0;
767 unsigned char lonybble, hinybble;
768 const char *hexchars = "0123456789ABCDEF";
769 char *p1 = NULL, *p2 = NULL;
771 for (i = 0; i < len && strhex[i] != 0; i++) {
772 if (strnequal(hexchars, "0x", 2)) {
773 i++; /* skip two chars */
777 if (!(p1 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
780 i++; /* next hex digit */
782 if (!(p2 = strchr_m(hexchars, toupper_ascii(strhex[i]))))
785 /* get the two nybbles */
786 hinybble = PTR_DIFF(p1, hexchars);
787 lonybble = PTR_DIFF(p2, hexchars);
789 p[num_chars] = (hinybble << 4) | lonybble;
798 DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
803 ret_blob = data_blob_talloc(mem_ctx, NULL, strlen(strhex)/2+1);
805 ret_blob = data_blob(NULL, strlen(strhex)/2+1);
807 ret_blob.length = strhex_to_str((char*)ret_blob.data,
815 * Routine to print a buffer as HEX digits, into an allocated string.
818 char *hex_encode(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
823 hex_buffer = TALLOC_ARRAY(mem_ctx, char, (len*2)+1);
825 for (i = 0; i < len; i++)
826 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
832 Check if a string is part of a list.
835 BOOL in_list(const char *s, const char *list, BOOL casesensitive)
843 while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
845 if (strcmp(tok,s) == 0)
848 if (StrCaseCmp(tok,s) == 0)
855 /* this is used to prevent lots of mallocs of size 1 */
856 static char *null_string = NULL;
859 Set a string value, allocing the space for the string
862 static BOOL string_init(char **dest,const char *src)
872 if((null_string = (char *)SMB_MALLOC(1)) == NULL) {
873 DEBUG(0,("string_init: malloc fail for null_string.\n"));
880 (*dest) = SMB_STRDUP(src);
881 if ((*dest) == NULL) {
882 DEBUG(0,("Out of memory in string_init\n"));
893 void string_free(char **s)
897 if (*s == null_string)
903 Set a string value, deallocating any existing space, and allocing the space
907 BOOL string_set(char **dest,const char *src)
910 return(string_init(dest,src));
914 Substitute a string for a pattern in another string. Make sure there is
917 This routine looks for pattern in s and replaces it with
918 insert. It may do multiple replacements or just one.
920 Any of " ; ' $ or ` in the insert string are replaced with _
921 if len==0 then the string cannot be extended. This is different from the old
922 use of len==0 which was for no length checks to be done.
925 void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
926 BOOL remove_unsafe_characters, BOOL replace_once, BOOL allow_trailing_dollar)
931 if (!insert || !pattern || !*pattern || !s)
934 ls = (ssize_t)strlen(s);
935 lp = (ssize_t)strlen(pattern);
936 li = (ssize_t)strlen(insert);
939 len = ls + 1; /* len is number of *bytes* */
941 while (lp <= ls && (p = strstr_m(s,pattern))) {
942 if (ls + (li-lp) >= len) {
943 DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
944 (int)(ls + (li-lp) - len),
949 memmove(p+li,p+lp,strlen(p+lp)+1);
958 /* allow a trailing $ (as in machine accounts) */
959 if (allow_trailing_dollar && (i == li - 1 )) {
966 if ( remove_unsafe_characters ) {
968 /* yes this break should be here since we want to
969 fall throw if not replacing unsafe chars */
984 void string_sub_once(char *s, const char *pattern, const char *insert, size_t len)
986 string_sub2( s, pattern, insert, len, True, True, False );
989 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
991 string_sub2( s, pattern, insert, len, True, False, False );
994 void fstring_sub(char *s,const char *pattern,const char *insert)
996 string_sub(s, pattern, insert, sizeof(fstring));
999 void pstring_sub(char *s,const char *pattern,const char *insert)
1001 string_sub(s, pattern, insert, sizeof(pstring));
1005 Similar to string_sub, but it will accept only allocated strings
1006 and may realloc them so pay attention at what you pass on no
1007 pointers inside strings, no pstrings or const may be passed
1011 char *realloc_string_sub(char *string, const char *pattern,
1016 ssize_t ls,lp,li,ld, i;
1018 if (!insert || !pattern || !*pattern || !string || !*string)
1023 in = SMB_STRDUP(insert);
1025 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1028 ls = (ssize_t)strlen(s);
1029 lp = (ssize_t)strlen(pattern);
1030 li = (ssize_t)strlen(insert);
1032 for (i=0;i<li;i++) {
1049 while ((p = strstr_m(s,pattern))) {
1051 int offset = PTR_DIFF(s,string);
1052 string = SMB_REALLOC(string, ls + ld + 1);
1054 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1058 p = string + offset + (p - s);
1061 memmove(p+li,p+lp,strlen(p+lp)+1);
1071 /* Same as string_sub, but returns a talloc'ed string */
1073 char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
1074 const char *pattern, const char *insert)
1079 ssize_t ls,lp,li,ld, i;
1081 if (!insert || !pattern || !*pattern || !src || !*src)
1084 string = talloc_strdup(mem_ctx, src);
1085 if (string == NULL) {
1086 DEBUG(0, ("talloc_strdup failed\n"));
1092 in = SMB_STRDUP(insert);
1094 DEBUG(0, ("talloc_string_sub: out of memory!\n"));
1097 ls = (ssize_t)strlen(s);
1098 lp = (ssize_t)strlen(pattern);
1099 li = (ssize_t)strlen(insert);
1101 for (i=0;i<li;i++) {
1118 while ((p = strstr_m(s,pattern))) {
1120 int offset = PTR_DIFF(s,string);
1121 string = TALLOC_REALLOC(mem_ctx, string, ls + ld + 1);
1123 DEBUG(0, ("talloc_string_sub: out of "
1128 p = string + offset + (p - s);
1131 memmove(p+li,p+lp,strlen(p+lp)+1);
1142 Similar to string_sub() but allows for any character to be substituted.
1144 if len==0 then the string cannot be extended. This is different from the old
1145 use of len==0 which was for no length checks to be done.
1148 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1153 if (!insert || !pattern || !s)
1156 ls = (ssize_t)strlen(s);
1157 lp = (ssize_t)strlen(pattern);
1158 li = (ssize_t)strlen(insert);
1164 len = ls + 1; /* len is number of *bytes* */
1166 while (lp <= ls && (p = strstr_m(s,pattern))) {
1167 if (ls + (li-lp) >= len) {
1168 DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1169 (int)(ls + (li-lp) - len),
1170 pattern, (int)len));
1174 memmove(p+li,p+lp,strlen(p+lp)+1);
1176 memcpy(p, insert, li);
1183 Similar to all_string_sub but for unicode strings.
1184 Return a new allocated unicode string.
1185 similar to string_sub() but allows for any character to be substituted.
1189 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
1190 const smb_ucs2_t *insert)
1193 const smb_ucs2_t *sp;
1194 size_t lr, lp, li, lt;
1196 if (!insert || !pattern || !*pattern || !s)
1199 lt = (size_t)strlen_w(s);
1200 lp = (size_t)strlen_w(pattern);
1201 li = (size_t)strlen_w(insert);
1204 const smb_ucs2_t *st = s;
1206 while ((sp = strstr_w(st, pattern))) {
1212 r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
1214 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1218 while ((sp = strstr_w(s, pattern))) {
1219 memcpy(rp, s, (sp - s));
1220 rp += ((sp - s) / sizeof(smb_ucs2_t));
1221 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1225 lr = ((rp - r) / sizeof(smb_ucs2_t));
1227 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1235 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1240 if (!insert || !pattern || !s)
1242 push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1243 push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1244 return all_string_sub_w(s, p, i);
1249 Splits out the front and back at a separator.
1252 static void split_at_last_component(char *path, char *front, char sep, char *back)
1254 char *p = strrchr_m(path, sep);
1260 pstrcpy(front, path);
1274 Write an octal as a string.
1277 const char *octal_string(int i)
1279 static char ret[64];
1282 slprintf(ret, sizeof(ret)-1, "0%o", i);
1288 Truncate a string at a specified length.
1291 char *string_truncate(char *s, unsigned int length)
1293 if (s && strlen(s) > length)
1299 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1300 We convert via ucs2 for now.
1303 char *strchr_m(const char *src, char c)
1310 /* characters below 0x3F are guaranteed to not appear in
1311 non-initial position in multi-byte charsets */
1312 if ((c & 0xC0) == 0) {
1313 return strchr(src, c);
1316 /* this is quite a common operation, so we want it to be
1317 fast. We optimise for the ascii case, knowing that all our
1318 supported multi-byte character sets are ascii-compatible
1319 (ie. they match for the first 128 chars) */
1321 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1329 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1330 /* With compose characters we must restart from the beginning. JRA. */
1334 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1335 p = strchr_w(ws, UCS2_CHAR(c));
1339 pull_ucs2_pstring(s2, ws);
1340 return (char *)(s+strlen(s2));
1343 char *strrchr_m(const char *s, char c)
1345 /* characters below 0x3F are guaranteed to not appear in
1346 non-initial position in multi-byte charsets */
1347 if ((c & 0xC0) == 0) {
1348 return strrchr(s, c);
1351 /* this is quite a common operation, so we want it to be
1352 fast. We optimise for the ascii case, knowing that all our
1353 supported multi-byte character sets are ascii-compatible
1354 (ie. they match for the first 128 chars). Also, in Samba
1355 we only search for ascii characters in 'c' and that
1356 in all mb character sets with a compound character
1357 containing c, if 'c' is not a match at position
1358 p, then p[-1] > 0x7f. JRA. */
1361 size_t len = strlen(s);
1363 BOOL got_mb = False;
1370 /* Could be a match. Part of a multibyte ? */
1371 if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
1372 /* Yep - go slow :-( */
1376 /* No - we have a match ! */
1379 } while (cp-- != s);
1384 /* String contained a non-ascii char. Slow path. */
1390 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1391 p = strrchr_w(ws, UCS2_CHAR(c));
1395 pull_ucs2_pstring(s2, ws);
1396 return (char *)(s+strlen(s2));
1400 /***********************************************************************
1401 Return the equivalent of doing strrchr 'n' times - always going
1403 ***********************************************************************/
1405 char *strnrchr_m(const char *s, char c, unsigned int n)
1411 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1412 p = strnrchr_w(ws, UCS2_CHAR(c), n);
1416 pull_ucs2_pstring(s2, ws);
1417 return (char *)(s+strlen(s2));
1420 /***********************************************************************
1421 strstr_m - We convert via ucs2 for now.
1422 ***********************************************************************/
1424 char *strstr_m(const char *src, const char *findstr)
1427 smb_ucs2_t *src_w, *find_w;
1432 size_t findstr_len = 0;
1434 /* for correctness */
1439 /* Samba does single character findstr calls a *lot*. */
1440 if (findstr[1] == '\0')
1441 return strchr_m(src, *findstr);
1443 /* We optimise for the ascii case, knowing that all our
1444 supported multi-byte character sets are ascii-compatible
1445 (ie. they match for the first 128 chars) */
1447 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1448 if (*s == *findstr) {
1450 findstr_len = strlen(findstr);
1452 if (strncmp(s, findstr, findstr_len) == 0) {
1461 #if 1 /* def BROKEN_UNICODE_COMPOSE_CHARACTERS */
1462 /* 'make check' fails unless we do this */
1464 /* With compose characters we must restart from the beginning. JRA. */
1468 if (push_ucs2_allocate(&src_w, src) == (size_t)-1) {
1469 DEBUG(0,("strstr_m: src malloc fail\n"));
1473 if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
1475 DEBUG(0,("strstr_m: find malloc fail\n"));
1479 p = strstr_w(src_w, find_w);
1488 if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
1491 DEBUG(0,("strstr_m: dest malloc fail\n"));
1494 retp = (char *)(s+strlen(s2));
1502 Convert a string to lower case.
1505 void strlower_m(char *s)
1510 /* this is quite a common operation, so we want it to be
1511 fast. We optimise for the ascii case, knowing that all our
1512 supported multi-byte character sets are ascii-compatible
1513 (ie. they match for the first 128 chars) */
1515 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1516 *s = tolower_ascii((unsigned char)*s);
1523 /* I assume that lowercased string takes the same number of bytes
1524 * as source string even in UTF-8 encoding. (VIV) */
1525 len = strlen(s) + 1;
1528 unix_strlower(s,len,s,len);
1529 /* Catch mb conversion errors that may not terminate. */
1536 Convert a string to upper case.
1539 void strupper_m(char *s)
1544 /* this is quite a common operation, so we want it to be
1545 fast. We optimise for the ascii case, knowing that all our
1546 supported multi-byte character sets are ascii-compatible
1547 (ie. they match for the first 128 chars) */
1549 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1550 *s = toupper_ascii((unsigned char)*s);
1557 /* I assume that lowercased string takes the same number of bytes
1558 * as source string even in multibyte encoding. (VIV) */
1559 len = strlen(s) + 1;
1562 unix_strupper(s,len,s,len);
1563 /* Catch mb conversion errors that may not terminate. */
1570 Return a RFC2254 binary string representation of a buffer.
1571 Used in LDAP filters.
1575 char *binary_string(char *buf, int len)
1579 const char *hex = "0123456789ABCDEF";
1580 s = SMB_MALLOC(len * 3 + 1);
1583 for (j=i=0;i<len;i++) {
1585 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1586 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1594 Just a typesafety wrapper for snprintf into a pstring.
1597 int pstr_sprintf(pstring s, const char *fmt, ...)
1603 ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1610 Just a typesafety wrapper for snprintf into a fstring.
1613 int fstr_sprintf(fstring s, const char *fmt, ...)
1619 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1625 #if !defined(HAVE_STRNDUP) || defined(BROKEN_STRNDUP)
1627 Some platforms don't have strndup.
1629 #if defined(PARANOID_MALLOC_CHECKER)
1633 char *strndup(const char *s, size_t n)
1638 ret = SMB_MALLOC(n+1);
1647 #if defined(PARANOID_MALLOC_CHECKER)
1648 #define strndup(s,n) __ERROR_DONT_USE_STRNDUP_DIRECTLY
1653 #if !defined(HAVE_STRNLEN) || defined(BROKEN_STRNLEN)
1655 Some platforms don't have strnlen
1658 size_t strnlen(const char *s, size_t n)
1661 for (i=0; i<n && s[i] != '\0'; i++)
1668 List of Strings manipulation functions
1671 #define S_LIST_ABS 16 /* List Allocation Block Size */
1673 static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
1675 char **list, **rlist;
1681 if (!string || !*string)
1684 s = talloc_strdup(mem_ctx, string);
1686 s = SMB_STRDUP(string);
1689 DEBUG(0,("str_list_make: Unable to allocate memory"));
1692 if (!sep) sep = LIST_SEP;
1698 while (next_token(&str, tok, sep, sizeof(tok))) {
1700 lsize += S_LIST_ABS;
1702 rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list, char *, lsize +1);
1704 /* We need to keep the old list on error so we can free the elements
1705 if the realloc fails. */
1706 rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
1709 DEBUG(0,("str_list_make: Unable to allocate memory"));
1710 str_list_free(&list);
1720 memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1724 list[num] = talloc_strdup(mem_ctx, tok);
1726 list[num] = SMB_STRDUP(tok);
1730 DEBUG(0,("str_list_make: Unable to allocate memory"));
1731 str_list_free(&list);
1752 char **str_list_make_talloc(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
1754 return str_list_make_internal(mem_ctx, string, sep);
1757 char **str_list_make(const char *string, const char *sep)
1759 return str_list_make_internal(NULL, string, sep);
1762 BOOL str_list_copy(char ***dest, const char **src)
1764 char **list, **rlist;
1776 lsize += S_LIST_ABS;
1777 rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
1779 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1780 str_list_free(&list);
1784 memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1787 list[num] = SMB_STRDUP(src[num]);
1789 DEBUG(0,("str_list_copy: Unable to allocate memory"));
1790 str_list_free(&list);
1802 * Return true if all the elements of the list match exactly.
1804 BOOL str_list_compare(char **list1, char **list2)
1808 if (!list1 || !list2)
1809 return (list1 == list2);
1811 for (num = 0; list1[num]; num++) {
1814 if (!strcsequal(list1[num], list2[num]))
1818 return False; /* if list2 has more elements than list1 fail */
1823 static void str_list_free_internal(TALLOC_CTX *mem_ctx, char ***list)
1827 if (!list || !*list)
1830 for(; *tlist; tlist++) {
1832 TALLOC_FREE(*tlist);
1838 TALLOC_FREE(*tlist);
1844 void str_list_free_talloc(TALLOC_CTX *mem_ctx, char ***list)
1846 str_list_free_internal(mem_ctx, list);
1849 void str_list_free(char ***list)
1851 str_list_free_internal(NULL, list);
1854 /******************************************************************************
1855 *****************************************************************************/
1857 int str_list_count( const char **list )
1864 /* count the number of list members */
1866 for ( i=0; *list; i++, list++ );
1871 /******************************************************************************
1872 version of standard_sub_basic() for string lists; uses alloc_sub_basic()
1874 *****************************************************************************/
1876 BOOL str_list_sub_basic( char **list, const char *smb_name )
1882 tmpstr = alloc_sub_basic(smb_name, s);
1884 DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
1897 /******************************************************************************
1898 substritute a specific pattern in a string list
1899 *****************************************************************************/
1901 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1904 ssize_t ls, lp, li, ld, i, d;
1913 lp = (ssize_t)strlen(pattern);
1914 li = (ssize_t)strlen(insert);
1919 ls = (ssize_t)strlen(s);
1921 while ((p = strstr_m(s, pattern))) {
1925 t = (char *) SMB_MALLOC(ls +ld +1);
1927 DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1930 memcpy(t, *list, d);
1931 memcpy(t +d +li, p +lp, ls -d -lp +1);
1938 for (i = 0; i < li; i++) {
1939 switch (insert[i]) {
1951 t[d +i] = insert[i];
1964 #define IPSTR_LIST_SEP ","
1965 #define IPSTR_LIST_CHAR ','
1968 * Add ip string representation to ipstr list. Used also
1969 * as part of @function ipstr_list_make
1971 * @param ipstr_list pointer to string containing ip list;
1972 * MUST BE already allocated and IS reallocated if necessary
1973 * @param ipstr_size pointer to current size of ipstr_list (might be changed
1974 * as a result of reallocation)
1975 * @param ip IP address which is to be added to list
1976 * @return pointer to string appended with new ip and possibly
1977 * reallocated to new length
1980 char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
1982 char* new_ipstr = NULL;
1984 /* arguments checking */
1985 if (!ipstr_list || !service) return NULL;
1987 /* attempt to convert ip to a string and append colon separator to it */
1989 asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list, IPSTR_LIST_SEP,
1990 inet_ntoa(service->ip), service->port);
1991 SAFE_FREE(*ipstr_list);
1993 asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
1995 *ipstr_list = new_ipstr;
2001 * Allocate and initialise an ipstr list using ip adresses
2002 * passed as arguments.
2004 * @param ipstr_list pointer to string meant to be allocated and set
2005 * @param ip_list array of ip addresses to place in the list
2006 * @param ip_count number of addresses stored in ip_list
2007 * @return pointer to allocated ip string
2010 char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
2014 /* arguments checking */
2015 if (!ip_list && !ipstr_list) return 0;
2019 /* process ip addresses given as arguments */
2020 for (i = 0; i < ip_count; i++)
2021 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
2023 return (*ipstr_list);
2028 * Parse given ip string list into array of ip addresses
2029 * (as ip_service structures)
2030 * e.g. 192.168.1.100:389,192.168.1.78, ...
2032 * @param ipstr ip string list to be parsed
2033 * @param ip_list pointer to array of ip addresses which is
2034 * allocated by this function and must be freed by caller
2035 * @return number of succesfully parsed addresses
2038 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
2044 if (!ipstr_list || !ip_list)
2047 count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
2048 if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
2049 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
2054 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count;
2057 struct in_addr addr;
2059 char *p = strchr(token_str, ':');
2066 /* convert single token to ip address */
2067 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
2070 (*ip_list)[i].ip = addr;
2071 (*ip_list)[i].port = port;
2079 * Safely free ip string list
2081 * @param ipstr_list ip string list to be freed
2084 void ipstr_list_free(char* ipstr_list)
2086 SAFE_FREE(ipstr_list);
2091 Unescape a URL encoded string, in place.
2094 void rfc1738_unescape(char *buf)
2098 while (p && *p && (p=strchr_m(p,'%'))) {
2102 if (c1 >= '0' && c1 <= '9')
2104 else if (c1 >= 'A' && c1 <= 'F')
2106 else if (c1 >= 'a' && c1 <= 'f')
2108 else {p++; continue;}
2110 if (c2 >= '0' && c2 <= '9')
2112 else if (c2 >= 'A' && c2 <= 'F')
2114 else if (c2 >= 'a' && c2 <= 'f')
2116 else {p++; continue;}
2120 memmove(p+1, p+3, strlen(p+3)+1);
2125 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2128 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
2130 DATA_BLOB base64_decode_data_blob(const char *s)
2132 int bit_offset, byte_offset, idx, i, n;
2133 DATA_BLOB decoded = data_blob(s, strlen(s)+1);
2134 unsigned char *d = decoded.data;
2139 while (*s && (p=strchr_m(b64,*s))) {
2140 idx = (int)(p - b64);
2141 byte_offset = (i*6)/8;
2142 bit_offset = (i*6)%8;
2143 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
2144 if (bit_offset < 3) {
2145 d[byte_offset] |= (idx << (2-bit_offset));
2148 d[byte_offset] |= (idx >> (bit_offset-2));
2149 d[byte_offset+1] = 0;
2150 d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
2156 if ((n > 0) && (*s == '=')) {
2166 * Decode a base64 string in-place - wrapper for the above
2168 void base64_decode_inplace(char *s)
2170 DATA_BLOB decoded = base64_decode_data_blob(s);
2172 if ( decoded.length != 0 ) {
2173 memcpy(s, decoded.data, decoded.length);
2175 /* null terminate */
2176 s[decoded.length] = '\0';
2181 data_blob_free(&decoded);
2185 * Encode a base64 string into a malloc()ed string caller to free.
2187 *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
2189 char * base64_encode_data_blob(DATA_BLOB data)
2193 size_t out_cnt, len, output_len;
2196 if (!data.length || !data.data)
2201 output_len = data.length * 2;
2202 result = SMB_MALLOC(output_len); /* get us plenty of space */
2204 while (len-- && out_cnt < (data.length * 2) - 5) {
2205 int c = (unsigned char) *(data.data++);
2208 if (char_count == 3) {
2209 result[out_cnt++] = b64[bits >> 18];
2210 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2211 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2212 result[out_cnt++] = b64[bits & 0x3f];
2219 if (char_count != 0) {
2220 bits <<= 16 - (8 * char_count);
2221 result[out_cnt++] = b64[bits >> 18];
2222 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
2223 if (char_count == 1) {
2224 result[out_cnt++] = '=';
2225 result[out_cnt++] = '=';
2227 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
2228 result[out_cnt++] = '=';
2231 result[out_cnt] = '\0'; /* terminate */
2235 /* read a SMB_BIG_UINT from a string */
2236 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
2239 SMB_BIG_UINT val = -1;
2240 const char *p = nptr;
2242 while (p && *p && isspace(*p))
2244 #ifdef LARGE_SMB_OFF_T
2245 sscanf(p,"%llu",&val);
2246 #else /* LARGE_SMB_OFF_T */
2247 sscanf(p,"%lu",&val);
2248 #endif /* LARGE_SMB_OFF_T */
2250 while (p && *p && isdigit(*p))
2258 void string_append(char **left, const char *right)
2260 int new_len = strlen(right) + 1;
2262 if (*left == NULL) {
2263 *left = SMB_MALLOC(new_len);
2266 new_len += strlen(*left);
2267 *left = SMB_REALLOC(*left, new_len);
2270 if (*left == NULL) {
2274 safe_strcat(*left, right, new_len-1);
2277 BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
2278 const char *str, const char ***strings,
2281 char *dup_str = talloc_strdup(mem_ctx, str);
2283 *strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings, const char *, (*num)+1);
2285 if ((*strings == NULL) || (dup_str == NULL))
2288 (*strings)[*num] = dup_str;
2293 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
2294 * error checking in between. The indiation that something weird happened is
2297 void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
2298 size_t *bufsize, const char *fmt, ...)
2305 /* len<0 is an internal marker that something failed */
2309 if (*string == NULL) {
2313 if (mem_ctx != NULL)
2314 *string = TALLOC_ARRAY(mem_ctx, char, *bufsize);
2316 *string = SMB_MALLOC_ARRAY(char, *bufsize);
2318 if (*string == NULL)
2323 ret = vasprintf(&newstr, fmt, ap);
2331 while ((*len)+ret >= *bufsize) {
2334 if (*bufsize >= (1024*1024*256))
2339 if (mem_ctx != NULL) {
2340 *string = TALLOC_REALLOC_ARRAY(mem_ctx, *string, char,
2343 *string = SMB_REALLOC_ARRAY(*string, char, *bufsize);
2346 if (*string == NULL) {
2351 StrnCpy((*string)+(*len), newstr, ret);
2362 Returns the substring from src between the first occurrence of
2363 the char "front" and the first occurence of the char "back".
2364 Mallocs the return string which must be freed. Not for use
2365 with wide character strings.
2367 char *sstring_sub(const char *src, char front, char back)
2369 char *temp1, *temp2, *temp3;
2372 temp1 = strchr(src, front);
2373 if (temp1 == NULL) return NULL;
2374 temp2 = strchr(src, back);
2375 if (temp2 == NULL) return NULL;
2376 len = temp2 - temp1;
2377 if (len <= 0) return NULL;
2378 temp3 = (char*)SMB_MALLOC(len);
2379 if (temp3 == NULL) {
2380 DEBUG(1,("Malloc failure in sstring_sub\n"));
2383 memcpy(temp3, temp1+1, len-1);
2384 temp3[len-1] = '\0';
2388 /********************************************************************
2389 Check a string for any occurrences of a specified list of invalid
2391 ********************************************************************/
2393 BOOL validate_net_name( const char *name, const char *invalid_chars, int max_len )
2397 for ( i=0; i<max_len && name[i]; i++ ) {
2398 /* fail if strchr_m() finds one of the invalid characters */
2399 if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {