libcitadel/lib/stringbuf.c

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