int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen,
const Bytef * source, uLong sourceLen, int level);
#endif
-int BaseStrBufSize = SIZ;
+int BaseStrBufSize = 64;
/**
* Private Structure for the Stringbuffer
return Buf->BufSize;
}
+/**
+ * \brief shrink an _EMPTY_ buffer if its Buffer superseeds threshhold to NewSize. Buffercontent is thoroughly ignored and flushed.
+ * \param Buf Buffer to shrink (has to be empty)
+ * \param ThreshHold if the buffer is bigger then this, its readjusted
+ * \param NewSize if we Shrink it, how big are we going to be afterwards?
+ */
+void ReAdjustEmptyBuf(StrBuf *Buf, long ThreshHold, long NewSize)
+{
+ if (Buf->BufUsed > ThreshHold) {
+ free(Buf->buf);
+ Buf->buf = (char*) malloc(NewSize);
+ Buf->BufUsed = 0;
+ Buf->BufSize = NewSize;
+ }
+}
+
/**
* \brief shrink long term buffers to their real size so they don't waste memory
* \param Buf buffer to shrink
Buf->buf[Buf->BufUsed] = '\0';
}
+/**
+ * \brief Callback for cURL to append the webserver reply to a buffer
+ * params pre-defined by the cURL API; see man 3 curl for mre info
+ */
+size_t CurlFillStrBuf_callback(void *ptr, size_t size, size_t nmemb, void *stream)
+{
+
+ StrBuf *Target;
+
+ Target = stream;
+ if (ptr == NULL)
+ return 0;
+
+ StrBufAppendBufPlain(Target, ptr, size * nmemb, 0);
+ return size * nmemb;
+}
+
/**
* \brief Escape a string for feeding out as a URL while appending it to a Buffer
* \param Source source buffer; set to NULL if you just have a C-String
* \param PlainIn Plain-C string to append; set to NULL if unused
*/
-void StrMsgEscAppend(StrBuf *Target, StrBuf *Source, const char *PlainIn)
+void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
{
const char *aptr, *eiptr;
char *tptr, *eptr;
*tptr = '\0';
}
+
+
+/*
+ * \brief Append a string, escaping characters which have meaning in ICAL.
+ * [\n,]
+ * \param Target target buffer
+ * \param Source source buffer; set to NULL if you just have a C-String
+ * \param PlainIn Plain-C string to append; set to NULL if unused
+ */
+void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
+{
+ const char *aptr, *eiptr;
+ char *tptr, *eptr;
+ long len;
+
+ if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
+ return ;
+
+ if (PlainIn != NULL) {
+ aptr = PlainIn;
+ len = strlen(PlainIn);
+ eiptr = aptr + len;
+ }
+ else {
+ aptr = Source->buf;
+ eiptr = aptr + Source->BufUsed;
+ len = Source->BufUsed;
+ }
+
+ if (len == 0)
+ return;
+
+ eptr = Target->buf + Target->BufSize - 8;
+ tptr = Target->buf + Target->BufUsed;
+
+ while (aptr < eiptr){
+ if(tptr + 3 >= eptr) {
+ IncreaseBuf(Target, 1, -1);
+ eptr = Target->buf + Target->BufSize - 8;
+ tptr = Target->buf + Target->BufUsed;
+ }
+
+ if (*aptr == '\n') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = 'n';
+ Target->BufUsed++;
+ }
+ else if (*aptr == '\r') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = 'r';
+ Target->BufUsed++;
+ }
+ else if (*aptr == ',') {
+ *tptr = '\\';
+ Target->BufUsed++;
+ tptr++;
+ *tptr = ',';
+ Target->BufUsed++;
+ } else {
+ *tptr = *aptr;
+ Target->BufUsed++;
+ }
+ tptr++; aptr++;
+ }
+ *tptr = '\0';
+}
+
/*
* \brief Append a string, escaping characters which have meaning in JavaScript strings .
*
bptr = Target->buf + Target->BufUsed;
}
else if (*aptr == '"') {
- memcpy(bptr, "\\\"", 2);
- bptr += 2;
+ *bptr = '\\';
+ bptr ++;
+ *bptr = '"';
+ bptr ++;
Target->BufUsed += 2;
} else if (*aptr == '\\') {
- memcpy(bptr, "\\\\", 2);
- bptr += 2;
- Target->BufUsed += 2;
+ *bptr = '\\';
+ bptr ++;
+ *bptr = '\\';
+ bptr ++;
+ Target->BufUsed += 2;
}
else{
*bptr = *aptr;
aptr ++;
}
*bptr = '\0';
- if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
+ if ((bptr == eptr - 1 ) && !IsEmptyStr(aptr) )
return -1;
return Target->BufUsed;
}
if (*s == separator) {
++current_token;
}
- if (len >= dest->BufSize)
+ if (len >= dest->BufSize) {
+ dest->BufUsed = len;
if (!IncreaseBuf(dest, 1, -1))
break;
+ }
if ( (current_token == parmnum) &&
(*s != separator)) {
dest->buf[len] = *s;
if (*s == separator) {
++current_token;
}
- if (len >= dest->BufSize)
+ if (len >= dest->BufSize) {
+ dest->BufUsed = len;
if (!IncreaseBuf(dest, 1, -1)) {
*pStart = EndBuffer + 1;
break;
}
+ }
if ( (current_token == 0) &&
(*s != separator)) {
dest->buf[len] = *s;
int selectresolution,
const char **Error)
{
- const char *pche;
- const char *pos;
+ const char *pche = NULL;
+ const char *pos = NULL;
int len, rlen;
int nSuccessLess = 0;
fd_set rfds;
}
if (pos != NULL) {
- StrBufCutLeft(IOBuf, (pos - IOBuf->buf));
+ if (pos > pche)
+ FlushStrBuf(IOBuf);
+ else
+ StrBufCutLeft(IOBuf, (pos - IOBuf->buf));
*Pos = NULL;
}
if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
return -1;
+ pch = NULL;
while ((nSuccessLess < timeout) && (pch == NULL)) {
tv.tv_sec = selectresolution;
tv.tv_usec = 0;
if (IOBuf->BufUsed + 10 > IOBuf->BufSize) {
IncreaseBuf(IOBuf, 1, -1);
}
- pch = strchr(IOBuf->buf, '\n');
+
+ pche = IOBuf->buf + IOBuf->BufUsed;
+ pch = IOBuf->buf;
+ while ((pch < pche) && (*pch != '\n'))
+ pch ++;
+ if ((pch >= pche) || (*pch == '\0'))
+ pch = NULL;
continue;
}
}
}
}
+/**
+ * \Brief removes double slashes from pathnames
+ * \param Dir directory string to filter
+ * \param RemoveTrailingSlash allows / disallows trailing slashes
+ */
+void StrBufStripSlashes(StrBuf *Dir, int RemoveTrailingSlash)
+{
+ char *a, *b;
+
+ a = b = Dir->buf;
+
+ while (!IsEmptyStr(a)) {
+ if (*a == '/') {
+ while (*a == '/')
+ a++;
+ *b = '/';
+ b++;
+ }
+ else {
+ *b = *a;
+ b++; a++;
+ }
+ }
+ if ((RemoveTrailingSlash) && (*(b - 1) != '/')){
+ *b = '/';
+ b++;
+ }
+ *b = '\0';
+ Dir->BufUsed = b - Dir->buf;
+}
/**
* \brief unhide special chars hidden to the HTML escaper
return end;
}
+static inline void SwapBuffers(StrBuf *A, StrBuf *B)
+{
+ StrBuf C;
+
+ memcpy(&C, A, sizeof(*A));
+ memcpy(A, B, sizeof(*B));
+ memcpy(B, &C, sizeof(C));
+
+}
void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
{
#ifdef HAVE_ICONV
- int BufSize;
+ long trycount = 0;
+ size_t siz;
iconv_t ic;
char *ibuf; /**< Buffer of characters to be converted */
char *obuf; /**< Buffer for converted characters */
if (ConvertBuf->BufUsed >= TmpBuf->BufSize)
IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed);
-
+TRYAGAIN:
ic = *(iconv_t*)pic;
ibuf = ConvertBuf->buf;
ibuflen = ConvertBuf->BufUsed;
obuf = TmpBuf->buf;
obuflen = TmpBuf->BufSize;
- iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
+ siz = iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
- /* little card game: wheres the red lady? */
- ibuf = ConvertBuf->buf;
- BufSize = ConvertBuf->BufSize;
+ if (siz < 0) {
+ if (errno == E2BIG) {
+ trycount ++;
+ IncreaseBuf(TmpBuf, 0, 0);
+ if (trycount < 5)
+ goto TRYAGAIN;
- ConvertBuf->buf = TmpBuf->buf;
- ConvertBuf->BufSize = TmpBuf->BufSize;
- ConvertBuf->BufUsed = TmpBuf->BufSize - obuflen;
- ConvertBuf->buf[ConvertBuf->BufUsed] = '\0';
-
- TmpBuf->buf = ibuf;
- TmpBuf->BufSize = BufSize;
- TmpBuf->BufUsed = 0;
- TmpBuf->buf[0] = '\0';
+ }
+ else if (errno == EILSEQ){
+ /* hm, invalid utf8 sequence... what to do now? */
+ /* An invalid multibyte sequence has been encountered in the input */
+ }
+ else if (errno == EINVAL) {
+ /* An incomplete multibyte sequence has been encountered in the input. */
+ }
+
+ FlushStrBuf(TmpBuf);
+ }
+ else {
+ TmpBuf->BufUsed = TmpBuf->BufSize - obuflen;
+ TmpBuf->buf[TmpBuf->BufUsed] = '\0';
+
+ /* little card game: wheres the red lady? */
+ SwapBuffers(ConvertBuf, TmpBuf);
+ FlushStrBuf(TmpBuf);
+ }
#endif
}
/* did we find a gab just filled with blanks? */
if (ptr == next)
{
+ long gap = next - start;
memmove (end + 2,
next,
- len - (next - start));
-
+ len - (gap));
+ len -= gap;
/* now terminate the gab at the end */
delta = (next - end) - 2; ////TODO: const!
((StrBuf*)DecodeMe)->BufUsed -= delta;
FreeStrBuf(&ConvertBuf2);
}
+/**
+ * \brief evaluate the length of an utf8 special character sequence
+ * \param Char the character to examine
+ * \returns width of utf8 chars in bytes
+ */
+static inline int Ctdl_GetUtf8SequenceLength(char *CharS, char *CharE)
+{
+ int n = 1;
+ char test = (1<<7);
+
+ while ((n < 8) && ((test & *CharS) != 0)) {
+ test = test << 1;
+ n ++;
+ }
+ if ((n > 6) || ((CharE - CharS) > n))
+ n = 1;
+ return n;
+}
+/**
+ * \brief detect whether this char starts an utf-8 encoded char
+ * \param Char character to inspect
+ * \returns yes or no
+ */
+static inline int Ctdl_IsUtf8SequenceStart(char Char)
+{
+/** 11??.???? indicates an UTF8 Sequence. */
+ return ((Char & 0xC0) != 0);
+}
+/**
+ * \brief measure the number of glyphs in an UTF8 string...
+ * \param str string to measure
+ * \returns the length of str
+ */
long StrBuf_Utf8StrLen(StrBuf *Buf)
{
- return Ctdl_Utf8StrLen(Buf->buf);
+ int n = 0;
+ int m = 0;
+ char *aptr, *eptr;
+
+ if ((Buf == NULL) || (Buf->BufUsed == 0))
+ return 0;
+ aptr = Buf->buf;
+ eptr = Buf->buf + Buf->BufUsed;
+ while ((aptr < eptr) && (*aptr != '\0')) {
+ if (Ctdl_IsUtf8SequenceStart(*aptr)){
+ m = Ctdl_GetUtf8SequenceLength(aptr, eptr);
+ while ((aptr < eptr) && (m-- > 0) && (*aptr++ != '\0'))
+ n ++;
+ }
+ else {
+ n++;
+ aptr++;
+ }
+
+ }
+ return n;
}
+/**
+ * \brief cuts a string after maxlen glyphs
+ * \param str string to cut to maxlen glyphs
+ * \param maxlen how long may the string become?
+ * \returns pointer to maxlen or the end of the string
+ */
long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen)
{
- char *CutAt;
+ char *aptr, *eptr;
+ int n = 0, m = 0;
- CutAt = Ctdl_Utf8StrCut(Buf->buf, maxlen);
- if (CutAt != NULL) {
- Buf->BufUsed = CutAt - Buf->buf;
- Buf->buf[Buf->BufUsed] = '\0';
+ aptr = Buf->buf;
+ eptr = Buf->buf + Buf->BufUsed;
+ while ((aptr < eptr) && (*aptr != '\0')) {
+ if (Ctdl_IsUtf8SequenceStart(*aptr)){
+ m = Ctdl_GetUtf8SequenceLength(aptr, eptr);
+ while ((m-- > 0) && (*aptr++ != '\0'))
+ n ++;
+ }
+ else {
+ n++;
+ aptr++;
+ }
+ if (n > maxlen) {
+ *aptr = '\0';
+ Buf->BufUsed = aptr - Buf->buf;
+ return Buf->BufUsed;
+ }
}
- return Buf->BufUsed;
+ return Buf->BufUsed;
+
}
projects / citadel.git / blobdiff