#include "includes.h"
/****************************************************************************
- 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
+ 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(char **ptr,char *buff,char *sep, size_t bufsize)
+
+BOOL next_token(char **ptr,char *buff, const char *sep, size_t bufsize)
{
char *s;
BOOL quoted;
size_t len=1;
- if (!ptr) return(False);
+ if (!ptr)
+ return(False);
s = *ptr;
/* default to simple separators */
- if (!sep) sep = " \t\n\r";
+ if (!sep)
+ sep = " \t\n\r";
/* find the first non sep char */
- while (*s && strchr_m(sep,*s)) s++;
+ while (*s && strchr_m(sep,*s))
+ s++;
/* nothing left? */
- if (! *s) return(False);
+ if (! *s)
+ return(False);
/* copy over the token */
for (quoted = False; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
return(True);
}
-
-
/****************************************************************************
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 char *last_ptr=NULL;
-BOOL next_token_nr(char **ptr,char *buff,char *sep, size_t bufsize)
+BOOL next_token_nr(char **ptr,char *buff, const char *sep, size_t bufsize)
{
BOOL ret;
- if (!ptr) ptr = &last_ptr;
+ if (!ptr)
+ ptr = &last_ptr;
ret = next_token(ptr, buff, sep, bufsize);
last_ptr = *ptr;
last_ptr = ptr;
}
-
/****************************************************************************
-Convert list of tokens to array; dependent on above routine.
-Uses last_ptr from above - bit of a hack.
+ Convert list of tokens to array; dependent on above routine.
+ Uses last_ptr from above - bit of a hack.
****************************************************************************/
-char **toktocliplist(int *ctok, char *sep)
+
+char **toktocliplist(int *ctok, const char *sep)
{
char *s=last_ptr;
int ictok=0;
char **ret, **iret;
- if (!sep) sep = " \t\n\r";
+ if (!sep)
+ sep = " \t\n\r";
- while(*s && strchr_m(sep,*s)) s++;
+ while(*s && strchr_m(sep,*s))
+ s++;
/* nothing left? */
- if (!*s) return(NULL);
+ if (!*s)
+ return(NULL);
do {
ictok++;
- while(*s && (!strchr_m(sep,*s))) s++;
- while(*s && strchr_m(sep,*s)) *s++=0;
+ while(*s && (!strchr_m(sep,*s)))
+ s++;
+ while(*s && strchr_m(sep,*s))
+ *s++=0;
} while(*s);
*ctok=ictok;
s=last_ptr;
- if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
+ if (!(ret=iret=malloc(ictok*sizeof(char *))))
+ return NULL;
while(ictok--) {
*iret++=s;
- while(*s++);
- while(!*s) s++;
+ while(*s++)
+ ;
+ while(!*s)
+ s++;
}
return ret;
}
/*******************************************************************
- case insensitive string compararison
+ Case insensitive string compararison.
********************************************************************/
+
int StrCaseCmp(const char *s, const char *t)
{
pstring buf1, buf2;
}
/*******************************************************************
- case insensitive string compararison, length limited
+ Case insensitive string compararison, length limited.
********************************************************************/
+
int StrnCaseCmp(const char *s, const char *t, size_t n)
{
pstring buf1, buf2;
}
/*******************************************************************
- compare 2 strings
+ Compare 2 strings.
********************************************************************/
+
BOOL strequal(const char *s1, const char *s2)
{
- if (s1 == s2) return(True);
- if (!s1 || !s2) return(False);
+ if (s1 == s2)
+ return(True);
+ if (!s1 || !s2)
+ return(False);
return(StrCaseCmp(s1,s2)==0);
}
/*******************************************************************
- compare 2 strings up to and including the nth char.
- ******************************************************************/
+ Compare 2 strings up to and including the nth char.
+******************************************************************/
+
BOOL strnequal(const char *s1,const char *s2,size_t n)
{
- if (s1 == s2) return(True);
- if (!s1 || !s2 || !n) return(False);
+ if (s1 == s2)
+ return(True);
+ if (!s1 || !s2 || !n)
+ return(False);
return(StrnCaseCmp(s1,s2,n)==0);
}
/*******************************************************************
- compare 2 strings (case sensitive)
+ Compare 2 strings (case sensitive).
********************************************************************/
+
BOOL strcsequal(const char *s1,const char *s2)
{
- if (s1 == s2) return(True);
- if (!s1 || !s2) return(False);
+ 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 */
return (1);
/* sync the strings on first non-whitespace */
- while (1)
- {
+ while (1) {
while (isspace((int)*psz1))
psz1++;
while (isspace((int)*psz2))
}
-/* Convert a string to upper case, but don't modify it */
+/*******************************************************************
+ Convert a string to upper case, but don't modify it.
+********************************************************************/
char *strupper_static(const char *s)
{
}
/*******************************************************************
- convert a string to "normal" form
+ Convert a string to "normal" form.
********************************************************************/
+
void strnorm(char *s)
{
- extern int case_default;
- if (case_default == CASE_UPPER)
- strupper(s);
- else
- strlower(s);
+ extern int case_default;
+ if (case_default == CASE_UPPER)
+ strupper(s);
+ else
+ strlower(s);
}
/*******************************************************************
-check if a string is in "normal" case
+ Check if a string is in "normal" case.
********************************************************************/
-BOOL strisnormal(char *s)
+
+BOOL strisnormal(const char *s)
{
extern int case_default;
if (case_default == CASE_UPPER)
/****************************************************************************
- string replace
- NOTE: oldc and newc must be 7 bit characters
+ String replace.
+ NOTE: oldc and newc must be 7 bit characters
****************************************************************************/
+
void string_replace(char *s,char oldc,char newc)
{
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
pull_ucs2(NULL, s, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
}
-
/*******************************************************************
-skip past some strings in a buffer
+ Skip past some strings in a buffer.
********************************************************************/
+
char *skip_string(char *buf,size_t n)
{
while (n--)
be the same as the number of bytes in a string for single byte strings,
but will be different for multibyte.
********************************************************************/
+
size_t str_charnum(const char *s)
{
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
}
/*******************************************************************
-trim the specified elements off the front and back of a string
+ Trim the specified elements off the front and back of a string.
********************************************************************/
BOOL trim_string(char *s,const char *front,const char *back)
return ret;
}
-
/****************************************************************************
-does a string have any uppercase chars in it?
+ Does a string have any uppercase chars in it?
****************************************************************************/
+
BOOL strhasupper(const char *s)
{
smb_ucs2_t *ptr;
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
for(ptr=tmpbuf;*ptr;ptr++)
- if(isupper_w(*ptr)) return True;
+ if(isupper_w(*ptr))
+ return True;
return(False);
}
/****************************************************************************
-does a string have any lowercase chars in it?
+ Does a string have any lowercase chars in it?
****************************************************************************/
+
BOOL strhaslower(const char *s)
{
smb_ucs2_t *ptr;
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
for(ptr=tmpbuf;*ptr;ptr++)
- if(islower_w(*ptr)) return True;
+ if(islower_w(*ptr))
+ return True;
return(False);
}
/****************************************************************************
-find the number of 'c' chars in a string
+ Find the number of 'c' chars in a string
****************************************************************************/
+
size_t count_chars(const char *s,char c)
{
smb_ucs2_t *ptr;
int count;
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
- for(count=0,ptr=tmpbuf;*ptr;ptr++) if(*ptr==UCS2_CHAR(c)) count++;
+ for(count=0,ptr=tmpbuf;*ptr;ptr++)
+ if(*ptr==UCS2_CHAR(c))
+ count++;
return(count);
}
{
smb_ucs2_t *ptr;
- if(s == NULL) return False;
- if(!*s) return False;
+ if(s == NULL)
+ return False;
+ if(!*s)
+ return False;
push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
- for(ptr=tmpbuf;*ptr;ptr++) if(*ptr!=UCS2_CHAR(c)) return False;
+ for(ptr=tmpbuf;*ptr;ptr++)
+ if(*ptr!=UCS2_CHAR(c))
+ return False;
return True;
}
/*******************************************************************
-safe string copy into a known length string. maxlength does not
-include the terminating zero.
+ 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)
}
/*******************************************************************
-safe string cat into a string. maxlength does not
-include the terminating zero.
+ Safe string cat into a string. maxlength does not
+ include the terminating zero.
********************************************************************/
char *safe_strcat(char *dest, const char *src, size_t maxlength)
return NULL;
}
- if (!src) {
+ if (!src)
return dest;
- }
src_len = strlen(src);
dest_len = strlen(dest);
char *StrnCpy(char *dest,const char *src,size_t n)
{
char *d = dest;
- if (!dest) return(NULL);
+ if (!dest)
+ return(NULL);
if (!src) {
*dest = 0;
return(dest);
}
- while (n-- && (*d++ = *src++)) ;
+ while (n-- && (*d++ = *src++))
+ ;
*d = 0;
return(dest);
}
/****************************************************************************
-like strncpy but copies up to the character marker. always null terminates.
-returns a pointer to the character marker in the source string (src).
+ Like strncpy but copies up to the character marker. always null terminates.
+ returns a pointer to the character marker in the source string (src).
****************************************************************************/
+
char *strncpyn(char *dest, const char *src, size_t n, char c)
{
char *p;
size_t str_len;
p = strchr_m(src, c);
- if (p == NULL)
- {
+ if (p == NULL) {
DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
return NULL;
}
return p;
}
-
/*************************************************************
Routine to get hex characters and turn them into a 16 byte array.
the array can be variable length, and any non-hex-numeric
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;
char *hexchars = "0123456789ABCDEF";
char *p1 = NULL, *p2 = NULL;
- for (i = 0; i < len && strhex[i] != 0; i++)
- {
- if (strnequal(hexchars, "0x", 2))
- {
+ for (i = 0; i < len && strhex[i] != 0; i++) {
+ if (strnequal(hexchars, "0x", 2)) {
i++; /* skip two chars */
continue;
}
if (!(p1 = strchr_m(hexchars, toupper(strhex[i]))))
- {
break;
- }
i++; /* next hex digit */
if (!(p2 = strchr_m(hexchars, toupper(strhex[i]))))
- {
break;
- }
/* get the two nybbles */
hinybble = PTR_DIFF(p1, hexchars);
}
/****************************************************************************
-check if a string is part of a list
+ Check if a string is part of a list.
****************************************************************************/
+
BOOL in_list(char *s,char *list,BOOL casesensitive)
{
- pstring tok;
- 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(tok,s) == 0)
- return(True);
- }
- }
- return(False);
+ pstring tok;
+ 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(tok,s) == 0)
+ return(True);
+ }
+ }
+ return(False);
}
/* this is used to prevent lots of mallocs of size 1 */
static char *null_string = NULL;
/****************************************************************************
-set a string value, allocing the space for the string
+ Set a string value, allocing the space for the string
****************************************************************************/
+
static BOOL string_init(char **dest,const char *src)
{
- size_t l;
- if (!src)
- src = "";
-
- l = strlen(src);
-
- if (l == 0)
- {
- if (!null_string) {
- if((null_string = (char *)malloc(1)) == NULL) {
- DEBUG(0,("string_init: malloc fail for null_string.\n"));
- return False;
- }
- *null_string = 0;
- }
- *dest = null_string;
- }
- else
- {
- (*dest) = (char *)malloc(l+1);
- if ((*dest) == NULL) {
- DEBUG(0,("Out of memory in string_init\n"));
- return False;
- }
-
- pstrcpy(*dest,src);
- }
- return(True);
+ size_t l;
+ if (!src)
+ src = "";
+
+ l = strlen(src);
+
+ if (l == 0) {
+ if (!null_string) {
+ if((null_string = (char *)malloc(1)) == NULL) {
+ DEBUG(0,("string_init: malloc fail for null_string.\n"));
+ return False;
+ }
+ *null_string = 0;
+ }
+ *dest = null_string;
+ } else {
+ (*dest) = (char *)malloc(l+1);
+ if ((*dest) == NULL) {
+ DEBUG(0,("Out of memory in string_init\n"));
+ return False;
+ }
+
+ pstrcpy(*dest,src);
+ }
+ return(True);
}
/****************************************************************************
-free a string value
+ Free a string value.
****************************************************************************/
+
void string_free(char **s)
{
- if (!s || !(*s)) return;
- if (*s == null_string)
- *s = NULL;
- SAFE_FREE(*s);
+ if (!s || !(*s))
+ return;
+ if (*s == null_string)
+ *s = NULL;
+ SAFE_FREE(*s);
}
/****************************************************************************
-set a string value, deallocating any existing space, and allocing the space
-for the string
+ 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));
+ string_free(dest);
+ return(string_init(dest,src));
}
-
/****************************************************************************
-substitute a string for a pattern in another string. Make sure there is
-enough room!
+ 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.
+ 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.
+ 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)
string_sub(s, pattern, insert, sizeof(pstring));
}
-/* similar to string_sub, but it will accept only allocated strings
- * and may realloc them so pay attention at what you pass on no
- * pointers inside strings, no pstrings or const may be passed
- * as string.
- */
+/****************************************************************************
+ Similar to string_sub, but it will accept only allocated strings
+ and may realloc them so pay attention at what you pass on no
+ pointers inside strings, no pstrings or const may be passed
+ as string.
+****************************************************************************/
char *realloc_string_sub(char *string, const char *pattern, const char *insert)
{
}
/****************************************************************************
-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.
+ 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)
}
/****************************************************************************
-similar to all_string_sub but for unicode strings.
-return a new allocated unicode string.
- similar to string_sub() but allows for any character to be substituted.
- Use with caution!
+ Similar to all_string_sub but for unicode strings.
+ Return a new allocated unicode string.
+ similar to string_sub() but allows for any character to be substituted.
+ Use with caution!
****************************************************************************/
smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
const smb_ucs2_t *sp;
size_t lr, lp, li, lt;
- if (!insert || !pattern || !*pattern || !s) return NULL;
+ if (!insert || !pattern || !*pattern || !s)
+ return NULL;
lt = (size_t)strlen_w(s);
lp = (size_t)strlen_w(pattern);
{
wpstring p, i;
- if (!insert || !pattern || !s) return NULL;
+ if (!insert || !pattern || !s)
+ return NULL;
push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
return all_string_sub_w(s, p, i);
return t;
}
-/*
- return a RFC2254 binary string representation of a buffer
- used in LDAP filters
- caller must free
-*/
+/*******************************************************************
+ Return a RFC2254 binary string representation of a buffer.
+ Used in LDAP filters.
+ Caller must free.
+********************************************************************/
+
char *binary_string(char *buf, int len)
{
char *s;
return s;
}
-/* Just a typesafety wrapper for snprintf into a pstring */
+/*******************************************************************
+ Just a typesafety wrapper for snprintf into a pstring.
+********************************************************************/
int pstr_sprintf(pstring s, const char *fmt, ...)
{
return ret;
}
-/* Just a typesafety wrapper for snprintf into a fstring */
+/*******************************************************************
+ Just a typesafety wrapper for snprintf into a fstring.
+********************************************************************/
int fstr_sprintf(fstring s, const char *fmt, ...)
{
#ifndef HAVE_STRNLEN
/*******************************************************************
-some platforms don't have strnlen
+ Some platforms don't have strnlen
********************************************************************/
+
size_t strnlen(const char *s, size_t n)
{
int i;
str_list_free(&list);
SAFE_FREE(s);
return NULL;
- }
- else list = rlist;
+ } else
+ list = rlist;
memset (&list[num], 0, ((sizeof(char**)) * (S_LIST_ABS +1)));
}
DEBUG(0,("str_list_copy: Unable to re-allocate memory"));
str_list_free(&list);
return False;
- }
- else list = rlist;
+ } else
+ list = rlist;
memset (&list[num], 0, ((sizeof(char **)) * (S_LIST_ABS +1)));
}
return True;
}
-/* return true if all the elements of the list match exactly */
+/***********************************************************
+ Return true if all the elements of the list match exactly.
+***********************************************************/
BOOL str_list_compare(char **list1, char **list2)
{
git.samba.org / kai / samba.git / commitdiff