X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=libcitadel%2Flib%2Ftools.c;h=df2f1b42d1086e434a3c254ebca21fe217a3047a;hp=6cb0646ea17133bcdd42937eb4c2dd3f1a796908;hb=1aa2da0249792527f99172681aecc77e0ad086af;hpb=351f7680b65e93cdd31ba6623d8b9c88175575f5

diff --git a/libcitadel/lib/tools.c b/libcitadel/lib/tools.c
index 6cb0646ea..df2f1b42d 100644
--- a/libcitadel/lib/tools.c
+++ b/libcitadel/lib/tools.c
@@ -1,6 +1,22 @@
 /*
  * A basic toolset containing miscellaneous functions for string manipluation,
  * encoding/decoding, and a bunch of other stuff.
+ *
+ * Copyright (c) 1987-2011 by the citadel.org team
+ *
+ * This program is open source 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
 
@@ -371,7 +387,6 @@ size_t CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen, int li
 		dest[dpos++] = '\r';
 		dest[dpos++] = '\n';
 		dest[dpos] = 0;
-		thisline = 0;
 	}
 
 	return(dpos);
@@ -430,9 +445,9 @@ int CtdlDecodeBase64(char *dest, const char *source, size_t length)
 /*
  * if we send out non ascii subjects, we encode it this way.
  */
-char *rfc2047encode(char *line, long length)
+char *rfc2047encode(const char *line, long length)
 {
-	char *AlreadyEncoded;
+	const char *AlreadyEncoded;
 	char *result;
 	long end;
 #define UTF8_HEADER "=?UTF-8?B?"
@@ -456,57 +471,77 @@ char *rfc2047encode(char *line, long length)
 	return result;
 }
 
-
 /*
- * Strip leading and trailing spaces from a string
+ * removes double slashes from pathnames
+ * allows / disallows trailing slashes
  */
-long striplt(char *buf)
+void StripSlashes(char *Dir, int TrailingSlash)
 {
-	int CountTrail = 0;
-	int FromStart = 1;
-	char *aptr, *bptr;
-
-	if ((buf==NULL) || (IsEmptyStr(buf)))
-		return 0;
+	char *a, *b;
 
-	bptr = aptr = buf;
+	a = b = Dir;
 
-	while (!IsEmptyStr(aptr)) {
-		if (isspace(*aptr)) {
-			if (FromStart)
-				aptr ++;
-			else {
-				CountTrail ++;
-				*bptr = *aptr;
-				aptr++; bptr++;
-			}
+	while (!IsEmptyStr(a)) {
+		if (*a == '/') {
+			while (*a == '/')
+				a++;
+			*b = '/';
+			b++;
 		}
 		else {
-			CountTrail = 0;
-			*bptr = *aptr;
-			aptr++; bptr++;
+			*b = *a;
+			b++; a++;
 		}
 	}
-
-	if (CountTrail > 0) {
-		bptr -= CountTrail;
+	if ((TrailingSlash) && (*(b - 1) != '/')){
+		*b = '/';
+		b++;
 	}
+	*b = '\0';
 
-	*bptr = '\0';
-	return bptr - buf;
 }
 
+/*
+ * Strip leading and trailing spaces from a string
+ */
+size_t striplt(char *buf) {
+	char *first_nonspace = NULL;
+	char *last_nonspace = NULL;
+	char *ptr;
+	size_t new_len = 0;
+
+	if ((buf == NULL) || (*buf == '\0')) {
+		return 0;
+	}
+
+	for (ptr=buf; *ptr!=0; ++ptr) {
+		if (!isspace(*ptr)) {
+			if (!first_nonspace) {
+				first_nonspace = ptr;
+			}
+			last_nonspace = ptr;
+		}
+	}
 
+	if ((!first_nonspace) || (!last_nonspace)) {
+		buf[0] = 0;
+		return 0;
+	}
 
+	new_len = last_nonspace - first_nonspace + 1;
+	memmove(buf, first_nonspace, new_len);
+	buf[new_len] = 0;
+	return new_len;
+}
 
 
 /**
  * \brief check for the presence of a character within a string (returns count)
  * \param st the string to examine
  * \param ch the char to search
- * \return the position inside of st
+ * \return the number of times ch appears in st
  */
-int haschar(const char *st,int ch)
+int haschar(const char *st, int ch)
 {
 	const char *ptr;
 	int b;
@@ -531,40 +566,19 @@ int haschar(const char *st,int ch)
  */
 void fmt_date(char *buf, size_t n, time_t thetime, int seconds) {
 	struct tm tm;
-	int hour;
-
-	/* Month strings for date conversions ... this needs to be localized eventually */
-	char *fmt_date_months[12] = {
-		"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-	};
+	char *teh_format = NULL;
 
-	strcpy(buf, "");
+	*buf = '\0';
 	localtime_r(&thetime, &tm);
 
-	hour = tm.tm_hour;
-	if (hour == 0)	hour = 12;
-	else if (hour > 12) hour = hour - 12;
-
 	if (seconds) {
-		snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s",
-			fmt_date_months[tm.tm_mon],
-			tm.tm_mday,
-			tm.tm_year + 1900,
-			hour,
-			tm.tm_min,
-			tm.tm_sec,
-			( (tm.tm_hour >= 12) ? "pm" : "am" )
-		);
-	} else {
-		snprintf(buf, n, "%s %d %4d %d:%02d%s",
-			fmt_date_months[tm.tm_mon],
-			tm.tm_mday,
-			tm.tm_year + 1900,
-			hour,
-			tm.tm_min,
-			( (tm.tm_hour >= 12) ? "pm" : "am" )
-		);
+		teh_format = "%F %R:%S";
 	}
+	else {
+		teh_format = "%F %R";
+	}
+
+	strftime(buf, n, teh_format, &tm);
 }
 
 
@@ -660,6 +674,64 @@ char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
 }
 
 
+/** 
+ * \brief Utility function to "readline" from memory
+ * \param start Location in memory from which we are reading.
+ * \param buf the buffer to place the string in.
+ * \param maxlen Size of string buffer
+ * \return Pointer to the source memory right after we stopped reading.
+ */
+const char *cmemreadline(const char *start, char *buf, int maxlen)
+{
+	char ch;
+	const char *ptr;
+	int len = 0;		/**< tally our own length to avoid strlen() delays */
+
+	ptr = start;
+
+	while (1) {
+		ch = *ptr++;
+		if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
+			buf[len++] = ch;
+		}
+		if ((ch == 10) || (ch == 0)) {
+			buf[len] = 0;
+			return ptr;
+		}
+	}
+}
+
+
+/** 
+ * \brief Utility function to "readline" from memory
+ * \param start Location in memory from which we are reading.
+ * \param buf the buffer to place the string in.
+ * \param maxlen Size of string buffer
+ * \param retlen the length of the returned string
+ * \return Pointer to the source memory right after we stopped reading.
+ */
+const char *cmemreadlinelen(const char *start, char *buf, int maxlen, int *retlen)
+{
+	char ch;
+	const char *ptr;
+	int len = 0;		/**< tally our own length to avoid strlen() delays */
+
+	ptr = start;
+
+	while (1) {
+		ch = *ptr++;
+		if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
+			buf[len++] = ch;
+		}
+		if ((ch == 10) || (ch == 0)) {
+			buf[len] = 0;
+			*retlen = len;
+			return ptr;
+		}
+	}
+}
+
+
 
 
 /*
@@ -693,19 +765,30 @@ int stripout(char *str, char leftboundary, char rightboundary) {
  * Reduce a string down to a boundarized substring (for example, remove
  * parentheses and anything outside them).
  */
-void stripallbut(char *str, char leftboundary, char rightboundary) {
-	int a;
-
-	for (a = 0; a < strlen(str); ++ a) {
-		if (str[a] == leftboundary) strcpy(str, &str[a+1]);
-	}
-
-	for (a = 0; a < strlen(str); ++ a) {
-		if (str[a] == rightboundary) str[a] = 0;
+long stripallbut(char *str, char leftboundary, char rightboundary) {
+	long len = 0;
+
+	char *lb = NULL;
+	char *rb = NULL;
+
+	lb = strrchr(str, leftboundary);
+	if (lb != NULL) {
+		++lb;
+		rb = strchr(str, rightboundary);
+		if ((rb != NULL) && (rb >= lb))  {
+			*rb = 0;
+			fflush(stderr);
+			len = (long)rb - (long)lb;
+			memmove(str, lb, len);
+			str[len] = 0;
+			return(len);
+		}
 	}
 
+	return (long)strlen(str);
 }
 
+
 char *myfgets(char *s, int size, FILE *stream) {
 	char *ret = fgets(s, size, stream);
 	char *nl;
@@ -731,7 +814,7 @@ void urlesc(char *outbuf, size_t oblen, char *strbuf)
 	int a, b, c, len, eclen, olen;
 	char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
 
-	strcpy(outbuf, "");
+	*outbuf = '\0';
 	len = strlen(strbuf);
 	eclen = strlen(ec);
 	olen = 0;
@@ -769,12 +852,41 @@ char *strcpy(char *dest, const char *src) {
  * Generate a new, globally unique UID parameter for a calendar etc. object
  */
 void generate_uuid(char *buf) {
-	static int seq = 0;
+	static int seq = (-1);
+	static int no_kernel_uuid = 0;
+
+	/* If we are running on Linux then we have a kernelspace uuid generator available */
+
+	if (no_kernel_uuid == 0) {
+		FILE *fp;
+		fp = fopen("/proc/sys/kernel/random/uuid", "rb");
+		if (fp) {
+			int rv;
+			rv = fread(buf, 36, 1, fp);
+			fclose(fp);
+			if (rv == 1) {
+				buf[36] = 0;
+				return;
+			}
+		}
+	}
+
+	/* If the kernel didn't provide us with a uuid, we generate a pseudo-random one */
 
-	sprintf(buf, "%lx-%lx-%x",
-		time(NULL),
+	no_kernel_uuid = 1;
+
+	if (seq == (-1)) {
+		seq = (int)rand();
+	}
+	++seq;
+	seq = (seq % 0x0FFF) ;
+
+	sprintf(buf, "%08lx-%04lx-4%03x-a%03x-%012lx",
+		(long)time(NULL),
 		(long)getpid(),
-		(seq++)
+		seq,
+		seq,
+		(long)rand()
 	);
 }
 
@@ -785,7 +897,7 @@ void generate_uuid(char *buf) {
  * The code is roughly based on the strstr() replacement from 'tin' written
  * by Urs Jannsen.
  */
-inline char *_bmstrcasestr_len(char *text, size_t textlen, char *pattern, size_t patlen) {
+inline static char *_bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
 
 	register unsigned char *p, *t;
 	register int i, j, *delta;
@@ -843,7 +955,7 @@ inline char *_bmstrcasestr_len(char *text, size_t textlen, char *pattern, size_t
  * The code is roughly based on the strstr() replacement from 'tin' written
  * by Urs Jannsen.
  */
-char *bmstrcasestr(char *text, char *pattern) {
+char *bmstrcasestr(char *text, const char *pattern) {
 	size_t textlen;
 	size_t patlen;
 
@@ -856,10 +968,95 @@ char *bmstrcasestr(char *text, char *pattern) {
 	return _bmstrcasestr_len(text, textlen, pattern, patlen);
 }
 
-char *bmstrcasestr_len(char *text, size_t textlen, char *pattern, size_t patlen) {
+char *bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
 	return _bmstrcasestr_len(text, textlen, pattern, patlen);
 }
 
+
+
+
+/*
+ * bmstrcasestr() -- case-insensitive substring search
+ *
+ * This uses the Boyer-Moore search algorithm and is therefore quite fast.
+ * The code is roughly based on the strstr() replacement from 'tin' written
+ * by Urs Jannsen.
+ */
+inline static const char *_cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
+
+	register unsigned char *p, *t;
+	register int i, j, *delta;
+	register size_t p1;
+	int deltaspace[256];
+
+	if (!text) return(NULL);
+	if (!pattern) return(NULL);
+
+	/* algorithm fails if pattern is empty */
+	if ((p1 = patlen) == 0)
+		return (text);
+
+	/* code below fails (whenever i is unsigned) if pattern too long */
+	if (p1 > textlen)
+		return (NULL);
+
+	/* set up deltas */
+	delta = deltaspace;
+	for (i = 0; i <= 255; i++)
+		delta[i] = p1;
+	for (p = (unsigned char *) pattern, i = p1; --i > 0;)
+		delta[tolower(*p++)] = i;
+
+	/*
+	 * From now on, we want patlen - 1.
+	 * In the loop below, p points to the end of the pattern,
+	 * t points to the end of the text to be tested against the
+	 * pattern, and i counts the amount of text remaining, not
+	 * including the part to be tested.
+	 */
+	p1--;
+	p = (unsigned char *) pattern + p1;
+	t = (unsigned char *) text + p1;
+	i = textlen - patlen;
+	while(1) {
+		if (tolower(p[0]) == tolower(t[0])) {
+			if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
+				return ((char *)t - p1);
+			}
+		}
+		j = delta[tolower(t[0])];
+		if (i < j)
+			break;
+		i -= j;
+		t += j;
+	}
+	return (NULL);
+}
+
+/*
+ * bmstrcasestr() -- case-insensitive substring search
+ *
+ * This uses the Boyer-Moore search algorithm and is therefore quite fast.
+ * The code is roughly based on the strstr() replacement from 'tin' written
+ * by Urs Jannsen.
+ */
+const char *cbmstrcasestr(const char *text, const char *pattern) {
+	size_t textlen;
+	size_t patlen;
+
+	if (!text) return(NULL);
+	if (!pattern) return(NULL);
+
+	textlen = strlen (text);
+	patlen = strlen (pattern);
+
+	return _cbmstrcasestr_len(text, textlen, pattern, patlen);
+}
+
+const char *cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
+	return _cbmstrcasestr_len(text, textlen, pattern, patlen);
+}
+
 /*
  * Local replacement for controversial C library function that generates
  * names for temporary files.  Included to shut up compiler warnings.
@@ -956,97 +1153,6 @@ void stripltlen(char *buf, int *len)
 	}
 }
 
-/**
- * \brief detect whether this char starts an utf-8 encoded char
- * \param Char character to inspect
- * \returns yes or no
- */
-inline int Ctdl_IsUtf8SequenceStart(char Char)
-{
-/** 11??.???? indicates an UTF8 Sequence. */
-	return ((Char & 0xC0) != 0);
-}
-
-/**
- * \brief evaluate the length of an utf8 special character sequence
- * \param Char the character to examine
- * \returns width of utf8 chars in bytes
- */
-inline int Ctdl_GetUtf8SequenceLength(char Char)
-{
-	int n = 1;
-        char test = (1<<7);
-	
-	while ((n < 8) && ((test & Char) != 0)) {
-		test = test << 1;
-		n ++;
-	}
-	if (n > 6)
-		n = 1;
-	return n;
-}
-
-/**
- * \brief measure the number of glyphs in an UTF8 string...
- * \param str string to measure
- * \returns the length of str
- */
-int Ctdl_Utf8StrLen(char *str)
-{
-	int n = 0;
-	int m = 0;
-	char *aptr;
-
-	if (str == NULL)
-		return n;
-	aptr = str;
-	while (*aptr != '\0') {
-		if (Ctdl_IsUtf8SequenceStart(*aptr)){
-			m = Ctdl_GetUtf8SequenceLength(*aptr);
-			while ((m-- > 0) && (*aptr++ != '\0'))
-				n ++;
-		}
-		else {
-			n++;
-			aptr++;
-		}
-			
-	}
-	return n;
-}
-
-/**
- * \brief cuts a string after maxlen glyphs
- * \param str string to cut to maxlen glyphs
- * \param maxlen how long may the string become?
- * \returns pointer to maxlen or the end of the string
- */
-char *Ctdl_Utf8StrCut(char *str, int maxlen)
-{
-	int n = 0, m = 0;
-	char *aptr;
-
-	if (str == NULL)
-		return NULL;
-	aptr = str;
-	while (*aptr != '\0') {
-		if (Ctdl_IsUtf8SequenceStart(*aptr)){
-			m = Ctdl_GetUtf8SequenceLength(*aptr);
-			while ((m-- > 0) && (*aptr++ != '\0'))
-				n ++;
-		}
-		else {
-			n++;
-			aptr++;
-		}
-		if (n > maxlen) {
-			*aptr = '\0';
-			return aptr;
-		}			
-	}
-	return aptr;
-}
-
 
 /*
  * Convert all whitespace characters in a supplied string to underscores
@@ -1067,3 +1173,20 @@ void convert_spaces_to_underscores(char *str)
 }
 
 
+/*
+ * check whether the provided string needs to be qp encoded or not
+ */
+int CheckEncode(const char *pch, long len, const char *pche)
+{
+	if (pche == NULL)
+		pche = pch + len;
+	while (pch < pche) {
+		if (((unsigned char) *pch < 32) || 
+		    ((unsigned char) *pch > 126)) {
+			return 1;
+		}
+		pch++;
+	}
+	return 0;
+}
+