struct StrBuf {
char *buf; /**< the pointer to the dynamic buffer */
long BufSize; /**< how many spcae do we optain */
- long BufUsed; /**< Number of Chars used excluding the trailing \0 */
+ long BufUsed; /**< StNumber of Chars used excluding the trailing \0 */
int ConstBuf; /**< are we just a wrapper arround a static buffer and musn't we be changed? */
};
return -1;
if (DestSize > 0)
- while (NewSize < DestSize)
+ while (NewSize <= DestSize)
NewSize *= 2;
NewBuf= (char*) malloc(NewSize);
*/
int FlushStrBuf(StrBuf *buf)
{
+ if (buf == NULL)
+ return -1;
if (buf->ConstBuf)
return -1;
buf->buf[0] ='\0';
*/
long StrTol(const StrBuf *Buf)
{
+ if (Buf == NULL)
+ return 0;
if(Buf->BufUsed > 0)
return atol(Buf->buf);
else
*/
int StrToi(const StrBuf *Buf)
{
- if(Buf->BufUsed > 0)
+ if (Buf == NULL)
+ return 0;
+ if (Buf->BufUsed > 0)
return atoi(Buf->buf);
else
return 0;
}
-
+/**
+ * \brief Checks to see if the string is a pure number
+ */
+int StrBufIsNumber(const StrBuf *Buf) {
+ if (Buf == NULL) {
+ return 0;
+ }
+ char * pEnd;
+ strtoll(Buf->buf, &pEnd, 10);
+ if (pEnd == NULL && ((Buf->buf)-pEnd) != 0) {
+ return 1;
+ }
+ return 0;
+}
/**
* \brief modifies a Single char of the Buf
* You can point to it via char* or a zero-based integer
* \param AppendBuf Buffer to copy at the end of our buffer
* \param Offset Should we start copying from an offset?
*/
-void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, size_t Offset)
+void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset)
{
- if ((AppendBuf == NULL) || (Buf == NULL))
+ if ((AppendBuf == NULL) || (Buf == NULL) || (AppendBuf->buf == NULL))
return;
- if (Buf->BufSize - Offset < AppendBuf->BufUsed + Buf->BufUsed)
+ if (Buf->BufSize - Offset < AppendBuf->BufUsed + Buf->BufUsed + 1)
IncreaseBuf(Buf,
(Buf->BufUsed > 0),
AppendBuf->BufUsed + Buf->BufUsed);
* \param AppendSize number of bytes to copy; set to -1 if we should count it in advance
* \param Offset Should we start copying from an offset?
*/
-void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, size_t Offset)
+void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, unsigned long Offset)
{
long aps;
+ long BufSizeRequired;
if ((AppendBuf == NULL) || (Buf == NULL))
return;
else
aps = AppendSize - Offset;
- if (Buf->BufSize < Buf->BufUsed + aps)
- IncreaseBuf(Buf, (Buf->BufUsed > 0), Buf->BufUsed + aps);
+ BufSizeRequired = Buf->BufUsed + aps + 1;
+ if (Buf->BufSize <= BufSizeRequired)
+ IncreaseBuf(Buf, (Buf->BufUsed > 0), BufSizeRequired);
memcpy(Buf->buf + Buf->BufUsed,
AppendBuf + Offset,
* \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, linebreaks are removed from the string.
+ * \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)
{
return -1;
bptr = Target->buf + Target->BufUsed;
- eptr = Target->buf + Target->BufSize - 6; /* our biggest unit to put in... */
+ 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 - 6;
+ eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in... */
bptr = Target->buf + Target->BufUsed;
}
if (*aptr == '<') {
bptr += 5;
Target->BufUsed += 5;
}
- else if (*aptr == '\"') {
+ else if (*aptr == '"') {
memcpy(bptr, """, 6);
bptr += 6;
Target->BufUsed += 6;
bptr += 6;
Target->BufUsed += 6;
}
- else if ((*aptr == '\n') && (nolinebreaks)) {
+ else if ((*aptr == '\n') && (nolinebreaks == 1)) {
*bptr='\0'; /* nothing */
}
- else if ((*aptr == '\r') && (nolinebreaks)) {
+ 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 (len == 0)
return;
- eptr = Target->buf + Target->BufSize - 6;
+ eptr = Target->buf + Target->BufSize - 8;
tptr = Target->buf + Target->BufUsed;
while (aptr < eiptr){
if(tptr >= eptr) {
IncreaseBuf(Target, 1, -1);
- eptr = Target->buf + Target->BufSize - 6;
+ eptr = Target->buf + Target->BufSize - 8;
tptr = Target->buf + Target->BufUsed;
}
*tptr = '\0';
}
+/*
+ * \brief Append a string, escaping characters which have meaning in JavaScript strings .
+ *
+ * \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
+ */
+long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
+{
+ 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 - 3; /* our biggest unit to put in... */
+
+ while (aptr < eiptr){
+ if(bptr >= eptr) {
+ IncreaseBuf(Target, 1, -1);
+ eptr = Target->buf + Target->BufSize - 3;
+ bptr = Target->buf + Target->BufUsed;
+ }
+ else if (*aptr == '"') {
+ memcpy(bptr, "\\\"", 2);
+ bptr += 2;
+ Target->BufUsed += 2;
+ } else if (*aptr == '\\') {
+ memcpy(bptr, "\\\\", 2);
+ bptr += 2;
+ Target->BufUsed += 2;
+ }
+ else{
+ *bptr = *aptr;
+ bptr++;
+ Target->BufUsed ++;
+ }
+ aptr ++;
+ }
+ *bptr = '\0';
+ if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
+ return -1;
+ return Target->BufUsed;
+}
/**
* \brief extracts a substring from Source into dest
* \param nChars number of chars to copy
* \returns the number of chars copied; may be different from nChars due to the size of Source
*/
-int StrBufSub(StrBuf *dest, const StrBuf *Source, size_t Offset, size_t nChars)
+int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t nChars)
{
size_t NCharsRemain;
if (Offset > Source->BufUsed)
}
if (Offset + nChars < Source->BufUsed)
{
- if (nChars > dest->BufSize)
+ if (nChars >= dest->BufSize)
IncreaseBuf(dest, 0, nChars + 1);
memcpy(dest->buf, Source->buf + Offset, nChars);
dest->BufUsed = nChars;
return nChars;
}
NCharsRemain = Source->BufUsed - Offset;
- if (NCharsRemain > dest->BufSize)
+ if (NCharsRemain >= dest->BufSize)
IncreaseBuf(dest, 0, NCharsRemain + 1);
memcpy(dest->buf, Source->buf + Offset, NCharsRemain);
dest->BufUsed = NCharsRemain;
while (*s && *s != separator) {
s++;
}
-
+ if (*s == separator)
+ s++;
ReducedBy = d - s;
/* Hack and slash */
if (*s) {
- memmove(d, s, Source->BufUsed - (s - Source->buf));
+ memmove(d, s, Source->BufUsed - (s - Source->buf) + 1);
Source->BufUsed -= (ReducedBy + 1);
}
else if (d == Source->buf) {
const char *s, *e; //* source * /
int len = 0; //* running total length of extracted string * /
int current_token = 0; //* token currently being processed * /
+
+ if (dest != NULL) {
+ dest->buf[0] = '\0';
+ dest->BufUsed = 0;
+ }
+ else
+ return(-1);
if ((Source == NULL) || (Source->BufUsed ==0)) {
return(-1);
}
s = Source->buf;
e = s + Source->BufUsed;
- if (dest == NULL) {
- return(-1);
- }
//cit_backtrace();
//lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
- dest->buf[0] = '\0';
- dest->BufUsed = 0;
while ((s<e) && !IsEmptyStr(s)) {
if (*s == separator) {
}
+
+
+
/**
* \brief a string tokenizer to fetch an integer
* \param dest Destination StringBuffer
buf[0] = '\0';
tmp.BufSize = 64;
tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0)
return(atoi(buf));
else
buf[0] = '\0';
tmp.BufSize = 64;
tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0)
return(atoi(buf));
else
buf[0] = '\0';
tmp.BufSize = 64;
tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0) {
pnum = &buf[0];
if (*pnum == '-')
+/**
+ * \brief a string tokenizer
+ * \param dest Destination StringBuffer
+ * \param Source StringBuffer to read into
+ * \param pStart pointer to the end of the last token. Feed with NULL.
+ * \param separator tokenizer param
+ * \returns -1 if not found, else length of token.
+ */
+int StrBufExtract_NextToken(StrBuf *dest, const StrBuf *Source, const char **pStart, char separator)
+{
+ const char *s, *EndBuffer; //* source * /
+ int len = 0; //* running total length of extracted string * /
+ int current_token = 0; //* token currently being processed * /
+
+ if (dest != NULL) {
+ dest->buf[0] = '\0';
+ dest->BufUsed = 0;
+ }
+ else
+ return(-1);
+
+ if ((Source == NULL) ||
+ (Source->BufUsed ==0)) {
+ return(-1);
+ }
+ if (*pStart == NULL)
+ *pStart = Source->buf;
+
+ EndBuffer = Source->buf + Source->BufUsed;
+
+ if ((*pStart < Source->buf) ||
+ (*pStart > EndBuffer)) {
+ return (-1);
+ }
+
+
+ s = *pStart;
+
+ //cit_backtrace();
+ //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
+
+ while ((s<EndBuffer) && !IsEmptyStr(s)) {
+ if (*s == separator) {
+ ++current_token;
+ }
+ if (len >= dest->BufSize)
+ if (!IncreaseBuf(dest, 1, -1)) {
+ *pStart = EndBuffer + 1;
+ break;
+ }
+ if ( (current_token == 0) &&
+ (*s != separator)) {
+ dest->buf[len] = *s;
+ ++len;
+ }
+ else if (current_token > 0) {
+ *pStart = s;
+ break;
+ }
+ ++s;
+ }
+ *pStart = s;
+ (*pStart) ++;
+
+ dest->buf[len] = '\0';
+ dest->BufUsed = len;
+ //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
+ //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
+ return(len);
+}
+
+
+/**
+ * \brief a string tokenizer
+ * \param dest Destination StringBuffer
+ * \param Source StringBuffer to read into
+ * \param pStart pointer to the end of the last token. Feed with NULL.
+ * \param separator tokenizer param
+ * \returns -1 if not found, else length of token.
+ */
+int StrBufSkip_NTokenS(const StrBuf *Source, const char **pStart, char separator, int nTokens)
+{
+ const char *s, *EndBuffer; //* source * /
+ int len = 0; //* running total length of extracted string * /
+ int current_token = 0; //* token currently being processed * /
+
+ if ((Source == NULL) ||
+ (Source->BufUsed ==0)) {
+ return(-1);
+ }
+ if (nTokens == 0)
+ return Source->BufUsed;
+
+ if (*pStart == NULL)
+ *pStart = Source->buf;
+
+ EndBuffer = Source->buf + Source->BufUsed;
+
+ if ((*pStart < Source->buf) ||
+ (*pStart > EndBuffer)) {
+ return (-1);
+ }
+
+
+ s = *pStart;
+
+ //cit_backtrace();
+ //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
+
+ while ((s<EndBuffer) && !IsEmptyStr(s)) {
+ if (*s == separator) {
+ ++current_token;
+ }
+ if (current_token >= nTokens) {
+ break;
+ }
+ ++s;
+ }
+ *pStart = s;
+ (*pStart) ++;
+
+ return(len);
+}
+
+/**
+ * \brief a string tokenizer to fetch an integer
+ * \param dest Destination StringBuffer
+ * \param parmnum n'th parameter to extract
+ * \param separator tokenizer param
+ * \returns 0 if not found, else integer representation of the token
+ */
+int StrBufExtractNext_int(const StrBuf* Source, const char **pStart, char separator)
+{
+ StrBuf tmp;
+ char buf[64];
+
+ tmp.buf = buf;
+ buf[0] = '\0';
+ tmp.BufSize = 64;
+ tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
+ if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0)
+ return(atoi(buf));
+ else
+ return 0;
+}
+
+/**
+ * \brief a string tokenizer to fetch a long integer
+ * \param dest Destination StringBuffer
+ * \param parmnum n'th parameter to extract
+ * \param separator tokenizer param
+ * \returns 0 if not found, else long integer representation of the token
+ */
+long StrBufExtractNext_long(const StrBuf* Source, const char **pStart, char separator)
+{
+ StrBuf tmp;
+ char buf[64];
+
+ tmp.buf = buf;
+ buf[0] = '\0';
+ tmp.BufSize = 64;
+ tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
+ if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0)
+ return(atoi(buf));
+ else
+ return 0;
+}
+
+
+/**
+ * \brief a string tokenizer to fetch an unsigned long
+ * \param dest Destination StringBuffer
+ * \param parmnum n'th parameter to extract
+ * \param separator tokenizer param
+ * \returns 0 if not found, else unsigned long representation of the token
+ */
+unsigned long StrBufExtractNext_unsigned_long(const StrBuf* Source, const char **pStart, char separator)
+{
+ StrBuf tmp;
+ char buf[64];
+ char *pnum;
+
+ tmp.buf = buf;
+ buf[0] = '\0';
+ tmp.BufSize = 64;
+ tmp.BufUsed = 0;
+ tmp.ConstBuf = 1;
+ if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0) {
+ pnum = &buf[0];
+ if (*pnum == '-')
+ pnum ++;
+ return (unsigned long) atol(pnum);
+ }
+ else
+ return 0;
+}
+
+
+
/**
* \brief Read a line from socket
* flushes and closes the FD on error
break;
if (buf->buf[len] != '\r')
len ++;
- if (!(len < buf->BufSize)) {
+ if (len >= buf->BufSize) {
buf->BufUsed = len;
buf->buf[len+1] = '\0';
IncreaseBuf(buf, 1, -1);
return -1;
if (!append)
FlushStrBuf(Buf);
- if (Buf->BufUsed + nBytes > Buf->BufSize)
+ if (Buf->BufUsed + nBytes >= Buf->BufSize)
IncreaseBuf(Buf, 1, Buf->BufUsed + nBytes);
ptr = Buf->buf + Buf->BufUsed;
Buf->buf[Buf->BufUsed] = '\0';
}
+/**
+ * \brief Cut the string after n Chars
+ * \param Buf Buffer to modify
+ * \param AfternChars after how many chars should we trunkate the string?
+ * \param At if non-null and points inside of our string, cut it there.
+ */
+void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At)
+{
+ if (At != NULL){
+ AfternChars = At - Buf->buf;
+ }
+
+ if ((AfternChars < 0) || (AfternChars >= Buf->BufUsed))
+ return;
+ Buf->BufUsed = AfternChars;
+ Buf->buf[Buf->BufUsed] = '\0';
+}
+
/*
* Strip leading and trailing spaces from a string; with premeasured and adjusted length.
}
+void StrBufLowerCase(StrBuf *Buf)
+{
+ char *pch, *pche;
+
+ pch = Buf->buf;
+ pche = pch + Buf->BufUsed;
+ while (pch < pche) {
+ *pch = tolower(*pch);
+ pch ++;
+ }
+}
+
+
/**
* \brief unhide special chars hidden to the HTML escaper
* \param target buffer to put the unescaped string in
#ifdef HAVE_ZLIB
char *compressed_data = NULL;
size_t compressed_len, bufsize;
+ int i = 0;
bufsize = compressed_len = ((Buf->BufUsed * 101) / 100) + 100;
compressed_data = malloc(compressed_len);
+ /* Flush some space after the used payload so valgrind shuts up... */
+ while ((i < 10) && (Buf->BufUsed + i < Buf->BufSize))
+ Buf->buf[Buf->BufUsed + i++] = '\0';
if (compress_gzip((Bytef *) compressed_data,
&compressed_len,
(Bytef *) Buf->buf,
Buf->buf = compressed_data;
Buf->BufUsed = compressed_len;
Buf->BufSize = bufsize;
+ /* Flush some space after the used payload so valgrind shuts up... */
+ i = 0;
+ while ((i < 10) && (Buf->BufUsed + i < Buf->BufSize))
+ Buf->buf[Buf->BufUsed + i++] = '\0';
return 1;
} else {
free(compressed_data);
return siz;
}
+/**
+ * \brief replace all chars >0x20 && < 0x7F with Mute
+ * \param Mute char to put over invalid chars
+ * \param Buf Buffor to transform
+ */
+int StrBufSanitizeAscii(StrBuf *Buf, const char Mute)
+{
+ unsigned char *pch;
+
+ if (Buf == NULL) return -1;
+ pch = (unsigned char *)Buf->buf;
+ while (pch < (unsigned char *)Buf->buf + Buf->BufUsed) {
+ if ((*pch < 0x20) || (*pch > 0x7F))
+ *pch = Mute;
+ pch ++;
+ }
+ return Buf->BufUsed;
+}
+
/**
* \brief remove escaped strings from i.e. the url string (like %20 for blanks)
}
if (*target == NULL)
*target = NewStrBufPlain(NULL, sizeof(headerStr) + source->BufUsed * 2);
- else if (sizeof(headerStr) + source->BufUsed > (*target)->BufSize)
+ else if (sizeof(headerStr) + source->BufUsed >= (*target)->BufSize)
IncreaseBuf(*target, sizeof(headerStr) + source->BufUsed, 0);
memcpy ((*target)->buf, headerStr, sizeof(headerStr) - 1);
(*target)->BufUsed = sizeof(headerStr) - 1;
for (i=0; (i < source->BufUsed); ++i) {
- if ((*target)->BufUsed + 4 > (*target)->BufSize)
+ if ((*target)->BufUsed + 4 >= (*target)->BufSize)
IncreaseBuf(*target, 1, 0);
ch = (unsigned char) source->buf[i];
if ((ch < 32) || (ch > 126) || (ch == 61)) {
}
}
- if ((*target)->BufUsed + 4 > (*target)->BufSize)
+ if ((*target)->BufUsed + 4 >= (*target)->BufSize)
IncreaseBuf(*target, 1, 0);
(*target)->buf[(*target)->BufUsed++] = '?';
-static inline char *FindNextEnd (StrBuf *Buf, char *bptr)
+static inline char *FindNextEnd (const StrBuf *Buf, char *bptr)
{
char * end;
/* Find the next ?Q? */
size_t obuflen; /**< Length of output buffer */
- if (ConvertBuf->BufUsed > TmpBuf->BufSize)
+ if (ConvertBuf->BufUsed >= TmpBuf->BufSize)
IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed);
ic = *(iconv_t*)pic;
inline static void DecodeSegment(StrBuf *Target,
- StrBuf *DecodeMe,
+ const StrBuf *DecodeMe,
char *SegmentStart,
char *SegmentEnd,
StrBuf *ConvertBuf,
- StrBuf *ConvertBuf2)
+ StrBuf *ConvertBuf2,
+ StrBuf *FoundCharset)
{
StrBuf StaticBuf;
char charset[128];
StaticBuf.BufUsed = SegmentEnd - SegmentStart;
StaticBuf.BufSize = DecodeMe->BufSize - (SegmentStart - DecodeMe->buf);
extract_token(charset, SegmentStart, 1, '?', sizeof charset);
+ if (FoundCharset != NULL) {
+ FlushStrBuf(FoundCharset);
+ StrBufAppendBufPlain(FoundCharset, charset, -1, 0);
+ }
extract_token(encoding, SegmentStart, 2, '?', sizeof encoding);
StrBufExtract_token(ConvertBuf, &StaticBuf, 3, '?');
+ *encoding = toupper(*encoding);
if (*encoding == 'B') { /**< base64 */
ConvertBuf2->BufUsed = CtdlDecodeBase64(ConvertBuf2->buf,
ConvertBuf->buf,
* Handle subjects with RFC2047 encoding such as:
* =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
*/
-void StrBuf_RFC822_to_Utf8(StrBuf *Target, StrBuf *DecodeMe, const StrBuf* DefaultCharset)
+void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset)
{
StrBuf *ConvertBuf, *ConvertBuf2;
- char *start, *end, *next, *nextend, *ptr;
+ char *start, *end, *next, *nextend, *ptr = NULL;
iconv_t ic = (iconv_t)(-1) ;
- char *ibuf; /**< Buffer of characters to be converted */
- char *obuf; /**< Buffer for converted characters */
- size_t ibuflen; /**< Length of input buffer */
- size_t obuflen; /**< Length of output buffer */
-
const char *eptr;
int passes = 0;
int i, len, delta;
}
ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe));
- if (illegal_non_rfc2047_encoding) {
- if ( (strcasecmp(ChrPtr(DefaultCharset), "UTF-8")) &&
- (strcasecmp(ChrPtr(DefaultCharset), "us-ascii")) ) {
- ctdl_iconv_open("UTF-8", ChrPtr(DefaultCharset), &ic);
- if (ic != (iconv_t)(-1) ) {
- long BufSize;
- ibuf = DecodeMe->buf;
- obuf = ConvertBuf->buf;
- ibuflen = DecodeMe->BufUsed;
- obuflen = ConvertBuf->BufSize;
-
- iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
- /* little card game: wheres the red lady? */
- ibuf = DecodeMe->buf;
- BufSize = DecodeMe->BufSize;
- DecodeMe->buf = ConvertBuf->buf;
- DecodeMe->BufSize = ConvertBuf->BufSize;
- DecodeMe->BufUsed = ConvertBuf->BufSize - obuflen;
- DecodeMe->buf[DecodeMe->BufUsed] = '\0';
-
- ConvertBuf->buf = ibuf;
- ConvertBuf->BufSize = BufSize;
- ConvertBuf->BufUsed = 0;
- ConvertBuf->buf[0] = '\0';
-
- iconv_close(ic);
- }
+ if ((illegal_non_rfc2047_encoding) &&
+ (strcasecmp(ChrPtr(DefaultCharset), "UTF-8")) &&
+ (strcasecmp(ChrPtr(DefaultCharset), "us-ascii")) )
+ {
+ ctdl_iconv_open("UTF-8", ChrPtr(DefaultCharset), &ic);
+ if (ic != (iconv_t)(-1) ) {
+ StrBufConvert((StrBuf*)DecodeMe, ConvertBuf, &ic);///TODO: don't void const?
+ iconv_close(ic);
}
}
ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMe));
+ if (start != DecodeMe->buf)
+ StrBufAppendBufPlain(Target, DecodeMe->buf, start - DecodeMe->buf, 0);
/*
* Since spammers will go to all sorts of absurd lengths to get their
* messages through, there are LOTS of corrupt headers out there.
start,
end,
ConvertBuf,
- ConvertBuf2);
+ ConvertBuf2,
+ FoundCharset);
next = strstr(end, "=?");
nextend = NULL;
len - (next - start));
/* now terminate the gab at the end */
- delta = (next - end) - 2;
- DecodeMe->BufUsed -= delta;
- DecodeMe->buf[DecodeMe->BufUsed] = '\0';
+ delta = (next - end) - 2; ////TODO: const!
+ ((StrBuf*)DecodeMe)->BufUsed -= delta;
+ ((StrBuf*)DecodeMe)->buf[DecodeMe->BufUsed] = '\0';
/* move next to its new location. */
next -= delta;
}
}
/* our next-pair is our new first pair now. */
+ ptr = end + 2;
start = next;
end = nextend;
}
+ end = ptr;
+ nextend = DecodeMe->buf + DecodeMe->BufUsed;
+ if ((end != NULL) && (end < nextend)) {
+ ptr = end;
+ while ( (ptr < nextend) &&
+ (isspace(*ptr) ||
+ (*ptr == '\r') ||
+ (*ptr == '\n') ||
+ (*ptr == '\t')))
+ ptr ++;
+ if (ptr < nextend)
+ StrBufAppendBufPlain(Target, end, nextend - end, 0);
+ }
FreeStrBuf(&ConvertBuf);
FreeStrBuf(&ConvertBuf2);
}
optr = LineBuf->buf;
eptr = Buf->buf + Buf->BufUsed;
- xptr = LineBuf->buf + LineBuf->BufSize;
+ xptr = LineBuf->buf + LineBuf->BufSize - 1;
while ((*ptr != '\n') &&
(*ptr != '\r') &&
LineBuf->BufUsed = optr - LineBuf->buf;
IncreaseBuf(LineBuf, 1, LineBuf->BufUsed + 1);
optr = LineBuf->buf + LineBuf->BufUsed;
- xptr = LineBuf->buf + LineBuf->BufSize;
+ xptr = LineBuf->buf + LineBuf->BufSize - 1;
}
}
LineBuf->BufUsed = optr - LineBuf->buf;
projects / citadel.git / blobdiff