]> code.citadel.org Git - citadel.git/blob - citadel/tools.c
Handle NULL data from XML parser in order to cope
[citadel.git] / citadel / tools.c
1 /*
2  * $Id$
3  *
4  * Utility functions that are used by both the client and server.
5  *
6  */
7
8 #include "sysdep.h"
9 #include <stdlib.h>
10 #include <unistd.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <ctype.h>
14 #include <string.h>
15 #include <stdarg.h>
16
17 #if TIME_WITH_SYS_TIME
18 # include <sys/time.h>
19 # include <time.h>
20 #else
21 # if HAVE_SYS_TIME_H
22 #  include <sys/time.h>
23 # else
24 #  include <time.h>
25 # endif
26 #endif
27
28 #include "tools.h"
29 #include "citadel.h"
30 #include "sysdep_decls.h"
31
32 #define TRUE  1
33 #define FALSE 0
34
35 typedef unsigned char byte;           /* Byte type */
36 static byte dtable[256] = "\0";       /* base64 decode table */
37 static byte etable[256] = "\0";       /* base64 encode table */
38
39 /* Month strings for date conversions */
40 char *ascmonths[12] = {
41         "Jan", "Feb", "Mar", "Apr", "May", "Jun",
42         "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
43 };
44
45 char *safestrncpy(char *dest, const char *src, size_t n)
46 {
47         int i = 0;
48
49         if (dest == NULL || src == NULL) {
50                 fprintf(stderr, "safestrncpy: NULL argument\n");
51                 abort();
52         }
53
54         do {
55                 dest[i] = src[i];
56                 if (dest[i] == 0) return(dest);
57                 ++i;
58         } while (i<n);
59         dest[n - 1] = 0;
60         return dest;
61 }
62
63
64
65 #ifndef HAVE_STRNCASECMP
66 int strncasecmp(char *lstr, char *rstr, int len)
67 {
68         int pos = 0;
69         char lc,rc;
70         while (pos<len) {
71                 lc=tolower(lstr[pos]);
72                 rc=tolower(rstr[pos]);
73                 if ((lc==0)&&(rc==0)) return(0);
74                 if (lc<rc) return(-1);
75                 if (lc>rc) return(1);
76                 pos=pos+1;
77         }
78         return(0);
79 }
80 #endif
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         extract_token(buf, source, parmnum, '|', sizeof buf);
257         return(atoi(buf));
258 }
259
260 /*
261  * extract_long()  -  extract an long parm w/o supplying a buffer
262  */
263 long extract_long(const char *source, int parmnum)
264 {
265         char buf[32];
266         
267         extract_token(buf, source, parmnum, '|', sizeof buf);
268         return(atol(buf));
269 }
270
271
272 /*
273  * extract_unsigned_long() - extract an unsigned long parm
274  */
275 unsigned long extract_unsigned_long(const char *source, int parmnum)
276 {
277         char buf[32];
278
279         extract_token(buf, source, parmnum, '|', sizeof buf);
280         return strtoul(buf, NULL, 10);
281 }
282
283
284
285 void CtdlInitBase64Table(void)
286 {
287         int i;
288         /*      Fill dtable with character encodings.  */
289         
290         /* Encoder Table */
291         for (i = 0; i < 26; i++) {
292                 etable[i] = 'A' + i;
293                 etable[26 + i] = 'a' + i;
294         }
295         for (i = 0; i < 10; i++) {
296                 etable[52 + i] = '0' + i;
297         }
298         etable[62] = '+';
299         etable[63] = '/';
300         
301         /* Decoder Table */
302         for (i = 0; i < 255; i++) {
303                 dtable[i] = 0x80;
304         }
305         for (i = 'A'; i <= 'Z'; i++) {
306                 dtable[i] = 0 + (i - 'A');
307         }
308         for (i = 'a'; i <= 'z'; i++) {
309                 dtable[i] = 26 + (i - 'a');
310         }
311         for (i = '0'; i <= '9'; i++) {
312                 dtable[i] = 52 + (i - '0');
313         }
314         dtable['+'] = 62;
315         dtable['/'] = 63;
316         dtable['='] = 0;
317 }
318
319 /*
320  * CtdlDecodeBase64() and CtdlEncodeBase64() are adaptations of code by
321  * John Walker, found in full in the file "base64.c" included with this
322  * distribution.  We are moving in the direction of eventually discarding
323  * the separate executables, and using the ones in our code exclusively.
324  */
325
326 void CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen)
327 {
328     int i, hiteof = FALSE;
329     int spos = 0;
330     int dpos = 0;
331
332     while (!hiteof) {
333         byte igroup[3], ogroup[4];
334         int c, n;
335
336         igroup[0] = igroup[1] = igroup[2] = 0;
337         for (n = 0; n < 3; n++) {
338             if (spos >= sourcelen) {
339                 hiteof = TRUE;
340                 break;
341             }
342             c = source[spos++];
343             igroup[n] = (byte) c;
344         }
345         if (n > 0) {
346             ogroup[0] = etable[igroup[0] >> 2];
347             ogroup[1] = etable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
348             ogroup[2] = etable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
349             ogroup[3] = etable[igroup[2] & 0x3F];
350
351             /* Replace characters in output stream with "=" pad
352                characters if fewer than three characters were
353                read from the end of the input stream. */
354
355             if (n < 3) {
356                 ogroup[3] = '=';
357                 if (n < 2) {
358                     ogroup[2] = '=';
359                 }
360             }
361             for (i = 0; i < 4; i++) {
362                 dest[dpos++] = ogroup[i];
363                 dest[dpos] = 0;
364             }
365         }
366     }
367 }
368
369
370 /* 
371  * Convert base64-encoded to binary.  Returns the length of the decoded data.
372  * It will stop after reading 'length' bytes.
373  */
374 int CtdlDecodeBase64(char *dest, const char *source, size_t length)
375 {
376     int i, c;
377     int dpos = 0;
378     int spos = 0;
379
380
381     /*CONSTANTCONDITION*/
382     while (TRUE) {
383         byte a[4], b[4], o[3];
384
385         for (i = 0; i < 4; i++) {
386             if (spos >= length) {
387                 return(dpos);
388             }
389             c = source[spos++];
390
391             if (c == 0) {
392                 if (i > 0) {
393                     return(dpos);
394                 }
395                 return(dpos);
396             }
397             if (dtable[c] & 0x80) {
398                 /* Ignoring errors: discard invalid character. */
399                 i--;
400                 continue;
401             }
402             a[i] = (byte) c;
403             b[i] = (byte) dtable[c];
404         }
405         o[0] = (b[0] << 2) | (b[1] >> 4);
406         o[1] = (b[1] << 4) | (b[2] >> 2);
407         o[2] = (b[2] << 6) | b[3];
408         i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3);
409         if (i>=1) dest[dpos++] = o[0];
410         if (i>=2) dest[dpos++] = o[1];
411         if (i>=3) dest[dpos++] = o[2];
412         dest[dpos] = 0;
413         if (i < 3) {
414             return(dpos);
415         }
416     }
417 }
418
419 /*
420  * if we send out non ascii subjects, we encode it this way.
421  */
422 char *rfc2047encode(char *line, long length)
423 {
424         char *AlreadyEncoded;
425         char *result;
426         long end;
427 #define UTF8_HEADER "=?UTF-8?B?"
428
429         /* check if we're already done */
430         AlreadyEncoded = strstr(line, "=?");
431         if ((AlreadyEncoded != NULL) &&
432             ((strstr(AlreadyEncoded, "?B?") != NULL)||
433              (strstr(AlreadyEncoded, "?Q?") != NULL)))
434         {
435                 return strdup(line);
436         }
437
438         result = (char*) malloc(strlen(UTF8_HEADER) + 4 + length * 2);
439         strncpy (result, UTF8_HEADER, strlen (UTF8_HEADER));
440         CtdlEncodeBase64(result + strlen(UTF8_HEADER), line, length);
441         end = strlen (result);
442         result[end]='?';
443         result[end+1]='=';
444         result[end+2]='\0';
445         return result;
446 }
447
448
449 /*
450  * Strip leading and trailing spaces from a string
451  */
452 void striplt(char *buf)
453 {
454         size_t len;
455         int a;
456
457         if (buf==NULL) return;
458         if (IsEmptyStr(buf)) return;
459         len = strlen(buf);
460         while ((!IsEmptyStr(buf)) && (isspace(buf[len - 1])))
461                 buf[--len] = 0;
462         if (IsEmptyStr(buf)) return;
463         a = 0;
464         while ((!IsEmptyStr(buf)) && (isspace(buf[a])))
465                 a++;
466         if (a > 0)
467                 memmove(buf, &buf[a], len - a + 1);
468 }
469
470
471
472
473
474 /**
475  * \brief check for the presence of a character within a string (returns count)
476  * \param st the string to examine
477  * \param ch the char to search
478  * \return the position inside of st
479  */
480 int haschar(const char *st,int ch)
481 {
482         const char *ptr;
483         int b;
484         b = 0;
485         ptr = st;
486         while (!IsEmptyStr(ptr))
487         {
488                 if (*ptr == ch)
489                         ++b;
490                 ptr ++;
491         }
492         return (b);
493 }
494
495
496
497
498
499 /*
500  * Format a date/time stamp for output 
501  * seconds is whether to print the seconds
502  */
503 void fmt_date(char *buf, size_t n, time_t thetime, int seconds) {
504         struct tm tm;
505         int hour;
506
507         strcpy(buf, "");
508         localtime_r(&thetime, &tm);
509
510         hour = tm.tm_hour;
511         if (hour == 0)  hour = 12;
512         else if (hour > 12) hour = hour - 12;
513
514         if (seconds) {
515                 snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s",
516                         ascmonths[tm.tm_mon],
517                         tm.tm_mday,
518                         tm.tm_year + 1900,
519                         hour,
520                         tm.tm_min,
521                         tm.tm_sec,
522                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
523                 );
524         } else {
525                 snprintf(buf, n, "%s %d %4d %d:%02d%s",
526                         ascmonths[tm.tm_mon],
527                         tm.tm_mday,
528                         tm.tm_year + 1900,
529                         hour,
530                         tm.tm_min,
531                         ( (tm.tm_hour >= 12) ? "pm" : "am" )
532                 );
533         }
534 }
535
536
537
538 /*
539  * Determine whether the specified message number is contained within the
540  * specified sequence set.
541  */
542 int is_msg_in_sequence_set(char *mset, long msgnum) {
543         int num_sets;
544         int s;
545         char setstr[128], lostr[128], histr[128];
546         long lo, hi;
547
548         num_sets = num_tokens(mset, ',');
549         for (s=0; s<num_sets; ++s) {
550                 extract_token(setstr, mset, s, ',', sizeof setstr);
551
552                 extract_token(lostr, setstr, 0, ':', sizeof lostr);
553                 if (num_tokens(setstr, ':') >= 2) {
554                         extract_token(histr, setstr, 1, ':', sizeof histr);
555                         if (!strcmp(histr, "*")) {
556                                 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
557                         }
558                 } 
559                 else {
560                         strcpy(histr, lostr);
561                 }
562                 lo = atol(lostr);
563                 hi = atol(histr);
564
565                 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
566         }
567
568         return(0);
569 }
570
571 /** 
572  * \brief Utility function to "readline" from memory
573  * \param start Location in memory from which we are reading.
574  * \param buf the buffer to place the string in.
575  * \param maxlen Size of string buffer
576  * \return Pointer to the source memory right after we stopped reading.
577  */
578 char *memreadline(char *start, char *buf, int maxlen)
579 {
580         char ch;
581         char *ptr;
582         int len = 0;            /**< tally our own length to avoid strlen() delays */
583
584         ptr = start;
585
586         while (1) {
587                 ch = *ptr++;
588                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
589                         buf[len++] = ch;
590                 }
591                 if ((ch == 10) || (ch == 0)) {
592                         buf[len] = 0;
593                         return ptr;
594                 }
595         }
596 }
597
598
599 /** 
600  * \brief Utility function to "readline" from memory
601  * \param start Location in memory from which we are reading.
602  * \param buf the buffer to place the string in.
603  * \param maxlen Size of string buffer
604  * \param retlen the length of the returned string
605  * \return Pointer to the source memory right after we stopped reading.
606  */
607 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
608 {
609         char ch;
610         char *ptr;
611         int len = 0;            /**< tally our own length to avoid strlen() delays */
612
613         ptr = start;
614
615         while (1) {
616                 ch = *ptr++;
617                 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
618                         buf[len++] = ch;
619                 }
620                 if ((ch == 10) || (ch == 0)) {
621                         buf[len] = 0;
622                         *retlen = len;
623                         return ptr;
624                 }
625         }
626 }
627
628
629
630
631 /*
632  * Strip a boundarized substring out of a string (for example, remove
633  * parentheses and anything inside them).
634  */
635 void stripout(char *str, char leftboundary, char rightboundary) {
636         int a;
637         int lb = (-1);
638         int rb = (-1);
639
640         for (a = 0; a < strlen(str); ++a) {
641                 if (str[a] == leftboundary) lb = a;
642                 if (str[a] == rightboundary) rb = a;
643         }
644
645         if ( (lb > 0) && (rb > lb) ) {
646                 strcpy(&str[lb - 1], &str[rb + 1]);
647         }
648
649         else if ( (lb == 0) && (rb > lb) ) {
650                 strcpy(str, &str[rb + 1]);
651         }
652
653 }
654
655
656 /*
657  * Reduce a string down to a boundarized substring (for example, remove
658  * parentheses and anything outside them).
659  */
660 void stripallbut(char *str, char leftboundary, char rightboundary) {
661         int a;
662
663         for (a = 0; a < strlen(str); ++ a) {
664                 if (str[a] == leftboundary) strcpy(str, &str[a+1]);
665         }
666
667         for (a = 0; a < strlen(str); ++ a) {
668                 if (str[a] == rightboundary) str[a] = 0;
669         }
670
671 }
672
673 char *myfgets(char *s, int size, FILE *stream) {
674         char *ret = fgets(s, size, stream);
675         char *nl;
676
677         if (ret != NULL) {
678                 nl = strchr(s, '\n');
679
680                 if (nl != NULL)
681                         *nl = 0;
682         }
683
684         return ret;
685 }
686
687 /*
688  * Escape a string for feeding out as a URL.
689  * Output buffer must be big enough to handle escape expansion!
690  */
691 void urlesc(char *outbuf, char *strbuf)
692 {
693         int a, b, c;
694         char *ec = " #&;`'|*?-~<>^()[]{}$\\";
695
696         strcpy(outbuf, "");
697
698         for (a = 0; a < (int)strlen(strbuf); ++a) {
699                 c = 0;
700                 for (b = 0; b < strlen(ec); ++b) {
701                         if (strbuf[a] == ec[b])
702                                 c = 1;
703                 }
704                 b = strlen(outbuf);
705                 if (c == 1)
706                         sprintf(&outbuf[b], "%%%02x", strbuf[a]);
707                 else
708                         sprintf(&outbuf[b], "%c", strbuf[a]);
709         }
710 }
711
712
713
714 /*
715  * In our world, we want strcpy() to be able to work with overlapping strings.
716  */
717 #ifdef strcpy
718 #undef strcpy
719 #endif
720 char *strcpy(char *dest, const char *src) {
721         memmove(dest, src, (strlen(src) + 1) );
722         return(dest);
723 }
724
725
726 /*
727  * Generate a new, globally unique UID parameter for a calendar etc. object
728  */
729 void generate_uuid(char *buf) {
730         static int seq = 0;
731
732         sprintf(buf, "%lx-"F_XPID_T"-%x",
733                 time(NULL),
734                 getpid(),
735                 (seq++)
736         );
737 }
738
739 /*
740  * bmstrcasestr() -- case-insensitive substring search
741  *
742  * This uses the Boyer-Moore search algorithm and is therefore quite fast.
743  * The code is roughly based on the strstr() replacement from 'tin' written
744  * by Urs Jannsen.
745  */
746 char *bmstrcasestr(char *text, char *pattern) {
747
748         register unsigned char *p, *t;
749         register int i, j, *delta;
750         register size_t p1;
751         int deltaspace[256];
752         size_t textlen;
753         size_t patlen;
754
755         textlen = strlen (text);
756         patlen = strlen (pattern);
757
758         /* algorithm fails if pattern is empty */
759         if ((p1 = patlen) == 0)
760                 return (text);
761
762         /* code below fails (whenever i is unsigned) if pattern too long */
763         if (p1 > textlen)
764                 return (NULL);
765
766         /* set up deltas */
767         delta = deltaspace;
768         for (i = 0; i <= 255; i++)
769                 delta[i] = p1;
770         for (p = (unsigned char *) pattern, i = p1; --i > 0;)
771                 delta[tolower(*p++)] = i;
772
773         /*
774          * From now on, we want patlen - 1.
775          * In the loop below, p points to the end of the pattern,
776          * t points to the end of the text to be tested against the
777          * pattern, and i counts the amount of text remaining, not
778          * including the part to be tested.
779          */
780         p1--;
781         p = (unsigned char *) pattern + p1;
782         t = (unsigned char *) text + p1;
783         i = textlen - patlen;
784         while(1) {
785                 if (tolower(p[0]) == tolower(t[0])) {
786                         if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
787                                 return ((char *)t - p1);
788                         }
789                 }
790                 j = delta[tolower(t[0])];
791                 if (i < j)
792                         break;
793                 i -= j;
794                 t += j;
795         }
796         return (NULL);
797 }
798
799
800
801 /*
802  * Local replacement for controversial C library function that generates
803  * names for temporary files.  Included to shut up compiler warnings.
804  */
805 void CtdlMakeTempFileName(char *name, int len) {
806         int i = 0;
807
808         while (i++, i < 100) {
809                 snprintf(name, len, "/tmp/ctdl."F_XPID_T".%04x",
810                         getpid(),
811                         rand()
812                 );
813                 if (!access(name, F_OK)) {
814                         return;
815                 }
816         }
817 }