summaryrefslogtreecommitdiffstats
path: root/stringbuf.c
diff options
context:
space:
mode:
Diffstat (limited to 'stringbuf.c')
-rwxr-xr-xstringbuf.c754
1 files changed, 0 insertions, 754 deletions
diff --git a/stringbuf.c b/stringbuf.c
deleted file mode 100755
index 01467f4d..00000000
--- a/stringbuf.c
+++ /dev/null
@@ -1,754 +0,0 @@
-/* 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
- * and, most importantly, lay they foundation for syslog-protocol, which
- * requires strings to be able to handle embedded \0 characters.
- * Please see syslogd.c for license information.
- * All functions in this "class" start with rsCStr (rsyslog Counted String).
- * This code is placed under the GPL.
- * begun 2005-09-07 rgerhards
- */
-#include "config.h"
-
-#include <stdlib.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include <regex.h>
-#include "rsyslog.h"
-#include "stringbuf.h"
-#include "srUtils.h"
-
-
-/* ################################################################# *
- * private members *
- * ################################################################# */
-
-
-
-/* ################################################################# *
- * public members *
- * ################################################################# */
-
-
-rsCStrObj *rsCStrConstruct(void)
-{
- rsCStrObj *pThis;
-
- if((pThis = (rsCStrObj*) calloc(1, sizeof(rsCStrObj))) == NULL)
- return NULL;
-
- rsSETOBJTYPE(pThis, OIDrsCStr);
- pThis->pBuf = NULL;
- pThis->pszBuf = NULL;
- pThis->iBufSize = 0;
- pThis->iStrLen = 0;
- pThis->iAllocIncrement = RS_STRINGBUF_ALLOC_INCREMENT;
-
- return pThis;
-}
-
-/* construct from sz string
- * rgerhards 2005-09-15
- */
-rsRetVal rsCStrConstructFromszStr(rsCStrObj **ppThis, uchar *sz)
-{
- rsCStrObj *pThis;
-
- assert(ppThis != NULL);
-
- if((pThis = rsCStrConstruct()) == NULL)
- return RS_RET_OUT_OF_MEMORY;
-
- pThis->iBufSize = pThis->iStrLen = strlen((char*)(char *) sz);
- if((pThis->pBuf = (uchar*) malloc(sizeof(uchar) * pThis->iStrLen)) == NULL) {
- RSFREEOBJ(pThis);
- return RS_RET_OUT_OF_MEMORY;
- }
-
- /* we do NOT need to copy the \0! */
- memcpy(pThis->pBuf, sz, pThis->iStrLen);
-
- *ppThis = pThis;
- return RS_RET_OK;
-}
-
-/* construct from CStr object. only the counted string is
- * copied, not the szString.
- * rgerhards 2005-10-18
- */
-rsRetVal rsCStrConstructFromCStr(rsCStrObj **ppThis, rsCStrObj *pFrom)
-{
- rsCStrObj *pThis;
-
- assert(ppThis != NULL);
- rsCHECKVALIDOBJECT(pFrom, OIDrsCStr);
-
- if((pThis = rsCStrConstruct()) == NULL)
- return RS_RET_OUT_OF_MEMORY;
-
- pThis->iBufSize = pThis->iStrLen = pFrom->iStrLen;
- if((pThis->pBuf = (uchar*) malloc(sizeof(uchar) * pThis->iStrLen)) == NULL) {
- RSFREEOBJ(pThis);
- return RS_RET_OUT_OF_MEMORY;
- }
-
- /* copy properties */
- memcpy(pThis->pBuf, pFrom->pBuf, pThis->iStrLen);
-
- *ppThis = pThis;
- return RS_RET_OK;
-}
-
-
-void rsCStrDestruct(rsCStrObj *pThis)
-{
- /* 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...
- */
- if(pThis->pBuf != NULL) {
- free(pThis->pBuf);
- }
-
- if(pThis->pszBuf != NULL) {
- free(pThis->pszBuf);
- }
-
- RSFREEOBJ(pThis);
-}
-
-
-rsRetVal rsCStrAppendStrWithLen(rsCStrObj *pThis, uchar* psz, size_t iStrLen)
-{
- rsRetVal iRet;
- int iOldAllocInc;
-
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- assert(psz != NULL);
-
- /* we first check if the to-be-added string is larger than the
- * alloc increment. If so, we temporarily increase the alloc
- * increment to the length of the string. This will ensure that
- * one string copy will be needed at most. As this is a very
- * costly operation, it outweights the cost of the strlen((char*)) and
- * related stuff - at least I think so.
- * rgerhards 2005-09-22
- */
- /* We save the current alloc increment in any case, so we can just
- * overwrite it below, this is faster than any if-construct.
- */
- iOldAllocInc = pThis->iAllocIncrement;
- if(iStrLen > pThis->iAllocIncrement) {
- pThis->iAllocIncrement = iStrLen;
- }
-
- while(*psz)
- if((iRet = rsCStrAppendChar(pThis, *psz++)) != RS_RET_OK)
- return iRet;
-
- pThis->iAllocIncrement = iOldAllocInc; /* restore */
- return RS_RET_OK;
-}
-
-
-/* changed to be a wrapper to rsCStrAppendStrWithLen() so that
- * we can save some time when we have the length but do not
- * need to change existing code.
- * rgerhards, 2007-07-03
- */
-rsRetVal rsCStrAppendStr(rsCStrObj *pThis, uchar* psz)
-{
- return rsCStrAppendStrWithLen(pThis, psz, strlen((char*)(char*) psz));
-}
-
-
-rsRetVal rsCStrAppendInt(rsCStrObj *pThis, int i)
-{
- rsRetVal iRet;
- uchar szBuf[32];
-
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
- if((iRet = srUtilItoA((char*) szBuf, sizeof(szBuf), i)) != RS_RET_OK)
- return iRet;
-
- return rsCStrAppendStr(pThis, szBuf);
-}
-
-
-rsRetVal rsCStrAppendChar(rsCStrObj *pThis, uchar c)
-{
- uchar* pNewBuf;
-
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
- if(pThis->iStrLen >= pThis->iBufSize)
- { /* need more memory! */
- if((pNewBuf = (uchar*) malloc((pThis->iBufSize + pThis->iAllocIncrement) * sizeof(uchar))) == NULL)
- return RS_RET_OUT_OF_MEMORY;
- memcpy(pNewBuf, pThis->pBuf, pThis->iBufSize);
- pThis->iBufSize += pThis->iAllocIncrement;
- if(pThis->pBuf != NULL) {
- free(pThis->pBuf);
- }
- pThis->pBuf = pNewBuf;
- }
-
- /* 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;
- }
-
- return RS_RET_OK;
-}
-
-
-/* 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.
- * rgerhards, 2005-10-18
- */
-rsRetVal rsCStrSetSzStr(rsCStrObj *pThis, uchar *pszNew)
-{
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
- if(pThis->pBuf != NULL)
- free(pThis->pBuf);
- if(pThis->pszBuf != NULL)
- free(pThis->pszBuf);
- if(pszNew == NULL) {
- pThis->iStrLen = 0;
- pThis->iBufSize = 0;
- pThis->pBuf = NULL;
- pThis->pszBuf = NULL;
- } else {
- 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) {
- RSFREEOBJ(pThis);
- return RS_RET_OUT_OF_MEMORY;
- }
-
- /* we do NOT need to copy the \0! */
- memcpy(pThis->pBuf, pszNew, pThis->iStrLen);
- }
-
- return RS_RET_OK;
-}
-
-/* Converts the CStr object to a classical sz string and returns that.
- * Same restrictions as in rsCStrGetSzStr() 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* rsCStrGetSzStrNoNULL(rsCStrObj *pThis)
-{
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- if(pThis->pBuf == NULL)
- return (uchar*) "";
- else
- return rsCStrGetSzStr(pThis);
-}
-
-
-/* Converts the CStr object to a classical zero-terminated C string
- * and returns that string. The caller must not free it 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
- * rsCStrGetSzStrNoNULL() instead.
- * rgerhards, 2005-09-15
- */
-uchar* rsCStrGetSzStr(rsCStrObj *pThis)
-{
- size_t i;
-
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
- if(pThis->pBuf != NULL)
- if(pThis->pszBuf == NULL) {
- /* we do not yet have a usable sz version - so create it... */
- if((pThis->pszBuf = malloc((pThis->iStrLen + 1) * sizeof(uchar))) == NULL) {
- /* TODO: think about what to do - so far, I have no bright
- * idea... rgerhards 2005-09-07
- */
- }
- else { /* we can create the sz String */
- /* now copy it while doing a sanity check. The string might contain a
- * \0 byte. There is no way how a sz string can handle this. For
- * the time being, we simply replace it with space - something that
- * could definitely be improved (TODO).
- * 2005-09-15 rgerhards
- */
- for(i = 0 ; i < pThis->iStrLen ; ++i) {
- if(pThis->pBuf[i] == '\0')
- pThis->pszBuf[i] = ' ';
- else
- pThis->pszBuf[i] = pThis->pBuf[i];
- }
- /* write terminator... */
- pThis->pszBuf[i] = '\0';
- }
- }
-
- return(pThis->pszBuf);
-}
-
-
-/* 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
- *
- * 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:
- * 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(rsCStrObj *pThis, uchar **ppSz, int bRetNULL)
-{
- DEFiRet;
- uchar* pRetBuf;
-
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- assert(ppSz != NULL);
- assert(bRetNULL == 0 || bRetNULL == 1);
-
- if(pThis->pBuf == NULL) {
- if(bRetNULL == 0) {
- if((pRetBuf = malloc(sizeof(uchar))) == NULL)
- ABORT_FINALIZE(RS_RET_OUT_OF_MEMORY);
- *pRetBuf = '\0';
- } else {
- pRetBuf = NULL;
- }
- } else
- pRetBuf = rsCStrGetSzStr(pThis);
-
- *ppSz = pRetBuf;
-
-finalize_it:
- /* We got it, now free the object ourselfs. Please note
- * 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);
-
- return(iRet);
-}
-
-
-rsRetVal rsCStrFinish(rsCStrObj __attribute__((unused)) *pThis)
-{
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- return RS_RET_OK;
-}
-
-void rsCStrSetAllocIncrement(rsCStrObj *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.
- * For release builds, it is a macro defined in stringbuf.h.
- * This is due to performance reasons.
- */
-#ifndef NDEBUG
-int rsCStrLen(rsCStrObj *pThis)
-{
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- return(pThis->iStrLen);
-}
-#endif
-
-/* Truncate characters from the end of the string.
- * rgerhards 2005-09-15
- */
-rsRetVal rsCStrTruncate(rsCStrObj *pThis, size_t nTrunc)
-{
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
-
- if(pThis->iStrLen < nTrunc)
- return RS_TRUNCAT_TOO_LARGE;
-
- pThis->iStrLen -= nTrunc;
-
- if(pThis->pszBuf != NULL) {
- /* in this case, we adjust the psz representation
- * by writing a new \0 terminator - this is by far
- * the fastest way and outweights the additional memory
- * required. 2005-9-19 rgerhards.
- */
- pThis->pszBuf[pThis->iStrLen] = '\0';
- }
-
- return RS_RET_OK;
-}
-
-/* Trim trailing whitespace from a given string
- */
-rsRetVal rsCStrTrimTrailingWhiteSpace(rsCStrObj *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;
-
- 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
- * rely on StrLen.
- * rgerhards 2005-09-19
- * fixed bug, in which only the last byte was actually compared
- * in equal-size strings.
- * rgerhards, 2005-09-26
- */
-int rsCStrCStrCmp(rsCStrObj *pCS1, rsCStrObj *pCS2)
-{
- rsCHECKVALIDOBJECT(pCS1, OIDrsCStr);
- rsCHECKVALIDOBJECT(pCS2, OIDrsCStr);
- if(pCS1->iStrLen == pCS2->iStrLen)
- if(pCS1->iStrLen == 0)
- return 0; /* zero-sized string are equal ;) */
- else { /* we now have two non-empty strings of equal
- * length, so we need to actually check if they
- * are equal.
- */
- register size_t i;
- for(i = 0 ; i < pCS1->iStrLen ; ++i) {
- if(pCS1->pBuf[i] != pCS2->pBuf[i])
- return pCS1->pBuf[i] - pCS2->pBuf[i];
- }
- /* if we arrive here, the strings are equal */
- return 0;
- }
- else
- return pCS1->iStrLen - pCS2->iStrLen;
-}
-
-
-/* check if a sz-type string start with a CStr object. This function
- * is initially written to support the "startswith" property-filter
- * comparison operation. Maybe it also has other needs.
- * rgerhards 2005-10-19
- */
-int rsCStrSzStrStartsWithCStr(rsCStrObj *pCS1, uchar *psz, size_t iLenSz)
-{
- register int i;
- int iMax;
-
- rsCHECKVALIDOBJECT(pCS1, OIDrsCStr);
- assert(psz != NULL);
- assert(iLenSz == strlen((char*)psz)); /* just make sure during debugging! */
- if(iLenSz >= pCS1->iStrLen) {
- /* we need to checkusing pCS1->iStrLen charactes at maximum, thus
- * we move it to iMax.
- */
- iMax = pCS1->iStrLen;
- if(iMax == 0)
- return 0; /* yes, it starts with a zero-sized string ;) */
- else { /* we now have something to compare, so let's do it... */
- for(i = 0 ; i < iMax ; ++i) {
- if(psz[i] != pCS1->pBuf[i])
- return psz[i] - pCS1->pBuf[i];
- }
- /* if we arrive here, the string actually starts with pCS1 */
- return 0;
- }
- }
- else
- return -1; /* pCS1 is less then psz */
-}
-
-
-/* check if a CStr object starts with a sz-type string.
- * rgerhards 2005-09-26
- */
-int rsCStrStartsWithSzStr(rsCStrObj *pCS1, uchar *psz, size_t iLenSz)
-{
- register size_t i;
-
- rsCHECKVALIDOBJECT(pCS1, OIDrsCStr);
- assert(psz != NULL);
- assert(iLenSz == strlen((char*)psz)); /* just make sure during debugging! */
- if(pCS1->iStrLen >= iLenSz) {
- /* we are using iLenSz below, because we need to check
- * iLenSz characters at maximum (start with!)
- */
- if(iLenSz == 0)
- return 0; /* yes, it starts with a zero-sized string ;) */
- else { /* we now have something to compare, so let's do it... */
- for(i = 0 ; i < iLenSz ; ++i) {
- if(pCS1->pBuf[i] != psz[i])
- return pCS1->pBuf[i] - psz[i];
- }
- /* if we arrive here, the string actually starts with psz */
- return 0;
- }
- }
- else
- return -1; /* pCS1 is less then psz */
-}
-
-/* check if a CStr object matches a regex.
- * msamia@redhat.com 2007-07-12
- * @return returns 0 if matched
- * bug: doesn't work for CStr containing \0
- * rgerhards, 2007-07-16: bug is no real bug, because rsyslogd ensures there
- * never is a \0 *inside* a property string.
- */
-int rsCStrSzStrMatchRegex(rsCStrObj *pCS1, uchar *psz)
-{
- regex_t preq;
- regcomp(&preq, (char*) rsCStrGetSzStr(pCS1), 0);
- int iRet = regexec(&preq, (char*) psz, 0, NULL, 0);
- regfree(&preq);
- return iRet;
-}
-
-/* compare a rsCStr object with a classical sz string. This function
- * is almost identical to rsCStrZsStrCmp(), but it also takes an offset
- * to the CStr object from where the comparison is to start.
- * I have thought quite a while if it really makes sense to more or
- * less duplicate the code. After all, if you call it with an offset of
- * zero, the functionality is exactly the same. So it looks natural to
- * just have a single function. However, supporting the offset requires
- * some (few) additional integer operations. While they are few, they
- * happen at places in the code that is run very frequently. All in all,
- * I have opted for performance and thus duplicated the code. I hope
- * this is a good, or at least acceptable, compromise.
- * rgerhards, 2005-09-26
- * This function also has an offset-pointer which allows to
- * specify *where* the compare operation should begin in
- * the CStr. If everything is to be compared, it must be set
- * to 0. If some leading bytes are to be skipped, it must be set
- * to the first index that is to be compared. It must not be
- * set higher than the string length (this is considered a
- * program bug and will lead to unpredictable results and program aborts).
- * rgerhards 2005-09-26
- */
-int rsCStrOffsetSzStrCmp(rsCStrObj *pCS1, size_t iOffset, uchar *psz, size_t iLenSz)
-{
- rsCHECKVALIDOBJECT(pCS1, OIDrsCStr);
- assert(iOffset < pCS1->iStrLen);
- assert(psz != NULL);
- assert(iLenSz == strlen((char*)psz)); /* just make sure during debugging! */
- if((pCS1->iStrLen - iOffset) == iLenSz) {
- /* we are using iLenSz below, because the lengths
- * are equal and iLenSz is faster to access
- */
- if(iLenSz == 0)
- return 0; /* zero-sized strings are equal ;) */
- else { /* we now have two non-empty strings of equal
- * length, so we need to actually check if they
- * are equal.
- */
- register size_t i;
- for(i = 0 ; i < iLenSz ; ++i) {
- if(pCS1->pBuf[i+iOffset] != psz[i])
- return pCS1->pBuf[i+iOffset] - psz[i];
- }
- /* if we arrive here, the strings are equal */
- return 0;
- }
- }
- else
- return pCS1->iStrLen - iOffset - iLenSz;
-}
-
-
-/* compare a rsCStr object with a classical sz string.
- * Just like rsCStrCStrCmp, just for a different data type.
- * There must not only the sz string but also its length be
- * provided. If the caller does not know the length he can
- * call with
- * rsCstrSzStrCmp(pCS, psz, strlen((char*)psz));
- * we are not doing the strlen((char*)) ourselfs as the caller might
- * already know the length and in such cases we can save the
- * overhead of doing it one more time (strelen() is costly!).
- * The bottom line is that the provided length MUST be correct!
- * The to sz string pointer must not be NULL!
- * rgerhards 2005-09-26
- */
-int rsCStrSzStrCmp(rsCStrObj *pCS1, uchar *psz, size_t iLenSz)
-{
- rsCHECKVALIDOBJECT(pCS1, OIDrsCStr);
- assert(psz != NULL);
- assert(iLenSz == strlen((char*)psz)); /* just make sure during debugging! */
- if(pCS1->iStrLen == iLenSz)
- /* we are using iLenSz below, because the lengths
- * are equal and iLenSz is faster to access
- */
- if(iLenSz == 0)
- return 0; /* zero-sized strings are equal ;) */
- else { /* we now have two non-empty strings of equal
- * length, so we need to actually check if they
- * are equal.
- */
- register size_t i;
- for(i = 0 ; i < iLenSz ; ++i) {
- if(pCS1->pBuf[i] != psz[i])
- return pCS1->pBuf[i] - psz[i];
- }
- /* if we arrive here, the strings are equal */
- return 0;
- }
- else
- return pCS1->iStrLen - iLenSz;
-}
-
-
-/* Locate the first occurence of this rsCStr object inside a standard sz string.
- * Returns the offset (0-bound) of this first occurrence. If not found, -1 is
- * returned. Both parameters MUST be given (NULL is not allowed).
- * rgerhards 2005-09-19
- */
-int rsCStrLocateInSzStr(rsCStrObj *pThis, uchar *sz)
-{
- int i;
- int iMax;
- int bFound;
- rsCHECKVALIDOBJECT(pThis, OIDrsCStr);
- assert(sz != NULL);
-
- if(pThis->iStrLen == 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 = strlen((char*)sz) - pThis->iStrLen;
-
- bFound = 0;
- i = 0;
- while(i <= iMax && !bFound) {
- size_t iCheck;
- uchar *pComp = sz + i;
- for(iCheck = 0 ; iCheck < pThis->iStrLen ; ++iCheck)
- if(*(pComp + iCheck) != *(pThis->pBuf + iCheck))
- break;
- if(iCheck == pThis->iStrLen)
- bFound = 1; /* found! - else it wouldn't be equal */
- else
- ++i; /* on to the next try */
- }
-
- return(bFound ? i : -1);
-}
-
-
-#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(rsCStrObj *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 */
-
-
-/*
- * Local variables:
- * c-indent-level: 8
- * c-basic-offset: 8
- * tab-width: 8
- * End:
- * vi:set ai:
- */
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-10 06:12:45 +0000