#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(const char **ptr,char *buff, const char *sep, size_t bufsize)
{
const char *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;
last_ptr = ptr;
}
-/****************************************************************************
+/**
Convert list of tokens to array; dependent on above routine.
Uses last_ptr from above - bit of a hack.
-****************************************************************************/
+**/
char **toktocliplist(int *ctok, const char *sep)
{
return ret;
}
-/*******************************************************************
+/**
Case insensitive string compararison.
-********************************************************************/
+**/
int StrCaseCmp(const char *s, const char *t)
{
return strcmp(buf1,buf2);
}
-/*******************************************************************
+/**
Case insensitive string compararison, length limited.
-********************************************************************/
+**/
int StrnCaseCmp(const char *s, const char *t, size_t n)
{
return strncmp(buf1,buf2,n);
}
-/*******************************************************************
+/**
Compare 2 strings.
-********************************************************************/
+**/
BOOL strequal(const char *s1, const char *s2)
{
return(StrCaseCmp(s1,s2)==0);
}
-/*******************************************************************
+/**
Compare 2 strings up to and including the nth char.
-******************************************************************/
+**/
BOOL strnequal(const char *s1,const char *s2,size_t n)
{
return(StrnCaseCmp(s1,s2,n)==0);
}
-/*******************************************************************
+/**
Compare 2 strings (case sensitive).
-********************************************************************/
+**/
BOOL strcsequal(const char *s1,const char *s2)
{
return(strcmp(s1,s2)==0);
}
-/***************************************************************************
+/**
Do a case-insensitive, whitespace-ignoring string compare.
-***************************************************************************/
+**/
int strwicmp(const char *psz1, const char *psz2)
{
}
-/*******************************************************************
+/**
Convert a string to upper case, but don't modify it.
-********************************************************************/
+**/
char *strupper_static(const char *s)
{
return str;
}
-/*******************************************************************
+/**
Convert a string to "normal" form.
-********************************************************************/
+**/
void strnorm(char *s)
{
strlower(s);
}
-/*******************************************************************
+/**
Check if a string is in "normal" case.
-********************************************************************/
+**/
BOOL strisnormal(const char *s)
{
}
-/****************************************************************************
+/**
String replace.
NOTE: oldc and newc must be 7 bit characters
-****************************************************************************/
+**/
void string_replace(char *s,char oldc,char newc)
{
pull_ucs2(NULL, s, tmpbuf, -1, sizeof(tmpbuf), STR_TERMINATE);
}
-/*******************************************************************
+/**
Skip past some strings in a buffer.
-********************************************************************/
+**/
char *skip_string(char *buf,size_t n)
{
return(buf);
}
-/*******************************************************************
+/**
Count the number of characters in a string. Normally this will
be the same as the number of bytes in a string for single byte strings,
but will be different for multibyte.
-********************************************************************/
+**/
size_t str_charnum(const char *s)
{
- push_ucs2(NULL, tmpbuf,s, sizeof(tmpbuf), STR_TERMINATE);
- return strlen_w(tmpbuf);
+ uint16 tmpbuf2[sizeof(pstring)];
+ push_ucs2(NULL, tmpbuf2,s, sizeof(tmpbuf2), STR_TERMINATE);
+ return strlen_w(tmpbuf2);
+}
+
+/**
+ Count the number of characters in a string. Normally this will
+ be the same as the number of bytes in a string for single byte strings,
+ but will be different for multibyte.
+**/
+
+size_t str_ascii_charnum(const char *s)
+{
+ pstring tmpbuf2;
+ push_ascii(tmpbuf2, s, sizeof(tmpbuf2), STR_TERMINATE);
+ return strlen(tmpbuf2);
}
-/*******************************************************************
+/**
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?
-****************************************************************************/
+**/
BOOL strhasupper(const char *s)
{
return(False);
}
-/****************************************************************************
+/**
Does a string have any lowercase chars in it?
-****************************************************************************/
+**/
BOOL strhaslower(const char *s)
{
return(False);
}
-/****************************************************************************
+/**
Find the number of 'c' chars in a string
-****************************************************************************/
+**/
size_t count_chars(const char *s,char c)
{
return(count);
}
-/*******************************************************************
+/**
Return True if a string consists only of one particular character.
-********************************************************************/
+**/
BOOL str_is_all(const char *s,char c)
{
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)
{
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
+
if (!src) {
*dest = 0;
return dest;
len = strlen(src);
if (len > maxlength) {
- DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
- (int)(len-maxlength), src));
+ DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
+ (unsigned int)(len-maxlength), len, maxlength, src));
len = maxlength;
}
return dest;
}
-/*******************************************************************
+/**
Safe string cat into a string. maxlength does not
include the terminating zero.
-********************************************************************/
+**/
char *safe_strcat(char *dest, const char *src, size_t maxlength)
{
src_len = strlen(src);
dest_len = strlen(dest);
-
+
if (src_len + dest_len > maxlength) {
DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
(int)(src_len + dest_len - maxlength), src));
- src_len = maxlength - dest_len;
+ if (maxlength > dest_len) {
+ memcpy(&dest[dest_len], src, maxlength - dest_len);
+ }
+ dest[maxlength] = 0;
+ return NULL;
}
memcpy(&dest[dest_len], src, src_len);
return dest;
}
-/*******************************************************************
+/**
Paranoid strcpy into a buffer of given length (includes terminating
zero. Strips out all but 'a-Z0-9' and the character in other_safe_chars
and replaces with '_'. Deliberately does *NOT* check for multibyte
characters. Don't change it !
-********************************************************************/
+**/
char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength)
{
return dest;
}
-/****************************************************************************
+/**
Like strncpy but always null terminates. Make sure there is room!
The variable n should always be one less than the available size.
-****************************************************************************/
+**/
char *StrnCpy(char *dest,const char *src,size_t n)
{
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).
-****************************************************************************/
+**/
char *strncpyn(char *dest, const char *src, size_t n, char c)
{
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
characters are skipped. "0xnn" or "0Xnn" is specially catered
valid examples: "0A5D15"; "0x15, 0x49, 0xa2"; "59\ta9\te3\n"
-**************************************************************/
+**/
size_t strhex_to_str(char *p, size_t len, const char *strhex)
{
size_t i;
size_t num_chars = 0;
unsigned char lonybble, hinybble;
- char *hexchars = "0123456789ABCDEF";
+ const char *hexchars = "0123456789ABCDEF";
char *p1 = NULL, *p2 = NULL;
for (i = 0; i < len && strhex[i] != 0; i++) {
return num_chars;
}
-/****************************************************************************
+/**
Check if a string is part of a list.
-****************************************************************************/
+**/
BOOL in_list(char *s,char *list,BOOL casesensitive)
{
/* 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
-****************************************************************************/
+**/
static BOOL string_init(char **dest,const char *src)
{
}
*dest = null_string;
} else {
- (*dest) = (char *)malloc(l+1);
+ (*dest) = strdup(src);
if ((*dest) == NULL) {
DEBUG(0,("Out of memory in string_init\n"));
return False;
}
-
- pstrcpy(*dest,src);
}
return(True);
}
-/****************************************************************************
+/**
Free a string value.
-****************************************************************************/
+**/
void string_free(char **s)
{
SAFE_FREE(*s);
}
-/****************************************************************************
+/**
Set a string value, deallocating any existing space, and allocing the space
for the string
-****************************************************************************/
+**/
BOOL string_set(char **dest,const char *src)
{
return(string_init(dest,src));
}
-/****************************************************************************
+/**
Substitute a string for a pattern in another string. Make sure there is
enough room!
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.
-****************************************************************************/
+**/
char *realloc_string_sub(char *string, const char *pattern, const char *insert)
{
return string;
}
-/****************************************************************************
+/**
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!
-****************************************************************************/
+**/
smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s, const smb_ucs2_t *pattern,
const smb_ucs2_t *insert)
return all_string_sub_w(s, p, i);
}
-/****************************************************************************
+/**
Splits out the front and back at a separator.
-****************************************************************************/
+**/
void split_at_last_component(char *path, char *front, char sep, char *back)
{
}
}
-/****************************************************************************
+/**
Write an octal as a string.
-****************************************************************************/
+**/
-char *octal_string(int i)
+const char *octal_string(int i)
{
static char ret[64];
if (i == -1)
}
-/****************************************************************************
+/**
Truncate a string at a specified length.
-****************************************************************************/
+**/
char *string_truncate(char *s, int length)
{
return s;
}
-/****************************************************************************
+/**
Strchr and strrchr_m are very hard to do on general multi-byte strings.
We convert via ucs2 for now.
-****************************************************************************/
+**/
char *strchr_m(const char *s, char c)
{
return (char *)(s+strlen(s2));
}
-/*******************************************************************
+/**
Convert a string to lower case.
-********************************************************************/
+**/
void strlower_m(char *s)
{
supported multi-byte character sets are ascii-compatible
(ie. they match for the first 128 chars) */
- while (*s && !(((unsigned char)s[0]) & 0x7F))
- *s++ = tolower((unsigned char)*s);
+ while (*s && !(((unsigned char)s[0]) & 0x7F)) {
+ *s = tolower((unsigned char)*s);
+ s++;
+ }
if (!*s)
return;
unix_strlower(s,strlen(s)+1,s,strlen(s)+1);
}
-/*******************************************************************
+/**
Duplicate convert a string to lower case.
-********************************************************************/
+**/
char *strdup_lower(const char *s)
{
return t;
}
-/*******************************************************************
+/**
Convert a string to upper case.
-********************************************************************/
+**/
void strupper_m(char *s)
{
supported multi-byte character sets are ascii-compatible
(ie. they match for the first 128 chars) */
- while (*s && !(((unsigned char)s[0]) & 0x7F))
- *s++ = toupper((unsigned char)*s);
+ while (*s && !(((unsigned char)s[0]) & 0x7F)) {
+ *s = toupper((unsigned char)*s);
+ s++;
+ }
if (!*s)
return;
unix_strupper(s,strlen(s)+1,s,strlen(s)+1);
}
-/*******************************************************************
+/**
Convert a string to upper case.
-********************************************************************/
+**/
char *strdup_upper(const char *s)
{
return t;
}
-/*******************************************************************
+/**
Return a RFC2254 binary string representation of a buffer.
Used in LDAP filters.
Caller must free.
-********************************************************************/
+**/
char *binary_string(char *buf, int len)
{
return s;
}
-/*******************************************************************
+/**
Just a typesafety wrapper for snprintf into a pstring.
-********************************************************************/
+**/
-int pstr_sprintf(pstring s, const char *fmt, ...)
+ int pstr_sprintf(pstring s, const char *fmt, ...)
{
va_list ap;
int ret;
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;
}
#ifndef HAVE_STRNDUP
-/*******************************************************************
+/**
Some platforms don't have strndup.
-********************************************************************/
+**/
char *strndup(const char *s, size_t n)
{
#endif
#ifndef HAVE_STRNLEN
-/*******************************************************************
+/**
Some platforms don't have strnlen
-********************************************************************/
+**/
size_t strnlen(const char *s, size_t n)
{
}
#endif
-/***********************************************************
+/**
List of Strings manipulation functions
-***********************************************************/
+**/
#define S_LIST_ABS 16 /* List Allocation Block Size */
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)
{
int num;
return True;
}
+
+
+#define IPSTR_LIST_SEP ","
+
+/**
+ * Add ip string representation to ipstr list. Used also
+ * as part of @function ipstr_list_make
+ *
+ * @param ipstr_list pointer to string containing ip list;
+ * MUST BE already allocated and IS reallocated if necessary
+ * @param ipstr_size pointer to current size of ipstr_list (might be changed
+ * as a result of reallocation)
+ * @param ip IP address which is to be added to list
+ * @return pointer to string appended with new ip and possibly
+ * reallocated to new length
+ **/
+
+char* ipstr_list_add(char** ipstr_list, const struct in_addr *ip)
+{
+ char* new_ipstr = NULL;
+
+ /* arguments checking */
+ if (!ipstr_list || !ip) return NULL;
+
+ /* attempt to convert ip to a string and append colon separator to it */
+ if (*ipstr_list) {
+ asprintf(&new_ipstr, "%s%s%s", *ipstr_list, IPSTR_LIST_SEP,inet_ntoa(*ip));
+ SAFE_FREE(*ipstr_list);
+ } else {
+ asprintf(&new_ipstr, "%s", inet_ntoa(*ip));
+ }
+ *ipstr_list = new_ipstr;
+ return *ipstr_list;
+}
+
+
+/**
+ * Allocate and initialise an ipstr list using ip adresses
+ * passed as arguments.
+ *
+ * @param ipstr_list pointer to string meant to be allocated and set
+ * @param ip_list array of ip addresses to place in the list
+ * @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 in_addr* 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 in_addr structures)
+ *
+ * @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 in_addr** ip_list)
+{
+ fstring token_str;
+ int count;
+
+ if (!ipstr_list || !ip_list) return 0;
+
+ for (*ip_list = NULL, count = 0;
+ next_token(&ipstr_list, token_str, IPSTR_LIST_SEP, FSTRING_LEN);
+ count++) {
+
+ struct in_addr addr;
+
+ /* convert single token to ip address */
+ if ( (addr.s_addr = inet_addr(token_str)) == INADDR_NONE )
+ break;
+
+ /* prepare place for another in_addr structure */
+ *ip_list = Realloc(*ip_list, (count + 1) * sizeof(struct in_addr));
+ if (!*ip_list) return -1;
+
+ (*ip_list)[count] = addr;
+ }
+
+ return count;
+}
+
+
+/**
+ * Safely free ip string list
+ *
+ * @param ipstr_list ip string list to be freed
+ **/
+
+void ipstr_list_free(char* ipstr_list)
+{
+ SAFE_FREE(ipstr_list);
+}
+
+
+/**
+ Unescape a URL encoded string, in place.
+**/
+
+void rfc1738_unescape(char *buf)
+{
+ char *p=buf;
+
+ while ((p=strchr_m(p,'+')))
+ *p = ' ';
+
+ p = buf;
+
+ while (p && *p && (p=strchr_m(p,'%'))) {
+ int c1 = p[1];
+ int c2 = p[2];
+
+ if (c1 >= '0' && c1 <= '9')
+ c1 = c1 - '0';
+ else if (c1 >= 'A' && c1 <= 'F')
+ c1 = 10 + c1 - 'A';
+ else if (c1 >= 'a' && c1 <= 'f')
+ c1 = 10 + c1 - 'a';
+ else {p++; continue;}
+
+ if (c2 >= '0' && c2 <= '9')
+ c2 = c2 - '0';
+ else if (c2 >= 'A' && c2 <= 'F')
+ c2 = 10 + c2 - 'A';
+ else if (c2 >= 'a' && c2 <= 'f')
+ c2 = 10 + c2 - 'a';
+ else {p++; continue;}
+
+ *p = (c1<<4) | c2;
+
+ memmove(p+1, p+3, strlen(p+3)+1);
+ p++;
+ }
+}
+
+static const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Decode a base64 string into a DATA_BLOB - simple and slow algorithm
+ **/
+DATA_BLOB base64_decode_data_blob(const char *s)
+{
+ int bit_offset, byte_offset, idx, i, n;
+ DATA_BLOB decoded = data_blob(s, strlen(s)+1);
+ unsigned char *d = decoded.data;
+ char *p;
+
+ n=i=0;
+
+ while (*s && (p=strchr_m(b64,*s))) {
+ idx = (int)(p - b64);
+ byte_offset = (i*6)/8;
+ bit_offset = (i*6)%8;
+ d[byte_offset] &= ~((1<<(8-bit_offset))-1);
+ if (bit_offset < 3) {
+ d[byte_offset] |= (idx << (2-bit_offset));
+ n = byte_offset+1;
+ } else {
+ d[byte_offset] |= (idx >> (bit_offset-2));
+ d[byte_offset+1] = 0;
+ d[byte_offset+1] |= (idx << (8-(bit_offset-2))) & 0xFF;
+ n = byte_offset+2;
+ }
+ s++; i++;
+ }
+
+ /* fix up length */
+ decoded.length = n;
+ return decoded;
+}
+
+/**
+ * Decode a base64 string in-place - wrapper for the above
+ **/
+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';
+}
+
+/**
+ * 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
+ **/
+char * base64_encode_data_blob(DATA_BLOB data)
+{
+ int bits = 0;
+ int char_count = 0;
+ size_t out_cnt = 0;
+ size_t len = data.length;
+ size_t output_len = data.length * 2;
+ char *result = malloc(output_len); /* get us plenty of space */
+
+ while (len-- && out_cnt < (data.length * 2) - 5) {
+ int c = (unsigned char) *(data.data++);
+ bits += c;
+ char_count++;
+ if (char_count == 3) {
+ 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] = '\0'; /* terminate */
+ return result;
+}
+
+#ifdef VALGRIND
+size_t valgrind_strlen(const char *s)
+{
+ size_t count;
+ for(count = 0; *s++; count++)
+ ;
+ return count;
+}
+#endif
git.samba.org / ira / wip.git / blobdiff