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
}
free (Buf->buf);
Buf->buf = NewBuf;
- Buf->BufSize *= 2;
+ Buf->BufSize = NewSize;
#ifdef SIZE_DEBUG
Buf->nIncreases++;
#if HAVE_BACKTRACE
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
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;
}
newused = Offset + nWritten;
if (newused >= Buf->BufSize) {
IncreaseBuf(Buf, 1, newused);
+ newused = Buf->BufSize + 1;
}
else {
Buf->BufUsed = Offset + nWritten;
newused = Buf->BufUsed + nWritten;
if (newused >= Buf->BufSize) {
IncreaseBuf(Buf, 1, newused);
+ newused = Buf->BufSize + 1;
}
else {
Buf->BufUsed += nWritten;
va_start(arg_ptr, format);
nWritten = vsnprintf(Buf->buf, Buf->BufSize, format, arg_ptr);
va_end(arg_ptr);
- Buf->BufUsed = nWritten ;
- if (nWritten >= Buf->BufSize)
+ if (nWritten >= Buf->BufSize) {
IncreaseBuf(Buf, 0, 0);
+ nWritten = Buf->BufSize + 1;
+ continue;
+ }
+ Buf->BufUsed = nWritten ;
}
}
* \returns numbers of chars read
*/
int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
- StrBuf *buf,
+ StrBuf *IOBuf,
const char **Pos,
int *fd,
int timeout,
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;
struct timeval tv;
pos = *Pos;
- if ((buf->BufUsed > 0) &&
+ if ((IOBuf->BufUsed > 0) &&
(pos != NULL) &&
- (pos < buf->buf + buf->BufUsed))
+ (pos < IOBuf->buf + IOBuf->BufUsed))
{
- pche = buf->buf + buf->BufUsed;
+ pche = IOBuf->buf + IOBuf->BufUsed;
pch = pos;
while ((pch < pche) && (*pch != '\n'))
pch ++;
len = pch - pos;
if (len > 0 && (*(pch - 1) == '\r') )
rlen ++;
- StrBufSub(Line, buf, (pos - buf->buf), len - rlen);
+ StrBufSub(Line, IOBuf, (pos - IOBuf->buf), len - rlen);
*Pos = pch + 1;
return len - rlen;
}
}
if (pos != NULL) {
- StrBufCutLeft(buf, (pos - buf->buf));
+ if (pos > pche)
+ FlushStrBuf(IOBuf);
+ else
+ StrBufCutLeft(IOBuf, (pos - IOBuf->buf));
*Pos = NULL;
}
- if (buf->BufSize - buf->BufUsed < 10) {
- IncreaseBuf(buf, 1, -1);
+ if (IOBuf->BufSize - IOBuf->BufUsed < 10) {
+ IncreaseBuf(IOBuf, 1, -1);
}
fdflags = fcntl(*fd, F_GETFL);
if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
return -1;
+ pch = NULL;
while ((nSuccessLess < timeout) && (pch == NULL)) {
tv.tv_sec = selectresolution;
tv.tv_usec = 0;
}
if (FD_ISSET(*fd, &rfds) != 0) {
rlen = read(*fd,
- &buf->buf[buf->BufUsed],
- buf->BufSize - buf->BufUsed - 1);
+ &IOBuf->buf[IOBuf->BufUsed],
+ IOBuf->BufSize - IOBuf->BufUsed - 1);
if (rlen < 1) {
*Error = strerror(errno);
close(*fd);
}
else if (rlen > 0) {
nSuccessLess = 0;
- buf->BufUsed += rlen;
- buf->buf[buf->BufUsed] = '\0';
- if (buf->BufUsed + 10 > buf->BufSize) {
- IncreaseBuf(buf, 1, -1);
+ IOBuf->BufUsed += rlen;
+ IOBuf->buf[IOBuf->BufUsed] = '\0';
+ if (IOBuf->BufUsed + 10 > IOBuf->BufSize) {
+ IncreaseBuf(IOBuf, 1, -1);
}
- pch = strchr(buf->buf, '\n');
+
+ pche = IOBuf->buf + IOBuf->BufUsed;
+ pch = IOBuf->buf;
+ while ((pch < pche) && (*pch != '\n'))
+ pch ++;
+ if ((pch >= pche) || (*pch == '\0'))
+ pch = NULL;
continue;
}
}
nSuccessLess ++;
}
if (pch != NULL) {
- pos = buf->buf;
+ pos = IOBuf->buf;
rlen = 0;
len = pch - pos;
if (len > 0 && (*(pch - 1) == '\r') )
rlen ++;
- StrBufSub(Line, buf, 0, len - rlen);
+ StrBufSub(Line, IOBuf, 0, len - rlen);
*Pos = pos + len + 1;
return len - rlen;
}
* \param Error strerror() on error
* \returns numbers of chars read
*/
-int StrBufReadBLOBBuffered(StrBuf *Buf,
+int StrBufReadBLOBBuffered(StrBuf *Blob,
StrBuf *IOBuf,
- const char **BufPos,
+ const char **Pos,
int *fd,
int append,
long nBytes,
int check,
const char **Error)
{
+ const char *pche;
+ const char *pos;
int nSelects = 0;
int SelRes;
fd_set wset;
int rlen, slen;
int nRead = 0;
char *ptr;
+ const char *pch;
- if ((Buf == NULL) || (*fd == -1) || (IOBuf == NULL) || (BufPos == NULL))
+ if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL))
return -1;
if (!append)
- FlushStrBuf(Buf);
- if (Buf->BufUsed + nBytes >= Buf->BufSize)
- IncreaseBuf(Buf, 1, Buf->BufUsed + nBytes);
+ FlushStrBuf(Blob);
+ if (Blob->BufUsed + nBytes >= Blob->BufSize)
+ IncreaseBuf(Blob, append, Blob->BufUsed + nBytes);
+ pos = *Pos;
- if (*BufPos > 0)
- len = *BufPos - IOBuf->buf;
+ if (pos > 0)
+ len = pos - IOBuf->buf;
rlen = IOBuf->BufUsed - len;
+
if ((IOBuf->BufUsed > 0) &&
- ((IOBuf->BufUsed - len > 0))) {
+ (pos != NULL) &&
+ (pos < IOBuf->buf + IOBuf->BufUsed))
+ {
+ pche = IOBuf->buf + IOBuf->BufUsed;
+ pch = pos;
+
if (rlen < nBytes) {
- memcpy(Buf->buf + Buf->BufUsed, *BufPos, rlen);
- Buf->BufUsed += rlen;
- Buf->buf[Buf->BufUsed] = '\0';
+ memcpy(Blob->buf + Blob->BufUsed, pos, rlen);
+ Blob->BufUsed += rlen;
+ Blob->buf[Blob->BufUsed] = '\0';
nRead = rlen;
- *BufPos = NULL;
- FlushStrBuf(IOBuf);
+ *Pos = NULL;
}
if (rlen >= nBytes) {
- memcpy(Buf->buf + Buf->BufUsed, *BufPos, nBytes);
- Buf->BufUsed += nBytes;
- Buf->buf[Buf->BufUsed] = '\0';
+ memcpy(Blob->buf + Blob->BufUsed, pos, nBytes);
+ Blob->BufUsed += nBytes;
+ Blob->buf[Blob->BufUsed] = '\0';
if (rlen == nBytes) {
- *BufPos = NULL;
+ *Pos = NULL;
FlushStrBuf(IOBuf);
}
else
- *BufPos += nBytes;
+ *Pos += nBytes;
return nBytes;
}
}
- ptr = IOBuf->buf + Buf->BufUsed;
+ FlushStrBuf(IOBuf);
+ if (IOBuf->BufSize < nBytes - nRead)
+ IncreaseBuf(IOBuf, 0, nBytes - nRead);
+ ptr = IOBuf->buf;
- slen = len = Buf->BufUsed;
+ slen = len = Blob->BufUsed;
fdflags = fcntl(*fd, F_GETFL);
SelRes = 1;
+ nBytes -= nRead;
+ nRead = 0;
while (nRead < nBytes) {
if ((fdflags & O_NONBLOCK) == O_NONBLOCK) {
FD_ZERO(&wset);
}
else if (SelRes) {
nSelects = 0;
- if ((rlen = read(*fd,
- ptr,
- nBytes - nRead)) == -1) {
+ rlen = read(*fd,
+ ptr,
+ nBytes - nRead);
+ if (rlen == -1) {
close(*fd);
*fd = -1;
*Error = strerror(errno);
nSelects ++;
if ((check == NNN_TERM) &&
(nRead > 5) &&
- (strncmp(Buf->buf + Buf->BufUsed - 5, "\n000\n", 5) == 0))
+ (strncmp(IOBuf->buf + IOBuf->BufUsed - 5, "\n000\n", 5) == 0))
{
- StrBufPlain(IOBuf, HKEY("\n000\n"));
- StrBufCutRight(Buf, 5);
- return Buf->BufUsed;
+ StrBufPlain(Blob, HKEY("\n000\n"));
+ StrBufCutRight(Blob, 5);
+ return Blob->BufUsed;
}
if (nSelects > 10) {
- FlushStrBuf(Buf);
+ FlushStrBuf(IOBuf);
return -1;
}
}
- nRead += rlen;
- ptr += rlen;
- Buf->BufUsed += rlen;
+ if (rlen > 0) {
+ nRead += rlen;
+ ptr += rlen;
+ IOBuf->BufUsed += rlen;
+ }
}
- Buf->buf[Buf->BufUsed] = '\0';
+ if (nRead > nBytes) {
+ *Pos = IOBuf->buf + nBytes;
+ }
+ Blob->buf[Blob->BufUsed] = '\0';
+ StrBufAppendBufPlain(Blob, IOBuf->buf, nBytes, 0);
return nRead;
}
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