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++) {
65 if (*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=malloc(ictok*sizeof(char *))))
152 * Case insensitive string compararison.
154 * iconv does not directly give us a way to compare strings in
155 * arbitrary unix character sets -- all we can is convert and then
156 * compare. This is expensive.
158 * As an optimization, we do a first pass that considers only the
159 * prefix of the strings that is entirely 7-bit. Within this, we
160 * check whether they have the same value.
162 * Hopefully this will often give the answer without needing to copy.
163 * In particular it should speed comparisons to literal ascii strings
164 * or comparisons of strings that are "obviously" different.
166 * If we find a non-ascii character we fall back to converting via
169 * This should never be slower than convering the whole thing, and
172 * A different optimization would be to compare for bitwise equality
173 * in the binary encoding. (It would be possible thought hairy to do
174 * both simultaneously.) But in that case if they turn out to be
175 * different, we'd need to restart the whole thing.
177 * Even better is to implement strcasecmp for each encoding and use a
180 int StrCaseCmp(const char *s, const char *t)
183 const char * ps, * pt;
185 smb_ucs2_t *buffer_s, *buffer_t;
188 for (ps = s, pt = t; ; ps++, pt++) {
192 return 0; /* both ended */
194 return -1; /* s is a prefix */
196 return +1; /* t is a prefix */
197 else if ((*ps & 0x80) || (*pt & 0x80))
198 /* not ascii anymore, do it the hard way from here on in */
211 size = push_ucs2_allocate(&buffer_s, s);
212 if (size == (size_t)-1) {
214 /* Not quite the right answer, but finding the right one
215 under this failure case is expensive, and it's pretty close */
218 size = push_ucs2_allocate(&buffer_t, t);
219 if (size == (size_t)-1) {
222 /* Not quite the right answer, but finding the right one
223 under this failure case is expensive, and it's pretty close */
226 ret = strcasecmp_w(buffer_s, buffer_t);
234 Case insensitive string compararison, length limited.
236 int StrnCaseCmp(const char *s, const char *t, size_t n)
239 unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
240 unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
241 return strncmp(buf1,buf2,n);
247 * @note The comparison is case-insensitive.
249 BOOL strequal(const char *s1, const char *s2)
256 return(StrCaseCmp(s1,s2)==0);
260 * Compare 2 strings up to and including the nth char.
262 * @note The comparison is case-insensitive.
264 BOOL strnequal(const char *s1,const char *s2,size_t n)
268 if (!s1 || !s2 || !n)
271 return(StrnCaseCmp(s1,s2,n)==0);
275 Compare 2 strings (case sensitive).
278 BOOL strcsequal(const char *s1,const char *s2)
285 return(strcmp(s1,s2)==0);
289 Do a case-insensitive, whitespace-ignoring string compare.
292 int strwicmp(const char *psz1, const char *psz2)
294 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
295 /* appropriate value. */
298 else if (psz1 == NULL)
300 else if (psz2 == NULL)
303 /* sync the strings on first non-whitespace */
305 while (isspace((int)*psz1))
307 while (isspace((int)*psz2))
309 if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0'
315 return (*psz1 - *psz2);
320 Convert a string to upper case, but don't modify it.
323 char *strupper_static(const char *s)
334 Convert a string to "normal" form.
337 void strnorm(char *s)
339 extern int case_default;
340 if (case_default == CASE_UPPER)
347 Check if a string is in "normal" case.
350 BOOL strisnormal(const char *s)
352 extern int case_default;
353 if (case_default == CASE_UPPER)
354 return(!strhaslower(s));
356 return(!strhasupper(s));
362 NOTE: oldc and newc must be 7 bit characters
365 void string_replace(pstring s,char oldc,char newc)
369 /* this is quite a common operation, so we want it to be
370 fast. We optimise for the ascii case, knowing that all our
371 supported multi-byte character sets are ascii-compatible
372 (ie. they match for the first 128 chars) */
374 for (p = (unsigned char *)s; *p; p++) {
375 if (*p & 0x80) /* mb string - slow path. */
384 /* Slow (mb) path. */
385 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
386 /* With compose characters we must restart from the beginning. JRA. */
389 push_ucs2(NULL, tmpbuf, p, sizeof(tmpbuf), STR_TERMINATE);
390 string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
391 pull_ucs2(NULL, p, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
395 Skip past some strings in a buffer.
398 char *skip_string(char *buf,size_t n)
401 buf += strlen(buf) + 1;
406 Count the number of characters in a string. Normally this will
407 be the same as the number of bytes in a string for single byte strings,
408 but will be different for multibyte.
411 size_t str_charnum(const char *s)
413 uint16 tmpbuf2[sizeof(pstring)];
414 push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
415 return strlen_w(tmpbuf2);
419 Count the number of characters in a string. Normally this will
420 be the same as the number of bytes in a string for single byte strings,
421 but will be different for multibyte.
424 size_t str_ascii_charnum(const char *s)
427 push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
428 return strlen(tmpbuf2);
431 BOOL trim_char(char *s,char cfront,char cback)
437 /* Ignore null or empty strings. */
438 if (!s || (s[0] == '\0'))
442 while (*fp && *fp == cfront)
445 /* We ate the string. */
453 ep = fp + strlen(fp) - 1;
455 /* Attempt ascii only. Bail for mb strings. */
456 while ((ep >= fp) && (*ep == cback)) {
458 if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
459 /* Could be mb... bail back to tim_string. */
467 return trim_string(s, cfront ? fs : NULL, bs);
473 /* We ate the string. */
480 memmove(s, fp, ep-fp+2);
485 Trim the specified elements off the front and back of a string.
488 BOOL trim_string(char *s,const char *front,const char *back)
495 /* Ignore null or empty strings. */
496 if (!s || (s[0] == '\0'))
499 front_len = front? strlen(front) : 0;
500 back_len = back? strlen(back) : 0;
505 while (len && strncmp(s, front, front_len)==0) {
506 /* Must use memmove here as src & dest can
507 * easily overlap. Found by valgrind. JRA. */
508 memmove(s, s+front_len, (len-front_len)+1);
515 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
516 s[len-back_len]='\0';
525 Does a string have any uppercase chars in it?
528 BOOL strhasupper(const char *s)
531 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
532 for(ptr=tmpbuf;*ptr;ptr++)
539 Does a string have any lowercase chars in it?
542 BOOL strhaslower(const char *s)
545 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
546 for(ptr=tmpbuf;*ptr;ptr++)
553 Find the number of 'c' chars in a string
556 size_t count_chars(const char *s,char c)
560 smb_ucs2_t *alloc_tmpbuf;
562 if (push_ucs2_allocate(&alloc_tmpbuf, s) == (size_t)-1) {
566 for(count=0,ptr=alloc_tmpbuf;*ptr;ptr++)
567 if(*ptr==UCS2_CHAR(c))
574 Safe string copy into a known length string. maxlength does not
575 include the terminating zero.
578 char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
583 DEBUG(0,("ERROR: NULL dest in safe_strcpy, called from [%s][%d]\n", fn, line));
588 clobber_region(fn,line,dest, maxlength+1);
596 len = strnlen(src, maxlength+1);
598 if (len > maxlength) {
599 DEBUG(0,("ERROR: string overflow by %lu (%lu - %lu) in safe_strcpy [%.50s]\n",
600 (unsigned long)(len-maxlength), (unsigned long)len,
601 (unsigned long)maxlength, src));
605 memmove(dest, src, len);
611 Safe string cat into a string. maxlength does not
612 include the terminating zero.
614 char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size_t maxlength)
616 size_t src_len, dest_len;
619 DEBUG(0,("ERROR: NULL dest in safe_strcat, called from [%s][%d]\n", fn, line));
626 src_len = strnlen(src, maxlength + 1);
627 dest_len = strnlen(dest, maxlength + 1);
630 clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
633 if (src_len + dest_len > maxlength) {
634 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
635 (int)(src_len + dest_len - maxlength), src));
636 if (maxlength > dest_len) {
637 memcpy(&dest[dest_len], src, maxlength - dest_len);
643 memcpy(&dest[dest_len], src, src_len);
644 dest[dest_len + src_len] = 0;
649 Paranoid strcpy into a buffer of given length (includes terminating
650 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
651 and replaces with '_'. Deliberately does *NOT* check for multibyte
652 characters. Don't change it !
654 char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
659 clobber_region(fn, line, dest, maxlength);
663 DEBUG(0,("ERROR: NULL dest in alpha_strcpy, called from [%s][%d]\n", fn, line));
673 if (len >= maxlength)
676 if (!other_safe_chars)
677 other_safe_chars = "";
679 for(i = 0; i < len; i++) {
680 int val = (src[i] & 0xff);
681 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
693 Like strncpy but always null terminates. Make sure there is room!
694 The variable n should always be one less than the available size.
696 char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
701 clobber_region(fn, line, dest, n+1);
705 DEBUG(0,("ERROR: NULL dest in StrnCpy, called from [%s][%d]\n", fn, line));
714 while (n-- && (*d = *src)) {
725 Like strncpy but copies up to the character marker. always null terminates.
726 returns a pointer to the character marker in the source string (src).
729 static char *strncpyn(char *dest, const char *src, size_t n, char c)
735 clobber_region(dest, n+1);
737 p = strchr_m(src, c);
739 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
743 str_len = PTR_DIFF(p, src);
744 strncpy(dest, src, MIN(n, str_len));
745 dest[str_len] = '\0';
752 Routine to get hex characters and turn them into a 16 byte array.
753 the array can be variable length, and any non-hex-numeric
754 characters are skipped. "0xnn" or "0Xnn" is specially catered
757 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
761 size_t strhex_to_str(char *p, size_t len, const char *strhex)
764 size_t num_chars = 0;
765 unsigned char lonybble, hinybble;
766 const char *hexchars = "0123456789ABCDEF";
767 char *p1 = NULL, *p2 = NULL;
769 for (i = 0; i < len && strhex[i] != 0; i++) {
770 if (strnequal(hexchars, "0x", 2)) {
771 i++; /* skip two chars */
775 if (!(p1 = strchr_m(hexchars, toupper(strhex[i]))))
778 i++; /* next hex digit */
780 if (!(p2 = strchr_m(hexchars, toupper(strhex[i]))))
783 /* get the two nybbles */
784 hinybble = PTR_DIFF(p1, hexchars);
785 lonybble = PTR_DIFF(p2, hexchars);
787 p[num_chars] = (hinybble << 4) | lonybble;
797 * Routine to print a buffer as HEX digits, into an allocated string.
800 void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
805 *out_hex_buffer = smb_xmalloc((len*2)+1);
806 hex_buffer = *out_hex_buffer;
808 for (i = 0; i < len; i++)
809 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
813 Check if a string is part of a list.
816 BOOL in_list(char *s,char *list,BOOL casesensitive)
824 while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
826 if (strcmp(tok,s) == 0)
829 if (StrCaseCmp(tok,s) == 0)
836 /* this is used to prevent lots of mallocs of size 1 */
837 static char *null_string = NULL;
840 Set a string value, allocing the space for the string
843 static BOOL string_init(char **dest,const char *src)
853 if((null_string = (char *)malloc(1)) == NULL) {
854 DEBUG(0,("string_init: malloc fail for null_string.\n"));
861 (*dest) = strdup(src);
862 if ((*dest) == NULL) {
863 DEBUG(0,("Out of memory in string_init\n"));
874 void string_free(char **s)
878 if (*s == null_string)
884 Set a string value, deallocating any existing space, and allocing the space
888 BOOL string_set(char **dest,const char *src)
891 return(string_init(dest,src));
895 Substitute a string for a pattern in another string. Make sure there is
898 This routine looks for pattern in s and replaces it with
899 insert. It may do multiple replacements.
901 Any of " ; ' $ or ` in the insert string are replaced with _
902 if len==0 then the string cannot be extended. This is different from the old
903 use of len==0 which was for no length checks to be done.
906 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
911 if (!insert || !pattern || !*pattern || !s)
914 ls = (ssize_t)strlen(s);
915 lp = (ssize_t)strlen(pattern);
916 li = (ssize_t)strlen(insert);
919 len = ls + 1; /* len is number of *bytes* */
921 while (lp <= ls && (p = strstr(s,pattern))) {
922 if (ls + (li-lp) >= len) {
923 DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
924 (int)(ls + (li-lp) - len),
929 memmove(p+li,p+lp,strlen(p+lp)+1);
952 void fstring_sub(char *s,const char *pattern,const char *insert)
954 string_sub(s, pattern, insert, sizeof(fstring));
957 void pstring_sub(char *s,const char *pattern,const char *insert)
959 string_sub(s, pattern, insert, sizeof(pstring));
963 Similar to string_sub, but it will accept only allocated strings
964 and may realloc them so pay attention at what you pass on no
965 pointers inside strings, no pstrings or const may be passed
969 char *realloc_string_sub(char *string, const char *pattern, const char *insert)
973 ssize_t ls,lp,li,ld, i;
975 if (!insert || !pattern || !*pattern || !string || !*string)
982 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
985 ls = (ssize_t)strlen(s);
986 lp = (ssize_t)strlen(pattern);
987 li = (ssize_t)strlen(insert);
1006 while ((p = strstr(s,pattern))) {
1008 int offset = PTR_DIFF(s,string);
1009 char *t = Realloc(string, ls + ld + 1);
1011 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
1016 p = t + offset + (p - s);
1019 memmove(p+li,p+lp,strlen(p+lp)+1);
1030 Similar to string_sub() but allows for any character to be substituted.
1032 if len==0 then the string cannot be extended. This is different from the old
1033 use of len==0 which was for no length checks to be done.
1036 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
1041 if (!insert || !pattern || !s)
1044 ls = (ssize_t)strlen(s);
1045 lp = (ssize_t)strlen(pattern);
1046 li = (ssize_t)strlen(insert);
1052 len = ls + 1; /* len is number of *bytes* */
1054 while (lp <= ls && (p = strstr(s,pattern))) {
1055 if (ls + (li-lp) >= len) {
1056 DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
1057 (int)(ls + (li-lp) - len),
1058 pattern, (int)len));
1062 memmove(p+li,p+lp,strlen(p+lp)+1);
1064 memcpy(p, insert, li);
1071 Similar to all_string_sub but for unicode strings.
1072 Return a new allocated unicode string.
1073 similar to string_sub() but allows for any character to be substituted.
1077 static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
1078 const smb_ucs2_t *insert)
1081 const smb_ucs2_t *sp;
1082 size_t lr, lp, li, lt;
1084 if (!insert || !pattern || !*pattern || !s)
1087 lt = (size_t)strlen_w(s);
1088 lp = (size_t)strlen_w(pattern);
1089 li = (size_t)strlen_w(insert);
1092 const smb_ucs2_t *st = s;
1094 while ((sp = strstr_w(st, pattern))) {
1100 r = rp = (smb_ucs2_t *)malloc((lt + 1)*(sizeof(smb_ucs2_t)));
1102 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
1106 while ((sp = strstr_w(s, pattern))) {
1107 memcpy(rp, s, (sp - s));
1108 rp += ((sp - s) / sizeof(smb_ucs2_t));
1109 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
1113 lr = ((rp - r) / sizeof(smb_ucs2_t));
1115 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
1123 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
1128 if (!insert || !pattern || !s)
1130 push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
1131 push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
1132 return all_string_sub_w(s, p, i);
1137 Splits out the front and back at a separator.
1140 static void split_at_last_component(char *path, char *front, char sep, char *back)
1142 char *p = strrchr_m(path, sep);
1148 pstrcpy(front, path);
1162 Write an octal as a string.
1165 const char *octal_string(int i)
1167 static char ret[64];
1170 slprintf(ret, sizeof(ret)-1, "0%o", i);
1176 Truncate a string at a specified length.
1179 char *string_truncate(char *s, unsigned int length)
1181 if (s && strlen(s) > length)
1187 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1188 We convert via ucs2 for now.
1191 char *strchr_m(const char *src, char c)
1198 /* this is quite a common operation, so we want it to be
1199 fast. We optimise for the ascii case, knowing that all our
1200 supported multi-byte character sets are ascii-compatible
1201 (ie. they match for the first 128 chars) */
1203 for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
1211 #ifdef BROKEN_UNICODE_COMPOSE_CHARACTERS
1212 /* With compose characters we must restart from the beginning. JRA. */
1216 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1217 p = strchr_w(ws, UCS2_CHAR(c));
1221 pull_ucs2_pstring(s2, ws);
1222 return (char *)(s+strlen(s2));
1225 char *strrchr_m(const char *s, char c)
1227 /* this is quite a common operation, so we want it to be
1228 fast. We optimise for the ascii case, knowing that all our
1229 supported multi-byte character sets are ascii-compatible
1230 (ie. they match for the first 128 chars). Also, in Samba
1231 we only search for ascii characters in 'c' and that
1232 in all mb character sets with a compound character
1233 containing c, if 'c' is not a match at position
1234 p, then p[-1] > 0x7f. JRA. */
1237 size_t len = strlen(s);
1239 BOOL got_mb = False;
1246 /* Could be a match. Part of a multibyte ? */
1247 if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
1248 /* Yep - go slow :-( */
1252 /* No - we have a match ! */
1255 } while (cp-- != s);
1260 /* String contained a non-ascii char. Slow path. */
1266 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1267 p = strrchr_w(ws, UCS2_CHAR(c));
1271 pull_ucs2_pstring(s2, ws);
1272 return (char *)(s+strlen(s2));
1276 /***********************************************************************
1277 Return the equivalent of doing strrchr 'n' times - always going
1279 ***********************************************************************/
1281 char *strnrchr_m(const char *s, char c, unsigned int n)
1287 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1288 p = strnrchr_w(ws, UCS2_CHAR(c), n);
1292 pull_ucs2_pstring(s2, ws);
1293 return (char *)(s+strlen(s2));
1297 Convert a string to lower case.
1300 void strlower_m(char *s)
1304 /* this is quite a common operation, so we want it to be
1305 fast. We optimise for the ascii case, knowing that all our
1306 supported multi-byte character sets are ascii-compatible
1307 (ie. they match for the first 128 chars) */
1309 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1310 *s = tolower((unsigned char)*s);
1317 /* I assume that lowercased string takes the same number of bytes
1318 * as source string even in UTF-8 encoding. (VIV) */
1319 len = strlen(s) + 1;
1321 unix_strlower(s,len,s,len);
1322 /* Catch mb conversion errors that may not terminate. */
1328 Convert a string to upper case.
1331 void strupper_m(char *s)
1335 /* this is quite a common operation, so we want it to be
1336 fast. We optimise for the ascii case, knowing that all our
1337 supported multi-byte character sets are ascii-compatible
1338 (ie. they match for the first 128 chars) */
1340 while (*s && !(((unsigned char)s[0]) & 0x80)) {
1341 *s = toupper((unsigned char)*s);
1348 /* I assume that lowercased string takes the same number of bytes
1349 * as source string even in multibyte encoding. (VIV) */
1350 len = strlen(s) + 1;
1352 unix_strupper(s,len,s,len);
1353 /* Catch mb conversion errors that may not terminate. */
1359 Return a RFC2254 binary string representation of a buffer.
1360 Used in LDAP filters.
1364 char *binary_string(char *buf, int len)
1368 const char *hex = "0123456789ABCDEF";
1369 s = malloc(len * 3 + 1);
1372 for (j=i=0;i<len;i++) {
1374 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1375 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1383 Just a typesafety wrapper for snprintf into a pstring.
1386 int pstr_sprintf(pstring s, const char *fmt, ...)
1392 ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1399 Just a typesafety wrapper for snprintf into a fstring.
1402 int fstr_sprintf(fstring s, const char *fmt, ...)
1408 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1414 #ifndef HAVE_STRNDUP
1416 Some platforms don't have strndup.
1419 char *strndup(const char *s, size_t n)
1434 #ifndef HAVE_STRNLEN
1436 Some platforms don't have strnlen
1439 size_t strnlen(const char *s, size_t n)
1442 for (i=0; s[i] && i<n; i++)
1449 List of Strings manipulation functions
1452 #define S_LIST_ABS 16 /* List Allocation Block Size */
1454 char **str_list_make(const char *string, const char *sep)
1456 char **list, **rlist;
1462 if (!string || !*string)
1466 DEBUG(0,("str_list_make: Unable to allocate memory"));
1469 if (!sep) sep = LIST_SEP;
1475 while (next_token(&str, tok, sep, sizeof(tok))) {
1477 lsize += S_LIST_ABS;
1478 rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1480 DEBUG(0,("str_list_make: Unable to allocate memory"));
1481 str_list_free(&list);
1486 memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1489 list[num] = strdup(tok);
1491 DEBUG(0,("str_list_make: Unable to allocate memory"));
1492 str_list_free(&list);
1504 BOOL str_list_copy(char ***dest, const char **src)
1506 char **list, **rlist;
1518 lsize += S_LIST_ABS;
1519 rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1521 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1522 str_list_free(&list);
1526 memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1529 list[num] = strdup(src[num]);
1531 DEBUG(0,("str_list_copy: Unable to allocate memory"));
1532 str_list_free(&list);
1544 * Return true if all the elements of the list match exactly.
1546 BOOL str_list_compare(char **list1, char **list2)
1550 if (!list1 || !list2)
1551 return (list1 == list2);
1553 for (num = 0; list1[num]; num++) {
1556 if (!strcsequal(list1[num], list2[num]))
1560 return False; /* if list2 has more elements than list1 fail */
1565 void str_list_free(char ***list)
1569 if (!list || !*list)
1572 for(; *tlist; tlist++)
1577 /******************************************************************************
1578 version of standard_sub_basic() for string lists; uses alloc_sub_basic()
1580 *****************************************************************************/
1582 BOOL str_list_sub_basic( char **list, const char *smb_name )
1588 tmpstr = alloc_sub_basic(smb_name, s);
1590 DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
1602 /******************************************************************************
1603 substritute a specific pattern in a string list
1604 *****************************************************************************/
1606 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1609 ssize_t ls, lp, li, ld, i, d;
1618 lp = (ssize_t)strlen(pattern);
1619 li = (ssize_t)strlen(insert);
1624 ls = (ssize_t)strlen(s);
1626 while ((p = strstr(s, pattern))) {
1630 t = (char *) malloc(ls +ld +1);
1632 DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1635 memcpy(t, *list, d);
1636 memcpy(t +d +li, p +lp, ls -d -lp +1);
1643 for (i = 0; i < li; i++) {
1644 switch (insert[i]) {
1656 t[d +i] = insert[i];
1669 #define IPSTR_LIST_SEP ","
1670 #define IPSTR_LIST_CHAR ','
1673 * Add ip string representation to ipstr list. Used also
1674 * as part of @function ipstr_list_make
1676 * @param ipstr_list pointer to string containing ip list;
1677 * MUST BE already allocated and IS reallocated if necessary
1678 * @param ipstr_size pointer to current size of ipstr_list (might be changed
1679 * as a result of reallocation)
1680 * @param ip IP address which is to be added to list
1681 * @return pointer to string appended with new ip and possibly
1682 * reallocated to new length
1685 char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
1687 char* new_ipstr = NULL;
1689 /* arguments checking */
1690 if (!ipstr_list || !service) return NULL;
1692 /* attempt to convert ip to a string and append colon separator to it */
1694 asprintf(&new_ipstr, "%s%s%s:%d", *ipstr_list, IPSTR_LIST_SEP,
1695 inet_ntoa(service->ip), service->port);
1696 SAFE_FREE(*ipstr_list);
1698 asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
1700 *ipstr_list = new_ipstr;
1706 * Allocate and initialise an ipstr list using ip adresses
1707 * passed as arguments.
1709 * @param ipstr_list pointer to string meant to be allocated and set
1710 * @param ip_list array of ip addresses to place in the list
1711 * @param ip_count number of addresses stored in ip_list
1712 * @return pointer to allocated ip string
1715 char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
1719 /* arguments checking */
1720 if (!ip_list && !ipstr_list) return 0;
1724 /* process ip addresses given as arguments */
1725 for (i = 0; i < ip_count; i++)
1726 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
1728 return (*ipstr_list);
1733 * Parse given ip string list into array of ip addresses
1734 * (as ip_service structures)
1735 * e.g. 192.168.1.100:389,192.168.1.78, ...
1737 * @param ipstr ip string list to be parsed
1738 * @param ip_list pointer to array of ip addresses which is
1739 * allocated by this function and must be freed by caller
1740 * @return number of succesfully parsed addresses
1743 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
1749 if (!ipstr_list || !ip_list)
1752 count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
1753 if ( (*ip_list = (struct ip_service*)malloc(count * sizeof(struct ip_service))) == NULL ) {
1754 DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
1759 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count;
1762 struct in_addr addr;
1764 char *p = strchr(token_str, ':');
1771 /* convert single token to ip address */
1772 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
1775 (*ip_list)[i].ip = addr;
1776 (*ip_list)[i].port = port;
1784 * Safely free ip string list
1786 * @param ipstr_list ip string list to be freed
1789 void ipstr_list_free(char* ipstr_list)
1791 SAFE_FREE(ipstr_list);
1796 Unescape a URL encoded string, in place.
1799 void rfc1738_unescape(char *buf)
1803 while (p && *p && (p=strchr_m(p,'%'))) {
1807 if (c1 >= '0' && c1 <= '9')
1809 else if (c1 >= 'A' && c1 <= 'F')
1811 else if (c1 >= 'a' && c1 <= 'f')
1813 else {p++; continue;}
1815 if (c2 >= '0' && c2 <= '9')
1817 else if (c2 >= 'A' && c2 <= 'F')
1819 else if (c2 >= 'a' && c2 <= 'f')
1821 else {p++; continue;}
1825 memmove(p+1, p+3, strlen(p+3)+1);
1830 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1833 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1835 DATA_BLOB base64_decode_data_blob(const char *s)
1837 int bit_offset, byte_offset, idx, i, n;
1838 DATA_BLOB decoded = data_blob(s, strlen(s)+1);
1839 unsigned char *d = decoded.data;
1844 while (*s && (p=strchr_m(b64,*s))) {
1845 idx = (int)(p - b64);
1846 byte_offset = (i*6)/8;
1847 bit_offset = (i*6)%8;
1848 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
1849 if (bit_offset < 3) {
1850 d[byte_offset] |= (idx << (2-bit_offset));
1853 d[byte_offset] |= (idx >> (bit_offset-2));
1854 d[byte_offset+1] = 0;
1855 d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
1861 if (*s == '=') n -= 1;
1869 * Decode a base64 string in-place - wrapper for the above
1871 void base64_decode_inplace(char *s)
1873 DATA_BLOB decoded = base64_decode_data_blob(s);
1874 memcpy(s, decoded.data, decoded.length);
1875 /* null terminate */
1876 s[decoded.length] = '\0';
1878 data_blob_free(&decoded);
1882 * Encode a base64 string into a malloc()ed string caller to free.
1884 *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
1886 char * base64_encode_data_blob(DATA_BLOB data)
1891 size_t len = data.length;
1892 size_t output_len = data.length * 2;
1893 char *result = malloc(output_len); /* get us plenty of space */
1895 while (len-- && out_cnt < (data.length * 2) - 5) {
1896 int c = (unsigned char) *(data.data++);
1899 if (char_count == 3) {
1900 result[out_cnt++] = b64[bits >> 18];
1901 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
1902 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
1903 result[out_cnt++] = b64[bits & 0x3f];
1910 if (char_count != 0) {
1911 bits <<= 16 - (8 * char_count);
1912 result[out_cnt++] = b64[bits >> 18];
1913 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
1914 if (char_count == 1) {
1915 result[out_cnt++] = '=';
1916 result[out_cnt++] = '=';
1918 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
1919 result[out_cnt++] = '=';
1922 result[out_cnt] = '\0'; /* terminate */
1926 /* read a SMB_BIG_UINT from a string */
1927 SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
1930 SMB_BIG_UINT val = -1;
1931 const char *p = nptr;
1933 while (p && *p && isspace(*p))
1935 #ifdef LARGE_SMB_OFF_T
1936 sscanf(p,"%llu",&val);
1937 #else /* LARGE_SMB_OFF_T */
1938 sscanf(p,"%lu",&val);
1939 #endif /* LARGE_SMB_OFF_T */
1941 while (p && *p && isdigit(*p))