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 void striplt(char *buf)
 464 {
 465         size_t len;
 466         int a;
 467
 468         if (buf==NULL) return;
 469         if (IsEmptyStr(buf)) return;
 470         len = strlen(buf);
 471         while ((!IsEmptyStr(buf)) && (isspace(buf[len - 1])))
 472                 buf[--len] = 0;
 473         if (IsEmptyStr(buf)) return;
 474         a = 0;
 475         while ((!IsEmptyStr(buf)) && (isspace(buf[a])))
 476                 a++;
 477         if (a > 0)
 478                 memmove(buf, &buf[a], len - a + 1);
 479 }
 480
 481
 482
 483
 484
 485 /**
 486  * \brief check for the presence of a character within a string (returns count)
 487  * \param st the string to examine
 488  * \param ch the char to search
 489  * \return the position inside of st
 490  */
 491 int haschar(const char *st,int ch)
 492 {
 493         const char *ptr;
 494         int b;
 495         b = 0;
 496         ptr = st;
 497         while (!IsEmptyStr(ptr))
 498         {
 499                 if (*ptr == ch)
 500                         ++b;
 501                 ptr ++;
 502         }
 503         return (b);
 504 }
 505
 506
 507
 508
 509
 510 /*
 511  * Format a date/time stamp for output
 512  * seconds is whether to print the seconds
 513  */
 514 void fmt_date(char *buf, size_t n, time_t thetime, int seconds) {
 515         struct tm tm;
 516         int hour;
 517
 518         /* Month strings for date conversions ... this needs to be localized eventually */
 519         char *fmt_date_months[12] = {
 520                 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 521         };
 522
 523         strcpy(buf, "");
 524         localtime_r(&thetime, &tm);
 525
 526         hour = tm.tm_hour;
 527         if (hour == 0)  hour = 12;
 528         else if (hour > 12) hour = hour - 12;
 529
 530         if (seconds) {
 531                 snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s",
 532                         fmt_date_months[tm.tm_mon],
 533                         tm.tm_mday,
 534                         tm.tm_year + 1900,
 535                         hour,
 536                         tm.tm_min,
 537                         tm.tm_sec,
 538                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 539                 );
 540         } else {
 541                 snprintf(buf, n, "%s %d %4d %d:%02d%s",
 542                         fmt_date_months[tm.tm_mon],
 543                         tm.tm_mday,
 544                         tm.tm_year + 1900,
 545                         hour,
 546                         tm.tm_min,
 547                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 548                 );
 549         }
 550 }
 551
 552
 553
 554 /*
 555  * Determine whether the specified message number is contained within the
 556  * specified sequence set.
 557  */
 558 int is_msg_in_sequence_set(char *mset, long msgnum) {
 559         int num_sets;
 560         int s;
 561         char setstr[128], lostr[128], histr[128];
 562         long lo, hi;
 563
 564         num_sets = num_tokens(mset, ',');
 565         for (s=0; s<num_sets; ++s) {
 566                 extract_token(setstr, mset, s, ',', sizeof setstr);
 567
 568                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
 569                 if (num_tokens(setstr, ':') >= 2) {
 570                         extract_token(histr, setstr, 1, ':', sizeof histr);
 571                         if (!strcmp(histr, "*")) {
 572                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
 573                         }
 574                 }
 575                 else {
 576                         strcpy(histr, lostr);
 577                 }
 578                 lo = atol(lostr);
 579                 hi = atol(histr);
 580
 581                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
 582         }
 583
 584         return(0);
 585 }
 586
 587 /**
 588  * \brief Utility function to "readline" from memory
 589  * \param start Location in memory from which we are reading.
 590  * \param buf the buffer to place the string in.
 591  * \param maxlen Size of string buffer
 592  * \return Pointer to the source memory right after we stopped reading.
 593  */
 594 char *memreadline(char *start, char *buf, int maxlen)
 595 {
 596         char ch;
 597         char *ptr;
 598         int len = 0;            /**< tally our own length to avoid strlen() delays */
 599
 600         ptr = start;
 601
 602         while (1) {
 603                 ch = *ptr++;
 604                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 605                         buf[len++] = ch;
 606                 }
 607                 if ((ch == 10) || (ch == 0)) {
 608                         buf[len] = 0;
 609                         return ptr;
 610                 }
 611         }
 612 }
 613
 614
 615 /**
 616  * \brief Utility function to "readline" from memory
 617  * \param start Location in memory from which we are reading.
 618  * \param buf the buffer to place the string in.
 619  * \param maxlen Size of string buffer
 620  * \param retlen the length of the returned string
 621  * \return Pointer to the source memory right after we stopped reading.
 622  */
 623 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
 624 {
 625         char ch;
 626         char *ptr;
 627         int len = 0;            /**< tally our own length to avoid strlen() delays */
 628
 629         ptr = start;
 630
 631         while (1) {
 632                 ch = *ptr++;
 633                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 634                         buf[len++] = ch;
 635                 }
 636                 if ((ch == 10) || (ch == 0)) {
 637                         buf[len] = 0;
 638                         *retlen = len;
 639                         return ptr;
 640                 }
 641         }
 642 }
 643
 644
 645
 646
 647 /*
 648  * Strip a boundarized substring out of a string (for example, remove
 649  * parentheses and anything inside them).
 650  */
 651 void stripout(char *str, char leftboundary, char rightboundary) {
 652         int a;
 653         int lb = (-1);
 654         int rb = (-1);
 655
 656         for (a = 0; a < strlen(str); ++a) {
 657                 if (str[a] == leftboundary) lb = a;
 658                 if (str[a] == rightboundary) rb = a;
 659         }
 660
 661         if ( (lb > 0) && (rb > lb) ) {
 662                 strcpy(&str[lb - 1], &str[rb + 1]);
 663         }
 664
 665         else if ( (lb == 0) && (rb > lb) ) {
 666                 strcpy(str, &str[rb + 1]);
 667         }
 668
 669 }
 670
 671
 672 /*
 673  * Reduce a string down to a boundarized substring (for example, remove
 674  * parentheses and anything outside them).
 675  */
 676 void stripallbut(char *str, char leftboundary, char rightboundary) {
 677         int a;
 678
 679         for (a = 0; a < strlen(str); ++ a) {
 680                 if (str[a] == leftboundary) strcpy(str, &str[a+1]);
 681         }
 682
 683         for (a = 0; a < strlen(str); ++ a) {
 684                 if (str[a] == rightboundary) str[a] = 0;
 685         }
 686
 687 }
 688
 689 char *myfgets(char *s, int size, FILE *stream) {
 690         char *ret = fgets(s, size, stream);
 691         char *nl;
 692
 693         if (ret != NULL) {
 694                 nl = strchr(s, '\n');
 695
 696                 if (nl != NULL)
 697                         *nl = 0;
 698         }
 699
 700         return ret;
 701 }
 702
 703 /**
 704  * \brief Escape a string for feeding out as a URL.
 705  * \param outbuf the output buffer
 706  * \param oblen the size of outbuf to sanitize
 707  * \param strbuf the input buffer
 708  */
 709 void urlesc(char *outbuf, size_t oblen, char *strbuf)
 710 {
 711         int a, b, c, len, eclen, olen;
 712         char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
 713
 714         strcpy(outbuf, "");
 715         len = strlen(strbuf);
 716         eclen = strlen(ec);
 717         olen = 0;
 718         for (a = 0; a < len; ++a) {
 719                 c = 0;
 720                 for (b = 0; b < eclen; ++b) {
 721                         if (strbuf[a] == ec[b])
 722                                 c = 1;
 723                 }
 724                 if (c == 1) {
 725                         snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
 726                         olen += 3;
 727                 }
 728                 else
 729                         outbuf[olen ++] = strbuf[a];
 730         }
 731         outbuf[olen] = '\0';
 732 }
 733
 734
 735
 736 /*
 737  * In our world, we want strcpy() to be able to work with overlapping strings.
 738  */
 739 #ifdef strcpy
 740 #undef strcpy
 741 #endif
 742 char *strcpy(char *dest, const char *src) {
 743         memmove(dest, src, (strlen(src) + 1) );
 744         return(dest);
 745 }
 746
 747
 748 /*
 749  * Generate a new, globally unique UID parameter for a calendar etc. object
 750  */
 751 void generate_uuid(char *buf) {
 752         static int seq = 0;
 753
 754         sprintf(buf, "%lx-%lx-%x",
 755                 time(NULL),
 756                 (long)getpid(),
 757                 (seq++)
 758         );
 759 }
 760
 761 /*
 762  * bmstrcasestr() -- case-insensitive substring search
 763  *
 764  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 765  * The code is roughly based on the strstr() replacement from 'tin' written
 766  * by Urs Jannsen.
 767  */
 768 char *bmstrcasestr(char *text, char *pattern) {
 769
 770         register unsigned char *p, *t;
 771         register int i, j, *delta;
 772         register size_t p1;
 773         int deltaspace[256];
 774         size_t textlen;
 775         size_t patlen;
 776
 777         if (!text) return(NULL);
 778         if (!pattern) return(NULL);
 779
 780         textlen = strlen (text);
 781         patlen = strlen (pattern);
 782
 783         /* algorithm fails if pattern is empty */
 784         if ((p1 = patlen) == 0)
 785                 return (text);
 786
 787         /* code below fails (whenever i is unsigned) if pattern too long */
 788         if (p1 > textlen)
 789                 return (NULL);
 790
 791         /* set up deltas */
 792         delta = deltaspace;
 793         for (i = 0; i <= 255; i++)
 794                 delta[i] = p1;
 795         for (p = (unsigned char *) pattern, i = p1; --i > 0;)
 796                 delta[tolower(*p++)] = i;
 797
 798         /*
 799          * From now on, we want patlen - 1.
 800          * In the loop below, p points to the end of the pattern,
 801          * t points to the end of the text to be tested against the
 802          * pattern, and i counts the amount of text remaining, not
 803          * including the part to be tested.
 804          */
 805         p1--;
 806         p = (unsigned char *) pattern + p1;
 807         t = (unsigned char *) text + p1;
 808         i = textlen - patlen;
 809         while(1) {
 810                 if (tolower(p[0]) == tolower(t[0])) {
 811                         if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
 812                                 return ((char *)t - p1);
 813                         }
 814                 }
 815                 j = delta[tolower(t[0])];
 816                 if (i < j)
 817                         break;
 818                 i -= j;
 819                 t += j;
 820         }
 821         return (NULL);
 822 }
 823
 824
 825
 826 /*
 827  * Local replacement for controversial C library function that generates
 828  * names for temporary files.  Included to shut up compiler warnings.
 829  */
 830 void CtdlMakeTempFileName(char *name, int len) {
 831         int i = 0;
 832
 833         while (i++, i < 100) {
 834                 snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
 835                         (long)getpid(),
 836                         rand()
 837                 );
 838                 if (!access(name, F_OK)) {
 839                         return;
 840                 }
 841         }
 842 }
 843
 844
 845
 846 /*
 847  * Determine whether the specified message number is contained within the specified set.
 848  * Returns nonzero if the specified message number is in the specified message set string.
 849  */
 850 int is_msg_in_mset(char *mset, long msgnum) {
 851         int num_sets;
 852         int s;
 853         char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
 854         long lo, hi;
 855
 856         /*
 857          * Now set it for all specified messages.
 858          */
 859         num_sets = num_tokens(mset, ',');
 860         for (s=0; s<num_sets; ++s) {
 861                 extract_token(setstr, mset, s, ',', sizeof setstr);
 862
 863                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
 864                 if (num_tokens(setstr, ':') >= 2) {
 865                         extract_token(histr, setstr, 1, ':', sizeof histr);
 866                         if (!strcmp(histr, "*")) {
 867                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
 868                         }
 869                 }
 870                 else {
 871                         strcpy(histr, lostr);
 872                 }
 873                 lo = atol(lostr);
 874                 hi = atol(histr);
 875
 876                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
 877         }
 878
 879         return(0);
 880 }
 881
 882
 883 /*
 884  * \brief searches for a  paternn within asearch string
 885  * \param search the string to search
 886  * \param patn the pattern to find in string
 887  * \returns position in string
 888  */
 889 int pattern2(char *search, char *patn)
 890 {
 891         int a;
 892         int len, plen;
 893         len = strlen (search);
 894         plen = strlen (patn);
 895         for (a = 0; a < len; ++a) {
 896                 if (!strncasecmp(&search[a], patn, plen))
 897                         return (a);
 898         }
 899         return (-1);
 900 }
 901
 902
 903 /*
 904  * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
 905  * buf - the string to modify
 906  * len - length of the string.
 907  */
 908 void stripltlen(char *buf, int *len)
 909 {
 910         int delta = 0;
 911         if (*len == 0) return;
 912         while ((*len > delta) && (isspace(buf[delta]))){
 913                 delta ++;
 914         }
 915         memmove (buf, &buf[delta], *len - delta + 1);
 916         (*len) -=delta;
 917
 918         if (*len == 0) return;
 919         while (isspace(buf[(*len) - 1])){
 920                 buf[--(*len)] = '\0';
 921         }
 922 }
 923
 924 /**
 925  * \brief detect whether this char starts an utf-8 encoded char
 926  * \param Char character to inspect
 927  * \returns yes or no
 928  */
 929 inline int Ctdl_IsUtf8SequenceStart(char Char)
 930 {
 931 /** 11??.???? indicates an UTF8 Sequence. */
 932         return ((Char & 0xC0) != 0);
 933 }
 934
 935 /**
 936  * \brief evaluate the length of an utf8 special character sequence
 937  * \param Char the character to examine
 938  * \returns width of utf8 chars in bytes
 939  */
 940 inline int Ctdl_GetUtf8SequenceLength(char Char)
 941 {
 942         int n = 1;
 943         char test = (1<<7);
 944
 945         while ((n < 8) && ((test & Char) != 0)) {
 946                 test = test << 1;
 947                 n ++;
 948         }
 949         if (n > 6)
 950                 n = 1;
 951         return n;
 952 }
 953
 954 /**
 955  * \brief measure the number of glyphs in an UTF8 string...
 956  * \param str string to measure
 957  * \returns the length of str
 958  */
 959 int Ctdl_Utf8StrLen(char *str)
 960 {
 961         int n = 0;
 962         int m = 0;
 963         char *aptr;
 964
 965         if (str == NULL)
 966                 return n;
 967         aptr = str;
 968         while (*aptr != '\0') {
 969                 if (Ctdl_IsUtf8SequenceStart(*aptr)){
 970                         m = Ctdl_GetUtf8SequenceLength(*aptr);
 971                         while ((m-- > 0) && (*aptr++ != '\0'))
 972                                 n ++;
 973                 }
 974                 else {
 975                         n++;
 976                         aptr++;
 977                 }
 978
 979         }
 980         return n;
 981 }
 982
 983 /**
 984  * \brief cuts a string after maxlen glyphs
 985  * \param str string to cut to maxlen glyphs
 986  * \param maxlen how long may the string become?
 987  * \returns pointer to maxlen or the end of the string
 988  */
 989 char *Ctdl_Utf8StrCut(char *str, int maxlen)
 990 {
 991         int n, m = 0;
 992         char *aptr;
 993
 994         if (str == NULL)
 995                 return NULL;
 996         aptr = str;
 997         while (*aptr != '\0') {
 998                 if (Ctdl_IsUtf8SequenceStart(*aptr)){
 999                         m = Ctdl_GetUtf8SequenceLength(*aptr);
1000                         while ((m-- > 0) && (*aptr++ != '\0'))
1001                                 n ++;
1002                 }
1003                 else {
1004                         n++;
1005                         aptr++;
1006                 }
1007                 if (n > maxlen) {
1008                         *aptr = '\0';
1009                         return aptr;
1010                 }
1011         }
1012         return aptr;
1013 }
1014
1015
1016 /*
1017  * Convert all whitespace characters in a supplied string to underscores
1018  */
1019 void convert_spaces_to_underscores(char *str)
1020 {
1021         int len;
1022         int i;
1023
1024         if (!str) return;
1025
1026         len = strlen(str);
1027         for (i=0; i<len; ++i) {
1028                 if (isspace(str[i])) {
1029                         str[i] = '_';
1030                 }
1031         }
1032 }
1033