* move utf8 handling stuff into strbuf, so we can be more exact about our buffer...

[citadel.git] / libcitadel / lib / stringbuf.c

diff --git a/libcitadel/lib/stringbuf.c b/libcitadel/lib/stringbuf.c
index 94728a9bb160417d8386f5dce137d220e18c3886..4bec25f3dde47740c3e4d931ee054b3c6c4331a3 100644 (file)
--- a/libcitadel/lib/stringbuf.c
+++ b/libcitadel/lib/stringbuf.c
@@ -25,7 +25,7 @@
 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
@@ -138,6 +138,22 @@ static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize)
        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
@@ -827,13 +843,17 @@ long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
                        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;
@@ -843,7 +863,7 @@ long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
                aptr ++;
        }
        *bptr = '\0';
-       if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
+       if ((bptr == eptr - 1 ) && !IsEmptyStr(aptr) )
                return -1;
        return Target->BufUsed;
 }
@@ -1542,8 +1562,8 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
                                      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;
@@ -1576,7 +1596,10 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
        }
        
        if (pos != NULL) {
-               StrBufCutLeft(IOBuf, (pos - IOBuf->buf));
+               if (pos > pche)
+                       FlushStrBuf(IOBuf);
+               else 
+                       StrBufCutLeft(IOBuf, (pos - IOBuf->buf));
                *Pos = NULL;
        }
        
@@ -1588,6 +1611,7 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
        if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
                return -1;
 
+       pch = NULL;
        while ((nSuccessLess < timeout) && (pch == NULL)) {
                tv.tv_sec = selectresolution;
                tv.tv_usec = 0;
@@ -1617,7 +1641,13 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
                                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;
                        }
                }
@@ -2611,23 +2641,97 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf*
        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;
+
 }