2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-2001
5 Copyright (C) Simo Sorce 2001-2002
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Get the next token from a string, return False if none found.
26 * Handles double-quotes.
28 * Based on a routine by GJC@VILLAGE.COM.
29 * Extensively modified by Andrew.Tridgell@anu.edu.au
31 BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
42 /* default to simple separators */
46 /* find the first non sep char */
47 while (*s && strchr_m(sep,*s))
54 /* copy over the token */
55 for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
64 *ptr = (*s) ? s+1 : s;
71 This is like next_token but is not re-entrant and "remembers" the first
72 parameter so you can pass NULL. This is useful for user interface code
73 but beware the fact that it is not re-entrant!
76 static char *last_ptr=NULL;
78 BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
82 ptr = (const char **)&last_ptr;
84 ret = next_token(ptr, buff, sep, bufsize);
89 static uint16 tmpbuf[sizeof(pstring)];
91 void set_first_token(char *ptr)
97 Convert list of tokens to array; dependent on above routine.
98 Uses last_ptr from above - bit of a hack.
101 char **toktocliplist(int *ctok, const char *sep)
110 while(*s && strchr_m(sep,*s))
119 while(*s && (!strchr_m(sep,*s)))
121 while(*s && strchr_m(sep,*s))
128 if (!(ret=iret=malloc(ictok*sizeof(char *))))
143 Case insensitive string compararison.
146 int StrCaseCmp(const char *s, const char *t)
149 unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
150 unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
151 return strcmp(buf1,buf2);
155 Case insensitive string compararison, length limited.
158 int StrnCaseCmp(const char *s, const char *t, size_t n)
161 unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
162 unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
163 return strncmp(buf1,buf2,n);
169 * @note The comparison is case-insensitive.
171 BOOL strequal(const char *s1, const char *s2)
178 return(StrCaseCmp(s1,s2)==0);
182 * Compare 2 strings up to and including the nth char.
184 * @note The comparison is case-insensitive.
186 BOOL strnequal(const char *s1,const char *s2,size_t n)
190 if (!s1 || !s2 || !n)
193 return(StrnCaseCmp(s1,s2,n)==0);
197 Compare 2 strings (case sensitive).
200 BOOL strcsequal(const char *s1,const char *s2)
207 return(strcmp(s1,s2)==0);
211 Do a case-insensitive, whitespace-ignoring string compare.
214 int strwicmp(const char *psz1, const char *psz2)
216 /* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
217 /* appropriate value. */
220 else if (psz1 == NULL)
222 else if (psz2 == NULL)
225 /* sync the strings on first non-whitespace */
227 while (isspace((int)*psz1))
229 while (isspace((int)*psz2))
231 if (toupper(*psz1) != toupper(*psz2) || *psz1 == '\0'
237 return (*psz1 - *psz2);
242 Convert a string to upper case, but don't modify it.
245 char *strupper_static(const char *s)
256 Convert a string to "normal" form.
259 void strnorm(char *s)
261 extern int case_default;
262 if (case_default == CASE_UPPER)
269 Check if a string is in "normal" case.
272 BOOL strisnormal(const char *s)
274 extern int case_default;
275 if (case_default == CASE_UPPER)
276 return(!strhaslower(s));
278 return(!strhasupper(s));
284 NOTE: oldc and newc must be 7 bit characters
287 void string_replace(char *s,char oldc,char newc)
289 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
290 string_replace_w(tmpbuf, UCS2_CHAR(oldc), UCS2_CHAR(newc));
291 pull_ucs2(NULL, s, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
295 Skip past some strings in a buffer.
298 char *skip_string(char *buf,size_t n)
301 buf += strlen(buf) + 1;
306 Count the number of characters in a string. Normally this will
307 be the same as the number of bytes in a string for single byte strings,
308 but will be different for multibyte.
311 size_t str_charnum(const char *s)
313 uint16 tmpbuf2[sizeof(pstring)];
314 push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
315 return strlen_w(tmpbuf2);
319 Count the number of characters in a string. Normally this will
320 be the same as the number of bytes in a string for single byte strings,
321 but will be different for multibyte.
324 size_t str_ascii_charnum(const char *s)
327 push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
328 return strlen(tmpbuf2);
332 Trim the specified elements off the front and back of a string.
335 BOOL trim_string(char *s,const char *front,const char *back)
342 /* Ignore null or empty strings. */
343 if (!s || (s[0] == '\0'))
346 front_len = front? strlen(front) : 0;
347 back_len = back? strlen(back) : 0;
352 while (len && strncmp(s, front, front_len)==0) {
353 memcpy(s, s+front_len, (len-front_len)+1);
360 while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
361 s[len-back_len]='\0';
370 Does a string have any uppercase chars in it?
373 BOOL strhasupper(const char *s)
376 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
377 for(ptr=tmpbuf;*ptr;ptr++)
384 Does a string have any lowercase chars in it?
387 BOOL strhaslower(const char *s)
390 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
391 for(ptr=tmpbuf;*ptr;ptr++)
398 Find the number of 'c' chars in a string
401 size_t count_chars(const char *s,char c)
405 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
406 for(count=0,ptr=tmpbuf;*ptr;ptr++)
407 if(*ptr==UCS2_CHAR(c))
413 Return True if a string consists only of one particular character.
416 BOOL str_is_all(const char *s,char c)
425 push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
426 for(ptr=tmpbuf;*ptr;ptr++)
427 if(*ptr!=UCS2_CHAR(c))
435 * In developer builds, clobber a region of memory.
437 * If we think a string buffer is longer than it really is, this ought
438 * to make the failure obvious, by segfaulting (if in the heap) or by
439 * killing the return address (on the stack), or by trapping under a
442 * This is meant to catch possible string overflows, even if the
443 * actual string copied is not big enough to cause an overflow.
445 void clobber_region(char *dest, size_t len)
448 /* F1 is odd and 0xf1f1f1f1 shouldn't be a valid pointer */
449 memset(dest, 0xF1, len);
455 Safe string copy into a known length string. maxlength does not
456 include the terminating zero.
459 char *safe_strcpy(char *dest,const char *src, size_t maxlength)
464 DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
468 clobber_region(dest, maxlength+1);
477 if (len > maxlength) {
478 DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
479 (unsigned int)(len-maxlength), len, maxlength, src));
483 memmove(dest, src, len);
489 Safe string cat into a string. maxlength does not
490 include the terminating zero.
493 char *safe_strcat(char *dest, const char *src, size_t maxlength)
495 size_t src_len, dest_len;
498 DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
505 src_len = strlen(src);
506 dest_len = strlen(dest);
508 clobber_region(dest + dest_len, maxlength + 1 - dest_len);
510 if (src_len + dest_len > maxlength) {
511 DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
512 (int)(src_len + dest_len - maxlength), src));
513 if (maxlength > dest_len) {
514 memcpy(&dest[dest_len], src, maxlength - dest_len);
520 memcpy(&dest[dest_len], src, src_len);
521 dest[dest_len + src_len] = 0;
526 Paranoid strcpy into a buffer of given length (includes terminating
527 zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
528 and replaces with '_'. Deliberately does *NOT* check for multibyte
529 characters. Don't change it !
532 char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
536 clobber_region(dest, maxlength);
539 DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
549 if (len >= maxlength)
552 if (!other_safe_chars)
553 other_safe_chars = "";
555 for(i = 0; i < len; i++) {
556 int val = (src[i] & 0xff);
557 if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
569 Like strncpy but always null terminates. Make sure there is room!
570 The variable n should always be one less than the available size.
573 char *StrnCpy(char *dest,const char *src,size_t n)
577 clobber_region(dest, n+1);
586 while (n-- && (*d++ = *src++))
593 Like strncpy but copies up to the character marker. always null terminates.
594 returns a pointer to the character marker in the source string (src).
597 char *strncpyn(char *dest, const char *src, size_t n, char c)
602 clobber_region(dest, n+1);
604 p = strchr_m(src, c);
606 DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
610 str_len = PTR_DIFF(p, src);
611 strncpy(dest, src, MIN(n, str_len));
612 dest[str_len] = '\0';
618 Routine to get hex characters and turn them into a 16 byte array.
619 the array can be variable length, and any non-hex-numeric
620 characters are skipped. "0xnn" or "0Xnn" is specially catered
623 valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
627 size_t strhex_to_str(char *p, size_t len, const char *strhex)
630 size_t num_chars = 0;
631 unsigned char lonybble, hinybble;
632 const char *hexchars = "0123456789ABCDEF";
633 char *p1 = NULL, *p2 = NULL;
635 for (i = 0; i < len && strhex[i] != 0; i++) {
636 if (strnequal(hexchars, "0x", 2)) {
637 i++; /* skip two chars */
641 if (!(p1 = strchr_m(hexchars, toupper(strhex[i]))))
644 i++; /* next hex digit */
646 if (!(p2 = strchr_m(hexchars, toupper(strhex[i]))))
649 /* get the two nybbles */
650 hinybble = PTR_DIFF(p1, hexchars);
651 lonybble = PTR_DIFF(p2, hexchars);
653 p[num_chars] = (hinybble << 4) | lonybble;
663 Check if a string is part of a list.
666 BOOL in_list(char *s,char *list,BOOL casesensitive)
674 while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
676 if (strcmp(tok,s) == 0)
679 if (StrCaseCmp(tok,s) == 0)
686 /* this is used to prevent lots of mallocs of size 1 */
687 static char *null_string = NULL;
690 Set a string value, allocing the space for the string
693 static BOOL string_init(char **dest,const char *src)
703 if((null_string = (char *)malloc(1)) == NULL) {
704 DEBUG(0,("string_init: malloc fail for null_string.\n"));
711 (*dest) = strdup(src);
712 if ((*dest) == NULL) {
713 DEBUG(0,("Out of memory in string_init\n"));
724 void string_free(char **s)
728 if (*s == null_string)
734 Set a string value, deallocating any existing space, and allocing the space
738 BOOL string_set(char **dest,const char *src)
741 return(string_init(dest,src));
745 Substitute a string for a pattern in another string. Make sure there is
748 This routine looks for pattern in s and replaces it with
749 insert. It may do multiple replacements.
751 Any of " ; ' $ or ` in the insert string are replaced with _
752 if len==0 then the string cannot be extended. This is different from the old
753 use of len==0 which was for no length checks to be done.
756 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
761 if (!insert || !pattern || !*pattern || !s)
764 ls = (ssize_t)strlen(s);
765 lp = (ssize_t)strlen(pattern);
766 li = (ssize_t)strlen(insert);
769 len = ls + 1; /* len is number of *bytes* */
771 while (lp <= ls && (p = strstr(s,pattern))) {
772 if (ls + (li-lp) >= len) {
773 DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n",
774 (int)(ls + (li-lp) - len),
779 memmove(p+li,p+lp,strlen(p+lp)+1);
802 void fstring_sub(char *s,const char *pattern,const char *insert)
804 string_sub(s, pattern, insert, sizeof(fstring));
807 void pstring_sub(char *s,const char *pattern,const char *insert)
809 string_sub(s, pattern, insert, sizeof(pstring));
813 Similar to string_sub, but it will accept only allocated strings
814 and may realloc them so pay attention at what you pass on no
815 pointers inside strings, no pstrings or const may be passed
819 char *realloc_string_sub(char *string, const char *pattern, const char *insert)
823 ssize_t ls,lp,li,ld, i;
825 if (!insert || !pattern || !*pattern || !string || !*string)
832 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
835 ls = (ssize_t)strlen(s);
836 lp = (ssize_t)strlen(pattern);
837 li = (ssize_t)strlen(insert);
856 while ((p = strstr(s,pattern))) {
858 char *t = Realloc(string, ls + ld + 1);
860 DEBUG(0, ("realloc_string_sub: out of memory!\n"));
868 memmove(p+li,p+lp,strlen(p+lp)+1);
879 Similar to string_sub() but allows for any character to be substituted.
881 if len==0 then the string cannot be extended. This is different from the old
882 use of len==0 which was for no length checks to be done.
885 void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
890 if (!insert || !pattern || !s)
893 ls = (ssize_t)strlen(s);
894 lp = (ssize_t)strlen(pattern);
895 li = (ssize_t)strlen(insert);
901 len = ls + 1; /* len is number of *bytes* */
903 while (lp <= ls && (p = strstr(s,pattern))) {
904 if (ls + (li-lp) >= len) {
905 DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n",
906 (int)(ls + (li-lp) - len),
911 memmove(p+li,p+lp,strlen(p+lp)+1);
913 memcpy(p, insert, li);
920 Similar to all_string_sub but for unicode strings.
921 Return a new allocated unicode string.
922 similar to string_sub() but allows for any character to be substituted.
926 smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
927 const smb_ucs2_t *insert)
930 const smb_ucs2_t *sp;
931 size_t lr, lp, li, lt;
933 if (!insert || !pattern || !*pattern || !s)
936 lt = (size_t)strlen_w(s);
937 lp = (size_t)strlen_w(pattern);
938 li = (size_t)strlen_w(insert);
941 const smb_ucs2_t *st = s;
943 while ((sp = strstr_w(st, pattern))) {
949 r = rp = (smb_ucs2_t *)malloc((lt + 1)*(sizeof(smb_ucs2_t)));
951 DEBUG(0, ("all_string_sub_w: out of memory!\n"));
955 while ((sp = strstr_w(s, pattern))) {
956 memcpy(rp, s, (sp - s));
957 rp += ((sp - s) / sizeof(smb_ucs2_t));
958 memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
962 lr = ((rp - r) / sizeof(smb_ucs2_t));
964 memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
972 smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
977 if (!insert || !pattern || !s)
979 push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
980 push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
981 return all_string_sub_w(s, p, i);
985 Splits out the front and back at a separator.
988 void split_at_last_component(char *path, char *front, char sep, char *back)
990 char *p = strrchr_m(path, sep);
996 pstrcpy(front, path);
1009 Write an octal as a string.
1012 const char *octal_string(int i)
1014 static char ret[64];
1017 slprintf(ret, sizeof(ret)-1, "0%o", i);
1023 Truncate a string at a specified length.
1026 char *string_truncate(char *s, int length)
1028 if (s && strlen(s) > length)
1034 Strchr and strrchr_m are very hard to do on general multi-byte strings.
1035 We convert via ucs2 for now.
1038 char *strchr_m(const char *s, char c)
1044 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1045 p = strchr_w(ws, UCS2_CHAR(c));
1049 pull_ucs2_pstring(s2, ws);
1050 return (char *)(s+strlen(s2));
1053 char *strrchr_m(const char *s, char c)
1059 push_ucs2(NULL, ws, s, sizeof(ws), STR_TERMINATE);
1060 p = strrchr_w(ws, UCS2_CHAR(c));
1064 pull_ucs2_pstring(s2, ws);
1065 return (char *)(s+strlen(s2));
1069 Convert a string to lower case.
1072 void strlower_m(char *s)
1074 /* this is quite a common operation, so we want it to be
1075 fast. We optimise for the ascii case, knowing that all our
1076 supported multi-byte character sets are ascii-compatible
1077 (ie. they match for the first 128 chars) */
1079 while (*s && !(((unsigned char)s[0]) & 0x7F)) {
1080 *s = tolower((unsigned char)*s);
1087 /* I assume that lowercased string takes the same number of bytes
1088 * as source string even in UTF-8 encoding. (VIV) */
1089 unix_strlower(s,strlen(s)+1,s,strlen(s)+1);
1093 Duplicate convert a string to lower case.
1096 char *strdup_lower(const char *s)
1098 char *t = strdup(s);
1100 DEBUG(0, ("strdup_lower: Out of memory!\n"));
1108 Convert a string to upper case.
1111 void strupper_m(char *s)
1113 /* this is quite a common operation, so we want it to be
1114 fast. We optimise for the ascii case, knowing that all our
1115 supported multi-byte character sets are ascii-compatible
1116 (ie. they match for the first 128 chars) */
1118 while (*s && !(((unsigned char)s[0]) & 0x7F)) {
1119 *s = toupper((unsigned char)*s);
1126 /* I assume that lowercased string takes the same number of bytes
1127 * as source string even in multibyte encoding. (VIV) */
1128 unix_strupper(s,strlen(s)+1,s,strlen(s)+1);
1132 Convert a string to upper case.
1135 char *strdup_upper(const char *s)
1137 char *t = strdup(s);
1139 DEBUG(0, ("strdup_upper: Out of memory!\n"));
1147 Return a RFC2254 binary string representation of a buffer.
1148 Used in LDAP filters.
1152 char *binary_string(char *buf, int len)
1156 const char *hex = "0123456789ABCDEF";
1157 s = malloc(len * 3 + 1);
1160 for (j=i=0;i<len;i++) {
1162 s[j+1] = hex[((unsigned char)buf[i]) >> 4];
1163 s[j+2] = hex[((unsigned char)buf[i]) & 0xF];
1171 Just a typesafety wrapper for snprintf into a pstring.
1174 int pstr_sprintf(pstring s, const char *fmt, ...)
1180 ret = vsnprintf(s, PSTRING_LEN, fmt, ap);
1186 Just a typesafety wrapper for snprintf into a fstring.
1189 int fstr_sprintf(fstring s, const char *fmt, ...)
1195 ret = vsnprintf(s, FSTRING_LEN, fmt, ap);
1200 #ifndef HAVE_STRNDUP
1202 Some platforms don't have strndup.
1205 char *strndup(const char *s, size_t n)
1220 #ifndef HAVE_STRNLEN
1222 Some platforms don't have strnlen
1225 size_t strnlen(const char *s, size_t n)
1228 for (i=0; s[i] && i<n; i++)
1235 List of Strings manipulation functions
1238 #define S_LIST_ABS 16 /* List Allocation Block Size */
1240 char **str_list_make(const char *string, const char *sep)
1242 char **list, **rlist;
1248 if (!string || !*string)
1252 DEBUG(0,("str_list_make: Unable to allocate memory"));
1255 if (!sep) sep = LIST_SEP;
1261 while (next_token(&str, tok, sep, sizeof(tok))) {
1263 lsize += S_LIST_ABS;
1264 rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1266 DEBUG(0,("str_list_make: Unable to allocate memory"));
1267 str_list_free(&list);
1272 memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
1275 list[num] = strdup(tok);
1277 DEBUG(0,("str_list_make: Unable to allocate memory"));
1278 str_list_free(&list);
1290 BOOL str_list_copy(char ***dest, const char **src)
1292 char **list, **rlist;
1304 lsize += S_LIST_ABS;
1305 rlist = (char **)Realloc(list, ((sizeof(char **)) * (lsize +1)));
1307 DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
1308 str_list_free(&list);
1312 memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
1315 list[num] = strdup(src[num]);
1317 DEBUG(0,("str_list_copy: Unable to allocate memory"));
1318 str_list_free(&list);
1330 * Return true if all the elements of the list match exactly.
1332 BOOL str_list_compare(char **list1, char **list2)
1336 if (!list1 || !list2)
1337 return (list1 == list2);
1339 for (num = 0; list1[num]; num++) {
1342 if (!strcsequal(list1[num], list2[num]))
1346 return False; /* if list2 has more elements than list1 fail */
1351 void str_list_free(char ***list)
1355 if (!list || !*list)
1358 for(; *tlist; tlist++)
1363 BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
1366 ssize_t ls, lp, li, ld, i, d;
1375 lp = (ssize_t)strlen(pattern);
1376 li = (ssize_t)strlen(insert);
1381 ls = (ssize_t)strlen(s);
1383 while ((p = strstr(s, pattern))) {
1387 t = (char *) malloc(ls +ld +1);
1389 DEBUG(0,("str_list_substitute: Unable to allocate memory"));
1392 memcpy(t, *list, d);
1393 memcpy(t +d +li, p +lp, ls -d -lp +1);
1400 for (i = 0; i < li; i++) {
1401 switch (insert[i]) {
1413 t[d +i] = insert[i];
1425 #define IPSTR_LIST_SEP ","
1428 * Add ip string representation to ipstr list. Used also
1429 * as part of @function ipstr_list_make
1431 * @param ipstr_list pointer to string containing ip list;
1432 * MUST BE already allocated and IS reallocated if necessary
1433 * @param ipstr_size pointer to current size of ipstr_list (might be changed
1434 * as a result of reallocation)
1435 * @param ip IP address which is to be added to list
1436 * @return pointer to string appended with new ip and possibly
1437 * reallocated to new length
1440 char* ipstr_list_add(char** ipstr_list, const struct in_addr *ip)
1442 char* new_ipstr = NULL;
1444 /* arguments checking */
1445 if (!ipstr_list || !ip) return NULL;
1447 /* attempt to convert ip to a string and append colon separator to it */
1449 asprintf(&new_ipstr, "%s%s%s", *ipstr_list, IPSTR_LIST_SEP,inet_ntoa(*ip));
1450 SAFE_FREE(*ipstr_list);
1452 asprintf(&new_ipstr, "%s", inet_ntoa(*ip));
1454 *ipstr_list = new_ipstr;
1460 * Allocate and initialise an ipstr list using ip adresses
1461 * passed as arguments.
1463 * @param ipstr_list pointer to string meant to be allocated and set
1464 * @param ip_list array of ip addresses to place in the list
1465 * @param ip_count number of addresses stored in ip_list
1466 * @return pointer to allocated ip string
1469 char* ipstr_list_make(char** ipstr_list, const struct in_addr* ip_list, int ip_count)
1473 /* arguments checking */
1474 if (!ip_list && !ipstr_list) return 0;
1478 /* process ip addresses given as arguments */
1479 for (i = 0; i < ip_count; i++)
1480 *ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
1482 return (*ipstr_list);
1487 * Parse given ip string list into array of ip addresses
1488 * (as in_addr structures)
1490 * @param ipstr ip string list to be parsed
1491 * @param ip_list pointer to array of ip addresses which is
1492 * allocated by this function and must be freed by caller
1493 * @return number of succesfully parsed addresses
1496 int ipstr_list_parse(const char* ipstr_list, struct in_addr** ip_list)
1501 if (!ipstr_list || !ip_list) return 0;
1503 for (*ip_list = NULL, count = 0;
1504 next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN);
1507 struct in_addr addr;
1509 /* convert single token to ip address */
1510 if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
1513 /* prepare place for another in_addr structure */
1514 *ip_list = Realloc(*ip_list, (count + 1) * sizeof(struct in_addr));
1515 if (!*ip_list) return -1;
1517 (*ip_list)[count] = addr;
1525 * Safely free ip string list
1527 * @param ipstr_list ip string list to be freed
1530 void ipstr_list_free(char* ipstr_list)
1532 SAFE_FREE(ipstr_list);
1537 Unescape a URL encoded string, in place.
1540 void rfc1738_unescape(char *buf)
1544 while ((p=strchr_m(p,'+')))
1549 while (p && *p && (p=strchr_m(p,'%'))) {
1553 if (c1 >= '0' && c1 <= '9')
1555 else if (c1 >= 'A' && c1 <= 'F')
1557 else if (c1 >= 'a' && c1 <= 'f')
1559 else {p++; continue;}
1561 if (c2 >= '0' && c2 <= '9')
1563 else if (c2 >= 'A' && c2 <= 'F')
1565 else if (c2 >= 'a' && c2 <= 'f')
1567 else {p++; continue;}
1571 memmove(p+1, p+3, strlen(p+3)+1);
1576 static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1579 * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
1581 DATA_BLOB base64_decode_data_blob(const char *s)
1583 int bit_offset, byte_offset, idx, i, n;
1584 DATA_BLOB decoded = data_blob(s, strlen(s)+1);
1585 unsigned char *d = decoded.data;
1590 while (*s && (p=strchr_m(b64,*s))) {
1591 idx = (int)(p - b64);
1592 byte_offset = (i*6)/8;
1593 bit_offset = (i*6)%8;
1594 d[byte_offset] &= ~((1<<(8-bit_offset))-1);
1595 if (bit_offset < 3) {
1596 d[byte_offset] |= (idx << (2-bit_offset));
1599 d[byte_offset] |= (idx >> (bit_offset-2));
1600 d[byte_offset+1] = 0;
1601 d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
1613 * Decode a base64 string in-place - wrapper for the above
1615 void base64_decode_inplace(char *s)
1617 DATA_BLOB decoded = base64_decode_data_blob(s);
1618 memcpy(s, decoded.data, decoded.length);
1619 data_blob_free(&decoded);
1621 /* null terminate */
1622 s[decoded.length] = '\0';
1626 * Encode a base64 string into a malloc()ed string caller to free.
1628 *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
1630 char * base64_encode_data_blob(DATA_BLOB data)
1635 size_t len = data.length;
1636 size_t output_len = data.length * 2;
1637 char *result = malloc(output_len); /* get us plenty of space */
1639 while (len-- && out_cnt < (data.length * 2) - 5) {
1640 int c = (unsigned char) *(data.data++);
1643 if (char_count == 3) {
1644 result[out_cnt++] = b64[bits >> 18];
1645 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
1646 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
1647 result[out_cnt++] = b64[bits & 0x3f];
1654 if (char_count != 0) {
1655 bits <<= 16 - (8 * char_count);
1656 result[out_cnt++] = b64[bits >> 18];
1657 result[out_cnt++] = b64[(bits >> 12) & 0x3f];
1658 if (char_count == 1) {
1659 result[out_cnt++] = '=';
1660 result[out_cnt++] = '=';
1662 result[out_cnt++] = b64[(bits >> 6) & 0x3f];
1663 result[out_cnt++] = '=';
1666 result[out_cnt] = '\0'; /* terminate */
1671 size_t valgrind_strlen(const char *s)
1674 for(count = 0; *s++; count++)