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