diff options
| -rw-r--r-- | source3/lib/util_str.c | 584 |
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; } |