Finalize Networker; native modern linux.
[citadel] / libcitadel / lib / stringbuf.c
1 /*
2  * Copyright (c) 1987-2011 by the citadel.org team
3  *
4  * This program is open source software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  */
18
19 #define _GNU_SOURCE
20 #include "sysdep.h"
21 #include <ctype.h>
22 #include <errno.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <string.h>
26 #include <stdio.h>
27 #include <sys/select.h>
28 #include <fcntl.h>
29 #include <sys/types.h>
30 #define SHOW_ME_VAPPEND_PRINTF
31 #include <stdarg.h>
32 #ifndef LINUX_SENDFILE
33 #include <bits/fcntl.h>
34 #include <sys/sendfile.h>
35 #endif
36 #include "libcitadel.h"
37
38 #ifdef HAVE_ICONV
39 #include <iconv.h>
40 #endif
41
42 #ifdef HAVE_BACKTRACE
43 #include <execinfo.h>
44 #endif
45
46 #ifdef LINUX_SENDFILE
47 #include <sys/sendfile.h>
48 #endif
49
50 #ifdef HAVE_ZLIB
51 #include <zlib.h>
52 int ZEXPORT compress_gzip(Bytef * dest, size_t * destLen,
53                           const Bytef * source, uLong sourceLen, int level);
54 #endif
55 int BaseStrBufSize = 64;
56
57 const char *StrBufNOTNULL = ((char*) NULL) - 1;
58
59 const char HexList[256][3] = {
60         "00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
61         "10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
62         "20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
63         "30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
64         "40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
65         "50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
66         "60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
67         "70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
68         "80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
69         "90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
70         "A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
71         "B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
72         "C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
73         "D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
74         "E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
75         "F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF"};
76
77 /**
78  * @defgroup StrBuf Stringbuffer, A class for manipulating strings with dynamic buffers
79  * StrBuf is a versatile class, aiding the handling of dynamic strings
80  *  * reduce de/reallocations
81  *  * reduce the need to remeasure it
82  *  * reduce scanning over the string (in @ref StrBuf_NextTokenizer "Tokenizers")
83  *  * allow asyncroneous IO for line and Blob based operations
84  *  * reduce the use of memove in those
85  *  * Quick filling in several operations with append functions
86  */
87
88 /**
89  * @defgroup StrBuf_DeConstructors Create/Destroy StrBufs
90  * @ingroup StrBuf
91  */
92
93 /**
94  * @defgroup StrBuf_Cast Cast operators to interact with char* based code
95  * @ingroup StrBuf
96  * use these operators to interfere with code demanding char*; 
97  * if you need to own the content, smash me. Avoid, since we loose the length information.
98  */
99
100 /**
101  * @defgroup StrBuf_Filler Create/Replace/Append Content into a StrBuf
102  * @ingroup StrBuf
103  * operations to get your Strings into a StrBuf, manipulating them, or appending
104  */
105 /**
106  * @defgroup StrBuf_NextTokenizer Fast tokenizer to pull tokens in sequence 
107  * @ingroup StrBuf
108  * Quick tokenizer; demands of the user to pull its tokens in sequence
109  */
110
111 /**
112  * @defgroup StrBuf_Tokenizer tokenizer Functions; Slow ones.
113  * @ingroup StrBuf
114  * versatile tokenizer; random access to tokens, but slower; Prefer the @ref StrBuf_NextTokenizer "Next Tokenizer"
115  */
116
117 /**
118  * @defgroup StrBuf_BufferedIO Buffered IO with Asynchroneous reads and no unneeded memmoves (the fast ones)
119  * @ingroup StrBuf
120  * File IO to fill StrBufs; Works with work-buffer shared across several calls;
121  * External Cursor to maintain the current read position inside of the buffer
122  * the non-fast ones will use memove to keep the start of the buffer the read buffer (which is slower) 
123  */
124
125 /**
126  * @defgroup StrBuf_IO FileIO; Prefer @ref StrBuf_BufferedIO
127  * @ingroup StrBuf
128  * Slow I/O; avoid.
129  */
130
131 /**
132  * @defgroup StrBuf_DeEnCoder functions to translate the contents of a buffer
133  * @ingroup StrBuf
134  * these functions translate the content of a buffer into another representation;
135  * some are combined Fillers and encoders
136  */
137
138 /**
139  * Private Structure for the Stringbuffer
140  */
141 struct StrBuf {
142         char *buf;         /**< the pointer to the dynamic buffer */
143         long BufSize;      /**< how many spcae do we optain */
144         long BufUsed;      /**< StNumber of Chars used excluding the trailing \\0 */
145         int ConstBuf;      /**< are we just a wrapper arround a static buffer and musn't we be changed? */
146 #ifdef SIZE_DEBUG
147         long nIncreases;   /**< for profiling; cound how many times we needed more */
148         char bt [SIZ];     /**< Stacktrace of last increase */
149         char bt_lastinc [SIZ]; /**< How much did we increase last time? */
150 #endif
151 };
152
153
154 static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE);
155 static inline int Ctdl_IsUtf8SequenceStart(const char Char);
156
157 #ifdef SIZE_DEBUG
158 #ifdef HAVE_BACKTRACE
159 static void StrBufBacktrace(StrBuf *Buf, int which)
160 {
161         int n;
162         char *pstart, *pch;
163         void *stack_frames[50];
164         size_t size, i;
165         char **strings;
166
167         if (which)
168                 pstart = pch = Buf->bt;
169         else
170                 pstart = pch = Buf->bt_lastinc;
171         size = backtrace(stack_frames, sizeof(stack_frames) / sizeof(void*));
172         strings = backtrace_symbols(stack_frames, size);
173         for (i = 0; i < size; i++) {
174                 if (strings != NULL)
175                         n = snprintf(pch, SIZ - (pch - pstart), "%s\\n", strings[i]);
176                 else
177                         n = snprintf(pch, SIZ - (pch - pstart), "%p\\n", stack_frames[i]);
178                 pch += n;
179         }
180         free(strings);
181
182
183 }
184 #endif
185
186 void dbg_FreeStrBuf(StrBuf *FreeMe, char *FromWhere)
187 {
188         if (hFreeDbglog == -1){
189                 pid_t pid = getpid();
190                 char path [SIZ];
191                 snprintf(path, SIZ, "/tmp/libcitadel_strbuf_realloc.log.%d", pid);
192                 hFreeDbglog = open(path, O_APPEND|O_CREAT|O_WRONLY);
193         }
194         if ((*FreeMe)->nIncreases > 0)
195         {
196                 char buf[SIZ * 3];
197                 long n;
198                 n = snprintf(buf, SIZ * 3, "%c+|%ld|%ld|%ld|%s|%s|\n",
199                              FromWhere,
200                              (*FreeMe)->nIncreases,
201                              (*FreeMe)->BufUsed,
202                              (*FreeMe)->BufSize,
203                              (*FreeMe)->bt,
204                              (*FreeMe)->bt_lastinc);
205                 n = write(hFreeDbglog, buf, n);
206         }
207         else
208         {
209                 char buf[128];
210                 long n;
211                 n = snprintf(buf, 128, "%c_|0|%ld%ld|\n",
212                              FromWhere,
213                              (*FreeMe)->BufUsed,
214                              (*FreeMe)->BufSize);
215                 n = write(hFreeDbglog, buf, n);
216         }
217 }
218
219 void dbg_IncreaseBuf(StrBuf *IncMe)
220 {
221         Buf->nIncreases++;
222 #ifdef HAVE_BACKTRACE
223         StrBufBacktrace(Buf, 1);
224 #endif
225 }
226
227 void dbg_Init(StrBuf *Buf)
228 {
229         Buf->nIncreases = 0;
230         Buf->bt[0] = '\0';
231         Buf->bt_lastinc[0] = '\0';
232 #ifdef HAVE_BACKTRACE
233         StrBufBacktrace(Buf, 0);
234 #endif
235 }
236
237 #else
238 /* void it... */
239 #define dbg_FreeStrBuf(a, b)
240 #define dbg_IncreaseBuf(a)
241 #define dbg_Init(a)
242
243 #endif
244
245 /**
246  * @ingroup StrBuf
247  * @brief swaps the contents of two StrBufs
248  * this is to be used to have cheap switched between a work-buffer and a target buffer 
249  * @param A First one
250  * @param B second one
251  */
252 static inline void SwapBuffers(StrBuf *A, StrBuf *B)
253 {
254         StrBuf C;
255
256         memcpy(&C, A, sizeof(*A));
257         memcpy(A, B, sizeof(*B));
258         memcpy(B, &C, sizeof(C));
259
260 }
261
262 /** 
263  * @ingroup StrBuf_Cast
264  * @brief Cast operator to Plain String 
265  * @note if the buffer is altered by StrBuf operations, this pointer may become 
266  *  invalid. So don't lean on it after altering the buffer!
267  *  Since this operation is considered cheap, rather call it often than risking
268  *  your pointer to become invalid!
269  * @param Str the string we want to get the c-string representation for
270  * @returns the Pointer to the Content. Don't mess with it!
271  */
272 inline const char *ChrPtr(const StrBuf *Str)
273 {
274         if (Str == NULL)
275                 return "";
276         return Str->buf;
277 }
278
279 /**
280  * @ingroup StrBuf_Cast
281  * @brief since we know strlen()'s result, provide it here.
282  * @param Str the string to return the length to
283  * @returns contentlength of the buffer
284  */
285 inline int StrLength(const StrBuf *Str)
286 {
287         return (Str != NULL) ? Str->BufUsed : 0;
288 }
289
290 /**
291  * @ingroup StrBuf_DeConstructors
292  * @brief local utility function to resize the buffer
293  * @param Buf the buffer whichs storage we should increase
294  * @param KeepOriginal should we copy the original buffer or just start over with a new one
295  * @param DestSize what should fit in after?
296  */
297 static int IncreaseBuf(StrBuf *Buf, int KeepOriginal, int DestSize)
298 {
299         char *NewBuf;
300         size_t NewSize = Buf->BufSize * 2;
301
302         if (Buf->ConstBuf)
303                 return -1;
304                 
305         if (DestSize > 0)
306                 while ((NewSize <= DestSize) && (NewSize != 0))
307                         NewSize *= 2;
308
309         if (NewSize == 0)
310                 return -1;
311
312         NewBuf= (char*) malloc(NewSize);
313         if (NewBuf == NULL)
314                 return -1;
315
316         if (KeepOriginal && (Buf->BufUsed > 0))
317         {
318                 memcpy(NewBuf, Buf->buf, Buf->BufUsed);
319         }
320         else
321         {
322                 NewBuf[0] = '\0';
323                 Buf->BufUsed = 0;
324         }
325         free (Buf->buf);
326         Buf->buf = NewBuf;
327         Buf->BufSize = NewSize;
328
329         dbg_IncreaseBuf(Buf);
330
331         return Buf->BufSize;
332 }
333
334 /**
335  * @ingroup StrBuf_DeConstructors
336  * @brief shrink / increase an _EMPTY_ buffer to NewSize. Buffercontent is thoroughly ignored and flushed.
337  * @param Buf Buffer to shrink (has to be empty)
338  * @param ThreshHold if the buffer is bigger then this, its readjusted
339  * @param NewSize if we Shrink it, how big are we going to be afterwards?
340  */
341 void ReAdjustEmptyBuf(StrBuf *Buf, long ThreshHold, long NewSize)
342 {
343         if ((Buf != NULL) && 
344             (Buf->BufUsed == 0) &&
345             (Buf->BufSize < ThreshHold)) {
346                 free(Buf->buf);
347                 Buf->buf = (char*) malloc(NewSize);
348                 Buf->BufUsed = 0;
349                 Buf->BufSize = NewSize;
350         }
351 }
352
353 /**
354  * @ingroup StrBuf_DeConstructors
355  * @brief shrink long term buffers to their real size so they don't waste memory
356  * @param Buf buffer to shrink
357  * @param Force if not set, will just executed if the buffer is much to big; set for lifetime strings
358  * @returns physical size of the buffer
359  */
360 long StrBufShrinkToFit(StrBuf *Buf, int Force)
361 {
362         if (Buf == NULL)
363                 return -1;
364         if (Force || 
365             (Buf->BufUsed + (Buf->BufUsed / 3) > Buf->BufSize))
366         {
367                 char *TmpBuf = (char*) malloc(Buf->BufUsed + 1);
368                 memcpy (TmpBuf, Buf->buf, Buf->BufUsed + 1);
369                 Buf->BufSize = Buf->BufUsed + 1;
370                 free(Buf->buf);
371                 Buf->buf = TmpBuf;
372         }
373         return Buf->BufUsed;
374 }
375
376 /**
377  * @ingroup StrBuf_DeConstructors
378  * @brief Allocate a new buffer with default buffer size
379  * @returns the new stringbuffer
380  */
381 StrBuf* NewStrBuf(void)
382 {
383         StrBuf *NewBuf;
384
385         NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
386         NewBuf->buf = (char*) malloc(BaseStrBufSize);
387         NewBuf->buf[0] = '\0';
388         NewBuf->BufSize = BaseStrBufSize;
389         NewBuf->BufUsed = 0;
390         NewBuf->ConstBuf = 0;
391
392         dbg_Init (NewBuf);
393
394         return NewBuf;
395 }
396
397 /** 
398  * @ingroup StrBuf_DeConstructors
399  * @brief Copy Constructor; returns a duplicate of CopyMe
400  * @param CopyMe Buffer to faxmilate
401  * @returns the new stringbuffer
402  */
403 StrBuf* NewStrBufDup(const StrBuf *CopyMe)
404 {
405         StrBuf *NewBuf;
406         
407         if (CopyMe == NULL)
408                 return NewStrBuf();
409
410         NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
411         NewBuf->buf = (char*) malloc(CopyMe->BufSize);
412         memcpy(NewBuf->buf, CopyMe->buf, CopyMe->BufUsed + 1);
413         NewBuf->BufUsed = CopyMe->BufUsed;
414         NewBuf->BufSize = CopyMe->BufSize;
415         NewBuf->ConstBuf = 0;
416
417         dbg_Init(NewBuf);
418
419         return NewBuf;
420 }
421
422 /** 
423  * @ingroup StrBuf_DeConstructors
424  * @brief Copy Constructor; CreateRelpaceMe will contain CopyFlushMe afterwards.
425  * @param NoMe if non-NULL, we will use that buffer as value; KeepOriginal will abused as len.
426  * @param CopyFlushMe Buffer to faxmilate if KeepOriginal, or to move into CreateRelpaceMe if !KeepOriginal.
427  * @param CreateRelpaceMe If NULL, will be created, else Flushed and filled CopyFlushMe 
428  * @param KeepOriginal should CopyFlushMe remain intact? or may we Steal its buffer?
429  * @returns the new stringbuffer
430  */
431 void NewStrBufDupAppendFlush(StrBuf **CreateRelpaceMe, StrBuf *CopyFlushMe, const char *NoMe, int KeepOriginal)
432 {
433         StrBuf *NewBuf;
434         
435         if (CreateRelpaceMe == NULL)
436                 return;
437
438         if (NoMe != NULL)
439         {
440                 if (*CreateRelpaceMe != NULL)
441                         StrBufPlain(*CreateRelpaceMe, NoMe, KeepOriginal);
442                 else 
443                         *CreateRelpaceMe = NewStrBufPlain(NoMe, KeepOriginal);
444                 return;
445         }
446
447         if (CopyFlushMe == NULL)
448         {
449                 if (*CreateRelpaceMe != NULL)
450                         FlushStrBuf(*CreateRelpaceMe);
451                 else 
452                         *CreateRelpaceMe = NewStrBuf();
453                 return;
454         }
455
456         /* 
457          * Randomly Chosen: bigger than 64 chars is cheaper to swap the buffers instead of copying.
458          * else *CreateRelpaceMe may use more memory than needed in a longer term, CopyFlushMe might
459          * be a big IO-Buffer...
460          */
461         if (KeepOriginal || (StrLength(CopyFlushMe) < 256))
462         {
463                 if (*CreateRelpaceMe == NULL)
464                 {
465                         *CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed);
466                         dbg_Init(NewBuf);
467                 }
468                 else 
469                 {
470                         NewBuf = *CreateRelpaceMe;
471                         FlushStrBuf(NewBuf);
472                 }
473                 StrBufAppendBuf(NewBuf, CopyFlushMe, 0);
474         }
475         else
476         {
477                 if (*CreateRelpaceMe == NULL)
478                 {
479                         *CreateRelpaceMe = NewBuf = NewStrBufPlain(NULL, CopyFlushMe->BufUsed);
480                         dbg_Init(NewBuf);
481                 }
482                 else 
483                         NewBuf = *CreateRelpaceMe;
484                 SwapBuffers (NewBuf, CopyFlushMe);
485         }
486         if (!KeepOriginal)
487                 FlushStrBuf(CopyFlushMe);
488         return;
489 }
490
491 /**
492  * @ingroup StrBuf_DeConstructors
493  * @brief create a new Buffer using an existing c-string
494  * this function should also be used if you want to pre-suggest
495  * the buffer size to allocate in conjunction with ptr == NULL
496  * @param ptr the c-string to copy; may be NULL to create a blank instance
497  * @param nChars How many chars should we copy; -1 if we should measure the length ourselves
498  * @returns the new stringbuffer
499  */
500 StrBuf* NewStrBufPlain(const char* ptr, int nChars)
501 {
502         StrBuf *NewBuf;
503         size_t Siz = BaseStrBufSize;
504         size_t CopySize;
505
506         NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
507         if (nChars < 0)
508                 CopySize = strlen((ptr != NULL)?ptr:"");
509         else
510                 CopySize = nChars;
511
512         while ((Siz <= CopySize) && (Siz != 0))
513                 Siz *= 2;
514
515         if (Siz == 0)
516         {
517                 return NULL;
518         }
519
520         NewBuf->buf = (char*) malloc(Siz);
521         if (NewBuf->buf == NULL)
522         {
523                 free(NewBuf);
524                 return NULL;
525         }
526         NewBuf->BufSize = Siz;
527         if (ptr != NULL) {
528                 memcpy(NewBuf->buf, ptr, CopySize);
529                 NewBuf->buf[CopySize] = '\0';
530                 NewBuf->BufUsed = CopySize;
531         }
532         else {
533                 NewBuf->buf[0] = '\0';
534                 NewBuf->BufUsed = 0;
535         }
536         NewBuf->ConstBuf = 0;
537
538         dbg_Init(NewBuf);
539
540         return NewBuf;
541 }
542
543 /**
544  * @ingroup StrBuf_DeConstructors
545  * @brief Set an existing buffer from a c-string
546  * @param Buf buffer to load
547  * @param ptr c-string to put into 
548  * @param nChars set to -1 if we should work 0-terminated
549  * @returns the new length of the string
550  */
551 int StrBufPlain(StrBuf *Buf, const char* ptr, int nChars)
552 {
553         size_t Siz;
554         size_t CopySize;
555
556         if (Buf == NULL)
557                 return -1;
558         if (ptr == NULL) {
559                 FlushStrBuf(Buf);
560                 return -1;
561         }
562
563         Siz = Buf->BufSize;
564
565         if (nChars < 0)
566                 CopySize = strlen(ptr);
567         else
568                 CopySize = nChars;
569
570         while ((Siz <= CopySize) && (Siz != 0))
571                 Siz *= 2;
572
573         if (Siz == 0) {
574                 FlushStrBuf(Buf);
575                 return -1;
576         }
577
578         if (Siz != Buf->BufSize)
579                 IncreaseBuf(Buf, 0, Siz);
580         memcpy(Buf->buf, ptr, CopySize);
581         Buf->buf[CopySize] = '\0';
582         Buf->BufUsed = CopySize;
583         Buf->ConstBuf = 0;
584         return CopySize;
585 }
586
587
588 /**
589  * @ingroup StrBuf_DeConstructors
590  * @brief use strbuf as wrapper for a string constant for easy handling
591  * @param StringConstant a string to wrap
592  * @param SizeOfStrConstant should be sizeof(StringConstant)-1
593  */
594 StrBuf* _NewConstStrBuf(const char* StringConstant, size_t SizeOfStrConstant)
595 {
596         StrBuf *NewBuf;
597
598         NewBuf = (StrBuf*) malloc(sizeof(StrBuf));
599         NewBuf->buf = (char*) StringConstant;
600         NewBuf->BufSize = SizeOfStrConstant;
601         NewBuf->BufUsed = SizeOfStrConstant;
602         NewBuf->ConstBuf = 1;
603
604         dbg_Init(NewBuf);
605
606         return NewBuf;
607 }
608
609
610 /**
611  * @ingroup StrBuf_DeConstructors
612  * @brief flush the content of a Buf; keep its struct
613  * @param buf Buffer to flush
614  */
615 int FlushStrBuf(StrBuf *buf)
616 {
617         if (buf == NULL)
618                 return -1;
619         if (buf->ConstBuf)
620                 return -1;       
621         buf->buf[0] ='\0';
622         buf->BufUsed = 0;
623         return 0;
624 }
625
626 /**
627  * @ingroup StrBuf_DeConstructors
628  * @brief wipe the content of a Buf thoroughly (overwrite it -> expensive); keep its struct
629  * @param buf Buffer to wipe
630  */
631 int FLUSHStrBuf(StrBuf *buf)
632 {
633         if (buf == NULL)
634                 return -1;
635         if (buf->ConstBuf)
636                 return -1;
637         if (buf->BufUsed > 0) {
638                 memset(buf->buf, 0, buf->BufUsed);
639                 buf->BufUsed = 0;
640         }
641         return 0;
642 }
643
644 #ifdef SIZE_DEBUG
645 int hFreeDbglog = -1;
646 #endif
647 /**
648  * @ingroup StrBuf_DeConstructors
649  * @brief Release a Buffer
650  * Its a double pointer, so it can NULL your pointer
651  * so fancy SIG11 appear instead of random results
652  * @param FreeMe Pointer Pointer to the buffer to free
653  */
654 void FreeStrBuf (StrBuf **FreeMe)
655 {
656         if (*FreeMe == NULL)
657                 return;
658
659         dbg_FreeStrBuf(FreeMe, 'F');
660
661         if (!(*FreeMe)->ConstBuf) 
662                 free((*FreeMe)->buf);
663         free(*FreeMe);
664         *FreeMe = NULL;
665 }
666
667 /**
668  * @ingroup StrBuf_DeConstructors
669  * @brief flatten a Buffer to the Char * we return 
670  * Its a double pointer, so it can NULL your pointer
671  * so fancy SIG11 appear instead of random results
672  * The Callee then owns the buffer and is responsible for freeing it.
673  * @param SmashMe Pointer Pointer to the buffer to release Buf from and free
674  * @returns the pointer of the buffer; Callee owns the memory thereafter.
675  */
676 char *SmashStrBuf (StrBuf **SmashMe)
677 {
678         char *Ret;
679
680         if ((SmashMe == NULL) || (*SmashMe == NULL))
681                 return NULL;
682         
683         dbg_FreeStrBuf(SmashMe, 'S');
684
685         Ret = (*SmashMe)->buf;
686         free(*SmashMe);
687         *SmashMe = NULL;
688         return Ret;
689 }
690
691 /**
692  * @ingroup StrBuf_DeConstructors
693  * @brief Release the buffer
694  * If you want put your StrBuf into a Hash, use this as Destructor.
695  * @param VFreeMe untyped pointer to a StrBuf. be shure to do the right thing [TM]
696  */
697 void HFreeStrBuf (void *VFreeMe)
698 {
699         StrBuf *FreeMe = (StrBuf*)VFreeMe;
700         if (FreeMe == NULL)
701                 return;
702
703         dbg_FreeStrBuf(SmashMe, 'H');
704
705         if (!FreeMe->ConstBuf) 
706                 free(FreeMe->buf);
707         free(FreeMe);
708 }
709
710
711 /*******************************************************************************
712  *                      Simple string transformations                          *
713  *******************************************************************************/
714
715 /**
716  * @ingroup StrBuf
717  * @brief Wrapper around atol
718  */
719 long StrTol(const StrBuf *Buf)
720 {
721         if (Buf == NULL)
722                 return 0;
723         if(Buf->BufUsed > 0)
724                 return atol(Buf->buf);
725         else
726                 return 0;
727 }
728
729 /**
730  * @ingroup StrBuf
731  * @brief Wrapper around atoi
732  */
733 int StrToi(const StrBuf *Buf)
734 {
735         if (Buf == NULL)
736                 return 0;
737         if (Buf->BufUsed > 0)
738                 return atoi(Buf->buf);
739         else
740                 return 0;
741 }
742
743 /**
744  * @ingroup StrBuf
745  * @brief Checks to see if the string is a pure number 
746  * @param Buf The buffer to inspect
747  * @returns 1 if its a pure number, 0, if not.
748  */
749 int StrBufIsNumber(const StrBuf *Buf) {
750         char * pEnd;
751         if ((Buf == NULL) || (Buf->BufUsed == 0)) {
752                 return 0;
753         }
754         strtoll(Buf->buf, &pEnd, 10);
755         if (pEnd == Buf->buf)
756                 return 0;
757         if ((pEnd != NULL) && (pEnd == Buf->buf + Buf->BufUsed))
758                 return 1;
759         if (Buf->buf == pEnd)
760                 return 0;
761         return 0;
762
763
764 /**
765  * @ingroup StrBuf_Filler
766  * @brief modifies a Single char of the Buf
767  * You can point to it via char* or a zero-based integer
768  * @param Buf The buffer to manipulate
769  * @param ptr char* to zero; use NULL if unused
770  * @param nThChar zero based pointer into the string; use -1 if unused
771  * @param PeekValue The Character to place into the position
772  */
773 long StrBufPeek(StrBuf *Buf, const char* ptr, long nThChar, char PeekValue)
774 {
775         if (Buf == NULL)
776                 return -1;
777         if (ptr != NULL)
778                 nThChar = ptr - Buf->buf;
779         if ((nThChar < 0) || (nThChar > Buf->BufUsed))
780                 return -1;
781         Buf->buf[nThChar] = PeekValue;
782         return nThChar;
783 }
784
785 /**
786  * @ingroup StrBuf_Filler
787  * @brief modifies a range of chars of the Buf
788  * You can point to it via char* or a zero-based integer
789  * @param Buf The buffer to manipulate
790  * @param ptr char* to zero; use NULL if unused
791  * @param nThChar zero based pointer into the string; use -1 if unused
792  * @param nChars how many chars are to be flushed?
793  * @param PookValue The Character to place into that area
794  */
795 long StrBufPook(StrBuf *Buf, const char* ptr, long nThChar, long nChars, char PookValue)
796 {
797         if (Buf == NULL)
798                 return -1;
799         if (ptr != NULL)
800                 nThChar = ptr - Buf->buf;
801         if ((nThChar < 0) || (nThChar > Buf->BufUsed))
802                 return -1;
803         if (nThChar + nChars > Buf->BufUsed)
804                 nChars =  Buf->BufUsed - nThChar;
805
806         memset(Buf->buf + nThChar, PookValue, nChars);
807         /* just to be shure... */
808         Buf->buf[Buf->BufUsed] = 0;
809         return nChars;
810 }
811
812 /**
813  * @ingroup StrBuf_Filler
814  * @brief Append a StringBuffer to the buffer
815  * @param Buf Buffer to modify
816  * @param AppendBuf Buffer to copy at the end of our buffer
817  * @param Offset Should we start copying from an offset?
818  */
819 void StrBufAppendBuf(StrBuf *Buf, const StrBuf *AppendBuf, unsigned long Offset)
820 {
821         if ((AppendBuf == NULL) || (Buf == NULL) || (AppendBuf->buf == NULL))
822                 return;
823
824         if (Buf->BufSize - Offset < AppendBuf->BufUsed + Buf->BufUsed + 1)
825                 IncreaseBuf(Buf, 
826                             (Buf->BufUsed > 0), 
827                             AppendBuf->BufUsed + Buf->BufUsed);
828
829         memcpy(Buf->buf + Buf->BufUsed, 
830                AppendBuf->buf + Offset, 
831                AppendBuf->BufUsed - Offset);
832         Buf->BufUsed += AppendBuf->BufUsed - Offset;
833         Buf->buf[Buf->BufUsed] = '\0';
834 }
835
836
837 /**
838  * @ingroup StrBuf_Filler
839  * @brief Append a C-String to the buffer
840  * @param Buf Buffer to modify
841  * @param AppendBuf Buffer to copy at the end of our buffer
842  * @param AppendSize number of bytes to copy; set to -1 if we should count it in advance
843  * @param Offset Should we start copying from an offset?
844  */
845 void StrBufAppendBufPlain(StrBuf *Buf, const char *AppendBuf, long AppendSize, unsigned long Offset)
846 {
847         long aps;
848         long BufSizeRequired;
849
850         if ((AppendBuf == NULL) || (Buf == NULL))
851                 return;
852
853         if (AppendSize < 0 )
854                 aps = strlen(AppendBuf + Offset);
855         else
856                 aps = AppendSize - Offset;
857
858         BufSizeRequired = Buf->BufUsed + aps + 1;
859         if (Buf->BufSize <= BufSizeRequired)
860                 IncreaseBuf(Buf, (Buf->BufUsed > 0), BufSizeRequired);
861
862         memcpy(Buf->buf + Buf->BufUsed, 
863                AppendBuf + Offset, 
864                aps);
865         Buf->BufUsed += aps;
866         Buf->buf[Buf->BufUsed] = '\0';
867 }
868
869 /**
870  * @ingroup StrBuf_Filler
871  * @brief sprintf like function appending the formated string to the buffer
872  * vsnprintf version to wrap into own calls
873  * @param Buf Buffer to extend by format and Params
874  * @param format printf alike format to add
875  * @param ap va_list containing the items for format
876  */
877 void StrBufVAppendPrintf(StrBuf *Buf, const char *format, va_list ap)
878 {
879         va_list apl;
880         size_t BufSize;
881         size_t nWritten;
882         size_t Offset;
883         size_t newused;
884
885         if ((Buf == NULL)  || (format == NULL))
886                 return;
887
888         BufSize = Buf->BufSize;
889         nWritten = Buf->BufSize + 1;
890         Offset = Buf->BufUsed;
891         newused = Offset + nWritten;
892         
893         while (newused >= BufSize) {
894                 va_copy(apl, ap);
895                 nWritten = vsnprintf(Buf->buf + Offset, 
896                                      Buf->BufSize - Offset, 
897                                      format, apl);
898                 va_end(apl);
899                 newused = Offset + nWritten;
900                 if (newused >= Buf->BufSize) {
901                         if (IncreaseBuf(Buf, 1, newused) == -1)
902                                 return; /* TODO: error handling? */
903                         newused = Buf->BufSize + 1;
904                 }
905                 else {
906                         Buf->BufUsed = Offset + nWritten;
907                         BufSize = Buf->BufSize;
908                 }
909
910         }
911 }
912
913 /**
914  * @ingroup StrBuf_Filler
915  * @brief sprintf like function appending the formated string to the buffer
916  * @param Buf Buffer to extend by format and Params
917  * @param format printf alike format to add
918  */
919 void StrBufAppendPrintf(StrBuf *Buf, const char *format, ...)
920 {
921         size_t BufSize;
922         size_t nWritten;
923         size_t Offset;
924         size_t newused;
925         va_list arg_ptr;
926         
927         if ((Buf == NULL)  || (format == NULL))
928                 return;
929
930         BufSize = Buf->BufSize;
931         nWritten = Buf->BufSize + 1;
932         Offset = Buf->BufUsed;
933         newused = Offset + nWritten;
934
935         while (newused >= BufSize) {
936                 va_start(arg_ptr, format);
937                 nWritten = vsnprintf(Buf->buf + Buf->BufUsed, 
938                                      Buf->BufSize - Buf->BufUsed, 
939                                      format, arg_ptr);
940                 va_end(arg_ptr);
941                 newused = Buf->BufUsed + nWritten;
942                 if (newused >= Buf->BufSize) {
943                         if (IncreaseBuf(Buf, 1, newused) == -1)
944                                 return; /* TODO: error handling? */
945                         newused = Buf->BufSize + 1;
946                 }
947                 else {
948                         Buf->BufUsed += nWritten;
949                         BufSize = Buf->BufSize;
950                 }
951
952         }
953 }
954
955 /**
956  * @ingroup StrBuf_Filler
957  * @brief sprintf like function putting the formated string into the buffer
958  * @param Buf Buffer to extend by format and Parameters
959  * @param format printf alike format to add
960  */
961 void StrBufPrintf(StrBuf *Buf, const char *format, ...)
962 {
963         size_t nWritten;
964         va_list arg_ptr;
965         
966         if ((Buf == NULL)  || (format == NULL))
967                 return;
968
969         nWritten = Buf->BufSize + 1;
970         while (nWritten >= Buf->BufSize) {
971                 va_start(arg_ptr, format);
972                 nWritten = vsnprintf(Buf->buf, Buf->BufSize, format, arg_ptr);
973                 va_end(arg_ptr);
974                 if (nWritten >= Buf->BufSize) {
975                         if (IncreaseBuf(Buf, 0, 0) == -1)
976                                 return; /* TODO: error handling? */
977                         nWritten = Buf->BufSize + 1;
978                         continue;
979                 }
980                 Buf->BufUsed = nWritten ;
981         }
982 }
983
984 /**
985  * @ingroup StrBuf_Filler
986  * @brief Callback for cURL to append the webserver reply to a buffer
987  * @param ptr pre-defined by the cURL API; see man 3 curl for mre info
988  * @param size pre-defined by the cURL API; see man 3 curl for mre info
989  * @param nmemb pre-defined by the cURL API; see man 3 curl for mre info
990  * @param stream pre-defined by the cURL API; see man 3 curl for mre info
991  */
992 size_t CurlFillStrBuf_callback(void *ptr, size_t size, size_t nmemb, void *stream)
993 {
994
995         StrBuf *Target;
996
997         Target = stream;
998         if (ptr == NULL)
999                 return 0;
1000
1001         StrBufAppendBufPlain(Target, ptr, size * nmemb, 0);
1002         return size * nmemb;
1003 }
1004
1005
1006 /**
1007  * @ingroup StrBuf
1008  * @brief extracts a substring from Source into dest
1009  * @param dest buffer to place substring into
1010  * @param Source string to copy substring from
1011  * @param Offset chars to skip from start
1012  * @param nChars number of chars to copy
1013  * @returns the number of chars copied; may be different from nChars due to the size of Source
1014  */
1015 int StrBufSub(StrBuf *dest, const StrBuf *Source, unsigned long Offset, size_t nChars)
1016 {
1017         size_t NCharsRemain;
1018         if (Offset > Source->BufUsed)
1019         {
1020                 if (dest != NULL)
1021                         FlushStrBuf(dest);
1022                 return 0;
1023         }
1024         if (Offset + nChars < Source->BufUsed)
1025         {
1026                 if (nChars >= dest->BufSize)
1027                         IncreaseBuf(dest, 0, nChars + 1);
1028                 memcpy(dest->buf, Source->buf + Offset, nChars);
1029                 dest->BufUsed = nChars;
1030                 dest->buf[dest->BufUsed] = '\0';
1031                 return nChars;
1032         }
1033         NCharsRemain = Source->BufUsed - Offset;
1034         if (NCharsRemain  >= dest->BufSize)
1035                 IncreaseBuf(dest, 0, NCharsRemain + 1);
1036         memcpy(dest->buf, Source->buf + Offset, NCharsRemain);
1037         dest->BufUsed = NCharsRemain;
1038         dest->buf[dest->BufUsed] = '\0';
1039         return NCharsRemain;
1040 }
1041
1042 /**
1043  * @ingroup StrBuf
1044  * @brief Cut nChars from the start of the string
1045  * @param Buf Buffer to modify
1046  * @param nChars how many chars should be skipped?
1047  */
1048 void StrBufCutLeft(StrBuf *Buf, int nChars)
1049 {
1050         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1051         if (nChars >= Buf->BufUsed) {
1052                 FlushStrBuf(Buf);
1053                 return;
1054         }
1055         memmove(Buf->buf, Buf->buf + nChars, Buf->BufUsed - nChars);
1056         Buf->BufUsed -= nChars;
1057         Buf->buf[Buf->BufUsed] = '\0';
1058 }
1059
1060 /**
1061  * @ingroup StrBuf
1062  * @brief Cut the trailing n Chars from the string
1063  * @param Buf Buffer to modify
1064  * @param nChars how many chars should be trunkated?
1065  */
1066 void StrBufCutRight(StrBuf *Buf, int nChars)
1067 {
1068         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1069         if (nChars >= Buf->BufUsed) {
1070                 FlushStrBuf(Buf);
1071                 return;
1072         }
1073         Buf->BufUsed -= nChars;
1074         Buf->buf[Buf->BufUsed] = '\0';
1075 }
1076
1077 /**
1078  * @ingroup StrBuf
1079  * @brief Cut the string after n Chars
1080  * @param Buf Buffer to modify
1081  * @param AfternChars after how many chars should we trunkate the string?
1082  * @param At if non-null and points inside of our string, cut it there.
1083  */
1084 void StrBufCutAt(StrBuf *Buf, int AfternChars, const char *At)
1085 {
1086         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1087         if (At != NULL){
1088                 AfternChars = At - Buf->buf;
1089         }
1090
1091         if ((AfternChars < 0) || (AfternChars >= Buf->BufUsed))
1092                 return;
1093         Buf->BufUsed = AfternChars;
1094         Buf->buf[Buf->BufUsed] = '\0';
1095 }
1096
1097
1098 /**
1099  * @ingroup StrBuf
1100  * @brief Strip leading and trailing spaces from a string; with premeasured and adjusted length.
1101  * @param Buf the string to modify
1102  */
1103 void StrBufTrim(StrBuf *Buf)
1104 {
1105         int delta = 0;
1106         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1107
1108         while ((Buf->BufUsed > 0) &&
1109                isspace(Buf->buf[Buf->BufUsed - 1]))
1110         {
1111                 Buf->BufUsed --;
1112         }
1113         Buf->buf[Buf->BufUsed] = '\0';
1114
1115         if (Buf->BufUsed == 0) return;
1116
1117         while ((Buf->BufUsed > delta) && (isspace(Buf->buf[delta]))){
1118                 delta ++;
1119         }
1120         if (delta > 0) StrBufCutLeft(Buf, delta);
1121 }
1122 /**
1123  * @ingroup StrBuf
1124  * @brief changes all spaces in the string  (tab, linefeed...) to Blank (0x20)
1125  * @param Buf the string to modify
1126  */
1127 void StrBufSpaceToBlank(StrBuf *Buf)
1128 {
1129         char *pche, *pch;
1130
1131         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1132
1133         pch = Buf->buf;
1134         pche = pch + Buf->BufUsed;
1135         while (pch < pche) 
1136         {
1137                 if (isspace(*pch))
1138                         *pch = ' ';
1139                 pch ++;
1140         }
1141 }
1142
1143 void StrBufStripAllBut(StrBuf *Buf, char leftboundary, char rightboundary)
1144 {
1145         const char *pBuff;
1146         const char *pLeft;
1147         const char *pRight;
1148
1149         if (Buf == NULL)
1150                 return;
1151         pLeft = pBuff = Buf->buf;
1152         while (pBuff != NULL) {
1153                 pLeft = pBuff;
1154                 pBuff = strchr(pBuff, leftboundary);
1155                 if (pBuff != NULL)
1156                         pBuff++;
1157         }
1158                 
1159         if (pLeft != NULL)
1160                 pBuff = pLeft;
1161         else
1162                 pBuff = Buf->buf;
1163         pRight = strchr(pBuff, rightboundary);
1164         if (pRight != NULL)
1165                 StrBufCutAt(Buf, 0, pRight);
1166         if (pLeft != NULL)
1167                 StrBufCutLeft(Buf, pLeft - Buf->buf);
1168 }
1169
1170
1171 /**
1172  * @ingroup StrBuf_Filler
1173  * @brief uppercase the contents of a buffer
1174  * @param Buf the buffer to translate
1175  */
1176 void StrBufUpCase(StrBuf *Buf) 
1177 {
1178         char *pch, *pche;
1179
1180         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1181
1182         pch = Buf->buf;
1183         pche = pch + Buf->BufUsed;
1184         while (pch < pche) {
1185                 *pch = toupper(*pch);
1186                 pch ++;
1187         }
1188 }
1189
1190
1191 /**
1192  * @ingroup StrBuf_Filler
1193  * @brief lowercase the contents of a buffer
1194  * @param Buf the buffer to translate
1195  */
1196 void StrBufLowerCase(StrBuf *Buf) 
1197 {
1198         char *pch, *pche;
1199
1200         if ((Buf == NULL) || (Buf->BufUsed == 0)) return;
1201
1202         pch = Buf->buf;
1203         pche = pch + Buf->BufUsed;
1204         while (pch < pche) {
1205                 *pch = tolower(*pch);
1206                 pch ++;
1207         }
1208 }
1209
1210
1211 /*******************************************************************************
1212  *           a tokenizer that kills, maims, and destroys                       *
1213  *******************************************************************************/
1214
1215 /**
1216  * @ingroup StrBuf_Tokenizer
1217  * @brief Replace a token at a given place with a given length by another token with given length
1218  * @param Buf String where to work on
1219  * @param where where inside of the Buf is the search-token
1220  * @param HowLong How long is the token to be replaced
1221  * @param Repl Token to insert at 'where'
1222  * @param ReplLen Length of repl
1223  * @returns -1 if fail else length of resulting Buf
1224  */
1225 int StrBufReplaceToken(StrBuf *Buf, long where, long HowLong, 
1226                        const char *Repl, long ReplLen)
1227 {
1228
1229         if ((Buf == NULL) || 
1230             (where > Buf->BufUsed) ||
1231             (where + HowLong > Buf->BufUsed))
1232                 return -1;
1233
1234         if (where + ReplLen - HowLong > Buf->BufSize)
1235                 if (IncreaseBuf(Buf, 1, Buf->BufUsed + ReplLen) < 0)
1236                         return -1;
1237
1238         memmove(Buf->buf + where + ReplLen, 
1239                 Buf->buf + where + HowLong,
1240                 Buf->BufUsed - where - HowLong);
1241                                                 
1242         memcpy(Buf->buf + where, 
1243                Repl, ReplLen);
1244
1245         Buf->BufUsed += ReplLen - HowLong;
1246
1247         return Buf->BufUsed;
1248 }
1249
1250 /**
1251  * @ingroup StrBuf_Tokenizer
1252  * @brief Counts the numbmer of tokens in a buffer
1253  * @param source String to count tokens in
1254  * @param tok    Tokenizer char to count
1255  * @returns numbers of tokenizer chars found
1256  */
1257 int StrBufNum_tokens(const StrBuf *source, char tok)
1258 {
1259         char *pch, *pche;
1260         long NTokens;
1261         if ((source == NULL) || (source->BufUsed == 0))
1262                 return 0;
1263         if ((source->BufUsed == 1) && (*source->buf == tok))
1264                 return 2;
1265         NTokens = 1;
1266         pch = source->buf;
1267         pche = pch + source->BufUsed;
1268         while (pch < pche)
1269         {
1270                 if (*pch == tok)
1271                         NTokens ++;
1272                 pch ++;
1273         }
1274         return NTokens;
1275 }
1276
1277 /**
1278  * @ingroup StrBuf_Tokenizer
1279  * @brief a string tokenizer
1280  * @param Source StringBuffer to read into
1281  * @param parmnum n'th Parameter to remove
1282  * @param separator tokenizer character
1283  * @returns -1 if not found, else length of token.
1284  */
1285 int StrBufRemove_token(StrBuf *Source, int parmnum, char separator)
1286 {
1287         int ReducedBy;
1288         char *d, *s, *end;              /* dest, source */
1289         int count = 0;
1290
1291         /* Find desired @parameter */
1292         end = Source->buf + Source->BufUsed;
1293         d = Source->buf;
1294         while ((d <= end) && 
1295                (count < parmnum))
1296         {
1297                 /* End of string, bail! */
1298                 if (!*d) {
1299                         d = NULL;
1300                         break;
1301                 }
1302                 if (*d == separator) {
1303                         count++;
1304                 }
1305                 d++;
1306         }
1307         if ((d == NULL) || (d >= end))
1308                 return 0;               /* @Parameter not found */
1309
1310         /* Find next @parameter */
1311         s = d;
1312         while ((s <= end) && 
1313                (*s && *s != separator))
1314         {
1315                 s++;
1316         }
1317         if (*s == separator)
1318                 s++;
1319         ReducedBy = d - s;
1320
1321         /* Hack and slash */
1322         if (s >= end) {
1323                 return 0;
1324         }
1325         else if (*s) {
1326                 memmove(d, s, Source->BufUsed - (s - Source->buf));
1327                 Source->BufUsed += ReducedBy;
1328                 Source->buf[Source->BufUsed] = '\0';
1329         }
1330         else if (d == Source->buf) {
1331                 *d = 0;
1332                 Source->BufUsed = 0;
1333         }
1334         else {
1335                 *--d = '\0';
1336                 Source->BufUsed += ReducedBy;
1337         }
1338         /*
1339         while (*s) {
1340                 *d++ = *s++;
1341         }
1342         *d = 0;
1343         */
1344         return ReducedBy;
1345 }
1346
1347
1348 /**
1349  * @ingroup StrBuf_Tokenizer
1350  * @brief a string tokenizer
1351  * @param dest Destination StringBuffer
1352  * @param Source StringBuffer to read into
1353  * @param parmnum n'th Parameter to extract
1354  * @param separator tokenizer character
1355  * @returns -1 if not found, else length of token.
1356  */
1357 int StrBufExtract_token(StrBuf *dest, const StrBuf *Source, int parmnum, char separator)
1358 {
1359         const char *s, *e;              //* source * /
1360         int len = 0;                    //* running total length of extracted string * /
1361         int current_token = 0;          //* token currently being processed * /
1362          
1363         if (dest != NULL) {
1364                 dest->buf[0] = '\0';
1365                 dest->BufUsed = 0;
1366         }
1367         else
1368                 return(-1);
1369
1370         if ((Source == NULL) || (Source->BufUsed ==0)) {
1371                 return(-1);
1372         }
1373         s = Source->buf;
1374         e = s + Source->BufUsed;
1375
1376         //cit_backtrace();
1377         //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
1378
1379         while ((s < e) && !IsEmptyStr(s)) {
1380                 if (*s == separator) {
1381                         ++current_token;
1382                 }
1383                 if (len >= dest->BufSize) {
1384                         dest->BufUsed = len;
1385                         if (IncreaseBuf(dest, 1, -1) < 0) {
1386                                 dest->BufUsed --;
1387                                 break;
1388                         }
1389                 }
1390                 if ( (current_token == parmnum) && 
1391                      (*s != separator)) {
1392                         dest->buf[len] = *s;
1393                         ++len;
1394                 }
1395                 else if (current_token > parmnum) {
1396                         break;
1397                 }
1398                 ++s;
1399         }
1400         
1401         dest->buf[len] = '\0';
1402         dest->BufUsed = len;
1403                 
1404         if (current_token < parmnum) {
1405                 //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
1406                 return(-1);
1407         }
1408         //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
1409         return(len);
1410 }
1411
1412
1413
1414
1415
1416 /**
1417  * @ingroup StrBuf_Tokenizer
1418  * @brief a string tokenizer to fetch an integer
1419  * @param Source String containing tokens
1420  * @param parmnum n'th Parameter to extract
1421  * @param separator tokenizer character
1422  * @returns 0 if not found, else integer representation of the token
1423  */
1424 int StrBufExtract_int(const StrBuf* Source, int parmnum, char separator)
1425 {
1426         StrBuf tmp;
1427         char buf[64];
1428         
1429         tmp.buf = buf;
1430         buf[0] = '\0';
1431         tmp.BufSize = 64;
1432         tmp.BufUsed = 0;
1433         tmp.ConstBuf = 1;
1434         if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0)
1435                 return(atoi(buf));
1436         else
1437                 return 0;
1438 }
1439
1440 /**
1441  * @ingroup StrBuf_Tokenizer
1442  * @brief a string tokenizer to fetch a long integer
1443  * @param Source String containing tokens
1444  * @param parmnum n'th Parameter to extract
1445  * @param separator tokenizer character
1446  * @returns 0 if not found, else long integer representation of the token
1447  */
1448 long StrBufExtract_long(const StrBuf* Source, int parmnum, char separator)
1449 {
1450         StrBuf tmp;
1451         char buf[64];
1452         
1453         tmp.buf = buf;
1454         buf[0] = '\0';
1455         tmp.BufSize = 64;
1456         tmp.BufUsed = 0;
1457         tmp.ConstBuf = 1;
1458         if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0)
1459                 return(atoi(buf));
1460         else
1461                 return 0;
1462 }
1463
1464
1465 /**
1466  * @ingroup StrBuf_Tokenizer
1467  * @brief a string tokenizer to fetch an unsigned long
1468  * @param Source String containing tokens
1469  * @param parmnum n'th Parameter to extract
1470  * @param separator tokenizer character
1471  * @returns 0 if not found, else unsigned long representation of the token
1472  */
1473 unsigned long StrBufExtract_unsigned_long(const StrBuf* Source, int parmnum, char separator)
1474 {
1475         StrBuf tmp;
1476         char buf[64];
1477         char *pnum;
1478         
1479         tmp.buf = buf;
1480         buf[0] = '\0';
1481         tmp.BufSize = 64;
1482         tmp.BufUsed = 0;
1483         tmp.ConstBuf = 1;
1484         if (StrBufExtract_token(&tmp, Source, parmnum, separator) > 0) {
1485                 pnum = &buf[0];
1486                 if (*pnum == '-')
1487                         pnum ++;
1488                 return (unsigned long) atol(pnum);
1489         }
1490         else 
1491                 return 0;
1492 }
1493
1494
1495
1496 /**
1497  * @ingroup StrBuf_NextTokenizer
1498  * @brief a string tokenizer; Bounds checker
1499  *  function to make shure whether StrBufExtract_NextToken and friends have reached the end of the string.
1500  * @param Source our tokenbuffer
1501  * @param pStart the token iterator pointer to inspect
1502  * @returns whether the revolving pointer is inside of the search range
1503  */
1504 int StrBufHaveNextToken(const StrBuf *Source, const char **pStart)
1505 {
1506         if ((Source == NULL) || 
1507             (*pStart == StrBufNOTNULL) ||
1508             (Source->BufUsed == 0))
1509         {
1510                 return 0;
1511         }
1512         if (*pStart == NULL)
1513         {
1514                 return 1;
1515         }
1516         else if (*pStart > Source->buf + Source->BufUsed)
1517         {
1518                 return 0;
1519         }
1520         else if (*pStart <= Source->buf)
1521         {
1522                 return 0;
1523         }
1524
1525         return 1;
1526 }
1527
1528 /**
1529  * @ingroup StrBuf_NextTokenizer
1530  * @brief a string tokenizer
1531  * @param dest Destination StringBuffer
1532  * @param Source StringBuffer to read into
1533  * @param pStart pointer to the end of the last token. Feed with NULL on start.
1534  * @param separator tokenizer 
1535  * @returns -1 if not found, else length of token.
1536  */
1537 int StrBufExtract_NextToken(StrBuf *dest, const StrBuf *Source, const char **pStart, char separator)
1538 {
1539         const char *s;          /* source */
1540         const char *EndBuffer;  /* end stop of source buffer */
1541         int current_token = 0;  /* token currently being processed */
1542         int len = 0;            /* running total length of extracted string */
1543
1544         if ((Source          == NULL) || 
1545             (Source->BufUsed == 0)      ) 
1546         {
1547                 *pStart = StrBufNOTNULL;
1548                 if (dest != NULL)
1549                         FlushStrBuf(dest);
1550                 return -1;
1551         }
1552          
1553         EndBuffer = Source->buf + Source->BufUsed;
1554
1555         if (dest != NULL) 
1556         {
1557                 dest->buf[0] = '\0';
1558                 dest->BufUsed = 0;
1559         }
1560         else
1561         {
1562                 *pStart = EndBuffer + 1;
1563                 return -1;
1564         }
1565
1566         if (*pStart == NULL)
1567         {
1568                 *pStart = Source->buf; /* we're starting to examine this buffer. */
1569         }
1570         else if ((*pStart < Source->buf) || 
1571                  (*pStart > EndBuffer  )   ) 
1572         {
1573                 return -1; /* no more tokens to find. */
1574         }
1575
1576         s = *pStart;
1577         /* start to find the next token */
1578         while ((s <= EndBuffer)      && 
1579                (current_token == 0) ) 
1580         {
1581                 if (*s == separator) 
1582                 {
1583                         /* we found the next token */
1584                         ++current_token;
1585                 }
1586
1587                 if (len >= dest->BufSize) 
1588                 {
1589                         /* our Dest-buffer isn't big enough, increase it. */
1590                         dest->BufUsed = len;
1591
1592                         if (IncreaseBuf(dest, 1, -1) < 0) {
1593                                 /* WHUT? no more mem? bail out. */
1594                                 s = EndBuffer;
1595                                 dest->BufUsed --;
1596                                 break;
1597                         }
1598                 }
1599
1600                 if ( (current_token == 0 ) &&   /* are we in our target token? */
1601                      (!IsEmptyStr(s)     ) &&
1602                      (separator     != *s)    ) /* don't copy the token itself */
1603                 {
1604                         dest->buf[len] = *s;    /* Copy the payload */
1605                         ++len;                  /* remember the bigger size. */
1606                 }
1607
1608                 ++s;
1609         }
1610
1611         /* did we reach the end? */
1612         if ((s > EndBuffer)) {
1613                 EndBuffer = StrBufNOTNULL;
1614                 *pStart = EndBuffer;
1615         }
1616         else {
1617                 *pStart = s;  /* remember the position for the next run */
1618         }
1619
1620         /* sanitize our extracted token */
1621         dest->buf[len] = '\0';
1622         dest->BufUsed  = len;
1623
1624         return (len);
1625 }
1626
1627
1628 /**
1629  * @ingroup StrBuf_NextTokenizer
1630  * @brief a string tokenizer
1631  * @param Source StringBuffer to read from
1632  * @param pStart pointer to the end of the last token. Feed with NULL.
1633  * @param separator tokenizer character
1634  * @param nTokens number of tokens to fastforward over
1635  * @returns -1 if not found, else length of token.
1636  */
1637 int StrBufSkip_NTokenS(const StrBuf *Source, const char **pStart, char separator, int nTokens)
1638 {
1639         const char *s, *EndBuffer;      //* source * /
1640         int len = 0;                    //* running total length of extracted string * /
1641         int current_token = 0;          //* token currently being processed * /
1642
1643         if ((Source == NULL) || 
1644             (Source->BufUsed ==0)) {
1645                 return(-1);
1646         }
1647         if (nTokens == 0)
1648                 return Source->BufUsed;
1649
1650         if (*pStart == NULL)
1651                 *pStart = Source->buf;
1652
1653         EndBuffer = Source->buf + Source->BufUsed;
1654
1655         if ((*pStart < Source->buf) || 
1656             (*pStart >  EndBuffer)) {
1657                 return (-1);
1658         }
1659
1660
1661         s = *pStart;
1662
1663         //cit_backtrace();
1664         //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
1665
1666         while ((s < EndBuffer) && !IsEmptyStr(s)) {
1667                 if (*s == separator) {
1668                         ++current_token;
1669                 }
1670                 if (current_token >= nTokens) {
1671                         break;
1672                 }
1673                 ++s;
1674         }
1675         *pStart = s;
1676         (*pStart) ++;
1677
1678         return(len);
1679 }
1680
1681 /**
1682  * @ingroup StrBuf_NextTokenizer
1683  * @brief a string tokenizer to fetch an integer
1684  * @param Source StringBuffer to read from
1685  * @param pStart Cursor on the tokenstring
1686  * @param separator tokenizer character
1687  * @returns 0 if not found, else integer representation of the token
1688  */
1689 int StrBufExtractNext_int(const StrBuf* Source, const char **pStart, char separator)
1690 {
1691         StrBuf tmp;
1692         char buf[64];
1693         
1694         tmp.buf = buf;
1695         buf[0] = '\0';
1696         tmp.BufSize = 64;
1697         tmp.BufUsed = 0;
1698         tmp.ConstBuf = 1;
1699         if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0)
1700                 return(atoi(buf));
1701         else
1702                 return 0;
1703 }
1704
1705 /**
1706  * @ingroup StrBuf_NextTokenizer
1707  * @brief a string tokenizer to fetch a long integer
1708  * @param Source StringBuffer to read from
1709  * @param pStart Cursor on the tokenstring
1710  * @param separator tokenizer character
1711  * @returns 0 if not found, else long integer representation of the token
1712  */
1713 long StrBufExtractNext_long(const StrBuf* Source, const char **pStart, char separator)
1714 {
1715         StrBuf tmp;
1716         char buf[64];
1717         
1718         tmp.buf = buf;
1719         buf[0] = '\0';
1720         tmp.BufSize = 64;
1721         tmp.BufUsed = 0;
1722         tmp.ConstBuf = 1;
1723         if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0)
1724                 return(atoi(buf));
1725         else
1726                 return 0;
1727 }
1728
1729
1730 /**
1731  * @ingroup StrBuf_NextTokenizer
1732  * @brief a string tokenizer to fetch an unsigned long
1733  * @param Source StringBuffer to read from
1734  * @param pStart Cursor on the tokenstring
1735  * @param separator tokenizer character
1736  * @returns 0 if not found, else unsigned long representation of the token
1737  */
1738 unsigned long StrBufExtractNext_unsigned_long(const StrBuf* Source, const char **pStart, char separator)
1739 {
1740         StrBuf tmp;
1741         char buf[64];
1742         char *pnum;
1743         
1744         tmp.buf = buf;
1745         buf[0] = '\0';
1746         tmp.BufSize = 64;
1747         tmp.BufUsed = 0;
1748         tmp.ConstBuf = 1;
1749         if (StrBufExtract_NextToken(&tmp, Source, pStart, separator) > 0) {
1750                 pnum = &buf[0];
1751                 if (*pnum == '-')
1752                         pnum ++;
1753                 return (unsigned long) atol(pnum);
1754         }
1755         else 
1756                 return 0;
1757 }
1758
1759
1760
1761
1762
1763 /*******************************************************************************
1764  *                             Escape Appending                                *
1765  *******************************************************************************/
1766
1767 /** 
1768  * @ingroup StrBuf_DeEnCoder
1769  * @brief Escape a string for feeding out as a URL while appending it to a Buffer
1770  * @param OutBuf the output buffer
1771  * @param In Buffer to encode
1772  * @param PlainIn way in from plain old c strings
1773  */
1774 void StrBufUrlescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn)
1775 {
1776         const char *pch, *pche;
1777         char *pt, *pte;
1778         int len;
1779         
1780         if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
1781                 return;
1782         if (PlainIn != NULL) {
1783                 len = strlen(PlainIn);
1784                 pch = PlainIn;
1785                 pche = pch + len;
1786         }
1787         else {
1788                 pch = In->buf;
1789                 pche = pch + In->BufUsed;
1790                 len = In->BufUsed;
1791         }
1792
1793         if (len == 0) 
1794                 return;
1795
1796         pt = OutBuf->buf + OutBuf->BufUsed;
1797         pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */
1798
1799         while (pch < pche) {
1800                 if (pt >= pte) {
1801                         IncreaseBuf(OutBuf, 1, -1);
1802                         pte = OutBuf->buf + OutBuf->BufSize - 4; /**< we max append 3 chars at once plus the \0 */
1803                         pt = OutBuf->buf + OutBuf->BufUsed;
1804                 }
1805
1806                 if((*pch >= 'a' && *pch <= 'z') ||
1807                    (*pch >= '@' && *pch <= 'Z') || /* @ A-Z */
1808                    (*pch >= '0' && *pch <= ':') || /* 0-9 : */
1809                    (*pch == '!') || (*pch == '_') || 
1810                    (*pch == ',') || (*pch == '.'))
1811                 {
1812                         *(pt++) = *(pch++);
1813                         OutBuf->BufUsed++;
1814                 }                       
1815                 else {
1816                         *pt = '%';
1817                         *(pt + 1) = HexList[(unsigned char)*pch][0];
1818                         *(pt + 2) = HexList[(unsigned char)*pch][1];
1819                         pt += 3;
1820                         OutBuf->BufUsed += 3;
1821                         pch ++;
1822                 }
1823         }
1824         *pt = '\0';
1825 }
1826
1827 /** 
1828  * @ingroup StrBuf_DeEnCoder
1829  * @brief append a string in hex encoding to the buffer
1830  * @param OutBuf the output buffer
1831  * @param In Buffer to encode
1832  * @param PlainIn way in from plain old c strings
1833  * @param PlainInLen way in from plain old c strings; maybe you've got binary data or know the length?
1834  */
1835 void StrBufHexEscAppend(StrBuf *OutBuf, const StrBuf *In, const unsigned char *PlainIn, long PlainInLen)
1836 {
1837         const unsigned char *pch, *pche;
1838         char *pt, *pte;
1839         int len;
1840         
1841         if (((In == NULL) && (PlainIn == NULL)) || (OutBuf == NULL) )
1842                 return;
1843         if (PlainIn != NULL) {
1844                 if (PlainInLen < 0)
1845                         len = strlen((const char*)PlainIn);
1846                 else
1847                         len = PlainInLen;
1848                 pch = PlainIn;
1849                 pche = pch + len;
1850         }
1851         else {
1852                 pch = (const unsigned char*)In->buf;
1853                 pche = pch + In->BufUsed;
1854                 len = In->BufUsed;
1855         }
1856
1857         if (len == 0) 
1858                 return;
1859
1860         pt = OutBuf->buf + OutBuf->BufUsed;
1861         pte = OutBuf->buf + OutBuf->BufSize - 3; /**< we max append 3 chars at once plus the \0 */
1862
1863         while (pch < pche) {
1864                 if (pt >= pte) {
1865                         IncreaseBuf(OutBuf, 1, -1);
1866                         pte = OutBuf->buf + OutBuf->BufSize - 3; /**< we max append 3 chars at once plus the \0 */
1867                         pt = OutBuf->buf + OutBuf->BufUsed;
1868                 }
1869
1870                 *pt = HexList[*pch][0];
1871                 pt ++;
1872                 *pt = HexList[*pch][1];
1873                 pt ++; pch ++; OutBuf->BufUsed += 2;
1874         }
1875         *pt = '\0';
1876 }
1877
1878 /** 
1879  * @ingroup StrBuf_DeEnCoder
1880  * @brief append a string in hex encoding to the buffer
1881  * @param OutBuf the output buffer
1882  * @param In Buffer to encode
1883  * @param PlainIn way in from plain old c strings
1884  */
1885 void StrBufHexescAppend(StrBuf *OutBuf, const StrBuf *In, const char *PlainIn)
1886 {
1887         StrBufHexEscAppend(OutBuf, In, (const unsigned char*) PlainIn, -1);
1888 }
1889
1890 /**
1891  * @ingroup StrBuf_DeEnCoder
1892  * @brief Append a string, escaping characters which have meaning in HTML.  
1893  *
1894  * @param Target        target buffer
1895  * @param Source        source buffer; set to NULL if you just have a C-String
1896  * @param PlainIn       Plain-C string to append; set to NULL if unused
1897  * @param nbsp          If nonzero, spaces are converted to non-breaking spaces.
1898  * @param nolinebreaks  if set to 1, linebreaks are removed from the string.
1899  *                      if set to 2, linebreaks are replaced by &ltbr/&gt
1900  */
1901 long StrEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks)
1902 {
1903         const char *aptr, *eiptr;
1904         char *bptr, *eptr;
1905         long len;
1906
1907         if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
1908                 return -1;
1909
1910         if (PlainIn != NULL) {
1911                 aptr = PlainIn;
1912                 len = strlen(PlainIn);
1913                 eiptr = aptr + len;
1914         }
1915         else {
1916                 aptr = Source->buf;
1917                 eiptr = aptr + Source->BufUsed;
1918                 len = Source->BufUsed;
1919         }
1920
1921         if (len == 0) 
1922                 return -1;
1923
1924         bptr = Target->buf + Target->BufUsed;
1925         eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in...  */
1926
1927         while (aptr < eiptr){
1928                 if(bptr >= eptr) {
1929                         IncreaseBuf(Target, 1, -1);
1930                         eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in...  */
1931                         bptr = Target->buf + Target->BufUsed;
1932                 }
1933                 if (*aptr == '<') {
1934                         memcpy(bptr, "&lt;", 4);
1935                         bptr += 4;
1936                         Target->BufUsed += 4;
1937                 }
1938                 else if (*aptr == '>') {
1939                         memcpy(bptr, "&gt;", 4);
1940                         bptr += 4;
1941                         Target->BufUsed += 4;
1942                 }
1943                 else if (*aptr == '&') {
1944                         memcpy(bptr, "&amp;", 5);
1945                         bptr += 5;
1946                         Target->BufUsed += 5;
1947                 }
1948                 else if (*aptr == '"') {
1949                         memcpy(bptr, "&quot;", 6);
1950                         bptr += 6;
1951                         Target->BufUsed += 6;
1952                 }
1953                 else if (*aptr == '\'') {
1954                         memcpy(bptr, "&#39;", 5);
1955                         bptr += 5;
1956                         Target->BufUsed += 5;
1957                 }
1958                 else if (*aptr == LB) {
1959                         *bptr = '<';
1960                         bptr ++;
1961                         Target->BufUsed ++;
1962                 }
1963                 else if (*aptr == RB) {
1964                         *bptr = '>';
1965                         bptr ++;
1966                         Target->BufUsed ++;
1967                 }
1968                 else if (*aptr == QU) {
1969                         *bptr ='"';
1970                         bptr ++;
1971                         Target->BufUsed ++;
1972                 }
1973                 else if ((*aptr == 32) && (nbsp == 1)) {
1974                         memcpy(bptr, "&nbsp;", 6);
1975                         bptr += 6;
1976                         Target->BufUsed += 6;
1977                 }
1978                 else if ((*aptr == '\n') && (nolinebreaks == 1)) {
1979                         *bptr='\0';     /* nothing */
1980                 }
1981                 else if ((*aptr == '\n') && (nolinebreaks == 2)) {
1982                         memcpy(bptr, "&lt;br/&gt;", 11);
1983                         bptr += 11;
1984                         Target->BufUsed += 11;
1985                 }
1986
1987
1988                 else if ((*aptr == '\r') && (nolinebreaks != 0)) {
1989                         *bptr='\0';     /* nothing */
1990                 }
1991                 else{
1992                         *bptr = *aptr;
1993                         bptr++;
1994                         Target->BufUsed ++;
1995                 }
1996                 aptr ++;
1997         }
1998         *bptr = '\0';
1999         if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
2000                 return -1;
2001         return Target->BufUsed;
2002 }
2003
2004 /**
2005  * @ingroup StrBuf_DeEnCoder
2006  * @brief Append a string, escaping characters which have meaning in HTML.  
2007  * Converts linebreaks into blanks; escapes single quotes
2008  * @param Target        target buffer
2009  * @param Source        source buffer; set to NULL if you just have a C-String
2010  * @param PlainIn       Plain-C string to append; set to NULL if unused
2011  */
2012 void StrMsgEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
2013 {
2014         const char *aptr, *eiptr;
2015         char *tptr, *eptr;
2016         long len;
2017
2018         if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
2019                 return ;
2020
2021         if (PlainIn != NULL) {
2022                 aptr = PlainIn;
2023                 len = strlen(PlainIn);
2024                 eiptr = aptr + len;
2025         }
2026         else {
2027                 aptr = Source->buf;
2028                 eiptr = aptr + Source->BufUsed;
2029                 len = Source->BufUsed;
2030         }
2031
2032         if (len == 0) 
2033                 return;
2034
2035         eptr = Target->buf + Target->BufSize - 8; 
2036         tptr = Target->buf + Target->BufUsed;
2037         
2038         while (aptr < eiptr){
2039                 if(tptr >= eptr) {
2040                         IncreaseBuf(Target, 1, -1);
2041                         eptr = Target->buf + Target->BufSize - 8; 
2042                         tptr = Target->buf + Target->BufUsed;
2043                 }
2044                
2045                 if (*aptr == '\n') {
2046                         *tptr = ' ';
2047                         Target->BufUsed++;
2048                 }
2049                 else if (*aptr == '\r') {
2050                         *tptr = ' ';
2051                         Target->BufUsed++;
2052                 }
2053                 else if (*aptr == '\'') {
2054                         *(tptr++) = '&';
2055                         *(tptr++) = '#';
2056                         *(tptr++) = '3';
2057                         *(tptr++) = '9';
2058                         *tptr = ';';
2059                         Target->BufUsed += 5;
2060                 } else {
2061                         *tptr = *aptr;
2062                         Target->BufUsed++;
2063                 }
2064                 tptr++; aptr++;
2065         }
2066         *tptr = '\0';
2067 }
2068
2069
2070
2071 /**
2072  * @ingroup StrBuf_DeEnCoder
2073  * @brief Append a string, escaping characters which have meaning in ICAL.  
2074  * [\n,] 
2075  * @param Target        target buffer
2076  * @param Source        source buffer; set to NULL if you just have a C-String
2077  * @param PlainIn       Plain-C string to append; set to NULL if unused
2078  */
2079 void StrIcalEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
2080 {
2081         const char *aptr, *eiptr;
2082         char *tptr, *eptr;
2083         long len;
2084
2085         if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
2086                 return ;
2087
2088         if (PlainIn != NULL) {
2089                 aptr = PlainIn;
2090                 len = strlen(PlainIn);
2091                 eiptr = aptr + len;
2092         }
2093         else {
2094                 aptr = Source->buf;
2095                 eiptr = aptr + Source->BufUsed;
2096                 len = Source->BufUsed;
2097         }
2098
2099         if (len == 0) 
2100                 return;
2101
2102         eptr = Target->buf + Target->BufSize - 8; 
2103         tptr = Target->buf + Target->BufUsed;
2104         
2105         while (aptr < eiptr){
2106                 if(tptr + 3 >= eptr) {
2107                         IncreaseBuf(Target, 1, -1);
2108                         eptr = Target->buf + Target->BufSize - 8; 
2109                         tptr = Target->buf + Target->BufUsed;
2110                 }
2111                
2112                 if (*aptr == '\n') {
2113                         *tptr = '\\';
2114                         Target->BufUsed++;
2115                         tptr++;
2116                         *tptr = 'n';
2117                         Target->BufUsed++;
2118                 }
2119                 else if (*aptr == '\r') {
2120                         *tptr = '\\';
2121                         Target->BufUsed++;
2122                         tptr++;
2123                         *tptr = 'r';
2124                         Target->BufUsed++;
2125                 }
2126                 else if (*aptr == ',') {
2127                         *tptr = '\\';
2128                         Target->BufUsed++;
2129                         tptr++;
2130                         *tptr = ',';
2131                         Target->BufUsed++;
2132                 } else {
2133                         *tptr = *aptr;
2134                         Target->BufUsed++;
2135                 }
2136                 tptr++; aptr++;
2137         }
2138         *tptr = '\0';
2139 }
2140
2141 /**
2142  * @ingroup StrBuf_DeEnCoder
2143  * @brief Append a string, escaping characters which have meaning in JavaScript strings .  
2144  *
2145  * @param Target        target buffer
2146  * @param Source        source buffer; set to NULL if you just have a C-String
2147  * @param PlainIn       Plain-C string to append; set to NULL if unused
2148  * @returns size of result or -1
2149  */
2150 long StrECMAEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn)
2151 {
2152         const char *aptr, *eiptr;
2153         char *bptr, *eptr;
2154         long len;
2155         int IsUtf8Sequence;
2156
2157         if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
2158                 return -1;
2159
2160         if (PlainIn != NULL) {
2161                 aptr = PlainIn;
2162                 len = strlen(PlainIn);
2163                 eiptr = aptr + len;
2164         }
2165         else {
2166                 aptr = Source->buf;
2167                 eiptr = aptr + Source->BufUsed;
2168                 len = Source->BufUsed;
2169         }
2170
2171         if (len == 0) 
2172                 return -1;
2173
2174         bptr = Target->buf + Target->BufUsed;
2175         eptr = Target->buf + Target->BufSize - 7; /* our biggest unit to put in...  */
2176
2177         while (aptr < eiptr){
2178                 if(bptr >= eptr) {
2179                         IncreaseBuf(Target, 1, -1);
2180                         eptr = Target->buf + Target->BufSize - 7; /* our biggest unit to put in...  */
2181                         bptr = Target->buf + Target->BufUsed;
2182                 }
2183                 switch (*aptr) {
2184                 case '\n':
2185                         memcpy(bptr, HKEY("\\n"));
2186                         bptr += 2;
2187                         Target->BufUsed += 2;                           
2188                         break;
2189                 case '\r':
2190                         memcpy(bptr, HKEY("\\r"));
2191                         bptr += 2;
2192                         Target->BufUsed += 2;
2193                         break;
2194                 case '"':
2195                         *bptr = '\\';
2196                         bptr ++;
2197                         *bptr = '"';
2198                         bptr ++;
2199                         Target->BufUsed += 2;
2200                         break;
2201                 case '\\':
2202                         if ((*(aptr + 1) == 'u') &&
2203                             isxdigit(*(aptr + 2)) &&
2204                             isxdigit(*(aptr + 3)) &&
2205                             isxdigit(*(aptr + 4)) &&
2206                             isxdigit(*(aptr + 5)))
2207                         { /* oh, a unicode escaper. let it pass through. */
2208                                 memcpy(bptr, aptr, 6);
2209                                 aptr += 5;
2210                                 bptr +=6;
2211                                 Target->BufUsed += 6;
2212                         }
2213                         else 
2214                         {
2215                                 *bptr = '\\';
2216                                 bptr ++;
2217                                 *bptr = '\\';
2218                                 bptr ++;
2219                                 Target->BufUsed += 2;
2220                         }
2221                         break;
2222                 case '\b':
2223                         *bptr = '\\';
2224                         bptr ++;
2225                         *bptr = 'b';
2226                         bptr ++;
2227                         Target->BufUsed += 2;
2228                         break;
2229                 case '\f':
2230                         *bptr = '\\';
2231                         bptr ++;
2232                         *bptr = 'f';
2233                         bptr ++;
2234                         Target->BufUsed += 2;
2235                         break;
2236                 case '\t':
2237                         *bptr = '\\';
2238                         bptr ++;
2239                         *bptr = 't';
2240                         bptr ++;
2241                         Target->BufUsed += 2;
2242                         break;
2243                 default:
2244                         IsUtf8Sequence =  Ctdl_GetUtf8SequenceLength(aptr, eiptr);
2245                         while (IsUtf8Sequence > 0){
2246                                 *bptr = *aptr;
2247                                 Target->BufUsed ++;
2248                                 if (--IsUtf8Sequence)
2249                                         aptr++;
2250                                 bptr++;
2251                         }
2252                 }
2253                 aptr ++;
2254         }
2255         *bptr = '\0';
2256         if ((bptr == eptr - 1 ) && !IsEmptyStr(aptr) )
2257                 return -1;
2258         return Target->BufUsed;
2259 }
2260
2261 /**
2262  * @ingroup StrBuf_DeEnCoder
2263  * @brief Append a string, escaping characters which have meaning in HTML + json.  
2264  *
2265  * @param Target        target buffer
2266  * @param Source        source buffer; set to NULL if you just have a C-String
2267  * @param PlainIn       Plain-C string to append; set to NULL if unused
2268  * @param nbsp          If nonzero, spaces are converted to non-breaking spaces.
2269  * @param nolinebreaks  if set to 1, linebreaks are removed from the string.
2270  *                      if set to 2, linebreaks are replaced by &ltbr/&gt
2271  */
2272 long StrHtmlEcmaEscAppend(StrBuf *Target, const StrBuf *Source, const char *PlainIn, int nbsp, int nolinebreaks)
2273 {
2274         const char *aptr, *eiptr;
2275         char *bptr, *eptr;
2276         long len;
2277         int IsUtf8Sequence = 0;
2278
2279         if (((Source == NULL) && (PlainIn == NULL)) || (Target == NULL) )
2280                 return -1;
2281
2282         if (PlainIn != NULL) {
2283                 aptr = PlainIn;
2284                 len = strlen(PlainIn);
2285                 eiptr = aptr + len;
2286         }
2287         else {
2288                 aptr = Source->buf;
2289                 eiptr = aptr + Source->BufUsed;
2290                 len = Source->BufUsed;
2291         }
2292
2293         if (len == 0) 
2294                 return -1;
2295
2296         bptr = Target->buf + Target->BufUsed;
2297         eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in...  */
2298
2299         while (aptr < eiptr){
2300                 if(bptr >= eptr) {
2301                         IncreaseBuf(Target, 1, -1);
2302                         eptr = Target->buf + Target->BufSize - 11; /* our biggest unit to put in...  */
2303                         bptr = Target->buf + Target->BufUsed;
2304                 }
2305                 switch (*aptr) {
2306                 case '<':
2307                         memcpy(bptr, HKEY("&lt;"));
2308                         bptr += 4;
2309                         Target->BufUsed += 4;
2310                         break;
2311                 case '>':
2312                         memcpy(bptr, HKEY("&gt;"));
2313                         bptr += 4;
2314                         Target->BufUsed += 4;
2315                         break;
2316                 case '&':
2317                         memcpy(bptr, HKEY("&amp;"));
2318                         bptr += 5;
2319                         Target->BufUsed += 5;
2320                         break;
2321                 case LB:
2322                         *bptr = '<';
2323                         bptr ++;
2324                         Target->BufUsed ++;
2325                         break;
2326                 case RB:
2327                         *bptr = '>';
2328                         bptr ++;
2329                         Target->BufUsed ++;
2330                         break;
2331                 case '\n':
2332                         switch (nolinebreaks) {
2333                         case 1:
2334                                 *bptr='\0';     /* nothing */
2335                                 break;
2336                         case 2:
2337                                 memcpy(bptr, HKEY("&lt;br/&gt;"));
2338                                 bptr += 11;
2339                                 Target->BufUsed += 11;
2340                                 break;
2341                         default:
2342                                 memcpy(bptr, HKEY("\\n"));
2343                                 bptr += 2;
2344                                 Target->BufUsed += 2;                           
2345                         }
2346                         break;
2347                 case '\r':
2348                         switch (nolinebreaks) {
2349                         case 1:
2350                         case 2:
2351                                 *bptr='\0';     /* nothing */
2352                                 break;
2353                         default:
2354                                 memcpy(bptr, HKEY("\\r"));
2355                                 bptr += 2;
2356                                 Target->BufUsed += 2;
2357                                 break;
2358                         }
2359                         break;
2360                 case '"':
2361                 case QU:
2362                         *bptr = '\\';
2363                         bptr ++;
2364                         *bptr = '"';
2365                         bptr ++;
2366                         Target->BufUsed += 2;
2367                         break;
2368                 case '\\':
2369                         if ((*(aptr + 1) == 'u') &&
2370                             isxdigit(*(aptr + 2)) &&
2371                             isxdigit(*(aptr + 3)) &&
2372                             isxdigit(*(aptr + 4)) &&
2373                             isxdigit(*(aptr + 5)))
2374                         { /* oh, a unicode escaper. let it pass through. */
2375                                 memcpy(bptr, aptr, 6);
2376                                 aptr += 5;
2377                                 bptr +=6;
2378                                 Target->BufUsed += 6;
2379                         }
2380                         else 
2381                         {
2382                                 *bptr = '\\';
2383                                 bptr ++;
2384                                 *bptr = '\\';
2385                                 bptr ++;
2386                                 Target->BufUsed += 2;
2387                         }
2388                         break;
2389                 case '\b':
2390                         *bptr = '\\';
2391                         bptr ++;
2392                         *bptr = 'b';
2393                         bptr ++;
2394                         Target->BufUsed += 2;
2395                         break;
2396                 case '\f':
2397                         *bptr = '\\';
2398                         bptr ++;
2399                         *bptr = 'f';
2400                         bptr ++;
2401                         Target->BufUsed += 2;
2402                         break;
2403                 case '\t':
2404                         *bptr = '\\';
2405                         bptr ++;
2406                         *bptr = 't';
2407                         bptr ++;
2408                         Target->BufUsed += 2;
2409                         break;
2410                 case  32:
2411                         if (nbsp == 1) {
2412                                 memcpy(bptr, HKEY("&nbsp;"));
2413                                 bptr += 6;
2414                                 Target->BufUsed += 6;
2415                                 break;
2416                         }
2417                 default:
2418                         IsUtf8Sequence =  Ctdl_GetUtf8SequenceLength(aptr, eiptr);
2419                         while (IsUtf8Sequence > 0){
2420                                 *bptr = *aptr;
2421                                 Target->BufUsed ++;
2422                                 if (--IsUtf8Sequence)
2423                                         aptr++;
2424                                 bptr++;
2425                         }
2426                 }
2427                 aptr ++;
2428         }
2429         *bptr = '\0';
2430         if ((bptr = eptr - 1 ) && !IsEmptyStr(aptr) )
2431                 return -1;
2432         return Target->BufUsed;
2433 }
2434
2435 /**
2436  * @ingroup StrBuf_DeEnCoder
2437  * @brief unhide special chars hidden to the HTML escaper
2438  * @param target buffer to put the unescaped string in
2439  * @param source buffer to unescape
2440  */
2441 void StrBufEUid_unescapize(StrBuf *target, const StrBuf *source) 
2442 {
2443         int a, b, len;
2444         char hex[3];
2445
2446         if (target != NULL)
2447                 FlushStrBuf(target);
2448
2449         if (source == NULL ||target == NULL)
2450         {
2451                 return;
2452         }
2453
2454         len = source->BufUsed;
2455         for (a = 0; a < len; ++a) {
2456                 if (target->BufUsed >= target->BufSize)
2457                         IncreaseBuf(target, 1, -1);
2458
2459                 if (source->buf[a] == '=') {
2460                         hex[0] = source->buf[a + 1];
2461                         hex[1] = source->buf[a + 2];
2462                         hex[2] = 0;
2463                         b = 0;
2464                         sscanf(hex, "%02x", &b);
2465                         target->buf[target->BufUsed] = b;
2466                         target->buf[++target->BufUsed] = 0;
2467                         a += 2;
2468                 }
2469                 else {
2470                         target->buf[target->BufUsed] = source->buf[a];
2471                         target->buf[++target->BufUsed] = 0;
2472                 }
2473         }
2474 }
2475
2476
2477 /**
2478  * @ingroup StrBuf_DeEnCoder
2479  * @brief hide special chars from the HTML escapers and friends
2480  * @param target buffer to put the escaped string in
2481  * @param source buffer to escape
2482  */
2483 void StrBufEUid_escapize(StrBuf *target, const StrBuf *source) 
2484 {
2485         int i, len;
2486
2487         if (target != NULL)
2488                 FlushStrBuf(target);
2489
2490         if (source == NULL ||target == NULL)
2491         {
2492                 return;
2493         }
2494
2495         len = source->BufUsed;
2496         for (i=0; i<len; ++i) {
2497                 if (target->BufUsed + 4 >= target->BufSize)
2498                         IncreaseBuf(target, 1, -1);
2499                 if ( (isalnum(source->buf[i])) || 
2500                      (source->buf[i]=='-') || 
2501                      (source->buf[i]=='_') ) {
2502                         target->buf[target->BufUsed++] = source->buf[i];
2503                 }
2504                 else {
2505                         sprintf(&target->buf[target->BufUsed], 
2506                                 "=%02X", 
2507                                 (0xFF &source->buf[i]));
2508                         target->BufUsed += 3;
2509                 }
2510         }
2511         target->buf[target->BufUsed + 1] = '\0';
2512 }
2513
2514
2515 /*******************************************************************************
2516  *                      Quoted Printable de/encoding                           *
2517  *******************************************************************************/
2518
2519 /**
2520  * @ingroup StrBuf_DeEnCoder
2521  * @brief decode a buffer from base 64 encoding; destroys original
2522  * @param Buf Buffor to transform
2523  */
2524 int StrBufDecodeBase64(StrBuf *Buf)
2525 {
2526         char *xferbuf;
2527         size_t siz;
2528         if (Buf == NULL) return -1;
2529
2530         xferbuf = (char*) malloc(Buf->BufSize);
2531         *xferbuf = '\0';
2532         siz = CtdlDecodeBase64(xferbuf,
2533                                Buf->buf,
2534                                Buf->BufUsed);
2535         free(Buf->buf);
2536         Buf->buf = xferbuf;
2537         Buf->BufUsed = siz;
2538         return siz;
2539 }
2540
2541 /**
2542  * @ingroup StrBuf_DeEnCoder
2543  * @brief decode a buffer from base 64 encoding; destroys original
2544  * @param Buf Buffor to transform
2545  */
2546 int StrBufDecodeHex(StrBuf *Buf)
2547 {
2548         unsigned int ch;
2549         char *pch, *pche, *pchi;
2550
2551         if (Buf == NULL) return -1;
2552
2553         pch = pchi = Buf->buf;
2554         pche = pch + Buf->BufUsed;
2555
2556         while (pchi < pche){
2557                 ch = decode_hex(pchi);
2558                 *pch = ch;
2559                 pch ++;
2560                 pchi += 2;
2561         }
2562
2563         *pch = '\0';
2564         Buf->BufUsed = pch - Buf->buf;
2565         return Buf->BufUsed;
2566 }
2567
2568 /**
2569  * @ingroup StrBuf_DeEnCoder
2570  * @brief replace all chars >0x20 && < 0x7F with Mute
2571  * @param Mute char to put over invalid chars
2572  * @param Buf Buffor to transform
2573  */
2574 int StrBufSanitizeAscii(StrBuf *Buf, const char Mute)
2575 {
2576         unsigned char *pch;
2577
2578         if (Buf == NULL) return -1;
2579         pch = (unsigned char *)Buf->buf;
2580         while (pch < (unsigned char *)Buf->buf + Buf->BufUsed) {
2581                 if ((*pch < 0x20) || (*pch > 0x7F))
2582                         *pch = Mute;
2583                 pch ++;
2584         }
2585         return Buf->BufUsed;
2586 }
2587
2588
2589 /**
2590  * @ingroup StrBuf_DeEnCoder
2591  * @brief remove escaped strings from i.e. the url string (like %20 for blanks)
2592  * @param Buf Buffer to translate
2593  * @param StripBlanks Reduce several blanks to one?
2594  */
2595 long StrBufUnescape(StrBuf *Buf, int StripBlanks)
2596 {
2597         int a, b;
2598         char hex[3];
2599         long len;
2600
2601         if (Buf == NULL)
2602                 return -1;
2603
2604         while ((Buf->BufUsed > 0) && (isspace(Buf->buf[Buf->BufUsed - 1]))){
2605                 Buf->buf[Buf->BufUsed - 1] = '\0';
2606                 Buf->BufUsed --;
2607         }
2608
2609         a = 0; 
2610         while (a < Buf->BufUsed) {
2611                 if (Buf->buf[a] == '+')
2612                         Buf->buf[a] = ' ';
2613                 else if (Buf->buf[a] == '%') {
2614                         /* don't let % chars through, rather truncate the input. */
2615                         if (a + 2 > Buf->BufUsed) {
2616                                 Buf->buf[a] = '\0';
2617                                 Buf->BufUsed = a;
2618                         }
2619                         else {                  
2620                                 hex[0] = Buf->buf[a + 1];
2621                                 hex[1] = Buf->buf[a + 2];
2622                                 hex[2] = 0;
2623                                 b = 0;
2624                                 sscanf(hex, "%02x", &b);
2625                                 Buf->buf[a] = (char) b;
2626                                 len = Buf->BufUsed - a - 2;
2627                                 if (len > 0)
2628                                         memmove(&Buf->buf[a + 1], &Buf->buf[a + 3], len);
2629                         
2630                                 Buf->BufUsed -=2;
2631                         }
2632                 }
2633                 a++;
2634         }
2635         return a;
2636 }
2637
2638
2639 /**
2640  * @ingroup StrBuf_DeEnCoder
2641  * @brief       RFC2047-encode a header field if necessary.
2642  *              If no non-ASCII characters are found, the string
2643  *              will be copied verbatim without encoding.
2644  *
2645  * @param       target          Target buffer.
2646  * @param       source          Source string to be encoded.
2647  * @returns     encoded length; -1 if non success.
2648  */
2649 int StrBufRFC2047encode(StrBuf **target, const StrBuf *source)
2650 {
2651         const char headerStr[] = "=?UTF-8?Q?";
2652         int need_to_encode = 0;
2653         int i = 0;
2654         unsigned char ch;
2655
2656         if ((source == NULL) || 
2657             (target == NULL))
2658             return -1;
2659
2660         while ((i < source->BufUsed) &&
2661                (!IsEmptyStr (&source->buf[i])) &&
2662                (need_to_encode == 0)) {
2663                 if (((unsigned char) source->buf[i] < 32) || 
2664                     ((unsigned char) source->buf[i] > 126)) {
2665                         need_to_encode = 1;
2666                 }
2667                 i++;
2668         }
2669
2670         if (!need_to_encode) {
2671                 if (*target == NULL) {
2672                         *target = NewStrBufPlain(source->buf, source->BufUsed);
2673                 }
2674                 else {
2675                         FlushStrBuf(*target);
2676                         StrBufAppendBuf(*target, source, 0);
2677                 }
2678                 return (*target)->BufUsed;
2679         }
2680         if (*target == NULL)
2681                 *target = NewStrBufPlain(NULL, sizeof(headerStr) + source->BufUsed * 2);
2682         else if (sizeof(headerStr) + source->BufUsed >= (*target)->BufSize)
2683                 IncreaseBuf(*target, sizeof(headerStr) + source->BufUsed, 0);
2684         memcpy ((*target)->buf, headerStr, sizeof(headerStr) - 1);
2685         (*target)->BufUsed = sizeof(headerStr) - 1;
2686         for (i=0; (i < source->BufUsed); ++i) {
2687                 if ((*target)->BufUsed + 4 >= (*target)->BufSize)
2688                         IncreaseBuf(*target, 1, 0);
2689                 ch = (unsigned char) source->buf[i];
2690                 if ((ch  <  32) || 
2691                     (ch  > 126) || 
2692                     (ch ==  61) ||
2693                     (ch == '=') ||
2694                     (ch == '?') ||
2695                     (ch == '_') ||
2696                     (ch == '[') ||
2697                     (ch == ']')   )
2698                 {
2699                         sprintf(&(*target)->buf[(*target)->BufUsed], "=%02X", ch);
2700                         (*target)->BufUsed += 3;
2701                 }
2702                 else {
2703                         if (ch == ' ')
2704                                 (*target)->buf[(*target)->BufUsed] = '_';
2705                         else
2706                                 (*target)->buf[(*target)->BufUsed] = ch;
2707                         (*target)->BufUsed++;
2708                 }
2709         }
2710         
2711         if ((*target)->BufUsed + 4 >= (*target)->BufSize)
2712                 IncreaseBuf(*target, 1, 0);
2713
2714         (*target)->buf[(*target)->BufUsed++] = '?';
2715         (*target)->buf[(*target)->BufUsed++] = '=';
2716         (*target)->buf[(*target)->BufUsed] = '\0';
2717         return (*target)->BufUsed;;
2718 }
2719
2720
2721
2722 static void AddRecipient(StrBuf *Target, 
2723                          StrBuf *UserName, 
2724                          StrBuf *EmailAddress, 
2725                          StrBuf *EncBuf)
2726 {
2727         int QuoteMe = 0;
2728
2729         if (StrLength(Target) > 0) StrBufAppendBufPlain(Target, HKEY(", "), 0);
2730         if (strchr(ChrPtr(UserName), ',') != NULL) QuoteMe = 1;
2731
2732         if (QuoteMe)  StrBufAppendBufPlain(Target, HKEY("\""), 0);
2733         StrBufRFC2047encode(&EncBuf, UserName);
2734         StrBufAppendBuf(Target, EncBuf, 0);
2735         if (QuoteMe)  StrBufAppendBufPlain(Target, HKEY("\" "), 0);
2736         else          StrBufAppendBufPlain(Target, HKEY(" "), 0);
2737
2738         if (StrLength(EmailAddress) > 0){
2739                 StrBufAppendBufPlain(Target, HKEY("<"), 0);
2740                 StrBufAppendBuf(Target, EmailAddress, 0); /* TODO: what about IDN???? */
2741                 StrBufAppendBufPlain(Target, HKEY(">"), 0);
2742         }
2743 }
2744
2745
2746 /**
2747  * \brief QP encode parts of an email TO/CC/BCC vector, and strip/filter invalid parts
2748  * \param Recp Source list of email recipients
2749  * \param UserName Temporary buffer for internal use; Please provide valid buffer.
2750  * \param EmailAddress Temporary buffer for internal use; Please provide valid buffer.
2751  * \param EncBuf Temporary buffer for internal use; Please provide valid buffer.
2752  * \returns encoded & sanitized buffer with the contents of Recp; Caller owns this memory.
2753  */
2754 StrBuf *StrBufSanitizeEmailRecipientVector(const StrBuf *Recp, 
2755                                            StrBuf *UserName, 
2756                                            StrBuf *EmailAddress,
2757                                            StrBuf *EncBuf)
2758 {
2759         StrBuf *Target;
2760         const char *pch, *pche;
2761         const char *UserStart, *UserEnd, *EmailStart, *EmailEnd, *At;
2762
2763         if ((Recp == NULL) || (StrLength(Recp) == 0))
2764                 return NULL;
2765
2766         pch = ChrPtr(Recp);
2767         pche = pch + StrLength(Recp);
2768
2769         if (!CheckEncode(pch, -1, pche))
2770                 return NewStrBufDup(Recp);
2771
2772         Target = NewStrBufPlain(NULL, StrLength(Recp));
2773
2774         while ((pch != NULL) && (pch < pche))
2775         {
2776                 while (isspace(*pch)) pch++;
2777                 UserStart = UserEnd = EmailStart = EmailEnd = NULL;
2778                 
2779                 if ((*pch == '"') || (*pch == '\'')) {
2780                         UserStart = pch + 1;
2781                         
2782                         UserEnd = strchr(UserStart, *pch);
2783                         if (UserEnd == NULL) 
2784                                 break; ///TODO: Userfeedback??
2785                         EmailStart = UserEnd + 1;
2786                         while (isspace(*EmailStart))
2787                                 EmailStart++;
2788                         if (UserEnd == UserStart) {
2789                                 UserStart = UserEnd = NULL;
2790                         }
2791                         
2792                         if (*EmailStart == '<') {
2793                                 EmailStart++;
2794                                 EmailEnd = strchr(EmailStart, '>');
2795                                 if (EmailEnd == NULL)
2796                                         EmailEnd = strchr(EmailStart, ',');
2797                                 
2798                         }
2799                         else {
2800                                 EmailEnd = strchr(EmailStart, ',');
2801                         }
2802                         if (EmailEnd == NULL)
2803                                 EmailEnd = pche;
2804                         pch = EmailEnd + 1;
2805                 }
2806                 else {
2807                         int gt = 0;
2808                         UserStart = pch;
2809                         EmailEnd = strchr(UserStart, ',');
2810                         if (EmailEnd == NULL) {
2811                                 EmailEnd = strchr(pch, '>');
2812                                 pch = NULL;
2813                                 if (EmailEnd != NULL) {
2814                                         gt = 1;
2815                                 }
2816                                 else {
2817                                         EmailEnd = pche;
2818                                 }
2819                         }
2820                         else {
2821
2822                                 pch = EmailEnd + 1;
2823                                 while ((EmailEnd > UserStart) && !gt &&
2824                                        ((*EmailEnd == ',') ||
2825                                         (*EmailEnd == '>') ||
2826                                         (isspace(*EmailEnd))))
2827                                 {
2828                                         if (*EmailEnd == '>')
2829                                                 gt = 1;
2830                                         else 
2831                                                 EmailEnd--;
2832                                 }
2833                                 if (EmailEnd == UserStart)
2834                                         break;
2835                         }
2836                         if (gt) {
2837                                 EmailStart = strchr(UserStart, '<');
2838                                 if ((EmailStart == NULL) || (EmailStart > EmailEnd))
2839                                         break;
2840                                 UserEnd = EmailStart;
2841
2842                                 while ((UserEnd > UserStart) && 
2843                                        isspace (*(UserEnd - 1)))
2844                                         UserEnd --;
2845                                 EmailStart ++;
2846                                 if (UserStart >= UserEnd)
2847                                         UserStart = UserEnd = NULL;
2848                                 At = strchr(EmailStart, '@');
2849                         }
2850                         else { /* this is a local recipient... no domain, just a realname */
2851                                 EmailStart = UserStart;
2852                                 At = strchr(EmailStart, '@');
2853                                 if (At == NULL) {
2854                                         UserEnd = EmailEnd;
2855                                         EmailEnd = NULL;
2856                                 }
2857                                 else {
2858                                         EmailStart = UserStart;
2859                                         UserStart = NULL;
2860                                 }
2861                         }
2862                 }
2863
2864                 if ((UserStart != NULL) && (UserEnd != NULL))
2865                         StrBufPlain(UserName, UserStart, UserEnd - UserStart);
2866                 else if ((UserStart != NULL) && (UserEnd == NULL))
2867                         StrBufPlain(UserName, UserStart, UserEnd - UserStart);
2868                 else
2869                         FlushStrBuf(UserName);
2870
2871                 if ((EmailStart != NULL) && (EmailEnd != NULL))
2872                         StrBufPlain(EmailAddress, EmailStart, EmailEnd - EmailStart);
2873                 else if ((EmailStart != NULL) && (EmailEnd == NULL))
2874                         StrBufPlain(EmailAddress, EmailStart, EmailEnd - pche);
2875                 else 
2876                         FlushStrBuf(EmailAddress);
2877
2878                 AddRecipient(Target, UserName, EmailAddress, EncBuf);
2879
2880                 if (pch == NULL)
2881                         break;
2882                 
2883                 if ((pch != NULL) && (*pch == ','))
2884                         pch ++;
2885                 if (pch != NULL) while (isspace(*pch))
2886                         pch ++;
2887         }
2888         return Target;
2889 }
2890
2891
2892 /**
2893  * @ingroup StrBuf
2894  * @brief replaces all occurances of 'search' by 'replace'
2895  * @param buf Buffer to modify
2896  * @param search character to search
2897  * @param replace character to replace search by
2898  */
2899 void StrBufReplaceChars(StrBuf *buf, char search, char replace)
2900 {
2901         long i;
2902         if (buf == NULL)
2903                 return;
2904         for (i=0; i<buf->BufUsed; i++)
2905                 if (buf->buf[i] == search)
2906                         buf->buf[i] = replace;
2907
2908 }
2909
2910 /**
2911  * @ingroup StrBuf
2912  * @brief removes all \\r s from the string, or replaces them with \n if its not a combination of both.
2913  * @param buf Buffer to modify
2914  */
2915 void StrBufToUnixLF(StrBuf *buf)
2916 {
2917         char *pche, *pchS, *pchT;
2918         if (buf == NULL)
2919                 return;
2920
2921         pche = buf->buf + buf->BufUsed;
2922         pchS = pchT = buf->buf;
2923         while (pchS < pche)
2924         {
2925                 if (*pchS == '\r')
2926                 {
2927                         pchS ++;
2928                         if (*pchS != '\n') {
2929                                 *pchT = '\n';
2930                                 pchT++;
2931                         }
2932                 }
2933                 *pchT = *pchS;
2934                 pchT++; pchS++;
2935         }
2936         *pchT = '\0';
2937         buf->BufUsed = pchT - buf->buf;
2938 }
2939
2940
2941 /*******************************************************************************
2942  *                 Iconv Wrapper; RFC822 de/encoding                           *
2943  *******************************************************************************/
2944
2945 /**
2946  * @ingroup StrBuf_DeEnCoder
2947  * @brief Wrapper around iconv_open()
2948  * Our version adds aliases for non-standard Microsoft charsets
2949  * such as 'MS950', aliasing them to names like 'CP950'
2950  *
2951  * @param tocode        Target encoding
2952  * @param fromcode      Source encoding
2953  * @param pic           anonimized pointer to iconv struct
2954  */
2955 void  ctdl_iconv_open(const char *tocode, const char *fromcode, void *pic)
2956 {
2957 #ifdef HAVE_ICONV
2958         iconv_t ic = (iconv_t)(-1) ;
2959         ic = iconv_open(tocode, fromcode);
2960         if (ic == (iconv_t)(-1) ) {
2961                 char alias_fromcode[64];
2962                 if ( (strlen(fromcode) == 5) && (!strncasecmp(fromcode, "MS", 2)) ) {
2963                         safestrncpy(alias_fromcode, fromcode, sizeof alias_fromcode);
2964                         alias_fromcode[0] = 'C';
2965                         alias_fromcode[1] = 'P';
2966                         ic = iconv_open(tocode, alias_fromcode);
2967                 }
2968         }
2969         *(iconv_t *)pic = ic;
2970 #endif
2971 }
2972
2973
2974 /**
2975  * @ingroup StrBuf_DeEnCoder
2976  * @brief find one chunk of a RFC822 encoded string
2977  * @param Buffer where to search
2978  * @param bptr where to start searching
2979  * @returns found position, NULL if none.
2980  */
2981 static inline const char *FindNextEnd (const StrBuf *Buf, const char *bptr)
2982 {
2983         const char * end;
2984         /* Find the next ?Q? */
2985         if (Buf->BufUsed - (bptr - Buf->buf)  < 6)
2986                 return NULL;
2987
2988         end = strchr(bptr + 2, '?');
2989
2990         if (end == NULL)
2991                 return NULL;
2992
2993         if ((Buf->BufUsed - (end - Buf->buf) > 3) &&
2994             (((*(end + 1) == 'B') || (*(end + 1) == 'Q')) ||
2995              ((*(end + 1) == 'b') || (*(end + 1) == 'q'))) && 
2996             (*(end + 2) == '?')) {
2997                 /* skip on to the end of the cluster, the next ?= */
2998                 end = strstr(end + 3, "?=");
2999         }
3000         else
3001                 /* sort of half valid encoding, try to find an end. */
3002                 end = strstr(bptr, "?=");
3003         return end;
3004 }
3005
3006
3007
3008 /**
3009  * @ingroup StrBuf_DeEnCoder
3010  * @brief convert one buffer according to the preselected iconv pointer PIC
3011  * @param ConvertBuf buffer we need to translate
3012  * @param TmpBuf To share a workbuffer over several iterations. prepare to have it filled with useless stuff afterwards.
3013  * @param pic Pointer to the iconv-session Object
3014  */
3015 void StrBufConvert(StrBuf *ConvertBuf, StrBuf *TmpBuf, void *pic)
3016 {
3017 #ifdef HAVE_ICONV
3018         long trycount = 0;
3019         size_t siz;
3020         iconv_t ic;
3021         char *ibuf;                     /**< Buffer of characters to be converted */
3022         char *obuf;                     /**< Buffer for converted characters */
3023         size_t ibuflen;                 /**< Length of input buffer */
3024         size_t obuflen;                 /**< Length of output buffer */
3025
3026
3027         /* since we're converting to utf-8, one glyph may take up to 6 bytes */
3028         if (ConvertBuf->BufUsed * 6 >= TmpBuf->BufSize)
3029                 IncreaseBuf(TmpBuf, 0, ConvertBuf->BufUsed * 6);
3030 TRYAGAIN:
3031         ic = *(iconv_t*)pic;
3032         ibuf = ConvertBuf->buf;
3033         ibuflen = ConvertBuf->BufUsed;
3034         obuf = TmpBuf->buf;
3035         obuflen = TmpBuf->BufSize;
3036         
3037         siz = iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
3038
3039         if (siz < 0) {
3040                 if (errno == E2BIG) {
3041                         trycount ++;                    
3042                         IncreaseBuf(TmpBuf, 0, 0);
3043                         if (trycount < 5) 
3044                                 goto TRYAGAIN;
3045
3046                 }
3047                 else if (errno == EILSEQ){ 
3048                         /* hm, invalid utf8 sequence... what to do now? */
3049                         /* An invalid multibyte sequence has been encountered in the input */
3050                 }
3051                 else if (errno == EINVAL) {
3052                         /* An incomplete multibyte sequence has been encountered in the input. */
3053                 }
3054
3055                 FlushStrBuf(TmpBuf);
3056         }
3057         else {
3058                 TmpBuf->BufUsed = TmpBuf->BufSize - obuflen;
3059                 TmpBuf->buf[TmpBuf->BufUsed] = '\0';
3060                 
3061                 /* little card game: wheres the red lady? */
3062                 SwapBuffers(ConvertBuf, TmpBuf);
3063                 FlushStrBuf(TmpBuf);
3064         }
3065 #endif
3066 }
3067
3068
3069 /**
3070  * @ingroup StrBuf_DeEnCoder
3071  * @brief catches one RFC822 encoded segment, and decodes it.
3072  * @param Target buffer to fill with result
3073  * @param DecodeMe buffer with stuff to process
3074  * @param SegmentStart points to our current segment in DecodeMe
3075  * @param SegmentEnd Points to the end of our current segment in DecodeMe
3076  * @param ConvertBuf Workbuffer shared between several iterations. Random content; needs to be valid
3077  * @param ConvertBuf2 Workbuffer shared between several iterations. Random content; needs to be valid
3078  * @param FoundCharset Characterset to default decoding to; if we find another we will overwrite it.
3079  */
3080 inline static void DecodeSegment(StrBuf *Target, 
3081                                  const StrBuf *DecodeMe, 
3082                                  const char *SegmentStart, 
3083                                  const char *SegmentEnd, 
3084                                  StrBuf *ConvertBuf,
3085                                  StrBuf *ConvertBuf2, 
3086                                  StrBuf *FoundCharset)
3087 {
3088         StrBuf StaticBuf;
3089         char charset[128];
3090         char encoding[16];
3091 #ifdef HAVE_ICONV
3092         iconv_t ic = (iconv_t)(-1);
3093 #else
3094         void *ic = NULL;
3095 #endif
3096         /* Now we handle foreign character sets properly encoded
3097          * in RFC2047 format.
3098          */
3099         StaticBuf.buf = (char*) SegmentStart; /*< it will just be read there... */
3100         StaticBuf.BufUsed = SegmentEnd - SegmentStart;
3101         StaticBuf.BufSize = DecodeMe->BufSize - (SegmentStart - DecodeMe->buf);
3102         extract_token(charset, SegmentStart, 1, '?', sizeof charset);
3103         if (FoundCharset != NULL) {
3104                 FlushStrBuf(FoundCharset);
3105                 StrBufAppendBufPlain(FoundCharset, charset, -1, 0);
3106         }
3107         extract_token(encoding, SegmentStart, 2, '?', sizeof encoding);
3108         StrBufExtract_token(ConvertBuf, &StaticBuf, 3, '?');
3109         
3110         *encoding = toupper(*encoding);
3111         if (*encoding == 'B') { /**< base64 */
3112                 if (ConvertBuf2->BufSize < ConvertBuf->BufUsed)
3113                         IncreaseBuf(ConvertBuf2, 0, ConvertBuf->BufUsed);
3114                 ConvertBuf2->BufUsed = CtdlDecodeBase64(ConvertBuf2->buf, 
3115                                                         ConvertBuf->buf, 
3116                                                         ConvertBuf->BufUsed);
3117         }
3118         else if (*encoding == 'Q') {    /**< quoted-printable */
3119                 long pos;
3120                 
3121                 pos = 0;
3122                 while (pos < ConvertBuf->BufUsed)
3123                 {
3124                         if (ConvertBuf->buf[pos] == '_') 
3125                                 ConvertBuf->buf[pos] = ' ';
3126                         pos++;
3127                 }
3128                 
3129                 if (ConvertBuf2->BufSize < ConvertBuf->BufUsed)
3130                         IncreaseBuf(ConvertBuf2, 0, ConvertBuf->BufUsed);
3131
3132                 ConvertBuf2->BufUsed = CtdlDecodeQuotedPrintable(
3133                         ConvertBuf2->buf, 
3134                         ConvertBuf->buf,
3135                         ConvertBuf->BufUsed);
3136         }
3137         else {
3138                 StrBufAppendBuf(ConvertBuf2, ConvertBuf, 0);
3139         }
3140 #ifdef HAVE_ICONV
3141         ctdl_iconv_open("UTF-8", charset, &ic);
3142         if (ic != (iconv_t)(-1) ) {             
3143 #endif
3144                 StrBufConvert(ConvertBuf2, ConvertBuf, &ic);
3145                 StrBufAppendBuf(Target, ConvertBuf2, 0);
3146 #ifdef HAVE_ICONV
3147                 iconv_close(ic);
3148         }
3149         else {
3150                 StrBufAppendBufPlain(Target, HKEY("(unreadable)"), 0);
3151         }
3152 #endif
3153 }
3154
3155 /**
3156  * @ingroup StrBuf_DeEnCoder
3157  * @brief Handle subjects with RFC2047 encoding such as: [deprecated old syntax!]
3158  * =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
3159  * @param Target where to put the decoded string to 
3160  * @param DecodeMe buffer with encoded string
3161  * @param DefaultCharset if we don't find one, which should we use?
3162  * @param FoundCharset overrides DefaultCharset if non-empty; If we find a charset inside of the string, 
3163  *        put it here for later use where no string might be known.
3164  */
3165 void StrBuf_RFC822_to_Utf8(StrBuf *Target, const StrBuf *DecodeMe, const StrBuf* DefaultCharset, StrBuf *FoundCharset)
3166 {
3167         StrBuf *ConvertBuf;
3168         StrBuf *ConvertBuf2;
3169         ConvertBuf = NewStrBufPlain(NULL, StrLength(DecodeMe));
3170         ConvertBuf2 = NewStrBufPlain(NULL, StrLength(DecodeMe));
3171         
3172         StrBuf_RFC822_2_Utf8(Target, 
3173                              DecodeMe, 
3174                              DefaultCharset, 
3175                              FoundCharset, 
3176                              ConvertBuf, 
3177                              ConvertBuf2);
3178         FreeStrBuf(&ConvertBuf);
3179         FreeStrBuf(&ConvertBuf2);
3180 }
3181
3182 /**
3183  * @ingroup StrBuf_DeEnCoder
3184  * @brief Handle subjects with RFC2047 encoding such as:
3185  * =?koi8-r?B?78bP0s3Mxc7JxSDXz9rE1dvO2c3JINvB0sHNySDP?=
3186  * @param Target where to put the decoded string to 
3187  * @param DecodeMe buffer with encoded string
3188  * @param DefaultCharset if we don't find one, which should we use?
3189  * @param FoundCharset overrides DefaultCharset if non-empty; If we find a charset inside of the string, 
3190  *        put it here for later use where no string might be known.
3191  * @param ConvertBuf workbuffer. feed in, you shouldn't care about its content.
3192  * @param ConvertBuf2 workbuffer. feed in, you shouldn't care about its content.
3193  */
3194 void StrBuf_RFC822_2_Utf8(StrBuf *Target, 
3195                           const StrBuf *DecodeMe, 
3196                           const StrBuf* DefaultCharset, 
3197                           StrBuf *FoundCharset, 
3198                           StrBuf *ConvertBuf, 
3199                           StrBuf *ConvertBuf2)
3200 {
3201         StrBuf *DecodedInvalidBuf = NULL;
3202         const StrBuf *DecodeMee = DecodeMe;
3203         const char *start, *end, *next, *nextend, *ptr = NULL;
3204 #ifdef HAVE_ICONV
3205         iconv_t ic = (iconv_t)(-1) ;
3206 #endif
3207         const char *eptr;
3208         int passes = 0;
3209         int i, len;
3210         int illegal_non_rfc2047_encoding = 0;
3211
3212         /* Sometimes, badly formed messages contain strings which were simply
3213          *  written out directly in some foreign character set instead of
3214          *  using RFC2047 encoding.  This is illegal but we will attempt to
3215          *  handle it anyway by converting from a user-specified default
3216          *  charset to UTF-8 if we see any nonprintable characters.
3217          */
3218         
3219         len = StrLength(DecodeMe);
3220         for (i=0; i<DecodeMe->BufUsed; ++i) {
3221                 if ((DecodeMe->buf[i] < 32) || (DecodeMe->buf[i] > 126)) {
3222                         illegal_non_rfc2047_encoding = 1;
3223                         break;
3224                 }
3225         }
3226
3227         if ((illegal_non_rfc2047_encoding) &&
3228             (strcasecmp(ChrPtr(DefaultCharset), "UTF-8")) && 
3229             (strcasecmp(ChrPtr(DefaultCharset), "us-ascii")) )
3230         {
3231 #ifdef HAVE_ICONV
3232                 ctdl_iconv_open("UTF-8", ChrPtr(DefaultCharset), &ic);
3233                 if (ic != (iconv_t)(-1) ) {
3234                         DecodedInvalidBuf = NewStrBufDup(DecodeMe);
3235                         StrBufConvert(DecodedInvalidBuf, ConvertBuf, &ic);///TODO: don't void const?
3236                         DecodeMee = DecodedInvalidBuf;
3237                         iconv_close(ic);
3238                 }
3239 #endif
3240         }
3241
3242         /* pre evaluate the first pair */
3243         nextend = end = NULL;
3244         len = StrLength(DecodeMee);
3245         start = strstr(DecodeMee->buf, "=?");
3246         eptr = DecodeMee->buf + DecodeMee->BufUsed;
3247         if (start != NULL) 
3248                 end = FindNextEnd (DecodeMee, start + 2);
3249         else {
3250                 StrBufAppendBuf(Target, DecodeMee, 0);
3251                 FreeStrBuf(&DecodedInvalidBuf);
3252                 return;
3253         }
3254
3255
3256         if (start != DecodeMee->buf) {
3257                 long nFront;
3258                 
3259                 nFront = start - DecodeMee->buf;
3260                 StrBufAppendBufPlain(Target, DecodeMee->buf, nFront, 0);
3261                 len -= nFront;
3262         }
3263         /*
3264          * Since spammers will go to all sorts of absurd lengths to get their
3265          * messages through, there are LOTS of corrupt headers out there.
3266          * So, prevent a really badly formed RFC2047 header from throwing
3267          * this function into an infinite loop.
3268          */
3269         while ((start != NULL) && 
3270                (end != NULL) && 
3271                (start < eptr) && 
3272                (end < eptr) && 
3273                (passes < 20))
3274         {
3275                 passes++;
3276                 DecodeSegment(Target, 
3277                               DecodeMee, 
3278                               start, 
3279                               end, 
3280                               ConvertBuf,
3281                               ConvertBuf2,
3282                               FoundCharset);
3283                 
3284                 next = strstr(end, "=?");
3285                 nextend = NULL;
3286                 if ((next != NULL) && 
3287                     (next < eptr))
3288                         nextend = FindNextEnd(DecodeMee, next);
3289                 if (nextend == NULL)
3290                         next = NULL;
3291
3292                 /* did we find two partitions */
3293                 if ((next != NULL) && 
3294                     ((next - end) > 2))
3295                 {
3296                         ptr = end + 2;
3297                         while ((ptr < next) && 
3298                                (isspace(*ptr) ||
3299                                 (*ptr == '\r') ||
3300                                 (*ptr == '\n') || 
3301                                 (*ptr == '\t')))
3302                                 ptr ++;
3303                         /* 
3304                          * did we find a gab just filled with blanks?
3305                          * if not, copy its stuff over.
3306                          */
3307                         if (ptr != next)
3308                         {
3309                                 StrBufAppendBufPlain(Target, 
3310                                                      end + 2, 
3311                                                      next - end - 2,
3312                                                      0);
3313                         }
3314                 }
3315                 /* our next-pair is our new first pair now. */
3316                 ptr = end + 2;
3317                 start = next;
3318                 end = nextend;
3319         }
3320         end = ptr;
3321         nextend = DecodeMee->buf + DecodeMee->BufUsed;
3322         if ((end != NULL) && (end < nextend)) {
3323                 ptr = end;
3324                 while ( (ptr < nextend) &&
3325                         (isspace(*ptr) ||
3326                          (*ptr == '\r') ||
3327                          (*ptr == '\n') || 
3328                          (*ptr == '\t')))
3329                         ptr ++;
3330                 if (ptr < nextend)
3331                         StrBufAppendBufPlain(Target, end, nextend - end, 0);
3332         }
3333         FreeStrBuf(&DecodedInvalidBuf);
3334 }
3335
3336 /*******************************************************************************
3337  *                   Manipulating UTF-8 Strings                                *
3338  *******************************************************************************/
3339
3340 /**
3341  * @ingroup StrBuf
3342  * @brief evaluate the length of an utf8 special character sequence
3343  * @param Char the character to examine
3344  * @returns width of utf8 chars in bytes; if the sequence is broken 0 is returned; 1 if its simply ASCII.
3345  */
3346 static inline int Ctdl_GetUtf8SequenceLength(const char *CharS, const char *CharE)
3347 {
3348         int n = 0;
3349         unsigned char test = (1<<7);
3350
3351         if ((*CharS & 0xC0) != 0xC0) 
3352                 return 1;
3353
3354         while ((n < 8) && 
3355                ((test & ((unsigned char)*CharS)) != 0)) 
3356         {
3357                 test = test >> 1;
3358                 n ++;
3359         }
3360         if ((n > 6) || ((CharE - CharS) < n))
3361                 n = 0;
3362         return n;
3363 }
3364
3365 /**
3366  * @ingroup StrBuf
3367  * @brief detect whether this char starts an utf-8 encoded char
3368  * @param Char character to inspect
3369  * @returns yes or no
3370  */
3371 static inline int Ctdl_IsUtf8SequenceStart(const char Char)
3372 {
3373 /** 11??.???? indicates an UTF8 Sequence. */
3374         return ((Char & 0xC0) == 0xC0);
3375 }
3376
3377 /**
3378  * @ingroup StrBuf
3379  * @brief measure the number of glyphs in an UTF8 string...
3380  * @param Buf string to measure
3381  * @returns the number of glyphs in Buf
3382  */
3383 long StrBuf_Utf8StrLen(StrBuf *Buf)
3384 {
3385         int n = 0;
3386         int m = 0;
3387         char *aptr, *eptr;
3388
3389         if ((Buf == NULL) || (Buf->BufUsed == 0))
3390                 return 0;
3391         aptr = Buf->buf;
3392         eptr = Buf->buf + Buf->BufUsed;
3393         while ((aptr < eptr) && (*aptr != '\0')) {
3394                 if (Ctdl_IsUtf8SequenceStart(*aptr)){
3395                         m = Ctdl_GetUtf8SequenceLength(aptr, eptr);
3396                         while ((aptr < eptr) && (*aptr++ != '\0')&& (m-- > 0) );
3397                         n ++;
3398                 }
3399                 else {