X-Git-Url: https://code.citadel.org/?p=citadel.git;a=blobdiff_plain;f=libcitadel%2Flib%2Fstringbuf.c;h=436864690bd62d0af5eb9f638053de41ac9fe495;hp=ba88a2f431bbfe594661dd738bc3deaba19917e3;hb=fc6cb49257a19bff1336d735a075f78fae2f4728;hpb=b2341111a6a40427f8c7991c34d99af8b25ac6e1

diff --git a/libcitadel/lib/stringbuf.c b/libcitadel/lib/stringbuf.c
index ba88a2f43..436864690 100644
--- a/libcitadel/lib/stringbuf.c
+++ b/libcitadel/lib/stringbuf.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1987-2011 by the citadel.org team
+ * Copyright (c) 1987-2013 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
@@ -32,6 +32,9 @@
 
 #include "libcitadel.h"
 
+#include "b64/cencode.h"
+#include "b64/cdecode.h"
+
 #ifdef HAVE_ICONV
 #include <iconv.h>
 #endif
@@ -362,7 +365,12 @@ long StrBufShrinkToFit(StrBuf *Buf, int Force)
 	if (Force || 
 	    (Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize))
 	{
-		char *TmpBuf = (char*) malloc(Buf->BufUsed + 1);
+		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);
@@ -381,7 +389,15 @@ 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;
@@ -406,7 +422,16 @@ StrBuf* NewStrBufDup(const StrBuf *CopyMe)
 		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;
@@ -502,6 +527,9 @@ StrBuf* NewStrBufPlain(const char* ptr, int nChars)
 	size_t CopySize;
 
 	NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
+	if (NewBuf == NULL)
+		return NULL;
+
 	if (nChars < 0)
 		CopySize = strlen((ptr != NULL)?ptr:"");
 	else
@@ -595,6 +623,8 @@ 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;
@@ -1023,16 +1053,18 @@ int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t n
 	}
 	if (Offset + nChars < Source->BufUsed)
 	{
-		if (nChars >= dest->BufSize)
-			IncreaseBuf(dest, 0, nChars + 1);
+		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';
@@ -1144,29 +1176,22 @@ void StrBufSpaceToBlank(StrBuf *Buf)
 
 void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary)
 {
-	const char *pBuff;
 	const char *pLeft;
 	const char *pRight;
 
-	if ((Buf == NULL) || (Buf->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);
+	}
 }
 
 
@@ -1903,6 +1928,129 @@ void StrBufUrlescUPAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn)
 	*pt = '\0';
 }
 
+/** 
+ * @ingroup StrBuf_DeEnCoder
+ * @brief append a string with characters having a special meaning in xml encoded 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?
+ * @param 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("&lt;"));
+			pt += 4;
+			pch ++;
+		}
+		else if (*pch == '>') {
+			memcpy(pt, HKEY("&gt;"));
+			pt += 4;
+			pch ++;
+		}
+		else if (*pch == '&') {
+			memcpy(pt, HKEY("&amp;"));
+			pt += 5;
+			pch++;
+		}
+		else if ((*pch >= 0x20) && (*pch <= 0x7F)) {
+			*pt = *pch;
+			pt++; pch++;
+		}
+		else if (*pch < 0x20) {
+			/* we probably shouldn't be doing this */
+			if (OverrideLowChars)
+			{
+				*pt = '_';
+				pt ++;
+				pch ++;
+			}
+			else
+			{
+				*pt = '&';
+				pt++;
+				*pt = HexList[*(unsigned char*)pch][0];
+				pt ++;
+				*pt = HexList[*(unsigned char*)pch][1];
+				pt ++; pch ++;
+				*pt = '&';
+				pt++;
+				pch ++;
+			}
+		}
+		else {
+			IsUtf8Sequence =  Ctdl_GetUtf8SequenceLength(pch, pche);
+			if (IsUtf8Sequence)
+			{
+				while (IsUtf8Sequence > 0){
+					*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
@@ -1954,6 +2102,45 @@ void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *P
 	*pt = '\0';
 }
 
+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';
+}
+
 /** 
  * @ingroup StrBuf_DeEnCoder
  * @brief append a string in hex encoding to the buffer
@@ -2511,6 +2698,23 @@ long StrHtmlEcmaEscAppend(StrBuf *Target, const StrBuf *Source, const char *Plai
 	return Target->BufUsed;
 }
 
+
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief replace all non-Ascii characters by another
+ * @param Buf buffer to inspect
+ * @param repl charater to stamp over non ascii chars
+ */
+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;
+	
+}
+
 /**
  * @ingroup StrBuf_DeEnCoder
  * @brief unhide special chars hidden to the HTML escaper
@@ -2604,9 +2808,14 @@ int StrBufDecodeBase64(StrBuf *Buf)
 {
 	char *xferbuf;
 	size_t siz;
-	if (Buf == NULL) return -1;
+
+	if (Buf == NULL)
+		return -1;
 
 	xferbuf = (char*) malloc(Buf->BufSize);
+	if (xferbuf == NULL)
+		return -1;
+
 	*xferbuf = '\0';
 	siz = CtdlDecodeBase64(xferbuf,
 			       Buf->buf,
@@ -2614,9 +2823,81 @@ int StrBufDecodeBase64(StrBuf *Buf)
 	free(Buf->buf);
 	Buf->buf = xferbuf;
 	Buf->BufUsed = siz;
+
+	Buf->buf[Buf->BufUsed] = '\0';
 	return siz;
 }
 
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief decode a buffer from base 64 encoding; expects targetbuffer
+ * @param BufIn Buffor to transform
+ * @param 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, BufIn->BufUsed, 0);
+
+	BufOut->BufUsed = CtdlDecodeBase64(BufOut->buf,
+					   BufIn->buf,
+					   BufIn->BufUsed);
+	return BufOut->BufUsed;
+}
+
+void *StrBufNewStreamContext(eStreamType type)
+{
+	base64_decodestate *state;;
+
+	switch (type)
+	{
+	case eBase64Decode:
+		state = (base64_decodestate*) malloc(sizeof(base64_decodestate));
+		base64_init_decodestate(state);
+		return state;
+		break;
+	}
+	return NULL;
+}
+
+void StrBufDestroyStreamContext(eStreamType type, void **Stream)
+{
+	switch (type)
+	{
+	case eBase64Decode:
+		free(*Stream);
+		*Stream = NULL;
+		break;
+	}
+}
+void StrBufStreamDecodeTo(StrBuf *Target, const StrBuf *In, const char* pIn, long pInLen, void *Stream)
+{
+	base64_decodestate *state = Stream;
+	long ExpectLen;
+
+	if (In != NULL)
+	{
+		pIn = In->buf;
+		pInLen = In->BufUsed;
+	}
+	if ((pIn == NULL) || (Stream == NULL))
+		return;
+	
+	ExpectLen = (pInLen / 4) * 3;
+
+	if (Target->BufSize - Target->BufUsed < ExpectLen)
+	{
+		IncreaseBuf(Target, 1, Target->BufUsed + ExpectLen + 1);
+	}
+
+	ExpectLen = base64_decode_block(pIn, pInLen, Target->buf + Target->BufUsed, state);
+	Target->BufUsed += ExpectLen;
+	Target->buf[Target->BufUsed] = '\0';
+}
+
 /**
  * @ingroup StrBuf_DeEnCoder
  * @brief decode a buffer from base 64 encoding; destroys original
@@ -2771,7 +3052,6 @@ int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
 		ch = (unsigned char) source->buf[i];
 		if ((ch  <  32) || 
 		    (ch  > 126) || 
-		    (ch ==  61) ||
 		    (ch == '=') ||
                     (ch == '?') ||
 		    (ch == '_') ||
@@ -2799,6 +3079,95 @@ int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
 	return (*target)->BufUsed;;
 }
 
+/**
+ * @ingroup StrBuf_DeEnCoder
+ * @brief	Quoted-Printable encode a message; make it < 80 columns width.
+ * @param	source		Source string to be encoded.
+ * @returns     buffer with encoded message.
+ */
+StrBuf *StrBufRFC2047encodeMessage(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;
+
+	return OutBuf;
+}
 
 
 static void AddRecipient(StrBuf *Target, 
@@ -3881,18 +4250,34 @@ long IOBufferStrLength(IOBuffer *FB)
 	return StrLength(FB->Buf) - (FB->ReadWritePointer - FB->Buf->buf);
 }
 
-void FDIOBufferInit(FDIOBuffer *FDB, IOBuffer *IO, int FD, long TotalSendSize)
+inline static void FDIOBufferFlush(FDIOBuffer *FDB)
 {
 	memset(FDB, 0, sizeof(FDIOBuffer));
-	FDB->ChunkSize = 
-		FDB->TotalSendSize = TotalSendSize;
+	FDB->OtherFD = -1;
+	FDB->SplicePipe[0] = -1;
+	FDB->SplicePipe[1] = -1;
+}
+
+void FDIOBufferInit(FDIOBuffer *FDB, IOBuffer *IO, int FD, long TotalSendSize)
+{
+	FDIOBufferFlush(FDB);
+
+	FDB->TotalSendSize = TotalSendSize;
+	if (TotalSendSize > 0)
+		FDB->ChunkSize = TotalSendSize;
+	else
+	{
+		TotalSendSize = SIZ * 10;
+		FDB->ChunkSize = TotalSendSize;
+	}
 	FDB->IOB = IO;
+
 #ifdef LINUX_SPLICE
 	if (EnableSplice)
 		pipe(FDB->SplicePipe);
 	else
 #endif
-		FDB->ChunkBuffer = NewStrBufPlain(NULL, TotalSendSize + 1);
+		FDB->ChunkBuffer = NewStrBufPlain(NULL, TotalSendSize+ 1);
 
 	FDB->OtherFD = FD;
 }
@@ -3902,82 +4287,176 @@ void FDIOBufferDelete(FDIOBuffer *FDB)
 #ifdef LINUX_SPLICE
 	if (EnableSplice)
 	{
-		close(FDB->SplicePipe[0]);
-		close(FDB->SplicePipe[1]);
+		if (FDB->SplicePipe[0] > 0)
+			close(FDB->SplicePipe[0]);
+		if (FDB->SplicePipe[1] > 0)
+			close(FDB->SplicePipe[1]);
 	}
 	else
 #endif
 		FreeStrBuf(&FDB->ChunkBuffer);
 	
-	close(FDB->OtherFD);
-	memset(FDB, 0, sizeof(FDIOBuffer));	
+	if (FDB->OtherFD > 0)
+		close(FDB->OtherFD);
+	FDIOBufferFlush(FDB);
 }
 
 int FileSendChunked(FDIOBuffer *FDB, const char **Err)
 {
 	ssize_t sent, pipesize;
-#ifdef LINUX_SPLICE
-	if (EnableSplice)
+
+	if (FDB->TotalSendSize > 0)
 	{
-		if (FDB->PipeSize == 0)
+#ifdef LINUX_SPLICE
+		if (EnableSplice)
 		{
-			pipesize = splice(FDB->OtherFD,
-					  &FDB->TotalSentAlready, 
-					  FDB->SplicePipe[1],
-					  NULL, 
-					  FDB->ChunkSendRemain, 
-					  SPLICE_F_MOVE);
+			if (FDB->PipeSize == 0)
+			{
+				pipesize = splice(FDB->OtherFD,
+						  &FDB->TotalSentAlready, 
+						  FDB->SplicePipe[1],
+						  NULL, 
+						  FDB->ChunkSendRemain, 
+						  SPLICE_F_MOVE);
 	
-			if (pipesize == -1)
+				if (pipesize == -1)
+				{
+					*Err = strerror(errno);
+					return pipesize;
+				}
+				FDB->PipeSize = pipesize;
+			}
+			sent =  splice(FDB->SplicePipe[0],
+				       NULL, 
+				       FDB->IOB->fd,
+				       NULL, 
+				       FDB->PipeSize,
+				       SPLICE_F_MORE | SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
+			if (sent == -1)
 			{
 				*Err = strerror(errno);
-				return pipesize;
+				return sent;
 			}
-			FDB->PipeSize = pipesize;
+			FDB->PipeSize -= sent;
+			FDB->ChunkSendRemain -= sent;
+			return sent;
 		}
-		sent =  splice(FDB->SplicePipe[0],
-			       NULL, 
-			       FDB->IOB->fd,
-			       NULL, 
-			       FDB->PipeSize,
-			       SPLICE_F_MORE | SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
-		if (sent == -1)
+		else
+#endif
 		{
-			*Err = strerror(errno);
-			return sent;
+			char *pRead;
+			long nRead = 0;
+
+			pRead = FDB->ChunkBuffer->buf;
+			while ((FDB->ChunkBuffer->BufUsed < FDB->TotalSendSize) && (nRead >= 0))
+			{
+				nRead = read(FDB->OtherFD, pRead, FDB->TotalSendSize - FDB->ChunkBuffer->BufUsed);
+				if (nRead > 0) {
+					FDB->ChunkBuffer->BufUsed += nRead;
+					FDB->ChunkBuffer->buf[FDB->ChunkBuffer->BufUsed] = '\0';
+				}
+				else if (nRead == 0) {}
+				else return nRead;
+			}
+
+			nRead = write(FDB->IOB->fd,
+				      FDB->ChunkBuffer->buf     + FDB->TotalSentAlready,
+				      FDB->ChunkBuffer->BufUsed - FDB->TotalSentAlready);
+
+			if (nRead >= 0) {
+				FDB->TotalSentAlready += nRead;
+				FDB->ChunkSendRemain -= nRead;
+				return FDB->ChunkSendRemain;
+			}
+			else {
+				return nRead;
+			}
 		}
-		FDB->PipeSize -= sent;
-		FDB->ChunkSendRemain -= sent;
-		return sent;
 	}
 	else
-#endif
 	{
-		char *pRead;
-		long nRead = 0;
-
-		pRead = FDB->ChunkBuffer->buf;
-		while ((FDB->ChunkBuffer->BufUsed < FDB->TotalSendSize) && (nRead >= 0))
+#ifdef LINUX_SPLICE
+		if (EnableSplice)
 		{
-			nRead = read(FDB->OtherFD, pRead, FDB->TotalSendSize - FDB->ChunkBuffer->BufUsed);
-			if (nRead > 0) {
-				FDB->ChunkBuffer->BufUsed += nRead;
-				FDB->ChunkBuffer->buf[FDB->ChunkBuffer->BufUsed] = '\0';
+			if (FDB->PipeSize == 0)
+			{
+				pipesize = splice(FDB->OtherFD,
+						  &FDB->TotalSentAlready, 
+						  FDB->SplicePipe[1],
+						  NULL, 
+						  SIZ * 10, 
+						  SPLICE_F_MOVE);
+	
+				if (pipesize == -1)
+				{
+					*Err = strerror(errno);
+					return pipesize;
+				}
+				FDB->PipeSize = pipesize;
+				if (pipesize == 0)
+					return -1;
 			}
-			else if (nRead == 0) {}
-			else return nRead;
-		
+			sent =  splice(FDB->SplicePipe[0],
+				       NULL, 
+				       FDB->IOB->fd,
+				       NULL, 
+				       FDB->PipeSize,
+				       SPLICE_F_MORE | SPLICE_F_MOVE | SPLICE_F_NONBLOCK);
+			if (sent == -1)
+			{
+				*Err = strerror(errno);
+				return sent;
+			}
+			FDB->PipeSize -= sent;
+			FDB->ChunkSendRemain -= sent;
+			return sent;
 		}
+		else
+#endif
+		{
+			char *pRead;
+			long nRead = 0;
+
+			pRead = FDB->ChunkBuffer->buf;
+			while ((FDB->ChunkSendRemain == 0) && 
+			       (FDB->ChunkBuffer->BufUsed < FDB->ChunkBuffer->BufSize) &&
+			       (nRead >= 0))
+			{
+				FDB->TotalSentAlready = 0;
+				nRead = read(FDB->OtherFD, pRead, FDB->ChunkBuffer->BufSize - FDB->ChunkBuffer->BufUsed);
+				if (nRead > 0) {
+					FDB->ChunkBuffer->BufUsed += nRead;
+					FDB->ChunkBuffer->buf[FDB->ChunkBuffer->BufUsed] = '\0';
+					FDB->ChunkSendRemain += nRead;
+				}
+				else if (nRead == 0)
+				{
+					return -1;
+				}
+				else
+				{
+					*Err = strerror(errno);
+					return nRead;
+				}
+			}
 
-		nRead = write(FDB->IOB->fd, FDB->ChunkBuffer->buf + FDB->TotalSentAlready, FDB->ChunkSendRemain);
+			nRead = write(FDB->IOB->fd,
+				      FDB->ChunkBuffer->buf     + FDB->TotalSentAlready,
+				      FDB->ChunkBuffer->BufUsed - FDB->TotalSentAlready);
 
-		if (nRead >= 0) {
-			FDB->TotalSentAlready += nRead;
-			FDB->ChunkSendRemain -= nRead;
-			return FDB->ChunkSendRemain;
-		}
-		else {
-			return nRead;
+			if (nRead >= 0) {
+				FDB->TotalSentAlready += nRead;
+				FDB->ChunkSendRemain -= nRead;
+				if (FDB->ChunkSendRemain == 0)
+				{
+					FDB->ChunkBuffer->BufUsed = 0;
+					FDB->TotalSentAlready = 0;
+				}
+				return FDB->ChunkSendRemain;
+			}
+			else {
+				return nRead;
+			}
 		}
 	}
 }
@@ -4316,10 +4795,11 @@ int StrBufTCP_read_buffered_line(StrBuf *Line,
 			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;
 		}
 		
@@ -4509,6 +4989,10 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line,
 
 			continue;
 		}
+		else
+		{
+			nSuccessLess++;
+		}
 	}
 	*Pos = NULL;
 	if (pLF != NULL) {
@@ -4645,9 +5129,12 @@ int StrBufReadBLOBBuffered(StrBuf *Blob,
 	int nSuccessLess = 0;
 	int MaxTries;
 
-	if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL))
+	if ((Blob == NULL)  ||
+	    (*fd == -1)     ||
+	    (IOBuf == NULL) ||
+	    (Pos == NULL))
 	{
-		if (*Pos != NULL)
+		if (Pos != NULL)
 			*Pos = NULL;
 		*Error = ErrRBB_BLOBFPreConditionFailed;
 		return -1;