Reformatting fix for new coding guidelines. BOOL ->bool.

Jeremy.
(This used to be commit 315215e20e1e470c5077122a2e250ecb3d45ce9b)

1 files changed, 320 insertions, 264 deletions

diff --git a/source3/lib/util_str.c b/source3/lib/util_str.c
index fbd9c1ca6d..2fd22280a4 100644
--- a/source3/lib/util_str.c
+++ b/source3/lib/util_str.c
@@ -1,23 +1,23 @@
-/* 
+/*
    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	 2006
    Copyright (C) Jeremy Allison  1992-2007
-   
+
    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 3 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, see <http://www.gnu.org/licenses/>.
 */
@@ -30,26 +30,26 @@
  **/
 
 /**
- * Internal function to get the next token from a string, return False if none
+ * Internal function to get the next token from a string, return false if none
  * found.  Handles double-quotes.  This is the work horse function called by
  * next_token() and next_token_no_ltrim().
  *
- * Based on a routine by GJC@VILLAGE.COM. 
+ * Based on a routine by GJC@VILLAGE.COM.
  * Extensively modified by Andrew.Tridgell@anu.edu.au
  */
-static BOOL next_token_internal(const char **ptr,
+static bool next_token_internal(const char **ptr,
                                 char *buff,
                                 const char *sep,
                                 size_t bufsize,
-                                BOOL ltrim)
+                                bool ltrim)
 {
 	char *s;
 	char *pbuf;
-	BOOL quoted;
+	bool quoted;
 	size_t len=1;
 
 	if (!ptr)
-		return(False);
+		return(false);
 
 	s = (char *)*ptr;
 
@@ -62,14 +62,15 @@ static BOOL next_token_internal(const char **ptr,
 		while (*s && strchr_m(sep,*s))
 			s++;
 	}
-	
+
 	/* nothing left? */
 	if (! *s)
-		return(False);
-	
+		return(false);
+
 	/* copy over the token */
 	pbuf = buff;
-	for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
+	for (quoted = false; len < bufsize && *s &&
+			(quoted || !strchr_m(sep,*s)); s++) {
 		if ( *s == '\"' ) {
 			quoted = !quoted;
 		} else {
@@ -77,53 +78,53 @@ static BOOL next_token_internal(const char **ptr,
 			*pbuf++ = *s;
 		}
 	}
-	
-	*ptr = (*s) ? s+1 : s;  
+
+	*ptr = (*s) ? s+1 : s;
 	*pbuf = 0;
-	
-	return(True);
+
+	return(true);
 }
 
 /*
- * Get the next token from a string, return False if none found.  Handles
+ * Get the next token from a string, return false if none found.  Handles
  * double-quotes.  This version trims leading separator characters before
  * looking for a token.
  */
-BOOL next_token(const char **ptr, char *buff, const char *sep, size_t bufsize)
+bool next_token(const char **ptr, char *buff, const char *sep, size_t bufsize)
 {
-    return next_token_internal(ptr, buff, sep, bufsize, True);
+    return next_token_internal(ptr, buff, sep, bufsize, true);
 }
 
 /*
- * Get the next token from a string, return False if none found.  Handles
+ * Get the next token from a string, return false if none found.  Handles
  * double-quotes.  This version does not trim leading separator characters
  * before looking for a token.
  */
-BOOL next_token_no_ltrim(const char **ptr,
+bool next_token_no_ltrim(const char **ptr,
                          char *buff,
                          const char *sep,
                          size_t bufsize)
 {
-    return next_token_internal(ptr, buff, sep, bufsize, False);
+    return next_token_internal(ptr, buff, sep, bufsize, false);
 }
 
 /**
-This is like next_token but is not re-entrant and "remembers" the first 
+This is like next_token but is not re-entrant and "remembers" the first
 parameter so you can pass NULL. This is useful for user interface code
 but beware the fact that it is not re-entrant!
 **/
 
 static const char *last_ptr=NULL;
 
-BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
+bool next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
 {
-	BOOL ret;
+	bool ret;
 	if (!ptr)
 		ptr = &last_ptr;
 
 	ret = next_token(ptr, buff, sep, bufsize);
 	last_ptr = *ptr;
-	return ret;	
+	return ret;
 }
 
 void set_first_token(char *ptr)
@@ -159,14 +160,14 @@ char **toktocliplist(int *ctok, const char *sep)
 		while(*s && strchr_m(sep,*s))
 			*s++=0;
 	} while(*s);
-	
+
 	*ctok=ictok;
 	s=(char *)last_ptr;
-	
+
 	if (!(ret=iret=SMB_MALLOC_ARRAY(char *,ictok+1)))
 		return NULL;
-	
-	while(ictok--) {    
+
+	while(ictok--) {
 		*iret++=s;
 		if (ictok > 0) {
 			while(*s++)
@@ -207,7 +208,7 @@ char **toktocliplist(int *ctok, const char *sep)
  * different, we'd need to restart the whole thing.
  *
  * Even better is to implement strcasecmp for each encoding and use a
- * function pointer. 
+ * function pointer.
  **/
 int StrCaseCmp(const char *s, const char *t)
 {
@@ -227,7 +228,8 @@ int StrCaseCmp(const char *s, const char *t)
 		else if (!*pt)
 			return +1; /* t is a prefix */
 		else if ((*ps & 0x80) || (*pt & 0x80))
-			/* not ascii anymore, do it the hard way from here on in */
+			/* not ascii anymore, do it the hard way
+			 * from here on in */
 			break;
 
 		us = toupper_ascii(*ps);
@@ -242,19 +244,21 @@ int StrCaseCmp(const char *s, const char *t)
 
 	size = push_ucs2_allocate(&buffer_s, ps);
 	if (size == (size_t)-1) {
-		return strcmp(ps, pt); 
+		return strcmp(ps, pt);
 		/* Not quite the right answer, but finding the right one
-		   under this failure case is expensive, and it's pretty close */
+		   under this failure case is expensive, and it's pretty
+		   close */
 	}
-	
+
 	size = push_ucs2_allocate(&buffer_t, pt);
 	if (size == (size_t)-1) {
 		SAFE_FREE(buffer_s);
-		return strcmp(ps, pt); 
+		return strcmp(ps, pt);
 		/* Not quite the right answer, but finding the right one
-		   under this failure case is expensive, and it's pretty close */
+		   under this failure case is expensive, and it's pretty
+		   close */
 	}
-	
+
 	ret = strcasecmp_w(buffer_s, buffer_t);
 	SAFE_FREE(buffer_s);
 	SAFE_FREE(buffer_t);
@@ -329,12 +333,12 @@ int StrnCaseCmp(const char *s, const char *t, size_t len)
  *
  * @note The comparison is case-insensitive.
  **/
-BOOL strequal(const char *s1, const char *s2)
+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);
 }
@@ -344,12 +348,12 @@ BOOL strequal(const char *s1, const char *s2)
  *
  * @note The comparison is case-insensitive.
  **/
-BOOL strnequal(const char *s1,const char *s2,size_t n)
+bool strnequal(const char *s1,const char *s2,size_t n)
 {
 	if (s1 == s2)
-		return(True);
+		return(true);
 	if (!s1 || !s2 || !n)
-		return(False);
+		return(false);
 
 	return(StrnCaseCmp(s1,s2,n)==0);
 }
@@ -358,13 +362,13 @@ BOOL strnequal(const char *s1,const char *s2,size_t n)
  Compare 2 strings (case sensitive).
 **/
 
-BOOL strcsequal(const char *s1,const char *s2)
+bool strcsequal(const char *s1,const char *s2)
 {
 	if (s1 == s2)
-		return(True);
+		return(true);
 	if (!s1 || !s2)
-		return(False);
-  
+		return(false);
+
 	return(strcmp(s1,s2)==0);
 }
 
@@ -389,8 +393,8 @@ int strwicmp(const char *psz1, const char *psz2)
 			psz1++;
 		while (isspace((int)*psz2))
 			psz2++;
-		if (toupper_ascii(*psz1) != toupper_ascii(*psz2) || *psz1 == '\0'
-		    || *psz2 == '\0')
+		if (toupper_ascii(*psz1) != toupper_ascii(*psz2) ||
+				*psz1 == '\0' || *psz2 == '\0')
 			break;
 		psz1++;
 		psz2++;
@@ -434,7 +438,7 @@ void strnorm(char *s, int case_default)
  Check if a string is in "normal" case.
 **/
 
-BOOL strisnormal(const char *s, int case_default)
+bool strisnormal(const char *s, int case_default)
 {
 	if (case_default == CASE_UPPER)
 		return(!strhaslower(s));
@@ -558,15 +562,15 @@ size_t str_ascii_charnum(const char *s)
 	return ret;
 }
 
-BOOL trim_char(char *s,char cfront,char cback)
+bool trim_char(char *s,char cfront,char cback)
 {
-	BOOL ret = False;
+	bool ret = false;
 	char *ep;
 	char *fp = s;
 
 	/* Ignore null or empty strings. */
 	if (!s || (s[0] == '\0'))
-		return False;
+		return false;
 
 	if (cfront) {
 		while (*fp && *fp == cfront)
@@ -574,17 +578,17 @@ BOOL trim_char(char *s,char cfront,char cback)
 		if (!*fp) {
 			/* We ate the string. */
 			s[0] = '\0';
-			return True;
+			return true;
 		}
 		if (fp != s)
-			ret = True;
+			ret = true;
 	}
 
 	ep = fp + strlen(fp) - 1;
 	if (cback) {
 		/* Attempt ascii only. Bail for mb strings. */
 		while ((ep >= fp) && (*ep == cback)) {
-			ret = True;
+			ret = true;
 			if ((ep > fp) && (((unsigned char)ep[-1]) & 0x80)) {
 				/* Could be mb... bail back to tim_string. */
 				char fs[2], bs[2];
@@ -602,7 +606,7 @@ BOOL trim_char(char *s,char cfront,char cback)
 		if (ep < fp) {
 			/* We ate the string. */
 			s[0] = '\0';
-			return True;
+			return true;
 		}
 	}
 
@@ -615,16 +619,16 @@ BOOL trim_char(char *s,char cfront,char cback)
  Trim the specified elements off the front and back of a string.
 **/
 
-BOOL trim_string(char *s,const char *front,const char *back)
+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;
@@ -637,15 +641,16 @@ 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;
 		}
 	}
-	
+
 	if (back_len) {
-		while ((len >= back_len) && strncmp(s+len-back_len,back,back_len)==0) {
+		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;
@@ -655,13 +660,13 @@ BOOL trim_string(char *s,const char *front,const char *back)
  Does a string have any uppercase chars in it?
 **/
 
-BOOL strhasupper(const char *s)
+bool strhasupper(const char *s)
 {
 	smb_ucs2_t *tmp, *p;
-	BOOL ret;
+	bool ret;
 
 	if (push_ucs2_allocate(&tmp, s) == -1) {
-		return False;
+		return false;
 	}
 
 	for(p = tmp; *p != 0; p++) {
@@ -679,13 +684,13 @@ BOOL strhasupper(const char *s)
  Does a string have any lowercase chars in it?
 **/
 
-BOOL strhaslower(const char *s)
+bool strhaslower(const char *s)
 {
 	smb_ucs2_t *tmp, *p;
-	BOOL ret;
+	bool ret;
 
 	if (push_ucs2_allocate(&tmp, s) == -1) {
-		return False;
+		return false;
 	}
 
 	for(p = tmp; *p != 0; p++) {
@@ -726,12 +731,17 @@ size_t count_chars(const char *s,char c)
  include the terminating zero.
 **/
 
-char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
+char *safe_strcpy_fn(const char *fn,
+		int line,
+		char *dest,
+		const char *src,
+		size_t maxlength)
 {
 	size_t len;
 
 	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in safe_strcpy, called from [%s][%d]\n", fn, line));
+		DEBUG(0,("ERROR: NULL dest in safe_strcpy, "
+			"called from [%s][%d]\n", fn, line));
 		return NULL;
 	}
 
@@ -742,38 +752,44 @@ char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_
 	if (!src) {
 		*dest = 0;
 		return dest;
-	}  
+	}
 
 	len = strnlen(src, maxlength+1);
 
 	if (len > maxlength) {
-		DEBUG(0,("ERROR: string overflow by %lu (%lu - %lu) in safe_strcpy [%.50s]\n",
-			 (unsigned long)(len-maxlength), (unsigned long)len, 
+		DEBUG(0,("ERROR: string overflow by "
+			"%lu (%lu - %lu) in safe_strcpy [%.50s]\n",
+			 (unsigned long)(len-maxlength), (unsigned long)len,
 			 (unsigned long)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_fn(const char *fn, int line, char *dest, const char *src, size_t maxlength)
+char *safe_strcat_fn(const char *fn,
+		int line,
+		char *dest,
+		const char *src,
+		size_t maxlength)
 {
 	size_t src_len, dest_len;
 
 	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in safe_strcat, called from [%s][%d]\n", fn, line));
+		DEBUG(0,("ERROR: NULL dest in safe_strcat, "
+			"called from [%s][%d]\n", fn, line));
 		return NULL;
 	}
 
 	if (!src)
 		return dest;
-	
+
 	src_len = strnlen(src, maxlength + 1);
 	dest_len = strnlen(dest, maxlength + 1);
 
@@ -782,7 +798,8 @@ char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size
 #endif
 
 	if (src_len + dest_len > maxlength) {
-		DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
+		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);
@@ -802,7 +819,13 @@ char *safe_strcat_fn(const char *fn, int line, char *dest, const char *src, size
  and replaces with '_'. Deliberately does *NOT* check for multibyte
  characters. Don't change it !
 **/
-char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
+
+char *alpha_strcpy_fn(const char *fn,
+		int line,
+		char *dest,
+		const char *src,
+		const char *other_safe_chars,
+		size_t maxlength)
 {
 	size_t len, i;
 
@@ -811,14 +834,15 @@ char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, con
 #endif
 
 	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in alpha_strcpy, called from [%s][%d]\n", fn, line));
+		DEBUG(0,("ERROR: NULL dest in alpha_strcpy, "
+			"called from [%s][%d]\n", fn, line));
 		return NULL;
 	}
 
 	if (!src) {
 		*dest = 0;
 		return dest;
-	}  
+	}
 
 	len = strlen(src);
 	if (len >= maxlength)
@@ -829,7 +853,8 @@ char *alpha_strcpy_fn(const char *fn, int line, char *dest, const char *src, con
 
 	for(i = 0; i < len; i++) {
 		int val = (src[i] & 0xff);
-		if (isupper_ascii(val) || islower_ascii(val) || isdigit(val) || strchr_m(other_safe_chars, val))
+		if (isupper_ascii(val) || islower_ascii(val) ||
+				isdigit(val) || strchr_m(other_safe_chars, val))
 			dest[i] = src[i];
 		else
 			dest[i] = '_';
@@ -853,7 +878,8 @@ char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
 #endif
 
 	if (!dest) {
-		DEBUG(0,("ERROR: NULL dest in StrnCpy, called from [%s][%d]\n", fn, line));
+		DEBUG(0,("ERROR: NULL dest in StrnCpy, "
+			"called from [%s][%d]\n", fn, line));
 		return(NULL);
 	}
 
@@ -861,7 +887,7 @@ char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
 		*dest = 0;
 		return(dest);
 	}
-	
+
 	while (n-- && (*d = *src)) {
 		d++;
 		src++;
@@ -944,7 +970,7 @@ size_t strhex_to_str(char *p, size_t len, const char *strhex)
 	return num_chars;
 }
 
-DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex) 
+DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
 {
 	DATA_BLOB ret_blob;
 
@@ -953,8 +979,8 @@ DATA_BLOB strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *strhex)
 	else
 		ret_blob = data_blob(NULL, strlen(strhex)/2+1);
 
-	ret_blob.length = strhex_to_str((char*)ret_blob.data, 	
-					strlen(strhex), 
+	ret_blob.length = strhex_to_str((char*)ret_blob.data,
+					strlen(strhex),
 					strhex);
 
 	return ret_blob;
@@ -981,33 +1007,33 @@ char *hex_encode(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
  Check if a string is part of a list.
 **/
 
-BOOL in_list(const char *s, const char *list, BOOL casesensitive)
+bool in_list(const char *s, const char *list, bool casesensitive)
 {
 	char *tok;
 	const char *p=list;
 	size_t bufsize = strlen(list);
-	BOOL ret = False;
+	bool ret = false;
 
 	if (!list)
-		return(False);
+		return(false);
 
 	/* We know a token can't be larger
 	 * than the entire list. */
 
 	tok = SMB_MALLOC_ARRAY(char, bufsize+1);
 	if (!tok) {
-		return False;
+		return false;
 	}
 
 	while (next_token(&p,tok,LIST_SEP,bufsize+1)) {
 		if (casesensitive) {
 			if (strcmp(tok,s) == 0) {
-				ret = True;
+				ret = true;
 				break;
 			}
 		} else {
 			if (StrCaseCmp(tok,s) == 0) {
-				ret = True;
+				ret = true;
 				break;
 			}
 		}
@@ -1024,11 +1050,11 @@ static const char *null_string = "";
  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)
 {
 	size_t l;
 
-	if (!src)     
+	if (!src)
 		src = "";
 
 	l = strlen(src);
@@ -1039,10 +1065,10 @@ static BOOL string_init(char **dest,const char *src)
 		(*dest) = SMB_STRDUP(src);
 		if ((*dest) == NULL) {
 			DEBUG(0,("Out of memory in string_init\n"));
-			return False;
+			return false;
 		}
 	}
-	return(True);
+	return(true);
 }
 
 /**
@@ -1063,17 +1089,17 @@ void string_free(char **s)
  for the string
 **/
 
-BOOL string_set(char **dest,const char *src)
+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 
+ 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 
+ This routine looks for pattern in s and replaces it with
  insert. It may do multiple replacements or just one.
 
  Any of " ; ' $ or ` in the insert string are replaced with _
@@ -1081,8 +1107,9 @@ BOOL string_set(char **dest,const char *src)
  use of len==0 which was for no length checks to be done.
 **/
 
-void string_sub2(char *s,const char *pattern, const char *insert, size_t len, 
-		 BOOL remove_unsafe_characters, BOOL replace_once, BOOL allow_trailing_dollar)
+void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
+		 bool remove_unsafe_characters, bool replace_once,
+		 bool allow_trailing_dollar)
 {
 	char *p;
 	ssize_t ls,lp,li, i;
@@ -1099,7 +1126,8 @@ void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
 
 	while (lp <= ls && (p = strstr_m(s,pattern))) {
 		if (ls + (li-lp) >= len) {
-			DEBUG(0,("ERROR: string overflow by %d in string_sub(%.50s, %d)\n", 
+			DEBUG(0,("ERROR: string overflow by "
+				"%d in string_sub(%.50s, %d)\n",
 				 (int)(ls + (li-lp) - len),
 				 pattern, (int)len));
 			break;
@@ -1114,7 +1142,8 @@ void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
 			case '\'':
 			case ';':
 			case '$':
-				/* allow a trailing $ (as in machine accounts) */
+				/* allow a trailing $
+				 * (as in machine accounts) */
 				if (allow_trailing_dollar && (i == li - 1 )) {
 					p[i] = insert[i];
 					break;
@@ -1124,8 +1153,9 @@ void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
 			case '\n':
 				if ( remove_unsafe_characters ) {
 					p[i] = '_';
-					/* yes this break should be here since we want to 
-					   fall throw if not replacing unsafe chars */
+					/* yes this break should be here
+					 * since we want to fall throw if
+					 * not replacing unsafe chars */
 					break;
 				}
 			default:
@@ -1140,14 +1170,15 @@ void string_sub2(char *s,const char *pattern, const char *insert, size_t len,
 	}
 }
 
-void string_sub_once(char *s, const char *pattern, const char *insert, size_t len)
+void string_sub_once(char *s, const char *pattern,
+		const char *insert, size_t len)
 {
-	string_sub2( s, pattern, insert, len, True, True, False );
+	string_sub2( s, pattern, insert, len, true, true, false );
 }
 
 void string_sub(char *s,const char *pattern, const char *insert, size_t len)
 {
-	string_sub2( s, pattern, insert, len, True, False, False );
+	string_sub2( s, pattern, insert, len, true, false, false );
 }
 
 void fstring_sub(char *s,const char *pattern,const char *insert)
@@ -1204,13 +1235,14 @@ char *realloc_string_sub(char *string, const char *pattern,
 				break;
 		}
 	}
-	
+
 	while ((p = strstr_m(s,pattern))) {
 		if (ld > 0) {
 			int offset = PTR_DIFF(s,string);
 			string = (char *)SMB_REALLOC(string, ls + ld + 1);
 			if (!string) {
-				DEBUG(0, ("realloc_string_sub: out of memory!\n"));
+				DEBUG(0, ("realloc_string_sub: "
+					"out of memory!\n"));
 				SAFE_FREE(in);
 				return NULL;
 			}
@@ -1273,7 +1305,7 @@ char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
 				break;
 		}
 	}
-	
+
 	while ((p = strstr_m(s,pattern))) {
 		if (ld > 0) {
 			int offset = PTR_DIFF(s,string);
@@ -1299,7 +1331,7 @@ char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
 }
 
 /**
- Similar to string_sub() but allows for any character to be substituted. 
+ 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.
@@ -1319,13 +1351,14 @@ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
 
 	if (!*pattern)
 		return;
-	
+
 	if (len == 0)
 		len = ls + 1; /* len is number of *bytes* */
-	
+
 	while (lp <= ls && (p = strstr_m(s,pattern))) {
 		if (ls + (li-lp) >= len) {
-			DEBUG(0,("ERROR: string overflow by %d in all_string_sub(%.50s, %d)\n", 
+			DEBUG(0,("ERROR: string overflow by "
+				"%d in all_string_sub(%.50s, %d)\n",
 				 (int)(ls + (li-lp) - len),
 				 pattern, (int)len));
 			break;
@@ -1346,7 +1379,8 @@ void all_string_sub(char *s,const char *pattern,const char *insert, size_t len)
  Use with caution!
 **/
 
-static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
+static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s,
+				const smb_ucs2_t *pattern,
 				const smb_ucs2_t *insert)
 {
 	smb_ucs2_t *r, *rp;
@@ -1409,7 +1443,8 @@ smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
  Splits out the front and back at a separator.
 **/
 
-static void split_at_last_component(char *path, char *front, char sep, char *back)
+static void split_at_last_component(char *path, char *front, char sep,
+		char *back)
 {
 	char *p = strrchr_m(path, sep);
 
@@ -1456,7 +1491,7 @@ char *string_truncate(char *s, unsigned int length)
 }
 
 /**
- Strchr and strrchr_m are very hard to do on general multi-byte strings. 
+ Strchr and strrchr_m are very hard to do on general multi-byte strings.
  We convert via ucs2 for now.
 **/
 
@@ -1533,7 +1568,7 @@ char *strrchr_m(const char *s, char c)
 	{
 		size_t len = strlen(s);
 		const char *cp = s;
-		BOOL got_mb = False;
+		bool got_mb = false;
 
 		if (len == 0)
 			return NULL;
@@ -1541,9 +1576,10 @@ char *strrchr_m(const char *s, char c)
 		do {
 			if (c == *cp) {
 				/* Could be a match. Part of a multibyte ? */
-			       	if ((cp > s) && (((unsigned char)cp[-1]) & 0x80)) {
+			       	if ((cp > s) &&
+					(((unsigned char)cp[-1]) & 0x80)) {
 					/* Yep - go slow :-( */
-					got_mb = True;
+					got_mb = true;
 					break;
 				}
 				/* No - we have a match ! */
@@ -1645,7 +1681,7 @@ char *strstr_m(const char *src, const char *findstr)
 
 	for (s = src; *s && !(((unsigned char)s[0]) & 0x80); s++) {
 		if (*s == *findstr) {
-			if (!findstr_len) 
+			if (!findstr_len)
 				findstr_len = strlen(findstr);
 
 			if (strncmp(s, findstr, findstr_len) == 0) {
@@ -1668,7 +1704,7 @@ char *strstr_m(const char *src, const char *findstr)
 		DEBUG(0,("strstr_m: src malloc fail\n"));
 		return NULL;
 	}
-	
+
 	if (push_ucs2_allocate(&find_w, findstr) == (size_t)-1) {
 		SAFE_FREE(src_w);
 		DEBUG(0,("strstr_m: find malloc fail\n"));
@@ -1682,7 +1718,7 @@ char *strstr_m(const char *src, const char *findstr)
 		SAFE_FREE(find_w);
 		return NULL;
 	}
-	
+
 	*p = 0;
 	if (pull_ucs2_allocate(&s2, src_w) == (size_t)-1) {
 		SAFE_FREE(src_w);
@@ -1724,7 +1760,7 @@ void strlower_m(char *s)
 	len = strlen(s) + 1;
 	errno_save = errno;
 	errno = 0;
-	unix_strlower(s,len,s,len);	
+	unix_strlower(s,len,s,len);
 	/* Catch mb conversion errors that may not terminate. */
 	if (errno)
 		s[len-1] = '\0';
@@ -1758,7 +1794,7 @@ void strupper_m(char *s)
 	len = strlen(s) + 1;
 	errno_save = errno;
 	errno = 0;
-	unix_strupper(s,len,s,len);	
+	unix_strupper(s,len,s,len);
 	/* Catch mb conversion errors that may not terminate. */
 	if (errno)
 		s[len-1] = '\0';
@@ -1912,7 +1948,9 @@ int fstr_sprintf(fstring s, const char *fmt, ...)
 
 #define S_LIST_ABS 16 /* List Allocation Block Size */
 
-static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
+static char **str_list_make_internal(TALLOC_CTX *mem_ctx,
+		const char *string,
+		const char *sep)
 {
 	char **list, **rlist;
 	const char *str;
@@ -1941,14 +1979,18 @@ static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, co
 		if (num == lsize) {
 			lsize += S_LIST_ABS;
 			if (mem_ctx) {
-				rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list, char *, lsize +1);
+				rlist = TALLOC_REALLOC_ARRAY(mem_ctx, list,
+						char *, lsize +1);
 			} else {
-				/* We need to keep the old list on error so we can free the elements
+				/* We need to keep the old list on
+				 * error so we can free the elements
 				   if the realloc fails. */
-				rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
+				rlist =SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
+						char *, lsize +1);
 			}
 			if (!rlist) {
-				DEBUG(0,("str_list_make: Unable to allocate memory"));
+				DEBUG(0,("str_list_make: "
+					"Unable to allocate memory"));
 				str_list_free(&list);
 				if (mem_ctx) {
 					TALLOC_FREE(s);
@@ -1959,7 +2001,8 @@ static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, co
 			} else {
 				list = rlist;
 			}
-			memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
+			memset (&list[num], 0,
+					((sizeof(char**)) * (S_LIST_ABS +1)));
 		}
 
 		if (mem_ctx) {
@@ -1978,8 +2021,8 @@ static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, co
 			}
 			return NULL;
 		}
-	
-		num++;	
+
+		num++;
 	}
 
 	if (mem_ctx) {
@@ -1991,7 +2034,9 @@ static char **str_list_make_internal(TALLOC_CTX *mem_ctx, const char *string, co
 	return list;
 }
 
-char **str_list_make_talloc(TALLOC_CTX *mem_ctx, const char *string, const char *sep)
+char **str_list_make_talloc(TALLOC_CTX *mem_ctx,
+		const char *string,
+		const char *sep)
 {
 	return str_list_make_internal(mem_ctx, string, sep);
 }
@@ -2001,72 +2046,75 @@ char **str_list_make(const char *string, const char *sep)
 	return str_list_make_internal(NULL, string, sep);
 }
 
-BOOL str_list_copy(char ***dest, const char **src)
+bool str_list_copy(char ***dest, const char **src)
 {
 	char **list, **rlist;
 	int num, lsize;
-	
+
 	*dest = NULL;
 	if (!src)
-		return False;
-	
+		return false;
+
 	num = lsize = 0;
 	list = NULL;
-		
+
 	while (src[num]) {
 		if (num == lsize) {
 			lsize += S_LIST_ABS;
-			rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list, char *, lsize +1);
+			rlist = SMB_REALLOC_ARRAY_KEEP_OLD_ON_ERROR(list,
+					char *, lsize +1);
 			if (!rlist) {
-				DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
+				DEBUG(0,("str_list_copy: "
+					"Unable to re-allocate memory"));
 				str_list_free(&list);
-				return False;
+				return false;
 			} else {
 				list = rlist;
 			}
-			memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
+			memset (&list[num], 0,
+					((sizeof(char **)) * (S_LIST_ABS +1)));
 		}
-		
+
 		list[num] = SMB_STRDUP(src[num]);
 		if (!list[num]) {
 			DEBUG(0,("str_list_copy: Unable to allocate memory"));
 			str_list_free(&list);
-			return False;
+			return false;
 		}
 
 		num++;
 	}
-	
+
 	*dest = list;
-	return True;	
+	return true;
 }
 
 /**
  * Return true if all the elements of the list match exactly.
  **/
-BOOL str_list_compare(char **list1, char **list2)
+bool str_list_compare(char **list1, char **list2)
 {
 	int num;
-	
+
 	if (!list1 || !list2)
-		return (list1 == list2); 
-	
+		return (list1 == list2);
+
 	for (num = 0; list1[num]; num++) {
 		if (!list2[num])
-			return False;
+			return false;
 		if (!strcsequal(list1[num], list2[num]))
-			return False;
+			return false;
 	}
 	if (list2[num])
-		return False; /* if list2 has more elements than list1 fail */
-	
-	return True;
+		return false; /* if list2 has more elements than list1 fail */
+
+	return true;
 }
 
 static void str_list_free_internal(TALLOC_CTX *mem_ctx, char ***list)
 {
 	char **tlist;
-	
+
 	if (!list || !*list)
 		return;
 	tlist = *list;
@@ -2105,59 +2153,60 @@ int str_list_count( const char **list )
 		return 0;
 
 	/* count the number of list members */
-	
+
 	for ( i=0; *list; i++, list++ );
-	
+
 	return i;
 }
 
 /******************************************************************************
- version of standard_sub_basic() for string lists; uses alloc_sub_basic() 
+ version of standard_sub_basic() for string lists; uses alloc_sub_basic()
  for the work
  *****************************************************************************/
- 
-BOOL str_list_sub_basic( char **list, const char *smb_name,
+
+bool str_list_sub_basic( char **list, const char *smb_name,
 			 const char *domain_name )
 {
 	char *s, *tmpstr;
-	
+
 	while ( *list ) {
 		s = *list;
 		tmpstr = alloc_sub_basic(smb_name, domain_name, s);
 		if ( !tmpstr ) {
-			DEBUG(0,("str_list_sub_basic: alloc_sub_basic() return NULL!\n"));
-			return False;
+			DEBUG(0,("str_list_sub_basic: "
+				"alloc_sub_basic() return NULL!\n"));
+			return false;
 		}
 
 		SAFE_FREE(*list);
 		*list = tmpstr;
-			
+
 		list++;
 	}
 
-	return True;
+	return true;
 }
 
 /******************************************************************************
  substritute a specific pattern in a string list
  *****************************************************************************/
- 
-BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
+
+bool str_list_substitute(char **list, const char *pattern, const char *insert)
 {
 	char *p, *s, *t;
 	ssize_t ls, lp, li, ld, i, d;
 
 	if (!list)
-		return False;
+		return false;
 	if (!pattern)
-		return False;
+		return false;
 	if (!insert)
-		return False;
+		return false;
 
 	lp = (ssize_t)strlen(pattern);
 	li = (ssize_t)strlen(insert);
 	ld = li -lp;
-			
+
 	while (*list) {
 		s = *list;
 		ls = (ssize_t)strlen(s);
@@ -2168,8 +2217,9 @@ BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
 			if (ld) {
 				t = (char *) SMB_MALLOC(ls +ld +1);
 				if (!t) {
-					DEBUG(0,("str_list_substitute: Unable to allocate memory"));
-					return False;
+					DEBUG(0,("str_list_substitute: "
+						"Unable to allocate memory"));
+					return false;
 				}
 				memcpy(t, *list, d);
 				memcpy(t +d +li, p +lp, ls -d -lp +1);
@@ -2178,7 +2228,7 @@ BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
 				ls += ld;
 				s = t +d +li;
 			}
-			
+
 			for (i = 0; i < li; i++) {
 				switch (insert[i]) {
 					case '`':
@@ -2194,14 +2244,13 @@ BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
 					default:
 						t[d +i] = insert[i];
 				}
-			}	
+			}
 		}
-		
-		
+
 		list++;
 	}
-	
-	return True;
+
+	return true;
 }
 
 
@@ -2221,10 +2270,10 @@ BOOL str_list_substitute(char **list, const char *pattern, const char *insert)
  *         reallocated to new length
  **/
 
-char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
+char *ipstr_list_add(char **ipstr_list, const struct ip_service *service)
 {
-	char* new_ipstr = NULL;
-	
+	char *new_ipstr = NULL;
+
 	/* arguments checking */
 	if (!ipstr_list || !service) return NULL;
 
@@ -2234,7 +2283,8 @@ char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
 			inet_ntoa(service->ip), service->port);
 		SAFE_FREE(*ipstr_list);
 	} else {
-		asprintf(&new_ipstr, "%s:%d", inet_ntoa(service->ip), service->port);
+		asprintf(&new_ipstr, "%s:%d",
+				inet_ntoa(service->ip), service->port);
 	}
 	*ipstr_list = new_ipstr;
 	return *ipstr_list;
@@ -2250,58 +2300,58 @@ char* ipstr_list_add(char** ipstr_list, const struct ip_service *service)
  * @param ip_count number of addresses stored in ip_list
  * @return pointer to allocated ip string
  **/
- 
-char* ipstr_list_make(char** ipstr_list, const struct ip_service* ip_list, int ip_count)
+
+char *ipstr_list_make(char **ipstr_list,
+		const struct ip_service * ip_list, int ip_count)
 {
 	int i;
-	
+
 	/* arguments checking */
 	if (!ip_list || !ipstr_list) return 0;
 
 	*ipstr_list = NULL;
-	
+
 	/* process ip addresses given as arguments */
 	for (i = 0; i < ip_count; i++)
 		*ipstr_list = ipstr_list_add(ipstr_list, &ip_list[i]);
-	
+
 	return (*ipstr_list);
 }
 
 
 /**
  * Parse given ip string list into array of ip addresses
- * (as ip_service structures)  
+ * (as ip_service structures)
  *    e.g. 192.168.1.100:389,192.168.1.78, ...
  *
- * @param ipstr ip string list to be parsed 
+ * @param ipstr ip string list to be parsed
  * @param ip_list pointer to array of ip addresses which is
  *        allocated by this function and must be freed by caller
  * @return number of succesfully parsed addresses
  **/
- 
+
 int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
 {
 	fstring token_str;
 	size_t count;
 	int i;
 
-	if (!ipstr_list || !ip_list) 
+	if (!ipstr_list || !ip_list)
 		return 0;
-	
+
 	count = count_chars(ipstr_list, IPSTR_LIST_CHAR) + 1;
 	if ( (*ip_list = SMB_MALLOC_ARRAY(struct ip_service, count)) == NULL ) {
-		DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n", (unsigned long)count));
+		DEBUG(0,("ipstr_list_parse: malloc failed for %lu entries\n",
+					(unsigned long)count));
 		return 0;
 	}
-	
-	for ( i=0; 
-		next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN) && i<count; 
-		i++ ) 
-	{
+
+	for ( i=0; next_token(&ipstr_list, token_str,
+				IPSTR_LIST_SEP, FSTRING_LEN) && i<count; i++ ) {
 		struct in_addr addr;
-		unsigned port = 0;	
+		unsigned port = 0;
 		char *p = strchr(token_str, ':');
-		
+
 		if (p) {
 			*p = 0;
 			port = atoi(p+1);
@@ -2310,11 +2360,11 @@ int ipstr_list_parse(const char* ipstr_list, struct ip_service **ip_list)
 		/* convert single token to ip address */
 		if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
 			break;
-				
+
 		(*ip_list)[i].ip = addr;
 		(*ip_list)[i].port = port;
 	}
-	
+
 	return count;
 }
 
@@ -2358,7 +2408,7 @@ void rfc1738_unescape(char *buf)
 		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);
@@ -2428,9 +2478,11 @@ void base64_decode_inplace(char *s)
 /**
  * Encode a base64 string into a malloc()ed string caller to free.
  *
- *From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c with adjustments
+ * From SQUID: adopted from http://ftp.sunet.se/pub2/gnu/vm/base64-encode.c
+ * with adjustments
  **/
-char * base64_encode_data_blob(DATA_BLOB data)
+
+char *base64_encode_data_blob(DATA_BLOB data)
 {
 	int bits = 0;
 	int char_count = 0;
@@ -2453,27 +2505,27 @@ char * base64_encode_data_blob(DATA_BLOB data)
 			result[out_cnt++] = b64[bits >> 18];
 			result[out_cnt++] = b64[(bits >> 12) & 0x3f];
 			result[out_cnt++] = b64[(bits >> 6) & 0x3f];
-	    result[out_cnt++] = b64[bits & 0x3f];
-	    bits = 0;
-	    char_count = 0;
-	} else {
-	    bits <<= 8;
-	}
-    }
-    if (char_count != 0) {
-	bits <<= 16 - (8 * char_count);
-	result[out_cnt++] = b64[bits >> 18];
-	result[out_cnt++] = b64[(bits >> 12) & 0x3f];
-	if (char_count == 1) {
-	    result[out_cnt++] = '=';
-	    result[out_cnt++] = '=';
-	} else {
-	    result[out_cnt++] = b64[(bits >> 6) & 0x3f];
-	    result[out_cnt++] = '=';
+			result[out_cnt++] = b64[bits & 0x3f];
+			bits = 0;
+			char_count = 0;
+		} else {
+			bits <<= 8;
+		}
 	}
-    }
-    result[out_cnt] = '\0';	/* terminate */
-    return result;
+	if (char_count != 0) {
+		bits <<= 16 - (8 * char_count);
+		result[out_cnt++] = b64[bits >> 18];
+		result[out_cnt++] = b64[(bits >> 12) & 0x3f];
+		if (char_count == 1) {
+			result[out_cnt++] = '=';
+			result[out_cnt++] = '=';
+		} else {
+			result[out_cnt++] = b64[(bits >> 6) & 0x3f];
+			result[out_cnt++] = '=';
+		}
+	}
+	result[out_cnt] = '\0';	/* terminate */
+	return result;
 }
 
 /* read a SMB_BIG_UINT from a string */
@@ -2482,7 +2534,7 @@ SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
 
 	SMB_BIG_UINT val = -1;
 	const char *p = nptr;
-	
+
 	if (!p) {
 		if (entptr) {
 			*entptr = p;
@@ -2494,7 +2546,7 @@ SMB_BIG_UINT STR_TO_SMB_BIG_UINT(const char *nptr, const char **entptr)
 		p++;
 
 #ifdef LARGE_SMB_OFF_T
-	sscanf(p,"%llu",&val);	
+	sscanf(p,"%llu",&val);
 #else /* LARGE_SMB_OFF_T */
 	sscanf(p,"%lu",&val);
 #endif /* LARGE_SMB_OFF_T */
@@ -2593,22 +2645,23 @@ void string_append(char **left, const char *right)
 	safe_strcat(*left, right, new_len-1);
 }
 
-BOOL add_string_to_array(TALLOC_CTX *mem_ctx,
+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_ARRAY(mem_ctx, *strings, const char *, (*num)+1);
+	*strings = TALLOC_REALLOC_ARRAY(mem_ctx, *strings,
+			const char *, (*num)+1);
 
 	if ((*strings == NULL) || (dup_str == NULL)) {
 		*num = 0;
-		return False;
+		return false;
 	}
 
 	(*strings)[*num] = dup_str;
 	*num += 1;
-	return True;
+	return true;
 }
 
 /* Append an sprintf'ed string. Double buffer size on demand. Usable without
@@ -2621,7 +2674,7 @@ void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
 	va_list ap;
 	char *newstr;
 	int ret;
-	BOOL increased;
+	bool increased;
 
 	/* len<0 is an internal marker that something failed */
 	if (*len < 0)
@@ -2643,10 +2696,10 @@ void sprintf_append(TALLOC_CTX *mem_ctx, char **string, ssize_t *len,
 	if (ret < 0)
 		goto error;
 
-	increased = False;
+	increased = false;
 
 	while ((*len)+ret >= *bufsize) {
-		increased = True;
+		increased = true;
 		*bufsize *= 2;
 		if (*bufsize >= (1024*1024*256))
 			goto error;
@@ -2702,18 +2755,20 @@ char *sstring_sub(const char *src, char front, char back)
  characters.
 ********************************************************************/
 
-BOOL validate_net_name( const char *name, const char *invalid_chars, int max_len )
+bool validate_net_name( const char *name,
+		const char *invalid_chars,
+		int max_len)
 {
 	int i;
 
 	for ( i=0; i<max_len && name[i]; i++ ) {
 		/* fail if strchr_m() finds one of the invalid characters */
 		if ( name[i] && strchr_m( invalid_chars, name[i] ) ) {
-			return False;
+			return false;
 		}
 	}
 
-	return True;
+	return true;
 }
 
 
@@ -2778,9 +2833,9 @@ char *escape_shell_string(const char *src)
 	size_t srclen = strlen(src);
 	char *ret = SMB_MALLOC_ARRAY(char, (srclen * 2) + 1);
 	char *dest = ret;
-	BOOL in_s_quote = False;
-	BOOL in_d_quote = False;
-	BOOL next_escaped = False;
+	bool in_s_quote = false;
+	bool in_d_quote = false;
+	bool next_escaped = false;
 
 	if (!ret) {
 		return NULL;
@@ -2799,7 +2854,7 @@ char *escape_shell_string(const char *src)
 			memcpy(dest, src, c_size);
 			src += c_size;
 			dest += c_size;
-			next_escaped = False;
+			next_escaped = false;
 			continue;
 		}
 
@@ -2810,7 +2865,7 @@ char *escape_shell_string(const char *src)
 
 		if (next_escaped) {
 			*dest++ = *src++;
-			next_escaped = False;
+			next_escaped = false;
 			continue;
 		}
 
@@ -2822,13 +2877,13 @@ char *escape_shell_string(const char *src)
 
 		if (in_s_quote) {
 			if (*src == '\'') {
-				in_s_quote = False;
+				in_s_quote = false;
 			}
 			*dest++ = *src++;
 			continue;
 		}
 
-		/* 
+		/*
 		 * Deal with double quote state. The most
 		 * complex state. We must cope with \, meaning
 		 * possibly escape next char (depending what it
@@ -2839,7 +2894,7 @@ char *escape_shell_string(const char *src)
 
 		if (in_d_quote) {
 			if (*src == '\\') {
-				/* 
+				/*
 				 * Next character might be escaped.
 				 * We have to peek. Inside double
 				 * quotes only INSIDE_DQUOTE_LIST
@@ -2864,8 +2919,9 @@ char *escape_shell_string(const char *src)
 
 				nextchar = src[1];
 
-				if (nextchar && strchr(INSIDE_DQUOTE_LIST, (int)nextchar)) {
-					next_escaped = True;
+				if (nextchar && strchr(INSIDE_DQUOTE_LIST,
+							(int)nextchar)) {
+					next_escaped = true;
 				}
 				*dest++ = *src++;
 				continue;
@@ -2873,7 +2929,7 @@ char *escape_shell_string(const char *src)
 
 			if (*src == '\"') {
 				/* Exit double quote state. */
-				in_d_quote = False;
+				in_d_quote = false;
 				*dest++ = *src++;
 				continue;
 			}
@@ -2891,28 +2947,28 @@ char *escape_shell_string(const char *src)
 			continue;
 		}
 
-		/* 
+		/*
 		 * From here to the end of the loop we're
 		 * not in the single or double quote state.
 		 */
 
 		if (*src == '\\') {
 			/* Next character must be escaped. */
-			next_escaped = True;
+			next_escaped = true;
 			*dest++ = *src++;
 			continue;
 		}
 
 		if (*src == '\'') {
 			/* Go into single quote state. */
-			in_s_quote = True;
+			in_s_quote = true;
 			*dest++ = *src++;
 			continue;
 		}
 
 		if (*src == '\"') {
 			/* Go into double quote state. */
-			in_d_quote = True;
+			in_d_quote = true;
 			*dest++ = *src++;
 			continue;
 		}