#include <iconv.h>
#endif
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
#include <execinfo.h>
#endif
#endif
int BaseStrBufSize = 64;
+const char *StrBufNOTNULL = ((char*) NULL) - 1;
+
+const char HexList[256][3] = {
+"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
+"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
+"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
+"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
+"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
+"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
+"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
+"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
+"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
+"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
+"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
+"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
+"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
+"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
+"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
+"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF"};
+
+/**
+ * @defgroup StrBuf Stringbuffer, A class for manipulating strings with dynamic buffers
+ * StrBuf is a versatile class, aiding the handling of dynamic strings
+ * * reduce de/reallocations
+ * * reduce the need to remeasure it
+ * * reduce scanning over the string (in @ref StrBuf_NextTokenizer "Tokenizers")
+ * * allow asyncroneous IO for line and Blob based operations
+ * * reduce the use of memove in those
+ * * Quick filling in several operations with append functions
+ */
+
+/**
+ * @defgroup StrBuf_DeConstructors Create/Destroy StrBufs
+ * @ingroup StrBuf
+ */
+
+/**
+ * @defgroup StrBuf_Cast Cast operators to interact with char* based code
+ * @ingroup StrBuf
+ * use these operators to interfere with code demanding char*;
+ * if you need to own the content, smash me. Avoid, since we loose the length information.
+ */
+
+/**
+ * @defgroup StrBuf_Filler Create/Replace/Append Content into a StrBuf
+ * @ingroup StrBuf
+ * operations to get your Strings into a StrBuf, manipulating them, or appending
+ */
+/**
+ * @defgroup StrBuf_NextTokenizer Fast tokenizer to pull tokens in sequence
+ * @ingroup StrBuf
+ * Quick tokenizer; demands of the user to pull its tokens in sequence
+ */
+
+/**
+ * @defgroup StrBuf_Tokenizer tokenizer Functions; Slow ones.
+ * @ingroup StrBuf
+ * versatile tokenizer; random access to tokens, but slower; Prefer the @ref StrBuf_NextTokenizer "Next Tokenizer"
+ */
+
+/**
+ * @defgroup StrBuf_BufferedIO Buffered IO with Asynchroneous reads and no unneeded memmoves (the fast ones)
+ * @ingroup StrBuf
+ * File IO to fill StrBufs; Works with work-buffer shared across several calls;
+ * External Cursor to maintain the current read position inside of the buffer
+ * the non-fast ones will use memove to keep the start of the buffer the read buffer (which is slower)
+ */
+
+/**
+ * @defgroup StrBuf_IO FileIO; Prefer @ref StrBuf_BufferedIO
+ * @ingroup StrBuf
+ * Slow I/O; avoid.
+ */
+
+/**
+ * @defgroup StrBuf_DeEnCoder functions to translate the contents of a buffer
+ * @ingroup StrBuf
+ * these functions translate the content of a buffer into another representation;
+ * some are combined Fillers and encoders
+ */
+
/**
* Private Structure for the Stringbuffer
*/
struct StrBuf {
char *buf; /**< the pointer to the dynamic buffer */
long BufSize; /**< how many spcae do we optain */
- long BufUsed; /**< StNumber of Chars used excluding the trailing \0 */
+ long BufUsed; /**< StNumber of Chars used excluding the trailing \\0 */
int ConstBuf; /**< are we just a wrapper arround a static buffer and musn't we be changed? */
#ifdef SIZE_DEBUG
- long nIncreases;
- char bt [SIZ];
- char bt_lastinc [SIZ];
+ long nIncreases; /**< for profiling; cound how many times we needed more */
+ char bt [SIZ]; /**< Stacktrace of last increase */
+ char bt_lastinc [SIZ]; /**< How much did we increase last time? */
#endif
};
+
+static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE);
+static inline int Ctdl_IsUtf8SequenceStart(const char Char);
+
#ifdef SIZE_DEBUG
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
static void StrBufBacktrace(StrBuf *Buf, int which)
{
int n;
#endif
/**
- * \Brief Cast operator to Plain String
- * Note: if the buffer is altered by StrBuf operations, this pointer may become
+ * @ingroup StrBuf_Cast
+ * @brief Cast operator to Plain String
+ * @note if the buffer is altered by StrBuf operations, this pointer may become
* invalid. So don't lean on it after altering the buffer!
* Since this operation is considered cheap, rather call it often than risking
* your pointer to become invalid!
- * \param Str the string we want to get the c-string representation for
- * \returns the Pointer to the Content. Don't mess with it!
+ * @param Str the string we want to get the c-string representation for
+ * @returns the Pointer to the Content. Don't mess with it!
*/
inline const char *ChrPtr(const StrBuf *Str)
{
}
/**
- * \brief since we know strlen()'s result, provide it here.
- * \param Str the string to return the length to
- * \returns contentlength of the buffer
+ * @ingroup StrBuf_Cast
+ * @brief since we know strlen()'s result, provide it here.
+ * @param Str the string to return the length to
+ * @returns contentlength of the buffer
*/
inline int StrLength(const StrBuf *Str)
{
}
/**
- * \brief local utility function to resize the buffer
- * \param Buf the buffer whichs storage we should increase
- * \param KeepOriginal should we copy the original buffer or just start over with a new one
- * \param DestSize what should fit in after?
+ * @ingroup StrBuf_DeConstructors
+ * @brief local utility function to resize the buffer
+ * @param Buf the buffer whichs storage we should increase
+ * @param KeepOriginal should we copy the original buffer or just start over with a new one
+ * @param DestSize what should fit in after?
*/
static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize)
{
NewSize *= 2;
NewBuf= (char*) malloc(NewSize);
+ if (NewBuf == NULL)
+ return -1;
+
if (KeepOriginal && (Buf->BufUsed > 0))
{
memcpy(NewBuf, Buf->buf, Buf->BufUsed);
Buf->BufSize = NewSize;
#ifdef SIZE_DEBUG
Buf->nIncreases++;
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
StrBufBacktrace(Buf, 1);
#endif
#endif
}
/**
- * \brief shrink an _EMPTY_ buffer if its Buffer superseeds threshhold to NewSize. Buffercontent is thoroughly ignored and flushed.
- * \param Buf Buffer to shrink (has to be empty)
- * \param ThreshHold if the buffer is bigger then this, its readjusted
- * \param NewSize if we Shrink it, how big are we going to be afterwards?
+ * @ingroup StrBuf_DeConstructors
+ * @brief shrink an _EMPTY_ buffer if its Buffer superseeds threshhold to NewSize. Buffercontent is thoroughly ignored and flushed.
+ * @param Buf Buffer to shrink (has to be empty)
+ * @param ThreshHold if the buffer is bigger then this, its readjusted
+ * @param NewSize if we Shrink it, how big are we going to be afterwards?
*/
void ReAdjustEmptyBuf(StrBuf *Buf, long ThreshHold, long NewSize)
{
}
/**
- * \brief shrink long term buffers to their real size so they don't waste memory
- * \param Buf buffer to shrink
- * \param Force if not set, will just executed if the buffer is much to big; set for lifetime strings
- * \returns physical size of the buffer
+ * @ingroup StrBuf_DeConstructors
+ * @brief shrink long term buffers to their real size so they don't waste memory
+ * @param Buf buffer to shrink
+ * @param Force if not set, will just executed if the buffer is much to big; set for lifetime strings
+ * @returns physical size of the buffer
*/
long StrBufShrinkToFit(StrBuf *Buf, int Force)
{
}
/**
- * Allocate a new buffer with default buffer size
- * \returns the new stringbuffer
+ * @ingroup StrBuf_DeConstructors
+ * @brief Allocate a new buffer with default buffer size
+ * @returns the new stringbuffer
*/
StrBuf* NewStrBuf(void)
{
NewBuf->nIncreases = 0;
NewBuf->bt[0] = '\0';
NewBuf->bt_lastinc[0] = '\0';
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
StrBufBacktrace(NewBuf, 0);
#endif
#endif
}
/**
- * \brief Copy Constructor; returns a duplicate of CopyMe
- * \params CopyMe Buffer to faxmilate
- * \returns the new stringbuffer
+ * @ingroup StrBuf_DeConstructors
+ * @brief Copy Constructor; returns a duplicate of CopyMe
+ * @param CopyMe Buffer to faxmilate
+ * @returns the new stringbuffer
*/
StrBuf* NewStrBufDup(const StrBuf *CopyMe)
{
NewBuf->nIncreases = 0;
NewBuf->bt[0] = '\0';
NewBuf->bt_lastinc[0] = '\0';
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
StrBufBacktrace(NewBuf, 0);
#endif
#endif
}
/**
- * \brief create a new Buffer using an existing c-string
+ * @ingroup StrBuf_DeConstructors
+ * @brief create a new Buffer using an existing c-string
* this function should also be used if you want to pre-suggest
* the buffer size to allocate in conjunction with ptr == NULL
- * \param ptr the c-string to copy; may be NULL to create a blank instance
- * \param nChars How many chars should we copy; -1 if we should measure the length ourselves
- * \returns the new stringbuffer
+ * @param ptr the c-string to copy; may be NULL to create a blank instance
+ * @param nChars How many chars should we copy; -1 if we should measure the length ourselves
+ * @returns the new stringbuffer
*/
StrBuf* NewStrBufPlain(const char* ptr, int nChars)
{
NewBuf->nIncreases = 0;
NewBuf->bt[0] = '\0';
NewBuf->bt_lastinc[0] = '\0';
-#if HAVE_BACKTRACE
+#ifdef HAVE_BACKTRACE
StrBufBacktrace(NewBuf, 0);
#endif
#endif
}
/**
- * \brief Set an existing buffer from a c-string
- * \param ptr c-string to put into
- * \param nChars set to -1 if we should work 0-terminated
- * \returns the new length of the string
+ * @ingroup StrBuf_DeConstructors
+ * @brief Set an existing buffer from a c-string
+ * @param Buf buffer to load
+ * @param ptr c-string to put into
+ * @param nChars set to -1 if we should work 0-terminated
+ * @returns the new length of the string
*/
int StrBufPlain(StrBuf *Buf, const char* ptr, int nChars)
{
/**
- * \brief use strbuf as wrapper for a string constant for easy handling
- * \param StringConstant a string to wrap
- * \param SizeOfConstant should be sizeof(StringConstant)-1
+ * @ingroup StrBuf_DeConstructors
+ * @brief use strbuf as wrapper for a string constant for easy handling
+ * @param StringConstant a string to wrap
+ * @param SizeOfStrConstant should be sizeof(StringConstant)-1
*/
StrBuf* _NewConstStrBuf(const char* StringConstant, size_t SizeOfStrConstant)
{
/**
- * \brief flush the content of a Buf; keep its struct
- * \param buf Buffer to flush
+ * @ingroup StrBuf_DeConstructors
+ * @brief flush the content of a Buf; keep its struct
+ * @param buf Buffer to flush
*/
int FlushStrBuf(StrBuf *buf)
{
}
/**
- * \brief wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
- * \param buf Buffer to wipe
+ * @ingroup StrBuf_DeConstructors
+ * @brief wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
+ * @param buf Buffer to wipe
*/
int FLUSHStrBuf(StrBuf *buf)
{
int hFreeDbglog = -1;
#endif
/**
- * \brief Release a Buffer
+ * @ingroup StrBuf_DeConstructors
+ * @brief Release a Buffer
* Its a double pointer, so it can NULL your pointer
* so fancy SIG11 appear instead of random results
- * \param FreeMe Pointer Pointer to the buffer to free
+ * @param FreeMe Pointer Pointer to the buffer to free
*/
void FreeStrBuf (StrBuf **FreeMe)
{
}
/**
- * \brief Release the buffer
+ * @ingroup StrBuf_DeConstructors
+ * @brief flatten a Buffer to the Char * we return
+ * Its a double pointer, so it can NULL your pointer
+ * so fancy SIG11 appear instead of random results
+ * The Callee then owns the buffer and is responsible for freeing it.
+ * @param SmashMe Pointer Pointer to the buffer to release Buf from and free
+ * @returns the pointer of the buffer; Callee owns the memory thereafter.
+ */
+char *SmashStrBuf (StrBuf **SmashMe)
+{
+ char *Ret;
+
+ if ((SmashMe == NULL) || (*SmashMe == NULL))
+ return NULL;
+#ifdef SIZE_DEBUG
+ if (hFreeDbglog == -1){
+ pid_t pid = getpid();
+ char path [SIZ];
+ snprintf(path, SIZ, "/tmp/libcitadel_strbuf_realloc.log.%d", pid);
+ hFreeDbglog = open(path, O_APPEND|O_CREAT|O_WRONLY);
+ }
+ if ((*SmashMe)->nIncreases > 0)
+ {
+ char buf[SIZ * 3];
+ long n;
+ n = snprintf(buf, SIZ * 3, "S+|%ld|%ld|%ld|%s|%s|\n",
+ (*SmashMe)->nIncreases,
+ (*SmashMe)->BufUsed,
+ (*SmashMe)->BufSize,
+ (*SmashMe)->bt,
+ (*SmashMe)->bt_lastinc);
+ n = write(hFreeDbglog, buf, n);
+ }
+ else
+ {
+ char buf[128];
+ long n;
+ n = snprintf(buf, 128, "S_|0|%ld%ld|\n",
+ (*SmashMe)->BufUsed,
+ (*SmashMe)->BufSize);
+ n = write(hFreeDbglog, buf, n);
+ }
+#endif
+ Ret = (*SmashMe)->buf;
+ free(*SmashMe);
+ *SmashMe = NULL;
+ return Ret;
+}
+
+/**
+ * @ingroup StrBuf_DeConstructors
+ * @brief Release the buffer
* If you want put your StrBuf into a Hash, use this as Destructor.
- * \param VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
+ * @param VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
*/
void HFreeStrBuf (void *VFreeMe)
{
}
/**
- * \brief Wrapper around atol
+ * @ingroup StrBuf
+ * @brief Wrapper around atol
*/
long StrTol(const StrBuf *Buf)
{
}
/**
- * \brief Wrapper around atoi
+ * @ingroup StrBuf
+ * @brief Wrapper around atoi
*/
int StrToi(const StrBuf *Buf)
{
}
/**
- * \brief Checks to see if the string is a pure number
+ * @ingroup StrBuf
+ * @brief Checks to see if the string is a pure number
*/
int StrBufIsNumber(const StrBuf *Buf) {
char * pEnd;
return 0;
}
/**
- * \brief modifies a Single char of the Buf
+ * @ingroup StrBuf
+ * @brief modifies a Single char of the Buf
* You can point to it via char* or a zero-based integer
- * \param ptr char* to zero; use NULL if unused
- * \param nThChar zero based pointer into the string; use -1 if unused
- * \param PeekValue The Character to place into the position
+ * @param Buf The buffer to manipulate
+ * @param ptr char* to zero; use NULL if unused
+ * @param nThChar zero based pointer into the string; use -1 if unused
+ * @param PeekValue The Character to place into the position
*/
long StrBufPeek(StrBuf *Buf, const char* ptr, long nThChar, char PeekValue)
{
}
/**
- * \brief Append a StringBuffer to the buffer
- * \param Buf Buffer to modify
- * \param AppendBuf Buffer to copy at the end of our buffer
- * \param Offset Should we start copying from an offset?
+ * @ingroup StrBuf
+ * @brief Append a StringBuffer to the buffer
+ * @param Buf Buffer to modify
+ * @param AppendBuf Buffer to copy at the end of our buffer
+ * @param Offset Should we start copying from an offset?
*/
void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset)
{
/**
- * \brief Append a C-String to the buffer
- * \param Buf Buffer to modify
- * \param AppendBuf Buffer to copy at the end of our buffer
- * \param AppendSize number of bytes to copy; set to -1 if we should count it in advance
- * \param Offset Should we start copying from an offset?
+ * @ingroup StrBuf
+ * @brief Append a C-String to the buffer
+ * @param Buf Buffer to modify
+ * @param AppendBuf Buffer to copy at the end of our buffer
+ * @param AppendSize number of bytes to copy; set to -1 if we should count it in advance
+ * @param Offset Should we start copying from an offset?
*/
void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, unsigned long Offset)
{
Buf->buf[Buf->BufUsed] = '\0';
}
+/**
+ * @ingroup StrBuf
+ * @brief Callback for cURL to append the webserver reply to a buffer
+ * @param ptr pre-defined by the cURL API; see man 3 curl for mre info
+ * @param size pre-defined by the cURL API; see man 3 curl for mre info
+ * @param nmemb pre-defined by the cURL API; see man 3 curl for mre info
+ * @param stream pre-defined by the cURL API; see man 3 curl for mre info
+ */
+size_t CurlFillStrBuf_callback(void *ptr, size_t size, size_t nmemb, void *stream)
+{
+
+ StrBuf *Target;
+
+ Target = stream;
+ if (ptr == NULL)
+ return 0;
+
+ StrBufAppendBufPlain(Target, ptr, size * nmemb, 0);
+ return size * nmemb;
+}
+
/**
- * \brief Escape a string for feeding out as a URL while appending it to a Buffer
- * \param outbuf the output buffer
- * \param oblen the size of outbuf to sanitize
- * \param strbuf the input buffer
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Escape a string for feeding out as a URL while appending it to a Buffer
+ * @param OutBuf the output buffer
+ * @param In Buffer to encode
+ * @param PlainIn way in from plain old c strings
*/
void StrBufUrlescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn)
{
const char *pch, *pche;
char *pt, *pte;
- int b, c, len;
- const char ec[] = " +#&;`'|*?-~<>^()[]{}/$\"\\";
- int eclen = sizeof(ec) -1;
-
+ int len;
+
if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
return;
if (PlainIn != NULL) {
pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */
pt = OutBuf->buf + OutBuf->BufUsed;
}
-
- c = 0;
- for (b = 0; b < eclen; ++b) {
- if (*pch == ec[b]) {
- c = 1;
- b += eclen;
- }
- }
- if (c == 1) {
- sprintf(pt,"%%%02X", *pch);
+
+ if((*pch >= 'a' && *pch <= 'z') ||
+ (*pch >= '@' && *pch <= 'Z') || /* @ A-Z */
+ (*pch >= '0' && *pch <= ':') || /* 0-9 : */
+ (*pch == '!') || (*pch == '_') ||
+ (*pch == ',') || (*pch == '.') ||
+ (*pch == ','))
+ {
+ *(pt++) = *(pch++);
+ OutBuf->BufUsed++;
+ }
+ else {
+ *pt = '%';
+ *(pt + 1) = HexList[(unsigned char)*pch][0];
+ *(pt + 2) = HexList[(unsigned char)*pch][1];
pt += 3;
OutBuf->BufUsed += 3;
pch ++;
}
- else {
- *(pt++) = *(pch++);
- OutBuf->BufUsed++;
- }
}
*pt = '\0';
}
-/*
- * \brief Append a string, escaping characters which have meaning in HTML.
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Append a string, escaping characters which have meaning in HTML.
*
- * \param Target target buffer
- * \param Source source buffer; set to NULL if you just have a C-String
- * \param PlainIn Plain-C string to append; set to NULL if unused
- * \param nbsp If nonzero, spaces are converted to non-breaking spaces.
- * \param nolinebreaks if set to 1, linebreaks are removed from the string.
+ * @param Target target buffer
+ * @param Source source buffer; set to NULL if you just have a C-String
+ * @param PlainIn Plain-C string to append; set to NULL if unused
+ * @param nbsp If nonzero, spaces are converted to non-breaking spaces.
+ * @param nolinebreaks if set to 1, linebreaks are removed from the string.
* if set to 2, linebreaks are replaced by <br/>
*/
long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks)
return Target->BufUsed;
}
-/*
- * \brief Append a string, escaping characters which have meaning in HTML.
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Append a string, escaping characters which have meaning in HTML.
* Converts linebreaks into blanks; escapes single quotes
- * \param Target target buffer
- * \param Source source buffer; set to NULL if you just have a C-String
- * \param PlainIn Plain-C string to append; set to NULL if unused
+ * @param Target target buffer
+ * @param Source source buffer; set to NULL if you just have a C-String
+ * @param PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrMsgEscAppend(StrBuf *Target, StrBuf *Source, const char *PlainIn)
+void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
{
const char *aptr, *eiptr;
char *tptr, *eptr;
*tptr = '\0';
}
-/*
- * \brief Append a string, escaping characters which have meaning in JavaScript strings .
+
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Append a string, escaping characters which have meaning in ICAL.
+ * [\n,]
+ * @param Target target buffer
+ * @param Source source buffer; set to NULL if you just have a C-String
+ * @param PlainIn Plain-C string to append; set to NULL if unused
+ */
+void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
+{
+ const char *aptr, *eiptr;
+ char *tptr, *eptr;
+ long len;
+
+ if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
+ return ;
+
+ if (PlainIn != NULL) {
+ aptr = PlainIn;
+ len = strlen(PlainIn);
+ eiptr = aptr + len;
+ }
+ else {
+ aptr = Source->buf;
+ eiptr = aptr + Source->BufUsed;
+ len = Source->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ eptr = Target->buf + Target->BufSize - 8;
+ tptr = Target->buf + Target->BufUsed;
+
+ while (aptr < eiptr){
+ if(tptr + 3 >= eptr) {
+ IncreaseBuf(Target, 1, -1);
+ eptr = Target->buf + Target->BufSize - 8;
+ tptr = Target->buf + Target->BufUsed;
+ }
+
+ if (*aptr == '\n') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = 'n';
+ Target->BufUsed++;
+ }
+ else if (*aptr == '\r') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = 'r';
+ Target->BufUsed++;
+ }
+ else if (*aptr == ',') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = ',';
+ Target->BufUsed++;
+ } else {
+ *tptr = *aptr;
+ Target->BufUsed++;
+ }
+ tptr++; aptr++;
+ }
+ *tptr = '\0';
+}
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Append a string, escaping characters which have meaning in JavaScript strings .
*
- * \param Target target buffer
- * \param Source source buffer; set to NULL if you just have a C-String
- * \param PlainIn Plain-C string to append; set to NULL if unused
+ * @param Target target buffer
+ * @param Source source buffer; set to NULL if you just have a C-String
+ * @param PlainIn Plain-C string to append; set to NULL if unused
+ * @returns size of result or -1
*/
long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
{
eptr = Target->buf + Target->BufSize - 3;
bptr = Target->buf + Target->BufUsed;
}
- else if (*aptr == '"') {
+ if (*aptr == '"') {
*bptr = '\\';
bptr ++;
*bptr = '"';
}
/**
- * \brief extracts a substring from Source into dest
- * \param dest buffer to place substring into
- * \param Source string to copy substring from
- * \param Offset chars to skip from start
- * \param nChars number of chars to copy
- * \returns the number of chars copied; may be different from nChars due to the size of Source
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Append a string, escaping characters which have meaning in HTML + json.
+ *
+ * @param Target target buffer
+ * @param Source source buffer; set to NULL if you just have a C-String
+ * @param PlainIn Plain-C string to append; set to NULL if unused
+ * @param nbsp If nonzero, spaces are converted to non-breaking spaces.
+ * @param nolinebreaks if set to 1, linebreaks are removed from the string.
+ * if set to 2, linebreaks are replaced by <br/>
+ */
+long StrHtmlEcmaEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks)
+{
+ const char *aptr, *eiptr;
+ char *bptr, *eptr;
+ long len;
+ int IsUtf8Sequence = 0;
+
+ if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
+ return -1;
+
+ if (PlainIn != NULL) {
+ aptr = PlainIn;
+ len = strlen(PlainIn);
+ eiptr = aptr + len;
+ }
+ else {
+ aptr = Source->buf;
+ eiptr = aptr + Source->BufUsed;
+ len = Source->BufUsed;
+ }
+
+ if (len == 0)
+ return -1;
+
+ bptr = Target->buf + Target->BufUsed;
+ eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
+
+ while (aptr < eiptr){
+ if(bptr >= eptr) {
+ IncreaseBuf(Target, 1, -1);
+ eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
+ bptr = Target->buf + Target->BufUsed;
+ }
+ if (*aptr == '<') {
+ memcpy(bptr, "<", 4);
+ bptr += 4;
+ Target->BufUsed += 4;
+ }
+ else if (*aptr == '>') {
+ memcpy(bptr, ">", 4);
+ bptr += 4;
+ Target->BufUsed += 4;
+ }
+ else if (*aptr == '&') {
+ memcpy(bptr, "&", 5);
+ bptr += 5;
+ Target->BufUsed += 5;
+ }
+ else if (*aptr == LB) {
+ *bptr = '<';
+ bptr ++;
+ Target->BufUsed ++;
+ }
+ else if (*aptr == RB) {
+ *bptr = '>';
+ bptr ++;
+ Target->BufUsed ++;
+ }
+ else if ((*aptr == 32) && (nbsp == 1)) {
+ memcpy(bptr, " ", 6);
+ bptr += 6;
+ Target->BufUsed += 6;
+ }
+ else if ((*aptr == '\n') && (nolinebreaks == 1)) {
+ *bptr='\0'; /* nothing */
+ }
+ else if ((*aptr == '\n') && (nolinebreaks == 2)) {
+ memcpy(bptr, "<br/>", 11);
+ bptr += 11;
+ Target->BufUsed += 11;
+ }
+
+ else if ((*aptr == '\r') && (nolinebreaks != 0)) {
+ *bptr='\0'; /* nothing */
+ }
+
+ else if ((*aptr == '"') || (*aptr == QU)) {
+ *bptr = '\\';
+ bptr ++;
+ *bptr = '"';
+ bptr ++;
+ Target->BufUsed += 2;
+ } else if (*aptr == '\\') {
+ *bptr = '\\';
+ bptr ++;
+ *bptr = '\\';
+ bptr ++;
+ Target->BufUsed += 2;
+ }
+ else {
+ if (((unsigned char)*aptr) >= 0x20)
+ {
+ IsUtf8Sequence = Ctdl_GetUtf8SequenceLength(aptr, eiptr);
+
+ *bptr = *aptr;
+ Target->BufUsed ++;
+ while (IsUtf8Sequence > 1){
+ if(bptr + IsUtf8Sequence >= eptr) {
+ IncreaseBuf(Target, 1, -1);
+ eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
+ bptr = Target->buf + Target->BufUsed - 1;
+ }
+ bptr++; aptr++;
+ IsUtf8Sequence --;
+ *bptr = *aptr;
+ Target->BufUsed ++;
+ }
+ bptr++;
+ }
+
+ }
+ aptr ++;
+ }
+ *bptr = '\0';
+ if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
+ return -1;
+ return Target->BufUsed;
+}
+
+
+/**
+ * @ingroup StrBuf
+ * @brief extracts a substring from Source into dest
+ * @param dest buffer to place substring into
+ * @param Source string to copy substring from
+ * @param Offset chars to skip from start
+ * @param nChars number of chars to copy
+ * @returns the number of chars copied; may be different from nChars due to the size of Source
*/
int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t nChars)
{
}
/**
- * \brief sprintf like function appending the formated string to the buffer
+ * @ingroup StrBuf
+ * @brief sprintf like function appending the formated string to the buffer
* vsnprintf version to wrap into own calls
- * \param Buf Buffer to extend by format and params
- * \param format printf alike format to add
- * \param ap va_list containing the items for format
+ * @param Buf Buffer to extend by format and Params
+ * @param format printf alike format to add
+ * @param ap va_list containing the items for format
*/
void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap)
{
va_list apl;
- size_t BufSize = Buf->BufSize;
- size_t nWritten = Buf->BufSize + 1;
- size_t Offset = Buf->BufUsed;
- size_t newused = Offset + nWritten;
+ size_t BufSize;
+ size_t nWritten;
+ size_t Offset;
+ size_t newused;
+
+ if ((Buf == NULL) || (format == NULL))
+ return;
+
+ BufSize = Buf->BufSize;
+ nWritten = Buf->BufSize + 1;
+ Offset = Buf->BufUsed;
+ newused = Offset + nWritten;
while (newused >= BufSize) {
va_copy(apl, ap);
}
/**
- * \brief sprintf like function appending the formated string to the buffer
- * \param Buf Buffer to extend by format and params
- * \param format printf alike format to add
- * \param ap va_list containing the items for format
+ * @ingroup StrBuf
+ * @brief sprintf like function appending the formated string to the buffer
+ * @param Buf Buffer to extend by format and Params
+ * @param format printf alike format to add
*/
void StrBufAppendPrintf(StrBuf *Buf, const char *format, ...)
{
- size_t BufSize = Buf->BufSize;
- size_t nWritten = Buf->BufSize + 1;
- size_t Offset = Buf->BufUsed;
- size_t newused = Offset + nWritten;
+ size_t BufSize;
+ size_t nWritten;
+ size_t Offset;
+ size_t newused;
va_list arg_ptr;
+ if ((Buf == NULL) || (format == NULL))
+ return;
+
+ BufSize = Buf->BufSize;
+ nWritten = Buf->BufSize + 1;
+ Offset = Buf->BufUsed;
+ newused = Offset + nWritten;
+
while (newused >= BufSize) {
va_start(arg_ptr, format);
nWritten = vsnprintf(Buf->buf + Buf->BufUsed,
}
/**
- * \brief sprintf like function putting the formated string into the buffer
- * \param Buf Buffer to extend by format and params
- * \param format printf alike format to add
- * \param ap va_list containing the items for format
+ * @ingroup StrBuf
+ * @brief sprintf like function putting the formated string into the buffer
+ * @param Buf Buffer to extend by format and Parameters
+ * @param format printf alike format to add
*/
void StrBufPrintf(StrBuf *Buf, const char *format, ...)
{
- size_t nWritten = Buf->BufSize + 1;
+ size_t nWritten;
va_list arg_ptr;
+ if ((Buf == NULL) || (format == NULL))
+ return;
+
+ nWritten = Buf->BufSize + 1;
while (nWritten >= Buf->BufSize) {
va_start(arg_ptr, format);
nWritten = vsnprintf(Buf->buf, Buf->BufSize, format, arg_ptr);
/**
- * \brief Counts the numbmer of tokens in a buffer
- * \param Source String to count tokens in
- * \param tok Tokenizer char to count
- * \returns numbers of tokenizer chars found
+ * @ingroup StrBuf_Tokenizer
+ * @brief Counts the numbmer of tokens in a buffer
+ * @param source String to count tokens in
+ * @param tok Tokenizer char to count
+ * @returns numbers of tokenizer chars found
*/
int StrBufNum_tokens(const StrBuf *source, char tok)
{
* remove_token() - a tokenizer that kills, maims, and destroys
*/
/**
- * \brief a string tokenizer
- * \param Source StringBuffer to read into
- * \param parmnum n'th parameter to remove
- * \param separator tokenizer param
- * \returns -1 if not found, else length of token.
+ * @ingroup StrBuf_Tokenizer
+ * @brief a string tokenizer
+ * @param Source StringBuffer to read into
+ * @param parmnum n'th Parameter to remove
+ * @param separator tokenizer character
+ * @returns -1 if not found, else length of token.
*/
int StrBufRemove_token(StrBuf *Source, int parmnum, char separator)
{
int ReducedBy;
- char *d, *s; /* dest, source */
+ char *d, *s, *end; /* dest, source */
int count = 0;
- /* Find desired parameter */
+ /* Find desired @parameter */
+ end = Source->buf + Source->BufUsed;
d = Source->buf;
- while (count < parmnum) {
+ while ((d <= end) &&
+ (count < parmnum))
+ {
/* End of string, bail! */
if (!*d) {
d = NULL;
}
d++;
}
- if (!d) return 0; /* Parameter not found */
+ if ((d == NULL) || (d >= end))
+ return 0; /* @Parameter not found */
- /* Find next parameter */
+ /* Find next @parameter */
s = d;
- while (*s && *s != separator) {
+ while ((s <= end) &&
+ (*s && *s != separator))
+ {
s++;
}
if (*s == separator)
ReducedBy = d - s;
/* Hack and slash */
- if (*s) {
- memmove(d, s, Source->BufUsed - (s - Source->buf) + 1);
- Source->BufUsed -= (ReducedBy + 1);
+ if (s >= end) {
+ return 0;
+ }
+ else if (*s) {
+ memmove(d, s, Source->BufUsed - (s - Source->buf));
+ Source->BufUsed += ReducedBy;
+ Source->buf[Source->BufUsed] = '\0';
}
else if (d == Source->buf) {
*d = 0;
Source->BufUsed = 0;
}
else {
- *--d = 0;
- Source->BufUsed -= (ReducedBy + 1);
+ *--d = '\0';
+ Source->BufUsed += ReducedBy;
}
/*
while (*s) {
/**
- * \brief a string tokenizer
- * \param dest Destination StringBuffer
- * \param Source StringBuffer to read into
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns -1 if not found, else length of token.
+ * @ingroup StrBuf_Tokenizer
+ * @brief a string tokenizer
+ * @param dest Destination StringBuffer
+ * @param Source StringBuffer to read into
+ * @param parmnum n'th Parameter to extract
+ * @param separator tokenizer character
+ * @returns -1 if not found, else length of token.
*/
int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char separator)
{
if (*s == separator) {
++current_token;
}
- if (len >= dest->BufSize)
- if (!IncreaseBuf(dest, 1, -1))
+ if (len >= dest->BufSize) {
+ dest->BufUsed = len;
+ if (IncreaseBuf(dest, 1, -1) < 0) {
+ dest->BufUsed --;
break;
+ }
+ }
if ( (current_token == parmnum) &&
(*s != separator)) {
dest->buf[len] = *s;
/**
- * \brief a string tokenizer to fetch an integer
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else integer representation of the token
+ * @ingroup StrBuf_Tokenizer
+ * @brief a string tokenizer to fetch an integer
+ * @param Source String containing tokens
+ * @param parmnum n'th Parameter to extract
+ * @param separator tokenizer character
+ * @returns 0 if not found, else integer representation of the token
*/
int StrBufExtract_int(const StrBuf* Source, int parmnum, char separator)
{
}
/**
- * \brief a string tokenizer to fetch a long integer
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else long integer representation of the token
+ * @ingroup StrBuf_Tokenizer
+ * @brief a string tokenizer to fetch a long integer
+ * @param Source String containing tokens
+ * @param parmnum n'th Parameter to extract
+ * @param separator tokenizer character
+ * @returns 0 if not found, else long integer representation of the token
*/
long StrBufExtract_long(const StrBuf* Source, int parmnum, char separator)
{
/**
- * \brief a string tokenizer to fetch an unsigned long
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else unsigned long representation of the token
+ * @ingroup StrBuf_Tokenizer
+ * @brief a string tokenizer to fetch an unsigned long
+ * @param Source String containing tokens
+ * @param parmnum n'th Parameter to extract
+ * @param separator tokenizer character
+ * @returns 0 if not found, else unsigned long representation of the token
*/
unsigned long StrBufExtract_unsigned_long(const StrBuf* Source, int parmnum, char separator)
{
/**
- * \brief a string tokenizer
- * \param dest Destination StringBuffer
- * \param Source StringBuffer to read into
- * \param pStart pointer to the end of the last token. Feed with NULL.
- * \param separator tokenizer param
- * \returns -1 if not found, else length of token.
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer; Bounds checker
+ * function to make shure whether StrBufExtract_NextToken and friends have reached the end of the string.
+ * @param Source our tokenbuffer
+ * @param pStart the token iterator pointer to inspect
+ * @returns whether the revolving pointer is inside of the search range
+ */
+int StrBufHaveNextToken(const StrBuf *Source, const char **pStart)
+{
+ if ((Source == NULL) ||
+ (*pStart == StrBufNOTNULL) ||
+ (Source->BufUsed == 0))
+ {
+ return 0;
+ }
+ if (*pStart == NULL)
+ {
+ return 1;
+ }
+ else if (*pStart > Source->buf + Source->BufUsed)
+ {
+ return 0;
+ }
+ else if (*pStart <= Source->buf)
+ {
+ return 0;
+ }
+
+ return 1;
+}
+
+/**
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer
+ * @param dest Destination StringBuffer
+ * @param Source StringBuffer to read into
+ * @param pStart pointer to the end of the last token. Feed with NULL on start.
+ * @param separator tokenizer
+ * @returns -1 if not found, else length of token.
*/
int StrBufExtract_NextToken(StrBuf *dest, const StrBuf *Source, const char **pStart, char separator)
{
- const char *s, *EndBuffer; //* source * /
- int len = 0; //* running total length of extracted string * /
- int current_token = 0; //* token currently being processed * /
+ const char *s; /* source */
+ const char *EndBuffer; /* end stop of source buffer */
+ int current_token = 0; /* token currently being processed */
+ int len = 0; /* running total length of extracted string */
+
+ if ((Source == NULL) ||
+ (Source->BufUsed == 0) )
+ {
+ *pStart = StrBufNOTNULL;
+ return -1;
+ }
- if (dest != NULL) {
+ EndBuffer = Source->buf + Source->BufUsed;
+
+ if (dest != NULL)
+ {
dest->buf[0] = '\0';
dest->BufUsed = 0;
}
else
- return(-1);
-
- if ((Source == NULL) ||
- (Source->BufUsed ==0)) {
- return(-1);
+ {
+ *pStart = EndBuffer + 1;
+ return -1;
}
- if (*pStart == NULL)
- *pStart = Source->buf;
-
- EndBuffer = Source->buf + Source->BufUsed;
- if ((*pStart < Source->buf) ||
- (*pStart > EndBuffer)) {
- return (-1);
+ if (*pStart == NULL)
+ {
+ *pStart = Source->buf; /* we're starting to examine this buffer. */
+ }
+ else if ((*pStart < Source->buf) ||
+ (*pStart > EndBuffer ) )
+ {
+ return -1; /* no more tokens to find. */
}
-
s = *pStart;
-
- //cit_backtrace();
- //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
-
- while ((s<EndBuffer) && !IsEmptyStr(s)) {
- if (*s == separator) {
+ /* start to find the next token */
+ while ((s <= EndBuffer) &&
+ (current_token == 0) )
+ {
+ if (*s == separator)
+ {
+ /* we found the next token */
++current_token;
}
- if (len >= dest->BufSize)
- if (!IncreaseBuf(dest, 1, -1)) {
- *pStart = EndBuffer + 1;
+
+ if (len >= dest->BufSize)
+ {
+ /* our Dest-buffer isn't big enough, increase it. */
+ dest->BufUsed = len;
+
+ if (IncreaseBuf(dest, 1, -1) < 0) {
+ /* WHUT? no more mem? bail out. */
+ s = EndBuffer;
+ dest->BufUsed --;
break;
}
- if ( (current_token == 0) &&
- (*s != separator)) {
- dest->buf[len] = *s;
- ++len;
}
- else if (current_token > 0) {
- *pStart = s;
- break;
+
+ if ( (current_token == 0 ) && /* are we in our target token? */
+ (!IsEmptyStr(s) ) &&
+ (separator != *s) ) /* don't copy the token itself */
+ {
+ dest->buf[len] = *s; /* Copy the payload */
+ ++len; /* remember the bigger size. */
}
+
++s;
}
- *pStart = s;
- (*pStart) ++;
+ /* did we reach the end? */
+ if ((s > EndBuffer)) {
+ EndBuffer = StrBufNOTNULL;
+ *pStart = EndBuffer;
+ }
+ else {
+ *pStart = s; /* remember the position for the next run */
+ }
+
+ /* sanitize our extracted token */
dest->buf[len] = '\0';
- dest->BufUsed = len;
- //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
- //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
- return(len);
+ dest->BufUsed = len;
+
+ return (len);
}
/**
- * \brief a string tokenizer
- * \param dest Destination StringBuffer
- * \param Source StringBuffer to read into
- * \param pStart pointer to the end of the last token. Feed with NULL.
- * \param separator tokenizer param
- * \returns -1 if not found, else length of token.
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer
+ * @param Source StringBuffer to read from
+ * @param pStart pointer to the end of the last token. Feed with NULL.
+ * @param separator tokenizer character
+ * @param nTokens number of tokens to fastforward over
+ * @returns -1 if not found, else length of token.
*/
int StrBufSkip_NTokenS(const StrBuf *Source, const char **pStart, char separator, int nTokens)
{
}
/**
- * \brief a string tokenizer to fetch an integer
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else integer representation of the token
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer to fetch an integer
+ * @param Source StringBuffer to read from
+ * @param pStart Cursor on the tokenstring
+ * @param separator tokenizer character
+ * @returns 0 if not found, else integer representation of the token
*/
int StrBufExtractNext_int(const StrBuf* Source, const char **pStart, char separator)
{
}
/**
- * \brief a string tokenizer to fetch a long integer
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else long integer representation of the token
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer to fetch a long integer
+ * @param Source StringBuffer to read from
+ * @param pStart Cursor on the tokenstring
+ * @param separator tokenizer character
+ * @returns 0 if not found, else long integer representation of the token
*/
long StrBufExtractNext_long(const StrBuf* Source, const char **pStart, char separator)
{
/**
- * \brief a string tokenizer to fetch an unsigned long
- * \param dest Destination StringBuffer
- * \param parmnum n'th parameter to extract
- * \param separator tokenizer param
- * \returns 0 if not found, else unsigned long representation of the token
+ * @ingroup StrBuf_NextTokenizer
+ * @brief a string tokenizer to fetch an unsigned long
+ * @param Source StringBuffer to read from
+ * @param pStart Cursor on the tokenstring
+ * @param separator tokenizer character
+ * @returns 0 if not found, else unsigned long representation of the token
*/
unsigned long StrBufExtractNext_unsigned_long(const StrBuf* Source, const char **pStart, char separator)
{
/**
- * \brief Read a line from socket
+ * @ingroup StrBuf_IO
+ * @brief Read a line from socket
* flushes and closes the FD on error
- * \param buf the buffer to get the input to
- * \param fd pointer to the filedescriptor to read
- * \param append Append to an existing string or replace?
- * \param Error strerror() on error
- * \returns numbers of chars read
+ * @param buf the buffer to get the input to
+ * @param fd pointer to the filedescriptor to read
+ * @param append Append to an existing string or replace?
+ * @param Error strerror() on error
+ * @returns numbers of chars read
*/
int StrBufTCP_read_line(StrBuf *buf, int *fd, int append, const char **Error)
{
break;
if (buf->buf[len] != '\r')
len ++;
- if (len >= buf->BufSize) {
+ if (len + 2 >= buf->BufSize) {
buf->BufUsed = len;
buf->buf[len+1] = '\0';
IncreaseBuf(buf, 1, -1);
}
/**
- * \brief Read a line from socket
+ * @ingroup StrBuf_BufferedIO
+ * @brief Read a line from socket
* flushes and closes the FD on error
- * \param buf the buffer to get the input to
- * \param fd pointer to the filedescriptor to read
- * \param append Append to an existing string or replace?
- * \param Error strerror() on error
- * \returns numbers of chars read
+ * @param Line the line to read from the fd / I/O Buffer
+ * @param buf the buffer to get the input to
+ * @param fd pointer to the filedescriptor to read
+ * @param timeout number of successless selects until we bail out
+ * @param selectresolution how long to wait on each select
+ * @param Error strerror() on error
+ * @returns numbers of chars read
*/
int StrBufTCP_read_buffered_line(StrBuf *Line,
StrBuf *buf,
fd_set rfds;
char *pch = NULL;
int fdflags;
+ int IsNonBlock;
struct timeval tv;
if (buf->BufUsed > 0) {
IncreaseBuf(buf, 1, -1);
fdflags = fcntl(*fd, F_GETFL);
- if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
- return -1;
+ IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
while ((nSuccessLess < timeout) && (pch == NULL)) {
- tv.tv_sec = selectresolution;
- tv.tv_usec = 0;
-
- FD_ZERO(&rfds);
- FD_SET(*fd, &rfds);
- if (select(*fd + 1, NULL, &rfds, NULL, &tv) == -1) {
- *Error = strerror(errno);
- close (*fd);
- *fd = -1;
- return -1;
- }
- if (FD_ISSET(*fd, &rfds)) {
- rlen = read(*fd,
- &buf->buf[buf->BufUsed],
- buf->BufSize - buf->BufUsed - 1);
- if (rlen < 1) {
+ if (IsNonBlock){
+ tv.tv_sec = selectresolution;
+ tv.tv_usec = 0;
+
+ FD_ZERO(&rfds);
+ FD_SET(*fd, &rfds);
+ if (select(*fd + 1, NULL, &rfds, NULL, &tv) == -1) {
*Error = strerror(errno);
- close(*fd);
+ close (*fd);
*fd = -1;
return -1;
}
- else if (rlen > 0) {
- nSuccessLess = 0;
- buf->BufUsed += rlen;
- buf->buf[buf->BufUsed] = '\0';
- if (buf->BufUsed + 10 > buf->BufSize) {
- IncreaseBuf(buf, 1, -1);
- }
- pch = strchr(buf->buf, '\n');
- continue;
+ }
+ if (IsNonBlock && ! FD_ISSET(*fd, &rfds)) {
+ nSuccessLess ++;
+ continue;
+ }
+ rlen = read(*fd,
+ &buf->buf[buf->BufUsed],
+ buf->BufSize - buf->BufUsed - 1);
+ if (rlen < 1) {
+ *Error = strerror(errno);
+ close(*fd);
+ *fd = -1;
+ return -1;
+ }
+ else if (rlen > 0) {
+ nSuccessLess = 0;
+ buf->BufUsed += rlen;
+ buf->buf[buf->BufUsed] = '\0';
+ if (buf->BufUsed + 10 > buf->BufSize) {
+ IncreaseBuf(buf, 1, -1);
}
+ pch = strchr(buf->buf, '\n');
+ continue;
}
- nSuccessLess ++;
+
}
if (pch != NULL) {
rlen = 0;
}
+static const char *ErrRBLF_PreConditionFailed="StrBufTCP_read_buffered_line_fast: Wrong arguments or invalid Filedescriptor";
+static const char *ErrRBLF_SelectFailed="StrBufTCP_read_buffered_line_fast: Select failed without reason";
+static const char *ErrRBLF_NotEnoughSentFromServer="StrBufTCP_read_buffered_line_fast: No complete line was sent from peer";
/**
- * \brief Read a line from socket
+ * @ingroup StrBuf_BufferedIO
+ * @brief Read a line from socket
* flushes and closes the FD on error
- * \param buf the buffer to get the input to
- * \param Pos pointer to the current read position, should be NULL initialized!
- * \param fd pointer to the filedescriptor to read
- * \param append Append to an existing string or replace?
- * \param Error strerror() on error
- * \returns numbers of chars read
+ * @param Line Line to read from the fd / I/O Buffer
+ * @param IOBuf the buffer to get the input to
+ * @param Pos pointer to the current read position, should be NULL initialized!
+ * @param fd pointer to the filedescriptor to read
+ * @param timeout number of successless selects until we bail out
+ * @param selectresolution how long to wait on each select
+ * @param Error strerror() on error
+ * @returns numbers of chars read
*/
int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
StrBuf *IOBuf,
fd_set rfds;
const char *pch = NULL;
int fdflags;
+ int IsNonBlock;
struct timeval tv;
+ if ((Line == NULL) ||
+ (Pos == NULL) ||
+ (IOBuf == NULL) ||
+ (*fd == -1))
+ {
+ if (Pos != NULL)
+ *Pos = NULL;
+ *Error = ErrRBLF_PreConditionFailed;
+ return -1;
+ }
+
pos = *Pos;
if ((IOBuf->BufUsed > 0) &&
(pos != NULL) &&
if (IOBuf->BufSize - IOBuf->BufUsed < 10) {
IncreaseBuf(IOBuf, 1, -1);
+ *Pos = NULL;
}
fdflags = fcntl(*fd, F_GETFL);
- if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
- return -1;
+ IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
pch = NULL;
- while ((nSuccessLess < timeout) && (pch == NULL)) {
- tv.tv_sec = selectresolution;
- tv.tv_usec = 0;
+ while ((nSuccessLess < timeout) &&
+ (pch == NULL) &&
+ (*fd != -1)) {
+ if (IsNonBlock)
+ {
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
- FD_ZERO(&rfds);
- FD_SET(*fd, &rfds);
- if (select(*fd + 1, NULL, &rfds, NULL, &tv) == -1) {
- *Error = strerror(errno);
- close (*fd);
- *fd = -1;
- return -1;
- }
- if (FD_ISSET(*fd, &rfds) != 0) {
- rlen = read(*fd,
- &IOBuf->buf[IOBuf->BufUsed],
- IOBuf->BufSize - IOBuf->BufUsed - 1);
- if (rlen < 1) {
+ FD_ZERO(&rfds);
+ FD_SET(*fd, &rfds);
+ if (select((*fd) + 1, &rfds, NULL, NULL, &tv) == -1) {
*Error = strerror(errno);
- close(*fd);
+ close (*fd);
*fd = -1;
+ if (*Error == NULL)
+ *Error = ErrRBLF_SelectFailed;
return -1;
}
- else if (rlen > 0) {
- nSuccessLess = 0;
- IOBuf->BufUsed += rlen;
- IOBuf->buf[IOBuf->BufUsed] = '\0';
- if (IOBuf->BufUsed + 10 > IOBuf->BufSize) {
- IncreaseBuf(IOBuf, 1, -1);
- }
-
- pche = IOBuf->buf + IOBuf->BufUsed;
- pch = IOBuf->buf;
- while ((pch < pche) && (*pch != '\n'))
- pch ++;
- if ((pch >= pche) || (*pch == '\0'))
- pch = NULL;
+ if (! FD_ISSET(*fd, &rfds) != 0) {
+ nSuccessLess ++;
continue;
}
}
- nSuccessLess ++;
+ rlen = read(*fd,
+ &IOBuf->buf[IOBuf->BufUsed],
+ IOBuf->BufSize - IOBuf->BufUsed - 1);
+ if (rlen < 1) {
+ *Error = strerror(errno);
+ close(*fd);
+ *fd = -1;
+ return -1;
+ }
+ else if (rlen > 0) {
+ nSuccessLess = 0;
+ IOBuf->BufUsed += rlen;
+ IOBuf->buf[IOBuf->BufUsed] = '\0';
+ if (IOBuf->BufUsed + 10 > IOBuf->BufSize) {
+ IncreaseBuf(IOBuf, 1, -1);
+ *Pos = NULL;
+ }
+
+ pche = IOBuf->buf + IOBuf->BufUsed;
+ pch = IOBuf->buf;
+ while ((pch < pche) && (*pch != '\n'))
+ pch ++;
+ if ((pch >= pche) || (*pch == '\0'))
+ pch = NULL;
+ continue;
+ }
}
if (pch != NULL) {
pos = IOBuf->buf;
*Pos = pos + len + 1;
return len - rlen;
}
+ *Error = ErrRBLF_NotEnoughSentFromServer;
return -1;
}
+static const char *ErrRBLF_BLOBPreConditionFailed="StrBufReadBLOB: Wrong arguments or invalid Filedescriptor";
/**
- * \brief Input binary data from socket
+ * @ingroup StrBuf_IO
+ * @brief Input binary data from socket
* flushes and closes the FD on error
- * \param buf the buffer to get the input to
- * \param fd pointer to the filedescriptor to read
- * \param append Append to an existing string or replace?
- * \param nBytes the maximal number of bytes to read
- * \param Error strerror() on error
- * \returns numbers of chars read
+ * @param Buf the buffer to get the input to
+ * @param fd pointer to the filedescriptor to read
+ * @param append Append to an existing string or replace?
+ * @param nBytes the maximal number of bytes to read
+ * @param Error strerror() on error
+ * @returns numbers of chars read
*/
int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error)
{
- fd_set wset;
- int fdflags;
+ int fdflags;
int len, rlen, slen;
+ int nSuccessLess;
int nRead = 0;
char *ptr;
+ int IsNonBlock;
+ struct timeval tv;
+ fd_set rfds;
if ((Buf == NULL) || (*fd == -1))
+ {
+ *Error = ErrRBLF_BLOBPreConditionFailed;
return -1;
+ }
if (!append)
FlushStrBuf(Buf);
if (Buf->BufUsed + nBytes >= Buf->BufSize)
slen = len = Buf->BufUsed;
fdflags = fcntl(*fd, F_GETFL);
-
- while (nRead < nBytes) {
- if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
- FD_ZERO(&wset);
- FD_SET(*fd, &wset);
- if (select(*fd + 1, NULL, &wset, NULL, NULL) == -1) {
+ IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
+ nSuccessLess = 0;
+ while ((nRead < nBytes) &&
+ (*fd != -1))
+ {
+ if (IsNonBlock)
+ {
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
+
+ FD_ZERO(&rfds);
+ FD_SET(*fd, &rfds);
+ if (select(*fd + 1, &rfds, NULL, NULL, &tv) == -1) {
*Error = strerror(errno);
- return -1;
- }
- }
+ close (*fd);
+ *fd = -1;
+ if (*Error == NULL)
+ *Error = ErrRBLF_SelectFailed;
+ return -1;
+ }
+ if (! FD_ISSET(*fd, &rfds) != 0) {
+ nSuccessLess ++;
+ continue;
+ }
+ }
if ((rlen = read(*fd,
ptr,
return nRead;
}
+const char *ErrRBB_BLOBFPreConditionFailed = "StrBufReadBLOBBuffered: to many selects; aborting.";
+const char *ErrRBB_too_many_selects = "StrBufReadBLOBBuffered: to many selects; aborting.";
/**
- * \brief Input binary data from socket
+ * @ingroup StrBuf_BufferedIO
+ * @brief Input binary data from socket
* flushes and closes the FD on error
- * \param buf the buffer to get the input to
- * \param fd pointer to the filedescriptor to read
- * \param append Append to an existing string or replace?
- * \param nBytes the maximal number of bytes to read
- * \param Error strerror() on error
- * \returns numbers of chars read
+ * @param Blob put binary thing here
+ * @param IOBuf the buffer to get the input to
+ * @param Pos offset inside of IOBuf
+ * @param fd pointer to the filedescriptor to read
+ * @param append Append to an existing string or replace?
+ * @param nBytes the maximal number of bytes to read
+ * @param check whether we should search for '000\n' terminators in case of timeouts
+ * @param Error strerror() on error
+ * @returns numbers of chars read
*/
int StrBufReadBLOBBuffered(StrBuf *Blob,
StrBuf *IOBuf,
const char *pos;
int nSelects = 0;
int SelRes;
- fd_set wset;
- int fdflags;
+ int fdflags;
int len = 0;
int rlen, slen;
int nRead = 0;
+ int nAlreadyRead = 0;
+ int IsNonBlock;
char *ptr;
+ fd_set rfds;
const char *pch;
+ struct timeval tv;
+ int nSuccessLess;
if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL))
+ {
+ if (*Pos != NULL)
+ *Pos = NULL;
+ *Error = ErrRBB_BLOBFPreConditionFailed;
return -1;
+ }
+
if (!append)
FlushStrBuf(Blob);
if (Blob->BufUsed + nBytes >= Blob->BufSize)
memcpy(Blob->buf + Blob->BufUsed, pos, rlen);
Blob->BufUsed += rlen;
Blob->buf[Blob->BufUsed] = '\0';
- nRead = rlen;
+ nAlreadyRead = nRead = rlen;
*Pos = NULL;
}
if (rlen >= nBytes) {
}
FlushStrBuf(IOBuf);
+ *Pos = NULL;
if (IOBuf->BufSize < nBytes - nRead)
IncreaseBuf(IOBuf, 0, nBytes - nRead);
ptr = IOBuf->buf;
slen = len = Blob->BufUsed;
fdflags = fcntl(*fd, F_GETFL);
+ IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
SelRes = 1;
nBytes -= nRead;
nRead = 0;
- while (nRead < nBytes) {
- if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
- FD_ZERO(&wset);
- FD_SET(*fd, &wset);
- SelRes = select(*fd + 1, NULL, &wset, NULL, NULL);
- }
- if (SelRes == -1) {
- *Error = strerror(errno);
- return -1;
- }
- else if (SelRes) {
- nSelects = 0;
- rlen = read(*fd,
- ptr,
- nBytes - nRead);
- if (rlen == -1) {
- close(*fd);
- *fd = -1;
+ while ((nRead < nBytes) &&
+ (*fd != -1)) {
+ if (IsNonBlock)
+ {
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
+
+ FD_ZERO(&rfds);
+ FD_SET(*fd, &rfds);
+ if (select(*fd + 1, &rfds, NULL, NULL, &tv) == -1) {
*Error = strerror(errno);
- return rlen;
+ close (*fd);
+ *fd = -1;
+ if (*Error == NULL)
+ *Error = ErrRBLF_SelectFailed;
+ return -1;
+ }
+ if (! FD_ISSET(*fd, &rfds) != 0) {
+ nSuccessLess ++;
+ continue;
}
}
- else {
- nSelects ++;
+ nSuccessLess = 0;
+ rlen = read(*fd,
+ ptr,
+ nBytes - nRead);
+ if (rlen == -1) {
+ close(*fd);
+ *fd = -1;
+ *Error = strerror(errno);
+ return rlen;
+ }
+ else if (rlen == 0){
+ nSuccessLess ++;
if ((check == NNN_TERM) &&
(nRead > 5) &&
(strncmp(IOBuf->buf + IOBuf->BufUsed - 5, "\n000\n", 5) == 0))
}
if (nSelects > 10) {
FlushStrBuf(IOBuf);
+ *Error = ErrRBB_too_many_selects;
return -1;
}
}
- if (rlen > 0) {
+ else if (rlen > 0) {
nRead += rlen;
ptr += rlen;
IOBuf->BufUsed += rlen;
}
Blob->buf[Blob->BufUsed] = '\0';
StrBufAppendBufPlain(Blob, IOBuf->buf, nBytes, 0);
- return nRead;
+ if (*Pos == NULL) {
+ FlushStrBuf(IOBuf);
+ }
+ return nRead + nAlreadyRead;
}
/**
- * \brief Cut nChars from the start of the string
- * \param Buf Buffer to modify
- * \param nChars how many chars should be skipped?
+ * @ingroup StrBuf
+ * @brief Cut nChars from the start of the string
+ * @param Buf Buffer to modify
+ * @param nChars how many chars should be skipped?
*/
void StrBufCutLeft(StrBuf *Buf, int nChars)
{
}
/**
- * \brief Cut the trailing n Chars from the string
- * \param Buf Buffer to modify
- * \param nChars how many chars should be trunkated?
+ * @ingroup StrBuf
+ * @brief Cut the trailing n Chars from the string
+ * @param Buf Buffer to modify
+ * @param nChars how many chars should be trunkated?
*/
void StrBufCutRight(StrBuf *Buf, int nChars)
{
}
/**
- * \brief Cut the string after n Chars
- * \param Buf Buffer to modify
- * \param AfternChars after how many chars should we trunkate the string?
- * \param At if non-null and points inside of our string, cut it there.
+ * @ingroup StrBuf
+ * @brief Cut the string after n Chars
+ * @param Buf Buffer to modify
+ * @param AfternChars after how many chars should we trunkate the string?
+ * @param At if non-null and points inside of our string, cut it there.
*/
void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At)
{
}
-/*
- * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
- * buf - the string to modify
- * len - length of the string.
+/**
+ * @ingroup StrBuf
+ * @brief Strip leading and trailing spaces from a string; with premeasured and adjusted length.
+ * @param Buf the string to modify
*/
void StrBufTrim(StrBuf *Buf)
{
Buf->buf[Buf->BufUsed] = '\0';
}
-
+/**
+ * @ingroup StrBuf
+ * @brief uppercase the contents of a buffer
+ * @param Buf the buffer to translate
+ */
void StrBufUpCase(StrBuf *Buf)
{
char *pch, *pche;
}
+/**
+ * @ingroup StrBuf
+ * @brief lowercase the contents of a buffer
+ * @param Buf the buffer to translate
+ */
void StrBufLowerCase(StrBuf *Buf)
{
char *pch, *pche;
}
}
+/**
+ * @ingroup StrBuf
+ * @brief removes double slashes from pathnames
+ * @param Dir directory string to filter
+ * @param RemoveTrailingSlash allows / disallows trailing slashes
+ */
+void StrBufStripSlashes(StrBuf *Dir, int RemoveTrailingSlash)
+{
+ char *a, *b;
+
+ a = b = Dir->buf;
+
+ while (!IsEmptyStr(a)) {
+ if (*a == '/') {
+ while (*a == '/')
+ a++;
+ *b = '/';
+ b++;
+ }
+ else {
+ *b = *a;
+ b++; a++;
+ }
+ }
+ if ((RemoveTrailingSlash) && (*(b - 1) != '/')){
+ *b = '/';
+ b++;
+ }
+ *b = '\0';
+ Dir->BufUsed = b - Dir->buf;
+}
/**
- * \brief unhide special chars hidden to the HTML escaper
- * \param target buffer to put the unescaped string in
- * \param source buffer to unescape
+ * @ingroup StrBuf_DeEnCoder
+ * @brief unhide special chars hidden to the HTML escaper
+ * @param target buffer to put the unescaped string in
+ * @param source buffer to unescape
*/
void StrBufEUid_unescapize(StrBuf *target, const StrBuf *source)
{
/**
- * \brief hide special chars from the HTML escapers and friends
- * \param target buffer to put the escaped string in
- * \param source buffer to escape
+ * @ingroup StrBuf_DeEnCoder
+ * @brief hide special chars from the HTML escapers and friends
+ * @param target buffer to put the escaped string in
+ * @param source buffer to escape
*/
void StrBufEUid_escapize(StrBuf *target, const StrBuf *source)
{
target->buf[target->BufUsed + 1] = '\0';
}
-/*
- * \brief uses the same calling syntax as compress2(), but it
- * creates a stream compatible with HTTP "Content-encoding: gzip"
- */
#ifdef HAVE_ZLIB
#define DEF_MEM_LEVEL 8 /*< memlevel??? */
#define OS_CODE 0x03 /*< unix */
-int ZEXPORT compress_gzip(Bytef * dest, /*< compressed buffer*/
- size_t * destLen, /*< length of the compresed data */
- const Bytef * source, /*< source to encode */
- uLong sourceLen, /*< length of source to encode */
- int level) /*< compression level */
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief uses the same calling syntax as compress2(), but it
+ * creates a stream compatible with HTTP "Content-encoding: gzip"
+ * @param dest compressed buffer
+ * @param destLen length of the compresed data
+ * @param source source to encode
+ * @param sourceLen length of source to encode
+ * @param level compression level
+ */
+int ZEXPORT compress_gzip(Bytef * dest,
+ size_t * destLen,
+ const Bytef * source,
+ uLong sourceLen,
+ int level)
{
const int gz_magic[2] = { 0x1f, 0x8b }; /* gzip magic header */
/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief compress the buffer with gzip
* Attention! If you feed this a Const String, you must maintain the uncompressed buffer yourself!
+ * @param Buf buffer whose content is to be gzipped
*/
int CompressBuffer(StrBuf *Buf)
{
char *compressed_data = NULL;
size_t compressed_len, bufsize;
int i = 0;
-
- bufsize = compressed_len = ((Buf->BufUsed * 101) / 100) + 100;
+
+ bufsize = compressed_len = Buf->BufUsed + (Buf->BufUsed / 100) + 100;
compressed_data = malloc(compressed_len);
+ if (compressed_data == NULL)
+ return -1;
/* Flush some space after the used payload so valgrind shuts up... */
while ((i < 10) && (Buf->BufUsed + i < Buf->BufSize))
Buf->buf[Buf->BufUsed + i++] = '\0';
}
/**
- * \brief decode a buffer from base 64 encoding; destroys original
- * \param Buf Buffor to transform
+ * @ingroup StrBuf_DeEnCoder
+ * @brief decode a buffer from base 64 encoding; destroys original
+ * @param Buf Buffor to transform
*/
int StrBufDecodeBase64(StrBuf *Buf)
{
}
/**
- * \brief decode a buffer from base 64 encoding; destroys original
- * \param Buf Buffor to transform
+ * @ingroup StrBuf_DeEnCoder
+ * @brief decode a buffer from base 64 encoding; destroys original
+ * @param Buf Buffor to transform
*/
int StrBufDecodeHex(StrBuf *Buf)
{
}
/**
- * \brief replace all chars >0x20 && < 0x7F with Mute
- * \param Mute char to put over invalid chars
- * \param Buf Buffor to transform
+ * @ingroup StrBuf_DeEnCoder
+ * @brief replace all chars >0x20 && < 0x7F with Mute
+ * @param Mute char to put over invalid chars
+ * @param Buf Buffor to transform
*/
int StrBufSanitizeAscii(StrBuf *Buf, const char Mute)
{
/**
- * \brief remove escaped strings from i.e. the url string (like %20 for blanks)
- * \param Buf Buffer to translate
- * \param StripBlanks Reduce several blanks to one?
+ * @ingroup StrBuf_DeEnCoder
+ * @brief remove escaped strings from i.e. the url string (like %20 for blanks)
+ * @param Buf Buffer to translate
+ * @param StripBlanks Reduce several blanks to one?
*/
long StrBufUnescape(StrBuf *Buf, int StripBlanks)
{
/**
- * \brief RFC2047-encode a header field if necessary.
+ * @ingroup StrBuf_DeEnCoder
+ * @brief RFC2047-encode a header field if necessary.
* If no non-ASCII characters are found, the string
* will be copied verbatim without encoding.
*
- * \param target Target buffer.
- * \param source Source string to be encoded.
- * \returns encoded length; -1 if non success.
+ * @param target Target buffer.
+ * @param source Source string to be encoded.
+ * @returns encoded length; -1 if non success.
*/
int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
{
}
/**
- * \brief replaces all occurances of 'search' by 'replace'
- * \param buf Buffer to modify
- * \param search character to search
- * \param relpace character to replace search by
+ * @ingroup StrBuf
+ * @brief replaces all occurances of 'search' by 'replace'
+ * @param buf Buffer to modify
+ * @param search character to search
+ * @param replace character to replace search by
*/
void StrBufReplaceChars(StrBuf *buf, char search, char replace)
{
-/*
- * Wrapper around iconv_open()
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Wrapper around iconv_open()
* Our version adds aliases for non-standard Microsoft charsets
* such as 'MS950', aliasing them to names like 'CP950'
*
- * tocode Target encoding
- * fromcode Source encoding
+ * @param tocode Target encoding
+ * @param fromcode Source encoding
+ * @param pic anonimized pointer to iconv struct
*/
void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic)
{
}
-
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief find one chunk of a RFC822 encoded string
+ * @param Buffer where to search
+ * @param bptr where to start searching
+ * @returns found position, NULL if none.
+ */
static inline char *FindNextEnd (const StrBuf *Buf, char *bptr)
{
char * end;
return end;
}
+/**
+ * @ingroup StrBuf
+ * @brief swaps the contents of two StrBufs
+ * this is to be used to have cheap switched between a work-buffer and a target buffer
+ * @param A First one
+ * @param B second one
+ */
+static inline void SwapBuffers(StrBuf *A, StrBuf *B)
+{
+ StrBuf C;
+
+ memcpy(&C, A, sizeof(*A));
+ memcpy(A, B, sizeof(*B));
+ memcpy(B, &C, sizeof(C));
+
+}
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief convert one buffer according to the preselected iconv pointer PIC
+ * @param ConvertBuf buffer we need to translate
+ * @param TmpBuf To share a workbuffer over several iterations. prepare to have it filled with useless stuff afterwards.
+ * @param pic Pointer to the iconv-session Object
+ */
void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
{
#ifdef HAVE_ICONV
- int BufSize;
+ long trycount = 0;
+ size_t siz;
iconv_t ic;
char *ibuf; /**< Buffer of characters to be converted */
char *obuf; /**< Buffer for converted characters */
size_t obuflen; /**< Length of output buffer */
- if (ConvertBuf->BufUsed >= TmpBuf->BufSize)
- IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed);
-
+ /* since we're converting to utf-8, one glyph may take up to 6 bytes */
+ if (ConvertBuf->BufUsed * 6 >= TmpBuf->BufSize)
+ IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed * 6);
+TRYAGAIN:
ic = *(iconv_t*)pic;
ibuf = ConvertBuf->buf;
ibuflen = ConvertBuf->BufUsed;
obuf = TmpBuf->buf;
obuflen = TmpBuf->BufSize;
- iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
+ siz = iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
- /* little card game: wheres the red lady? */
- ibuf = ConvertBuf->buf;
- BufSize = ConvertBuf->BufSize;
+ if (siz < 0) {
+ if (errno == E2BIG) {
+ trycount ++;
+ IncreaseBuf(TmpBuf, 0, 0);
+ if (trycount < 5)
+ goto TRYAGAIN;
- ConvertBuf->buf = TmpBuf->buf;
- ConvertBuf->BufSize = TmpBuf->BufSize;
- ConvertBuf->BufUsed = TmpBuf->BufSize - obuflen;
- ConvertBuf->buf[ConvertBuf->BufUsed] = '\0';
-
- TmpBuf->buf = ibuf;
- TmpBuf->BufSize = BufSize;
- TmpBuf->BufUsed = 0;
- TmpBuf->buf[0] = '\0';
+ }
+ else if (errno == EILSEQ){
+ /* hm, invalid utf8 sequence... what to do now? */
+ /* An invalid multibyte sequence has been encountered in the input */
+ }
+ else if (errno == EINVAL) {
+ /* An incomplete multibyte sequence has been encountered in the input. */
+ }
+
+ FlushStrBuf(TmpBuf);
+ }
+ else {
+ TmpBuf->BufUsed = TmpBuf->BufSize - obuflen;
+ TmpBuf->buf[TmpBuf->BufUsed] = '\0';
+
+ /* little card game: wheres the red lady? */
+ SwapBuffers(ConvertBuf, TmpBuf);
+ FlushStrBuf(TmpBuf);
+ }
#endif
}
-
-
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief catches one RFC822 encoded segment, and decodes it.
+ * @param Target buffer to fill with result
+ * @param DecodeMe buffer with stuff to process
+ * @param SegmentStart points to our current segment in DecodeMe
+ * @param SegmentEnd Points to the end of our current segment in DecodeMe
+ * @param ConvertBuf Workbuffer shared between several iterations. Random content; needs to be valid
+ * @param ConvertBuf2 Workbuffer shared between several iterations. Random content; needs to be valid
+ * @param FoundCharset Characterset to default decoding to; if we find another we will overwrite it.
+ */
inline static void DecodeSegment(StrBuf *Target,
const StrBuf *DecodeMe,
char *SegmentStart,
char encoding[16];
#ifdef HAVE_ICONV
iconv_t ic = (iconv_t)(-1);
+#else
+ void *ic = NULL;
#endif
/* Now we handle foreign character sets properly encoded
* in RFC2047 format.
}
#endif
}
-/*
- * Handle subjects with RFC2047 encoding such as:
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief Handle subjects with RFC2047 encoding such as:
* =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
+ * @param Target where to put the decoded string to
+ * @param DecodeMe buffer with encoded string
+ * @param DefaultCharset if we don't find one, which should we use?
+ * @param FoundCharset overrides DefaultCharset if non-empty; If we find a charset inside of the string,
+ * put it here for later use where no string might be known.
*/
void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset)
{
+ StrBuf *DecodedInvalidBuf = NULL;
StrBuf *ConvertBuf, *ConvertBuf2;
+ const StrBuf *DecodeMee = DecodeMe;
char *start, *end, *next, *nextend, *ptr = NULL;
#ifdef HAVE_ICONV
iconv_t ic = (iconv_t)(-1) ;
#ifdef HAVE_ICONV
ctdl_iconv_open("UTF-8", ChrPtr(DefaultCharset), &ic);
if (ic != (iconv_t)(-1) ) {
- StrBufConvert((StrBuf*)DecodeMe, ConvertBuf, &ic);///TODO: don't void const?
+ DecodedInvalidBuf = NewStrBufDup(DecodeMe);
+ StrBufConvert(DecodedInvalidBuf, ConvertBuf, &ic);///TODO: don't void const?
+ DecodeMee = DecodedInvalidBuf;
iconv_close(ic);
}
#endif
/* pre evaluate the first pair */
nextend = end = NULL;
- len = StrLength(DecodeMe);
- start = strstr(DecodeMe->buf, "=?");
- eptr = DecodeMe->buf + DecodeMe->BufUsed;
+ len = StrLength(DecodeMee);
+ start = strstr(DecodeMee->buf, "=?");
+ eptr = DecodeMee->buf + DecodeMee->BufUsed;
if (start != NULL)
- end = FindNextEnd (DecodeMe, start);
+ end = FindNextEnd (DecodeMee, start);
else {
- StrBufAppendBuf(Target, DecodeMe, 0);
+ StrBufAppendBuf(Target, DecodeMee, 0);
FreeStrBuf(&ConvertBuf);
+ FreeStrBuf(&DecodedInvalidBuf);
return;
}
- ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMe));
+ ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMee));
- if (start != DecodeMe->buf)
- StrBufAppendBufPlain(Target, DecodeMe->buf, start - DecodeMe->buf, 0);
+ if (start != DecodeMee->buf) {
+ long nFront;
+
+ nFront = start - DecodeMee->buf;
+ StrBufAppendBufPlain(Target, DecodeMee->buf, nFront, 0);
+ len -= nFront;
+ }
/*
* Since spammers will go to all sorts of absurd lengths to get their
* messages through, there are LOTS of corrupt headers out there.
{
passes++;
DecodeSegment(Target,
- DecodeMe,
+ DecodeMee,
start,
end,
ConvertBuf,
nextend = NULL;
if ((next != NULL) &&
(next < eptr))
- nextend = FindNextEnd(DecodeMe, next);
+ nextend = FindNextEnd(DecodeMee, next);
if (nextend == NULL)
next = NULL;
/* did we find a gab just filled with blanks? */
if (ptr == next)
{
+ long gap = next - start;
memmove (end + 2,
next,
- len - (next - start));
-
+ len - (gap));
+ len -= gap;
/* now terminate the gab at the end */
delta = (next - end) - 2; ////TODO: const!
- ((StrBuf*)DecodeMe)->BufUsed -= delta;
- ((StrBuf*)DecodeMe)->buf[DecodeMe->BufUsed] = '\0';
+ ((StrBuf*)DecodeMee)->BufUsed -= delta;
+ ((StrBuf*)DecodeMee)->buf[DecodeMee->BufUsed] = '\0';
/* move next to its new location. */
next -= delta;
end = nextend;
}
end = ptr;
- nextend = DecodeMe->buf + DecodeMe->BufUsed;
+ nextend = DecodeMee->buf + DecodeMee->BufUsed;
if ((end != NULL) && (end < nextend)) {
ptr = end;
while ( (ptr < nextend) &&
}
FreeStrBuf(&ConvertBuf);
FreeStrBuf(&ConvertBuf2);
+ FreeStrBuf(&DecodedInvalidBuf);
}
/**
- * \brief evaluate the length of an utf8 special character sequence
- * \param Char the character to examine
- * \returns width of utf8 chars in bytes
+ * @ingroup StrBuf
+ * @brief evaluate the length of an utf8 special character sequence
+ * @param Char the character to examine
+ * @returns width of utf8 chars in bytes
*/
-static inline int Ctdl_GetUtf8SequenceLength(char *CharS, char *CharE)
+static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE)
{
int n = 1;
char test = (1<<7);
test = test << 1;
n ++;
}
- if ((n > 6) || ((CharE - CharS) > n))
+ if ((n > 6) || ((CharE - CharS) < n))
n = 1;
return n;
}
/**
- * \brief detect whether this char starts an utf-8 encoded char
- * \param Char character to inspect
- * \returns yes or no
+ * @ingroup StrBuf
+ * @brief detect whether this char starts an utf-8 encoded char
+ * @param Char character to inspect
+ * @returns yes or no
*/
-static inline int Ctdl_IsUtf8SequenceStart(char Char)
+static inline int Ctdl_IsUtf8SequenceStart(const char Char)
{
/** 11??.???? indicates an UTF8 Sequence. */
return ((Char & 0xC0) != 0);
}
/**
- * \brief measure the number of glyphs in an UTF8 string...
- * \param str string to measure
- * \returns the length of str
+ * @ingroup StrBuf
+ * @brief measure the number of glyphs in an UTF8 string...
+ * @param Buf string to measure
+ * @returns the number of glyphs in Buf
*/
long StrBuf_Utf8StrLen(StrBuf *Buf)
{
while ((aptr < eptr) && (*aptr != '\0')) {
if (Ctdl_IsUtf8SequenceStart(*aptr)){
m = Ctdl_GetUtf8SequenceLength(aptr, eptr);
- while ((aptr < eptr) && (m-- > 0) && (*aptr++ != '\0'))
- n ++;
+ while ((aptr < eptr) && (*aptr++ != '\0')&& (m-- > 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
+ * @ingroup StrBuf
+ * @brief cuts a string after maxlen glyphs
+ * @param Buf string to cut to maxlen glyphs
+ * @param maxlen how long may the string become?
+ * @returns current length of the string
*/
long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen)
{
while ((aptr < eptr) && (*aptr != '\0')) {
if (Ctdl_IsUtf8SequenceStart(*aptr)){
m = Ctdl_GetUtf8SequenceLength(aptr, eptr);
- while ((m-- > 0) && (*aptr++ != '\0'))
- n ++;
+ while ((*aptr++ != '\0') && (m-- > 0));
+ n ++;
}
else {
n++;
}
-
+/**
+ * @ingroup StrBuf
+ * @brief extract a "next line" from Buf; Ptr to persist across several iterations
+ * @param LineBuf your line will be copied here.
+ * @param Buf BLOB with lines of text...
+ * @param Ptr moved arround to keep the next-line across several iterations
+ * has to be &NULL on start; will be &NotNULL on end of buffer
+ * @returns size of copied buffer
+ */
int StrBufSipLine(StrBuf *LineBuf, StrBuf *Buf, const char **Ptr)
{
const char *aptr, *ptr, *eptr;
char *optr, *xptr;
- if (Buf == NULL)
+ if ((Buf == NULL) || (*Ptr == StrBufNOTNULL)) {
+ *Ptr = StrBufNOTNULL;
return 0;
+ }
+ FlushStrBuf(LineBuf);
if (*Ptr==NULL)
ptr = aptr = Buf->buf;
else
eptr = Buf->buf + Buf->BufUsed;
xptr = LineBuf->buf + LineBuf->BufSize - 1;
- while ((*ptr != '\n') &&
- (*ptr != '\r') &&
- (ptr < eptr))
+ while ((ptr <= eptr) &&
+ (*ptr != '\n') &&
+ (*ptr != '\r') )
{
*optr = *ptr;
optr++; ptr++;
xptr = LineBuf->buf + LineBuf->BufSize - 1;
}
}
+
+ if ((ptr >= eptr) && (optr > LineBuf->buf))
+ optr --;
LineBuf->BufUsed = optr - LineBuf->buf;
*optr = '\0';
- if (*ptr == '\r')
+ if ((ptr <= eptr) && (*ptr == '\r'))
ptr ++;
- if (*ptr == '\n')
+ if ((ptr <= eptr) && (*ptr == '\n'))
ptr ++;
-
- *Ptr = ptr;
+
+ if (ptr < eptr) {
+ *Ptr = ptr;
+ }
+ else {
+ *Ptr = StrBufNOTNULL;
+ }
return Buf->BufUsed - (ptr - Buf->buf);
}
+
projects / citadel.git / blobdiff