From 5005bce38763051b5b12e48ac60c3ff17097a952 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Wed, 4 Mar 2009 18:22:48 +0100
Subject: added ERE support in filter conditions

new comparison operation "ereregex"
---
 runtime/stringbuf.c | 44 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 34 insertions(+), 10 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 93d1e1ef..150439a1 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -694,6 +694,32 @@ int rsCStrCaseInsensitveStartsWithSzStr(cstr_t *pCS1, uchar *psz, size_t iLenSz)
 		return -1; /* pCS1 is less then psz */
 }
 
+#if 0
+/* check if a CStr object matches a POSIX ERE regex.
+ * added 2009-03-04 by rgerhards
+ * TODO: we should merge this with rsCStrSzStrMatchReg
+ */
+rsRetVal rsCStrSzStrMatchRegexERE(cstr_t *pCS1, uchar *psz)
+{
+	regex_t preq;
+	DEFiRet;
+
+	BEGINfunc
+
+	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
+		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), REG_EXTENDED);
+		ret = regexp.regexec(&preq, (char*) psz, 0, NULL, 0);
+		regexp.regfree(&preq);
+	} else {
+		ret = 1; /* simulate "not found" */
+	}
+
+	ENDfunc
+	RETiRet;
+}
+#endif
+
+
 /* check if a CStr object matches a regex.
  * msamia@redhat.com 2007-07-12
  * @return returns 0 if matched
@@ -701,25 +727,23 @@ int rsCStrCaseInsensitveStartsWithSzStr(cstr_t *pCS1, uchar *psz, size_t iLenSz)
  * rgerhards, 2007-07-16: bug is no real bug, because rsyslogd ensures there
  * never is a \0 *inside* a property string.
  * Note that the function returns -1 if regexp functionality is not available.
- * TODO: change calling interface! -- rgerhards, 2008-03-07
+ * rgerhards: 2009-03-04: ERE support added, via parameter iType: 0 - BRE, 1 - ERE
  */
-int rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz)
+rsRetVal rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz, int iType)
 {
 	regex_t preq;
-	int ret;
-
-	BEGINfunc
+	DEFiRet;
 
 	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
-		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), 0);
-		ret = regexp.regexec(&preq, (char*) psz, 0, NULL, 0);
+		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), iType == 1 ? REG_EXTENDED : 0);
+		CHKiRet(regexp.regexec(&preq, (char*) psz, 0, NULL, 0));
 		regexp.regfree(&preq);
 	} else {
-		ret = 1; /* simulate "not found" */
+		ABORT_FINALIZE(RS_RET_NOT_FOUND);
 	}
 
-	ENDfunc
-	return ret;
+finalize_it:
+	RETiRet;
 }
 
 
-- 
cgit v1.2.3


From bbcbd87ebdafe8a344c375104264a9ebdd3948d5 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Wed, 4 Mar 2009 18:34:36 +0100
Subject: some optimization on regex code

also some commented-out leftover removed
---
 runtime/stringbuf.c | 27 +--------------------------
 1 file changed, 1 insertion(+), 26 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 150439a1..8d52834d 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -694,31 +694,6 @@ int rsCStrCaseInsensitveStartsWithSzStr(cstr_t *pCS1, uchar *psz, size_t iLenSz)
 		return -1; /* pCS1 is less then psz */
 }
 
-#if 0
-/* check if a CStr object matches a POSIX ERE regex.
- * added 2009-03-04 by rgerhards
- * TODO: we should merge this with rsCStrSzStrMatchReg
- */
-rsRetVal rsCStrSzStrMatchRegexERE(cstr_t *pCS1, uchar *psz)
-{
-	regex_t preq;
-	DEFiRet;
-
-	BEGINfunc
-
-	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
-		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), REG_EXTENDED);
-		ret = regexp.regexec(&preq, (char*) psz, 0, NULL, 0);
-		regexp.regfree(&preq);
-	} else {
-		ret = 1; /* simulate "not found" */
-	}
-
-	ENDfunc
-	RETiRet;
-}
-#endif
-
 
 /* check if a CStr object matches a regex.
  * msamia@redhat.com 2007-07-12
@@ -735,7 +710,7 @@ rsRetVal rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz, int iType)
 	DEFiRet;
 
 	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
-		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), iType == 1 ? REG_EXTENDED : 0);
+		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), (iType == 1 ? REG_EXTENDED : 0) | REG_NOSUB);
 		CHKiRet(regexp.regexec(&preq, (char*) psz, 0, NULL, 0));
 		regexp.regfree(&preq);
 	} else {
-- 
cgit v1.2.3


From 42db7de5968d2db0fa855a9f029f6bccc0a30650 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Wed, 4 Mar 2009 18:46:06 +0100
Subject: fixed newly introduced memory leak

(bug created 30 minutes ago or so)
---
 runtime/stringbuf.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 8d52834d..a5dc625a 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -707,12 +707,15 @@ int rsCStrCaseInsensitveStartsWithSzStr(cstr_t *pCS1, uchar *psz, size_t iLenSz)
 rsRetVal rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz, int iType)
 {
 	regex_t preq;
+	int ret;
 	DEFiRet;
 
 	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
 		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), (iType == 1 ? REG_EXTENDED : 0) | REG_NOSUB);
-		CHKiRet(regexp.regexec(&preq, (char*) psz, 0, NULL, 0));
+		ret = regexp.regexec(&preq, (char*) psz, 0, NULL, 0);
 		regexp.regfree(&preq);
+		if(ret != 0)
+			ABORT_FINALIZE(RS_RET_NOT_FOUND);
 	} else {
 		ABORT_FINALIZE(RS_RET_NOT_FOUND);
 	}
-- 
cgit v1.2.3


From a86e42028afeba1daca262b590bfd49d9c393b90 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Thu, 2 Apr 2009 16:16:57 +0200
Subject: improved performance of regexp-based filters

Thanks to Arnaud Cornet for providing the idea and initial patch.
---
 runtime/stringbuf.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index a5dc625a..c0a19ae4 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -724,6 +724,36 @@ finalize_it:
 	RETiRet;
 }
 
+/* same as above, only not braindead */
+int rsCStrSzStrMatchRegexCache(cstr_t *pCS1, uchar *psz, void **rc)
+{
+   int ret;
+
+   BEGINfunc
+
+   if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
+      regex_t **cache = rc;
+      if (*cache == NULL) {
+         *cache = calloc(sizeof(regex_t), 1);
+         regexp.regcomp(*cache, (char*) rsCStrGetSzStr(pCS1), 0);
+      }
+      ret = regexp.regexec(*cache, (char*) psz, 0, NULL, 0);
+   } else {
+      ret = 1; /* simulate "not found" */
+   }
+
+   ENDfunc
+   return ret;
+}
+
+/* free a cached compiled regex */
+void rsRegexDestruct(void **rc) {
+   regex_t **cache = rc;
+   regexp.regfree(*cache);
+   free(*cache);
+   *cache = NULL;
+}
+
 
 /* compare a rsCStr object with a classical sz string.  This function
  * is almost identical to rsCStrZsStrCmp(), but it also takes an offset
-- 
cgit v1.2.3


From 1d16216aa326296673cc8520a8df351c4d492dfe Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Thu, 2 Apr 2009 16:51:53 +0200
Subject: streamlined regex patch

- abided to code conventions
- fixed a potential segfault when regex library can not
  be loaded
---
 runtime/stringbuf.c | 61 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 24 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index c0a19ae4..4a7cc4bd 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -725,33 +725,46 @@ finalize_it:
 }
 
 /* same as above, only not braindead */
-int rsCStrSzStrMatchRegexCache(cstr_t *pCS1, uchar *psz, void **rc)
+int rsCStrSzStrMatchRegexCache(cstr_t *pCS1, uchar *psz, void *rc)
 {
-   int ret;
-
-   BEGINfunc
-
-   if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
-      regex_t **cache = rc;
-      if (*cache == NULL) {
-         *cache = calloc(sizeof(regex_t), 1);
-         regexp.regcomp(*cache, (char*) rsCStrGetSzStr(pCS1), 0);
-      }
-      ret = regexp.regexec(*cache, (char*) psz, 0, NULL, 0);
-   } else {
-      ret = 1; /* simulate "not found" */
-   }
-
-   ENDfunc
-   return ret;
+	int ret;
+	regex_t **cache = (regex_t**) rc;
+
+	BEGINfunc
+
+	assert(cache != NULL);
+
+	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
+		if (*cache == NULL) {
+			*cache = calloc(sizeof(regex_t), 1);
+			regexp.regcomp(*cache, (char*) rsCStrGetSzStr(pCS1), 0);
+		}
+		ret = regexp.regexec(*cache, (char*) psz, 0, NULL, 0);
+	} else {
+		ret = 1; /* simulate "not found" */
+	}
+
+	ENDfunc
+	return ret;
 }
 
-/* free a cached compiled regex */
-void rsRegexDestruct(void **rc) {
-   regex_t **cache = rc;
-   regexp.regfree(*cache);
-   free(*cache);
-   *cache = NULL;
+
+/* free a cached compiled regex
+ * Caller must provide a pointer to a buffer that was created by
+ * rsCStrSzStrMatchRegexCache()
+ */
+void rsCStrRegexDestruct(void *rc)
+{
+	regex_t **cache = rc;
+	
+	assert(cache != NULL);
+	assert(*cache != NULL);
+
+	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
+		regexp.regfree(*cache);
+		free(*cache);
+		*cache = NULL;
+	}
 }
 
 
-- 
cgit v1.2.3


From 4ab540e3ba25a13fd079490ac52438e55dc92672 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Thu, 2 Apr 2009 17:54:48 +0200
Subject: fully integrated regex patch

Now have removed the previous method, as really nobody should call
it any longer (and now nobody does ;)). Also did some other cleanup.
---
 runtime/stringbuf.c | 41 +++++++++++++----------------------------
 1 file changed, 13 insertions(+), 28 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 4a7cc4bd..35ec44c6 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -703,49 +703,34 @@ int rsCStrCaseInsensitveStartsWithSzStr(cstr_t *pCS1, uchar *psz, size_t iLenSz)
  * never is a \0 *inside* a property string.
  * Note that the function returns -1 if regexp functionality is not available.
  * rgerhards: 2009-03-04: ERE support added, via parameter iType: 0 - BRE, 1 - ERE
+ * Arnaud Cornet/rgerhards: 2009-04-02: performance improvement by caching compiled regex
+ * If a caller does not need the cached version, it must still provide memory for it
+ * and must call rsCStrRegexDestruct() afterwards.
  */
-rsRetVal rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz, int iType)
+rsRetVal rsCStrSzStrMatchRegex(cstr_t *pCS1, uchar *psz, int iType, void *rc)
 {
-	regex_t preq;
+	regex_t **cache = (regex_t**) rc;
 	int ret;
 	DEFiRet;
 
-	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
-		regexp.regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), (iType == 1 ? REG_EXTENDED : 0) | REG_NOSUB);
-		ret = regexp.regexec(&preq, (char*) psz, 0, NULL, 0);
-		regexp.regfree(&preq);
-		if(ret != 0)
-			ABORT_FINALIZE(RS_RET_NOT_FOUND);
-	} else {
-		ABORT_FINALIZE(RS_RET_NOT_FOUND);
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-/* same as above, only not braindead */
-int rsCStrSzStrMatchRegexCache(cstr_t *pCS1, uchar *psz, void *rc)
-{
-	int ret;
-	regex_t **cache = (regex_t**) rc;
-
-	BEGINfunc
-
+	assert(pCS1 != NULL);
+	assert(psz != NULL);
 	assert(cache != NULL);
 
 	if(objUse(regexp, LM_REGEXP_FILENAME) == RS_RET_OK) {
 		if (*cache == NULL) {
 			*cache = calloc(sizeof(regex_t), 1);
-			regexp.regcomp(*cache, (char*) rsCStrGetSzStr(pCS1), 0);
+			regexp.regcomp(*cache, (char*) rsCStrGetSzStr(pCS1), (iType == 1 ? REG_EXTENDED : 0) | REG_NOSUB);
 		}
 		ret = regexp.regexec(*cache, (char*) psz, 0, NULL, 0);
+		if(ret != 0)
+			ABORT_FINALIZE(RS_RET_NOT_FOUND);
 	} else {
-		ret = 1; /* simulate "not found" */
+		ABORT_FINALIZE(RS_RET_NOT_FOUND);
 	}
 
-	ENDfunc
-	return ret;
+finalize_it:
+	RETiRet;
 }
 
 
-- 
cgit v1.2.3


From 015d17ca70e81ad998e32cdfeed3cd925fd7dedc Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Tue, 16 Jun 2009 08:46:45 +0200
Subject: some performance optimizations

- saved gettimeofday() calls in imtcp (and increased reception buffer)
- somewhat optimized stringbuf.c
- some other optimizations
---
 runtime/stringbuf.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 07256fab..f3d9aa48 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -299,10 +299,8 @@ rsRetVal rsCStrSetSzStr(cstr_t *pThis, uchar *pszNew)
 {
 	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
 
-	if(pThis->pBuf != NULL)
-		free(pThis->pBuf);
-	if(pThis->pszBuf != NULL)
-		free(pThis->pszBuf);
+	free(pThis->pBuf);
+	free(pThis->pszBuf);
 	if(pszNew == NULL) {
 		pThis->iStrLen = 0;
 		pThis->iBufSize = 0;
-- 
cgit v1.2.3


From f7579e68a67364c8040966be57c2eae4c9550ee5 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Tue, 16 Jun 2009 11:36:05 +0200
Subject: done various optimizations to the stringbuf and its users

---
 runtime/stringbuf.c | 221 ++++++++++++++++++----------------------------------
 1 file changed, 77 insertions(+), 144 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index f3d9aa48..a2d9c599 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -6,8 +6,9 @@
  * Please see syslogd.c for license information.
  * All functions in this "class" start with rsCStr (rsyslog Counted String).
  * begun 2005-09-07 rgerhards
+ * did some optimization (read: bugs!) rgerhards, 2009-06-16
  *
- * Copyright (C) 2007-2008 by Rainer Gerhards and Adiscon GmbH
+ * Copyright (C) 2007-2009 by Rainer Gerhards and Adiscon GmbH
  *
  * This file is part of the rsyslog runtime library.
  *
@@ -40,6 +41,7 @@
 #include "regexp.h"
 #include "obj.h"
 
+uchar*  rsCStrGetSzStr(cstr_t *pThis);
 
 /* ################################################################# *
  * private members                                                   *
@@ -54,15 +56,14 @@ DEFobjCurrIf(regexp)
  * ################################################################# */
 
 
-rsRetVal rsCStrConstruct(cstr_t **ppThis)
+rsRetVal cstrConstruct(cstr_t **ppThis)
 {
 	DEFiRet;
 	cstr_t *pThis;
 
 	ASSERT(ppThis != NULL);
 
-	if((pThis = (cstr_t*) calloc(1, sizeof(cstr_t))) == NULL)
-		ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
+	CHKmalloc(pThis = (cstr_t*) calloc(1, sizeof(cstr_t)));
 
 	rsSETOBJTYPE(pThis, OIDrsCStr);
 	pThis->pBuf = NULL;
@@ -89,7 +90,7 @@ rsRetVal rsCStrConstructFromszStr(cstr_t **ppThis, uchar *sz)
 
 	CHKiRet(rsCStrConstruct(&pThis));
 
-	pThis->iBufSize = pThis->iStrLen = strlen((char*)(char *) sz);
+	pThis->iBufSize = pThis->iStrLen = strlen((char *) sz);
 	if((pThis->pBuf = (uchar*) malloc(sizeof(uchar) * pThis->iStrLen)) == NULL) {
 		RSFREEOBJ(pThis);
 		ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
@@ -137,24 +138,8 @@ void rsCStrDestruct(cstr_t **ppThis)
 {
 	cstr_t *pThis = *ppThis;
 
-	/* rgerhards 2005-10-19: The free of pBuf was contained in conditional compilation.
-	 * The code was only compiled if STRINGBUF_TRIM_ALLOCSIZE was set to 1. I honestly
-	 * do not know why it was so, I think it was an artifact. Anyhow, I have changed this
-	 * now. Should there any issue occur, this comment hopefully will shed some light 
-	 * on what happened. I re-verified, and this function has never before been called
-	 * by anyone. So changing it can have no impact for obvious reasons...
-	 *
-	 * rgerhards, 2008-02-20: I changed the interface to the new calling conventions, where
-	 * the destructor receives a pointer to the object, so that it can set it to NULL.
-	 */
-	if(pThis->pBuf != NULL) {
-		free(pThis->pBuf);
-	}
-
-	if(pThis->pszBuf != NULL) {
-		free(pThis->pszBuf);
-	}
-
+	free(pThis->pBuf);
+	free(pThis->pszBuf);
 	RSFREEOBJ(pThis);
 	*ppThis = NULL;
 }
@@ -166,12 +151,14 @@ void rsCStrDestruct(cstr_t **ppThis)
  * allocated. In practice, a bit more is allocated because we envision that
  * some more characters may be added after these.
  * rgerhards, 2008-01-07
+ * changed to utilized realloc() -- rgerhards, 2009-06-16
  */
-static rsRetVal rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
+static rsRetVal
+rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
 {
-	DEFiRet;
 	uchar *pNewBuf;
 	size_t iNewSize;
+	DEFiRet;
 
 	/* first compute the new size needed */
 	if(iMinNeeded > pThis->iAllocIncrement) {
@@ -187,15 +174,9 @@ static rsRetVal rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
 	}
 	iNewSize += pThis->iBufSize; /* add current size */
 
-	/* and then allocate and copy over */
 	/* DEV debugging only: dbgprintf("extending string buffer, old %d, new %d\n", pThis->iBufSize, iNewSize); */
-	if((pNewBuf = (uchar*) malloc(iNewSize * sizeof(uchar))) == NULL)
-		ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
-	memcpy(pNewBuf, pThis->pBuf, pThis->iBufSize);
+	CHKmalloc(pNewBuf = (uchar*) realloc(pThis->pBuf, iNewSize * sizeof(uchar)));
 	pThis->iBufSize = iNewSize;
-	if(pThis->pBuf != NULL) {
-		free(pThis->pBuf);
-	}
 	pThis->pBuf = pNewBuf;
 
 finalize_it:
@@ -288,6 +269,29 @@ finalize_it:
 }
 
 
+/* NEW VARIANT
+ * Append a character to the current string object. This may only be done until
+ * cstrFinalize() is called.
+ * rgerhards, 2009-06-16
+ */
+rsRetVal cstrAppendChar(cstr_t *pThis, uchar c)
+{
+	DEFiRet;
+
+	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
+
+	if(pThis->iStrLen >= pThis->iBufSize) {  
+		CHKiRet(rsCStrExtendBuf(pThis, 1)); /* need more memory! */
+	}
+
+	/* ok, when we reach this, we have sufficient memory */
+	*(pThis->pBuf + pThis->iStrLen++) = c;
+
+finalize_it:
+	RETiRet;
+}
+
+
 /* Sets the string object to the classigal sz-string provided.
  * Any previously stored vlaue is discarded. If a NULL pointer
  * the the new value (pszNew) is provided, an empty string is
@@ -388,35 +392,42 @@ uchar*  rsCStrGetSzStr(cstr_t *pThis)
 }
 
 
+/* NEW VERSION for interface without separate psz buffer! */
+/* Returns the cstr data as a classical C sz string. We use that the 
+ * Finalizer did properly terminate our string (but we may stil be NULL).
+ * So it is vital that the finalizer is called BEFORe this function here!
+ * The caller must not free or otherwise manipulate the returned string and must not
+ * destroy the CStr object as long as the ascii string is used.
+ * This function may return NULL, if the string is currently NULL. This
+ * is a feature, not a bug. If you need non-NULL in any case, use
+ * cstrGetSzStrNoNULL() instead.
+ * Note that due to the new single-buffer interface this function almost does nothing!
+ * rgerhards, 2006-09-16
+ */
+uchar*  cstrGetSzStr(cstr_t *pThis)
+{
+	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
+	return(pThis->pBuf);
+}
+
+
 /* Converts the CStr object to a classical zero-terminated C string,
  * returns that string and destroys the CStr object. The returned string
  * MUST be freed by the caller. The function might return NULL if
  * no memory can be allocated.
  *
- * TODO:
- * This function should at some time become special. The base idea is to
- * add one extra byte to the end of the regular buffer, so that we can
- * convert it to an szString without the need to copy. The extra memory
- * footprint is not hefty, but the performance gain is potentially large.
- * To get it done now, I am not doing the optimiziation right now.
- * rgerhards, 2005-09-07
+ * This is the NEW replacement for rsCStrConvSzStrAndDestruct which does
+ * no longer utilize a special buffer but soley works on pBuf (and also
+ * assumes that cstrFinalize had been called).
  *
- * rgerhards, 2007-09-04: I have changed the interface of this function. It now
- * returns an rsRetVal, so that we can communicate back if we have an error.
- * Using the standard method is much better than returning NULL. Secondly, NULL
- * was not actually an error - it was in indication if the string was empty.
- * This was needed in some parts of the code, in others not. I have now added
- * a second parameter to specify what the caller needs. I hope these changes
- * will make it less likely that the function is called incorrectly, what
- * previously happend quite often and was the cause of a number of program
- * aborts. So the parameters are now:
+ * Parameters are as follows:
  * pointer to the object, pointer to string-pointer to receive string and
  * bRetNULL: 0 - must not return NULL on empty string, return "" in that
  * case, 1 - return NULL instead of an empty string.
  * PLEASE NOTE: the caller must free the memory returned in ppSz in any case
  * (except, of course, if it is NULL).
  */
-rsRetVal rsCStrConvSzStrAndDestruct(cstr_t *pThis, uchar **ppSz, int bRetNULL)
+rsRetVal cstrConvSzStrAndDestruct(cstr_t *pThis, uchar **ppSz, int bRetNULL)
 {
 	DEFiRet;
 	uchar* pRetBuf;
@@ -427,14 +438,13 @@ rsRetVal rsCStrConvSzStrAndDestruct(cstr_t *pThis, uchar **ppSz, int bRetNULL)
 
 	if(pThis->pBuf == NULL) {
 		if(bRetNULL == 0) {
-			if((pRetBuf = malloc(sizeof(uchar))) == NULL)
-				ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
+			CHKmalloc(pRetBuf = malloc(sizeof(uchar)));
 			*pRetBuf = '\0';
 		} else {
 			pRetBuf = NULL;
 		}
 	} else
-		pRetBuf = rsCStrGetSzStr(pThis);
+		pRetBuf = pThis->pBuf;
 	
 	*ppSz = pRetBuf;
 
@@ -443,60 +453,39 @@ finalize_it:
 	 * that we can NOT use the rsCStrDestruct function as it would
 	 * also free the sz String buffer, which we pass on to the user.
 	 */
-	if(pThis->pBuf != NULL)
-		free(pThis->pBuf);
 	RSFREEOBJ(pThis);
-	
 	RETiRet;
 }
 
 
-#if STRINGBUF_TRIM_ALLOCSIZE == 1
-	/* Only in this mode, we need to trim the string. To do
-	 * so, we must allocate a new buffer of the exact 
-	 * string size, and then copy the old one over. 
-	 */
-	/* WARNING
-	 * STRINGBUF_TRIM_ALLOCSIZE can, in theory, be used to trim
-	 * memory buffers. This part of the code was inherited from
-	 * liblogging (where it is used in a different context) but
-	 * never put to use in rsyslog. The reason is that it is hardly
-	 * imaginable where the extra performance cost is worth the save
-	 * in memory alloc. Then Anders Blomdel rightfully pointed out that
-	 * the code does not work at all - and nobody even know that it
-	 * probably shouldn't. Rather than removing, I deciced to somewhat
-	 * fix the code, so that this feature may be enabled if somebody
-	 * really has a need for it. Be warned, however, that I NEVER
-	 * tested the fix. So if you intend to use this feature, you must
-	 * do full testing before you rely on it. -- rgerhards, 2008-02-12
-	 */
-rsRetVal  rsCStrFinish(cstr_t __attribute__((unused)) *pThis)
+/* Finalize the string object. This must be called after all data is added to it
+ * but before that data is used.
+ * rgerhards, 2009-06-16
+ */
+rsRetVal
+cstrFinalize(cstr_t *pThis)
 {
 	DEFiRet;
-	uchar* pBuf;
 	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
+	
+	assert(pThis->bIsFinalized == 0);
 
-	if((pBuf = malloc((pThis->iStrLen) * sizeof(uchar))) == NULL)
-	{	/* OK, in this case we use the previous buffer. At least
-		 * we have it ;)
-		 */
-	}
-	else
-	{	/* got the new buffer, so let's use it */
-		memcpy(pBuf, pThis->pBuf, pThis->iStrLen);
-		pThis->pBuf = pBuf;
+	if(pThis->iStrLen > 0) {
+		/* terminate string only if one exists */
+		CHKiRet(cstrAppendChar(pThis, '\0'));
+		--pThis->iStrLen;	/* do NOT count the \0 byte */
 	}
+	pThis->bIsFinalized = 1;
 
+finalize_it:
 	RETiRet;
 }
-#endif 	/* #if STRINGBUF_TRIM_ALLOCSIZE == 1 */
 
 
 void rsCStrSetAllocIncrement(cstr_t *pThis, int iNewIncrement)
 {
 	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
 	assert(iNewIncrement > 0);
-
 	pThis->iAllocIncrement = iNewIncrement;
 }
 
@@ -1025,56 +1014,6 @@ int rsCStrCaseInsensitiveLocateInSzStr(cstr_t *pThis, uchar *sz)
 }
 
 
-#if 0	 /* read comment below why this is commented out. In short: for future use! */
-/* locate the first occurence of a standard sz string inside a rsCStr object.
- * Returns the offset (0-bound) of this first occurrence. If not found, -1 is
- * returned.
- * rgerhards 2005-09-19
- * WARNING: I accidently created this function (I later noticed I didn't relly
- *          need it... I will not remove the function, as it probably is useful
- *          some time later. However, it is not fully tested, so start with testing
- *          it before you put it to first use).
- */
-int rsCStrLocateSzStr(cstr_t *pThis, uchar *sz)
-{
-	int iLenSz;
-	int i;
-	int iMax;
-	int bFound;
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-	
-	if(sz == NULL)
-		return 0;
-
-	iLenSz = strlen((char*)sz);
-	if(iLenSz == 0)
-		return 0;
-	
-	/* compute the largest index where a match could occur - after all,
-	 * the to-be-located string must be able to be present in the 
-	 * searched string (it needs its size ;)).
-	 */
-	iMax = pThis->iStrLen - iLenSz;
-
-	bFound = 0;
-	i = 0;
-	while(i  < iMax && !bFound) {
-		int iCheck;
-		uchar *pComp = pThis->pBuf + i;
-		for(iCheck = 0 ; iCheck < iLenSz ; ++iCheck)
-			if(*(pComp + iCheck) != *(sz + iCheck))
-				break;
-		if(iCheck == iLenSz)
-			bFound = 1; /* found! - else it wouldn't be equal */
-		else
-			++i; /* on to the next try */
-	}
-
-	return(bFound ? i : -1);
-}
-#endif /* end comment out */
-
-
 /* our exit function. TODO: remove once converted to a class
  * rgerhards, 2008-03-11
  */
@@ -1098,11 +1037,5 @@ finalize_it:
 }
 
 
-/*
- * Local variables:
- *  c-indent-level: 8
- *  c-basic-offset: 8
- *  tab-width: 8
- * End:
- * vi:set ai:
+/* vi:set ai:
  */
-- 
cgit v1.2.3


From d2d54013aebb756169182ed8716b142d27134a70 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Wed, 17 Jun 2009 15:22:13 +0200
Subject: going forward in moving string-handling functions to new interface...

---
 runtime/stringbuf.c | 74 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 30 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index a2d9c599..e7fa8c41 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -1,3 +1,4 @@
+#include <stdio.h>
 /* This is the byte-counted string class for rsyslog. It is a replacement
  * for classical \0 terminated string functions. We introduce it in
  * the hope it will make the program more secure, obtain some performance
@@ -157,7 +158,7 @@ static rsRetVal
 rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
 {
 	uchar *pNewBuf;
-	size_t iNewSize;
+	unsigned short iNewSize;
 	DEFiRet;
 
 	/* first compute the new size needed */
@@ -224,7 +225,7 @@ rsRetVal rsCStrAppendStr(cstr_t *pThis, uchar* psz)
 /* append the contents of one cstr_t object to another
  * rgerhards, 2008-02-25
  */
-rsRetVal rsCStrAppendCStr(cstr_t *pThis, cstr_t *pstrAppend)
+rsRetVal cstrAppendCStr(cstr_t *pThis, cstr_t *pstrAppend)
 {
 	return rsCStrAppendStrWithLen(pThis, pstrAppend->pBuf, pstrAppend->iStrLen);
 }
@@ -245,32 +246,7 @@ finalize_it:
 }
 
 
-rsRetVal rsCStrAppendChar(cstr_t *pThis, uchar c)
-{
-	DEFiRet;
-
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
-	if(pThis->iStrLen >= pThis->iBufSize) {  
-		CHKiRet(rsCStrExtendBuf(pThis, 1)); /* need more memory! */
-	}
-
-	/* ok, when we reach this, we have sufficient memory */
-	*(pThis->pBuf + pThis->iStrLen++) = c;
-
-	/* check if we need to invalidate an sz representation! */
-	if(pThis->pszBuf != NULL) {
-		free(pThis->pszBuf);
-		pThis->pszBuf = NULL;
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-
-/* NEW VARIANT
- * Append a character to the current string object. This may only be done until
+/* Append a character to the current string object. This may only be done until
  * cstrFinalize() is called.
  * rgerhards, 2009-06-16
  */
@@ -392,7 +368,24 @@ uchar*  rsCStrGetSzStr(cstr_t *pThis)
 }
 
 
-/* NEW VERSION for interface without separate psz buffer! */
+/* Converts the CStr object to a classical sz string and returns that.
+ * Same restrictions as in cstrGetSzStr() applies (see there!). This
+ * function here guarantees that a valid string is returned, even if
+ * the CStr object currently holds a NULL pointer string buffer. If so,
+ * "" is returned.
+ * rgerhards 2005-10-19
+ * WARNING: The returned pointer MUST NOT be freed, as it may be
+ *          obtained from that constant memory pool (in case of NULL!)
+ */
+uchar*  cstrGetSzStrNoNULL(cstr_t *pThis)
+{
+	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
+	if(pThis->pBuf == NULL)
+		return (uchar*) "";
+	else
+		return cstrGetSzStr(pThis);
+}
+
 /* Returns the cstr data as a classical C sz string. We use that the 
  * Finalizer did properly terminate our string (but we may stil be NULL).
  * So it is vital that the finalizer is called BEFORe this function here!
@@ -497,7 +490,7 @@ void rsCStrSetAllocIncrement(cstr_t *pThis, int iNewIncrement)
  * This is due to performance reasons.
  */
 #ifndef NDEBUG
-int rsCStrLen(cstr_t *pThis)
+int cstrLen(cstr_t *pThis)
 {
 	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
 	return(pThis->iStrLen);
@@ -548,6 +541,27 @@ rsRetVal rsCStrTrimTrailingWhiteSpace(cstr_t *pThis)
 	return RS_RET_OK;
 }
 
+/* Trim trailing whitespace from a given string
+ */
+rsRetVal cstrTrimTrailingWhiteSpace(cstr_t *pThis)
+{
+	register int i;
+	register uchar *pC;
+	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
+
+	i = pThis->iStrLen;
+	pC = pThis->pBuf + i - 1;
+	while(i > 0 && isspace((int)*pC)) {
+		--pC;
+		--i;
+	}
+	/* i now is the new string length! */
+	pThis->iStrLen = i;
+	pThis->pBuf[pThis->iStrLen] = '0'; /* we always have this space */
+
+	return RS_RET_OK;
+}
+
 /* compare two string objects - works like strcmp(), but operates
  * on CStr objects. Please note that this version here is
  * faster in the majority of cases, simply because it can
-- 
cgit v1.2.3


From 3abf567d2b57014381eda49018a0e2c21fa1b853 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Fri, 19 Jun 2009 16:07:17 +0200
Subject: optimized template string generation

---
 runtime/stringbuf.c | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index e7fa8c41..d3ddf33a 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -461,14 +461,11 @@ cstrFinalize(cstr_t *pThis)
 	DEFiRet;
 	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
 	
-	assert(pThis->bIsFinalized == 0);
-
 	if(pThis->iStrLen > 0) {
 		/* terminate string only if one exists */
 		CHKiRet(cstrAppendChar(pThis, '\0'));
 		--pThis->iStrLen;	/* do NOT count the \0 byte */
 	}
-	pThis->bIsFinalized = 1;
 
 finalize_it:
 	RETiRet;
-- 
cgit v1.2.3


From 464dcf2339634a2cda0244011abe7ed8f6ed2fe5 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Thu, 25 Jun 2009 18:44:48 +0200
Subject: some more stringbuffer optimization

---
 runtime/stringbuf.c | 45 ++++++---------------------------------------
 1 file changed, 6 insertions(+), 39 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index d3ddf33a..f3824831 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -71,7 +71,6 @@ rsRetVal cstrConstruct(cstr_t **ppThis)
 	pThis->pszBuf = NULL;
 	pThis->iBufSize = 0;
 	pThis->iStrLen = 0;
-	pThis->iAllocIncrement = RS_STRINGBUF_ALLOC_INCREMENT;
 	*ppThis = pThis;
 
 finalize_it:
@@ -154,7 +153,7 @@ void rsCStrDestruct(cstr_t **ppThis)
  * rgerhards, 2008-01-07
  * changed to utilized realloc() -- rgerhards, 2009-06-16
  */
-static rsRetVal
+rsRetVal
 rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
 {
 	uchar *pNewBuf;
@@ -162,16 +161,16 @@ rsCStrExtendBuf(cstr_t *pThis, size_t iMinNeeded)
 	DEFiRet;
 
 	/* first compute the new size needed */
-	if(iMinNeeded > pThis->iAllocIncrement) {
-		/* we allocate "n" iAllocIncrements. Usually, that should
+	if(iMinNeeded > RS_STRINGBUF_ALLOC_INCREMENT) {
+		/* we allocate "n" ALLOC_INCREMENTs. Usually, that should
 		 * leave some room after the absolutely needed one. It also
 		 * reduces memory fragmentation. Note that all of this are
 		 * integer operations (very important to understand what is
 		 * going on)! Parenthesis are for better readibility.
 		 */
-		iNewSize = ((iMinNeeded / pThis->iAllocIncrement) + 1) * pThis->iAllocIncrement;
+		iNewSize = (iMinNeeded / RS_STRINGBUF_ALLOC_INCREMENT + 1) * RS_STRINGBUF_ALLOC_INCREMENT;
 	} else {
-		iNewSize = pThis->iBufSize + pThis->iAllocIncrement;
+		iNewSize = pThis->iBufSize + RS_STRINGBUF_ALLOC_INCREMENT;
 	}
 	iNewSize += pThis->iBufSize; /* add current size */
 
@@ -246,33 +245,10 @@ finalize_it:
 }
 
 
-/* Append a character to the current string object. This may only be done until
- * cstrFinalize() is called.
- * rgerhards, 2009-06-16
- */
-rsRetVal cstrAppendChar(cstr_t *pThis, uchar c)
-{
-	DEFiRet;
-
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
-	if(pThis->iStrLen >= pThis->iBufSize) {  
-		CHKiRet(rsCStrExtendBuf(pThis, 1)); /* need more memory! */
-	}
-
-	/* ok, when we reach this, we have sufficient memory */
-	*(pThis->pBuf + pThis->iStrLen++) = c;
-
-finalize_it:
-	RETiRet;
-}
-
-
 /* Sets the string object to the classigal sz-string provided.
  * Any previously stored vlaue is discarded. If a NULL pointer
  * the the new value (pszNew) is provided, an empty string is
- * created (this is NOT an error!). Property iAllocIncrement is
- * not modified by this function.
+ * created (this is NOT an error!).
  * rgerhards, 2005-10-18
  */
 rsRetVal rsCStrSetSzStr(cstr_t *pThis, uchar *pszNew)
@@ -290,7 +266,6 @@ rsRetVal rsCStrSetSzStr(cstr_t *pThis, uchar *pszNew)
 		pThis->iStrLen = strlen((char*)pszNew);
 		pThis->iBufSize = pThis->iStrLen;
 		pThis->pszBuf = NULL;
-		/* iAllocIncrement is NOT modified! */
 
 		/* now save the new value */
 		if((pThis->pBuf = (uchar*) malloc(sizeof(uchar) * pThis->iStrLen)) == NULL) {
@@ -472,14 +447,6 @@ finalize_it:
 }
 
 
-void rsCStrSetAllocIncrement(cstr_t *pThis, int iNewIncrement)
-{
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-	assert(iNewIncrement > 0);
-	pThis->iAllocIncrement = iNewIncrement;
-}
-
-
 /* return the length of the current string
  * 2005-09-09 rgerhards
  * Please note: this is only a function in a debug build.
-- 
cgit v1.2.3


From 1f361c5eb9028e7750a1c84811c9c3ac5cdd0a31 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Fri, 26 Jun 2009 14:22:00 +0200
Subject: some optimization, declared some frequently called small stringbuf
 functions inline

---
 runtime/stringbuf.c | 57 -----------------------------------------------------
 1 file changed, 57 deletions(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index f3824831..88f5a3a2 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -343,42 +343,6 @@ uchar*  rsCStrGetSzStr(cstr_t *pThis)
 }
 
 
-/* Converts the CStr object to a classical sz string and returns that.
- * Same restrictions as in cstrGetSzStr() applies (see there!). This
- * function here guarantees that a valid string is returned, even if
- * the CStr object currently holds a NULL pointer string buffer. If so,
- * "" is returned.
- * rgerhards 2005-10-19
- * WARNING: The returned pointer MUST NOT be freed, as it may be
- *          obtained from that constant memory pool (in case of NULL!)
- */
-uchar*  cstrGetSzStrNoNULL(cstr_t *pThis)
-{
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-	if(pThis->pBuf == NULL)
-		return (uchar*) "";
-	else
-		return cstrGetSzStr(pThis);
-}
-
-/* Returns the cstr data as a classical C sz string. We use that the 
- * Finalizer did properly terminate our string (but we may stil be NULL).
- * So it is vital that the finalizer is called BEFORe this function here!
- * The caller must not free or otherwise manipulate the returned string and must not
- * destroy the CStr object as long as the ascii string is used.
- * This function may return NULL, if the string is currently NULL. This
- * is a feature, not a bug. If you need non-NULL in any case, use
- * cstrGetSzStrNoNULL() instead.
- * Note that due to the new single-buffer interface this function almost does nothing!
- * rgerhards, 2006-09-16
- */
-uchar*  cstrGetSzStr(cstr_t *pThis)
-{
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-	return(pThis->pBuf);
-}
-
-
 /* Converts the CStr object to a classical zero-terminated C string,
  * returns that string and destroys the CStr object. The returned string
  * MUST be freed by the caller. The function might return NULL if
@@ -426,27 +390,6 @@ finalize_it:
 }
 
 
-/* Finalize the string object. This must be called after all data is added to it
- * but before that data is used.
- * rgerhards, 2009-06-16
- */
-rsRetVal
-cstrFinalize(cstr_t *pThis)
-{
-	DEFiRet;
-	rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-	
-	if(pThis->iStrLen > 0) {
-		/* terminate string only if one exists */
-		CHKiRet(cstrAppendChar(pThis, '\0'));
-		--pThis->iStrLen;	/* do NOT count the \0 byte */
-	}
-
-finalize_it:
-	RETiRet;
-}
-
-
 /* return the length of the current string
  * 2005-09-09 rgerhards
  * Please note: this is only a function in a debug build.
-- 
cgit v1.2.3


From f76881fff39b46630d95a8d8308f383bec1b8be8 Mon Sep 17 00:00:00 2001
From: Rainer Gerhards <rgerhards@adiscon.com>
Date: Wed, 1 Jul 2009 10:34:17 +0200
Subject: removed a debugging-left-over, caused compilation failure on some
 platforms

... because LARGFILE macros were not defined consistenly
---
 runtime/stringbuf.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'runtime/stringbuf.c')

diff --git a/runtime/stringbuf.c b/runtime/stringbuf.c
index 88f5a3a2..93995b38 100644
--- a/runtime/stringbuf.c
+++ b/runtime/stringbuf.c
@@ -1,4 +1,3 @@
-#include <stdio.h>
 /* This is the byte-counted string class for rsyslog. It is a replacement
  * for classical \0 terminated string functions. We introduce it in
  * the hope it will make the program more secure, obtain some performance
-- 
cgit v1.2.3