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