+#include "../sysdep.h"
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include "libcitadel.h"
+#ifdef HAVE_ICONV
+#include <iconv.h>
+#endif
+
+#ifdef HAVE_ZLIB
+#include <zlib.h>
+#endif
+
+
+#ifdef HAVE_ZLIB
+#include <zlib.h>
+int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen,
+ const Bytef * source, uLong sourceLen, int level);
+#endif
/**
* Private Structure for the Stringbuffer
/**
* \Brief Cast operator to Plain String
+ * Note: if the buffer is altered by StrBuf operations, this pointer may become
+ * invalid. So don't lean on it after altering the buffer!
+ * Since this operation is considered cheap, rather call it often than risking
+ * your pointer to become invalid!
* \param Str the string we want to get the c-string representation for
* \returns the Pointer to the Content. Don't mess with it!
*/
return (Str != NULL) ? Str->BufUsed : 0;
}
+/**
+ * \brief local utility function to resize the buffer
+ * \param Buf the buffer whichs storage we should increase
+ * \param KeepOriginal should we copy the original buffer or just start over with a new one
+ * \param DestSize what should fit in after?
+ */
+static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize)
+{
+ char *NewBuf;
+ size_t NewSize = Buf->BufSize * 2;
+
+ if (Buf->ConstBuf)
+ return -1;
+
+ if (DestSize > 0)
+ while (NewSize <= DestSize)
+ NewSize *= 2;
+
+ NewBuf= (char*) malloc(NewSize);
+ if (KeepOriginal && (Buf->BufUsed > 0))
+ {
+ memcpy(NewBuf, Buf->buf, Buf->BufUsed);
+ }
+ else
+ {
+ NewBuf[0] = '\0';
+ Buf->BufUsed = 0;
+ }
+ free (Buf->buf);
+ Buf->buf = NewBuf;
+ Buf->BufSize *= 2;
+ return Buf->BufSize;
+}
+
/**
* Allocate a new buffer with default buffer size
* \returns the new stringbuffer
return NewBuf;
}
-/**
- * \brief local utility function to resize the buffer
- * \param Buf the buffer whichs storage we should increase
- * \param KeepOriginal should we copy the original buffer or just start over with a new one
- * \param DestSize what should fit in after?
- */
-static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize)
-{
- char *NewBuf;
- size_t NewSize = Buf->BufSize * 2;
-
- if (Buf->ConstBuf)
- return -1;
-
- if (DestSize > 0)
- while (NewSize < DestSize)
- NewSize *= 2;
-
- NewBuf= (char*) malloc(NewSize);
- if (KeepOriginal && (Buf->BufUsed > 0))
- {
- memcpy(NewBuf, Buf->buf, Buf->BufUsed);
- }
- else
- {
- NewBuf[0] = '\0';
- Buf->BufUsed = 0;
- }
- free (Buf->buf);
- Buf->buf = NewBuf;
- Buf->BufSize *= 2;
- return Buf->BufSize;
-}
/**
* \brief flush the content of a Buf; keep its struct
*/
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;
void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, size_t 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,
bptr += 5;
Target->BufUsed += 5;
}
- else if (*aptr == '\"') {
+ else if (*aptr == '"') {
memcpy(bptr, """, 6);
bptr += 6;
Target->BufUsed += 6;
*/
inline int StrBufNum_tokens(const StrBuf *source, char tok)
{
+ if (source == NULL)
+ return 0;
return num_tokens(source->buf, tok);
}
+/*
+ * remove_token() - a tokenizer that kills, maims, and destroys
+ */
+/**
+ * \brief a string tokenizer
+ * \param Source StringBuffer to read into
+ * \param parmnum n'th parameter to remove
+ * \param separator tokenizer param
+ * \returns -1 if not found, else length of token.
+ */
+int StrBufRemove_token(StrBuf *Source, int parmnum, char separator)
+{
+ int ReducedBy;
+ char *d, *s; /* dest, source */
+ int count = 0;
+
+ /* Find desired parameter */
+ d = Source->buf;
+ while (count < parmnum) {
+ /* End of string, bail! */
+ if (!*d) {
+ d = NULL;
+ break;
+ }
+ if (*d == separator) {
+ count++;
+ }
+ d++;
+ }
+ if (!d) return 0; /* Parameter not found */
+
+ /* Find next parameter */
+ s = d;
+ while (*s && *s != separator) {
+ s++;
+ }
+
+ ReducedBy = d - s;
+
+ /* Hack and slash */
+ if (*s) {
+ memmove(d, s, Source->BufUsed - (s - Source->buf));
+ Source->BufUsed -= (ReducedBy + 1);
+ }
+ else if (d == Source->buf) {
+ *d = 0;
+ Source->BufUsed = 0;
+ }
+ else {
+ *--d = 0;
+ Source->BufUsed -= (ReducedBy + 1);
+ }
+ /*
+ while (*s) {
+ *d++ = *s++;
+ }
+ *d = 0;
+ */
+ return ReducedBy;
+}
+
+
/**
* \brief a string tokenizer
* \param dest Destination StringBuffer
return len - slen;
}
+/**
+ * \brief Read a line from socket
+ * flushes and closes the FD on error
+ * \param buf the buffer to get the input to
+ * \param fd pointer to the filedescriptor to read
+ * \param append Append to an existing string or replace?
+ * \param Error strerror() on error
+ * \returns numbers of chars read
+ */
+int StrBufTCP_read_buffered_line(StrBuf *Line,
+ StrBuf *buf,
+ int *fd,
+ int timeout,
+ int selectresolution,
+ const char **Error)
+{
+ int len, rlen;
+ int nSuccessLess = 0;
+ fd_set rfds;
+ char *pch = NULL;
+ int fdflags;
+ struct timeval tv;
+
+ if (buf->BufUsed > 0) {
+ pch = strchr(buf->buf, '\n');
+ if (pch != NULL) {
+ rlen = 0;
+ len = pch - buf->buf;
+ if (len > 0 && (*(pch - 1) == '\r') )
+ rlen ++;
+ StrBufSub(Line, buf, 0, len - rlen);
+ StrBufCutLeft(buf, len + 1);
+ return len - rlen;
+ }
+ }
+
+ if (buf->BufSize - buf->BufUsed < 10)
+ IncreaseBuf(buf, 1, -1);
+
+ fdflags = fcntl(*fd, F_GETFL);
+ if ((fdflags & O_NONBLOCK) == O_NONBLOCK)
+ return -1;
+
+ while ((nSuccessLess < timeout) && (pch == NULL)) {
+ tv.tv_sec = selectresolution;
+ tv.tv_usec = 0;
+
+ FD_ZERO(&rfds);
+ FD_SET(*fd, &rfds);
+ if (select(*fd + 1, NULL, &rfds, NULL, &tv) == -1) {
+ *Error = strerror(errno);
+ close (*fd);
+ *fd = -1;
+ return -1;
+ }
+ if (FD_ISSET(*fd, &rfds)) {
+ rlen = read(*fd,
+ &buf->buf[buf->BufUsed],
+ buf->BufSize - buf->BufUsed - 1);
+ if (rlen < 1) {
+ *Error = strerror(errno);
+ close(*fd);
+ *fd = -1;
+ return -1;
+ }
+ else if (rlen > 0) {
+ 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');
+ continue;
+ }
+ }
+ nSuccessLess ++;
+ }
+ if (pch != NULL) {
+ rlen = 0;
+ len = pch - buf->buf;
+ if (len > 0 && (*(pch - 1) == '\r') )
+ rlen ++;
+ StrBufSub(Line, buf, 0, len - rlen);
+ StrBufCutLeft(buf, len + 1);
+ return len - rlen;
+ }
+ return -1;
+
+}
+
/**
* \brief Input binary data from socket
* flushes and closes the FD on error
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.
+ * buf - the string to modify
+ * len - length of the string.
+ */
+void StrBufTrim(StrBuf *Buf)
+{
+ int delta = 0;
+ if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
+
+ while ((Buf->BufUsed > delta) && (isspace(Buf->buf[delta]))){
+ delta ++;
+ }
+ if (delta > 0) StrBufCutLeft(Buf, delta);
+
+ if (Buf->BufUsed == 0) return;
+ while (isspace(Buf->buf[Buf->BufUsed - 1])){
+ Buf->BufUsed --;
+ }
+ Buf->buf[Buf->BufUsed] = '\0';
+}
+
+
+void StrBufUpCase(StrBuf *Buf)
+{
+ char *pch, *pche;
+
+ pch = Buf->buf;
+ pche = pch + Buf->BufUsed;
+ while (pch < pche) {
+ *pch = toupper(*pch);
+ pch ++;
+ }
+}
+
+
+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
&compressed_len,
(Bytef *) Buf->buf,
(uLongf) Buf->BufUsed, Z_BEST_SPEED) == Z_OK) {
- if (!ConstBuf)
+ if (!Buf->ConstBuf)
free(Buf->buf);
Buf->buf = compressed_data;
Buf->BufUsed = compressed_len;
buf->buf[i] = replace;
}
+
+
+
+/*
+ * Wrapper around iconv_open()
+ * Our version adds aliases for non-standard Microsoft charsets
+ * such as 'MS950', aliasing them to names like 'CP950'
+ *
+ * tocode Target encoding
+ * fromcode Source encoding
+ */
+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
+}
+
+
+
+static inline char *FindNextEnd (const StrBuf *Buf, char *bptr)
+{
+ char * end;
+ /* Find the next ?Q? */
+ if (Buf->BufUsed - (bptr - Buf->buf) < 6)
+ return NULL;
+
+ end = strchr(bptr + 2, '?');
+
+ if (end == NULL)
+ return NULL;
+
+ if ((Buf->BufUsed - (end - Buf->buf) > 3) &&
+ ((*(end + 1) == 'B') || (*(end + 1) == 'Q')) &&
+ (*(end + 2) == '?')) {
+ /* skip on to the end of the cluster, the next ?= */
+ end = strstr(end + 3, "?=");
+ }
+ else
+ /* sort of half valid encoding, try to find an end. */
+ end = strstr(bptr, "?=");
+ return end;
+}
+
+
+void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
+{
+#ifdef HAVE_ICONV
+ int BufSize;
+ iconv_t ic;
+ 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 */
+
+
+ if (ConvertBuf->BufUsed > TmpBuf->BufSize)
+ IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed);
+
+ ic = *(iconv_t*)pic;
+ ibuf = ConvertBuf->buf;
+ ibuflen = ConvertBuf->BufUsed;
+ obuf = TmpBuf->buf;
+ obuflen = TmpBuf->BufSize;
+
+ iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
+
+ /* little card game: wheres the red lady? */
+ ibuf = ConvertBuf->buf;
+ BufSize = ConvertBuf->BufSize;
+
+ ConvertBuf->buf = TmpBuf->buf;
+ ConvertBuf->BufSize = TmpBuf->BufSize;
+ ConvertBuf->BufUsed = TmpBuf->BufSize - obuflen;
+ ConvertBuf->buf[ConvertBuf->BufUsed] = '\0';
+
+ TmpBuf->buf = ibuf;
+ TmpBuf->BufSize = BufSize;
+ TmpBuf->BufUsed = 0;
+ TmpBuf->buf[0] = '\0';
+#endif
+}
+
+
+
+
+inline static void DecodeSegment(StrBuf *Target,
+ const StrBuf *DecodeMe,
+ char *SegmentStart,
+ char *SegmentEnd,
+ StrBuf *ConvertBuf,
+ StrBuf *ConvertBuf2,
+ StrBuf *FoundCharset)
+{
+ StrBuf StaticBuf;
+ char charset[128];
+ char encoding[16];
+ iconv_t ic = (iconv_t)(-1);
+
+ /* Now we handle foreign character sets properly encoded
+ * in RFC2047 format.
+ */
+ StaticBuf.buf = SegmentStart;
+ 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,
+ ConvertBuf->BufUsed);
+ }
+ else if (*encoding == 'Q') { /**< quoted-printable */
+ long pos;
+
+ pos = 0;
+ while (pos < ConvertBuf->BufUsed)
+ {
+ if (ConvertBuf->buf[pos] == '_')
+ ConvertBuf->buf[pos] = ' ';
+ pos++;
+ }
+
+ ConvertBuf2->BufUsed = CtdlDecodeQuotedPrintable(
+ ConvertBuf2->buf,
+ ConvertBuf->buf,
+ ConvertBuf->BufUsed);
+ }
+ else {
+ StrBufAppendBuf(ConvertBuf2, ConvertBuf, 0);
+ }
+
+ ctdl_iconv_open("UTF-8", charset, &ic);
+ if (ic != (iconv_t)(-1) ) {
+ StrBufConvert(ConvertBuf2, ConvertBuf, &ic);
+ StrBufAppendBuf(Target, ConvertBuf2, 0);
+ iconv_close(ic);
+ }
+ else {
+ StrBufAppendBufPlain(Target, HKEY("(unreadable)"), 0);
+ }
+}
+/*
+ * Handle subjects with RFC2047 encoding such as:
+ * =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
+ */
+void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset)
+{
+ StrBuf *ConvertBuf, *ConvertBuf2;
+ char *start, *end, *next, *nextend, *ptr = NULL;
+ iconv_t ic = (iconv_t)(-1) ;
+ const char *eptr;
+ int passes = 0;
+ int i, len, delta;
+ int illegal_non_rfc2047_encoding = 0;
+
+ /* Sometimes, badly formed messages contain strings which were simply
+ * written out directly in some foreign character set instead of
+ * using RFC2047 encoding. This is illegal but we will attempt to
+ * handle it anyway by converting from a user-specified default
+ * charset to UTF-8 if we see any nonprintable characters.
+ */
+
+ len = StrLength(DecodeMe);
+ for (i=0; i<DecodeMe->BufUsed; ++i) {
+ if ((DecodeMe->buf[i] < 32) || (DecodeMe->buf[i] > 126)) {
+ illegal_non_rfc2047_encoding = 1;
+ break;
+ }
+ }
+
+ ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe));
+ 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);
+ }
+ }
+
+ /* pre evaluate the first pair */
+ nextend = end = NULL;
+ len = StrLength(DecodeMe);
+ start = strstr(DecodeMe->buf, "=?");
+ eptr = DecodeMe->buf + DecodeMe->BufUsed;
+ if (start != NULL)
+ end = FindNextEnd (DecodeMe, start);
+ else {
+ StrBufAppendBuf(Target, DecodeMe, 0);
+ FreeStrBuf(&ConvertBuf);
+ return;
+ }
+
+ 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.
+ * So, prevent a really badly formed RFC2047 header from throwing
+ * this function into an infinite loop.
+ */
+ while ((start != NULL) &&
+ (end != NULL) &&
+ (start < eptr) &&
+ (end < eptr) &&
+ (passes < 20))
+ {
+ passes++;
+ DecodeSegment(Target,
+ DecodeMe,
+ start,
+ end,
+ ConvertBuf,
+ ConvertBuf2,
+ FoundCharset);
+
+ next = strstr(end, "=?");
+ nextend = NULL;
+ if ((next != NULL) &&
+ (next < eptr))
+ nextend = FindNextEnd(DecodeMe, next);
+ if (nextend == NULL)
+ next = NULL;
+
+ /* did we find two partitions */
+ if ((next != NULL) &&
+ ((next - end) > 2))
+ {
+ ptr = end + 2;
+ while ((ptr < next) &&
+ (isspace(*ptr) ||
+ (*ptr == '\r') ||
+ (*ptr == '\n') ||
+ (*ptr == '\t')))
+ ptr ++;
+ /* did we find a gab just filled with blanks? */
+ if (ptr == next)
+ {
+ memmove (end + 2,
+ next,
+ len - (next - start));
+
+ /* now terminate the gab at the end */
+ delta = (next - end) - 2; ////TODO: const!
+ ((StrBuf*)DecodeMe)->BufUsed -= delta;
+ ((StrBuf*)DecodeMe)->buf[DecodeMe->BufUsed] = '\0';
+
+ /* move next to its new location. */
+ next -= delta;
+ nextend -= 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);
+}
+
+
+
+long StrBuf_Utf8StrLen(StrBuf *Buf)
+{
+ return Ctdl_Utf8StrLen(Buf->buf);
+}
+
+long StrBuf_Utf8StrCut(StrBuf *Buf, int maxlen)
+{
+ char *CutAt;
+
+ CutAt = Ctdl_Utf8StrCut(Buf->buf, maxlen);
+ if (CutAt != NULL) {
+ Buf->BufUsed = CutAt - Buf->buf;
+ Buf->buf[Buf->BufUsed] = '\0';
+ }
+ return Buf->BufUsed;
+}
+
+
+
+int StrBufSipLine(StrBuf *LineBuf, StrBuf *Buf, const char **Ptr)
+{
+ const char *aptr, *ptr, *eptr;
+ char *optr, *xptr;
+
+ if (Buf == NULL)
+ return 0;
+
+ if (*Ptr==NULL)
+ ptr = aptr = Buf->buf;
+ else
+ ptr = aptr = *Ptr;
+
+ optr = LineBuf->buf;
+ eptr = Buf->buf + Buf->BufUsed;
+ xptr = LineBuf->buf + LineBuf->BufSize;
+
+ while ((*ptr != '\n') &&
+ (*ptr != '\r') &&
+ (ptr < eptr))
+ {
+ *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;
+ }
+ }
+ LineBuf->BufUsed = optr - LineBuf->buf;
+ *optr = '\0';
+ if (*ptr == '\r')
+ ptr ++;
+ if (*ptr == '\n')
+ ptr ++;
+
+ *Ptr = ptr;
+
+ return Buf->BufUsed - (ptr - Buf->buf);
+}
projects / citadel.git / blobdiff