/*
Unix SMB/CIFS implementation.
Samba utility functions
+
Copyright (C) Andrew Tridgell 1992-2001
Copyright (C) Simo Sorce 2001-2002
+ Copyright (C) Martin Pool 2003
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
#include "includes.h"
+/**
+ * @file
+ * @brief String utilities.
+ **/
+
/**
* Get the next token from a string, return False if none found.
* Handles double-quotes.
but beware the fact that it is not re-entrant!
**/
-static char *last_ptr=NULL;
+static const char *last_ptr=NULL;
BOOL next_token_nr(const char **ptr,char *buff, const char *sep, size_t bufsize)
{
}
/**
- Case insensitive string compararison.
-**/
-
+ * Case insensitive string compararison.
+ *
+ * iconv does not directly give us a way to compare strings in
+ * arbitrary unix character sets -- all we can is convert and then
+ * compare. This is expensive.
+ *
+ * As an optimization, we do a first pass that considers only the
+ * prefix of the strings that is entirely 7-bit. Within this, we
+ * check whether they have the same value.
+ *
+ * Hopefully this will often give the answer without needing to copy.
+ * In particular it should speed comparisons to literal ascii strings
+ * or comparisons of strings that are "obviously" different.
+ *
+ * If we find a non-ascii character we fall back to converting via
+ * iconv.
+ *
+ * This should never be slower than convering the whole thing, and
+ * often faster.
+ *
+ * A different optimization would be to compare for bitwise equality
+ * in the binary encoding. (It would be possible thought hairy to do
+ * both simultaneously.) But in that case if they turn out to be
+ * different, we'd need to restart the whole thing.
+ *
+ * Even better is to implement strcasecmp for each encoding and use a
+ * function pointer.
+ **/
int StrCaseCmp(const char *s, const char *t)
{
+
+ const char * ps, * pt;
pstring buf1, buf2;
- unix_strupper(s, strlen(s)+1, buf1, sizeof(buf1));
- unix_strupper(t, strlen(t)+1, buf2, sizeof(buf2));
- return strcmp(buf1,buf2);
+
+ for (ps = s, pt = t; ; ps++, pt++) {
+ char us, ut;
+
+ if (!*ps && !*pt)
+ return 0; /* both ended */
+ else if (!*ps)
+ return -1; /* s is a prefix */
+ 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 */
+ break;
+
+ us = toupper(*ps);
+ ut = toupper(*pt);
+ if (us == ut)
+ continue;
+ else if (us < ut)
+ return -1;
+ else if (us > ut)
+ return +1;
+ }
+
+ /* TODO: Don't do this with a fixed-length buffer. This could
+ * still be much more efficient. */
+ /* TODO: Hardcode a char-by-char comparison for UTF-8, which
+ * can be much faster. */
+ /* TODO: Test case for this! */
+
+ unix_strupper(ps, strlen(ps)+1, buf1, sizeof(buf1));
+ unix_strupper(pt, strlen(pt)+1, buf2, sizeof(buf2));
+
+ return strcmp(buf1, buf2);
}
+
/**
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.
+ *
+ * @note The comparison is case-insensitive.
+ **/
BOOL strequal(const char *s1, const char *s2)
{
if (s1 == s2)
}
/**
- Compare 2 strings up to and including the nth char.
-**/
-
+ * Compare 2 strings up to and including the nth char.
+ *
+ * @note The comparison is case-insensitive.
+ **/
BOOL strnequal(const char *s1,const char *s2,size_t n)
{
if (s1 == s2)
return(count);
}
-/**
-Return True if a string consists only of one particular character.
-**/
-
-BOOL str_is_all(const char *s,char c)
-{
- smb_ucs2_t *ptr;
-
- 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;
-
- return True;
-}
-
/**
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)
+char *safe_strcpy_fn(const char *fn, int line, char *dest,const char *src, size_t maxlength)
{
size_t len;
return NULL;
}
-#ifdef DEVELOPER
- /* We intentionally write out at the extremity of the destination
- * string. If the destination is too short (e.g. pstrcpy into mallocd
- * or fstring) then this should cause an error under a memory
- * checker. */
- dest[maxlength] = '\0';
-#endif
+ clobber_region(fn,line,dest, maxlength+1);
if (!src) {
*dest = 0;
return dest;
}
- len = strlen(src);
+ len = strnlen(src, maxlength+1);
if (len > maxlength) {
DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
Safe string cat into a string. maxlength does not
include the terminating zero.
**/
-
-char *safe_strcat(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 (!src)
return dest;
- src_len = strlen(src);
- dest_len = strlen(dest);
+ src_len = strnlen(src, maxlength + 1);
+ dest_len = strnlen(dest, maxlength + 1);
+
+ clobber_region(fn, line, dest + dest_len, maxlength + 1 - dest_len);
if (src_len + dest_len > maxlength) {
DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
dest[maxlength] = 0;
return NULL;
}
-
+
memcpy(&dest[dest_len], src, src_len);
dest[dest_len + src_len] = 0;
return dest;
and replaces with '_'. Deliberately does *NOT* check for multibyte
characters. Don't change it !
**/
-
-char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
+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;
+ clobber_region(fn, line, dest, maxlength);
+
if (!dest) {
DEBUG(0,("ERROR: NULL dest in alpha_strcpy\n"));
return NULL;
Like strncpy but always null terminates. Make sure there is room!
The variable n should always be one less than the available size.
**/
-
-char *StrnCpy(char *dest,const char *src,size_t n)
+char *StrnCpy_fn(const char *fn, int line,char *dest,const char *src,size_t n)
{
char *d = dest;
+
+ clobber_region(fn, line, dest, n+1);
+
if (!dest)
return(NULL);
+
if (!src) {
*dest = 0;
return(dest);
}
- while (n-- && (*d++ = *src++))
- ;
+
+ while (n-- && (*d = *src)) {
+ d++;
+ src++;
+ }
+
*d = 0;
return(dest);
}
+#if 0
/**
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)
+static char *strncpyn(char *dest, const char *src, size_t n, char c)
{
char *p;
size_t str_len;
+ clobber_region(dest, n+1);
+
p = strchr_m(src, c);
if (p == NULL) {
DEBUG(5, ("strncpyn: separator character (%c) not found\n", c));
return p;
}
+#endif
/**
Routine to get hex characters and turn them into a 16 byte array.
return num_chars;
}
+/**
+ * Routine to print a buffer as HEX digits, into an allocated string.
+ */
+
+void hex_encode(const unsigned char *buff_in, size_t len, char **out_hex_buffer)
+{
+ int i;
+ char *hex_buffer;
+
+ *out_hex_buffer = smb_xmalloc((len*2)+1);
+ hex_buffer = *out_hex_buffer;
+
+ for (i = 0; i < len; i++)
+ slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
+}
+
/**
Check if a string is part of a list.
**/
Use with caution!
**/
-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;
return all_string_sub_w(s, p, i);
}
+#if 0
/**
Splits out the front and back at a separator.
**/
-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);
back[0] = 0;
}
}
+#endif
/**
Write an octal as a string.
Truncate a string at a specified length.
**/
-char *string_truncate(char *s, int length)
+char *string_truncate(char *s, unsigned int length)
{
if (s && strlen(s) > length)
s[length] = 0;
return ret;
}
+
/**
Just a typesafety wrapper for snprintf into a fstring.
**/
- int fstr_sprintf(fstring s, const char *fmt, ...)
+int fstr_sprintf(fstring s, const char *fmt, ...)
{
va_list ap;
int ret;
return ret;
}
+
#ifndef HAVE_STRNDUP
/**
Some platforms don't have strndup.
/**
* Decode a base64 string in-place - wrapper for the above
**/
-void base64_decode(char *s)
+void base64_decode_inplace(char *s)
{
DATA_BLOB decoded = base64_decode_data_blob(s);
memcpy(s, decoded.data, decoded.length);
- data_blob_free(&decoded);
-
/* null terminate */
s[decoded.length] = '\0';
+
+ data_blob_free(&decoded);
}
/**
return result;
}
-#ifdef VALGRIND
-size_t valgrind_strlen(const char *s)
-{
- size_t count;
- for(count = 0; *s++; count++)
- ;
- return count;
-}
-#endif