-/*
- * Copyright (c) 1987-2011 by the citadel.org team
- *
- * This program is open source software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
+// Copyright (c) 1987-2024 by the citadel.org team
+//
+// This program is open source software. Use, duplication, or disclosure is subject to the GNU General Public License, version 3.
+#define _GNU_SOURCE
#include "sysdep.h"
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#define SHOW_ME_VAPPEND_PRINTF
#include <stdarg.h>
+
#include "libcitadel.h"
#ifdef HAVE_ICONV
#include <execinfo.h>
#endif
+#ifdef UNDEF_MEMCPY
+#undef memcpy
+#endif
+
#ifdef HAVE_ZLIB
#include <zlib.h>
-int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen,
- const Bytef * source, uLong sourceLen, int level);
+int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen, const Bytef * source, uLong sourceLen, int level);
#endif
int BaseStrBufSize = 64;
+int EnableSplice = 0;
+int ZLibCompressionRatio = -1; // defaults to 6
+#ifdef HAVE_ZLIB
+#define DEF_MEM_LEVEL 8 // memlevel???
+#define OS_CODE 0x03 // unix
+const int gz_magic[2] = { 0x1f, 0x8b }; // gzip magic header
+#endif
const char *StrBufNOTNULL = ((char*) NULL) - 1;
"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
- */
+// 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 */
- int ConstBuf; /**< are we just a wrapper arround a static buffer and musn't we be changed? */
+ char *buf; // the pointer to the dynamic buffer
+ long BufSize; // how many spcae do we optain
+ long BufUsed; // Number 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; /**< 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? */
+ 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
};
#ifdef SIZE_DEBUG
#ifdef HAVE_BACKTRACE
-static void StrBufBacktrace(StrBuf *Buf, int which)
-{
+static void StrBufBacktrace(StrBuf *Buf, int which) {
int n;
char *pstart, *pch;
void *stack_frames[50];
size_t size, i;
char **strings;
- if (which)
+ if (which) {
pstart = pch = Buf->bt;
- else
+ }
+ else {
pstart = pch = Buf->bt_lastinc;
+ }
size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
strings = backtrace_symbols(stack_frames, size);
for (i = 0; i < size; i++) {
- if (strings != NULL)
+ if (strings != NULL) {
n = snprintf(pch, SIZ - (pch - pstart), "%s\\n", strings[i]);
- else
+ }
+ else {
n = snprintf(pch, SIZ - (pch - pstart), "%p\\n", stack_frames[i]);
+ }
pch += n;
}
free(strings);
-
-
}
#endif
-void dbg_FreeStrBuf(StrBuf *FreeMe, char *FromWhere)
-{
- if (hFreeDbglog == -1){
+
+void dbg_FreeStrBuf(StrBuf *FreeMe, char *FromWhere) {
+ 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 ((*FreeMe)->nIncreases > 0)
- {
+ if ((*FreeMe)->nIncreases > 0) {
char buf[SIZ * 3];
long n;
n = snprintf(buf, SIZ * 3, "%c+|%ld|%ld|%ld|%s|%s|\n",
- FromWhere,
- (*FreeMe)->nIncreases,
- (*FreeMe)->BufUsed,
- (*FreeMe)->BufSize,
- (*FreeMe)->bt,
- (*FreeMe)->bt_lastinc);
+ FromWhere,
+ (*FreeMe)->nIncreases,
+ (*FreeMe)->BufUsed,
+ (*FreeMe)->BufSize,
+ (*FreeMe)->bt,
+ (*FreeMe)->bt_lastinc
+ );
n = write(hFreeDbglog, buf, n);
}
- else
- {
+ else {
char buf[128];
long n;
n = snprintf(buf, 128, "%c_|0|%ld%ld|\n",
- FromWhere,
- (*FreeMe)->BufUsed,
- (*FreeMe)->BufSize);
+ FromWhere,
+ (*FreeMe)->BufUsed,
+ (*FreeMe)->BufSize
+ );
n = write(hFreeDbglog, buf, n);
}
}
-void dbg_IncreaseBuf(StrBuf *IncMe)
-{
+
+void dbg_IncreaseBuf(StrBuf *IncMe) {
Buf->nIncreases++;
#ifdef HAVE_BACKTRACE
StrBufBacktrace(Buf, 1);
#endif
}
-void dbg_Init(StrBuf *Buf)
-{
+
+void dbg_Init(StrBuf *Buf) {
Buf->nIncreases = 0;
Buf->bt[0] = '\0';
Buf->bt_lastinc[0] = '\0';
}
#else
-/* void it... */
+// void it...
#define dbg_FreeStrBuf(a, b)
#define dbg_IncreaseBuf(a)
#define dbg_Init(a)
#endif
-/**
- * @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)
-{
+// swaps the contents of two StrBufs
+// this is to be used to have cheap switched between a work-buffer and a target buffer
+// A First one
+// B second one
+static inline void iSwapBuffers(StrBuf *A, StrBuf *B) {
StrBuf C;
memcpy(&C, A, sizeof(*A));
}
-/**
- * @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!
- */
-inline const char *ChrPtr(const StrBuf *Str)
-{
+
+void SwapBuffers(StrBuf *A, StrBuf *B) {
+ iSwapBuffers(A, B);
+}
+
+
+// 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!
+// 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) {
if (Str == NULL)
return "";
return Str->buf;
}
-/**
- * @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)
-{
+
+// since we know strlen()'s result, provide it here.
+// Str the string to return the length to
+// returns contentlength of the buffer
+inline int StrLength(const StrBuf *Str) {
return (Str != NULL) ? Str->BufUsed : 0;
}
-/**
- * @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)
-{
+
+// local utility function to resize the buffer
+// Buf the buffer whichs storage we should increase
+// KeepOriginal should we copy the original buffer or just start over with a new one
+// DestSize what should fit in after?
+static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize) {
char *NewBuf;
size_t NewSize = Buf->BufSize * 2;
- if (Buf->ConstBuf)
+ if (Buf->ConstBuf) {
return -1;
+ }
- if (DestSize > 0)
- while ((NewSize <= DestSize) && (NewSize != 0))
+ if (DestSize > 0) {
+ while ((NewSize <= DestSize) && (NewSize != 0)) {
NewSize *= 2;
+ }
+ }
- if (NewSize == 0)
+ if (NewSize == 0) {
return -1;
+ }
- NewBuf= (char*) malloc(NewSize);
- if (NewBuf == NULL)
+ NewBuf = (char*) malloc(NewSize);
+ if (NewBuf == NULL) {
return -1;
+ }
- if (KeepOriginal && (Buf->BufUsed > 0))
- {
+ if (KeepOriginal && (Buf->BufUsed > 0)) {
memcpy(NewBuf, Buf->buf, Buf->BufUsed);
}
- else
- {
+ else {
NewBuf[0] = '\0';
Buf->BufUsed = 0;
}
return Buf->BufSize;
}
-/**
- * @ingroup StrBuf_DeConstructors
- * @brief shrink / increase an _EMPTY_ buffer 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)
-{
- if ((Buf != NULL) &&
- (Buf->BufUsed == 0) &&
- (Buf->BufSize < ThreshHold)) {
+
+// shrink / increase an _EMPTY_ buffer to NewSize. Buffercontent is thoroughly ignored and flushed.
+// Buf Buffer to shrink (has to be empty)
+// ThreshHold if the buffer is bigger then this, its readjusted
+// NewSize if we Shrink it, how big are we going to be afterwards?
+void ReAdjustEmptyBuf(StrBuf *Buf, long ThreshHold, long NewSize) {
+ if ((Buf != NULL) && (Buf->BufUsed == 0) && (Buf->BufSize < ThreshHold)) {
free(Buf->buf);
Buf->buf = (char*) malloc(NewSize);
Buf->BufUsed = 0;
}
}
-/**
- * @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)
-{
+
+// shrink long term buffers to their real size so they don't waste memory
+// Buf buffer to shrink
+// 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) {
if (Buf == NULL)
return -1;
- if (Force ||
- (Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize))
- {
- char *TmpBuf = (char*) malloc(Buf->BufUsed + 1);
+ if (Force || (Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize)) {
+ char *TmpBuf;
+
+ TmpBuf = (char*) malloc(Buf->BufUsed + 1);
+ if (TmpBuf == NULL)
+ return -1;
+
memcpy (TmpBuf, Buf->buf, Buf->BufUsed + 1);
Buf->BufSize = Buf->BufUsed + 1;
free(Buf->buf);
return Buf->BufUsed;
}
-/**
- * @ingroup StrBuf_DeConstructors
- * @brief Allocate a new buffer with default buffer size
- * @returns the new stringbuffer
- */
-StrBuf* NewStrBuf(void)
-{
+
+// Allocate a new buffer with default buffer size
+// returns the new stringbuffer
+StrBuf *NewStrBuf(void) {
StrBuf *NewBuf;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
NewBuf->buf = (char*) malloc(BaseStrBufSize);
+ if (NewBuf->buf == NULL) {
+ free(NewBuf);
+ return NULL;
+ }
NewBuf->buf[0] = '\0';
NewBuf->BufSize = BaseStrBufSize;
NewBuf->BufUsed = 0;
NewBuf->ConstBuf = 0;
dbg_Init (NewBuf);
-
return NewBuf;
}
-/**
- * @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)
-{
+
+// Copy Constructor; returns a duplicate of CopyMe
+// CopyMe Buffer to faxmilate
+// returns the new stringbuffer
+StrBuf *NewStrBufDup(const StrBuf *CopyMe) {
StrBuf *NewBuf;
if (CopyMe == NULL)
return NewStrBuf();
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
NewBuf->buf = (char*) malloc(CopyMe->BufSize);
+ if (NewBuf->buf == NULL) {
+ free(NewBuf);
+ return NULL;
+ }
+
memcpy(NewBuf->buf, CopyMe->buf, CopyMe->BufUsed + 1);
NewBuf->BufUsed = CopyMe->BufUsed;
NewBuf->BufSize = CopyMe->BufSize;
return NewBuf;
}
-/**
- * @ingroup StrBuf_DeConstructors
- * @brief Copy Constructor; CreateRelpaceMe will contain CopyFlushMe afterwards.
- * @param NoMe if non-NULL, we will use that buffer as value; KeepOriginal will abused as len.
- * @param CopyFlushMe Buffer to faxmilate if KeepOriginal, or to move into CreateRelpaceMe if !KeepOriginal.
- * @param CreateRelpaceMe If NULL, will be created, else Flushed and filled CopyFlushMe
- * @param KeepOriginal should CopyFlushMe remain intact? or may we Steal its buffer?
- * @returns the new stringbuffer
- */
-void NewStrBufDupAppendFlush(StrBuf **CreateRelpaceMe, StrBuf *CopyFlushMe, const char *NoMe, int KeepOriginal)
-{
+
+// Copy Constructor; CreateRelpaceMe will contain CopyFlushMe afterwards.
+// NoMe if non-NULL, we will use that buffer as value; KeepOriginal will abused as len.
+// CopyFlushMe Buffer to faxmilate if KeepOriginal, or to move into CreateRelpaceMe if !KeepOriginal.
+// CreateRelpaceMe If NULL, will be created, else Flushed and filled CopyFlushMe
+// KeepOriginal should CopyFlushMe remain intact? or may we Steal its buffer?
+// returns the new stringbuffer
+void NewStrBufDupAppendFlush(StrBuf **CreateRelpaceMe, StrBuf *CopyFlushMe, const char *NoMe, int KeepOriginal) {
StrBuf *NewBuf;
if (CreateRelpaceMe == NULL)
return;
- if (NoMe != NULL)
- {
+ if (NoMe != NULL) {
if (*CreateRelpaceMe != NULL)
StrBufPlain(*CreateRelpaceMe, NoMe, KeepOriginal);
else
return;
}
- if (CopyFlushMe == NULL)
- {
+ if (CopyFlushMe == NULL) {
if (*CreateRelpaceMe != NULL)
FlushStrBuf(*CreateRelpaceMe);
else
return;
}
- /*
- * Randomly Chosen: bigger than 64 chars is cheaper to swap the buffers instead of copying.
- * else *CreateRelpaceMe may use more memory than needed in a longer term, CopyFlushMe might
- * be a big IO-Buffer...
- */
- if (KeepOriginal || (StrLength(CopyFlushMe) < 256))
- {
- if (*CreateRelpaceMe == NULL)
- {
+ // Randomly Chosen: bigger than 64 chars is cheaper to swap the buffers instead of copying.
+ // else *CreateRelpaceMe may use more memory than needed in a longer term, CopyFlushMe might
+ // be a big IO-Buffer...
+ if (KeepOriginal || (StrLength(CopyFlushMe) < 256)) {
+ if (*CreateRelpaceMe == NULL) {
*CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed);
dbg_Init(NewBuf);
}
- else
- {
+ else {
NewBuf = *CreateRelpaceMe;
FlushStrBuf(NewBuf);
}
StrBufAppendBuf(NewBuf, CopyFlushMe, 0);
}
- else
- {
- if (*CreateRelpaceMe == NULL)
- {
+ else {
+ if (*CreateRelpaceMe == NULL) {
*CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed);
dbg_Init(NewBuf);
}
- else
+ else {
NewBuf = *CreateRelpaceMe;
- SwapBuffers (NewBuf, CopyFlushMe);
+ }
+ iSwapBuffers (NewBuf, CopyFlushMe);
}
- if (!KeepOriginal)
+ if (!KeepOriginal) {
FlushStrBuf(CopyFlushMe);
+ }
return;
}
-/**
- * @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
- */
-StrBuf* NewStrBufPlain(const char* ptr, int nChars)
-{
+
+// 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
+// ptr the c-string to copy; may be NULL to create a blank instance
+// 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) {
StrBuf *NewBuf;
size_t Siz = BaseStrBufSize;
size_t CopySize;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
+
if (nChars < 0)
CopySize = strlen((ptr != NULL)?ptr:"");
else
while ((Siz <= CopySize) && (Siz != 0))
Siz *= 2;
- if (Siz == 0)
- {
+ if (Siz == 0) {
+ free(NewBuf);
return NULL;
}
NewBuf->buf = (char*) malloc(Siz);
- if (NewBuf->buf == NULL)
- {
+ if (NewBuf->buf == NULL) {
free(NewBuf);
return NULL;
}
return NewBuf;
}
-/**
- * @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)
-{
+
+//
+// Set an existing buffer from a c-string
+// Buf buffer to load
+// ptr c-string to put into
+// 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) {
size_t Siz;
size_t CopySize;
}
-/**
- * @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)
-{
+//
+// use strbuf as wrapper for a string constant for easy handling
+// StringConstant a string to wrap
+// SizeOfStrConstant should be sizeof(StringConstant)-1
+///
+StrBuf *_NewConstStrBuf(const char* StringConstant, size_t SizeOfStrConstant) {
StrBuf *NewBuf;
NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+ if (NewBuf == NULL)
+ return NULL;
NewBuf->buf = (char*) StringConstant;
NewBuf->BufSize = SizeOfStrConstant;
NewBuf->BufUsed = SizeOfStrConstant;
}
-/**
- * @ingroup StrBuf_DeConstructors
- * @brief flush the content of a Buf; keep its struct
- * @param buf Buffer to flush
- */
-int FlushStrBuf(StrBuf *buf)
-{
- if (buf == NULL)
+//
+// flush the content of a Buf; keep its struct
+// buf Buffer to flush
+///
+int FlushStrBuf(StrBuf *buf) {
+ if ((buf == NULL) || (buf->buf == NULL)) {
return -1;
- if (buf->ConstBuf)
- return -1;
+ }
+ if (buf->ConstBuf) {
+ return -1;
+ }
buf->buf[0] ='\0';
buf->BufUsed = 0;
return 0;
}
-/**
- * @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)
-{
+//
+// wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
+// buf Buffer to wipe
+///
+int FLUSHStrBuf(StrBuf *buf) {
if (buf == NULL)
return -1;
if (buf->ConstBuf)
#ifdef SIZE_DEBUG
int hFreeDbglog = -1;
#endif
-/**
- * @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
- */
-void FreeStrBuf (StrBuf **FreeMe)
-{
+//
+// Release a Buffer
+// Its a double pointer, so it can NULL your pointer
+// so fancy SIG11 appear instead of random results
+// FreeMe Pointer Pointer to the buffer to free
+///
+void FreeStrBuf (StrBuf **FreeMe) {
if (*FreeMe == NULL)
return;
*FreeMe = NULL;
}
-/**
- * @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)
-{
+//
+// 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.
+// 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 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]
- */
-void HFreeStrBuf (void *VFreeMe)
-{
+
+// Release the buffer
+// If you want put your StrBuf into a Hash, use this as Destructor.
+// VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
+void HFreeStrBuf (void *VFreeMe) {
StrBuf *FreeMe = (StrBuf*)VFreeMe;
if (FreeMe == NULL)
return;
}
-/*******************************************************************************
- * Simple string transformations *
- *******************************************************************************/
+//******************************************************************************
+// Simple string transformations *
+//******************************************************************************/
-/**
- * @ingroup StrBuf
- * @brief Wrapper around atol
- */
-long StrTol(const StrBuf *Buf)
-{
+// Wrapper around atol
+long StrTol(const StrBuf *Buf) {
if (Buf == NULL)
return 0;
if(Buf->BufUsed > 0)
return 0;
}
-/**
- * @ingroup StrBuf
- * @brief Wrapper around atoi
- */
-int StrToi(const StrBuf *Buf)
-{
+
+// Wrapper around atoi
+int StrToi(const StrBuf *Buf) {
if (Buf == NULL)
return 0;
if (Buf->BufUsed > 0)
return 0;
}
-/**
- * @ingroup StrBuf
- * @brief Checks to see if the string is a pure number
- * @param Buf The buffer to inspect
- * @returns 1 if its a pure number, 0, if not.
- */
+
+// Checks to see if the string is a pure number
+// Buf The buffer to inspect
+// returns 1 if its a pure number, 0, if not.
int StrBufIsNumber(const StrBuf *Buf) {
char * pEnd;
if ((Buf == NULL) || (Buf->BufUsed == 0)) {
return 0;
}
-/**
- * @ingroup StrBuf_Filler
- * @brief modifies a Single char of the Buf
- * You can point to it via char* or a zero-based integer
- * @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)
-{
+
+// modifies a Single char of the Buf
+// You can point to it via char* or a zero-based integer
+// Buf The buffer to manipulate
+// ptr char* to zero; use NULL if unused
+// nThChar zero based pointer into the string; use -1 if unused
+// PeekValue The Character to place into the position
+long StrBufPeek(StrBuf *Buf, const char* ptr, long nThChar, char PeekValue) {
if (Buf == NULL)
return -1;
if (ptr != NULL)
return nThChar;
}
-/**
- * @ingroup StrBuf_Filler
- * @brief modifies a range of chars of the Buf
- * You can point to it via char* or a zero-based integer
- * @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 nChars how many chars are to be flushed?
- * @param PookValue The Character to place into that area
- */
-long StrBufPook(StrBuf *Buf, const char* ptr, long nThChar, long nChars, char PookValue)
-{
+
+// modifies a range of chars of the Buf
+// You can point to it via char* or a zero-based integer
+// Buf The buffer to manipulate
+// ptr char* to zero; use NULL if unused
+// nThChar zero based pointer into the string; use -1 if unused
+// nChars how many chars are to be flushed?
+// PookValue The Character to place into that area
+long StrBufPook(StrBuf *Buf, const char* ptr, long nThChar, long nChars, char PookValue) {
if (Buf == NULL)
return -1;
if (ptr != NULL)
nChars = Buf->BufUsed - nThChar;
memset(Buf->buf + nThChar, PookValue, nChars);
- /* just to be shure... */
+ // just to be sure...
Buf->buf[Buf->BufUsed] = 0;
return nChars;
}
-/**
- * @ingroup StrBuf_Filler
- * @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)
-{
- if ((AppendBuf == NULL) || (Buf == NULL) || (AppendBuf->buf == NULL))
+
+// Append a StringBuffer to the buffer
+// Buf Buffer to modify
+// AppendBuf Buffer to copy at the end of our buffer
+// Offset Should we start copying from an offset?
+void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset) {
+ if ((AppendBuf == NULL) || (AppendBuf->buf == NULL) || (Buf == NULL) || (Buf->buf == NULL)) {
return;
+ }
if (Buf->BufSize - Offset < AppendBuf->BufUsed + Buf->BufUsed + 1)
- IncreaseBuf(Buf,
- (Buf->BufUsed > 0),
- AppendBuf->BufUsed + Buf->BufUsed);
+ IncreaseBuf(Buf, (Buf->BufUsed > 0), AppendBuf->BufUsed + Buf->BufUsed);
- memcpy(Buf->buf + Buf->BufUsed,
- AppendBuf->buf + Offset,
- AppendBuf->BufUsed - Offset);
+ memcpy(Buf->buf + Buf->BufUsed, AppendBuf->buf + Offset, AppendBuf->BufUsed - Offset);
Buf->BufUsed += AppendBuf->BufUsed - Offset;
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * @ingroup StrBuf_Filler
- * @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)
-{
+// Append a C-String to the buffer
+// Buf Buffer to modify
+// AppendBuf Buffer to copy at the end of our buffer
+// AppendSize number of bytes to copy; set to -1 if we should count it in advance
+// Offset Should we start copying from an offset?
+void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, unsigned long Offset) {
long aps;
long BufSizeRequired;
if ((AppendBuf == NULL) || (Buf == NULL))
return;
- if (AppendSize < 0 )
+ if (AppendSize < 0) {
aps = strlen(AppendBuf + Offset);
- else
+ }
+ else {
aps = AppendSize - Offset;
+ }
BufSizeRequired = Buf->BufUsed + aps + 1;
- if (Buf->BufSize <= BufSizeRequired)
+ if (Buf->BufSize <= BufSizeRequired) {
IncreaseBuf(Buf, (Buf->BufUsed > 0), BufSizeRequired);
+ }
- memcpy(Buf->buf + Buf->BufUsed,
- AppendBuf + Offset,
- aps);
+ memcpy(Buf->buf + Buf->BufUsed, AppendBuf + Offset, aps);
Buf->BufUsed += aps;
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * @ingroup StrBuf_Filler
- * @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
- */
-void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap)
-{
+
+// sprintf like function appending the formated string to the buffer
+// vsnprintf version to wrap into own calls
+// Buf Buffer to extend by format and Params
+// format printf alike format to add
+// ap va_list containing the items for format
+void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap) {
va_list apl;
size_t BufSize;
size_t nWritten;
while (newused >= BufSize) {
va_copy(apl, ap);
- nWritten = vsnprintf(Buf->buf + Offset,
- Buf->BufSize - Offset,
- format, apl);
+ nWritten = vsnprintf(Buf->buf + Offset, Buf->BufSize - Offset, format, apl);
va_end(apl);
newused = Offset + nWritten;
if (newused >= Buf->BufSize) {
if (IncreaseBuf(Buf, 1, newused) == -1)
- return; /* TODO: error handling? */
+ return; // TODO: error handling?
newused = Buf->BufSize + 1;
}
else {
}
}
-/**
- * @ingroup StrBuf_Filler
- * @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, ...)
-{
+
+// sprintf like function appending the formated string to the buffer
+// Buf Buffer to extend by format and Params
+// format printf alike format to add
+void StrBufAppendPrintf(StrBuf *Buf, const char *format, ...) {
size_t BufSize;
size_t nWritten;
size_t Offset;
while (newused >= BufSize) {
va_start(arg_ptr, format);
- nWritten = vsnprintf(Buf->buf + Buf->BufUsed,
- Buf->BufSize - Buf->BufUsed,
- format, arg_ptr);
+ nWritten = vsnprintf(Buf->buf + Buf->BufUsed, Buf->BufSize - Buf->BufUsed, format, arg_ptr);
va_end(arg_ptr);
newused = Buf->BufUsed + nWritten;
if (newused >= Buf->BufSize) {
if (IncreaseBuf(Buf, 1, newused) == -1)
- return; /* TODO: error handling? */
+ return; // TODO: error handling?
newused = Buf->BufSize + 1;
}
else {
}
}
-/**
- * @ingroup StrBuf_Filler
- * @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, ...)
-{
+
+// sprintf like function putting the formated string into the buffer
+// Buf Buffer to extend by format and Parameters
+// format printf alike format to add
+void StrBufPrintf(StrBuf *Buf, const char *format, ...) {
size_t nWritten;
va_list arg_ptr;
va_end(arg_ptr);
if (nWritten >= Buf->BufSize) {
if (IncreaseBuf(Buf, 0, 0) == -1)
- return; /* TODO: error handling? */
+ return; // TODO: error handling?
nWritten = Buf->BufSize + 1;
continue;
}
}
}
-/**
- * @ingroup StrBuf_Filler
- * @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)
-{
+
+// Callback for cURL to append the webserver reply to a buffer
+// ptr, size, nmemb, and stream are pre-defined by the cURL API; see man 3 curl for more info
+size_t CurlFillStrBuf_callback(void *ptr, size_t size, size_t nmemb, void *stream) {
StrBuf *Target;
}
-/**
- * @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)
-{
+// extracts a substring from Source into dest
+// dest buffer to place substring into
+// Source string to copy substring from
+// Offset chars to skip from start
+// 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) {
size_t NCharsRemain;
- if (Offset > Source->BufUsed)
- {
+ if (Offset > Source->BufUsed) {
if (dest != NULL)
FlushStrBuf(dest);
return 0;
}
- if (Offset + nChars < Source->BufUsed)
- {
- if (nChars >= dest->BufSize)
- IncreaseBuf(dest, 0, nChars + 1);
+ if (Offset + nChars < Source->BufUsed) {
+ if ((nChars >= dest->BufSize) && (IncreaseBuf(dest, 0, nChars + 1) == -1)) {
+ return 0;
+ }
memcpy(dest->buf, Source->buf + Offset, nChars);
dest->BufUsed = nChars;
dest->buf[dest->BufUsed] = '\0';
return nChars;
}
NCharsRemain = Source->BufUsed - Offset;
- if (NCharsRemain >= dest->BufSize)
- IncreaseBuf(dest, 0, NCharsRemain + 1);
+ if ((NCharsRemain >= dest->BufSize) && (IncreaseBuf(dest, 0, NCharsRemain + 1) == -1)) {
+ return 0;
+ }
memcpy(dest->buf, Source->buf + Offset, NCharsRemain);
dest->BufUsed = NCharsRemain;
dest->buf[dest->BufUsed] = '\0';
return NCharsRemain;
}
-/**
- * @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)
-{
+// Cut nChars from the start of the string
+// Buf Buffer to modify
+// nChars how many chars should be skipped?
+void StrBufCutLeft(StrBuf *Buf, int nChars) {
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
if (nChars >= Buf->BufUsed) {
FlushStrBuf(Buf);
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * @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)
-{
- if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
+// Cut the trailing n Chars from the string
+// Buf Buffer to modify
+// nChars how many chars should be trunkated?
+void StrBufCutRight(StrBuf *Buf, int nChars) {
+ if ((Buf == NULL) || (Buf->BufUsed == 0) || (Buf->buf == NULL))
+ return;
+
if (nChars >= Buf->BufUsed) {
FlushStrBuf(Buf);
return;
Buf->buf[Buf->BufUsed] = '\0';
}
-/**
- * @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)
-{
+
+// Cut the string after n Chars
+// Buf Buffer to modify
+// AfternChars after how many chars should we trunkate the string?
+// At if non-null and points inside of our string, cut it there.
+void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At) {
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
if (At != NULL){
AfternChars = At - Buf->buf;
}
-/**
- * @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)
-{
+// Strip leading and trailing spaces from a string; with premeasured and adjusted length.
+// Buf the string to modify
+void StrBufTrim(StrBuf *Buf) {
int delta = 0;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
- while ((Buf->BufUsed > 0) &&
- isspace(Buf->buf[Buf->BufUsed - 1]))
- {
+ while ((Buf->BufUsed > 0) && isspace(Buf->buf[Buf->BufUsed - 1])) {
Buf->BufUsed --;
}
Buf->buf[Buf->BufUsed] = '\0';
}
if (delta > 0) StrBufCutLeft(Buf, delta);
}
-/**
- * @ingroup StrBuf
- * @brief changes all spaces in the string (tab, linefeed...) to Blank (0x20)
- * @param Buf the string to modify
- */
-void StrBufSpaceToBlank(StrBuf *Buf)
-{
+
+
+// changes all spaces in the string (tab, linefeed...) to Blank (0x20)
+// Buf the string to modify
+void StrBufSpaceToBlank(StrBuf *Buf) {
char *pche, *pch;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
}
-void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary)
-{
- const char *pBuff;
+void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary) {
const char *pLeft;
const char *pRight;
- if (Buf == NULL)
+ if ((Buf == NULL) || (Buf->buf == NULL)) {
return;
- pLeft = pBuff = Buf->buf;
- while (pBuff != NULL) {
- pLeft = pBuff;
- pBuff = strchr(pBuff, leftboundary);
- if (pBuff != NULL)
- pBuff++;
}
-
- if (pLeft != NULL)
- pBuff = pLeft;
- else
- pBuff = Buf->buf;
- pRight = strchr(pBuff, rightboundary);
- if (pRight != NULL)
+
+ pRight = strchr(Buf->buf, rightboundary);
+ if (pRight != NULL) {
StrBufCutAt(Buf, 0, pRight);
- if (pLeft != NULL)
- StrBufCutLeft(Buf, pLeft - Buf->buf);
+ }
+
+ pLeft = strrchr(ChrPtr(Buf), leftboundary);
+ if (pLeft != NULL) {
+ StrBufCutLeft(Buf, pLeft - Buf->buf + 1);
+ }
}
-/**
- * @ingroup StrBuf_Filler
- * @brief uppercase the contents of a buffer
- * @param Buf the buffer to translate
- */
-void StrBufUpCase(StrBuf *Buf)
-{
+// uppercase the contents of a buffer
+// Buf the buffer to translate
+void StrBufUpCase(StrBuf *Buf) {
char *pch, *pche;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
-/**
- * @ingroup StrBuf_Filler
- * @brief lowercase the contents of a buffer
- * @param Buf the buffer to translate
- */
-void StrBufLowerCase(StrBuf *Buf)
-{
+// lowercase the contents of a buffer
+// Buf the buffer to translate
+void StrBufLowerCase(StrBuf *Buf) {
char *pch, *pche;
if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
}
-/*******************************************************************************
- * a tokenizer that kills, maims, and destroys *
- *******************************************************************************/
+//******************************************************************************
+// a tokenizer that kills, maims, and destroys *
+//******************************************************************************/
-/**
- * @ingroup StrBuf_Tokenizer
- * @brief Replace a token at a given place with a given length by another token with given length
- * @param Buf String where to work on
- * @param where where inside of the Buf is the search-token
- * @param HowLong How long is the token to be replaced
- * @param Repl Token to insert at 'where'
- * @param ReplLen Length of repl
- * @returns -1 if fail else length of resulting Buf
- */
-int StrBufReplaceToken(StrBuf *Buf, long where, long HowLong,
- const char *Repl, long ReplLen)
-{
+//*
+// Replace a token at a given place with a given length by another token with given length
+// Buf String where to work on
+// where where inside of the Buf is the search-token
+// HowLong How long is the token to be replaced
+// Repl Token to insert at 'where'
+// ReplLen Length of repl
+// @returns -1 if fail else length of resulting Buf
+///
+int StrBufReplaceToken(StrBuf *Buf, long where, long HowLong, const char *Repl, long ReplLen) {
- if ((Buf == NULL) ||
- (where > Buf->BufUsed) ||
- (where + HowLong > Buf->BufUsed))
+ if ((Buf == NULL) || (where > Buf->BufUsed) || (where + HowLong > Buf->BufUsed)) {
return -1;
+ }
- if (where + ReplLen - HowLong > Buf->BufSize)
- if (IncreaseBuf(Buf, 1, Buf->BufUsed + ReplLen) < 0)
+ if (where + ReplLen - HowLong > Buf->BufSize) {
+ if (IncreaseBuf(Buf, 1, Buf->BufUsed + ReplLen) < 0) {
return -1;
+ }
+ }
- memmove(Buf->buf + where + ReplLen,
- Buf->buf + where + HowLong,
- Buf->BufUsed - where - HowLong);
-
- memcpy(Buf->buf + where,
- Repl, ReplLen);
-
+ memmove(Buf->buf + where + ReplLen, Buf->buf + where + HowLong, Buf->BufUsed - where - HowLong);
+ memcpy(Buf->buf + where, Repl, ReplLen);
Buf->BufUsed += ReplLen - HowLong;
-
+ Buf->buf[Buf->BufUsed] = 0;
return Buf->BufUsed;
}
-/**
- * @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)
-{
+// Counts the numbmer of tokens in a buffer
+// source String to count tokens in
+// tok Tokenizer char to count
+// @returns numbers of tokenizer chars found
+int StrBufNum_tokens(const StrBuf *source, char tok) {
char *pch, *pche;
long NTokens;
if ((source == NULL) || (source->BufUsed == 0))
return NTokens;
}
-/**
- * @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)
-{
+
+// a string tokenizer
+// Source StringBuffer to read into
+// parmnum n'th Parameter to remove
+// 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, *end; /* dest, source */
+ char *d, *s, *end; // dest, source
int count = 0;
- /* Find desired @parameter */
+ // Find desired eter
end = Source->buf + Source->BufUsed;
d = Source->buf;
- while ((d <= end) &&
- (count < parmnum))
- {
- /* End of string, bail! */
+ while ((d <= end) && (count < parmnum)) {
+ // End of string, bail!
if (!*d) {
d = NULL;
break;
d++;
}
if ((d == NULL) || (d >= end))
- return 0; /* @Parameter not found */
+ return 0; // Parameter not found
- /* Find next @parameter */
+ // Find next eter
s = d;
- while ((s <= end) &&
- (*s && *s != separator))
- {
+ while ((s <= end) && (*s && *s != separator)) {
s++;
}
if (*s == separator)
s++;
ReducedBy = d - s;
- /* Hack and slash */
+ // Hack and slash
if (s >= end) {
return 0;
}
*--d = '\0';
Source->BufUsed += ReducedBy;
}
- /*
- while (*s) {
- *d++ = *s++;
- }
- *d = 0;
- */
+
+ //while (*s) {
+ //*d++ = *s++;
+ //}
+ //*d = 0;
+
return ReducedBy;
}
+int StrBufExtract_tokenFromStr(StrBuf *dest, const char *Source, long SourceLen, int parmnum, char separator) {
+ const StrBuf Temp = {
+ (char*)Source,
+ SourceLen,
+ SourceLen,
+ 1
+#ifdef SIZE_DEBUG
+ ,
+ 0,
+ "",
+ ""
+#endif
+ };
-/**
- * @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)
-{
- const char *s, *e; //* source * /
- int len = 0; //* running total length of extracted string * /
- int current_token = 0; //* token currently being processed * /
+ return StrBufExtract_token(dest, &Temp, parmnum, separator);
+}
+
+// a string tokenizer
+// dest Destination StringBuffer
+// Source StringBuffer to read into
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// returns -1 if not found, else length of token.
+int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char separator) {
+ const char *s, *e; // source
+ int len = 0; // running total length of extracted string
+ int current_token = 0; // token currently being processed
if (dest != NULL) {
dest->buf[0] = '\0';
break;
}
}
- if ( (current_token == parmnum) &&
- (*s != separator)) {
+ if ( (current_token == parmnum) && (*s != separator)) {
dest->buf[len] = *s;
++len;
}
}
-
-
-
-/**
- * @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)
-{
+// a string tokenizer to fetch an integer
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// separator tokenizer character
+// @returns 0 if not found, else integer representation of the token
+int StrBufExtract_int(const StrBuf* Source, int parmnum, char separator) {
StrBuf tmp;
char buf[64];
return 0;
}
-/**
- * @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)
-{
+
+// a string tokenizer to fetch a long integer
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// 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) {
StrBuf tmp;
char buf[64];
}
-/**
- * @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)
-{
+// a string tokenizer to fetch an unsigned long
+// Source String containing tokens
+// parmnum n'th Parameter to extract
+// 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) {
StrBuf tmp;
char buf[64];
char *pnum;
}
-
-/**
- * @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))
- {
+// a string tokenizer; Bounds checker
+// function to make shure whether StrBufExtract_NextToken and friends have reached the end of the string.
+// Source our tokenbuffer
+// 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)
- {
+ if (*pStart == NULL) {
return 1;
}
- else if (*pStart > Source->buf + Source->BufUsed)
- {
+ else if (*pStart > Source->buf + Source->BufUsed) {
return 0;
}
- else if (*pStart <= Source->buf)
- {
+ else if (*pStart <= Source->buf) {
return 0;
}
}
/**
- * @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
+ * a string tokenizer
+ * dest Destination StringBuffer
+ * Source StringBuffer to read into
+ * pStart pointer to the end of the last token. Feed with NULL on start.
+ * separator tokenizer
* @returns -1 if not found, else length of token.
*/
-int StrBufExtract_NextToken(StrBuf *dest, const StrBuf *Source, const char **pStart, char separator)
-{
+int StrBufExtract_NextToken(StrBuf *dest, const StrBuf *Source, const char **pStart, char separator) {
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) )
- {
+ if ((Source == NULL) || (Source->BufUsed == 0)) {
*pStart = StrBufNOTNULL;
- if (dest != NULL)
+ if (dest != NULL) {
FlushStrBuf(dest);
+ }
return -1;
}
EndBuffer = Source->buf + Source->BufUsed;
- if (dest != NULL)
- {
+ if (dest != NULL) {
dest->buf[0] = '\0';
dest->BufUsed = 0;
}
- else
- {
+ else {
*pStart = EndBuffer + 1;
return -1;
}
- if (*pStart == NULL)
- {
+ if (*pStart == NULL) {
*pStart = Source->buf; /* we're starting to examine this buffer. */
}
- else if ((*pStart < Source->buf) ||
- (*pStart > EndBuffer ) )
- {
+ else if ((*pStart < Source->buf) || (*pStart > EndBuffer ) ) {
return -1; /* no more tokens to find. */
}
s = *pStart;
/* start to find the next token */
- while ((s <= EndBuffer) &&
- (current_token == 0) )
- {
- if (*s == separator)
- {
+ while ((s <= EndBuffer) && (current_token == 0) ) {
+ if (*s == separator) {
/* we found the next token */
++current_token;
}
- if (len >= dest->BufSize)
- {
+ if (len >= dest->BufSize) {
/* our Dest-buffer isn't big enough, increase it. */
dest->BufUsed = len;
/**
- * @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
+ * a string tokenizer
+ * Source StringBuffer to read from
+ * pStart pointer to the end of the last token. Feed with NULL.
+ * separator tokenizer character
+ * 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)
-{
+int StrBufSkip_NTokenS(const StrBuf *Source, const char **pStart, char separator, int nTokens) {
const char *s, *EndBuffer; //* source * /
int len = 0; //* running total length of extracted string * /
int current_token = 0; //* token currently being processed * /
- if ((Source == NULL) ||
- (Source->BufUsed ==0)) {
+ if ((Source == NULL) || (Source->BufUsed ==0)) {
return(-1);
}
if (nTokens == 0)
return (-1);
}
-
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) {
++current_token;
return(len);
}
-/**
- * @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)
-{
+
+// a string tokenizer to fetch an integer
+// Source StringBuffer to read from
+// pStart Cursor on the tokenstring
+// 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) {
StrBuf tmp;
char buf[64];
return 0;
}
-/**
- * @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)
-{
+
+// a string tokenizer to fetch a long integer
+// Source StringBuffer to read from
+// pStart Cursor on the tokenstring
+// 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) {
StrBuf tmp;
char buf[64];
}
-/**
- * @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)
-{
+// a string tokenizer to fetch an unsigned long
+// Source StringBuffer to read from
+// pStart Cursor on the tokenstring
+// 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) {
StrBuf tmp;
char buf[64];
char *pnum;
}
-
-
-
/*******************************************************************************
* Escape Appending *
*******************************************************************************/
-/**
- * @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)
-{
+// Escape a string for feeding out as a URL while appending it to a Buffer
+// OutBuf the output buffer
+// In Buffer to encode
+// 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 len;
- if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
+ if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) ) {
return;
+ }
if (PlainIn != NULL) {
len = strlen(PlainIn);
pch = PlainIn;
*pt = '\0';
}
+
+// Escape a string for feeding out as a the username/password part of an URL while appending it to a Buffer
+// OutBuf the output buffer
+// In Buffer to encode
+// PlainIn way in from plain old c strings
+void StrBufUrlescUPAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn) {
+ const char *pch, *pche;
+ char *pt, *pte;
+ int len;
+
+ if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
+ return;
+ if (PlainIn != NULL) {
+ len = strlen(PlainIn);
+ pch = PlainIn;
+ pche = pch + len;
+ }
+ else {
+ pch = In->buf;
+ pche = pch + In->BufUsed;
+ len = In->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ pt = OutBuf->buf + OutBuf->BufUsed;
+ pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */
+
+ while (pch < pche) {
+ if (pt >= pte) {
+ IncreaseBuf(OutBuf, 1, -1);
+ pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */
+ pt = OutBuf->buf + OutBuf->BufUsed;
+ }
+
+ if((*pch >= 'a' && *pch <= 'z') ||
+ (*pch >= 'A' && *pch <= 'Z') || /* A-Z */
+ (*pch >= '0' && *pch <= ':') || /* 0-9 : */
+ (*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 ++;
+ }
+ }
+ *pt = '\0';
+}
+
+
+// append a string with characters having a special meaning in xml encoded to the buffer
+// OutBuf the output buffer
+// In Buffer to encode
+// PlainIn way in from plain old c strings
+// PlainInLen way in from plain old c strings; maybe you've got binary data or know the length?
+// OverrideLowChars should chars < 0x20 be replaced by _ or escaped as xml entity?
+void StrBufXMLEscAppend(StrBuf *OutBuf,
+ const StrBuf *In,
+ const char *PlainIn,
+ long PlainInLen,
+ int OverrideLowChars)
+{
+ const char *pch, *pche;
+ char *pt, *pte;
+ int IsUtf8Sequence;
+ int len;
+
+ if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
+ return;
+ if (PlainIn != NULL) {
+ if (PlainInLen < 0)
+ len = strlen((const char*)PlainIn);
+ else
+ len = PlainInLen;
+ pch = PlainIn;
+ pche = pch + len;
+ }
+ else {
+ pch = (const char*)In->buf;
+ pche = pch + In->BufUsed;
+ len = In->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ pt = OutBuf->buf + OutBuf->BufUsed;
+ /**< we max append 6 chars at once plus the \0 */
+ pte = OutBuf->buf + OutBuf->BufSize - 6;
+
+ while (pch < pche) {
+ if (pt >= pte) {
+ OutBuf->BufUsed = pt - OutBuf->buf;
+ IncreaseBuf(OutBuf, 1, -1);
+ pte = OutBuf->buf + OutBuf->BufSize - 6;
+ /**< we max append 3 chars at once plus the \0 */
+
+ pt = OutBuf->buf + OutBuf->BufUsed;
+ }
+
+ if (*pch == '<') {
+ memcpy(pt, HKEY("<"));
+ pt += 4;
+ pch ++;
+ }
+ else if (*pch == '>') {
+ memcpy(pt, HKEY(">"));
+ pt += 4;
+ pch ++;
+ }
+ else if (*pch == '&') {
+ memcpy(pt, HKEY("&"));
+ pt += 5;
+ pch++;
+ }
+ else if ((*pch >= 0x20) && (*pch <= 0x7F)) {
+ *pt = *pch;
+ pt++; pch++;
+ }
+ else {
+ IsUtf8Sequence = Ctdl_GetUtf8SequenceLength(pch, pche);
+ if (IsUtf8Sequence)
+ {
+ while ((IsUtf8Sequence > 0) &&
+ (pch < pche))
+ {
+ *pt = *pch;
+ pt ++;
+ pch ++;
+ --IsUtf8Sequence;
+ }
+ }
+ else
+ {
+ *pt = '&';
+ pt++;
+ *pt = HexList[*(unsigned char*)pch][0];
+ pt ++;
+ *pt = HexList[*(unsigned char*)pch][1];
+ pt ++; pch ++;
+ *pt = '&';
+ pt++;
+ pch ++;
+ }
+ }
+ }
+ *pt = '\0';
+ OutBuf->BufUsed = pt - OutBuf->buf;
+}
+
+
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief append a string in hex encoding to the buffer
- * @param OutBuf the output buffer
- * @param In Buffer to encode
- * @param PlainIn way in from plain old c strings
- * @param PlainInLen way in from plain old c strings; maybe you've got binary data or know the length?
+ * append a string in hex encoding to the buffer
+ * OutBuf the output buffer
+ * In Buffer to encode
+ * PlainIn way in from plain old c strings
+ * PlainInLen way in from plain old c strings; maybe you've got binary data or know the length?
*/
-void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *PlainIn, long PlainInLen)
-{
+void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *PlainIn, long PlainInLen) {
const unsigned char *pch, *pche;
char *pt, *pte;
int len;
*pt = '\0';
}
-/**
- * @ingroup StrBuf_DeEnCoder
- * @brief append a string in hex encoding to the buffer
- * @param OutBuf the output buffer
- * @param In Buffer to encode
- * @param PlainIn way in from plain old c strings
- */
-void StrBufHexescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn)
-{
+
+void StrBufBase64Append(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn, long PlainInLen, int linebreaks) {
+ const char *pch;
+ char *pt;
+ int len;
+ long ExpectLen;
+
+ if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
+ return;
+ if (PlainIn != NULL) {
+ if (PlainInLen < 0)
+ len = strlen(PlainIn);
+ else
+ len = PlainInLen;
+ pch = PlainIn;
+ }
+ else {
+ pch = In->buf;
+ len = In->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ ExpectLen = ((len * 134) / 100) + OutBuf->BufUsed;
+
+ if (ExpectLen > OutBuf->BufSize)
+ if (IncreaseBuf(OutBuf, 1, ExpectLen) < ExpectLen)
+ return;
+
+ pt = OutBuf->buf + OutBuf->BufUsed;
+
+ len = CtdlEncodeBase64(pt, pch, len, linebreaks);
+
+ pt += len;
+ OutBuf->BufUsed += len;
+ *pt = '\0';
+}
+
+
+// append a string in hex encoding to the buffer
+// OutBuf the output buffer
+// In Buffer to encode
+// PlainIn way in from plain old c strings
+void StrBufHexescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn) {
StrBufHexEscAppend(OutBuf, In, (const unsigned char*) PlainIn, -1);
}
-/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Append a string, escaping characters which have meaning in HTML.
+/*
+ * 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.
+ * Target target buffer
+ * Source source buffer; set to NULL if you just have a C-String
+ * PlainIn Plain-C string to append; set to NULL if unused
+ * nbsp If nonzero, spaces are converted to non-breaking spaces.
+ * 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)
-{
+long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks) {
const char *aptr, *eiptr;
char *bptr, *eptr;
long len;
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Append a string, escaping characters which have meaning in HTML.
+ * 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
+ * Target target buffer
+ * Source source buffer; set to NULL if you just have a C-String
+ * PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
-{
+void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *tptr, *eptr;
long len;
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Append a string, escaping characters which have meaning in ICAL.
+ * 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
+ * Target target buffer
+ * Source source buffer; set to NULL if you just have a C-String
+ * PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
-{
+void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *tptr, *eptr;
long len;
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Append a string, escaping characters which have meaning in JavaScript strings .
+ * 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
+ * Target target buffer
+ * Source source buffer; set to NULL if you just have a C-String
+ * 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)
-{
+long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) {
const char *aptr, *eiptr;
char *bptr, *eptr;
long len;
return Target->BufUsed;
}
-/**
- * @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)
-{
+// Append a string, escaping characters which have meaning in HTML + json.
+//
+// Target target buffer
+// Source source buffer; set to NULL if you just have a C-String
+// PlainIn Plain-C string to append; set to NULL if unused
+// nbsp If nonzero, spaces are converted to non-breaking spaces.
+// 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) )
+ if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL)) {
return -1;
-
+ }
if (PlainIn != NULL) {
aptr = PlainIn;
len = strlen(PlainIn);
len = Source->BufUsed;
}
- if (len == 0)
+ if (len == 0) {
return -1;
+ }
bptr = Target->buf + Target->BufUsed;
- eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
+ eptr = Target->buf + Target->BufSize - 11; // our biggest unit to put in...
- while (aptr < eiptr){
+ while (aptr < eiptr) {
if(bptr >= eptr) {
IncreaseBuf(Target, 1, -1);
- eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
+ eptr = Target->buf + Target->BufSize - 11; // our biggest unit to put in...
bptr = Target->buf + Target->BufUsed;
}
switch (*aptr) {
isxdigit(*(aptr + 3)) &&
isxdigit(*(aptr + 4)) &&
isxdigit(*(aptr + 5)))
- { /* oh, a unicode escaper. let it pass through. */
+ { /* oh, a unicode escaper. let it pass through. */
memcpy(bptr, aptr, 6);
aptr += 5;
bptr +=6;
Target->BufUsed += 6;
}
- else
- {
+ else {
*bptr = '\\';
bptr ++;
*bptr = '\\';
bptr ++;
Target->BufUsed += 2;
break;
- case 32:
+ case 32:
if (nbsp == 1) {
memcpy(bptr, HKEY(" "));
bptr += 6;
return Target->BufUsed;
}
-/**
- * @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
+
+/*
+ * replace all non-Ascii characters by another
+ * Buf buffer to inspect
+ * repl charater to stamp over non ascii chars
*/
-void StrBufEUid_unescapize(StrBuf *target, const StrBuf *source)
-{
+void StrBufAsciify(StrBuf *Buf, const char repl) {
+ long offset;
+
+ for (offset = 0; offset < Buf->BufUsed; offset ++)
+ if (!isascii(Buf->buf[offset]))
+ Buf->buf[offset] = repl;
+
+}
+
+
+// unhide special chars hidden to the HTML escaper
+// target buffer to put the unescaped string in
+// source buffer to unescape
+void StrBufEUid_unescapize(StrBuf *target, const StrBuf *source) {
int a, b, len;
char hex[3];
+ if ((source == NULL) || (target == NULL) || (target->buf == NULL)) {
+ return;
+ }
+
+ if (target != NULL)
+ FlushStrBuf(target);
+
+ len = source->BufUsed;
+ for (a = 0; a < len; ++a) {
+ if (target->BufUsed >= target->BufSize)
+ IncreaseBuf(target, 1, -1);
+
+ if (source->buf[a] == '=') {
+ hex[0] = source->buf[a + 1];
+ hex[1] = source->buf[a + 2];
+ hex[2] = 0;
+ b = 0;
+ sscanf(hex, "%02x", &b);
+ target->buf[target->BufUsed] = b;
+ target->buf[++target->BufUsed] = 0;
+ a += 2;
+ }
+ else {
+ target->buf[target->BufUsed] = source->buf[a];
+ target->buf[++target->BufUsed] = 0;
+ }
+ }
+}
+
+
+/*
+ * hide special chars from the HTML escapers and friends
+ * target buffer to put the escaped string in
+ * source buffer to escape
+ */
+void StrBufEUid_escapize(StrBuf *target, const StrBuf *source) {
+ int i, len;
+
if (target != NULL)
FlushStrBuf(target);
- if (source == NULL ||target == NULL)
+ if ((source == NULL) || (target == NULL) || (target->buf == NULL)) {
+ return;
+ }
+
+ len = source->BufUsed;
+ for (i=0; i<len; ++i) {
+ if (target->BufUsed + 4 >= target->BufSize)
+ IncreaseBuf(target, 1, -1);
+ if ( (isalnum(source->buf[i])) ||
+ (source->buf[i]=='-') ||
+ (source->buf[i]=='_') ) {
+ target->buf[target->BufUsed++] = source->buf[i];
+ }
+ else {
+ sprintf(&target->buf[target->BufUsed],
+ "=%02X",
+ (0xFF &source->buf[i]));
+ target->BufUsed += 3;
+ }
+ }
+ target->buf[target->BufUsed + 1] = '\0';
+}
+
+
+/*******************************************************************************
+ * Quoted Printable de/encoding *
+ *******************************************************************************/
+
+/*
+ * decode a buffer from base 64 encoding; destroys original
+ * Buf Buffor to transform
+ */
+int StrBufDecodeBase64(StrBuf *Buf) {
+ char *xferbuf;
+ size_t siz;
+
+ if (Buf == NULL) {
+ return -1;
+ }
+
+ xferbuf = (char*) malloc(Buf->BufSize);
+ if (xferbuf == NULL)
+ return -1;
+
+ *xferbuf = '\0';
+ siz = CtdlDecodeBase64(xferbuf, Buf->buf, Buf->BufUsed);
+ free(Buf->buf);
+ Buf->buf = xferbuf;
+ Buf->BufUsed = siz;
+
+ Buf->buf[Buf->BufUsed] = '\0';
+ return siz;
+}
+
+
+/*
+ * decode a buffer from base 64 encoding; expects targetbuffer
+ * BufIn Buffor to transform
+ * BufOut Buffer to put result into
+ */
+int StrBufDecodeBase64To(const StrBuf *BufIn, StrBuf *BufOut) {
+ if ((BufIn == NULL) || (BufOut == NULL))
+ return -1;
+
+ if (BufOut->BufSize < BufIn->BufUsed) {
+ IncreaseBuf(BufOut, 0, BufIn->BufUsed);
+ }
+
+ BufOut->BufUsed = CtdlDecodeBase64(BufOut->buf, BufIn->buf, BufIn->BufUsed);
+ return BufOut->BufUsed;
+}
+
+typedef struct __z_enc_stream {
+ StrBuf OutBuf;
+ z_stream zstream;
+} z_enc_stream;
+
+
+vStreamT *StrBufNewStreamContext(eStreamType type, const char **Err) {
+ *Err = NULL;
+
+ switch (type) {
+
+ case eZLibDecode: {
+
+ z_enc_stream *stream;
+ int err;
+
+ stream = (z_enc_stream *) malloc(sizeof(z_enc_stream));
+ memset(stream, 0, sizeof(z_enc_stream));
+ stream->OutBuf.BufSize = 4*SIZ; /// TODO 64
+ stream->OutBuf.buf = (char*)malloc(stream->OutBuf.BufSize);
+
+ err = inflateInit(&stream->zstream);
+
+ if (err != Z_OK) {
+ StrBufDestroyStreamContext(type, (vStreamT**) &stream, Err);
+ *Err = zError(err);
+ return NULL;
+ }
+ return (vStreamT*) stream;
+
+ }
+
+ case eZLibEncode: {
+ z_enc_stream *stream;
+ int err;
+
+ stream = (z_enc_stream *) malloc(sizeof(z_enc_stream));
+ memset(stream, 0, sizeof(z_enc_stream));
+ stream->OutBuf.BufSize = 4*SIZ; /// todo 64
+ stream->OutBuf.buf = (char*)malloc(stream->OutBuf.BufSize);
+ /* write gzip header */
+ stream->OutBuf.BufUsed = snprintf
+ (stream->OutBuf.buf,
+ stream->OutBuf.BufSize,
+ "%c%c%c%c%c%c%c%c%c%c",
+ gz_magic[0], gz_magic[1], Z_DEFLATED,
+ 0 /*flags */ , 0, 0, 0, 0 /*time */ , 0 /* xflags */ ,
+ OS_CODE);
+
+ err = deflateInit2(&stream->zstream,
+ ZLibCompressionRatio,
+ Z_DEFLATED,
+ -MAX_WBITS,
+ DEF_MEM_LEVEL,
+ Z_DEFAULT_STRATEGY);
+ if (err != Z_OK) {
+ StrBufDestroyStreamContext(type, (vStreamT**) &stream, Err);
+ *Err = zError(err);
+ return NULL;
+ }
+ return (vStreamT*) stream;
+ }
+
+ case eEmtyCodec:
+ /// TODO
+ break;
+ }
+ return NULL;
+}
+
+
+int StrBufDestroyStreamContext(eStreamType type, vStreamT **vStream, const char **Err) {
+ int err;
+ int rc = 0;
+ *Err = NULL;
+
+ if ((vStream == NULL) || (*vStream==NULL)) {
+ *Err = strerror(EINVAL);
+ return EINVAL;
+ }
+ switch (type)
+ {
+ //case eBase64Encode:
+ //case eBase64Decode:
+ //free(*vStream);
+ //*vStream = NULL;
+ //break;
+ case eZLibDecode:
+ {
+ z_enc_stream *stream = (z_enc_stream *)*vStream;
+ (void)inflateEnd(&stream->zstream);
+ free(stream->OutBuf.buf);
+ free(stream);
+ }
+ case eZLibEncode:
+ {
+ z_enc_stream *stream = (z_enc_stream *)*vStream;
+ err = deflateEnd(&stream->zstream);
+ if (err != Z_OK) {
+ *Err = zError(err);
+ rc = -1;
+ }
+ free(stream->OutBuf.buf);
+ free(stream);
+ *vStream = NULL;
+ break;
+ }
+ case eEmtyCodec:
+ break; /// TODO
+ }
+ return rc;
+}
+
+int StrBufStreamTranscode(eStreamType type, IOBuffer *Target, IOBuffer *In, const char* pIn, long pInLen, vStreamT *vStream, int LastChunk, const char **Err) {
+ int rc = 0;
+ switch (type)
{
- return;
- }
+ //case eBase64Encode:
+ //{
+ // ???
+ //}
+ //break;
+ //case eBase64Decode:
+ //{
+ //// ???
+ //}
+ //break;
+ case eZLibEncode:
+ {
+ z_enc_stream *stream = (z_enc_stream *)vStream;
+ int org_outbuf_len = stream->OutBuf.BufUsed;
+ int err;
+ unsigned int chunkavail;
- len = source->BufUsed;
- for (a = 0; a < len; ++a) {
- if (target->BufUsed >= target->BufSize)
- IncreaseBuf(target, 1, -1);
+ if (In->ReadWritePointer != NULL)
+ {
+ stream->zstream.next_in = (Bytef *) In->ReadWritePointer;
+ stream->zstream.avail_in = (uInt) In->Buf->BufUsed -
+ (In->ReadWritePointer - In->Buf->buf);
+ }
+ else
+ {
+ stream->zstream.next_in = (Bytef *) In->Buf->buf;
+ stream->zstream.avail_in = (uInt) In->Buf->BufUsed;
+ }
+
+ stream->zstream.next_out = (unsigned char*)stream->OutBuf.buf + stream->OutBuf.BufUsed;
+ stream->zstream.avail_out = chunkavail = (uInt) stream->OutBuf.BufSize - stream->OutBuf.BufUsed;
- if (source->buf[a] == '=') {
- hex[0] = source->buf[a + 1];
- hex[1] = source->buf[a + 2];
- hex[2] = 0;
- b = 0;
- sscanf(hex, "%02x", &b);
- target->buf[target->BufUsed] = b;
- target->buf[++target->BufUsed] = 0;
- a += 2;
+ err = deflate(&stream->zstream, (LastChunk) ? Z_FINISH : Z_NO_FLUSH);
+
+ stream->OutBuf.BufUsed += (chunkavail - stream->zstream.avail_out);
+
+ if (Target && (LastChunk || (stream->OutBuf.BufUsed != org_outbuf_len))) {
+ iSwapBuffers(Target->Buf, &stream->OutBuf);
+ }
+
+ if (stream->zstream.avail_in == 0) {
+ FlushStrBuf(In->Buf);
+ In->ReadWritePointer = NULL;
}
else {
- target->buf[target->BufUsed] = source->buf[a];
- target->buf[++target->BufUsed] = 0;
+ if (stream->zstream.avail_in < 64) {
+ memmove(In->Buf->buf,
+ In->Buf->buf + In->Buf->BufUsed - stream->zstream.avail_in,
+ stream->zstream.avail_in);
+
+ In->Buf->BufUsed = stream->zstream.avail_in;
+ In->Buf->buf[In->Buf->BufUsed] = '\0';
+ }
+ else {
+ In->ReadWritePointer = In->Buf->buf + (In->Buf->BufUsed - stream->zstream.avail_in);
+ }
}
+ rc = (LastChunk && (err != Z_FINISH));
+ if (!rc && (err != Z_OK)) {
+ *Err = zError(err);
+ }
+
}
-}
+ break;
+ case eZLibDecode: {
+ z_enc_stream *stream = (z_enc_stream *)vStream;
+ int org_outbuf_len = stream->zstream.total_out;
+ int err;
+ if ((stream->zstream.avail_out != 0) && (stream->zstream.next_in != NULL)) {
+ if (In->ReadWritePointer != NULL) {
+ stream->zstream.next_in = (Bytef *) In->ReadWritePointer;
+ stream->zstream.avail_in = (uInt) In->Buf->BufUsed - (In->ReadWritePointer - In->Buf->buf);
+ }
+ else {
+ stream->zstream.next_in = (Bytef *) In->Buf->buf;
+ stream->zstream.avail_in = (uInt) In->Buf->BufUsed;
+ }
+ }
-/**
- * @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)
-{
- int i, len;
+ stream->zstream.next_out = (unsigned char*)stream->OutBuf.buf + stream->OutBuf.BufUsed;
+ stream->zstream.avail_out = (uInt) stream->OutBuf.BufSize - stream->OutBuf.BufUsed;
- if (target != NULL)
- FlushStrBuf(target);
+ err = inflate(&stream->zstream, Z_NO_FLUSH);
- if (source == NULL ||target == NULL)
- {
- return;
- }
+ ///assert(ret != Z_STREAM_ERROR); /* state not clobbered * /
+ switch (err) {
+ case Z_NEED_DICT:
+ err = Z_DATA_ERROR; /* and fall through */
- len = source->BufUsed;
- for (i=0; i<len; ++i) {
- if (target->BufUsed + 4 >= target->BufSize)
- IncreaseBuf(target, 1, -1);
- if ( (isalnum(source->buf[i])) ||
- (source->buf[i]=='-') ||
- (source->buf[i]=='_') ) {
- target->buf[target->BufUsed++] = source->buf[i];
+ case Z_DATA_ERROR:
+ *Err = zError(err);
+ case Z_MEM_ERROR:
+ (void)inflateEnd(&stream->zstream);
+ return err;
}
- else {
- sprintf(&target->buf[target->BufUsed],
- "=%02X",
- (0xFF &source->buf[i]));
- target->BufUsed += 3;
- }
- }
- target->buf[target->BufUsed + 1] = '\0';
-}
+ stream->OutBuf.BufUsed += stream->zstream.total_out + org_outbuf_len;
-/*******************************************************************************
- * Quoted Printable de/encoding *
- *******************************************************************************/
+ if (Target) iSwapBuffers(Target->Buf, &stream->OutBuf);
-/**
- * @ingroup StrBuf_DeEnCoder
- * @brief decode a buffer from base 64 encoding; destroys original
- * @param Buf Buffor to transform
- */
-int StrBufDecodeBase64(StrBuf *Buf)
-{
- char *xferbuf;
- size_t siz;
- if (Buf == NULL) return -1;
+ if (stream->zstream.avail_in == 0) {
+ FlushStrBuf(In->Buf);
+ In->ReadWritePointer = NULL;
+ }
+ else {
+ if (stream->zstream.avail_in < 64) {
+ memmove(In->Buf->buf,
+ In->Buf->buf + In->Buf->BufUsed - stream->zstream.avail_in,
+ stream->zstream.avail_in);
- xferbuf = (char*) malloc(Buf->BufSize);
- *xferbuf = '\0';
- siz = CtdlDecodeBase64(xferbuf,
- Buf->buf,
- Buf->BufUsed);
- free(Buf->buf);
- Buf->buf = xferbuf;
- Buf->BufUsed = siz;
- return siz;
+ In->Buf->BufUsed = stream->zstream.avail_in;
+ In->Buf->buf[In->Buf->BufUsed] = '\0';
+ }
+ else {
+
+ In->ReadWritePointer = In->Buf->buf + (In->Buf->BufUsed - stream->zstream.avail_in);
+ }
+ }
+ }
+ break;
+ case eEmtyCodec: {
+
+ }
+ break; /// TODO
+ }
+ return rc;
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief decode a buffer from base 64 encoding; destroys original
- * @param Buf Buffor to transform
+ * decode a buffer from base 64 encoding; destroys original
+ * Buf Buffor to transform
*/
-int StrBufDecodeHex(StrBuf *Buf)
-{
+int StrBufDecodeHex(StrBuf *Buf) {
unsigned int ch;
char *pch, *pche, *pchi;
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief replace all chars >0x20 && < 0x7F with Mute
- * @param Mute char to put over invalid chars
- * @param Buf Buffor to transform
+ * replace all chars >0x20 && < 0x7F with Mute
+ * Mute char to put over invalid chars
+ * Buf Buffor to transform
*/
-int StrBufSanitizeAscii(StrBuf *Buf, const char Mute)
-{
+int StrBufSanitizeAscii(StrBuf *Buf, const char Mute) {
unsigned char *pch;
if (Buf == NULL) return -1;
/**
- * @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?
+ * remove escaped strings from i.e. the url string (like %20 for blanks)
+ * Buf Buffer to translate
+ * StripBlanks Reduce several blanks to one?
*/
-long StrBufUnescape(StrBuf *Buf, int StripBlanks)
-{
+long StrBufUnescape(StrBuf *Buf, int StripBlanks) {
int a, b;
char hex[3];
long len;
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief RFC2047-encode a header field if necessary.
+ * 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.
+ * target Target buffer.
+ * source Source string to be encoded.
* @returns encoded length; -1 if non success.
*/
-int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
-{
+int StrBufRFC2047encode(StrBuf **target, const StrBuf *source) {
const char headerStr[] = "=?UTF-8?Q?";
int need_to_encode = 0;
int i = 0;
FlushStrBuf(*target);
StrBufAppendBuf(*target, source, 0);
}
- return (*target)->BufUsed;
+ if (*target != 0)
+ return (*target)->BufUsed;
+ else
+ return 0;
}
if (*target == NULL)
*target = NewStrBufPlain(NULL, sizeof(headerStr) + source->BufUsed * 2);
ch = (unsigned char) source->buf[i];
if ((ch < 32) ||
(ch > 126) ||
- (ch == 61) ||
(ch == '=') ||
(ch == '?') ||
(ch == '_') ||
return (*target)->BufUsed;;
}
+// Quoted-Printable encode a message; make it < 80 columns width.
+// source Source string to be encoded.
+// returns buffer with encoded message.
+StrBuf *StrBufQuotedPrintableEncode(const StrBuf *EncodeMe) {
+ StrBuf *OutBuf;
+ char *Optr, *OEptr;
+ const char *ptr, *eptr;
+ unsigned char ch;
+ int LinePos;
+
+ OutBuf = NewStrBufPlain(NULL, StrLength(EncodeMe) * 4);
+ Optr = OutBuf->buf;
+ OEptr = OutBuf->buf + OutBuf->BufSize;
+ ptr = EncodeMe->buf;
+ eptr = EncodeMe->buf + EncodeMe->BufUsed;
+ LinePos = 0;
+
+ while (ptr < eptr) {
+ if (Optr + 4 >= OEptr) {
+ long Offset;
+ Offset = Optr - OutBuf->buf;
+ OutBuf->BufUsed = Optr - OutBuf->buf;
+ IncreaseBuf(OutBuf, 1, 0);
+ Optr = OutBuf->buf + Offset;
+ OEptr = OutBuf->buf + OutBuf->BufSize;
+ }
+ if (*ptr == '\r') { // ignore carriage returns
+ ptr ++;
+ }
+ else if (*ptr == '\n') { // hard line break
+ memcpy(Optr, HKEY("=0A"));
+ Optr += 3;
+ LinePos += 3;
+ ptr ++;
+ }
+ else if (( (*ptr >= 32) && (*ptr <= 60) ) || ( (*ptr >= 62) && (*ptr <= 126) )) {
+ *Optr = *ptr;
+ Optr ++;
+ ptr ++;
+ LinePos ++;
+ }
+ else {
+ ch = *ptr;
+ *Optr = '=';
+ Optr ++;
+ *Optr = HexList[ch][0];
+ Optr ++;
+ *Optr = HexList[ch][1];
+ Optr ++;
+ LinePos += 3;
+ ptr ++;
+ }
+ if (LinePos > 72) { // soft line break
+ if (isspace(*(Optr - 1))) {
+ ch = *(Optr - 1);
+ Optr --;
+ *Optr = '=';
+ Optr ++;
+ *Optr = HexList[ch][0];
+ Optr ++;
+ *Optr = HexList[ch][1];
+ Optr ++;
+ LinePos += 3;
+ }
+ *Optr = '=';
+ Optr ++;
+ *Optr = '\n';
+ Optr ++;
+ LinePos = 0;
+ }
+ }
+ *Optr = '\0';
+ OutBuf->BufUsed = Optr - OutBuf->buf;
-static void AddRecipient(StrBuf *Target,
- StrBuf *UserName,
- StrBuf *EmailAddress,
- StrBuf *EncBuf)
-{
+ return OutBuf;
+}
+
+
+static void AddRecipient(StrBuf *Target, StrBuf *UserName, StrBuf *EmailAddress, StrBuf *EncBuf) {
int QuoteMe = 0;
if (StrLength(Target) > 0) StrBufAppendBufPlain(Target, HKEY(", "), 0);
* \param EncBuf Temporary buffer for internal use; Please provide valid buffer.
* \returns encoded & sanitized buffer with the contents of Recp; Caller owns this memory.
*/
-StrBuf *StrBufSanitizeEmailRecipientVector(const StrBuf *Recp,
- StrBuf *UserName,
- StrBuf *EmailAddress,
- StrBuf *EncBuf)
-{
+StrBuf *StrBufSanitizeEmailRecipientVector(const StrBuf *Recp, StrBuf *UserName, StrBuf *EmailAddress, StrBuf *EncBuf) {
StrBuf *Target;
const char *pch, *pche;
const char *UserStart, *UserEnd, *EmailStart, *EmailEnd, *At;
while ((pch != NULL) && (pch < pche))
{
while (isspace(*pch)) pch++;
- UserStart = UserEnd = EmailStart = EmailEnd = NULL;
+ UserEnd = EmailStart = EmailEnd = NULL;
if ((*pch == '"') || (*pch == '\'')) {
UserStart = pch + 1;
EmailStart ++;
if (UserStart >= UserEnd)
UserStart = UserEnd = NULL;
- At = strchr(EmailStart, '@');
}
else { /* this is a local recipient... no domain, just a realname */
EmailStart = UserStart;
/**
- * @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
+ * replaces all occurances of 'search' by 'replace'
+ * buf Buffer to modify
+ * search character to search
+ * replace character to replace search by
*/
-void StrBufReplaceChars(StrBuf *buf, char search, char replace)
-{
+void StrBufReplaceChars(StrBuf *buf, char search, char replace) {
long i;
if (buf == NULL)
return;
}
/**
- * @ingroup StrBuf
- * @brief removes all \\r s from the string, or replaces them with \n if its not a combination of both.
- * @param buf Buffer to modify
+ * removes all \\r s from the string, or replaces them with \n if its not a combination of both.
+ * buf Buffer to modify
*/
-void StrBufToUnixLF(StrBuf *buf)
-{
+void StrBufToUnixLF(StrBuf *buf) {
char *pche, *pchS, *pchT;
if (buf == NULL)
return;
*******************************************************************************/
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Wrapper around iconv_open()
+ * Wrapper around iconv_open()
* Our version adds aliases for non-standard Microsoft charsets
* such as 'MS950', aliasing them to names like 'CP950'
*
- * @param tocode Target encoding
- * @param fromcode Source encoding
- * @param pic anonimized pointer to iconv struct
+ * tocode Target encoding
+ * fromcode Source encoding
+ * pic anonimized pointer to iconv struct
*/
-void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic)
-{
+void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic) {
#ifdef HAVE_ICONV
iconv_t ic = (iconv_t)(-1) ;
ic = iconv_open(tocode, fromcode);
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief find one chunk of a RFC822 encoded string
- * @param Buffer where to search
- * @param bptr where to start searching
+ * find one chunk of a RFC822 encoded string
+ * Buffer where to search
+ * bptr where to start searching
* @returns found position, NULL if none.
*/
-static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr)
-{
+static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr) {
const char * end;
/* Find the next ?Q? */
if (Buf->BufUsed - (bptr - Buf->buf) < 6)
/**
- * @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
+ * convert one buffer according to the preselected iconv pointer PIC
+ * ConvertBuf buffer we need to translate
+ * TmpBuf To share a workbuffer over several iterations. prepare to have it filled with useless stuff afterwards.
+ * pic Pointer to the iconv-session Object
*/
-void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
-{
+void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic) {
#ifdef HAVE_ICONV
long trycount = 0;
size_t siz;
size_t obuflen; /**< Length of output buffer */
+ if ((ConvertBuf == NULL) || (TmpBuf == NULL))
+ return;
+
/* 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);
TmpBuf->buf[TmpBuf->BufUsed] = '\0';
/* little card game: wheres the red lady? */
- SwapBuffers(ConvertBuf, TmpBuf);
+ iSwapBuffers(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.
+ * catches one RFC822 encoded segment, and decodes it.
+ * Target buffer to fill with result
+ * DecodeMe buffer with stuff to process
+ * SegmentStart points to our current segment in DecodeMe
+ * SegmentEnd Points to the end of our current segment in DecodeMe
+ * ConvertBuf Workbuffer shared between several iterations. Random content; needs to be valid
+ * ConvertBuf2 Workbuffer shared between several iterations. Random content; needs to be valid
+ * FoundCharset Characterset to default decoding to; if we find another we will overwrite it.
*/
inline static void DecodeSegment(StrBuf *Target,
const StrBuf *DecodeMe,
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Handle subjects with RFC2047 encoding such as: [deprecated old syntax!]
+ * Handle subjects with RFC2047 encoding such as: [deprecated old syntax!]
* =?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,
+ * Target where to put the decoded string to
+ * DecodeMe buffer with encoded string
+ * DefaultCharset if we don't find one, which should we use?
+ * 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)
-{
+void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset) {
StrBuf *ConvertBuf;
StrBuf *ConvertBuf2;
ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe));
}
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief Handle subjects with RFC2047 encoding such as:
+ * 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,
+ * Target where to put the decoded string to
+ * DecodeMe buffer with encoded string
+ * DefaultCharset if we don't find one, which should we use?
+ * 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.
- * @param ConvertBuf workbuffer. feed in, you shouldn't care about its content.
- * @param ConvertBuf2 workbuffer. feed in, you shouldn't care about its content.
+ * ConvertBuf workbuffer. feed in, you shouldn't care about its content.
+ * ConvertBuf2 workbuffer. feed in, you shouldn't care about its content.
*/
void StrBuf_RFC822_2_Utf8(StrBuf *Target,
const StrBuf *DecodeMe,
#endif
const char *eptr;
int passes = 0;
- int i, len;
+ int i;
int illegal_non_rfc2047_encoding = 0;
+
+ if (DecodeMe == NULL)
+ return;
/* Sometimes, badly formed messages contain strings which were simply
* written out directly in some foreign character set instead of
* using RFC2047 encoding. This is illegal but we will attempt to
* charset to UTF-8 if we see any nonprintable characters.
*/
- len = StrLength(DecodeMe);
for (i=0; i<DecodeMe->BufUsed; ++i) {
if ((DecodeMe->buf[i] < 32) || (DecodeMe->buf[i] > 126)) {
illegal_non_rfc2047_encoding = 1;
}
/* pre evaluate the first pair */
- nextend = end = NULL;
- len = StrLength(DecodeMee);
+ end = NULL;
start = strstr(DecodeMee->buf, "=?");
eptr = DecodeMee->buf + DecodeMee->BufUsed;
if (start != NULL)
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
*******************************************************************************/
/**
- * @ingroup StrBuf
- * @brief evaluate the length of an utf8 special character sequence
- * @param Char the character to examine
+ * evaluate the length of an utf8 special character sequence
+ * Char the character to examine
* @returns width of utf8 chars in bytes; if the sequence is broken 0 is returned; 1 if its simply ASCII.
*/
-static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE)
-{
+static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE) {
int n = 0;
unsigned char test = (1<<7);
}
/**
- * @ingroup StrBuf
- * @brief detect whether this char starts an utf-8 encoded char
- * @param Char character to inspect
+ * detect whether this char starts an utf-8 encoded char
+ * Char character to inspect
* @returns yes or no
*/
-static inline int Ctdl_IsUtf8SequenceStart(const char Char)
-{
+static inline int Ctdl_IsUtf8SequenceStart(const char Char) {
/** 11??.???? indicates an UTF8 Sequence. */
return ((Char & 0xC0) == 0xC0);
}
/**
- * @ingroup StrBuf
- * @brief measure the number of glyphs in an UTF8 string...
- * @param Buf string to measure
+ * measure the number of glyphs in an UTF8 string...
+ * Buf string to measure
* @returns the number of glyphs in Buf
*/
-long StrBuf_Utf8StrLen(StrBuf *Buf)
-{
+long StrBuf_Utf8StrLen(StrBuf *Buf) {
int n = 0;
int m = 0;
char *aptr, *eptr;
}
/**
- * @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?
+ * cuts a string after maxlen glyphs
+ * Buf string to cut to maxlen glyphs
+ * maxlen how long may the string become?
* @returns current length of the string
*/
-long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen)
-{
+long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen) {
char *aptr, *eptr;
int n = 0, m = 0;
n++;
aptr++;
}
- if (n > maxlen) {
+ if (n >= maxlen) {
*aptr = '\0';
Buf->BufUsed = aptr - Buf->buf;
return Buf->BufUsed;
- }
+ }
}
return Buf->BufUsed;
}
-
-
-
/*******************************************************************************
* wrapping ZLib *
*******************************************************************************/
-#ifdef HAVE_ZLIB
-#define DEF_MEM_LEVEL 8 /*< memlevel??? */
-#define OS_CODE 0x03 /*< unix */
-
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief uses the same calling syntax as compress2(), but it
+ * 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
+ * dest compressed buffer
+ * destLen length of the compresed data
+ * source source to encode
+ * sourceLen length of source to encode
+ * level compression level
*/
+#ifdef HAVE_ZLIB
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 */
-
/* write gzip header */
snprintf((char *) dest, *destLen,
"%c%c%c%c%c%c%c%c%c%c",
/**
- * @ingroup StrBuf_DeEnCoder
- * @brief compress the buffer with gzip
+ * 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
+ * Buf buffer whose content is to be gzipped
*/
-int CompressBuffer(StrBuf *Buf)
-{
+int CompressBuffer(StrBuf *Buf) {
#ifdef HAVE_ZLIB
char *compressed_data = NULL;
size_t compressed_len, bufsize;
return 0;
}
+
/*******************************************************************************
* File I/O; Callbacks to libevent *
*******************************************************************************/
-long StrBuf_read_one_chunk_callback (int fd, short event, IOBuffer *FB)
-{
+long StrBuf_read_one_chunk_callback (int fd, short event, IOBuffer *FB) {
long bufremain = 0;
int n;
* where a cut left is inexpensive
*/
- if (FB->ReadWritePointer != NULL)
- {
+ if (FB->ReadWritePointer != NULL) {
long already_read;
already_read = FB->ReadWritePointer - FB->Buf->buf;
FB->ReadWritePointer = FB->Buf->buf;
bufremain = FB->Buf->BufSize;
}
- else if ((unread < 64) ||
- (bufremain < already_read))
- {
+ else if ((unread < 64) || (bufremain < already_read)) {
/*
* if its just a tiny bit remaining, or we run out of space...
* lets tidy up.
FB->ReadWritePointer = FB->Buf->buf;
bufremain = FB->Buf->BufSize - unread - 1;
}
- else if (bufremain < (FB->Buf->BufSize / 10))
- {
+ else if (bufremain < (FB->Buf->BufSize / 10)) {
/* get a bigger buffer */
IncreaseBuf(FB->Buf, 0, FB->Buf->BufUsed + 1);
return n;
}
-int StrBuf_write_one_chunk_callback(int fd, short event, IOBuffer *FB)
-{
+
+int StrBuf_write_one_chunk_callback(int fd, short event, IOBuffer *FB) {
long WriteRemain;
int n;
return n;
}
-/**
- * @ingroup StrBuf_IO
- * @brief extract a "next line" from Buf; Ptr to persist across several iterations
- * @param LineBuf your line will be copied here.
- * @param FB 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
- */
-eReadState StrBufChunkSipLine(StrBuf *LineBuf, IOBuffer *FB)
-{
+
+// extract a "next line" from Buf; Ptr to persist across several iterations
+// LineBuf your line will be copied here.
+// FB BLOB with lines of text...
+// 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
+eReadState StrBufChunkSipLine(StrBuf *LineBuf, IOBuffer *FB) {
const char *aptr, *ptr, *eptr;
char *optr, *xptr;
+ if ((FB == NULL) || (LineBuf == NULL) || (LineBuf->buf == NULL))
+ return eReadFail;
+
+
if ((FB->Buf == NULL) || (FB->ReadWritePointer == StrBufNOTNULL)) {
FB->ReadWritePointer = StrBufNOTNULL;
return eReadFail;
eptr = FB->Buf->buf + FB->Buf->BufUsed;
xptr = LineBuf->buf + LineBuf->BufSize - 1;
- while ((ptr <= eptr) &&
- (*ptr != '\n') &&
- (*ptr != '\r') )
- {
+ while ((ptr <= eptr) && (*ptr != '\n') && (*ptr != '\r') ) {
*optr = *ptr;
optr++; ptr++;
if (optr == xptr) {
if ((*(ptr - 1) != '\r') && (*(ptr - 1) != '\n')) {
LineBuf->BufUsed = optr - LineBuf->buf;
*optr = '\0';
- if ((FB->ReadWritePointer != NULL) &&
- (FB->ReadWritePointer != FB->Buf->buf))
- {
- /* Ok, the client application read all the data
- it was interested in so far. Since there is more to read,
- we now shrink the buffer, and move the rest over.
- */
- StrBufCutLeft(FB->Buf,
- FB->ReadWritePointer - FB->Buf->buf);
+ if ((FB->ReadWritePointer != NULL) && (FB->ReadWritePointer != FB->Buf->buf)) {
+ // Ok, the client application read all the data
+ // it was interested in so far. Since there is more to read,
+ // we now shrink the buffer, and move the rest over.
+ StrBufCutLeft(FB->Buf, FB->ReadWritePointer - FB->Buf->buf);
FB->ReadWritePointer = FB->Buf->buf;
}
return eMustReadMore;
}
/**
- * @ingroup StrBuf_CHUNKED_IO
- * @brief check whether the chunk-buffer has more data waiting or not.
- * @param FB Chunk-Buffer to inspect
+ * check whether the chunk-buffer has more data waiting or not.
+ * FB Chunk-Buffer to inspect
*/
-eReadState StrBufCheckBuffer(IOBuffer *FB)
-{
+eReadState StrBufCheckBuffer(IOBuffer *FB) {
if (FB == NULL)
return eReadFail;
if (FB->Buf->BufUsed == 0)
return eReadSuccess;
}
-long IOBufferStrLength(IOBuffer *FB)
-{
+
+long IOBufferStrLength(IOBuffer *FB) {
+ if ((FB == NULL) || (FB->Buf == NULL))
+ return 0;
if (FB->ReadWritePointer == NULL)
return StrLength(FB->Buf);
return StrLength(FB->Buf) - (FB->ReadWritePointer - FB->Buf->buf);
}
+
/*******************************************************************************
* File I/O; Prefer buffered read since its faster! *
*******************************************************************************/
/**
- * @ingroup StrBuf_IO
- * @brief Read a line from socket
+ * 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
+ * buf the buffer to get the input to
+ * fd pointer to the filedescriptor to read
+ * append Append to an existing string or replace?
+ * Error strerror() on error
* @returns numbers of chars read
*/
-int StrBufTCP_read_line(StrBuf *buf, int *fd, int append, const char **Error)
-{
+int StrBufTCP_read_line(StrBuf *buf, int *fd, int append, const char **Error) {
int len, rlen, slen;
+ if ((buf == NULL) || (buf->buf == NULL)) {
+ *Error = strerror(EINVAL);
+ return -1;
+ }
+
if (!append)
FlushStrBuf(buf);
return len - slen;
}
-/**
- * @ingroup StrBuf_BufferedIO
- * @brief Read a line from socket
- * flushes and closes the FD on error
- * @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
- */
+
+// Read a line from socket
+// flushes and closes the FD on error
+// Line the line to read from the fd / I/O Buffer
+// buf the buffer to get the input to
+// fd pointer to the filedescriptor to read
+// timeout number of successless selects until we bail out
+// selectresolution how long to wait on each select
+// Error strerror() on error
+// returns numbers of chars read
int StrBufTCP_read_buffered_line(StrBuf *Line,
StrBuf *buf,
int *fd,
if (pch != NULL) {
rlen = 0;
len = pch - buf->buf;
- if (len > 0 && (*(pch - 1) == '\r') )
+ if (len > 0 && (*(pch - 1) == '\r') ) {
rlen ++;
+ }
StrBufSub(Line, buf, 0, len - rlen);
StrBufCutLeft(buf, len + 1);
return len - rlen;
}
}
- if (buf->BufSize - buf->BufUsed < 10)
+ if (buf->BufSize - buf->BufUsed < 10) {
IncreaseBuf(buf, 1, -1);
+ }
fdflags = fcntl(*fd, F_GETFL);
IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
nSuccessLess ++;
continue;
}
- rlen = read(*fd,
- &buf->buf[buf->BufUsed],
- buf->BufSize - buf->BufUsed - 1);
+ rlen = read(*fd, &buf->buf[buf->BufUsed], buf->BufSize - buf->BufUsed - 1);
if (rlen < 1) {
*Error = strerror(errno);
close(*fd);
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');
+ if ((pch == NULL) && (buf->BufUsed + 10 > buf->BufSize) && (IncreaseBuf(buf, 1, -1) == -1)) {
+ return -1;
+ }
continue;
}
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";
-/**
- * @ingroup StrBuf_BufferedIO
- * @brief Read a line from socket
- * flushes and closes the FD on error
- * @param Line where to append our Line read from the fd / I/O Buffer;
- * @param IOBuf the buffer to get the input to; lifetime pair to FD
- * @param Pos pointer to the current read position, should be NULL initialized on opening the FD it belongs 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 or -1 in case of error. "\n" will become 0
- */
+
+
+// Read a line from socket
+// flushes and closes the FD on error
+// Line where to append our Line read from the fd / I/O Buffer;
+// IOBuf the buffer to get the input to; lifetime pair to FD
+// Pos pointer to the current read position, should be NULL initialized on opening the FD it belongs to.!
+// fd pointer to the filedescriptor to read
+// timeout number of successless selects until we bail out
+// selectresolution how long to wait on each select
+// Error strerror() on error
+// returns numbers of chars read or -1 in case of error. "\n" will become 0
int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
StrBuf *IOBuf,
const char **Pos,
struct timeval tv;
retlen = 0;
- if ((Line == NULL) ||
- (Pos == NULL) ||
- (IOBuf == NULL) ||
- (*fd == -1))
- {
- if (Pos != NULL)
+ 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) &&
- (pos < IOBuf->buf + IOBuf->BufUsed))
- {
+ if ((IOBuf->BufUsed > 0) && (pos != NULL) && (pos < IOBuf->buf + IOBuf->BufUsed)) {
char *pcht;
pche = IOBuf->buf + IOBuf->BufUsed;
pch = pos;
pcht = Line->buf;
- while ((pch < pche) && (*pch != '\n'))
- {
- if (Line->BufUsed + 10 > Line->BufSize)
- {
+ while ((pch < pche) && (*pch != '\n')) {
+ if (Line->BufUsed + 10 > Line->BufSize) {
long apos;
apos = pcht - Line->buf;
*pcht = '\0';
}
len = pch - pos;
- if (len > 0 && (*(pch - 1) == '\r') )
- {
+ if (len > 0 && (*(pch - 1) == '\r') ) {
retlen--;
len --;
pcht --;
}
*pcht = '\0';
- if ((pch >= pche) || (*pch == '\0'))
- {
+ if ((pch >= pche) || (*pch == '\0')) {
FlushStrBuf(IOBuf);
*Pos = NULL;
pch = NULL;
pos = 0;
}
- if ((pch != NULL) &&
- (pch <= pche))
- {
+ if ((pch != NULL) && (pch <= pche)) {
if (pch + 1 >= pche) {
*Pos = NULL;
FlushStrBuf(IOBuf);
}
- else
+ else {
*Pos = pch + 1;
-
+ }
return retlen;
}
else
/* If we come here, Pos is Unset since we read everything into Line, and now go for more. */
- if (IOBuf->BufSize - IOBuf->BufUsed < 10)
+ if (IOBuf->BufSize - IOBuf->BufUsed < 10) {
IncreaseBuf(IOBuf, 1, -1);
+ }
fdflags = fcntl(*fd, F_GETFL);
IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
while ((nSuccessLess < timeout) &&
(pLF == NULL) &&
(*fd != -1)) {
- if (IsNonBlock)
- {
+ if (IsNonBlock) {
tv.tv_sec = 1;
tv.tv_usec = 0;
continue;
}
}
- rlen = read(*fd,
- &IOBuf->buf[IOBuf->BufUsed],
- IOBuf->BufSize - IOBuf->BufUsed - 1);
+ rlen = read(*fd, &IOBuf->buf[IOBuf->BufUsed], IOBuf->BufSize - IOBuf->BufUsed - 1);
if (rlen < 1) {
*Error = strerror(errno);
close(*fd);
if ((pLF >= pche) || (*pLF == '\0'))
pLF = NULL;
- if (IOBuf->BufUsed + 10 > IOBuf->BufSize)
- {
+ if (IOBuf->BufUsed + 10 > IOBuf->BufSize) {
long apos = 0;
if (pLF != NULL) apos = pLF - IOBuf->buf;
continue;
}
+ else {
+ nSuccessLess++;
+ }
}
*Pos = NULL;
if (pLF != NULL) {
pos = IOBuf->buf;
len = pLF - pos;
- if (len > 0 && (*(pLF - 1) == '\r') )
+ if (len > 0 && (*(pLF - 1) == '\r') ) {
len --;
+ }
StrBufAppendBufPlain(Line, ChrPtr(IOBuf), len, 0);
- if (pLF + 1 >= IOBuf->buf + IOBuf->BufUsed)
- {
+ if (pLF + 1 >= IOBuf->buf + IOBuf->BufUsed) {
FlushStrBuf(IOBuf);
}
else
static const char *ErrRBLF_BLOBPreConditionFailed="StrBufReadBLOB: Wrong arguments or invalid Filedescriptor";
/**
- * @ingroup StrBuf_IO
- * @brief Input binary data from socket
+ * 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
+ * Buf the buffer to get the input to
+ * fd pointer to the filedescriptor to read
+ * append Append to an existing string or replace?
+ * nBytes the maximal number of bytes to read
+ * Error strerror() on error
* @returns numbers of chars read
*/
-int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error)
-{
+int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error) {
int fdflags;
int rlen;
int nSuccessLess;
struct timeval tv;
fd_set rfds;
- if ((Buf == NULL) || (*fd == -1))
- {
+ if ((Buf == NULL) || (Buf->buf == NULL) || (*fd == -1)) {
*Error = ErrRBLF_BLOBPreConditionFailed;
return -1;
}
- if (!append)
+ if (!append) {
FlushStrBuf(Buf);
- if (Buf->BufUsed + nBytes >= Buf->BufSize)
+ }
+ if (Buf->BufUsed + nBytes >= Buf->BufSize) {
IncreaseBuf(Buf, 1, Buf->BufUsed + nBytes);
-
+ }
ptr = Buf->buf + Buf->BufUsed;
fdflags = fcntl(*fd, F_GETFL);
IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
nSuccessLess = 0;
- while ((nRead < nBytes) &&
- (*fd != -1))
- {
- if (IsNonBlock)
- {
+ while ((nRead < nBytes) && (*fd != -1)) {
+ if (IsNonBlock) {
tv.tv_sec = 1;
tv.tv_usec = 0;
*Error = strerror(errno);
close (*fd);
*fd = -1;
- if (*Error == NULL)
+ if (*Error == NULL) {
*Error = ErrRBLF_SelectFailed;
+ }
return -1;
}
if (! FD_ISSET(*fd, &rfds) != 0) {
const char *ErrRBB_BLOBFPreConditionFailed = "StrBufReadBLOBBuffered: to many selects; aborting.";
const char *ErrRBB_too_many_selects = "StrBufReadBLOBBuffered: to many selects; aborting.";
-/**
- * @ingroup StrBuf_BufferedIO
- * @brief Input binary data from socket
- * flushes and closes the FD on error
- * @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
- */
+
+
+// Input binary data from socket
+// flushes and closes the FD on error
+// Blob put binary thing here
+// IOBuf the buffer to get the input to
+// Pos offset inside of IOBuf
+// fd pointer to the filedescriptor to read
+// append Append to an existing string or replace?
+// nBytes the maximal number of bytes to read
+// check whether we should search for '000\n' terminators in case of timeouts
+// Error strerror() on error
+// returns numbers of chars read
int StrBufReadBLOBBuffered(StrBuf *Blob,
StrBuf *IOBuf,
const char **Pos,
{
const char *pos;
int fdflags;
- int len = 0;
- int rlen;
+ int rlen = 0;
int nRead = 0;
int nAlreadyRead = 0;
int IsNonBlock;
int nSuccessLess = 0;
int MaxTries;
- if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL))
- {
- if (*Pos != NULL)
+ if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL)) {
+ if (Pos != NULL)
*Pos = NULL;
*Error = ErrRBB_BLOBFPreConditionFailed;
return -1;
pos = *Pos;
- if (pos != NULL)
- len = pos - IOBuf->buf;
- rlen = IOBuf->BufUsed - len;
+ if (pos != NULL) {
+ rlen = pos - IOBuf->buf;
+ }
+ rlen = IOBuf->BufUsed - rlen;
- if ((IOBuf->BufUsed > 0) &&
- (pos != NULL) &&
- (pos < IOBuf->buf + IOBuf->BufUsed))
- {
+ if ((IOBuf->BufUsed > 0) && (pos != NULL) && (pos < IOBuf->buf + IOBuf->BufUsed)) {
if (rlen < nBytes) {
memcpy(Blob->buf + Blob->BufUsed, pos, rlen);
Blob->BufUsed += rlen;
FlushStrBuf(IOBuf);
*Pos = NULL;
- if (IOBuf->BufSize < nBytes - nRead)
+ if (IOBuf->BufSize < nBytes - nRead) {
IncreaseBuf(IOBuf, 0, nBytes - nRead);
+ }
ptr = IOBuf->buf;
- len = Blob->BufUsed;
-
fdflags = fcntl(*fd, F_GETFL);
IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK;
if (IsNonBlock)
nBytes -= nRead;
nRead = 0;
- while ((nSuccessLess < MaxTries) &&
- (nRead < nBytes) &&
- (*fd != -1)) {
- if (IsNonBlock)
- {
+ while ((nSuccessLess < MaxTries) && (nRead < nBytes) && (*fd != -1)) {
+ if (IsNonBlock) {
tv.tv_sec = 1;
tv.tv_usec = 0;
*Error = strerror(errno);
close (*fd);
*fd = -1;
- if (*Error == NULL)
+ if (*Error == NULL) {
*Error = ErrRBLF_SelectFailed;
+ }
return -1;
}
if (! FD_ISSET(*fd, &rfds) != 0) {
continue;
}
}
- rlen = read(*fd,
- ptr,
- IOBuf->BufSize - (ptr - IOBuf->buf));
- if (rlen == -1) {
+ rlen = read(*fd, ptr, IOBuf->BufSize - (ptr - IOBuf->buf));
+ if (rlen < 1) { // We will always get at least 1 byte unless the connection is broken
close(*fd);
*fd = -1;
*Error = strerror(errno);
return rlen;
}
else if (rlen == 0){
- if ((check == NNN_TERM) &&
- (nRead > 5) &&
- (strncmp(IOBuf->buf + IOBuf->BufUsed - 5, "\n000\n", 5) == 0))
- {
+ if ((check == NNN_TERM) && (nRead > 5) && (strncmp(IOBuf->buf + IOBuf->BufUsed - 5, "\n000\n", 5) == 0)) {
StrBufPlain(Blob, HKEY("\n000\n"));
StrBufCutRight(Blob, 5);
return Blob->BufUsed;
return nRead + nAlreadyRead;
}
-/**
- * @ingroup StrBuf_IO
- * @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 remaining buffer
- */
-int StrBufSipLine(StrBuf *LineBuf, const StrBuf *Buf, const char **Ptr)
-{
+
+// extract a "next line" from Buf; Ptr to persist across several iterations
+// LineBuf your line will be copied here.
+// Buf BLOB with lines of text...
+// 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 remaining buffer
+int StrBufSipLine(StrBuf *LineBuf, const StrBuf *Buf, const char **Ptr) {
const char *aptr, *ptr, *eptr;
char *optr, *xptr;
- if ((Buf == NULL) || (*Ptr == StrBufNOTNULL)) {
+ if ((Buf == NULL) || (*Ptr == StrBufNOTNULL) || (LineBuf == NULL)|| (LineBuf->buf == NULL)) {
*Ptr = StrBufNOTNULL;
return 0;
}
eptr = Buf->buf + Buf->BufUsed;
xptr = LineBuf->buf + LineBuf->BufSize - 1;
- while ((ptr <= eptr) &&
- (*ptr != '\n') &&
- (*ptr != '\r') )
- {
+ while ((ptr <= eptr) && (*ptr != '\n') && (*ptr != '\r') ) {
*optr = *ptr;
optr++; ptr++;
if (optr == xptr) {
}
-/**
- * @ingroup StrBuf_IO
- * @brief removes double slashes from pathnames
- * @param Dir directory string to filter
- * @param RemoveTrailingSlash allows / disallows trailing slashes
- */
-void StrBufStripSlashes(StrBuf *Dir, int RemoveTrailingSlash)
-{
+// removes double slashes from pathnames
+// Dir directory string to filter
+// RemoveTrailingSlash allows / disallows trailing slashes
+void StrBufStripSlashes(StrBuf *Dir, int RemoveTrailingSlash) {
char *a, *b;
a = b = Dir->buf;
b++; a++;
}
}
- if ((RemoveTrailingSlash) && (*(b - 1) != '/')){
- *b = '/';
- b++;
+ if ((RemoveTrailingSlash) &&
+ (b > Dir->buf) &&
+ (*(b - 1) == '/')){
+ b--;
}
*b = '\0';
Dir->BufUsed = b - Dir->buf;
}
+// Decode a quoted-printable encoded StrBuf buffer "in place"
+// This is possible because the decoded will always be shorter than the encoded
+// so we don't have to worry about the buffer being to small.
+void StrBufDecodeQP(StrBuf *Buf) {
+ if (!Buf) { // sanity check #1
+ return;
+ }
+
+ int source_len = StrLength(Buf);
+ if (source_len < 1) { // sanity check #2
+ return;
+ }
+
+ int spos = 0; // source position
+ int tpos = 0; // target position
+
+ while (spos < source_len) {
+ if (!strncmp(&Buf->buf[spos], "=\r\n", 3)) {
+ spos += 3;
+ }
+ else if (!strncmp(&Buf->buf[spos], "=\n", 2)) {
+ spos += 2;
+ }
+ else if (Buf->buf[spos] == '=') {
+ ++spos;
+ int ch;
+ sscanf(&Buf->buf[spos], "%02x", &ch);
+ Buf->buf[tpos++] = ch;
+ spos +=2;
+ }
+ else {
+ Buf->buf[tpos++] = Buf->buf[spos++];
+ }
+ }
+
+ Buf->buf[tpos] = 0;
+ Buf->BufUsed = tpos;
+}