From dfc517b05395d925a4d7b1ce9633a849f9468e70 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 23 Feb 2006 15:52:24 +0000
Subject: r13658: More moving around of files:  - Collect the generic utility
 functions into a lib/util/ (a la GLib is 		for the GNOME folks) 
 - Remove even more files from include/ (This used to be commit
 ba62880f5b05c2a505dc7f54676b231197a7e707)

---
 source4/lib/util/util_str.c | 1209 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1209 insertions(+)
 create mode 100644 source4/lib/util/util_str.c

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
new file mode 100644
index 0000000000..b46787e3ea
--- /dev/null
+++ b/source4/lib/util/util_str.c
@@ -0,0 +1,1209 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Samba utility functions
+   
+   Copyright (C) Andrew Tridgell 1992-2001
+   Copyright (C) Simo Sorce      2001-2002
+   Copyright (C) Martin Pool     2003
+   Copyright (C) James Peach	 2005
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "system/iconv.h"
+#include "smb.h"
+#include "pstring.h"
+#include "lib/ldb/include/ldb.h"
+
+/**
+ * @file
+ * @brief String utilities.
+ **/
+
+/**
+ * Get the next token from a string, return False if none found.
+ * Handles double-quotes.
+ * 
+ * Based on a routine by GJC@VILLAGE.COM. 
+ * Extensively modified by Andrew.Tridgell@anu.edu.au
+ **/
+BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
+{
+	const char *s;
+	BOOL quoted;
+	size_t len=1;
+
+	if (!ptr)
+		return(False);
+
+	s = *ptr;
+
+	/* default to simple separators */
+	if (!sep)
+		sep = " \t\n\r";
+
+	/* find the first non sep char */
+	while (*s && strchr_m(sep,*s))
+		s++;
+	
+	/* nothing left? */
+	if (! *s)
+		return(False);
+	
+	/* copy over the token */
+	for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
+		if (*s == '\"') {
+			quoted = !quoted;
+		} else {
+			len++;
+			*buff++ = *s;
+		}
+	}
+	
+	*ptr = (*s) ? s+1 : s;  
+	*buff = 0;
+	
+	return(True);
+}
+
+/**
+ Case insensitive string compararison
+**/
+int strcasecmp_m(const char *s1, const char *s2)
+{
+	codepoint_t c1=0, c2=0;
+	size_t size1, size2;
+
+	while (*s1 && *s2) {
+		c1 = next_codepoint(s1, &size1);
+		c2 = next_codepoint(s2, &size2);
+
+		s1 += size1;
+		s2 += size2;
+
+		if (c1 == c2) {
+			continue;
+		}
+
+		if (c1 == INVALID_CODEPOINT ||
+		    c2 == INVALID_CODEPOINT) {
+			/* what else can we do?? */
+			return c1 - c2;
+		}
+
+		if (toupper_w(c1) != toupper_w(c2)) {
+			return c1 - c2;
+		}
+	}
+
+	return *s1 - *s2;
+}
+
+/**
+ * Compare 2 strings.
+ *
+ * @note The comparison is case-insensitive.
+ **/
+BOOL strequal(const char *s1, const char *s2)
+{
+	if (s1 == s2)
+		return(True);
+	if (!s1 || !s2)
+		return(False);
+  
+	return strcasecmp_m(s1,s2) == 0;
+}
+
+/**
+ Compare 2 strings (case sensitive).
+**/
+BOOL strcsequal(const char *s1,const char *s2)
+{
+	if (s1 == s2)
+		return(True);
+	if (!s1 || !s2)
+		return(False);
+	
+	return strcmp(s1,s2) == 0;
+}
+
+
+/**
+Do a case-insensitive, whitespace-ignoring string compare.
+**/
+int strwicmp(const char *psz1, const char *psz2)
+{
+	/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
+	/* appropriate value. */
+	if (psz1 == psz2)
+		return (0);
+	else if (psz1 == NULL)
+		return (-1);
+	else if (psz2 == NULL)
+		return (1);
+
+	/* sync the strings on first non-whitespace */
+	while (1) {
+		while (isspace((int)*psz1))
+			psz1++;
+		while (isspace((int)*psz2))
+			psz2++;
+		if (toupper((unsigned char)*psz1) != toupper((unsigned char)*psz2) 
+		    || *psz1 == '\0'
+		    || *psz2 == '\0')
+			break;
+		psz1++;
+		psz2++;
+	}
+	return (*psz1 - *psz2);
+}
+
+/**
+ String replace.
+ NOTE: oldc and newc must be 7 bit characters
+**/
+void string_replace(char *s, char oldc, char newc)
+{
+	while (*s) {
+		size_t size;
+		codepoint_t c = next_codepoint(s, &size);
+		if (c == oldc) {
+			*s = newc;
+		}
+		s += size;
+	}
+}
+
+/**
+ Trim the specified elements off the front and back of a string.
+**/
+BOOL trim_string(char *s,const char *front,const char *back)
+{
+	BOOL ret = False;
+	size_t front_len;
+	size_t back_len;
+	size_t len;
+
+	/* Ignore null or empty strings. */
+	if (!s || (s[0] == '\0'))
+		return False;
+
+	front_len	= front? strlen(front) : 0;
+	back_len	= back? strlen(back) : 0;
+
+	len = strlen(s);
+
+	if (front_len) {
+		while (len && strncmp(s, front, front_len)==0) {
+			/* Must use memmove here as src & dest can
+			 * easily overlap. Found by valgrind. JRA. */
+			memmove(s, s+front_len, (len-front_len)+1);
+			len -= front_len;
+			ret=True;
+		}
+	}
+	
+	if (back_len) {
+		while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
+			s[len-back_len]='\0';
+			len -= back_len;
+			ret=True;
+		}
+	}
+	return ret;
+}
+
+/**
+ Find the number of 'c' chars in a string
+**/
+size_t count_chars(const char *s, char c)
+{
+	size_t count = 0;
+
+	while (*s) {
+		size_t size;
+		codepoint_t c2 = next_codepoint(s, &size);
+		if (c2 == c) count++;
+		s += size;
+	}
+
+	return count;
+}
+
+/**
+ Safe string copy into a known length string. maxlength does not
+ include the terminating zero.
+**/
+char *safe_strcpy(char *dest,const char *src, size_t maxlength)
+{
+	size_t len;
+
+	if (!dest) {
+		DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
+		return NULL;
+	}
+
+#ifdef DEVELOPER
+	/* We intentionally write out at the extremity of the destination
+	 * string.  If the destination is too short (e.g. pstrcpy into mallocd
+	 * or fstring) then this should cause an error under a memory
+	 * checker. */
+	dest[maxlength] = '\0';
+	if (PTR_DIFF(&len, dest) > 0) {  /* check if destination is on the stack, ok if so */
+		log_suspicious_usage("safe_strcpy", src);
+	}
+#endif
+
+	if (!src) {
+		*dest = 0;
+		return dest;
+	}  
+
+	len = strlen(src);
+
+	if (len > maxlength) {
+		DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
+			 (uint_t)(len-maxlength), (unsigned)len, (unsigned)maxlength, src));
+		len = maxlength;
+	}
+      
+	memmove(dest, src, len);
+	dest[len] = 0;
+	return dest;
+}  
+
+/**
+ Safe string cat into a string. maxlength does not
+ include the terminating zero.
+**/
+char *safe_strcat(char *dest, const char *src, size_t maxlength)
+{
+	size_t src_len, dest_len;
+
+	if (!dest) {
+		DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
+		return NULL;
+	}
+
+	if (!src)
+		return dest;
+	
+#ifdef DEVELOPER
+	if (PTR_DIFF(&src_len, dest) > 0) {  /* check if destination is on the stack, ok if so */
+		log_suspicious_usage("safe_strcat", src);
+	}
+#endif
+	src_len = strlen(src);
+	dest_len = strlen(dest);
+
+	if (src_len + dest_len > maxlength) {
+		DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
+			 (int)(src_len + dest_len - maxlength), src));
+		if (maxlength > dest_len) {
+			memcpy(&dest[dest_len], src, maxlength - dest_len);
+		}
+		dest[maxlength] = 0;
+		return NULL;
+	}
+	
+	memcpy(&dest[dest_len], src, src_len);
+	dest[dest_len + src_len] = 0;
+	return dest;
+}
+
+/**
+ Paranoid strcpy into a buffer of given length (includes terminating
+ zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
+ and replaces with '_'. Deliberately does *NOT* check for multibyte
+ characters. Don't change it !
+**/
+
+char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
+{
+	size_t len, i;
+
+	if (maxlength == 0) {
+		/* can't fit any bytes at all! */
+		return NULL;
+	}
+
+	if (!dest) {
+		DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
+		return NULL;
+	}
+
+	if (!src) {
+		*dest = 0;
+		return dest;
+	}  
+
+	len = strlen(src);
+	if (len >= maxlength)
+		len = maxlength - 1;
+
+	if (!other_safe_chars)
+		other_safe_chars = "";
+
+	for(i = 0; i < len; i++) {
+		int val = (src[i] & 0xff);
+		if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
+			dest[i] = src[i];
+		else
+			dest[i] = '_';
+	}
+
+	dest[i] = '\0';
+
+	return dest;
+}
+
+/**
+ Like strncpy but always null terminates. Make sure there is room!
+ The variable n should always be one less than the available size.
+**/
+
+char *StrnCpy(char *dest,const char *src,size_t n)
+{
+	char *d = dest;
+	if (!dest)
+		return(NULL);
+	if (!src) {
+		*dest = 0;
+		return(dest);
+	}
+	while (n-- && (*d++ = *src++))
+		;
+	*d = 0;
+	return(dest);
+}
+
+
+/**
+ Routine to get hex characters and turn them into a 16 byte array.
+ the array can be variable length, and any non-hex-numeric
+ characters are skipped.  "0xnn" or "0Xnn" is specially catered
+ for.
+
+ valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
+
+
+**/
+size_t strhex_to_str(char *p, size_t len, const char *strhex)
+{
+	size_t i;
+	size_t num_chars = 0;
+	uint8_t   lonybble, hinybble;
+	const char     *hexchars = "0123456789ABCDEF";
+	char           *p1 = NULL, *p2 = NULL;
+
+	for (i = 0; i < len && strhex[i] != 0; i++) {
+		if (strncasecmp(hexchars, "0x", 2) == 0) {
+			i++; /* skip two chars */
+			continue;
+		}
+
+		if (!(p1 = strchr_m(hexchars, toupper((unsigned char)strhex[i]))))
+			break;
+
+		i++; /* next hex digit */
+
+		if (!(p2 = strchr_m(hexchars, toupper((unsigned char)strhex[i]))))
+			break;
+
+		/* get the two nybbles */
+		hinybble = PTR_DIFF(p1, hexchars);
+		lonybble = PTR_DIFF(p2, hexchars);
+
+		p[num_chars] = (hinybble << 4) | lonybble;
+		num_chars++;
+
+		p1 = NULL;
+		p2 = NULL;
+	}
+	return num_chars;
+}
+
+DATA_BLOB strhex_to_data_blob(const char *strhex) 
+{
+	DATA_BLOB ret_blob = data_blob(NULL, strlen(strhex)/2+1);
+
+	ret_blob.length = strhex_to_str((char *)ret_blob.data, 	
+					strlen(strhex), 
+					strhex);
+
+	return ret_blob;
+}
+
+
+/**
+ * Routine to print a buffer as HEX digits, into an allocated string.
+ */
+void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
+{
+	int i;
+	char *hex_buffer;
+
+	*out_hex_buffer = smb_xmalloc((len*2)+1);
+	hex_buffer = *out_hex_buffer;
+
+	for (i = 0; i < len; i++)
+		slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
+}
+
+/**
+ Check if a string is part of a list.
+**/
+BOOL in_list(const char *s, const char *list, BOOL casesensitive)
+{
+	pstring tok;
+	const char *p=list;
+
+	if (!list)
+		return(False);
+
+	while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
+		if (casesensitive) {
+			if (strcmp(tok,s) == 0)
+				return(True);
+		} else {
+			if (strcasecmp_m(tok,s) == 0)
+				return(True);
+		}
+	}
+	return(False);
+}
+
+/**
+ Set a string value, allocing the space for the string
+**/
+static BOOL string_init(char **dest,const char *src)
+{
+	if (!src) src = "";
+
+	(*dest) = strdup(src);
+	if ((*dest) == NULL) {
+		DEBUG(0,("Out of memory in string_init\n"));
+		return False;
+	}
+	return True;
+}
+
+/**
+ Free a string value.
+**/
+void string_free(char **s)
+{
+	if (s) SAFE_FREE(*s);
+}
+
+/**
+ Set a string value, deallocating any existing space, and allocing the space
+ for the string
+**/
+BOOL string_set(char **dest, const char *src)
+{
+	string_free(dest);
+	return string_init(dest,src);
+}
+
+/**
+ Substitute a string for a pattern in another string. Make sure there is 
+ enough room!
+
+ This routine looks for pattern in s and replaces it with 
+ insert. It may do multiple replacements.
+
+ Any of " ; ' $ or ` in the insert string are replaced with _
+ if len==0 then the string cannot be extended. This is different from the old
+ use of len==0 which was for no length checks to be done.
+**/
+
+void string_sub(char *s,const char *pattern, const char *insert, size_t len)
+{
+	char *p;
+	ssize_t ls,lp,li, i;
+
+	if (!insert || !pattern || !*pattern || !s)
+		return;
+
+	ls = (ssize_t)strlen(s);
+	lp = (ssize_t)strlen(pattern);
+	li = (ssize_t)strlen(insert);
+
+	if (len == 0)
+		len = ls + 1; /* len is number of *bytes* */
+
+	while (lp <= ls && (p = strstr(s,pattern))) {
+		if (ls + (li-lp) >= len) {
+			DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n", 
+				 (int)(ls + (li-lp) - len),
+				 pattern, (int)len));
+			break;
+		}
+		if (li != lp) {
+			memmove(p+li,p+lp,strlen(p+lp)+1);
+		}
+		for (i=0;i<li;i++) {
+			switch (insert[i]) {
+			case '`':
+			case '"':
+			case '\'':
+			case ';':
+			case '$':
+			case '%':
+			case '\r':
+			case '\n':
+				p[i] = '_';
+				break;
+			default:
+				p[i] = insert[i];
+			}
+		}
+		s = p + li;
+		ls += (li-lp);
+	}
+}
+
+
+/**
+ Similar to string_sub() but allows for any character to be substituted. 
+ Use with caution!
+ if len==0 then the string cannot be extended. This is different from the old
+ use of len==0 which was for no length checks to be done.
+**/
+
+void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
+{
+	char *p;
+	ssize_t ls,lp,li;
+
+	if (!insert || !pattern || !s)
+		return;
+
+	ls = (ssize_t)strlen(s);
+	lp = (ssize_t)strlen(pattern);
+	li = (ssize_t)strlen(insert);
+
+	if (!*pattern)
+		return;
+	
+	if (len == 0)
+		len = ls + 1; /* len is number of *bytes* */
+	
+	while (lp <= ls && (p = strstr(s,pattern))) {
+		if (ls + (li-lp) >= len) {
+			DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n", 
+				 (int)(ls + (li-lp) - len),
+				 pattern, (int)len));
+			break;
+		}
+		if (li != lp) {
+			memmove(p+li,p+lp,strlen(p+lp)+1);
+		}
+		memcpy(p, insert, li);
+		s = p + li;
+		ls += (li-lp);
+	}
+}
+
+
+/**
+ Strchr and strrchr_m are a bit complex on general multi-byte strings. 
+**/
+char *strchr_m(const char *s, char c)
+{
+	/* characters below 0x3F are guaranteed to not appear in
+	   non-initial position in multi-byte charsets */
+	if ((c & 0xC0) == 0) {
+		return strchr(s, c);
+	}
+
+	while (*s) {
+		size_t size;
+		codepoint_t c2 = next_codepoint(s, &size);
+		if (c2 == c) {
+			return discard_const(s);
+		}
+		s += size;
+	}
+
+	return NULL;
+}
+
+char *strrchr_m(const char *s, char c)
+{
+	char *ret = NULL;
+
+	/* characters below 0x3F are guaranteed to not appear in
+	   non-initial position in multi-byte charsets */
+	if ((c & 0xC0) == 0) {
+		return strrchr(s, c);
+	}
+
+	while (*s) {
+		size_t size;
+		codepoint_t c2 = next_codepoint(s, &size);
+		if (c2 == c) {
+			ret = discard_const(s);
+		}
+		s += size;
+	}
+
+	return ret;
+}
+
+/*
+  return True if any (multi-byte) character is lower case
+*/
+BOOL strhaslower(const char *string)
+{
+	while (*string) {
+		size_t c_size;
+		codepoint_t s;
+		codepoint_t t;
+
+		s = next_codepoint(string, &c_size);
+		string += c_size;
+
+		t = toupper_w(s);
+
+		if (s != t) {
+			return True; /* that means it has lower case chars */
+		}
+	}
+
+	return False;
+} 
+
+/*
+  return True if any (multi-byte) character is upper case
+*/
+BOOL strhasupper(const char *string)
+{
+	while (*string) {
+		size_t c_size;
+		codepoint_t s;
+		codepoint_t t;
+
+		s = next_codepoint(string, &c_size);
+		string += c_size;
+
+		t = tolower_w(s);
+
+		if (s != t) {
+			return True; /* that means it has upper case chars */
+		}
+	}
+
+	return False;
+} 
+
+/**
+ Convert a string to lower case, allocated with talloc
+**/
+char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
+{
+	size_t size=0;
+	char *dest;
+
+	/* this takes advantage of the fact that upper/lower can't
+	   change the length of a character by more than 1 byte */
+	dest = talloc_size(ctx, 2*(strlen(src))+1);
+	if (dest == NULL) {
+		return NULL;
+	}
+
+	while (*src) {
+		size_t c_size;
+		codepoint_t c = next_codepoint(src, &c_size);
+		src += c_size;
+
+		c = tolower_w(c);
+
+		c_size = push_codepoint(dest+size, c);
+		if (c_size == -1) {
+			talloc_free(dest);
+			return NULL;
+		}
+		size += c_size;
+	}
+
+	dest[size] = 0;
+
+	return dest;
+}
+
+/**
+ Convert a string to UPPER case, allocated with talloc
+**/
+char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
+{
+	size_t size=0;
+	char *dest;
+	
+	if (!src) {
+		return NULL;
+	}
+
+	/* this takes advantage of the fact that upper/lower can't
+	   change the length of a character by more than 1 byte */
+	dest = talloc_size(ctx, 2*(strlen(src))+1);
+	if (dest == NULL) {
+		return NULL;
+	}
+
+	while (*src) {
+		size_t c_size;
+		codepoint_t c = next_codepoint(src, &c_size);
+		src += c_size;
+
+		c = toupper_w(c);
+
+		c_size = push_codepoint(dest+size, c);
+		if (c_size == -1) {
+			talloc_free(dest);
+			return NULL;
+		}
+		size += c_size;
+	}
+
+	dest[size] = 0;
+
+	return dest;
+}
+
+/**
+ Convert a string to lower case.
+**/
+void strlower_m(char *s)
+{
+	char *d;
+
+	/* this is quite a common operation, so we want it to be
+	   fast. We optimise for the ascii case, knowing that all our
+	   supported multi-byte character sets are ascii-compatible
+	   (ie. they match for the first 128 chars) */
+	while (*s && !(((uint8_t)*s) & 0x80)) {
+		*s = tolower((uint8_t)*s);
+		s++;
+	}
+
+	if (!*s)
+		return;
+
+	d = s;
+
+	while (*s) {
+		size_t c_size, c_size2;
+		codepoint_t c = next_codepoint(s, &c_size);
+		c_size2 = push_codepoint(d, tolower_w(c));
+		if (c_size2 > c_size) {
+			DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
+				 c, tolower_w(c), (int)c_size, (int)c_size2));
+			smb_panic("codepoint expansion in strlower_m\n");
+		}
+		s += c_size;
+		d += c_size2;
+	}
+	*d = 0;
+}
+
+/**
+ Convert a string to UPPER case.
+**/
+void strupper_m(char *s)
+{
+	char *d;
+
+	/* this is quite a common operation, so we want it to be
+	   fast. We optimise for the ascii case, knowing that all our
+	   supported multi-byte character sets are ascii-compatible
+	   (ie. they match for the first 128 chars) */
+	while (*s && !(((uint8_t)*s) & 0x80)) {
+		*s = toupper((uint8_t)*s);
+		s++;
+	}
+
+	if (!*s)
+		return;
+
+	d = s;
+
+	while (*s) {
+		size_t c_size, c_size2;
+		codepoint_t c = next_codepoint(s, &c_size);
+		c_size2 = push_codepoint(d, toupper_w(c));
+		if (c_size2 > c_size) {
+			DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
+				 c, toupper_w(c), (int)c_size, (int)c_size2));
+			smb_panic("codepoint expansion in strupper_m\n");
+		}
+		s += c_size;
+		d += c_size2;
+	}
+	*d = 0;
+}
+
+/**
+ Count the number of UCS2 characters in a string. Normally this will
+ be the same as the number of bytes in a string for single byte strings,
+ but will be different for multibyte.
+**/
+size_t strlen_m(const char *s)
+{
+	size_t count = 0;
+
+	if (!s) {
+		return 0;
+	}
+
+	while (*s && !(((uint8_t)*s) & 0x80)) {
+		s++;
+		count++;
+	}
+
+	if (!*s) {
+		return count;
+	}
+
+	while (*s) {
+		size_t c_size;
+		codepoint_t c = next_codepoint(s, &c_size);
+		if (c < 0x10000) {
+			count += 1;
+		} else {
+			count += 2;
+		}
+		s += c_size;
+	}
+
+	return count;
+}
+
+/**
+   Work out the number of multibyte chars in a string, including the NULL
+   terminator.
+**/
+size_t strlen_m_term(const char *s)
+{
+	if (!s) {
+		return 0;
+	}
+
+	return strlen_m(s) + 1;
+}
+
+/**
+ Unescape a URL encoded string, in place.
+**/
+
+void rfc1738_unescape(char *buf)
+{
+	char *p=buf;
+
+	while ((p=strchr_m(p,'+')))
+		*p = ' ';
+
+	p = buf;
+
+	while (p && *p && (p=strchr_m(p,'%'))) {
+		int c1 = p[1];
+		int c2 = p[2];
+
+		if (c1 >= '0' && c1 <= '9')
+			c1 = c1 - '0';
+		else if (c1 >= 'A' && c1 <= 'F')
+			c1 = 10 + c1 - 'A';
+		else if (c1 >= 'a' && c1 <= 'f')
+			c1 = 10 + c1 - 'a';
+		else {p++; continue;}
+
+		if (c2 >= '0' && c2 <= '9')
+			c2 = c2 - '0';
+		else if (c2 >= 'A' && c2 <= 'F')
+			c2 = 10 + c2 - 'A';
+		else if (c2 >= 'a' && c2 <= 'f')
+			c2 = 10 + c2 - 'a';
+		else {p++; continue;}
+			
+		*p = (c1<<4) | c2;
+
+		memmove(p+1, p+3, strlen(p+3)+1);
+		p++;
+	}
+}
+
+/**
+ * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
+ **/
+DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
+{
+	DATA_BLOB ret = data_blob_talloc(mem_ctx, s, strlen(s)+1);
+	ret.length = ldb_base64_decode((char *)ret.data);
+	return ret;
+}
+
+/**
+ * Decode a base64 string in-place - wrapper for the above
+ **/
+void base64_decode_inplace(char *s)
+{
+	ldb_base64_decode(s);
+}
+
+/**
+ * Encode a base64 string into a talloc()ed string caller to free.
+ **/
+char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
+{
+	return ldb_base64_encode(mem_ctx, (const char *)data.data, data.length);
+}
+
+#ifdef VALGRIND
+size_t valgrind_strlen(const char *s)
+{
+	size_t count;
+	for(count = 0; *s++; count++)
+		;
+	return count;
+}
+#endif
+
+
+/*
+  format a string into length-prefixed dotted domain format, as used in NBT
+  and in some ADS structures
+*/
+const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
+{
+	char *ret;
+	int i;
+	if (!s || !*s) {
+		return talloc_strdup(mem_ctx, "");
+	}
+	ret = talloc_size(mem_ctx, strlen(s)+2);
+	if (!ret) {
+		return ret;
+	}
+	
+	memcpy(ret+1, s, strlen(s)+1);
+	ret[0] = '.';
+
+	for (i=0;ret[i];i++) {
+		if (ret[i] == '.') {
+			char *p = strchr(ret+i+1, '.');
+			if (p) {
+				ret[i] = p-(ret+i+1);
+			} else {
+				ret[i] = strlen(ret+i+1);
+			}
+		}
+	}
+
+	return ret;
+}
+
+BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
+			 const char *str, const char ***strings, int *num)
+{
+	char *dup_str = talloc_strdup(mem_ctx, str);
+
+	*strings = talloc_realloc(mem_ctx,
+				    *strings,
+				    const char *, ((*num)+1));
+
+	if ((*strings == NULL) || (dup_str == NULL))
+		return False;
+
+	(*strings)[*num] = dup_str;
+	*num += 1;
+
+	return True;
+}
+
+
+
+/*
+  varient of strcmp() that handles NULL ptrs
+*/
+int strcmp_safe(const char *s1, const char *s2)
+{
+	if (s1 == s2) {
+		return 0;
+	}
+	if (s1 == NULL || s2 == NULL) {
+		return s1?-1:1;
+	}
+	return strcmp(s1, s2);
+}
+
+
+/*******************************************************************
+return the number of bytes occupied by a buffer in ASCII format
+the result includes the null termination
+limited by 'n' bytes
+********************************************************************/
+size_t ascii_len_n(const char *src, size_t n)
+{
+	size_t len;
+
+	len = strnlen(src, n);
+	if (len+1 <= n) {
+		len += 1;
+	}
+
+	return len;
+}
+
+
+/*******************************************************************
+ Return a string representing a CIFS attribute for a file.
+********************************************************************/
+char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
+{
+	int i, len;
+	const struct {
+		char c;
+		uint16_t attr;
+	} attr_strs[] = {
+		{'V', FILE_ATTRIBUTE_VOLUME},
+		{'D', FILE_ATTRIBUTE_DIRECTORY},
+		{'A', FILE_ATTRIBUTE_ARCHIVE},
+		{'H', FILE_ATTRIBUTE_HIDDEN},
+		{'S', FILE_ATTRIBUTE_SYSTEM},
+		{'N', FILE_ATTRIBUTE_NORMAL},
+		{'R', FILE_ATTRIBUTE_READONLY},
+		{'d', FILE_ATTRIBUTE_DEVICE},
+		{'t', FILE_ATTRIBUTE_TEMPORARY},
+		{'s', FILE_ATTRIBUTE_SPARSE},
+		{'r', FILE_ATTRIBUTE_REPARSE_POINT},
+		{'c', FILE_ATTRIBUTE_COMPRESSED},
+		{'o', FILE_ATTRIBUTE_OFFLINE},
+		{'n', FILE_ATTRIBUTE_NONINDEXED},
+		{'e', FILE_ATTRIBUTE_ENCRYPTED}
+	};
+	char *ret;
+
+	ret = talloc_size(mem_ctx, ARRAY_SIZE(attr_strs)+1);
+	if (!ret) {
+		return NULL;
+	}
+
+	for (len=i=0; i<ARRAY_SIZE(attr_strs); i++) {
+		if (attrib & attr_strs[i].attr) {
+			ret[len++] = attr_strs[i].c;
+		}
+	}
+
+	ret[len] = 0;
+
+	return ret;
+}
+
+/***************************************************************************
+ Set a boolean variable from the text value stored in the passed string.
+ Returns True in success, False if the passed string does not correctly 
+ represent a boolean.
+***************************************************************************/
+
+BOOL set_boolean(const char *boolean_string, BOOL *boolean)
+{
+	if (strwicmp(boolean_string, "yes") == 0 ||
+	    strwicmp(boolean_string, "true") == 0 ||
+	    strwicmp(boolean_string, "on") == 0 ||
+	    strwicmp(boolean_string, "1") == 0) {
+		*boolean = True;
+		return True;
+	} else if (strwicmp(boolean_string, "no") == 0 ||
+		   strwicmp(boolean_string, "false") == 0 ||
+		   strwicmp(boolean_string, "off") == 0 ||
+		   strwicmp(boolean_string, "0") == 0) {
+		*boolean = False;
+		return True;
+	}
+	return False;
+}
+
+BOOL conv_str_bool(const char * str, BOOL * val)
+{
+	char *	end = NULL;
+	long	lval;
+
+	if (str == NULL || *str == '\0') {
+		return False;
+	}
+
+	lval = strtol(str, &end, 10 /* base */);
+	if (end == NULL || *end != '\0' || end == str) {
+		return set_boolean(str, val);
+	}
+
+	*val = (lval) ? True : False;
+	return True;
+}
+
+/* Convert a size specification like 16K into an integral number of bytes. */
+BOOL conv_str_size(const char * str, uint64_t * val)
+{
+	char *		    end = NULL;
+	unsigned long long  lval;
+
+	if (str == NULL || *str == '\0') {
+		return False;
+	}
+
+	lval = strtoull(str, &end, 10 /* base */);
+	if (end == NULL || end == str) {
+		return False;
+	}
+
+	if (*end) {
+		if (strwicmp(end, "K") == 0) {
+			lval *= 1024ULL;
+		} else if (strwicmp(end, "M") == 0) {
+			lval *= (1024ULL * 1024ULL);
+		} else if (strwicmp(end, "G") == 0) {
+			lval *= (1024ULL * 1024ULL * 1024ULL);
+		} else if (strwicmp(end, "T") == 0) {
+			lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL);
+		} else if (strwicmp(end, "P") == 0) {
+			lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL);
+		} else {
+			return False;
+		}
+	}
+
+	*val = (uint64_t)lval;
+	return True;
+}
+
+BOOL conv_str_u64(const char * str, uint64_t * val)
+{
+	char *		    end = NULL;
+	unsigned long long  lval;
+
+	if (str == NULL || *str == '\0') {
+		return False;
+	}
+
+	lval = strtoull(str, &end, 10 /* base */);
+	if (end == NULL || *end != '\0' || end == str) {
+		return False;
+	}
+
+	*val = (uint64_t)lval;
+	return True;
+}
-- 
cgit 


From aa04388943fe5d7d8c873a6ee8a4cc9af2491532 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 28 Feb 2006 13:12:39 +0000
Subject: r13752: Add doxyfile and fix formatting of comments. Current output
 is available at http://samba.org/~jelmer/util-api/ (This used to be commit
 90812203df151a5e62394306827c72adfe13c63c)

---
 source4/lib/util/util_str.c | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index b46787e3ea..11a95731de 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -983,10 +983,10 @@ size_t valgrind_strlen(const char *s)
 #endif
 
 
-/*
+/**
   format a string into length-prefixed dotted domain format, as used in NBT
   and in some ADS structures
-*/
+**/
 const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
 {
 	char *ret;
@@ -1036,9 +1036,9 @@ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 
 
 
-/*
+/**
   varient of strcmp() that handles NULL ptrs
-*/
+**/
 int strcmp_safe(const char *s1, const char *s2)
 {
 	if (s1 == s2) {
@@ -1051,11 +1051,11 @@ int strcmp_safe(const char *s1, const char *s2)
 }
 
 
-/*******************************************************************
+/**
 return the number of bytes occupied by a buffer in ASCII format
 the result includes the null termination
 limited by 'n' bytes
-********************************************************************/
+**/
 size_t ascii_len_n(const char *src, size_t n)
 {
 	size_t len;
@@ -1069,9 +1069,9 @@ size_t ascii_len_n(const char *src, size_t n)
 }
 
 
-/*******************************************************************
+/**
  Return a string representing a CIFS attribute for a file.
-********************************************************************/
+**/
 char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
 {
 	int i, len;
@@ -1113,11 +1113,11 @@ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
 	return ret;
 }
 
-/***************************************************************************
+/**
  Set a boolean variable from the text value stored in the passed string.
  Returns True in success, False if the passed string does not correctly 
  represent a boolean.
-***************************************************************************/
+**/
 
 BOOL set_boolean(const char *boolean_string, BOOL *boolean)
 {
@@ -1155,7 +1155,9 @@ BOOL conv_str_bool(const char * str, BOOL * val)
 	return True;
 }
 
-/* Convert a size specification like 16K into an integral number of bytes. */
+/**
+ * Convert a size specification like 16K into an integral number of bytes. 
+ **/
 BOOL conv_str_size(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
-- 
cgit 


From af30a32b6924b0f2b701186e435defbca2ebd1aa Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 5 Mar 2006 17:15:19 +0000
Subject: r13840: Mark some functions as public. (This used to be commit
 9a188eb1f48a50d92a67a4fc2b3899b90074059a)

---
 source4/lib/util/util_str.c | 86 ++++++++++++++++++++++-----------------------
 1 file changed, 43 insertions(+), 43 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 11a95731de..ef6abd6e83 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -40,7 +40,7 @@
  * Based on a routine by GJC@VILLAGE.COM. 
  * Extensively modified by Andrew.Tridgell@anu.edu.au
  **/
-BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
+_PUBLIC_ BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
 {
 	const char *s;
 	BOOL quoted;
@@ -82,7 +82,7 @@ BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
 /**
  Case insensitive string compararison
 **/
-int strcasecmp_m(const char *s1, const char *s2)
+_PUBLIC_ int strcasecmp_m(const char *s1, const char *s2)
 {
 	codepoint_t c1=0, c2=0;
 	size_t size1, size2;
@@ -117,7 +117,7 @@ int strcasecmp_m(const char *s1, const char *s2)
  *
  * @note The comparison is case-insensitive.
  **/
-BOOL strequal(const char *s1, const char *s2)
+_PUBLIC_ BOOL strequal(const char *s1, const char *s2)
 {
 	if (s1 == s2)
 		return(True);
@@ -130,7 +130,7 @@ BOOL strequal(const char *s1, const char *s2)
 /**
  Compare 2 strings (case sensitive).
 **/
-BOOL strcsequal(const char *s1,const char *s2)
+_PUBLIC_ BOOL strcsequal(const char *s1,const char *s2)
 {
 	if (s1 == s2)
 		return(True);
@@ -144,7 +144,7 @@ BOOL strcsequal(const char *s1,const char *s2)
 /**
 Do a case-insensitive, whitespace-ignoring string compare.
 **/
-int strwicmp(const char *psz1, const char *psz2)
+_PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
 {
 	/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
 	/* appropriate value. */
@@ -175,7 +175,7 @@ int strwicmp(const char *psz1, const char *psz2)
  String replace.
  NOTE: oldc and newc must be 7 bit characters
 **/
-void string_replace(char *s, char oldc, char newc)
+_PUBLIC_ void string_replace(char *s, char oldc, char newc)
 {
 	while (*s) {
 		size_t size;
@@ -190,7 +190,7 @@ void string_replace(char *s, char oldc, char newc)
 /**
  Trim the specified elements off the front and back of a string.
 **/
-BOOL trim_string(char *s,const char *front,const char *back)
+_PUBLIC_ BOOL trim_string(char *s,const char *front,const char *back)
 {
 	BOOL ret = False;
 	size_t front_len;
@@ -229,7 +229,7 @@ BOOL trim_string(char *s,const char *front,const char *back)
 /**
  Find the number of 'c' chars in a string
 **/
-size_t count_chars(const char *s, char c)
+_PUBLIC_ size_t count_chars(const char *s, char c)
 {
 	size_t count = 0;
 
@@ -247,7 +247,7 @@ size_t count_chars(const char *s, char c)
  Safe string copy into a known length string. maxlength does not
  include the terminating zero.
 **/
-char *safe_strcpy(char *dest,const char *src, size_t maxlength)
+_PUBLIC_ char *safe_strcpy(char *dest,const char *src, size_t maxlength)
 {
 	size_t len;
 
@@ -289,7 +289,7 @@ char *safe_strcpy(char *dest,const char *src, size_t maxlength)
  Safe string cat into a string. maxlength does not
  include the terminating zero.
 **/
-char *safe_strcat(char *dest, const char *src, size_t maxlength)
+_PUBLIC_ char *safe_strcat(char *dest, const char *src, size_t maxlength)
 {
 	size_t src_len, dest_len;
 
@@ -331,7 +331,7 @@ char *safe_strcat(char *dest, const char *src, size_t maxlength)
  characters. Don't change it !
 **/
 
-char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
+_PUBLIC_ char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
 {
 	size_t len, i;
 
@@ -375,7 +375,7 @@ char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, si
  The variable n should always be one less than the available size.
 **/
 
-char *StrnCpy(char *dest,const char *src,size_t n)
+_PUBLIC_ char *StrnCpy(char *dest,const char *src,size_t n)
 {
 	char *d = dest;
 	if (!dest)
@@ -401,7 +401,7 @@ char *StrnCpy(char *dest,const char *src,size_t n)
 
 
 **/
-size_t strhex_to_str(char *p, size_t len, const char *strhex)
+_PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 {
 	size_t i;
 	size_t num_chars = 0;
@@ -436,7 +436,7 @@ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 	return num_chars;
 }
 
-DATA_BLOB strhex_to_data_blob(const char *strhex) 
+_PUBLIC_ DATA_BLOB strhex_to_data_blob(const char *strhex) 
 {
 	DATA_BLOB ret_blob = data_blob(NULL, strlen(strhex)/2+1);
 
@@ -451,7 +451,7 @@ DATA_BLOB strhex_to_data_blob(const char *strhex)
 /**
  * Routine to print a buffer as HEX digits, into an allocated string.
  */
-void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
+_PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
 {
 	int i;
 	char *hex_buffer;
@@ -466,7 +466,7 @@ void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
 /**
  Check if a string is part of a list.
 **/
-BOOL in_list(const char *s, const char *list, BOOL casesensitive)
+_PUBLIC_ BOOL in_list(const char *s, const char *list, BOOL casesensitive)
 {
 	pstring tok;
 	const char *p=list;
@@ -504,7 +504,7 @@ static BOOL string_init(char **dest,const char *src)
 /**
  Free a string value.
 **/
-void string_free(char **s)
+_PUBLIC_ void string_free(char **s)
 {
 	if (s) SAFE_FREE(*s);
 }
@@ -513,7 +513,7 @@ void string_free(char **s)
  Set a string value, deallocating any existing space, and allocing the space
  for the string
 **/
-BOOL string_set(char **dest, const char *src)
+_PUBLIC_ BOOL string_set(char **dest, const char *src)
 {
 	string_free(dest);
 	return string_init(dest,src);
@@ -531,7 +531,7 @@ BOOL string_set(char **dest, const char *src)
  use of len==0 which was for no length checks to be done.
 **/
 
-void string_sub(char *s,const char *pattern, const char *insert, size_t len)
+_PUBLIC_ void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 {
 	char *p;
 	ssize_t ls,lp,li, i;
@@ -585,7 +585,7 @@ void string_sub(char *s,const char *pattern, const char *insert, size_t len)
  use of len==0 which was for no length checks to be done.
 **/
 
-void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
+_PUBLIC_ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
 {
 	char *p;
 	ssize_t ls,lp,li;
@@ -623,7 +623,7 @@ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
 /**
  Strchr and strrchr_m are a bit complex on general multi-byte strings. 
 **/
-char *strchr_m(const char *s, char c)
+_PUBLIC_ char *strchr_m(const char *s, char c)
 {
 	/* characters below 0x3F are guaranteed to not appear in
 	   non-initial position in multi-byte charsets */
@@ -643,7 +643,7 @@ char *strchr_m(const char *s, char c)
 	return NULL;
 }
 
-char *strrchr_m(const char *s, char c)
+_PUBLIC_ char *strrchr_m(const char *s, char c)
 {
 	char *ret = NULL;
 
@@ -668,7 +668,7 @@ char *strrchr_m(const char *s, char c)
 /*
   return True if any (multi-byte) character is lower case
 */
-BOOL strhaslower(const char *string)
+_PUBLIC_ BOOL strhaslower(const char *string)
 {
 	while (*string) {
 		size_t c_size;
@@ -691,7 +691,7 @@ BOOL strhaslower(const char *string)
 /*
   return True if any (multi-byte) character is upper case
 */
-BOOL strhasupper(const char *string)
+_PUBLIC_ BOOL strhasupper(const char *string)
 {
 	while (*string) {
 		size_t c_size;
@@ -714,7 +714,7 @@ BOOL strhasupper(const char *string)
 /**
  Convert a string to lower case, allocated with talloc
 **/
-char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
+_PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
 {
 	size_t size=0;
 	char *dest;
@@ -749,7 +749,7 @@ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
 /**
  Convert a string to UPPER case, allocated with talloc
 **/
-char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
+_PUBLIC_ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
 {
 	size_t size=0;
 	char *dest;
@@ -788,7 +788,7 @@ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
 /**
  Convert a string to lower case.
 **/
-void strlower_m(char *s)
+_PUBLIC_ void strlower_m(char *s)
 {
 	char *d;
 
@@ -824,7 +824,7 @@ void strlower_m(char *s)
 /**
  Convert a string to UPPER case.
 **/
-void strupper_m(char *s)
+_PUBLIC_ void strupper_m(char *s)
 {
 	char *d;
 
@@ -862,7 +862,7 @@ void strupper_m(char *s)
  be the same as the number of bytes in a string for single byte strings,
  but will be different for multibyte.
 **/
-size_t strlen_m(const char *s)
+_PUBLIC_ size_t strlen_m(const char *s)
 {
 	size_t count = 0;
 
@@ -897,7 +897,7 @@ size_t strlen_m(const char *s)
    Work out the number of multibyte chars in a string, including the NULL
    terminator.
 **/
-size_t strlen_m_term(const char *s)
+_PUBLIC_ size_t strlen_m_term(const char *s)
 {
 	if (!s) {
 		return 0;
@@ -910,7 +910,7 @@ size_t strlen_m_term(const char *s)
  Unescape a URL encoded string, in place.
 **/
 
-void rfc1738_unescape(char *buf)
+_PUBLIC_ void rfc1738_unescape(char *buf)
 {
 	char *p=buf;
 
@@ -949,7 +949,7 @@ void rfc1738_unescape(char *buf)
 /**
  * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
  **/
-DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
+_PUBLIC_ DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
 {
 	DATA_BLOB ret = data_blob_talloc(mem_ctx, s, strlen(s)+1);
 	ret.length = ldb_base64_decode((char *)ret.data);
@@ -959,7 +959,7 @@ DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
 /**
  * Decode a base64 string in-place - wrapper for the above
  **/
-void base64_decode_inplace(char *s)
+_PUBLIC_ void base64_decode_inplace(char *s)
 {
 	ldb_base64_decode(s);
 }
@@ -967,7 +967,7 @@ void base64_decode_inplace(char *s)
 /**
  * Encode a base64 string into a talloc()ed string caller to free.
  **/
-char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
+_PUBLIC_ char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
 {
 	return ldb_base64_encode(mem_ctx, (const char *)data.data, data.length);
 }
@@ -987,7 +987,7 @@ size_t valgrind_strlen(const char *s)
   format a string into length-prefixed dotted domain format, as used in NBT
   and in some ADS structures
 **/
-const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
+_PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
 {
 	char *ret;
 	int i;
@@ -1016,7 +1016,7 @@ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
 	return ret;
 }
 
-BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
+_PUBLIC_ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 			 const char *str, const char ***strings, int *num)
 {
 	char *dup_str = talloc_strdup(mem_ctx, str);
@@ -1039,7 +1039,7 @@ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 /**
   varient of strcmp() that handles NULL ptrs
 **/
-int strcmp_safe(const char *s1, const char *s2)
+_PUBLIC_ int strcmp_safe(const char *s1, const char *s2)
 {
 	if (s1 == s2) {
 		return 0;
@@ -1056,7 +1056,7 @@ return the number of bytes occupied by a buffer in ASCII format
 the result includes the null termination
 limited by 'n' bytes
 **/
-size_t ascii_len_n(const char *src, size_t n)
+_PUBLIC_ size_t ascii_len_n(const char *src, size_t n)
 {
 	size_t len;
 
@@ -1072,7 +1072,7 @@ size_t ascii_len_n(const char *src, size_t n)
 /**
  Return a string representing a CIFS attribute for a file.
 **/
-char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
+_PUBLIC_ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
 {
 	int i, len;
 	const struct {
@@ -1119,7 +1119,7 @@ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
  represent a boolean.
 **/
 
-BOOL set_boolean(const char *boolean_string, BOOL *boolean)
+_PUBLIC_ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
 {
 	if (strwicmp(boolean_string, "yes") == 0 ||
 	    strwicmp(boolean_string, "true") == 0 ||
@@ -1137,7 +1137,7 @@ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
 	return False;
 }
 
-BOOL conv_str_bool(const char * str, BOOL * val)
+_PUBLIC_ BOOL conv_str_bool(const char * str, BOOL * val)
 {
 	char *	end = NULL;
 	long	lval;
@@ -1158,7 +1158,7 @@ BOOL conv_str_bool(const char * str, BOOL * val)
 /**
  * Convert a size specification like 16K into an integral number of bytes. 
  **/
-BOOL conv_str_size(const char * str, uint64_t * val)
+_PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
 	unsigned long long  lval;
@@ -1192,7 +1192,7 @@ BOOL conv_str_size(const char * str, uint64_t * val)
 	return True;
 }
 
-BOOL conv_str_u64(const char * str, uint64_t * val)
+_PUBLIC_ BOOL conv_str_u64(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
 	unsigned long long  lval;
-- 
cgit 


From c287cc247d90c996894cab18e870c992e7f84f85 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 6 Mar 2006 00:24:51 +0000
Subject: r13851: More doc improvements. (This used to be commit
 936d26ae64b93ef8f8b2fbc632b1c2fd60840405)

---
 source4/lib/util/util_str.c | 30 ++++++++++++++++++++++++++++--
 1 file changed, 28 insertions(+), 2 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index ef6abd6e83..4bb3ea1b54 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -436,6 +436,9 @@ _PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 	return num_chars;
 }
 
+/** 
+ * Parse a hex string and return a data blob. 
+ */
 _PUBLIC_ DATA_BLOB strhex_to_data_blob(const char *strhex) 
 {
 	DATA_BLOB ret_blob = data_blob(NULL, strlen(strhex)/2+1);
@@ -643,6 +646,9 @@ _PUBLIC_ char *strchr_m(const char *s, char c)
 	return NULL;
 }
 
+/**
+ * Multibyte-character version of strrchr
+ */
 _PUBLIC_ char *strrchr_m(const char *s, char c)
 {
 	char *ret = NULL;
@@ -665,7 +671,7 @@ _PUBLIC_ char *strrchr_m(const char *s, char c)
 	return ret;
 }
 
-/*
+/**
   return True if any (multi-byte) character is lower case
 */
 _PUBLIC_ BOOL strhaslower(const char *string)
@@ -688,7 +694,7 @@ _PUBLIC_ BOOL strhaslower(const char *string)
 	return False;
 } 
 
-/*
+/**
   return True if any (multi-byte) character is upper case
 */
 _PUBLIC_ BOOL strhasupper(const char *string)
@@ -1016,6 +1022,12 @@ _PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
 	return ret;
 }
 
+/**
+ * Add a string to an array of strings.
+ *
+ * num should be a pointer to an integer that holds the current 
+ * number of elements in strings. It will be updated by this function.
+ */
 _PUBLIC_ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 			 const char *str, const char ***strings, int *num)
 {
@@ -1137,6 +1149,13 @@ _PUBLIC_ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
 	return False;
 }
 
+/**
+ * Parse a string containing a boolean value.
+ *
+ * val will be set to the read value.
+ *
+ * @retval True if a boolean value was parsed, False otherwise.
+ */
 _PUBLIC_ BOOL conv_str_bool(const char * str, BOOL * val)
 {
 	char *	end = NULL;
@@ -1192,6 +1211,13 @@ _PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
 	return True;
 }
 
+/**
+ * Parse a uint64_t value from a string
+ *
+ * val will be set to the value read.
+ *
+ * @retval True if parsing was successful, False otherwise
+ */
 _PUBLIC_ BOOL conv_str_u64(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
-- 
cgit 


From 2216af23c70ec8dee7162aaf35be5aed60a1a8ca Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 21 Mar 2006 11:37:11 +0000
Subject: r14612: added strncasecmp_m() and fixed strcasecmp_m() for invalid
 codepoints (This used to be commit 12b533450bdb31b57154940898f2f02c49e96ed1)

---
 source4/lib/util/util_str.c | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 4bb3ea1b54..8f408c00dc 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -101,14 +101,53 @@ _PUBLIC_ int strcasecmp_m(const char *s1, const char *s2)
 		if (c1 == INVALID_CODEPOINT ||
 		    c2 == INVALID_CODEPOINT) {
 			/* what else can we do?? */
+			return strcasecmp(s1, s2);
+		}
+
+		if (toupper_w(c1) != toupper_w(c2)) {
 			return c1 - c2;
 		}
+	}
+
+	return *s1 - *s2;
+}
+
+/**
+ Case insensitive string compararison, length limited
+**/
+_PUBLIC_ int strncasecmp_m(const char *s1, const char *s2, size_t n)
+{
+	codepoint_t c1=0, c2=0;
+	size_t size1, size2;
+
+	while (*s1 && *s2 && n) {
+		n--;
+
+		c1 = next_codepoint(s1, &size1);
+		c2 = next_codepoint(s2, &size2);
+
+		s1 += size1;
+		s2 += size2;
+
+		if (c1 == c2) {
+			continue;
+		}
+
+		if (c1 == INVALID_CODEPOINT ||
+		    c2 == INVALID_CODEPOINT) {
+			/* what else can we do?? */
+			return strcasecmp(s1, s2);
+		}
 
 		if (toupper_w(c1) != toupper_w(c2)) {
 			return c1 - c2;
 		}
 	}
 
+	if (n == 0) {
+		return 0;
+	}
+
 	return *s1 - *s2;
 }
 
-- 
cgit 


From 8d137d97858a618c8c5451bb7b11fb95990540c8 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 27 Apr 2006 16:05:05 +0000
Subject: r15295: Fix some dependencies Move unistr-specific code to
 lib/charset/. Remove _m from some places where it's not needed. (This used to
 be commit 03224e112424968fc3f547c6159c7ccae2d1aa5b)

---
 source4/lib/util/util_str.c | 652 +++++++-------------------------------------
 1 file changed, 97 insertions(+), 555 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 8f408c00dc..9de27c0777 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -23,208 +23,16 @@
 */
 
 #include "includes.h"
-#include "system/iconv.h"
 #include "smb.h"
 #include "pstring.h"
 #include "lib/ldb/include/ldb.h"
+#include "system/iconv.h"
 
 /**
  * @file
  * @brief String utilities.
  **/
 
-/**
- * Get the next token from a string, return False if none found.
- * Handles double-quotes.
- * 
- * Based on a routine by GJC@VILLAGE.COM. 
- * Extensively modified by Andrew.Tridgell@anu.edu.au
- **/
-_PUBLIC_ BOOL next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
-{
-	const char *s;
-	BOOL quoted;
-	size_t len=1;
-
-	if (!ptr)
-		return(False);
-
-	s = *ptr;
-
-	/* default to simple separators */
-	if (!sep)
-		sep = " \t\n\r";
-
-	/* find the first non sep char */
-	while (*s && strchr_m(sep,*s))
-		s++;
-	
-	/* nothing left? */
-	if (! *s)
-		return(False);
-	
-	/* copy over the token */
-	for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
-		if (*s == '\"') {
-			quoted = !quoted;
-		} else {
-			len++;
-			*buff++ = *s;
-		}
-	}
-	
-	*ptr = (*s) ? s+1 : s;  
-	*buff = 0;
-	
-	return(True);
-}
-
-/**
- Case insensitive string compararison
-**/
-_PUBLIC_ int strcasecmp_m(const char *s1, const char *s2)
-{
-	codepoint_t c1=0, c2=0;
-	size_t size1, size2;
-
-	while (*s1 && *s2) {
-		c1 = next_codepoint(s1, &size1);
-		c2 = next_codepoint(s2, &size2);
-
-		s1 += size1;
-		s2 += size2;
-
-		if (c1 == c2) {
-			continue;
-		}
-
-		if (c1 == INVALID_CODEPOINT ||
-		    c2 == INVALID_CODEPOINT) {
-			/* what else can we do?? */
-			return strcasecmp(s1, s2);
-		}
-
-		if (toupper_w(c1) != toupper_w(c2)) {
-			return c1 - c2;
-		}
-	}
-
-	return *s1 - *s2;
-}
-
-/**
- Case insensitive string compararison, length limited
-**/
-_PUBLIC_ int strncasecmp_m(const char *s1, const char *s2, size_t n)
-{
-	codepoint_t c1=0, c2=0;
-	size_t size1, size2;
-
-	while (*s1 && *s2 && n) {
-		n--;
-
-		c1 = next_codepoint(s1, &size1);
-		c2 = next_codepoint(s2, &size2);
-
-		s1 += size1;
-		s2 += size2;
-
-		if (c1 == c2) {
-			continue;
-		}
-
-		if (c1 == INVALID_CODEPOINT ||
-		    c2 == INVALID_CODEPOINT) {
-			/* what else can we do?? */
-			return strcasecmp(s1, s2);
-		}
-
-		if (toupper_w(c1) != toupper_w(c2)) {
-			return c1 - c2;
-		}
-	}
-
-	if (n == 0) {
-		return 0;
-	}
-
-	return *s1 - *s2;
-}
-
-/**
- * Compare 2 strings.
- *
- * @note The comparison is case-insensitive.
- **/
-_PUBLIC_ BOOL strequal(const char *s1, const char *s2)
-{
-	if (s1 == s2)
-		return(True);
-	if (!s1 || !s2)
-		return(False);
-  
-	return strcasecmp_m(s1,s2) == 0;
-}
-
-/**
- Compare 2 strings (case sensitive).
-**/
-_PUBLIC_ BOOL strcsequal(const char *s1,const char *s2)
-{
-	if (s1 == s2)
-		return(True);
-	if (!s1 || !s2)
-		return(False);
-	
-	return strcmp(s1,s2) == 0;
-}
-
-
-/**
-Do a case-insensitive, whitespace-ignoring string compare.
-**/
-_PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
-{
-	/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
-	/* appropriate value. */
-	if (psz1 == psz2)
-		return (0);
-	else if (psz1 == NULL)
-		return (-1);
-	else if (psz2 == NULL)
-		return (1);
-
-	/* sync the strings on first non-whitespace */
-	while (1) {
-		while (isspace((int)*psz1))
-			psz1++;
-		while (isspace((int)*psz2))
-			psz2++;
-		if (toupper((unsigned char)*psz1) != toupper((unsigned char)*psz2) 
-		    || *psz1 == '\0'
-		    || *psz2 == '\0')
-			break;
-		psz1++;
-		psz2++;
-	}
-	return (*psz1 - *psz2);
-}
-
-/**
- String replace.
- NOTE: oldc and newc must be 7 bit characters
-**/
-_PUBLIC_ void string_replace(char *s, char oldc, char newc)
-{
-	while (*s) {
-		size_t size;
-		codepoint_t c = next_codepoint(s, &size);
-		if (c == oldc) {
-			*s = newc;
-		}
-		s += size;
-	}
-}
 
 /**
  Trim the specified elements off the front and back of a string.
@@ -363,52 +171,6 @@ _PUBLIC_ char *safe_strcat(char *dest, const char *src, size_t maxlength)
 	return dest;
 }
 
-/**
- Paranoid strcpy into a buffer of given length (includes terminating
- zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
- and replaces with '_'. Deliberately does *NOT* check for multibyte
- characters. Don't change it !
-**/
-
-_PUBLIC_ char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
-{
-	size_t len, i;
-
-	if (maxlength == 0) {
-		/* can't fit any bytes at all! */
-		return NULL;
-	}
-
-	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
-		return NULL;
-	}
-
-	if (!src) {
-		*dest = 0;
-		return dest;
-	}  
-
-	len = strlen(src);
-	if (len >= maxlength)
-		len = maxlength - 1;
-
-	if (!other_safe_chars)
-		other_safe_chars = "";
-
-	for(i = 0; i < len; i++) {
-		int val = (src[i] & 0xff);
-		if (isupper(val) || islower(val) || isdigit(val) || strchr_m(other_safe_chars, val))
-			dest[i] = src[i];
-		else
-			dest[i] = '_';
-	}
-
-	dest[i] = '\0';
-
-	return dest;
-}
-
 /**
  Like strncpy but always null terminates. Make sure there is room!
  The variable n should always be one less than the available size.
@@ -454,12 +216,12 @@ _PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 			continue;
 		}
 
-		if (!(p1 = strchr_m(hexchars, toupper((unsigned char)strhex[i]))))
+		if (!(p1 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
 			break;
 
 		i++; /* next hex digit */
 
-		if (!(p2 = strchr_m(hexchars, toupper((unsigned char)strhex[i]))))
+		if (!(p2 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
 			break;
 
 		/* get the two nybbles */
@@ -662,294 +424,6 @@ _PUBLIC_ void all_string_sub(char *s,const char *pattern,const char *insert, siz
 }
 
 
-/**
- Strchr and strrchr_m are a bit complex on general multi-byte strings. 
-**/
-_PUBLIC_ char *strchr_m(const char *s, char c)
-{
-	/* characters below 0x3F are guaranteed to not appear in
-	   non-initial position in multi-byte charsets */
-	if ((c & 0xC0) == 0) {
-		return strchr(s, c);
-	}
-
-	while (*s) {
-		size_t size;
-		codepoint_t c2 = next_codepoint(s, &size);
-		if (c2 == c) {
-			return discard_const(s);
-		}
-		s += size;
-	}
-
-	return NULL;
-}
-
-/**
- * Multibyte-character version of strrchr
- */
-_PUBLIC_ char *strrchr_m(const char *s, char c)
-{
-	char *ret = NULL;
-
-	/* characters below 0x3F are guaranteed to not appear in
-	   non-initial position in multi-byte charsets */
-	if ((c & 0xC0) == 0) {
-		return strrchr(s, c);
-	}
-
-	while (*s) {
-		size_t size;
-		codepoint_t c2 = next_codepoint(s, &size);
-		if (c2 == c) {
-			ret = discard_const(s);
-		}
-		s += size;
-	}
-
-	return ret;
-}
-
-/**
-  return True if any (multi-byte) character is lower case
-*/
-_PUBLIC_ BOOL strhaslower(const char *string)
-{
-	while (*string) {
-		size_t c_size;
-		codepoint_t s;
-		codepoint_t t;
-
-		s = next_codepoint(string, &c_size);
-		string += c_size;
-
-		t = toupper_w(s);
-
-		if (s != t) {
-			return True; /* that means it has lower case chars */
-		}
-	}
-
-	return False;
-} 
-
-/**
-  return True if any (multi-byte) character is upper case
-*/
-_PUBLIC_ BOOL strhasupper(const char *string)
-{
-	while (*string) {
-		size_t c_size;
-		codepoint_t s;
-		codepoint_t t;
-
-		s = next_codepoint(string, &c_size);
-		string += c_size;
-
-		t = tolower_w(s);
-
-		if (s != t) {
-			return True; /* that means it has upper case chars */
-		}
-	}
-
-	return False;
-} 
-
-/**
- Convert a string to lower case, allocated with talloc
-**/
-_PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
-{
-	size_t size=0;
-	char *dest;
-
-	/* this takes advantage of the fact that upper/lower can't
-	   change the length of a character by more than 1 byte */
-	dest = talloc_size(ctx, 2*(strlen(src))+1);
-	if (dest == NULL) {
-		return NULL;
-	}
-
-	while (*src) {
-		size_t c_size;
-		codepoint_t c = next_codepoint(src, &c_size);
-		src += c_size;
-
-		c = tolower_w(c);
-
-		c_size = push_codepoint(dest+size, c);
-		if (c_size == -1) {
-			talloc_free(dest);
-			return NULL;
-		}
-		size += c_size;
-	}
-
-	dest[size] = 0;
-
-	return dest;
-}
-
-/**
- Convert a string to UPPER case, allocated with talloc
-**/
-_PUBLIC_ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
-{
-	size_t size=0;
-	char *dest;
-	
-	if (!src) {
-		return NULL;
-	}
-
-	/* this takes advantage of the fact that upper/lower can't
-	   change the length of a character by more than 1 byte */
-	dest = talloc_size(ctx, 2*(strlen(src))+1);
-	if (dest == NULL) {
-		return NULL;
-	}
-
-	while (*src) {
-		size_t c_size;
-		codepoint_t c = next_codepoint(src, &c_size);
-		src += c_size;
-
-		c = toupper_w(c);
-
-		c_size = push_codepoint(dest+size, c);
-		if (c_size == -1) {
-			talloc_free(dest);
-			return NULL;
-		}
-		size += c_size;
-	}
-
-	dest[size] = 0;
-
-	return dest;
-}
-
-/**
- Convert a string to lower case.
-**/
-_PUBLIC_ void strlower_m(char *s)
-{
-	char *d;
-
-	/* this is quite a common operation, so we want it to be
-	   fast. We optimise for the ascii case, knowing that all our
-	   supported multi-byte character sets are ascii-compatible
-	   (ie. they match for the first 128 chars) */
-	while (*s && !(((uint8_t)*s) & 0x80)) {
-		*s = tolower((uint8_t)*s);
-		s++;
-	}
-
-	if (!*s)
-		return;
-
-	d = s;
-
-	while (*s) {
-		size_t c_size, c_size2;
-		codepoint_t c = next_codepoint(s, &c_size);
-		c_size2 = push_codepoint(d, tolower_w(c));
-		if (c_size2 > c_size) {
-			DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strlower_m\n",
-				 c, tolower_w(c), (int)c_size, (int)c_size2));
-			smb_panic("codepoint expansion in strlower_m\n");
-		}
-		s += c_size;
-		d += c_size2;
-	}
-	*d = 0;
-}
-
-/**
- Convert a string to UPPER case.
-**/
-_PUBLIC_ void strupper_m(char *s)
-{
-	char *d;
-
-	/* this is quite a common operation, so we want it to be
-	   fast. We optimise for the ascii case, knowing that all our
-	   supported multi-byte character sets are ascii-compatible
-	   (ie. they match for the first 128 chars) */
-	while (*s && !(((uint8_t)*s) & 0x80)) {
-		*s = toupper((uint8_t)*s);
-		s++;
-	}
-
-	if (!*s)
-		return;
-
-	d = s;
-
-	while (*s) {
-		size_t c_size, c_size2;
-		codepoint_t c = next_codepoint(s, &c_size);
-		c_size2 = push_codepoint(d, toupper_w(c));
-		if (c_size2 > c_size) {
-			DEBUG(0,("FATAL: codepoint 0x%x (0x%x) expanded from %d to %d bytes in strupper_m\n",
-				 c, toupper_w(c), (int)c_size, (int)c_size2));
-			smb_panic("codepoint expansion in strupper_m\n");
-		}
-		s += c_size;
-		d += c_size2;
-	}
-	*d = 0;
-}
-
-/**
- Count the number of UCS2 characters in a string. Normally this will
- be the same as the number of bytes in a string for single byte strings,
- but will be different for multibyte.
-**/
-_PUBLIC_ size_t strlen_m(const char *s)
-{
-	size_t count = 0;
-
-	if (!s) {
-		return 0;
-	}
-
-	while (*s && !(((uint8_t)*s) & 0x80)) {
-		s++;
-		count++;
-	}
-
-	if (!*s) {
-		return count;
-	}
-
-	while (*s) {
-		size_t c_size;
-		codepoint_t c = next_codepoint(s, &c_size);
-		if (c < 0x10000) {
-			count += 1;
-		} else {
-			count += 2;
-		}
-		s += c_size;
-	}
-
-	return count;
-}
-
-/**
-   Work out the number of multibyte chars in a string, including the NULL
-   terminator.
-**/
-_PUBLIC_ size_t strlen_m_term(const char *s)
-{
-	if (!s) {
-		return 0;
-	}
-
-	return strlen_m(s) + 1;
-}
 
 /**
  Unescape a URL encoded string, in place.
@@ -991,32 +465,6 @@ _PUBLIC_ void rfc1738_unescape(char *buf)
 	}
 }
 
-/**
- * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
- **/
-_PUBLIC_ DATA_BLOB base64_decode_data_blob(TALLOC_CTX *mem_ctx, const char *s)
-{
-	DATA_BLOB ret = data_blob_talloc(mem_ctx, s, strlen(s)+1);
-	ret.length = ldb_base64_decode((char *)ret.data);
-	return ret;
-}
-
-/**
- * Decode a base64 string in-place - wrapper for the above
- **/
-_PUBLIC_ void base64_decode_inplace(char *s)
-{
-	ldb_base64_decode(s);
-}
-
-/**
- * Encode a base64 string into a talloc()ed string caller to free.
- **/
-_PUBLIC_ char *base64_encode_data_blob(TALLOC_CTX *mem_ctx, DATA_BLOB data)
-{
-	return ldb_base64_encode(mem_ctx, (const char *)data.data, data.length);
-}
-
 #ifdef VALGRIND
 size_t valgrind_strlen(const char *s)
 {
@@ -1274,3 +722,97 @@ _PUBLIC_ BOOL conv_str_u64(const char * str, uint64_t * val)
 	*val = (uint64_t)lval;
 	return True;
 }
+
+/**
+return the number of bytes occupied by a buffer in CH_UTF16 format
+the result includes the null termination
+**/
+_PUBLIC_ size_t utf16_len(const void *buf)
+{
+	size_t len;
+
+	for (len = 0; SVAL(buf,len); len += 2) ;
+
+	return len + 2;
+}
+
+/**
+return the number of bytes occupied by a buffer in CH_UTF16 format
+the result includes the null termination
+limited by 'n' bytes
+**/
+_PUBLIC_ size_t utf16_len_n(const void *src, size_t n)
+{
+	size_t len;
+
+	for (len = 0; (len+2 < n) && SVAL(src, len); len += 2) ;
+
+	if (len+2 <= n) {
+		len += 2;
+	}
+
+	return len;
+}
+
+_PUBLIC_ size_t ucs2_align(const void *base_ptr, const void *p, int flags)
+{
+	if (flags & (STR_NOALIGN|STR_ASCII))
+		return 0;
+	return PTR_DIFF(p, base_ptr) & 1;
+}
+
+/**
+Do a case-insensitive, whitespace-ignoring string compare.
+**/
+_PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
+{
+	/* if BOTH strings are NULL, return TRUE, if ONE is NULL return */
+	/* appropriate value. */
+	if (psz1 == psz2)
+		return (0);
+	else if (psz1 == NULL)
+		return (-1);
+	else if (psz2 == NULL)
+		return (1);
+
+	/* sync the strings on first non-whitespace */
+	while (1) {
+		while (isspace((int)*psz1))
+			psz1++;
+		while (isspace((int)*psz2))
+			psz2++;
+		if (toupper((unsigned char)*psz1) != toupper((unsigned char)*psz2) 
+		    || *psz1 == '\0'
+		    || *psz2 == '\0')
+			break;
+		psz1++;
+		psz2++;
+	}
+	return (*psz1 - *psz2);
+}
+
+/**
+ String replace.
+**/
+_PUBLIC_ void string_replace(char *s, char oldc, char newc)
+{
+	while (*s) {
+		s++;
+		if (*s == oldc) *s = newc;
+	}
+}
+
+/**
+ * Compare 2 strings.
+ *
+ * @note The comparison is case-insensitive.
+ **/
+_PUBLIC_ BOOL strequal(const char *s1, const char *s2)
+{
+	if (s1 == s2)
+		return(True);
+	if (!s1 || !s2)
+		return(False);
+  
+	return strcasecmp(s1,s2) == 0;
+}
-- 
cgit 


From 620d759f49f4b648d0fa4a84e67f1cecbbdd0f06 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 27 Apr 2006 19:50:13 +0000
Subject: r15298: Fix the build using a few hacks in the build system.
 Recursive dependencies are now forbidden (the build system will bail out if
 there are any).

I've split up auth_sam.c into auth_sam.c and sam.c. Andrew,
please rename sam.c / move its contents to whatever/wherever you think suits
best.
(This used to be commit 6646384aaf3e7fa2aa798c3e564b94b0617ec4d0)
---
 source4/lib/util/util_str.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 9de27c0777..60419e0510 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -81,15 +81,15 @@ _PUBLIC_ size_t count_chars(const char *s, char c)
 	size_t count = 0;
 
 	while (*s) {
-		size_t size;
-		codepoint_t c2 = next_codepoint(s, &size);
-		if (c2 == c) count++;
-		s += size;
+		if (*s == c) count++;
+		s ++;
 	}
 
 	return count;
 }
 
+
+
 /**
  Safe string copy into a known length string. maxlength does not
  include the terminating zero.
@@ -433,12 +433,12 @@ _PUBLIC_ void rfc1738_unescape(char *buf)
 {
 	char *p=buf;
 
-	while ((p=strchr_m(p,'+')))
+	while ((p=strchr(p,'+')))
 		*p = ' ';
 
 	p = buf;
 
-	while (p && *p && (p=strchr_m(p,'%'))) {
+	while (p && *p && (p=strchr(p,'%'))) {
 		int c1 = p[1];
 		int c2 = p[2];
 
-- 
cgit 


From eaaae31d1105a7abe31918c59ae9bfab0010bb51 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 27 Apr 2006 22:59:20 +0000
Subject: r15302: Remove strangely named function "StrnCpy" - strlcpy is
 available as a replacement. (This used to be commit
 72237344cf22dacfaf1d87c3e0b922023fa4afb0)

---
 source4/lib/util/util_str.c | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 60419e0510..34d37ecfbd 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -171,27 +171,6 @@ _PUBLIC_ char *safe_strcat(char *dest, const char *src, size_t maxlength)
 	return dest;
 }
 
-/**
- Like strncpy but always null terminates. Make sure there is room!
- The variable n should always be one less than the available size.
-**/
-
-_PUBLIC_ char *StrnCpy(char *dest,const char *src,size_t n)
-{
-	char *d = dest;
-	if (!dest)
-		return(NULL);
-	if (!src) {
-		*dest = 0;
-		return(dest);
-	}
-	while (n-- && (*d++ = *src++))
-		;
-	*d = 0;
-	return(dest);
-}
-
-
 /**
  Routine to get hex characters and turn them into a 16 byte array.
  the array can be variable length, and any non-hex-numeric
-- 
cgit 


From b4246a73537258bedbec63e37cb120a7d7ebafa8 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Sat, 29 Apr 2006 09:11:07 +0000
Subject: r15316: I don't understand quite why this function was ever like
 this, but we need to replace every instance of the character.  Previously we
 skipped the first.

Andrew Bartlett
(This used to be commit 5b58ab98d6b47b7cfd47eb5f7d38dc3724e44ca2)
---
 source4/lib/util/util_str.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 34d37ecfbd..df9fd44cd6 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -775,8 +775,7 @@ _PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
 **/
 _PUBLIC_ void string_replace(char *s, char oldc, char newc)
 {
-	while (*s) {
-		s++;
+	for (;s && *s; s++) {
 		if (*s == oldc) *s = newc;
 	}
 }
-- 
cgit 


From a3b8cfbc8f5b18a342dee79fd9928cbcc2fbb025 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 29 Apr 2006 11:32:54 +0000
Subject: r15318: Don't create empty static libraries as some hosts have
 trouble with them. (This used to be commit
 1505d7c6001f8a35e728a14af2885b813c32ebe7)

---
 source4/lib/util/util_str.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index df9fd44cd6..ec6a1cbbea 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -775,8 +775,9 @@ _PUBLIC_ int strwicmp(const char *psz1, const char *psz2)
 **/
 _PUBLIC_ void string_replace(char *s, char oldc, char newc)
 {
-	for (;s && *s; s++) {
+	while (*s) {
 		if (*s == oldc) *s = newc;
+		s++;
 	}
 }
 
-- 
cgit 


From 172a83d72491f90f6191be1040ef8b2e1789bd2e Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 13 May 2006 19:14:12 +0000
Subject: r15573: Fix build of systems that have iconv headers in non-standard
 locations

Split of system/locale.h header from system/iconv.h

Previously, iconv wasn't being used on these systems
(This used to be commit aa6d66fda69779d1c2948a1aca85dbd5208f1cba)
---
 source4/lib/util/util_str.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index ec6a1cbbea..62869198c3 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -26,7 +26,7 @@
 #include "smb.h"
 #include "pstring.h"
 #include "lib/ldb/include/ldb.h"
-#include "system/iconv.h"
+#include "system/locale.h"
 
 /**
  * @file
-- 
cgit 


From 0329d755a7611ba3897fc1ee9bdce410cc33d7f8 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 30 Aug 2006 11:29:34 +0000
Subject: r17930: Merge noinclude branch:  * Move dlinklist.h, smb.h to
 subsystem-specific directories  * Clean up ads.h and move what is left of it
 to dsdb/    (only place where it's used) (This used to be commit
 f7afa1cb77f3cfa7020b57de12e6003db7cfcc42)

---
 source4/lib/util/util_str.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 62869198c3..163ef3828e 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -23,7 +23,7 @@
 */
 
 #include "includes.h"
-#include "smb.h"
+#include "libcli/raw/smb.h"
 #include "pstring.h"
 #include "lib/ldb/include/ldb.h"
 #include "system/locale.h"
-- 
cgit 


From 3c5618fb1b5cf484c528a7c957a5a9f260d75a4a Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 19 Apr 2007 14:21:56 +0000
Subject: r22373: move in_list() to util_strlist.c to remove the dependency
 from util.o to next_token() and strcasecmp_m()

with this the pidl tests link better on some hosts

metze
(This used to be commit 54bfc1dccc40883d602402865eff3cfae676e9af)
---
 source4/lib/util/util_str.c | 24 ------------------------
 1 file changed, 24 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 163ef3828e..86cd3176c5 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -25,7 +25,6 @@
 #include "includes.h"
 #include "libcli/raw/smb.h"
 #include "pstring.h"
-#include "lib/ldb/include/ldb.h"
 #include "system/locale.h"
 
 /**
@@ -246,29 +245,6 @@ _PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_he
 		slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
 }
 
-/**
- Check if a string is part of a list.
-**/
-_PUBLIC_ BOOL in_list(const char *s, const char *list, BOOL casesensitive)
-{
-	pstring tok;
-	const char *p=list;
-
-	if (!list)
-		return(False);
-
-	while (next_token(&p,tok,LIST_SEP,sizeof(tok))) {
-		if (casesensitive) {
-			if (strcmp(tok,s) == 0)
-				return(True);
-		} else {
-			if (strcasecmp_m(tok,s) == 0)
-				return(True);
-		}
-	}
-	return(False);
-}
-
 /**
  Set a string value, allocing the space for the string
 **/
-- 
cgit 


From c2781df0d5477be58c3189c6d3c17b261d7b8b89 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 1 Jun 2007 12:01:53 +0000
Subject: r23289: Provide support for GCC attributes _PURE_, _NONNULL_,
 _DEPRECATED_, _NORETURN_ and _WARN_UNUSED_RESULT_. (This used to be commit
 44248f662f0b609dad6a7b437948f12d661a28f7)

---
 source4/lib/util/util_str.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 86cd3176c5..c088e26fe5 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -36,16 +36,16 @@
 /**
  Trim the specified elements off the front and back of a string.
 **/
-_PUBLIC_ BOOL trim_string(char *s,const char *front,const char *back)
+_PUBLIC_ bool trim_string(char *s, const char *front, const char *back)
 {
-	BOOL ret = False;
+	bool ret = false;
 	size_t front_len;
 	size_t back_len;
 	size_t len;
 
 	/* Ignore null or empty strings. */
 	if (!s || (s[0] == '\0'))
-		return False;
+		return false;
 
 	front_len	= front? strlen(front) : 0;
 	back_len	= back? strlen(back) : 0;
@@ -58,7 +58,7 @@ _PUBLIC_ BOOL trim_string(char *s,const char *front,const char *back)
 			 * easily overlap. Found by valgrind. JRA. */
 			memmove(s, s+front_len, (len-front_len)+1);
 			len -= front_len;
-			ret=True;
+			ret=true;
 		}
 	}
 	
@@ -66,7 +66,7 @@ _PUBLIC_ BOOL trim_string(char *s,const char *front,const char *back)
 		while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
 			s[len-back_len]='\0';
 			len -= back_len;
-			ret=True;
+			ret=true;
 		}
 	}
 	return ret;
@@ -75,7 +75,7 @@ _PUBLIC_ BOOL trim_string(char *s,const char *front,const char *back)
 /**
  Find the number of 'c' chars in a string
 **/
-_PUBLIC_ size_t count_chars(const char *s, char c)
+_PUBLIC_ _PURE_ size_t count_chars(const char *s, char c)
 {
 	size_t count = 0;
 
@@ -218,7 +218,7 @@ _PUBLIC_ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 /** 
  * Parse a hex string and return a data blob. 
  */
-_PUBLIC_ DATA_BLOB strhex_to_data_blob(const char *strhex) 
+_PUBLIC_ _PURE_ DATA_BLOB strhex_to_data_blob(const char *strhex) 
 {
 	DATA_BLOB ret_blob = data_blob(NULL, strlen(strhex)/2+1);
 
-- 
cgit 


From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:07:03 +0000
Subject: r23792: convert Samba4 to GPLv3

There are still a few tidyups of old FSF addresses to come (in both s3
and s4). More commits soon.
(This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa)
---
 source4/lib/util/util_str.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index c088e26fe5..80a22773d4 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -9,7 +9,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -18,8 +18,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-- 
cgit 


From 702372b343cd764b51f29fc0d6bf512197d2372d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 08:07:42 +0000
Subject: r23807: added hex_encode_talloc() (This used to be commit
 1b105097e3f4a8475d3a2623205ecdea2aef91cf)

---
 source4/lib/util/util_str.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 80a22773d4..baa42e806a 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -244,6 +244,22 @@ _PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_he
 		slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
 }
 
+/**
+ * talloc version of hex_encode()
+ */
+_PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
+{
+	int i;
+	char *hex_buffer;
+
+	hex_buffer = talloc_array(mem_ctx, char, (len*2)+1);
+
+	for (i = 0; i < len; i++)
+		slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
+
+	return hex_buffer;
+}
+
 /**
  Set a string value, allocing the space for the string
 **/
-- 
cgit 


From 4fb038b0b8e7a4bb69ac0d9022684eeaca8a491a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 27 Aug 2007 17:21:16 +0000
Subject: r24710: Use standard boolean type for easier use by external users.
 (This used to be commit 99f4124137d4a61216e8189f26d4da32882c0f4a)

---
 source4/lib/util/util_str.c | 64 ++++++++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index baa42e806a..67e59474fd 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -263,16 +263,16 @@ _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_
 /**
  Set a string value, allocing the space for the string
 **/
-static BOOL string_init(char **dest,const char *src)
+static bool string_init(char **dest,const char *src)
 {
 	if (!src) src = "";
 
 	(*dest) = strdup(src);
 	if ((*dest) == NULL) {
 		DEBUG(0,("Out of memory in string_init\n"));
-		return False;
+		return false;
 	}
-	return True;
+	return true;
 }
 
 /**
@@ -287,7 +287,7 @@ _PUBLIC_ void string_free(char **s)
  Set a string value, deallocating any existing space, and allocing the space
  for the string
 **/
-_PUBLIC_ BOOL string_set(char **dest, const char *src)
+_PUBLIC_ bool string_set(char **dest, const char *src)
 {
 	string_free(dest);
 	return string_init(dest,src);
@@ -485,7 +485,7 @@ _PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
  * num should be a pointer to an integer that holds the current 
  * number of elements in strings. It will be updated by this function.
  */
-_PUBLIC_ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
+_PUBLIC_ bool add_string_to_array(TALLOC_CTX *mem_ctx,
 			 const char *str, const char ***strings, int *num)
 {
 	char *dup_str = talloc_strdup(mem_ctx, str);
@@ -495,12 +495,12 @@ _PUBLIC_ BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
 				    const char *, ((*num)+1));
 
 	if ((*strings == NULL) || (dup_str == NULL))
-		return False;
+		return false;
 
 	(*strings)[*num] = dup_str;
 	*num += 1;
 
-	return True;
+	return true;
 }
 
 
@@ -584,26 +584,26 @@ _PUBLIC_ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
 
 /**
  Set a boolean variable from the text value stored in the passed string.
- Returns True in success, False if the passed string does not correctly 
+ Returns true in success, false if the passed string does not correctly 
  represent a boolean.
 **/
 
-_PUBLIC_ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
+_PUBLIC_ bool set_boolean(const char *boolean_string, bool *boolean)
 {
 	if (strwicmp(boolean_string, "yes") == 0 ||
 	    strwicmp(boolean_string, "true") == 0 ||
 	    strwicmp(boolean_string, "on") == 0 ||
 	    strwicmp(boolean_string, "1") == 0) {
-		*boolean = True;
-		return True;
+		*boolean = true;
+		return true;
 	} else if (strwicmp(boolean_string, "no") == 0 ||
 		   strwicmp(boolean_string, "false") == 0 ||
 		   strwicmp(boolean_string, "off") == 0 ||
 		   strwicmp(boolean_string, "0") == 0) {
-		*boolean = False;
-		return True;
+		*boolean = false;
+		return true;
 	}
-	return False;
+	return false;
 }
 
 /**
@@ -611,15 +611,15 @@ _PUBLIC_ BOOL set_boolean(const char *boolean_string, BOOL *boolean)
  *
  * val will be set to the read value.
  *
- * @retval True if a boolean value was parsed, False otherwise.
+ * @retval true if a boolean value was parsed, false otherwise.
  */
-_PUBLIC_ BOOL conv_str_bool(const char * str, BOOL * val)
+_PUBLIC_ bool conv_str_bool(const char * str, bool * val)
 {
 	char *	end = NULL;
 	long	lval;
 
 	if (str == NULL || *str == '\0') {
-		return False;
+		return false;
 	}
 
 	lval = strtol(str, &end, 10 /* base */);
@@ -627,25 +627,25 @@ _PUBLIC_ BOOL conv_str_bool(const char * str, BOOL * val)
 		return set_boolean(str, val);
 	}
 
-	*val = (lval) ? True : False;
-	return True;
+	*val = (lval) ? true : false;
+	return true;
 }
 
 /**
  * Convert a size specification like 16K into an integral number of bytes. 
  **/
-_PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
+_PUBLIC_ bool conv_str_size(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
 	unsigned long long  lval;
 
 	if (str == NULL || *str == '\0') {
-		return False;
+		return false;
 	}
 
 	lval = strtoull(str, &end, 10 /* base */);
 	if (end == NULL || end == str) {
-		return False;
+		return false;
 	}
 
 	if (*end) {
@@ -660,12 +660,12 @@ _PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
 		} else if (strwicmp(end, "P") == 0) {
 			lval *= (1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL);
 		} else {
-			return False;
+			return false;
 		}
 	}
 
 	*val = (uint64_t)lval;
-	return True;
+	return true;
 }
 
 /**
@@ -673,24 +673,24 @@ _PUBLIC_ BOOL conv_str_size(const char * str, uint64_t * val)
  *
  * val will be set to the value read.
  *
- * @retval True if parsing was successful, False otherwise
+ * @retval true if parsing was successful, false otherwise
  */
-_PUBLIC_ BOOL conv_str_u64(const char * str, uint64_t * val)
+_PUBLIC_ bool conv_str_u64(const char * str, uint64_t * val)
 {
 	char *		    end = NULL;
 	unsigned long long  lval;
 
 	if (str == NULL || *str == '\0') {
-		return False;
+		return false;
 	}
 
 	lval = strtoull(str, &end, 10 /* base */);
 	if (end == NULL || *end != '\0' || end == str) {
-		return False;
+		return false;
 	}
 
 	*val = (uint64_t)lval;
-	return True;
+	return true;
 }
 
 /**
@@ -777,12 +777,12 @@ _PUBLIC_ void string_replace(char *s, char oldc, char newc)
  *
  * @note The comparison is case-insensitive.
  **/
-_PUBLIC_ BOOL strequal(const char *s1, const char *s2)
+_PUBLIC_ bool strequal(const char *s1, const char *s2)
 {
 	if (s1 == s2)
-		return(True);
+		return true;
 	if (!s1 || !s2)
-		return(False);
+		return false;
   
 	return strcasecmp(s1,s2) == 0;
 }
-- 
cgit 


From b50ef4caef44e3b45445728818f3bca09273249d Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 7 Sep 2007 16:54:39 +0000
Subject: r25007: Remove more uses of pstring, move ntlmauth-specific utility
 function to ntlm-auth.c (This used to be commit
 6f224480b230ab7ccfc0417c13e7f4fc3f6f2a13)

---
 source4/lib/util/util_str.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 67e59474fd..eb8155cc7c 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -23,7 +23,6 @@
 
 #include "includes.h"
 #include "libcli/raw/smb.h"
-#include "pstring.h"
 #include "system/locale.h"
 
 /**
@@ -237,7 +236,7 @@ _PUBLIC_ void hex_encode(const unsigned char *buff_in, size_t len, char **out_he
 	int i;
 	char *hex_buffer;
 
-	*out_hex_buffer = smb_xmalloc((len*2)+1);
+	*out_hex_buffer = malloc_array_p(char, (len*2)+1);
 	hex_buffer = *out_hex_buffer;
 
 	for (i = 0; i < len; i++)
@@ -457,7 +456,7 @@ _PUBLIC_ const char *str_format_nbt_domain(TALLOC_CTX *mem_ctx, const char *s)
 	if (!s || !*s) {
 		return talloc_strdup(mem_ctx, "");
 	}
-	ret = talloc_size(mem_ctx, strlen(s)+2);
+	ret = talloc_array(mem_ctx, char, strlen(s)+2);
 	if (!ret) {
 		return ret;
 	}
@@ -566,7 +565,7 @@ _PUBLIC_ char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
 	};
 	char *ret;
 
-	ret = talloc_size(mem_ctx, ARRAY_SIZE(attr_strs)+1);
+	ret = talloc_array(mem_ctx, char, ARRAY_SIZE(attr_strs)+1);
 	if (!ret) {
 		return NULL;
 	}
-- 
cgit 


From e73df517c877add667cc36e889282d129eebe3b9 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 8 Sep 2007 00:38:22 +0000
Subject: r25014: Use talloc for allocating values as well. (This used to be
 commit 43f0e2622ef61bd865fcf17191118c050ec8cfcb)

---
 source4/lib/util/util_str.c | 33 ++++++++++-----------------------
 1 file changed, 10 insertions(+), 23 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index eb8155cc7c..4bec469f87 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -260,36 +260,23 @@ _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_
 }
 
 /**
- Set a string value, allocing the space for the string
+ Set a string value, deallocating any existing space, and allocing the space
+ for the string
 **/
-static bool string_init(char **dest,const char *src)
+_PUBLIC_ bool string_set(TALLOC_CTX *mem_ctx, char **dest, const char *src)
 {
-	if (!src) src = "";
+	talloc_free(*dest);
 
-	(*dest) = strdup(src);
+	if (src == NULL) 
+		src = "";
+
+	*dest = talloc_strdup(mem_ctx, src);
 	if ((*dest) == NULL) {
 		DEBUG(0,("Out of memory in string_init\n"));
 		return false;
 	}
-	return true;
-}
-
-/**
- Free a string value.
-**/
-_PUBLIC_ void string_free(char **s)
-{
-	if (s) SAFE_FREE(*s);
-}
 
-/**
- Set a string value, deallocating any existing space, and allocing the space
- for the string
-**/
-_PUBLIC_ bool string_set(char **dest, const char *src)
-{
-	string_free(dest);
-	return string_init(dest,src);
+	return true;
 }
 
 /**
@@ -304,7 +291,7 @@ _PUBLIC_ bool string_set(char **dest, const char *src)
  use of len==0 which was for no length checks to be done.
 **/
 
-_PUBLIC_ void string_sub(char *s,const char *pattern, const char *insert, size_t len)
+_PUBLIC_ void string_sub(char *s, const char *pattern, const char *insert, size_t len)
 {
 	char *p;
 	ssize_t ls,lp,li, i;
-- 
cgit 


From 7e297ecfa4db2c7ab720a63c7764bc0e20f8058c Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 9 Sep 2007 19:34:30 +0000
Subject: r25047: Fix more warnings. (This used to be commit
 69de86d2d2e49439760fbc61901eb87fb7fc5d55)

---
 source4/lib/util/util_str.c | 20 --------------------
 1 file changed, 20 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 4bec469f87..0f1f2d5a1c 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -259,26 +259,6 @@ _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_
 	return hex_buffer;
 }
 
-/**
- Set a string value, deallocating any existing space, and allocing the space
- for the string
-**/
-_PUBLIC_ bool string_set(TALLOC_CTX *mem_ctx, char **dest, const char *src)
-{
-	talloc_free(*dest);
-
-	if (src == NULL) 
-		src = "";
-
-	*dest = talloc_strdup(mem_ctx, src);
-	if ((*dest) == NULL) {
-		DEBUG(0,("Out of memory in string_init\n"));
-		return false;
-	}
-
-	return true;
-}
-
 /**
  Substitute a string for a pattern in another string. Make sure there is 
  enough room!
-- 
cgit 


From f2d64e1c45994e4b519454c071e90e0cd8240c8a Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 24 Sep 2007 15:55:26 +0000
Subject: r25306: Add tests for string_sub(). (This used to be commit
 2d37ddcbd1243f48d81af17d8ea3cdd6e8e35b8d)

---
 source4/lib/util/util_str.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index 0f1f2d5a1c..e9f81dbd9b 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -274,7 +274,7 @@ _PUBLIC_ char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_
 _PUBLIC_ void string_sub(char *s, const char *pattern, const char *insert, size_t len)
 {
 	char *p;
-	ssize_t ls,lp,li, i;
+	ssize_t ls, lp, li, i;
 
 	if (!insert || !pattern || !*pattern || !s)
 		return;
@@ -286,7 +286,7 @@ _PUBLIC_ void string_sub(char *s, const char *pattern, const char *insert, size_
 	if (len == 0)
 		len = ls + 1; /* len is number of *bytes* */
 
-	while (lp <= ls && (p = strstr(s,pattern))) {
+	while (lp <= ls && (p = strstr(s, pattern))) {
 		if (ls + (li-lp) >= len) {
 			DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n", 
 				 (int)(ls + (li-lp) - len),
-- 
cgit 


From 6b1c7d36f88b0c7cfdf16628d33512d4bacced88 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 24 Sep 2007 16:43:16 +0000
Subject: r25307: add string_sub_talloc. (This used to be commit
 96c1a24874289fdeddcac43d23c2d1214b9b6225)

---
 source4/lib/util/util_str.c | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

(limited to 'source4/lib/util/util_str.c')

diff --git a/source4/lib/util/util_str.c b/source4/lib/util/util_str.c
index e9f81dbd9b..9ea6403c52 100644
--- a/source4/lib/util/util_str.c
+++ b/source4/lib/util/util_str.c
@@ -317,6 +317,42 @@ _PUBLIC_ void string_sub(char *s, const char *pattern, const char *insert, size_
 	}
 }
 
+/**
+ * Talloc'ed version of string_sub
+ */
+_PUBLIC_ char *string_sub_talloc(TALLOC_CTX *mem_ctx, const char *s, 
+				const char *pattern, const char *insert)
+{
+	const char *p;
+	char *ret;
+	size_t len, alloc_len;
+
+	if (insert == NULL || pattern == NULL || !*pattern || s == NULL)
+		return NULL;
+
+	/* determine length needed */
+	len = strlen(s);
+	
+	for (p = strstr(s, pattern); p != NULL; 
+	     p = strstr(p+strlen(pattern), pattern)) {
+		len += strlen(insert) - strlen(pattern);
+	}
+
+	alloc_len = MAX(len, strlen(s))+1;
+	ret = talloc_array(mem_ctx, char, alloc_len);
+	if (ret == NULL)
+		return NULL;
+	strncpy(ret, s, alloc_len);
+	string_sub(ret, pattern, insert, alloc_len);
+
+	ret = talloc_realloc(mem_ctx, ret, char, len+1);
+	if (ret == NULL)
+		return NULL;
+
+	SMB_ASSERT(ret[len] == '\0');
+
+	return ret;
+}
 
 /**
  Similar to string_sub() but allows for any character to be substituted. 
-- 
cgit