libcitadel/lib/tools.c

   1 /*
   2  * A basic toolset containing miscellaneous functions for string manipluation,
   3  * encoding/decoding, and a bunch of other stuff.
   4  */
   5
   6
   7 #include <stdlib.h>
   8 #include <unistd.h>
   9 #include <stdio.h>
  10 #include <signal.h>
  11 #include <sys/types.h>
  12 #include <ctype.h>
  13 #include <string.h>
  14 #include <sys/stat.h>
  15 #include <errno.h>
  16 #include <limits.h>
  17
  18 #if TIME_WITH_SYS_TIME
  19 # include <sys/time.h>
  20 # include <time.h>
  21 #else
  22 # if HAVE_SYS_TIME_H
  23 #  include <sys/time.h>
  24 # else
  25 #  include <time.h>
  26 # endif
  27 #endif
  28
  29 #include "libcitadel.h"
  30
  31
  32 #define TRUE  1
  33 #define FALSE 0
  34
  35 typedef unsigned char byte;           /* Byte type */
  36
  37 /* Base64 encoding table */
  38 const byte etable[256] = {
  39         65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
  40         82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103,
  41         104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
  42         118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43,
  43         47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  44         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  45         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  46         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  47         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  48         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  49         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  50         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  51         0, 0, 0, 0, 0, 0, 0, 0, 0
  52 };
  53
  54 /* Base64 decoding table */
  55 const byte dtable[256] = {
  56         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  57         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  58         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  59         128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
  60         128, 128, 128, 0, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  61         12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128,
  62         128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
  63         40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128,
  64         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  65         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  66         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  67         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  68         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  69         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  70         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  71         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  72         128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  73         128, 128, 0
  74 };
  75
  76 /*
  77  * copy a string into a buffer of a known size. abort if we exceed the limits
  78  *
  79  * dest the targetbuffer
  80  * src  the source string
  81  * n    the size od dest
  82  *
  83  * returns the number of characters copied if dest is big enough, -n if not.
  84  */
  85 int safestrncpy(char *dest, const char *src, size_t n)
  86 {
  87         int i = 0;
  88
  89         if (dest == NULL || src == NULL) {
  90                 fprintf(stderr, "safestrncpy: NULL argument\n");
  91                 abort();
  92         }
  93
  94         do {
  95                 dest[i] = src[i];
  96                 if (dest[i] == 0) return i;
  97                 ++i;
  98         } while (i<n);
  99         dest[n - 1] = 0;
 100         return -i;
 101 }
 102
 103
 104
 105 /*
 106  * num_tokens()  -  discover number of parameters/tokens in a string
 107  */
 108 int num_tokens(const char *source, char tok)
 109 {
 110         int count = 1;
 111         const char *ptr = source;
 112
 113         if (source == NULL) {
 114                 return (0);
 115         }
 116
 117         while (*ptr != '\0') {
 118                 if (*ptr++ == tok) {
 119                         ++count;
 120                 }
 121         }
 122
 123         return (count);
 124 }
 125
 126 //extern void cit_backtrace(void);
 127
 128
 129 /*
 130  * extract_token() - a string tokenizer
 131  * returns -1 if not found, or length of token.
 132  */
 133 long extract_token(char *dest, const char *source, int parmnum, char separator, int maxlen)
 134 {
 135         const char *s;                  //* source * /
 136         int len = 0;                    //* running total length of extracted string * /
 137         int current_token = 0;          //* token currently being processed * /
 138
 139         s = source;
 140
 141         if (dest == NULL) {
 142                 return(-1);
 143         }
 144
 145         //cit_backtrace();
 146         //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
 147         dest[0] = 0;
 148
 149         if (s == NULL) {
 150                 return(-1);
 151         }
 152
 153         maxlen--;
 154
 155         while (*s) {
 156                 if (*s == separator) {
 157                         ++current_token;
 158                 }
 159                 if ( (current_token == parmnum) &&
 160                      (*s != separator) &&
 161                      (len < maxlen) ) {
 162                         dest[len] = *s;
 163                         ++len;
 164                 }
 165                 else if ((current_token > parmnum) || (len >= maxlen)) {
 166                         break;
 167                 }
 168                 ++s;
 169         }
 170
 171         dest[len] = '\0';
 172         if (current_token < parmnum) {
 173                 //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
 174                 return(-1);
 175         }
 176         //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
 177         return(len);
 178 }
 179 //*/
 180
 181
 182 /*
 183  * extract_token() - a string tokenizer
 184  * /
 185 long extract_token(char *dest, const char *source, int parmnum, char separator, int maxlen)
 186 {
 187         char *d;                // dest
 188         const char *s;          // source
 189         int count = 0;
 190         int len = 0;
 191
 192
 193         //cit_backtrace();
 194         //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
 195         strcpy(dest, "");
 196
 197         //  Locate desired parameter
 198         s = source;
 199         while (count < parmnum) {
 200                 //  End of string, bail!
 201                 if (!*s) {
 202                         s = NULL;
 203                         break;
 204                 }
 205                 if (*s == separator) {
 206                         count++;
 207                 }
 208                 s++;
 209         }
 210         if (!s) {
 211                 //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
 212                 return -1;              // Parameter not found
 213         }
 214
 215         for (d = dest; *s && *s != separator && ++len<maxlen; s++, d++) {
 216                 *d = *s;
 217         }
 218         *d = 0;
 219         //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
 220         return 0;
 221 }
 222 */
 223
 224
 225 /*
 226  * remove_token() - a tokenizer that kills, maims, and destroys
 227  */
 228 void remove_token(char *source, int parmnum, char separator)
 229 {
 230         char *d, *s;            /* dest, source */
 231         int count = 0;
 232
 233         /* Find desired parameter */
 234         d = source;
 235         while (count < parmnum) {
 236                 /* End of string, bail! */
 237                 if (!*d) {
 238                         d = NULL;
 239                         break;
 240                 }
 241                 if (*d == separator) {
 242                         count++;
 243                 }
 244                 d++;
 245         }
 246         if (!d) return;         /* Parameter not found */
 247
 248         /* Find next parameter */
 249         s = d;
 250         while (*s && *s != separator) {
 251                 s++;
 252         }
 253
 254         /* Hack and slash */
 255         if (*s)
 256                 strcpy(d, ++s);
 257         else if (d == source)
 258                 *d = 0;
 259         else
 260                 *--d = 0;
 261         /*
 262         while (*s) {
 263                 *d++ = *s++;
 264         }
 265         *d = 0;
 266         */
 267 }
 268
 269
 270 /*
 271  * extract_int()  -  extract an int parm w/o supplying a buffer
 272  */
 273 int extract_int(const char *source, int parmnum)
 274 {
 275         char buf[32];
 276
 277         if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
 278                 return(atoi(buf));
 279         else
 280                 return 0;
 281 }
 282
 283 /*
 284  * extract_long()  -  extract an long parm w/o supplying a buffer
 285  */
 286 long extract_long(const char *source, int parmnum)
 287 {
 288         char buf[32];
 289
 290         if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
 291                 return(atol(buf));
 292         else
 293                 return 0;
 294 }
 295
 296
 297 /*
 298  * extract_unsigned_long() - extract an unsigned long parm
 299  */
 300 unsigned long extract_unsigned_long(const char *source, int parmnum)
 301 {
 302         char buf[32];
 303
 304         if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
 305                 return strtoul(buf, NULL, 10);
 306         else
 307                 return 0;
 308 }
 309
 310
 311 /*
 312  * CtdlDecodeBase64() and CtdlEncodeBase64() are adaptations of code by John Walker.
 313  */
 314
 315 size_t CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen, int linebreaks)
 316 {
 317         int i, hiteof = FALSE;
 318         int spos = 0;
 319         int dpos = 0;
 320         int thisline = 0;
 321
 322         while (!hiteof) {
 323                 byte igroup[3], ogroup[4];
 324                 int c, n;
 325
 326                 igroup[0] = igroup[1] = igroup[2] = 0;
 327                 for (n = 0; n < 3; n++) {
 328                         if (spos >= sourcelen) {
 329                                 hiteof = TRUE;
 330                                 break;
 331                         }
 332                         c = source[spos++];
 333                         igroup[n] = (byte) c;
 334                 }
 335                 if (n > 0) {
 336                         ogroup[0] = etable[igroup[0] >> 2];
 337                         ogroup[1] =
 338                             etable[((igroup[0] & 3) << 4) |
 339                                    (igroup[1] >> 4)];
 340                         ogroup[2] =
 341                             etable[((igroup[1] & 0xF) << 2) |
 342                                    (igroup[2] >> 6)];
 343                         ogroup[3] = etable[igroup[2] & 0x3F];
 344
 345                         /*
 346                          * Replace characters in output stream with "=" pad
 347                          * characters if fewer than three characters were
 348                          * read from the end of the input stream.
 349                          */
 350
 351                         if (n < 3) {
 352                                 ogroup[3] = '=';
 353                                 if (n < 2) {
 354                                         ogroup[2] = '=';
 355                                 }
 356                         }
 357                         for (i = 0; i < 4; i++) {
 358                                 dest[dpos++] = ogroup[i];
 359                                 dest[dpos] = 0;
 360                         }
 361                         thisline += 4;
 362                         if ( (linebreaks) && (thisline > 70) ) {
 363                                 dest[dpos++] = '\r';
 364                                 dest[dpos++] = '\n';
 365                                 dest[dpos] = 0;
 366                                 thisline = 0;
 367                         }
 368                 }
 369         }
 370         if ( (linebreaks) && (thisline > 70) ) {
 371                 dest[dpos++] = '\r';
 372                 dest[dpos++] = '\n';
 373                 dest[dpos] = 0;
 374                 thisline = 0;
 375         }
 376
 377         return(dpos);
 378 }
 379
 380
 381
 382 /*
 383  * Convert base64-encoded to binary.  Returns the length of the decoded data.
 384  * It will stop after reading 'length' bytes.
 385  */
 386 int CtdlDecodeBase64(char *dest, const char *source, size_t length)
 387 {
 388     int i, c;
 389     int dpos = 0;
 390     int spos = 0;
 391
 392     while (TRUE) {
 393         byte a[4], b[4], o[3];
 394
 395         for (i = 0; i < 4; i++) {
 396             if (spos >= length) {
 397                 return(dpos);
 398             }
 399             c = source[spos++];
 400
 401             if (c == 0) {
 402                 if (i > 0) {
 403                     return(dpos);
 404                 }
 405                 return(dpos);
 406             }
 407             if (dtable[c] & 0x80) {
 408                 /* Ignoring errors: discard invalid character. */
 409                 i--;
 410                 continue;
 411             }
 412             a[i] = (byte) c;
 413             b[i] = (byte) dtable[c];
 414         }
 415         o[0] = (b[0] << 2) | (b[1] >> 4);
 416         o[1] = (b[1] << 4) | (b[2] >> 2);
 417         o[2] = (b[2] << 6) | b[3];
 418         i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
 419         if (i>=1) dest[dpos++] = o[0];
 420         if (i>=2) dest[dpos++] = o[1];
 421         if (i>=3) dest[dpos++] = o[2];
 422         dest[dpos] = 0;
 423         if (i < 3) {
 424             return(dpos);
 425         }
 426     }
 427 }
 428
 429
 430 /*
 431  * if we send out non ascii subjects, we encode it this way.
 432  */
 433 char *rfc2047encode(char *line, long length)
 434 {
 435         char *AlreadyEncoded;
 436         char *result;
 437         long end;
 438 #define UTF8_HEADER "=?UTF-8?B?"
 439
 440         /* check if we're already done */
 441         AlreadyEncoded = strstr(line, "=?");
 442         if ((AlreadyEncoded != NULL) &&
 443             ((strstr(AlreadyEncoded, "?B?") != NULL)||
 444              (strstr(AlreadyEncoded, "?Q?") != NULL)))
 445         {
 446                 return strdup(line);
 447         }
 448
 449         result = (char*) malloc(sizeof(UTF8_HEADER) + 4 + length * 2);
 450         strncpy (result, UTF8_HEADER, strlen (UTF8_HEADER));
 451         CtdlEncodeBase64(result + strlen(UTF8_HEADER), line, length, 0);
 452         end = strlen (result);
 453         result[end]='?';
 454         result[end+1]='=';
 455         result[end+2]='\0';
 456         return result;
 457 }
 458
 459
 460 /*
 461  * Strip leading and trailing spaces from a string
 462  */
 463 size_t striplt(char *buf) {
 464         char *first_nonspace = NULL;
 465         char *last_nonspace = NULL;
 466         char *ptr;
 467         size_t new_len = 0;
 468
 469         if (!buf) {
 470                 return 0;
 471         }
 472
 473         for (ptr=buf; *ptr!=0; ++ptr) {
 474                 if (!isspace(*ptr)) {
 475                         if (!first_nonspace) {
 476                                 first_nonspace = ptr;
 477                         }
 478                         last_nonspace = ptr;
 479                 }
 480         }
 481
 482         if ((!first_nonspace) || (!last_nonspace)) {
 483                 buf[0] = 0;
 484                 return 0;
 485         }
 486
 487         new_len = last_nonspace - first_nonspace + 1;
 488         memmove(buf, first_nonspace, new_len);
 489         buf[new_len] = 0;
 490         return new_len;
 491 }
 492
 493
 494 /**
 495  * \brief check for the presence of a character within a string (returns count)
 496  * \param st the string to examine
 497  * \param ch the char to search
 498  * \return the position inside of st
 499  */
 500 int haschar(const char *st,int ch)
 501 {
 502         const char *ptr;
 503         int b;
 504         b = 0;
 505         ptr = st;
 506         while (!IsEmptyStr(ptr))
 507         {
 508                 if (*ptr == ch)
 509                         ++b;
 510                 ptr ++;
 511         }
 512         return (b);
 513 }
 514
 515
 516
 517
 518
 519 /*
 520  * Format a date/time stamp for output
 521  * seconds is whether to print the seconds
 522  */
 523 void fmt_date(char *buf, size_t n, time_t thetime, int seconds) {
 524         struct tm tm;
 525         int hour;
 526
 527         /* Month strings for date conversions ... this needs to be localized eventually */
 528         char *fmt_date_months[12] = {
 529                 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 530         };
 531
 532         strcpy(buf, "");
 533         localtime_r(&thetime, &tm);
 534
 535         hour = tm.tm_hour;
 536         if (hour == 0)  hour = 12;
 537         else if (hour > 12) hour = hour - 12;
 538
 539         if (seconds) {
 540                 snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s",
 541                         fmt_date_months[tm.tm_mon],
 542                         tm.tm_mday,
 543                         tm.tm_year + 1900,
 544                         hour,
 545                         tm.tm_min,
 546                         tm.tm_sec,
 547                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 548                 );
 549         } else {
 550                 snprintf(buf, n, "%s %d %4d %d:%02d%s",
 551                         fmt_date_months[tm.tm_mon],
 552                         tm.tm_mday,
 553                         tm.tm_year + 1900,
 554                         hour,
 555                         tm.tm_min,
 556                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 557                 );
 558         }
 559 }
 560
 561
 562
 563 /*
 564  * Determine whether the specified message number is contained within the
 565  * specified sequence set.
 566  */
 567 int is_msg_in_sequence_set(const char *mset, long msgnum) {
 568         int num_sets;
 569         int s;
 570         char setstr[128], lostr[128], histr[128];
 571         long lo, hi;
 572
 573         num_sets = num_tokens(mset, ',');
 574         for (s=0; s<num_sets; ++s) {
 575                 extract_token(setstr, mset, s, ',', sizeof setstr);
 576
 577                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
 578                 if (num_tokens(setstr, ':') >= 2) {
 579                         extract_token(histr, setstr, 1, ':', sizeof histr);
 580                         if (!strcmp(histr, "*")) {
 581                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
 582                         }
 583                 }
 584                 else {
 585                         strcpy(histr, lostr);
 586                 }
 587                 lo = atol(lostr);
 588                 hi = atol(histr);
 589
 590                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
 591         }
 592
 593         return(0);
 594 }
 595
 596 /**
 597  * \brief Utility function to "readline" from memory
 598  * \param start Location in memory from which we are reading.
 599  * \param buf the buffer to place the string in.
 600  * \param maxlen Size of string buffer
 601  * \return Pointer to the source memory right after we stopped reading.
 602  */
 603 char *memreadline(char *start, char *buf, int maxlen)
 604 {
 605         char ch;
 606         char *ptr;
 607         int len = 0;            /**< tally our own length to avoid strlen() delays */
 608
 609         ptr = start;
 610
 611         while (1) {
 612                 ch = *ptr++;
 613                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 614                         buf[len++] = ch;
 615                 }
 616                 if ((ch == 10) || (ch == 0)) {
 617                         buf[len] = 0;
 618                         return ptr;
 619                 }
 620         }
 621 }
 622
 623
 624 /**
 625  * \brief Utility function to "readline" from memory
 626  * \param start Location in memory from which we are reading.
 627  * \param buf the buffer to place the string in.
 628  * \param maxlen Size of string buffer
 629  * \param retlen the length of the returned string
 630  * \return Pointer to the source memory right after we stopped reading.
 631  */
 632 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
 633 {
 634         char ch;
 635         char *ptr;
 636         int len = 0;            /**< tally our own length to avoid strlen() delays */
 637
 638         ptr = start;
 639
 640         while (1) {
 641                 ch = *ptr++;
 642                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 643                         buf[len++] = ch;
 644                 }
 645                 if ((ch == 10) || (ch == 0)) {
 646                         buf[len] = 0;
 647                         *retlen = len;
 648                         return ptr;
 649                 }
 650         }
 651 }
 652
 653
 654
 655
 656 /*
 657  * Strip a boundarized substring out of a string (for example, remove
 658  * parentheses and anything inside them).
 659  */
 660 int stripout(char *str, char leftboundary, char rightboundary) {
 661         int a;
 662         int lb = (-1);
 663         int rb = (-1);
 664
 665         for (a = 0; a < strlen(str); ++a) {
 666                 if (str[a] == leftboundary) lb = a;
 667                 if (str[a] == rightboundary) rb = a;
 668         }
 669
 670         if ( (lb > 0) && (rb > lb) ) {
 671                 strcpy(&str[lb - 1], &str[rb + 1]);
 672                 return 1;
 673         }
 674
 675         else if ( (lb == 0) && (rb > lb) ) {
 676                 strcpy(str, &str[rb + 1]);
 677                 return 1;
 678         }
 679         return 0;
 680 }
 681
 682
 683 /*
 684  * Reduce a string down to a boundarized substring (for example, remove
 685  * parentheses and anything outside them).
 686  */
 687 void stripallbut(char *str, char leftboundary, char rightboundary) {
 688         int a;
 689
 690         for (a = 0; a < strlen(str); ++ a) {
 691                 if (str[a] == leftboundary) strcpy(str, &str[a+1]);
 692         }
 693
 694         for (a = 0; a < strlen(str); ++ a) {
 695                 if (str[a] == rightboundary) str[a] = 0;
 696         }
 697
 698 }
 699
 700 char *myfgets(char *s, int size, FILE *stream) {
 701         char *ret = fgets(s, size, stream);
 702         char *nl;
 703
 704         if (ret != NULL) {
 705                 nl = strchr(s, '\n');
 706
 707                 if (nl != NULL)
 708                         *nl = 0;
 709         }
 710
 711         return ret;
 712 }
 713
 714 /**
 715  * \brief Escape a string for feeding out as a URL.
 716  * \param outbuf the output buffer
 717  * \param oblen the size of outbuf to sanitize
 718  * \param strbuf the input buffer
 719  */
 720 void urlesc(char *outbuf, size_t oblen, char *strbuf)
 721 {
 722         int a, b, c, len, eclen, olen;
 723         char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
 724
 725         strcpy(outbuf, "");
 726         len = strlen(strbuf);
 727         eclen = strlen(ec);
 728         olen = 0;
 729         for (a = 0; a < len; ++a) {
 730                 c = 0;
 731                 for (b = 0; b < eclen; ++b) {
 732                         if (strbuf[a] == ec[b])
 733                                 c = 1;
 734                 }
 735                 if (c == 1) {
 736                         snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
 737                         olen += 3;
 738                 }
 739                 else
 740                         outbuf[olen ++] = strbuf[a];
 741         }
 742         outbuf[olen] = '\0';
 743 }
 744
 745
 746
 747 /*
 748  * In our world, we want strcpy() to be able to work with overlapping strings.
 749  */
 750 #ifdef strcpy
 751 #undef strcpy
 752 #endif
 753 char *strcpy(char *dest, const char *src) {
 754         memmove(dest, src, (strlen(src) + 1) );
 755         return(dest);
 756 }
 757
 758
 759 /*
 760  * Generate a new, globally unique UID parameter for a calendar etc. object
 761  */
 762 void generate_uuid(char *buf) {
 763         static int seq = 0;
 764
 765         sprintf(buf, "%lx-%lx-%x",
 766                 time(NULL),
 767                 (long)getpid(),
 768                 (seq++)
 769         );
 770 }
 771
 772 /*
 773  * bmstrcasestr() -- case-insensitive substring search
 774  *
 775  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 776  * The code is roughly based on the strstr() replacement from 'tin' written
 777  * by Urs Jannsen.
 778  */
 779 inline char *_bmstrcasestr_len(char *text, size_t textlen, char *pattern, size_t patlen) {
 780
 781         register unsigned char *p, *t;
 782         register int i, j, *delta;
 783         register size_t p1;
 784         int deltaspace[256];
 785
 786         if (!text) return(NULL);
 787         if (!pattern) return(NULL);
 788
 789         /* algorithm fails if pattern is empty */
 790         if ((p1 = patlen) == 0)
 791                 return (text);
 792
 793         /* code below fails (whenever i is unsigned) if pattern too long */
 794         if (p1 > textlen)
 795                 return (NULL);
 796
 797         /* set up deltas */
 798         delta = deltaspace;
 799         for (i = 0; i <= 255; i++)
 800                 delta[i] = p1;
 801         for (p = (unsigned char *) pattern, i = p1; --i > 0;)
 802                 delta[tolower(*p++)] = i;
 803
 804         /*
 805          * From now on, we want patlen - 1.
 806          * In the loop below, p points to the end of the pattern,
 807          * t points to the end of the text to be tested against the
 808          * pattern, and i counts the amount of text remaining, not
 809          * including the part to be tested.
 810          */
 811         p1--;
 812         p = (unsigned char *) pattern + p1;
 813         t = (unsigned char *) text + p1;
 814         i = textlen - patlen;
 815         while(1) {
 816                 if (tolower(p[0]) == tolower(t[0])) {
 817                         if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
 818                                 return ((char *)t - p1);
 819                         }
 820                 }
 821                 j = delta[tolower(t[0])];
 822                 if (i < j)
 823                         break;
 824                 i -= j;
 825                 t += j;
 826         }
 827         return (NULL);
 828 }
 829
 830 /*
 831  * bmstrcasestr() -- case-insensitive substring search
 832  *
 833  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 834  * The code is roughly based on the strstr() replacement from 'tin' written
 835  * by Urs Jannsen.
 836  */
 837 char *bmstrcasestr(char *text, char *pattern) {
 838         size_t textlen;
 839         size_t patlen;
 840
 841         if (!text) return(NULL);
 842         if (!pattern) return(NULL);
 843
 844         textlen = strlen (text);
 845         patlen = strlen (pattern);
 846
 847         return _bmstrcasestr_len(text, textlen, pattern, patlen);
 848 }
 849
 850 char *bmstrcasestr_len(char *text, size_t textlen, char *pattern, size_t patlen) {
 851         return _bmstrcasestr_len(text, textlen, pattern, patlen);
 852 }
 853
 854 /*
 855  * Local replacement for controversial C library function that generates
 856  * names for temporary files.  Included to shut up compiler warnings.
 857  */
 858 void CtdlMakeTempFileName(char *name, int len) {
 859         int i = 0;
 860
 861         while (i++, i < 100) {
 862                 snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
 863                         (long)getpid(),
 864                         rand()
 865                 );
 866                 if (!access(name, F_OK)) {
 867                         return;
 868                 }
 869         }
 870 }
 871
 872
 873
 874 /*
 875  * Determine whether the specified message number is contained within the specified set.
 876  * Returns nonzero if the specified message number is in the specified message set string.
 877  */
 878 int is_msg_in_mset(const char *mset, long msgnum) {
 879         int num_sets;
 880         int s;
 881         char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
 882         long lo, hi;
 883
 884         /*
 885          * Now set it for all specified messages.
 886          */
 887         num_sets = num_tokens(mset, ',');
 888         for (s=0; s<num_sets; ++s) {
 889                 extract_token(setstr, mset, s, ',', sizeof setstr);
 890
 891                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
 892                 if (num_tokens(setstr, ':') >= 2) {
 893                         extract_token(histr, setstr, 1, ':', sizeof histr);
 894                         if (!strcmp(histr, "*")) {
 895                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
 896                         }
 897                 }
 898                 else {
 899                         strcpy(histr, lostr);
 900                 }
 901                 lo = atol(lostr);
 902                 hi = atol(histr);
 903
 904                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
 905         }
 906
 907         return(0);
 908 }
 909
 910
 911 /*
 912  * searches for a pattern within a search string
 913  * returns position in string
 914  */
 915 int pattern2(char *search, char *patn)
 916 {
 917         int a;
 918         int len, plen;
 919         len = strlen (search);
 920         plen = strlen (patn);
 921         for (a = 0; a < len; ++a) {
 922                 if (!strncasecmp(&search[a], patn, plen))
 923                         return (a);
 924         }
 925         return (-1);
 926 }
 927
 928
 929 /*
 930  * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
 931  * buf - the string to modify
 932  * len - length of the string.
 933  */
 934 void stripltlen(char *buf, int *len)
 935 {
 936         int delta = 0;
 937         if (*len == 0) return;
 938         while ((*len > delta) && (isspace(buf[delta]))){
 939                 delta ++;
 940         }
 941         memmove (buf, &buf[delta], *len - delta + 1);
 942         (*len) -=delta;
 943
 944         if (*len == 0) return;
 945         while (isspace(buf[(*len) - 1])){
 946                 buf[--(*len)] = '\0';
 947         }
 948 }
 949
 950 /**
 951  * \brief detect whether this char starts an utf-8 encoded char
 952  * \param Char character to inspect
 953  * \returns yes or no
 954  */
 955 inline int Ctdl_IsUtf8SequenceStart(char Char)
 956 {
 957 /** 11??.???? indicates an UTF8 Sequence. */
 958         return ((Char & 0xC0) != 0);
 959 }
 960
 961 /**
 962  * \brief evaluate the length of an utf8 special character sequence
 963  * \param Char the character to examine
 964  * \returns width of utf8 chars in bytes
 965  */
 966 inline int Ctdl_GetUtf8SequenceLength(char Char)
 967 {
 968         int n = 1;
 969         char test = (1<<7);
 970
 971         while ((n < 8) && ((test & Char) != 0)) {
 972                 test = test << 1;
 973                 n ++;
 974         }
 975         if (n > 6)
 976                 n = 1;
 977         return n;
 978 }
 979
 980 /**
 981  * \brief measure the number of glyphs in an UTF8 string...
 982  * \param str string to measure
 983  * \returns the length of str
 984  */
 985 int Ctdl_Utf8StrLen(char *str)
 986 {
 987         int n = 0;
 988         int m = 0;
 989         char *aptr;
 990
 991         if (str == NULL)
 992                 return n;
 993         aptr = str;
 994         while (*aptr != '\0') {
 995                 if (Ctdl_IsUtf8SequenceStart(*aptr)){
 996                         m = Ctdl_GetUtf8SequenceLength(*aptr);
 997                         while ((m-- > 0) && (*aptr++ != '\0'))
 998                                 n ++;
 999                 }
1000                 else {
1001                         n++;
1002                         aptr++;
1003                 }
1004
1005         }
1006         return n;
1007 }
1008
1009 /**
1010  * \brief cuts a string after maxlen glyphs
1011  * \param str string to cut to maxlen glyphs
1012  * \param maxlen how long may the string become?
1013  * \returns pointer to maxlen or the end of the string
1014  */
1015 char *Ctdl_Utf8StrCut(char *str, int maxlen)
1016 {
1017         int n = 0, m = 0;
1018         char *aptr;
1019
1020         if (str == NULL)
1021                 return NULL;
1022         aptr = str;
1023         while (*aptr != '\0') {
1024                 if (Ctdl_IsUtf8SequenceStart(*aptr)){
1025                         m = Ctdl_GetUtf8SequenceLength(*aptr);
1026                         while ((m-- > 0) && (*aptr++ != '\0'))
1027                                 n ++;
1028                 }
1029                 else {
1030                         n++;
1031                         aptr++;
1032                 }
1033                 if (n > maxlen) {
1034                         *aptr = '\0';
1035                         return aptr;
1036                 }
1037         }
1038         return aptr;
1039 }
1040
1041
1042 /*
1043  * Convert all whitespace characters in a supplied string to underscores
1044  */
1045 void convert_spaces_to_underscores(char *str)
1046 {
1047         int len;
1048         int i;
1049
1050         if (!str) return;
1051
1052         len = strlen(str);
1053         for (i=0; i<len; ++i) {
1054                 if (isspace(str[i])) {
1055                         str[i] = '_';
1056                 }
1057         }
1058 }
1059
1060