X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=libcitadel%2Flib%2Fstringbuf.c;h=b5bcf22f7a24d11d4b452700e1f5bdb45bc7335f;hb=0513df2bd1d22c17b3f401a4926a057037c1b5bd;hp=ba0b94e187d36c252fa88d8df6ad91e88a195b4c;hpb=17b1fb50274e441d3d0d70b587e36ea8e8475ff6;p=citadel.git diff --git a/libcitadel/lib/stringbuf.c b/libcitadel/lib/stringbuf.c index ba0b94e18..b5bcf22f7 100644 --- a/libcitadel/lib/stringbuf.c +++ b/libcitadel/lib/stringbuf.c @@ -1,4 +1,23 @@ -#include "../sysdep.h" +/* + * 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 + */ + +#define _GNU_SOURCE +#include "sysdep.h" #include #include #include @@ -10,6 +29,7 @@ #include #define SHOW_ME_VAPPEND_PRINTF #include + #include "libcitadel.h" #ifdef HAVE_ICONV @@ -20,6 +40,10 @@ #include #endif +#ifdef LINUX_SENDFILE +#include +#endif + #ifdef HAVE_ZLIB #include int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen, @@ -30,22 +54,22 @@ int BaseStrBufSize = 64; const char *StrBufNOTNULL = ((char*) NULL) - 1; const char HexList[256][3] = { -"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F", -"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F", -"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F", -"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F", -"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F", -"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F", -"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F", -"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F", -"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F", -"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F", -"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF", -"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF", -"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF", -"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF", -"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"}; + "00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F", + "10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F", + "20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F", + "30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F", + "40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F", + "50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F", + "60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F", + "70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F", + "80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F", + "90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F", + "A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF", + "B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF", + "C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF", + "D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF", + "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 @@ -215,6 +239,23 @@ void dbg_Init(StrBuf *Buf) #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) +{ + StrBuf C; + + memcpy(&C, A, sizeof(*A)); + memcpy(A, B, sizeof(*B)); + memcpy(B, &C, sizeof(C)); + +} + /** * @ingroup StrBuf_Cast * @brief Cast operator to Plain String @@ -259,9 +300,12 @@ static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize) return -1; if (DestSize > 0) - while (NewSize <= DestSize) + while ((NewSize <= DestSize) && (NewSize != 0)) NewSize *= 2; + if (NewSize == 0) + return -1; + NewBuf= (char*) malloc(NewSize); if (NewBuf == NULL) return -1; @@ -286,14 +330,16 @@ static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize) /** * @ingroup StrBuf_DeConstructors - * @brief shrink an _EMPTY_ buffer if its Buffer superseeds threshhold to NewSize. Buffercontent is thoroughly ignored and flushed. + * @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->BufUsed > ThreshHold) { + if ((Buf != NULL) && + (Buf->BufUsed == 0) && + (Buf->BufSize < ThreshHold)) { free(Buf->buf); Buf->buf = (char*) malloc(NewSize); Buf->BufUsed = 0; @@ -310,6 +356,8 @@ void ReAdjustEmptyBuf(StrBuf *Buf, long ThreshHold, long NewSize) */ long StrBufShrinkToFit(StrBuf *Buf, int Force) { + if (Buf == NULL) + return -1; if (Force || (Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize)) { @@ -368,6 +416,75 @@ StrBuf* NewStrBufDup(const StrBuf *CopyMe) 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) +{ + StrBuf *NewBuf; + + if (CreateRelpaceMe == NULL) + return; + + if (NoMe != NULL) + { + if (*CreateRelpaceMe != NULL) + StrBufPlain(*CreateRelpaceMe, NoMe, KeepOriginal); + else + *CreateRelpaceMe = NewStrBufPlain(NoMe, KeepOriginal); + return; + } + + if (CopyFlushMe == NULL) + { + if (*CreateRelpaceMe != NULL) + FlushStrBuf(*CreateRelpaceMe); + else + *CreateRelpaceMe = NewStrBuf(); + 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) + { + *CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed); + dbg_Init(NewBuf); + } + else + { + NewBuf = *CreateRelpaceMe; + FlushStrBuf(NewBuf); + } + StrBufAppendBuf(NewBuf, CopyFlushMe, 0); + } + else + { + if (*CreateRelpaceMe == NULL) + { + *CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed); + dbg_Init(NewBuf); + } + else + NewBuf = *CreateRelpaceMe; + SwapBuffers (NewBuf, CopyFlushMe); + } + if (!KeepOriginal) + FlushStrBuf(CopyFlushMe); + return; +} + /** * @ingroup StrBuf_DeConstructors * @brief create a new Buffer using an existing c-string @@ -389,10 +506,20 @@ StrBuf* NewStrBufPlain(const char* ptr, int nChars) else CopySize = nChars; - while (Siz <= CopySize) + while ((Siz <= CopySize) && (Siz != 0)) Siz *= 2; + if (Siz == 0) + { + return NULL; + } + NewBuf->buf = (char*) malloc(Siz); + if (NewBuf->buf == NULL) + { + free(NewBuf); + return NULL; + } NewBuf->BufSize = Siz; if (ptr != NULL) { memcpy(NewBuf->buf, ptr, CopySize); @@ -405,7 +532,7 @@ StrBuf* NewStrBufPlain(const char* ptr, int nChars) } NewBuf->ConstBuf = 0; - dbg_Init(NewBuf) + dbg_Init(NewBuf); return NewBuf; } @@ -420,17 +547,31 @@ StrBuf* NewStrBufPlain(const char* ptr, int nChars) */ int StrBufPlain(StrBuf *Buf, const char* ptr, int nChars) { - size_t Siz = Buf->BufSize; + size_t Siz; size_t CopySize; + if (Buf == NULL) + return -1; + if (ptr == NULL) { + FlushStrBuf(Buf); + return -1; + } + + Siz = Buf->BufSize; + if (nChars < 0) CopySize = strlen(ptr); else CopySize = nChars; - while (Siz <= CopySize) + while ((Siz <= CopySize) && (Siz != 0)) Siz *= 2; + if (Siz == 0) { + FlushStrBuf(Buf); + return -1; + } + if (Siz != Buf->BufSize) IncreaseBuf(Buf, 0, Siz); memcpy(Buf->buf, ptr, CopySize); @@ -599,20 +740,26 @@ int StrToi(const StrBuf *Buf) /** * @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. */ int StrBufIsNumber(const StrBuf *Buf) { - char * pEnd; - if (Buf == NULL) { + char * pEnd; + if ((Buf == NULL) || (Buf->BufUsed == 0)) { + return 0; + } + strtoll(Buf->buf, &pEnd, 10); + if (pEnd == Buf->buf) + return 0; + if ((pEnd != NULL) && (pEnd == Buf->buf + Buf->BufUsed)) + return 1; + if (Buf->buf == pEnd) + return 0; return 0; - } - strtoll(Buf->buf, &pEnd, 10); - if (pEnd == NULL && ((Buf->buf)-pEnd) != 0) { - return 1; - } - return 0; } + /** - * @ingroup StrBuf + * @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 @@ -633,7 +780,34 @@ long StrBufPeek(StrBuf *Buf, const char* ptr, long nThChar, char PeekValue) } /** - * @ingroup StrBuf + * @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) +{ + if (Buf == NULL) + return -1; + if (ptr != NULL) + nThChar = ptr - Buf->buf; + if ((nThChar < 0) || (nThChar > Buf->BufUsed)) + return -1; + if (nThChar + nChars > Buf->BufUsed) + nChars = Buf->BufUsed - nThChar; + + memset(Buf->buf + nThChar, PookValue, nChars); + /* just to be shure... */ + 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 @@ -658,7 +832,7 @@ void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset) /** - * @ingroup StrBuf + * @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 @@ -690,7 +864,7 @@ void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, u } /** - * @ingroup StrBuf + * @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 @@ -721,7 +895,8 @@ void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap) va_end(apl); newused = Offset + nWritten; if (newused >= Buf->BufSize) { - IncreaseBuf(Buf, 1, newused); + if (IncreaseBuf(Buf, 1, newused) == -1) + return; /* TODO: error handling? */ newused = Buf->BufSize + 1; } else { @@ -733,7 +908,7 @@ void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap) } /** - * @ingroup StrBuf + * @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 @@ -762,7 +937,8 @@ void StrBufAppendPrintf(StrBuf *Buf, const char *format, ...) va_end(arg_ptr); newused = Buf->BufUsed + nWritten; if (newused >= Buf->BufSize) { - IncreaseBuf(Buf, 1, newused); + if (IncreaseBuf(Buf, 1, newused) == -1) + return; /* TODO: error handling? */ newused = Buf->BufSize + 1; } else { @@ -774,7 +950,7 @@ void StrBufAppendPrintf(StrBuf *Buf, const char *format, ...) } /** - * @ingroup StrBuf + * @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 @@ -793,7 +969,8 @@ void StrBufPrintf(StrBuf *Buf, const char *format, ...) nWritten = vsnprintf(Buf->buf, Buf->BufSize, format, arg_ptr); va_end(arg_ptr); if (nWritten >= Buf->BufSize) { - IncreaseBuf(Buf, 0, 0); + if (IncreaseBuf(Buf, 0, 0) == -1) + return; /* TODO: error handling? */ nWritten = Buf->BufSize + 1; continue; } @@ -802,7 +979,7 @@ void StrBufPrintf(StrBuf *Buf, const char *format, ...) } /** - * @ingroup StrBuf + * @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 @@ -837,7 +1014,8 @@ int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t n size_t NCharsRemain; if (Offset > Source->BufUsed) { - FlushStrBuf(dest); + if (dest != NULL) + FlushStrBuf(dest); return 0; } if (Offset + nChars < Source->BufUsed) @@ -866,6 +1044,7 @@ int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t n */ void StrBufCutLeft(StrBuf *Buf, int nChars) { + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; if (nChars >= Buf->BufUsed) { FlushStrBuf(Buf); return; @@ -883,6 +1062,7 @@ void StrBufCutLeft(StrBuf *Buf, int nChars) */ void StrBufCutRight(StrBuf *Buf, int nChars) { + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; if (nChars >= Buf->BufUsed) { FlushStrBuf(Buf); return; @@ -900,6 +1080,7 @@ void StrBufCutRight(StrBuf *Buf, int nChars) */ void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At) { + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; if (At != NULL){ AfternChars = At - Buf->buf; } @@ -921,20 +1102,71 @@ void StrBufTrim(StrBuf *Buf) int delta = 0; if ((Buf == NULL) || (Buf->BufUsed == 0)) return; + while ((Buf->BufUsed > 0) && + isspace(Buf->buf[Buf->BufUsed - 1])) + { + Buf->BufUsed --; + } + Buf->buf[Buf->BufUsed] = '\0'; + + if (Buf->BufUsed == 0) return; + while ((Buf->BufUsed > delta) && (isspace(Buf->buf[delta]))){ delta ++; } 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) +{ + char *pche, *pch; - if (Buf->BufUsed == 0) return; - while (isspace(Buf->buf[Buf->BufUsed - 1])){ - Buf->BufUsed --; + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; + + pch = Buf->buf; + pche = pch + Buf->BufUsed; + while (pch < pche) + { + if (isspace(*pch)) + *pch = ' '; + pch ++; } - Buf->buf[Buf->BufUsed] = '\0'; } +void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary) +{ + const char *pBuff; + const char *pLeft; + const char *pRight; + + 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) + StrBufCutAt(Buf, 0, pRight); + if (pLeft != NULL) + StrBufCutLeft(Buf, pLeft - Buf->buf); +} + + /** - * @ingroup StrBuf + * @ingroup StrBuf_Filler * @brief uppercase the contents of a buffer * @param Buf the buffer to translate */ @@ -942,6 +1174,8 @@ void StrBufUpCase(StrBuf *Buf) { char *pch, *pche; + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; + pch = Buf->buf; pche = pch + Buf->BufUsed; while (pch < pche) { @@ -952,7 +1186,7 @@ void StrBufUpCase(StrBuf *Buf) /** - * @ingroup StrBuf + * @ingroup StrBuf_Filler * @brief lowercase the contents of a buffer * @param Buf the buffer to translate */ @@ -960,6 +1194,8 @@ void StrBufLowerCase(StrBuf *Buf) { char *pch, *pche; + if ((Buf == NULL) || (Buf->BufUsed == 0)) return; + pch = Buf->buf; pche = pch + Buf->BufUsed; while (pch < pche) { @@ -973,6 +1209,41 @@ void StrBufLowerCase(StrBuf *Buf) * 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) +{ + + 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) + return -1; + + memmove(Buf->buf + where + ReplLen, + Buf->buf + where + HowLong, + Buf->BufUsed - where - HowLong); + + memcpy(Buf->buf + where, + Repl, ReplLen); + + Buf->BufUsed += ReplLen - HowLong; + + return Buf->BufUsed; +} + /** * @ingroup StrBuf_Tokenizer * @brief Counts the numbmer of tokens in a buffer @@ -982,9 +1253,22 @@ void StrBufLowerCase(StrBuf *Buf) */ int StrBufNum_tokens(const StrBuf *source, char tok) { - if (source == NULL) + char *pch, *pche; + long NTokens; + if ((source == NULL) || (source->BufUsed == 0)) return 0; - return num_tokens(source->buf, tok); + if ((source->BufUsed == 1) && (*source->buf == tok)) + return 2; + NTokens = 1; + pch = source->buf; + pche = pch + source->BufUsed; + while (pch < pche) + { + if (*pch == tok) + NTokens ++; + pch ++; + } + return NTokens; } /** @@ -1089,7 +1373,7 @@ int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char se //cit_backtrace(); //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source); - while ((sBufUsed == 0) ) { *pStart = StrBufNOTNULL; + if (dest != NULL) + FlushStrBuf(dest); return -1; } @@ -1374,7 +1660,7 @@ int StrBufSkip_NTokenS(const StrBuf *Source, const char **pStart, char separator //cit_backtrace(); //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source); - while ((s= '@' && *pch <= 'Z') || /* @ A-Z */ (*pch >= '0' && *pch <= ':') || /* 0-9 : */ (*pch == '!') || (*pch == '_') || - (*pch == ',') || (*pch == '.') || - (*pch == ',')) + (*pch == ',') || (*pch == '.')) { *(pt++) = *(pch++); OutBuf->BufUsed++; @@ -1536,68 +1821,191 @@ void StrBufUrlescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn) *pt = '\0'; } -/** +/** * @ingroup StrBuf_DeEnCoder - * @brief 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. - * if set to 2, linebreaks are replaced by <br/> + * @brief Escape a string for feeding out as a the username/password part of an 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 */ -long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks) +void StrBufUrlescUPAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn) { - const char *aptr, *eiptr; - char *bptr, *eptr; - long len; - - if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) ) - return -1; - + const char *pch, *pche; + char *pt, *pte; + int len; + + if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) ) + return; if (PlainIn != NULL) { - aptr = PlainIn; len = strlen(PlainIn); - eiptr = aptr + len; + pch = PlainIn; + pche = pch + len; } else { - aptr = Source->buf; - eiptr = aptr + Source->BufUsed; - len = Source->BufUsed; + pch = In->buf; + pche = pch + In->BufUsed; + len = In->BufUsed; } if (len == 0) - return -1; + return; - bptr = Target->buf + Target->BufUsed; - eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ + pt = OutBuf->buf + OutBuf->BufUsed; + pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */ - while (aptr < eiptr){ - if(bptr >= eptr) { - IncreaseBuf(Target, 1, -1); - eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ - bptr = Target->buf + Target->BufUsed; - } - if (*aptr == '<') { - memcpy(bptr, "<", 4); - bptr += 4; - Target->BufUsed += 4; - } - else if (*aptr == '>') { - memcpy(bptr, ">", 4); - bptr += 4; - Target->BufUsed += 4; + 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; } - else if (*aptr == '&') { - memcpy(bptr, "&", 5); - bptr += 5; - Target->BufUsed += 5; + + 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 ++; } - else if (*aptr == '"') { - memcpy(bptr, """, 6); - bptr += 6; - Target->BufUsed += 6; + } + *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 + * @param 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) +{ + const unsigned char *pch, *pche; + char *pt, *pte; + 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 unsigned char*)In->buf; + pche = pch + In->BufUsed; + len = In->BufUsed; + } + + if (len == 0) + return; + + pt = OutBuf->buf + OutBuf->BufUsed; + pte = OutBuf->buf + OutBuf->BufSize - 3; /**< 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 - 3; /**< we max append 3 chars at once plus the \0 */ + pt = OutBuf->buf + OutBuf->BufUsed; + } + + *pt = HexList[*pch][0]; + pt ++; + *pt = HexList[*pch][1]; + pt ++; pch ++; OutBuf->BufUsed += 2; + } + *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) +{ + StrBufHexEscAppend(OutBuf, In, (const unsigned char*) PlainIn, -1); +} + +/** + * @ingroup StrBuf_DeEnCoder + * @brief 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. + * if set to 2, linebreaks are replaced by <br/> + */ +long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks) +{ + const char *aptr, *eiptr; + char *bptr, *eptr; + long len; + + if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) ) + return -1; + + 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 -1; + + bptr = Target->buf + Target->BufUsed; + eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ + + while (aptr < eiptr){ + if(bptr >= eptr) { + IncreaseBuf(Target, 1, -1); + eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ + bptr = Target->buf + Target->BufUsed; + } + if (*aptr == '<') { + memcpy(bptr, "<", 4); + bptr += 4; + Target->BufUsed += 4; + } + else if (*aptr == '>') { + memcpy(bptr, ">", 4); + bptr += 4; + Target->BufUsed += 4; + } + else if (*aptr == '&') { + memcpy(bptr, "&", 5); + bptr += 5; + Target->BufUsed += 5; + } + else if (*aptr == '"') { + memcpy(bptr, """, 6); + bptr += 6; + Target->BufUsed += 6; } else if (*aptr == '\'') { memcpy(bptr, "'", 5); @@ -1801,6 +2209,7 @@ long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) const char *aptr, *eiptr; char *bptr, *eptr; long len; + int IsUtf8Sequence; if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) ) return -1; @@ -1820,31 +2229,83 @@ long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn) return -1; bptr = Target->buf + Target->BufUsed; - eptr = Target->buf + Target->BufSize - 3; /* our biggest unit to put in... */ + eptr = Target->buf + Target->BufSize - 7; /* our biggest unit to put in... */ while (aptr < eiptr){ if(bptr >= eptr) { IncreaseBuf(Target, 1, -1); - eptr = Target->buf + Target->BufSize - 3; + eptr = Target->buf + Target->BufSize - 7; /* our biggest unit to put in... */ bptr = Target->buf + Target->BufUsed; } - if (*aptr == '"') { + switch (*aptr) { + case '\n': + memcpy(bptr, HKEY("\\n")); + bptr += 2; + Target->BufUsed += 2; + break; + case '\r': + memcpy(bptr, HKEY("\\r")); + bptr += 2; + Target->BufUsed += 2; + break; + case '"': *bptr = '\\'; bptr ++; *bptr = '"'; bptr ++; Target->BufUsed += 2; - } else if (*aptr == '\\') { + break; + case '\\': + if ((*(aptr + 1) == 'u') && + isxdigit(*(aptr + 2)) && + isxdigit(*(aptr + 3)) && + isxdigit(*(aptr + 4)) && + isxdigit(*(aptr + 5))) + { /* oh, a unicode escaper. let it pass through. */ + memcpy(bptr, aptr, 6); + aptr += 5; + bptr +=6; + Target->BufUsed += 6; + } + else + { + *bptr = '\\'; + bptr ++; + *bptr = '\\'; + bptr ++; + Target->BufUsed += 2; + } + break; + case '\b': *bptr = '\\'; bptr ++; + *bptr = 'b'; + bptr ++; + Target->BufUsed += 2; + break; + case '\f': *bptr = '\\'; bptr ++; + *bptr = 'f'; + bptr ++; Target->BufUsed += 2; - } - else{ - *bptr = *aptr; - bptr++; - Target->BufUsed ++; + break; + case '\t': + *bptr = '\\'; + bptr ++; + *bptr = 't'; + bptr ++; + Target->BufUsed += 2; + break; + default: + IsUtf8Sequence = Ctdl_GetUtf8SequenceLength(aptr, eiptr); + while (IsUtf8Sequence > 0){ + *bptr = *aptr; + Target->BufUsed ++; + if (--IsUtf8Sequence) + aptr++; + bptr++; + } } aptr ++; } @@ -1898,83 +2359,127 @@ long StrHtmlEcmaEscAppend(StrBuf *Target, const StrBuf *Source, const char *Plai eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ bptr = Target->buf + Target->BufUsed; } - if (*aptr == '<') { - memcpy(bptr, "<", 4); + switch (*aptr) { + case '<': + memcpy(bptr, HKEY("<")); bptr += 4; Target->BufUsed += 4; - } - else if (*aptr == '>') { - memcpy(bptr, ">", 4); + break; + case '>': + memcpy(bptr, HKEY(">")); bptr += 4; Target->BufUsed += 4; - } - else if (*aptr == '&') { - memcpy(bptr, "&", 5); + break; + case '&': + memcpy(bptr, HKEY("&")); bptr += 5; Target->BufUsed += 5; - } - else if (*aptr == LB) { + break; + case LB: *bptr = '<'; bptr ++; Target->BufUsed ++; - } - else if (*aptr == RB) { + break; + case RB: *bptr = '>'; bptr ++; Target->BufUsed ++; - } - else if ((*aptr == 32) && (nbsp == 1)) { - memcpy(bptr, " ", 6); - bptr += 6; - Target->BufUsed += 6; - } - else if ((*aptr == '\n') && (nolinebreaks == 1)) { - *bptr='\0'; /* nothing */ - } - else if ((*aptr == '\n') && (nolinebreaks == 2)) { - memcpy(bptr, "<br/>", 11); - bptr += 11; - Target->BufUsed += 11; - } - - else if ((*aptr == '\r') && (nolinebreaks != 0)) { - *bptr='\0'; /* nothing */ - } - - else if ((*aptr == '"') || (*aptr == QU)) { + break; + case '\n': + switch (nolinebreaks) { + case 1: + *bptr='\0'; /* nothing */ + break; + case 2: + memcpy(bptr, HKEY("<br/>")); + bptr += 11; + Target->BufUsed += 11; + break; + default: + memcpy(bptr, HKEY("\\n")); + bptr += 2; + Target->BufUsed += 2; + } + break; + case '\r': + switch (nolinebreaks) { + case 1: + case 2: + *bptr='\0'; /* nothing */ + break; + default: + memcpy(bptr, HKEY("\\r")); + bptr += 2; + Target->BufUsed += 2; + break; + } + break; + case '"': + case QU: *bptr = '\\'; bptr ++; *bptr = '"'; bptr ++; Target->BufUsed += 2; - } else if (*aptr == '\\') { + break; + case '\\': + if ((*(aptr + 1) == 'u') && + isxdigit(*(aptr + 2)) && + isxdigit(*(aptr + 3)) && + isxdigit(*(aptr + 4)) && + isxdigit(*(aptr + 5))) + { /* oh, a unicode escaper. let it pass through. */ + memcpy(bptr, aptr, 6); + aptr += 5; + bptr +=6; + Target->BufUsed += 6; + } + else + { + *bptr = '\\'; + bptr ++; + *bptr = '\\'; + bptr ++; + Target->BufUsed += 2; + } + break; + case '\b': + *bptr = '\\'; + bptr ++; + *bptr = 'b'; + bptr ++; + Target->BufUsed += 2; + break; + case '\f': *bptr = '\\'; bptr ++; + *bptr = 'f'; + bptr ++; + Target->BufUsed += 2; + break; + case '\t': *bptr = '\\'; bptr ++; + *bptr = 't'; + bptr ++; Target->BufUsed += 2; - } - else { - if (((unsigned char)*aptr) >= 0x20) - { - IsUtf8Sequence = Ctdl_GetUtf8SequenceLength(aptr, eiptr); - + break; + case 32: + if (nbsp == 1) { + memcpy(bptr, HKEY(" ")); + bptr += 6; + Target->BufUsed += 6; + break; + } + default: + IsUtf8Sequence = Ctdl_GetUtf8SequenceLength(aptr, eiptr); + while (IsUtf8Sequence > 0){ *bptr = *aptr; Target->BufUsed ++; - while (IsUtf8Sequence > 1){ - if(bptr + IsUtf8Sequence >= eptr) { - IncreaseBuf(Target, 1, -1); - eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */ - bptr = Target->buf + Target->BufUsed - 1; - } - bptr++; aptr++; - IsUtf8Sequence --; - *bptr = *aptr; - Target->BufUsed ++; - } + if (--IsUtf8Sequence) + aptr++; bptr++; } - } aptr ++; } @@ -2080,6 +2585,7 @@ int StrBufDecodeBase64(StrBuf *Buf) if (Buf == NULL) return -1; xferbuf = (char*) malloc(Buf->BufSize); + *xferbuf = '\0'; siz = CtdlDecodeBase64(xferbuf, Buf->buf, Buf->BufUsed); @@ -2149,6 +2655,9 @@ long StrBufUnescape(StrBuf *Buf, int StripBlanks) char hex[3]; long len; + if (Buf == NULL) + return -1; + while ((Buf->BufUsed > 0) && (isspace(Buf->buf[Buf->BufUsed - 1]))){ Buf->buf[Buf->BufUsed - 1] = '\0'; Buf->BufUsed --; @@ -2235,12 +2744,23 @@ int StrBufRFC2047encode(StrBuf **target, const StrBuf *source) if ((*target)->BufUsed + 4 >= (*target)->BufSize) IncreaseBuf(*target, 1, 0); ch = (unsigned char) source->buf[i]; - if ((ch < 32) || (ch > 126) || (ch == 61)) { + if ((ch < 32) || + (ch > 126) || + (ch == 61) || + (ch == '=') || + (ch == '?') || + (ch == '_') || + (ch == '[') || + (ch == ']') ) + { sprintf(&(*target)->buf[(*target)->BufUsed], "=%02X", ch); (*target)->BufUsed += 3; } else { - (*target)->buf[(*target)->BufUsed] = ch; + if (ch == ' ') + (*target)->buf[(*target)->BufUsed] = '_'; + else + (*target)->buf[(*target)->BufUsed] = ch; (*target)->BufUsed++; } } @@ -2254,53 +2774,254 @@ int StrBufRFC2047encode(StrBuf **target, const StrBuf *source) return (*target)->BufUsed;; } -/** - * @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 - */ -void StrBufReplaceChars(StrBuf *buf, char search, char replace) + + +static void AddRecipient(StrBuf *Target, + StrBuf *UserName, + StrBuf *EmailAddress, + StrBuf *EncBuf) { - long i; - if (buf == NULL) - return; - for (i=0; iBufUsed; i++) - if (buf->buf[i] == search) - buf->buf[i] = replace; + int QuoteMe = 0; -} + if (StrLength(Target) > 0) StrBufAppendBufPlain(Target, HKEY(", "), 0); + if (strchr(ChrPtr(UserName), ',') != NULL) QuoteMe = 1; + if (QuoteMe) StrBufAppendBufPlain(Target, HKEY("\""), 0); + StrBufRFC2047encode(&EncBuf, UserName); + StrBufAppendBuf(Target, EncBuf, 0); + if (QuoteMe) StrBufAppendBufPlain(Target, HKEY("\" "), 0); + else StrBufAppendBufPlain(Target, HKEY(" "), 0); + + if (StrLength(EmailAddress) > 0){ + StrBufAppendBufPlain(Target, HKEY("<"), 0); + StrBufAppendBuf(Target, EmailAddress, 0); /* TODO: what about IDN???? */ + StrBufAppendBufPlain(Target, HKEY(">"), 0); + } +} -/******************************************************************************* - * Iconv Wrapper; RFC822 de/encoding * - *******************************************************************************/ /** - * @ingroup StrBuf_DeEnCoder - * @brief 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 + * \brief QP encode parts of an email TO/CC/BCC vector, and strip/filter invalid parts + * \param Recp Source list of email recipients + * \param UserName Temporary buffer for internal use; Please provide valid buffer. + * \param EmailAddress Temporary buffer for internal use; Please provide valid buffer. + * \param EncBuf Temporary buffer for internal use; Please provide valid buffer. + * \returns encoded & sanitized buffer with the contents of Recp; Caller owns this memory. */ -void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic) +StrBuf *StrBufSanitizeEmailRecipientVector(const StrBuf *Recp, + StrBuf *UserName, + StrBuf *EmailAddress, + StrBuf *EncBuf) { -#ifdef HAVE_ICONV - iconv_t ic = (iconv_t)(-1) ; - ic = iconv_open(tocode, fromcode); - if (ic == (iconv_t)(-1) ) { - char alias_fromcode[64]; - if ( (strlen(fromcode) == 5) && (!strncasecmp(fromcode, "MS", 2)) ) { - safestrncpy(alias_fromcode, fromcode, sizeof alias_fromcode); - alias_fromcode[0] = 'C'; - alias_fromcode[1] = 'P'; - ic = iconv_open(tocode, alias_fromcode); - } - } + StrBuf *Target; + const char *pch, *pche; + const char *UserStart, *UserEnd, *EmailStart, *EmailEnd, *At; + + if ((Recp == NULL) || (StrLength(Recp) == 0)) + return NULL; + + pch = ChrPtr(Recp); + pche = pch + StrLength(Recp); + + if (!CheckEncode(pch, -1, pche)) + return NewStrBufDup(Recp); + + Target = NewStrBufPlain(NULL, StrLength(Recp)); + + while ((pch != NULL) && (pch < pche)) + { + while (isspace(*pch)) pch++; + UserEnd = EmailStart = EmailEnd = NULL; + + if ((*pch == '"') || (*pch == '\'')) { + UserStart = pch + 1; + + UserEnd = strchr(UserStart, *pch); + if (UserEnd == NULL) + break; ///TODO: Userfeedback?? + EmailStart = UserEnd + 1; + while (isspace(*EmailStart)) + EmailStart++; + if (UserEnd == UserStart) { + UserStart = UserEnd = NULL; + } + + if (*EmailStart == '<') { + EmailStart++; + EmailEnd = strchr(EmailStart, '>'); + if (EmailEnd == NULL) + EmailEnd = strchr(EmailStart, ','); + + } + else { + EmailEnd = strchr(EmailStart, ','); + } + if (EmailEnd == NULL) + EmailEnd = pche; + pch = EmailEnd + 1; + } + else { + int gt = 0; + UserStart = pch; + EmailEnd = strchr(UserStart, ','); + if (EmailEnd == NULL) { + EmailEnd = strchr(pch, '>'); + pch = NULL; + if (EmailEnd != NULL) { + gt = 1; + } + else { + EmailEnd = pche; + } + } + else { + + pch = EmailEnd + 1; + while ((EmailEnd > UserStart) && !gt && + ((*EmailEnd == ',') || + (*EmailEnd == '>') || + (isspace(*EmailEnd)))) + { + if (*EmailEnd == '>') + gt = 1; + else + EmailEnd--; + } + if (EmailEnd == UserStart) + break; + } + if (gt) { + EmailStart = strchr(UserStart, '<'); + if ((EmailStart == NULL) || (EmailStart > EmailEnd)) + break; + UserEnd = EmailStart; + + while ((UserEnd > UserStart) && + isspace (*(UserEnd - 1))) + UserEnd --; + EmailStart ++; + if (UserStart >= UserEnd) + UserStart = UserEnd = NULL; + } + else { /* this is a local recipient... no domain, just a realname */ + EmailStart = UserStart; + At = strchr(EmailStart, '@'); + if (At == NULL) { + UserEnd = EmailEnd; + EmailEnd = NULL; + } + else { + EmailStart = UserStart; + UserStart = NULL; + } + } + } + + if ((UserStart != NULL) && (UserEnd != NULL)) + StrBufPlain(UserName, UserStart, UserEnd - UserStart); + else if ((UserStart != NULL) && (UserEnd == NULL)) + StrBufPlain(UserName, UserStart, UserEnd - UserStart); + else + FlushStrBuf(UserName); + + if ((EmailStart != NULL) && (EmailEnd != NULL)) + StrBufPlain(EmailAddress, EmailStart, EmailEnd - EmailStart); + else if ((EmailStart != NULL) && (EmailEnd == NULL)) + StrBufPlain(EmailAddress, EmailStart, EmailEnd - pche); + else + FlushStrBuf(EmailAddress); + + AddRecipient(Target, UserName, EmailAddress, EncBuf); + + if (pch == NULL) + break; + + if ((pch != NULL) && (*pch == ',')) + pch ++; + if (pch != NULL) while (isspace(*pch)) + pch ++; + } + return Target; +} + + +/** + * @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 + */ +void StrBufReplaceChars(StrBuf *buf, char search, char replace) +{ + long i; + if (buf == NULL) + return; + for (i=0; iBufUsed; i++) + if (buf->buf[i] == search) + buf->buf[i] = replace; + +} + +/** + * @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 + */ +void StrBufToUnixLF(StrBuf *buf) +{ + char *pche, *pchS, *pchT; + if (buf == NULL) + return; + + pche = buf->buf + buf->BufUsed; + pchS = pchT = buf->buf; + while (pchS < pche) + { + if (*pchS == '\r') + { + pchS ++; + if (*pchS != '\n') { + *pchT = '\n'; + pchT++; + } + } + *pchT = *pchS; + pchT++; pchS++; + } + *pchT = '\0'; + buf->BufUsed = pchT - buf->buf; +} + + +/******************************************************************************* + * Iconv Wrapper; RFC822 de/encoding * + *******************************************************************************/ + +/** + * @ingroup StrBuf_DeEnCoder + * @brief 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 + */ +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); + if (ic == (iconv_t)(-1) ) { + char alias_fromcode[64]; + if ( (strlen(fromcode) == 5) && (!strncasecmp(fromcode, "MS", 2)) ) { + safestrncpy(alias_fromcode, fromcode, sizeof alias_fromcode); + alias_fromcode[0] = 'C'; + alias_fromcode[1] = 'P'; + ic = iconv_open(tocode, alias_fromcode); + } + } *(iconv_t *)pic = ic; #endif } @@ -2313,9 +3034,9 @@ void ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic) * @param bptr where to start searching * @returns found position, NULL if none. */ -static inline char *FindNextEnd (const StrBuf *Buf, char *bptr) +static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr) { - char * end; + const char * end; /* Find the next ?Q? */ if (Buf->BufUsed - (bptr - Buf->buf) < 6) return NULL; @@ -2326,7 +3047,8 @@ static inline char *FindNextEnd (const StrBuf *Buf, char *bptr) return NULL; if ((Buf->BufUsed - (end - Buf->buf) > 3) && - ((*(end + 1) == 'B') || (*(end + 1) == 'Q')) && + (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) || + ((*(end + 1) == 'b') || (*(end + 1) == 'q'))) && (*(end + 2) == '?')) { /* skip on to the end of the cluster, the next ?= */ end = strstr(end + 3, "?="); @@ -2337,22 +3059,6 @@ static inline char *FindNextEnd (const StrBuf *Buf, char *bptr) return end; } -/** - * @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) -{ - StrBuf C; - - memcpy(&C, A, sizeof(*A)); - memcpy(A, B, sizeof(*B)); - memcpy(B, &C, sizeof(C)); - -} /** @@ -2429,8 +3135,8 @@ TRYAGAIN: */ inline static void DecodeSegment(StrBuf *Target, const StrBuf *DecodeMe, - char *SegmentStart, - char *SegmentEnd, + const char *SegmentStart, + const char *SegmentEnd, StrBuf *ConvertBuf, StrBuf *ConvertBuf2, StrBuf *FoundCharset) @@ -2446,7 +3152,7 @@ inline static void DecodeSegment(StrBuf *Target, /* Now we handle foreign character sets properly encoded * in RFC2047 format. */ - StaticBuf.buf = SegmentStart; + StaticBuf.buf = (char*) SegmentStart; /*< it will just be read there... */ StaticBuf.BufUsed = SegmentEnd - SegmentStart; StaticBuf.BufSize = DecodeMe->BufSize - (SegmentStart - DecodeMe->buf); extract_token(charset, SegmentStart, 1, '?', sizeof charset); @@ -2459,6 +3165,8 @@ inline static void DecodeSegment(StrBuf *Target, *encoding = toupper(*encoding); if (*encoding == 'B') { /**< base64 */ + if (ConvertBuf2->BufSize < ConvertBuf->BufUsed) + IncreaseBuf(ConvertBuf2, 0, ConvertBuf->BufUsed); ConvertBuf2->BufUsed = CtdlDecodeBase64(ConvertBuf2->buf, ConvertBuf->buf, ConvertBuf->BufUsed); @@ -2474,6 +3182,9 @@ inline static void DecodeSegment(StrBuf *Target, pos++; } + if (ConvertBuf2->BufSize < ConvertBuf->BufUsed) + IncreaseBuf(ConvertBuf2, 0, ConvertBuf->BufUsed); + ConvertBuf2->BufUsed = CtdlDecodeQuotedPrintable( ConvertBuf2->buf, ConvertBuf->buf, @@ -2499,7 +3210,7 @@ inline static void DecodeSegment(StrBuf *Target, /** * @ingroup StrBuf_DeEnCoder - * @brief Handle subjects with RFC2047 encoding such as: + * @brief 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 @@ -2508,17 +3219,50 @@ inline static void DecodeSegment(StrBuf *Target, * 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) +{ + StrBuf *ConvertBuf; + StrBuf *ConvertBuf2; + ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe)); + ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMe)); + + StrBuf_RFC822_2_Utf8(Target, + DecodeMe, + DefaultCharset, + FoundCharset, + ConvertBuf, + ConvertBuf2); + FreeStrBuf(&ConvertBuf); + FreeStrBuf(&ConvertBuf2); +} + +/** + * @ingroup StrBuf_DeEnCoder + * @brief 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, + * 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. + */ +void StrBuf_RFC822_2_Utf8(StrBuf *Target, + const StrBuf *DecodeMe, + const StrBuf* DefaultCharset, + StrBuf *FoundCharset, + StrBuf *ConvertBuf, + StrBuf *ConvertBuf2) { StrBuf *DecodedInvalidBuf = NULL; - StrBuf *ConvertBuf, *ConvertBuf2; const StrBuf *DecodeMee = DecodeMe; - char *start, *end, *next, *nextend, *ptr = NULL; + const char *start, *end, *next, *nextend, *ptr = NULL; #ifdef HAVE_ICONV iconv_t ic = (iconv_t)(-1) ; #endif const char *eptr; int passes = 0; - int i, len, delta; + int i; int illegal_non_rfc2047_encoding = 0; /* Sometimes, badly formed messages contain strings which were simply @@ -2528,7 +3272,6 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* * charset to UTF-8 if we see any nonprintable characters. */ - len = StrLength(DecodeMe); for (i=0; iBufUsed; ++i) { if ((DecodeMe->buf[i] < 32) || (DecodeMe->buf[i] > 126)) { illegal_non_rfc2047_encoding = 1; @@ -2536,7 +3279,6 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* } } - ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe)); if ((illegal_non_rfc2047_encoding) && (strcasecmp(ChrPtr(DefaultCharset), "UTF-8")) && (strcasecmp(ChrPtr(DefaultCharset), "us-ascii")) ) @@ -2553,27 +3295,23 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* } /* 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) - end = FindNextEnd (DecodeMee, start); + end = FindNextEnd (DecodeMee, start + 2); else { StrBufAppendBuf(Target, DecodeMee, 0); - FreeStrBuf(&ConvertBuf); FreeStrBuf(&DecodedInvalidBuf); return; } - ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMee)); if (start != DecodeMee->buf) { long nFront; 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 @@ -2615,22 +3353,16 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* (*ptr == '\n') || (*ptr == '\t'))) ptr ++; - /* did we find a gab just filled with blanks? */ - if (ptr == next) + /* + * did we find a gab just filled with blanks? + * if not, copy its stuff over. + */ + if (ptr != next) { - long gap = next - start; - memmove (end + 2, - next, - len - (gap)); - len -= gap; - /* now terminate the gab at the end */ - delta = (next - end) - 2; ////TODO: const! - ((StrBuf*)DecodeMee)->BufUsed -= delta; - ((StrBuf*)DecodeMee)->buf[DecodeMee->BufUsed] = '\0'; - - /* move next to its new location. */ - next -= delta; - nextend -= delta; + StrBufAppendBufPlain(Target, + end + 2, + next - end - 2, + 0); } } /* our next-pair is our new first pair now. */ @@ -2651,8 +3383,6 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* if (ptr < nextend) StrBufAppendBufPlain(Target, end, nextend - end, 0); } - FreeStrBuf(&ConvertBuf); - FreeStrBuf(&ConvertBuf2); FreeStrBuf(&DecodedInvalidBuf); } @@ -2664,19 +3394,24 @@ void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* * @ingroup StrBuf * @brief evaluate the length of an utf8 special character sequence * @param Char the character to examine - * @returns width of utf8 chars in bytes + * @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) { - int n = 1; - char test = (1<<7); - - while ((n < 8) && ((test & *CharS) != 0)) { - test = test << 1; + int n = 0; + unsigned char test = (1<<7); + + if ((*CharS & 0xC0) != 0xC0) + return 1; + + while ((n < 8) && + ((test & ((unsigned char)*CharS)) != 0)) + { + test = test >> 1; n ++; } if ((n > 6) || ((CharE - CharS) < n)) - n = 1; + n = 0; return n; } @@ -2689,7 +3424,7 @@ static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *Char static inline int Ctdl_IsUtf8SequenceStart(const char Char) { /** 11??.???? indicates an UTF8 Sequence. */ - return ((Char & 0xC0) != 0); + return ((Char & 0xC0) == 0xC0); } /** @@ -2879,7 +3614,426 @@ int CompressBuffer(StrBuf *Buf) return 0; } +/******************************************************************************* + * File I/O; Callbacks to libevent * + *******************************************************************************/ + +long StrBuf_read_one_chunk_callback (int fd, short event, IOBuffer *FB) +{ + long bufremain = 0; + int n; + + if ((FB == NULL) || (FB->Buf == NULL)) + return -1; + + /* + * check whether the read pointer is somewhere in a range + * where a cut left is inexpensive + */ + + if (FB->ReadWritePointer != NULL) + { + long already_read; + + already_read = FB->ReadWritePointer - FB->Buf->buf; + bufremain = FB->Buf->BufSize - FB->Buf->BufUsed - 1; + + if (already_read != 0) { + long unread; + + unread = FB->Buf->BufUsed - already_read; + + /* else nothing to compact... */ + if (unread == 0) { + FB->ReadWritePointer = FB->Buf->buf; + bufremain = FB->Buf->BufSize; + } + else if ((unread < 64) || + (bufremain < already_read)) + { + /* + * if its just a tiny bit remaining, or we run out of space... + * lets tidy up. + */ + FB->Buf->BufUsed = unread; + if (unread < already_read) + memcpy(FB->Buf->buf, FB->ReadWritePointer, unread); + else + memmove(FB->Buf->buf, FB->ReadWritePointer, unread); + FB->ReadWritePointer = FB->Buf->buf; + bufremain = FB->Buf->BufSize - unread - 1; + } + else if (bufremain < (FB->Buf->BufSize / 10)) + { + /* get a bigger buffer */ + + IncreaseBuf(FB->Buf, 0, FB->Buf->BufUsed + 1); + + FB->ReadWritePointer = FB->Buf->buf + unread; + + bufremain = FB->Buf->BufSize - unread - 1; +/*TODO: special increase function that won't copy the already read! */ + } + } + else if (bufremain < 10) { + IncreaseBuf(FB->Buf, 1, FB->Buf->BufUsed + 10); + + FB->ReadWritePointer = FB->Buf->buf; + + bufremain = FB->Buf->BufSize - FB->Buf->BufUsed - 1; + } + + } + else { + FB->ReadWritePointer = FB->Buf->buf; + bufremain = FB->Buf->BufSize - 1; + } + + n = read(fd, FB->Buf->buf + FB->Buf->BufUsed, bufremain); + + if (n > 0) { + FB->Buf->BufUsed += n; + FB->Buf->buf[FB->Buf->BufUsed] = '\0'; + } + return n; +} + +int StrBuf_write_one_chunk_callback(int fd, short event, IOBuffer *FB) +{ + long WriteRemain; + int n; + + if ((FB == NULL) || (FB->Buf == NULL)) + return -1; + + if (FB->ReadWritePointer != NULL) + { + WriteRemain = FB->Buf->BufUsed - + (FB->ReadWritePointer - + FB->Buf->buf); + } + else { + FB->ReadWritePointer = FB->Buf->buf; + WriteRemain = FB->Buf->BufUsed; + } + + n = write(fd, FB->ReadWritePointer, WriteRemain); + if (n > 0) { + FB->ReadWritePointer += n; + + if (FB->ReadWritePointer == + FB->Buf->buf + FB->Buf->BufUsed) + { + FlushStrBuf(FB->Buf); + FB->ReadWritePointer = NULL; + return 0; + } + // check whether we've got something to write + // get the maximum chunk plus the pointer we can send + // write whats there + // if not all was sent, remember the send pointer for the next time + return FB->ReadWritePointer - FB->Buf->buf + FB->Buf->BufUsed; + } + 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) +{ + const char *aptr, *ptr, *eptr; + char *optr, *xptr; + + if ((FB->Buf == NULL) || (FB->ReadWritePointer == StrBufNOTNULL)) { + FB->ReadWritePointer = StrBufNOTNULL; + return eReadFail; + } + + FlushStrBuf(LineBuf); + if (FB->ReadWritePointer == NULL) + ptr = aptr = FB->Buf->buf; + else + ptr = aptr = FB->ReadWritePointer; + + optr = LineBuf->buf; + eptr = FB->Buf->buf + FB->Buf->BufUsed; + xptr = LineBuf->buf + LineBuf->BufSize - 1; + + while ((ptr <= eptr) && + (*ptr != '\n') && + (*ptr != '\r') ) + { + *optr = *ptr; + optr++; ptr++; + if (optr == xptr) { + LineBuf->BufUsed = optr - LineBuf->buf; + IncreaseBuf(LineBuf, 1, LineBuf->BufUsed + 1); + optr = LineBuf->buf + LineBuf->BufUsed; + xptr = LineBuf->buf + LineBuf->BufSize - 1; + } + } + + if (ptr >= eptr) { + if (optr > LineBuf->buf) + optr --; + 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); + FB->ReadWritePointer = FB->Buf->buf; + } + return eMustReadMore; + } + } + LineBuf->BufUsed = optr - LineBuf->buf; + *optr = '\0'; + if ((ptr <= eptr) && (*ptr == '\r')) + ptr ++; + if ((ptr <= eptr) && (*ptr == '\n')) + ptr ++; + + if (ptr < eptr) { + FB->ReadWritePointer = ptr; + } + else { + FlushStrBuf(FB->Buf); + FB->ReadWritePointer = NULL; + } + + return eReadSuccess; +} + +/** + * @ingroup StrBuf_CHUNKED_IO + * @brief check whether the chunk-buffer has more data waiting or not. + * @param FB Chunk-Buffer to inspect + */ +eReadState StrBufCheckBuffer(IOBuffer *FB) +{ + if (FB == NULL) + return eReadFail; + if (FB->Buf->BufUsed == 0) + return eReadSuccess; + if (FB->ReadWritePointer == NULL) + return eBufferNotEmpty; + if (FB->Buf->buf + FB->Buf->BufUsed > FB->ReadWritePointer) + return eBufferNotEmpty; + return eReadSuccess; +} + +long IOBufferStrLength(IOBuffer *FB) +{ + if (FB->ReadWritePointer == NULL) + return StrLength(FB->Buf); + + return StrLength(FB->Buf) - (FB->ReadWritePointer - FB->Buf->buf); +} + +void FDIOBufferInit(FDIOBuffer *FDB, IOBuffer *IO, int FD, long TotalSendSize) +{ + memset(FDB, 0, sizeof(FDIOBuffer)); + FDB->ChunkSize = + FDB->TotalSendSize = TotalSendSize; + FDB->IOB = IO; +#ifndef LINUX_SENDFILE + FDB->ChunkBuffer = NewStrBufPlain(NULL, TotalSendSize + 1); +#else + pipe(FDB->SplicePipe); +#endif + FDB->OtherFD = FD; +} + +void FDIOBufferDelete(FDIOBuffer *FDB) +{ +#ifndef LINUX_SENDFILE + FreeStrBuf(&FDB->ChunkBuffer); +#else + close(FDB->SplicePipe[0]); + close(FDB->SplicePipe[1]); + +#endif + close(FDB->OtherFD); + memset(FDB, 0, sizeof(FDIOBuffer)); +} + +int FileSendChunked(FDIOBuffer *FDB, const char **Err) +{ + +#ifdef LINUX_SENDFILE + ssize_t sent; + sent = sendfile(FDB->IOB->fd, FDB->OtherFD, &FDB->TotalSentAlready, FDB->ChunkSendRemain); + if (sent == -1) + { + *Err = strerror(errno); + return sent; + } + FDB->ChunkSendRemain -= sent; + FDB->TotalSentAlready += sent; + return FDB->ChunkSendRemain; +#else + + 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->ChunkSendRemain); + + if (nRead >= 0) { + FDB->TotalSentAlready += nRead; + FDB->ChunkSendRemain -= nRead; + return FDB->ChunkSendRemain; + } + else { + return nRead; + } +#endif +} + +int FileRecvChunked(FDIOBuffer *FDB, const char **Err) +{ + ssize_t sent, pipesize; + +#ifdef LINUX_SENDFILE + + pipesize = splice(FDB->IOB->fd, NULL, + FDB->SplicePipe[1], NULL, + FDB->ChunkSendRemain, + SPLICE_F_MORE | SPLICE_F_MOVE|SPLICE_F_NONBLOCK); + if (pipesize == -1) + { + *Err = strerror(errno); + return pipesize; + } + + sent = splice(FDB->SplicePipe[0], NULL, + FDB->OtherFD, &FDB->TotalSentAlready, + pipesize, SPLICE_F_MORE | SPLICE_F_MOVE); + if (sent == -1) + { + *Err = strerror(errno); + return sent; + } + FDB->ChunkSendRemain -= sent; + return sent; +#else + + sent = read(FDB->IOB->fd, FDB->ChunkBuffer->buf, FDB->ChunkSendRemain); + if (sent > 0) { + int nWritten = 0; + int rc; + + FDB->ChunkBuffer->BufUsed = sent; + + while (nWritten < FDB->ChunkBuffer->BufUsed) { + rc = write(FDB->OtherFD, FDB->ChunkBuffer->buf + nWritten, FDB->ChunkBuffer->BufUsed - nWritten); + if (rc < 0) { + *Err = strerror(errno); + return rc; + } + nWritten += rc; + + } + FDB->ChunkBuffer->BufUsed = 0; + FDB->TotalSentAlready += sent; + FDB->ChunkSendRemain -= sent; + return FDB->ChunkSendRemain; + } + else if (sent < 0) { + *Err = strerror(errno); + return sent; + } + +#endif + return 0; +} + +eReadState WriteIOBAlreadyRead(FDIOBuffer *FDB, const char **Error) +{ + int IsNonBlock; + int fdflags; + long rlen; + long should_write; + int nSuccessLess = 0; + struct timeval tv; + fd_set rfds; + fdflags = fcntl(FDB->OtherFD, F_GETFL); + IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK; + + while ((FDB->IOB->ReadWritePointer - FDB->IOB->Buf->buf < FDB->IOB->Buf->BufUsed) && + (FDB->ChunkSendRemain > 0)) + { + if (IsNonBlock){ + tv.tv_sec = 1; /* selectresolution; */ + tv.tv_usec = 0; + + FD_ZERO(&rfds); + FD_SET(FDB->OtherFD, &rfds); + if (select(FDB->OtherFD + 1, NULL, &rfds, NULL, &tv) == -1) { + *Error = strerror(errno); + return eReadFail; + } + } + if (IsNonBlock && ! FD_ISSET(FDB->OtherFD, &rfds)) { + nSuccessLess ++; + continue; + } + + should_write = FDB->IOB->Buf->BufUsed - + (FDB->IOB->ReadWritePointer - FDB->IOB->Buf->buf); + if (should_write > FDB->ChunkSendRemain) + should_write = FDB->ChunkSendRemain; + + rlen = write(FDB->OtherFD, + FDB->IOB->ReadWritePointer, + should_write); + if (rlen < 1) { + *Error = strerror(errno); + + return eReadFail; + } + FDB->TotalSentAlready += rlen; + FDB->IOB->ReadWritePointer += rlen; + FDB->ChunkSendRemain -= rlen; + } + if (FDB->IOB->ReadWritePointer >= FDB->IOB->Buf->buf + FDB->IOB->Buf->BufUsed) + { + FlushStrBuf(FDB->IOB->Buf); + FDB->IOB->ReadWritePointer = NULL; + } + + if (FDB->ChunkSendRemain == 0) + return eReadSuccess; + else + return eMustReadMore; +} /******************************************************************************* * File I/O; Prefer buffered read since its faster! * @@ -3033,14 +4187,14 @@ static const char *ErrRBLF_NotEnoughSentFromServer="StrBufTCP_read_buffered_line * @ingroup StrBuf_BufferedIO * @brief Read a line from socket * flushes and closes the FD on error - * @param Line Line to read from the fd / I/O Buffer - * @param IOBuf the buffer to get the input to - * @param Pos pointer to the current read position, should be NULL initialized! + * @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 + * @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, @@ -3052,7 +4206,8 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line, { const char *pche = NULL; const char *pos = NULL; - int len, rlen; + const char *pLF; + int len, rlen, retlen; int nSuccessLess = 0; fd_set rfds; const char *pch = NULL; @@ -3060,6 +4215,7 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line, int IsNonBlock; struct timeval tv; + retlen = 0; if ((Line == NULL) || (Pos == NULL) || (IOBuf == NULL) || @@ -3076,44 +4232,72 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line, (pos != NULL) && (pos < IOBuf->buf + IOBuf->BufUsed)) { + char *pcht; + pche = IOBuf->buf + IOBuf->BufUsed; pch = pos; + pcht = Line->buf; + while ((pch < pche) && (*pch != '\n')) - pch ++; + { + if (Line->BufUsed + 10 > Line->BufSize) + { + long apos; + apos = pcht - Line->buf; + *pcht = '\0'; + IncreaseBuf(Line, 1, -1); + pcht = Line->buf + apos; + } + *pcht++ = *pch++; + Line->BufUsed++; + retlen++; + } + + len = pch - pos; + if (len > 0 && (*(pch - 1) == '\r') ) + { + retlen--; + len --; + pcht --; + Line->BufUsed --; + } + *pcht = '\0'; + if ((pch >= pche) || (*pch == '\0')) + { + FlushStrBuf(IOBuf); + *Pos = NULL; pch = NULL; + pos = 0; + } + if ((pch != NULL) && (pch <= pche)) { - rlen = 0; - len = pch - pos; - if (len > 0 && (*(pch - 1) == '\r') ) - rlen ++; - StrBufSub(Line, IOBuf, (pos - IOBuf->buf), len - rlen); - *Pos = pch + 1; - return len - rlen; + if (pch + 1 >= pche) { + *Pos = NULL; + FlushStrBuf(IOBuf); + } + else + *Pos = pch + 1; + + return retlen; } - } - - if (pos != NULL) { - if (pos > pche) - FlushStrBuf(IOBuf); else - StrBufCutLeft(IOBuf, (pos - IOBuf->buf)); - *Pos = NULL; + FlushStrBuf(IOBuf); } + + /* 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); - *Pos = NULL; - } fdflags = fcntl(*fd, F_GETFL); IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK; - pch = NULL; + pLF = NULL; while ((nSuccessLess < timeout) && - (pch == NULL) && + (pLF == NULL) && (*fd != -1)) { if (IsNonBlock) { @@ -3146,31 +4330,43 @@ int StrBufTCP_read_buffered_line_fast(StrBuf *Line, } else if (rlen > 0) { nSuccessLess = 0; + pLF = IOBuf->buf + IOBuf->BufUsed; IOBuf->BufUsed += rlen; IOBuf->buf[IOBuf->BufUsed] = '\0'; - if (IOBuf->BufUsed + 10 > IOBuf->BufSize) { - IncreaseBuf(IOBuf, 1, -1); - *Pos = NULL; - } pche = IOBuf->buf + IOBuf->BufUsed; - pch = IOBuf->buf; - while ((pch < pche) && (*pch != '\n')) - pch ++; - if ((pch >= pche) || (*pch == '\0')) - pch = NULL; + + while ((pLF < pche) && (*pLF != '\n')) + pLF ++; + if ((pLF >= pche) || (*pLF == '\0')) + pLF = NULL; + + if (IOBuf->BufUsed + 10 > IOBuf->BufSize) + { + long apos = 0; + + if (pLF != NULL) apos = pLF - IOBuf->buf; + IncreaseBuf(IOBuf, 1, -1); + if (pLF != NULL) pLF = IOBuf->buf + apos; + } + continue; } } - if (pch != NULL) { + *Pos = NULL; + if (pLF != NULL) { pos = IOBuf->buf; - rlen = 0; - len = pch - pos; - if (len > 0 && (*(pch - 1) == '\r') ) - rlen ++; - StrBufSub(Line, IOBuf, 0, len - rlen); - *Pos = pos + len + 1; - return len - rlen; + len = pLF - pos; + if (len > 0 && (*(pLF - 1) == '\r') ) + len --; + StrBufAppendBufPlain(Line, ChrPtr(IOBuf), len, 0); + if (pLF + 1 >= IOBuf->buf + IOBuf->BufUsed) + { + FlushStrBuf(IOBuf); + } + else + *Pos = pLF + 1; + return retlen + len; } *Error = ErrRBLF_NotEnoughSentFromServer; return -1; @@ -3192,7 +4388,7 @@ static const char *ErrRBLF_BLOBPreConditionFailed="StrBufReadBLOB: Wrong argumen int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **Error) { int fdflags; - int len, rlen, slen; + int rlen; int nSuccessLess; int nRead = 0; char *ptr; @@ -3212,8 +4408,6 @@ int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **E ptr = Buf->buf + Buf->BufUsed; - slen = len = Buf->BufUsed; - fdflags = fcntl(*fd, F_GETFL); IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK; nSuccessLess = 0; @@ -3258,7 +4452,7 @@ int StrBufReadBLOB(StrBuf *Buf, int *fd, int append, long nBytes, const char **E } const char *ErrRBB_BLOBFPreConditionFailed = "StrBufReadBLOBBuffered: to many selects; aborting."; -const char *ErrRBB_too_many_selects = "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 @@ -3282,21 +4476,17 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, int check, const char **Error) { - const char *pche; const char *pos; - int nSelects = 0; - int SelRes; int fdflags; - int len = 0; - int rlen, slen; + int rlen = 0; int nRead = 0; int nAlreadyRead = 0; int IsNonBlock; char *ptr; fd_set rfds; - const char *pch; struct timeval tv; - int nSuccessLess; + int nSuccessLess = 0; + int MaxTries; if ((Blob == NULL) || (*fd == -1) || (IOBuf == NULL) || (Pos == NULL)) { @@ -3313,18 +4503,15 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, pos = *Pos; - if (pos > 0) - 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)) { - pche = IOBuf->buf + IOBuf->BufUsed; - pch = pos; - if (rlen < nBytes) { memcpy(Blob->buf + Blob->BufUsed, pos, rlen); Blob->BufUsed += rlen; @@ -3352,15 +4539,17 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, IncreaseBuf(IOBuf, 0, nBytes - nRead); ptr = IOBuf->buf; - slen = len = Blob->BufUsed; - fdflags = fcntl(*fd, F_GETFL); IsNonBlock = (fdflags & O_NONBLOCK) == O_NONBLOCK; + if (IsNonBlock) + MaxTries = 1000; + else + MaxTries = 100000; - SelRes = 1; nBytes -= nRead; nRead = 0; - while ((nRead < nBytes) && + while ((nSuccessLess < MaxTries) && + (nRead < nBytes) && (*fd != -1)) { if (IsNonBlock) { @@ -3382,10 +4571,9 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, continue; } } - nSuccessLess = 0; rlen = read(*fd, ptr, - nBytes - nRead); + IOBuf->BufSize - (ptr - IOBuf->buf)); if (rlen == -1) { close(*fd); *fd = -1; @@ -3393,7 +4581,6 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, return rlen; } else if (rlen == 0){ - nSuccessLess ++; if ((check == NNN_TERM) && (nRead > 5) && (strncmp(IOBuf->buf + IOBuf->BufUsed - 5, "\n000\n", 5) == 0)) @@ -3402,18 +4589,27 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, StrBufCutRight(Blob, 5); return Blob->BufUsed; } - if (nSelects > 10) { + else if (!IsNonBlock) + nSuccessLess ++; + else if (nSuccessLess > MaxTries) { FlushStrBuf(IOBuf); *Error = ErrRBB_too_many_selects; return -1; } } else if (rlen > 0) { + nSuccessLess = 0; nRead += rlen; ptr += rlen; IOBuf->BufUsed += rlen; } } + if (nSuccessLess >= MaxTries) { + FlushStrBuf(IOBuf); + *Error = ErrRBB_too_many_selects; + return -1; + } + if (nRead > nBytes) { *Pos = IOBuf->buf + nBytes; } @@ -3432,9 +4628,9 @@ int StrBufReadBLOBBuffered(StrBuf *Blob, * @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 copied buffer + * @returns size of remaining buffer */ -int StrBufSipLine(StrBuf *LineBuf, StrBuf *Buf, const char **Ptr) +int StrBufSipLine(StrBuf *LineBuf, const StrBuf *Buf, const char **Ptr) { const char *aptr, *ptr, *eptr; char *optr, *xptr; @@ -3512,9 +4708,10 @@ void StrBufStripSlashes(StrBuf *Dir, int RemoveTrailingSlash) b++; a++; } } - if ((RemoveTrailingSlash) && (*(b - 1) != '/')){ - *b = '/'; - b++; + if ((RemoveTrailingSlash) && + (b > Dir->buf) && + (*(b - 1) == '/')){ + b--; } *b = '\0'; Dir->BufUsed = b - Dir->buf;