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  * removes double slashes from pathnames
 461  * allows / disallows trailing slashes
 462  */
 463 void StripSlashes(char *Dir, int TrailingSlash)
 464 {
 465         char *a, *b;
 466
 467         a = b = Dir;
 468
 469         while (!IsEmptyStr(a)) {
 470                 if (*a == '/') {
 471                         while (*a == '/')
 472                                 a++;
 473                         *b = '/';
 474                         b++;
 475                 }
 476                 else {
 477                         *b = *a;
 478                         b++; a++;
 479                 }
 480         }
 481         if ((TrailingSlash) && (*(b - 1) != '/')){
 482                 *b = '/';
 483                 b++;
 484         }
 485         *b = '\0';
 486
 487 }
 488
 489 /*
 490  * Strip leading and trailing spaces from a string
 491  */
 492 size_t striplt(char *buf) {
 493         char *first_nonspace = NULL;
 494         char *last_nonspace = NULL;
 495         char *ptr;
 496         size_t new_len = 0;
 497
 498         if ((buf == NULL) || (*buf == '\0')) {
 499                 return 0;
 500         }
 501
 502         for (ptr=buf; *ptr!=0; ++ptr) {
 503                 if (!isspace(*ptr)) {
 504                         if (!first_nonspace) {
 505                                 first_nonspace = ptr;
 506                         }
 507                         last_nonspace = ptr;
 508                 }
 509         }
 510
 511         if ((!first_nonspace) || (!last_nonspace)) {
 512                 buf[0] = 0;
 513                 return 0;
 514         }
 515
 516         new_len = last_nonspace - first_nonspace + 1;
 517         memmove(buf, first_nonspace, new_len);
 518         buf[new_len] = 0;
 519         return new_len;
 520 }
 521
 522
 523 /**
 524  * \brief check for the presence of a character within a string (returns count)
 525  * \param st the string to examine
 526  * \param ch the char to search
 527  * \return the number of times ch appears in st
 528  */
 529 int haschar(const char *st, int ch)
 530 {
 531         const char *ptr;
 532         int b;
 533         b = 0;
 534         ptr = st;
 535         while (!IsEmptyStr(ptr))
 536         {
 537                 if (*ptr == ch)
 538                         ++b;
 539                 ptr ++;
 540         }
 541         return (b);
 542 }
 543
 544
 545
 546
 547
 548 /*
 549  * Format a date/time stamp for output
 550  * seconds is whether to print the seconds
 551  */
 552 void fmt_date(char *buf, size_t n, time_t thetime, int seconds) {
 553         struct tm tm;
 554         int hour;
 555
 556         /* Month strings for date conversions ... this needs to be localized eventually */
 557         char *fmt_date_months[12] = {
 558                 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 559         };
 560
 561         strcpy(buf, "");
 562         localtime_r(&thetime, &tm);
 563
 564         hour = tm.tm_hour;
 565         if (hour == 0)  hour = 12;
 566         else if (hour > 12) hour = hour - 12;
 567
 568         if (seconds) {
 569                 snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s",
 570                         fmt_date_months[tm.tm_mon],
 571                         tm.tm_mday,
 572                         tm.tm_year + 1900,
 573                         hour,
 574                         tm.tm_min,
 575                         tm.tm_sec,
 576                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 577                 );
 578         } else {
 579                 snprintf(buf, n, "%s %d %4d %d:%02d%s",
 580                         fmt_date_months[tm.tm_mon],
 581                         tm.tm_mday,
 582                         tm.tm_year + 1900,
 583                         hour,
 584                         tm.tm_min,
 585                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
 586                 );
 587         }
 588 }
 589
 590
 591
 592 /*
 593  * Determine whether the specified message number is contained within the
 594  * specified sequence set.
 595  */
 596 int is_msg_in_sequence_set(const char *mset, long msgnum) {
 597         int num_sets;
 598         int s;
 599         char setstr[128], lostr[128], histr[128];
 600         long lo, hi;
 601
 602         num_sets = num_tokens(mset, ',');
 603         for (s=0; s<num_sets; ++s) {
 604                 extract_token(setstr, mset, s, ',', sizeof setstr);
 605
 606                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
 607                 if (num_tokens(setstr, ':') >= 2) {
 608                         extract_token(histr, setstr, 1, ':', sizeof histr);
 609                         if (!strcmp(histr, "*")) {
 610                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
 611                         }
 612                 }
 613                 else {
 614                         strcpy(histr, lostr);
 615                 }
 616                 lo = atol(lostr);
 617                 hi = atol(histr);
 618
 619                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
 620         }
 621
 622         return(0);
 623 }
 624
 625 /**
 626  * \brief Utility function to "readline" from memory
 627  * \param start Location in memory from which we are reading.
 628  * \param buf the buffer to place the string in.
 629  * \param maxlen Size of string buffer
 630  * \return Pointer to the source memory right after we stopped reading.
 631  */
 632 char *memreadline(char *start, char *buf, int maxlen)
 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                         return ptr;
 648                 }
 649         }
 650 }
 651
 652
 653 /**
 654  * \brief Utility function to "readline" from memory
 655  * \param start Location in memory from which we are reading.
 656  * \param buf the buffer to place the string in.
 657  * \param maxlen Size of string buffer
 658  * \param retlen the length of the returned string
 659  * \return Pointer to the source memory right after we stopped reading.
 660  */
 661 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
 662 {
 663         char ch;
 664         char *ptr;
 665         int len = 0;            /**< tally our own length to avoid strlen() delays */
 666
 667         ptr = start;
 668
 669         while (1) {
 670                 ch = *ptr++;
 671                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 672                         buf[len++] = ch;
 673                 }
 674                 if ((ch == 10) || (ch == 0)) {
 675                         buf[len] = 0;
 676                         *retlen = len;
 677                         return ptr;
 678                 }
 679         }
 680 }
 681
 682
 683 /**
 684  * \brief Utility function to "readline" from memory
 685  * \param start Location in memory from which we are reading.
 686  * \param buf the buffer to place the string in.
 687  * \param maxlen Size of string buffer
 688  * \return Pointer to the source memory right after we stopped reading.
 689  */
 690 const char *cmemreadline(const char *start, char *buf, int maxlen)
 691 {
 692         char ch;
 693         const char *ptr;
 694         int len = 0;            /**< tally our own length to avoid strlen() delays */
 695
 696         ptr = start;
 697
 698         while (1) {
 699                 ch = *ptr++;
 700                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 701                         buf[len++] = ch;
 702                 }
 703                 if ((ch == 10) || (ch == 0)) {
 704                         buf[len] = 0;
 705                         return ptr;
 706                 }
 707         }
 708 }
 709
 710
 711 /**
 712  * \brief Utility function to "readline" from memory
 713  * \param start Location in memory from which we are reading.
 714  * \param buf the buffer to place the string in.
 715  * \param maxlen Size of string buffer
 716  * \param retlen the length of the returned string
 717  * \return Pointer to the source memory right after we stopped reading.
 718  */
 719 const char *cmemreadlinelen(const char *start, char *buf, int maxlen, int *retlen)
 720 {
 721         char ch;
 722         const char *ptr;
 723         int len = 0;            /**< tally our own length to avoid strlen() delays */
 724
 725         ptr = start;
 726
 727         while (1) {
 728                 ch = *ptr++;
 729                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
 730                         buf[len++] = ch;
 731                 }
 732                 if ((ch == 10) || (ch == 0)) {
 733                         buf[len] = 0;
 734                         *retlen = len;
 735                         return ptr;
 736                 }
 737         }
 738 }
 739
 740
 741
 742
 743 /*
 744  * Strip a boundarized substring out of a string (for example, remove
 745  * parentheses and anything inside them).
 746  */
 747 int stripout(char *str, char leftboundary, char rightboundary) {
 748         int a;
 749         int lb = (-1);
 750         int rb = (-1);
 751
 752         for (a = 0; a < strlen(str); ++a) {
 753                 if (str[a] == leftboundary) lb = a;
 754                 if (str[a] == rightboundary) rb = a;
 755         }
 756
 757         if ( (lb > 0) && (rb > lb) ) {
 758                 strcpy(&str[lb - 1], &str[rb + 1]);
 759                 return 1;
 760         }
 761
 762         else if ( (lb == 0) && (rb > lb) ) {
 763                 strcpy(str, &str[rb + 1]);
 764                 return 1;
 765         }
 766         return 0;
 767 }
 768
 769
 770 /*
 771  * Reduce a string down to a boundarized substring (for example, remove
 772  * parentheses and anything outside them).
 773  */
 774 long stripallbut(char *str, char leftboundary, char rightboundary) {
 775         long len = 0;
 776
 777         char *lb = NULL;
 778         char *rb = NULL;
 779
 780         lb = strrchr(str, leftboundary);
 781         if (lb != NULL) {
 782                 ++lb;
 783                 rb = strchr(str, rightboundary);
 784                 if ((rb != NULL) && (rb >= lb))  {
 785                         *rb = 0;
 786                         fflush(stderr);
 787                         len = (long)rb - (long)lb;
 788                         memmove(str, lb, len);
 789                         str[len] = 0;
 790                         return(len);
 791                 }
 792         }
 793
 794         return (long)strlen(str);
 795 }
 796
 797
 798 char *myfgets(char *s, int size, FILE *stream) {
 799         char *ret = fgets(s, size, stream);
 800         char *nl;
 801
 802         if (ret != NULL) {
 803                 nl = strchr(s, '\n');
 804
 805                 if (nl != NULL)
 806                         *nl = 0;
 807         }
 808
 809         return ret;
 810 }
 811
 812 /**
 813  * \brief Escape a string for feeding out as a URL.
 814  * \param outbuf the output buffer
 815  * \param oblen the size of outbuf to sanitize
 816  * \param strbuf the input buffer
 817  */
 818 void urlesc(char *outbuf, size_t oblen, char *strbuf)
 819 {
 820         int a, b, c, len, eclen, olen;
 821         char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
 822
 823         strcpy(outbuf, "");
 824         len = strlen(strbuf);
 825         eclen = strlen(ec);
 826         olen = 0;
 827         for (a = 0; a < len; ++a) {
 828                 c = 0;
 829                 for (b = 0; b < eclen; ++b) {
 830                         if (strbuf[a] == ec[b])
 831                                 c = 1;
 832                 }
 833                 if (c == 1) {
 834                         snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
 835                         olen += 3;
 836                 }
 837                 else
 838                         outbuf[olen ++] = strbuf[a];
 839         }
 840         outbuf[olen] = '\0';
 841 }
 842
 843
 844
 845 /*
 846  * In our world, we want strcpy() to be able to work with overlapping strings.
 847  */
 848 #ifdef strcpy
 849 #undef strcpy
 850 #endif
 851 char *strcpy(char *dest, const char *src) {
 852         memmove(dest, src, (strlen(src) + 1) );
 853         return(dest);
 854 }
 855
 856
 857 /*
 858  * Generate a new, globally unique UID parameter for a calendar etc. object
 859  */
 860 void generate_uuid(char *buf) {
 861         static int seq = (-1);
 862
 863 <<<<<<< HEAD
 864         if (seq == (-1)) {
 865                 seq = (int)rand();
 866         }
 867 =======
 868 >>>>>>> d0e228d... generate_uuid() now generates more or less DCE-compliant uuid's
 869         ++seq;
 870         seq = (seq % 0x0FFF) ;
 871
 872         sprintf(buf, "%08lx-%04lx-4%03x-a%03x-%012lx",
 873                 (long)time(NULL),
 874                 (long)getpid(),
 875                 seq,
 876                 seq,
 877                 (long)rand()
 878         );
 879 }
 880
 881 /*
 882  * bmstrcasestr() -- case-insensitive substring search
 883  *
 884  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 885  * The code is roughly based on the strstr() replacement from 'tin' written
 886  * by Urs Jannsen.
 887  */
 888 inline static char *_bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
 889
 890         register unsigned char *p, *t;
 891         register int i, j, *delta;
 892         register size_t p1;
 893         int deltaspace[256];
 894
 895         if (!text) return(NULL);
 896         if (!pattern) return(NULL);
 897
 898         /* algorithm fails if pattern is empty */
 899         if ((p1 = patlen) == 0)
 900                 return (text);
 901
 902         /* code below fails (whenever i is unsigned) if pattern too long */
 903         if (p1 > textlen)
 904                 return (NULL);
 905
 906         /* set up deltas */
 907         delta = deltaspace;
 908         for (i = 0; i <= 255; i++)
 909                 delta[i] = p1;
 910         for (p = (unsigned char *) pattern, i = p1; --i > 0;)
 911                 delta[tolower(*p++)] = i;
 912
 913         /*
 914          * From now on, we want patlen - 1.
 915          * In the loop below, p points to the end of the pattern,
 916          * t points to the end of the text to be tested against the
 917          * pattern, and i counts the amount of text remaining, not
 918          * including the part to be tested.
 919          */
 920         p1--;
 921         p = (unsigned char *) pattern + p1;
 922         t = (unsigned char *) text + p1;
 923         i = textlen - patlen;
 924         while(1) {
 925                 if (tolower(p[0]) == tolower(t[0])) {
 926                         if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
 927                                 return ((char *)t - p1);
 928                         }
 929                 }
 930                 j = delta[tolower(t[0])];
 931                 if (i < j)
 932                         break;
 933                 i -= j;
 934                 t += j;
 935         }
 936         return (NULL);
 937 }
 938
 939 /*
 940  * bmstrcasestr() -- case-insensitive substring search
 941  *
 942  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 943  * The code is roughly based on the strstr() replacement from 'tin' written
 944  * by Urs Jannsen.
 945  */
 946 char *bmstrcasestr(char *text, const char *pattern) {
 947         size_t textlen;
 948         size_t patlen;
 949
 950         if (!text) return(NULL);
 951         if (!pattern) return(NULL);
 952
 953         textlen = strlen (text);
 954         patlen = strlen (pattern);
 955
 956         return _bmstrcasestr_len(text, textlen, pattern, patlen);
 957 }
 958
 959 char *bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
 960         return _bmstrcasestr_len(text, textlen, pattern, patlen);
 961 }
 962
 963
 964
 965
 966 /*
 967  * bmstrcasestr() -- case-insensitive substring search
 968  *
 969  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
 970  * The code is roughly based on the strstr() replacement from 'tin' written
 971  * by Urs Jannsen.
 972  */
 973 inline static const char *_cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
 974
 975         register unsigned char *p, *t;
 976         register int i, j, *delta;
 977         register size_t p1;
 978         int deltaspace[256];
 979
 980         if (!text) return(NULL);
 981         if (!pattern) return(NULL);
 982
 983         /* algorithm fails if pattern is empty */
 984         if ((p1 = patlen) == 0)
 985                 return (text);
 986
 987         /* code below fails (whenever i is unsigned) if pattern too long */
 988         if (p1 > textlen)
 989                 return (NULL);
 990
 991         /* set up deltas */
 992         delta = deltaspace;
 993         for (i = 0; i <= 255; i++)
 994                 delta[i] = p1;
 995         for (p = (unsigned char *) pattern, i = p1; --i > 0;)
 996                 delta[tolower(*p++)] = i;
 997
 998         /*
 999          * From now on, we want patlen - 1.
1000          * In the loop below, p points to the end of the pattern,
1001          * t points to the end of the text to be tested against the
1002          * pattern, and i counts the amount of text remaining, not
1003          * including the part to be tested.
1004          */
1005         p1--;
1006         p = (unsigned char *) pattern + p1;
1007         t = (unsigned char *) text + p1;
1008         i = textlen - patlen;
1009         while(1) {
1010                 if (tolower(p[0]) == tolower(t[0])) {
1011                         if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
1012                                 return ((char *)t - p1);
1013                         }
1014                 }
1015                 j = delta[tolower(t[0])];
1016                 if (i < j)
1017                         break;
1018                 i -= j;
1019                 t += j;
1020         }
1021         return (NULL);
1022 }
1023
1024 /*
1025  * bmstrcasestr() -- case-insensitive substring search
1026  *
1027  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
1028  * The code is roughly based on the strstr() replacement from 'tin' written
1029  * by Urs Jannsen.
1030  */
1031 const char *cbmstrcasestr(const char *text, const char *pattern) {
1032         size_t textlen;
1033         size_t patlen;
1034
1035         if (!text) return(NULL);
1036         if (!pattern) return(NULL);
1037
1038         textlen = strlen (text);
1039         patlen = strlen (pattern);
1040
1041         return _cbmstrcasestr_len(text, textlen, pattern, patlen);
1042 }
1043
1044 const char *cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
1045         return _cbmstrcasestr_len(text, textlen, pattern, patlen);
1046 }
1047
1048 /*
1049  * Local replacement for controversial C library function that generates
1050  * names for temporary files.  Included to shut up compiler warnings.
1051  */
1052 void CtdlMakeTempFileName(char *name, int len) {
1053         int i = 0;
1054
1055         while (i++, i < 100) {
1056                 snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
1057                         (long)getpid(),
1058                         rand()
1059                 );
1060                 if (!access(name, F_OK)) {
1061                         return;
1062                 }
1063         }
1064 }
1065
1066
1067
1068 /*
1069  * Determine whether the specified message number is contained within the specified set.
1070  * Returns nonzero if the specified message number is in the specified message set string.
1071  */
1072 int is_msg_in_mset(const char *mset, long msgnum) {
1073         int num_sets;
1074         int s;
1075         char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
1076         long lo, hi;
1077
1078         /*
1079          * Now set it for all specified messages.
1080          */
1081         num_sets = num_tokens(mset, ',');
1082         for (s=0; s<num_sets; ++s) {
1083                 extract_token(setstr, mset, s, ',', sizeof setstr);
1084
1085                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
1086                 if (num_tokens(setstr, ':') >= 2) {
1087                         extract_token(histr, setstr, 1, ':', sizeof histr);
1088                         if (!strcmp(histr, "*")) {
1089                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
1090                         }
1091                 }
1092                 else {
1093                         strcpy(histr, lostr);
1094                 }
1095                 lo = atol(lostr);
1096                 hi = atol(histr);
1097
1098                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
1099         }
1100
1101         return(0);
1102 }
1103
1104
1105 /*
1106  * searches for a pattern within a search string
1107  * returns position in string
1108  */
1109 int pattern2(char *search, char *patn)
1110 {
1111         int a;
1112         int len, plen;
1113         len = strlen (search);
1114         plen = strlen (patn);
1115         for (a = 0; a < len; ++a) {
1116                 if (!strncasecmp(&search[a], patn, plen))
1117                         return (a);
1118         }
1119         return (-1);
1120 }
1121
1122
1123 /*
1124  * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
1125  * buf - the string to modify
1126  * len - length of the string.
1127  */
1128 void stripltlen(char *buf, int *len)
1129 {
1130         int delta = 0;
1131         if (*len == 0) return;
1132         while ((*len > delta) && (isspace(buf[delta]))){
1133                 delta ++;
1134         }
1135         memmove (buf, &buf[delta], *len - delta + 1);
1136         (*len) -=delta;
1137
1138         if (*len == 0) return;
1139         while (isspace(buf[(*len) - 1])){
1140                 buf[--(*len)] = '\0';
1141         }
1142 }
1143
1144
1145 /*
1146  * Convert all whitespace characters in a supplied string to underscores
1147  */
1148 void convert_spaces_to_underscores(char *str)
1149 {
1150         int len;
1151         int i;
1152
1153         if (!str) return;
1154
1155         len = strlen(str);
1156         for (i=0; i<len; ++i) {
1157                 if (isspace(str[i])) {
1158                         str[i] = '_';
1159                 }
1160         }
1161 }
1162
1163
1164 /*
1165  * check whether the provided string needs to be qp encoded or not
1166  */
1167 int CheckEncode(const char *pch, long len, const char *pche)
1168 {
1169         if (pche == NULL)
1170                 pche = pch + len;
1171         while (pch < pche) {
1172                 if (((unsigned char) *pch < 32) ||
1173                     ((unsigned char) *pch > 126)) {
1174                         return 1;
1175                 }
1176                 pch++;
1177         }
1178         return 0;
1179 }
1180