1 // A basic toolset containing miscellaneous functions for string manipluation,
2 // encoding/decoding, and a bunch of other stuff.
4 // Copyright (c) 1987-2022 by the citadel.org team
6 // This program is open source software. Use, duplication, or disclosure
7 // is subject to the terms of the GNU General Public License, version 3.
13 #include <sys/types.h>
20 #if TIME_WITH_SYS_TIME
21 # include <sys/time.h>
25 # include <sys/time.h>
31 #include "libcitadel.h"
37 typedef unsigned char byte; // Byte type
39 // copy a string into a buffer of a known size. abort if we exceed the limits
41 // dest the targetbuffer
42 // src the source string
45 // returns the number of characters copied if dest is big enough, -n if not.
46 int safestrncpy(char *dest, const char *src, size_t n) {
49 if (dest == NULL || src == NULL)
51 fprintf(stderr, "safestrncpy: NULL argument\n");
57 if (dest[i] == 0) return i;
65 // num_tokens() - discover number of parameters/tokens in a string
66 int num_tokens(const char *source, char tok) {
68 const char *ptr = source;
74 while (*ptr != '\0') {
84 // extract_token() - a string tokenizer
85 // returns -1 if not found, or length of token.
86 long extract_token(char *dest, const char *source, int parmnum, char separator, int maxlen) {
87 const char *s; // source
88 int len = 0; // running total length of extracted string
89 int current_token = 0; // token currently being processed
106 if (*s == separator) {
109 if ( (current_token == parmnum) && (*s != separator) && (len < maxlen) ) {
113 else if ((current_token > parmnum) || (len >= maxlen)) {
120 if (current_token < parmnum) {
127 // remove_token() - a tokenizer that kills, maims, and destroys
128 void remove_token(char *source, int parmnum, char separator) {
129 char *d, *s; // dest, source
132 // Find desired parameter
134 while (count < parmnum) {
135 // End of string, bail!
140 if (*d == separator) {
145 if (!d) return; // Parameter not found
147 // Find next parameter
149 while (*s && *s != separator) {
156 else if (d == source)
163 // extract_int() - extract an int parm without supplying a buffer
164 int extract_int(const char *source, int parmnum) {
167 if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
174 // extract_long() - extract an long parm without supplying a buffer
175 long extract_long(const char *source, int parmnum) {
178 if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
185 // extract_unsigned_long() - extract an unsigned long parm
186 unsigned long extract_unsigned_long(const char *source, int parmnum) {
189 if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
190 return strtoul(buf, NULL, 10);
196 // if we send out non ascii subjects, we encode it this way.
197 char *rfc2047encode(const char *line, long length) {
198 const char *AlreadyEncoded;
201 #define UTF8_HEADER "=?UTF-8?B?"
203 // check if we're already done
204 AlreadyEncoded = strstr(line, "=?");
205 if ((AlreadyEncoded != NULL) && ((strstr(AlreadyEncoded, "?B?") != NULL)|| (strstr(AlreadyEncoded, "?Q?") != NULL))) {
209 result = (char*) malloc(sizeof(UTF8_HEADER) + 4 + length * 2);
210 strncpy (result, UTF8_HEADER, strlen (UTF8_HEADER));
211 CtdlEncodeBase64(result + strlen(UTF8_HEADER), line, length, BASE64_NO_LINEBREAKS);
212 end = strlen (result);
219 // removes double slashes from pathnames
220 // allows / disallows trailing slashes
221 void StripSlashes(char *Dir, int TrailingSlash) {
226 while (!IsEmptyStr(a)) {
238 if ((TrailingSlash) && (*(b - 1) != '/')){
247 // Trim leading and trailing whitespace from a string
248 size_t string_trim(char *buf) {
249 char *first_nonspace = NULL;
250 char *last_nonspace = NULL;
254 if ((buf == NULL) || (*buf == '\0')) {
258 for (ptr=buf; *ptr!=0; ++ptr) {
259 if (!isspace(*ptr)) {
260 if (!first_nonspace) {
261 first_nonspace = ptr;
267 if ((!first_nonspace) || (!last_nonspace)) {
272 new_len = last_nonspace - first_nonspace + 1;
273 memmove(buf, first_nonspace, new_len);
279 // check for the presence of a character within a string (returns count)
280 // st the string to examine
281 // ch the char to search
282 // returns the number of times ch appears in st
283 int haschar(const char *st, int ch) {
288 while (!IsEmptyStr(ptr))
298 // Determine whether the specified message number is contained within the specified sequence set.
299 int is_msg_in_sequence_set(const char *mset, long msgnum) {
302 char setstr[128], lostr[128], histr[128];
305 num_sets = num_tokens(mset, ',');
306 for (s=0; s<num_sets; ++s) {
307 extract_token(setstr, mset, s, ',', sizeof setstr);
309 extract_token(lostr, setstr, 0, ':', sizeof lostr);
310 if (num_tokens(setstr, ':') >= 2) {
311 extract_token(histr, setstr, 1, ':', sizeof histr);
312 if (!strcmp(histr, "*")) {
313 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
317 strcpy(histr, lostr);
322 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
328 // Utility function to "readline" from memory
329 // start Location in memory from which we are reading.
330 // buf the buffer to place the string in.
331 // maxlen Size of string buffer
332 // returns pointer to the source memory right after we stopped reading.
333 char *memreadline(char *start, char *buf, int maxlen) {
336 int len = 0; // tally our own length to avoid strlen() delays
342 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
345 if ((ch == 10) || (ch == 0)) {
353 // Utility function to "readline" from memory
354 // start Location in memory from which we are reading.
355 // buf the buffer to place the string in.
356 // maxlen Size of string buffer
357 // retlen the length of the returned string
358 // returns a pointer to the source memory right after we stopped reading.
359 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen) {
362 int len = 0; // tally our own length to avoid strlen() delays
368 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
371 if ((ch == 10) || (ch == 0)) {
380 // Utility function to "readline" from memory
381 // start Location in memory from which we are reading.
382 // buf the buffer to place the string in.
383 // maxlen Size of string buffer
384 // return Pointer to the source memory right after we stopped reading.
385 const char *cmemreadline(const char *start, char *buf, int maxlen) {
388 int len = 0; // tally our own length to avoid strlen() delays
394 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
397 if ((ch == 10) || (ch == 0)) {
405 // Utility function to "readline" from memory
406 // start Location in memory from which we are reading.
407 // buf the buffer to place the string in.
408 // maxlen Size of string buffer
409 // retlen the length of the returned string
410 // return Pointer to the source memory right after we stopped reading.
411 const char *cmemreadlinelen(const char *start, char *buf, int maxlen, int *retlen) {
414 int len = 0; // tally our own length to avoid strlen() delays
420 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
423 if ((ch == 10) || (ch == 0)) {
432 // Strip a boundarized substring out of a string (for example, remove parentheses and anything inside them).
433 int stripout(char *str, char leftboundary, char rightboundary) {
438 for (a = 0; a < strlen(str); ++a) {
439 if (str[a] == leftboundary) lb = a;
440 if (str[a] == rightboundary) rb = a;
443 if ( (lb > 0) && (rb > lb) ) {
444 strcpy(&str[lb - 1], &str[rb + 1]);
448 else if ( (lb == 0) && (rb > lb) ) {
449 strcpy(str, &str[rb + 1]);
456 // Reduce a string down to a boundarized substring (for example, remove
457 // parentheses and anything outside them).
458 long stripallbut(char *str, char leftboundary, char rightboundary) {
464 lb = strrchr(str, leftboundary);
467 rb = strchr(str, rightboundary);
468 if ((rb != NULL) && (rb >= lb)) {
471 len = (long)rb - (long)lb;
472 memmove(str, lb, len);
478 return (long)strlen(str);
482 char *myfgets(char *s, int size, FILE *stream) {
483 char *ret = fgets(s, size, stream);
487 nl = strchr(s, '\n');
497 // Escape a string for feeding out as a URL.
498 // outbuf the output buffer
499 // oblen the size of outbuf to sanitize
500 // strbuf the input buffer
501 void urlesc(char *outbuf, size_t oblen, char *strbuf) {
502 int a, b, c, len, eclen, olen;
503 char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
506 len = strlen(strbuf);
509 for (a = 0; a < len; ++a) {
511 for (b = 0; b < eclen; ++b) {
512 if (strbuf[a] == ec[b])
516 snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
520 outbuf[olen ++] = strbuf[a];
526 // In our world, we want strcpy() to be able to work with overlapping strings.
530 char *strcpy(char *dest, const char *src) {
531 memmove(dest, src, (strlen(src) + 1) );
536 // Generate a new, globally unique UID parameter for a calendar etc. object
537 void generate_uuid(char *buf) {
538 static int seq = (-1);
539 static int no_kernel_uuid = 0;
541 // If we are running on Linux then we have a kernelspace uuid generator available
543 if (no_kernel_uuid == 0) {
545 fp = fopen("/proc/sys/kernel/random/uuid", "rb");
548 rv = fread(buf, 36, 1, fp);
557 // If the kernel didn't provide us with a uuid, we generate a pseudo-random one
565 seq = (seq % 0x0FFF) ;
567 sprintf(buf, "%08lx-%04lx-4%03x-a%03x-%012lx",
577 // bmstrcasestr() -- case-insensitive substring search
579 // This uses the Boyer-Moore search algorithm and is therefore quite fast.
580 // The code is roughly based on the strstr() replacement from 'tin' written
582 inline static char *_bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
584 register unsigned char *p, *t;
585 register int i, j, *delta;
589 if (!text) return(NULL);
590 if (!pattern) return(NULL);
592 // algorithm fails if pattern is empty
593 if ((p1 = patlen) == 0)
596 // code below fails (whenever i is unsigned) if pattern too long
602 for (i = 0; i <= 255; i++)
604 for (p = (unsigned char *) pattern, i = p1; --i > 0;)
605 delta[tolower(*p++)] = i;
607 // From now on, we want patlen - 1.
608 // In the loop below, p points to the end of the pattern,
609 // t points to the end of the text to be tested against the
610 // pattern, and i counts the amount of text remaining, not
611 // including the part to be tested.
613 p = (unsigned char *) pattern + p1;
614 t = (unsigned char *) text + p1;
615 i = textlen - patlen;
617 if (tolower(p[0]) == tolower(t[0])) {
618 if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
619 return ((char *)t - p1);
622 j = delta[tolower(t[0])];
633 * bmstrcasestr() -- case-insensitive substring search
635 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
636 * The code is roughly based on the strstr() replacement from 'tin' written
639 char *bmstrcasestr(char *text, const char *pattern) {
643 if (!text) return(NULL);
644 if (!pattern) return(NULL);
646 textlen = strlen (text);
647 patlen = strlen (pattern);
649 return _bmstrcasestr_len(text, textlen, pattern, patlen);
652 char *bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
653 return _bmstrcasestr_len(text, textlen, pattern, patlen);
658 * bmstrcasestr() -- case-insensitive substring search
660 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
661 * The code is roughly based on the strstr() replacement from 'tin' written
664 inline static const char *_cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
666 register unsigned char *p, *t;
667 register int i, j, *delta;
671 if (!text) return(NULL);
672 if (!pattern) return(NULL);
674 /* algorithm fails if pattern is empty */
675 if ((p1 = patlen) == 0)
678 /* code below fails (whenever i is unsigned) if pattern too long */
684 for (i = 0; i <= 255; i++)
686 for (p = (unsigned char *) pattern, i = p1; --i > 0;)
687 delta[tolower(*p++)] = i;
690 * From now on, we want patlen - 1.
691 * In the loop below, p points to the end of the pattern,
692 * t points to the end of the text to be tested against the
693 * pattern, and i counts the amount of text remaining, not
694 * including the part to be tested.
697 p = (unsigned char *) pattern + p1;
698 t = (unsigned char *) text + p1;
699 i = textlen - patlen;
701 if (tolower(p[0]) == tolower(t[0])) {
702 if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
703 return ((char *)t - p1);
706 j = delta[tolower(t[0])];
717 * bmstrcasestr() -- case-insensitive substring search
719 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
720 * The code is roughly based on the strstr() replacement from 'tin' written
723 const char *cbmstrcasestr(const char *text, const char *pattern) {
727 if (!text) return(NULL);
728 if (!pattern) return(NULL);
730 textlen = strlen (text);
731 patlen = strlen (pattern);
733 return _cbmstrcasestr_len(text, textlen, pattern, patlen);
737 const char *cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
738 return _cbmstrcasestr_len(text, textlen, pattern, patlen);
743 * Local replacement for controversial C library function that generates
744 * names for temporary files. Included to shut up compiler warnings.
746 void CtdlMakeTempFileName(char *name, int len) {
749 while (i++, i < 100) {
750 snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
754 if (!access(name, F_OK)) {
762 * Determine whether the specified message number is contained within the specified set.
763 * Returns nonzero if the specified message number is in the specified message set string.
765 int is_msg_in_mset(const char *mset, long msgnum) {
768 char setstr[SIZ], lostr[SIZ], histr[SIZ];
771 // Now set it for all specified messages.
772 num_sets = num_tokens(mset, ',');
773 for (s=0; s<num_sets; ++s) {
774 extract_token(setstr, mset, s, ',', sizeof setstr);
776 extract_token(lostr, setstr, 0, ':', sizeof lostr);
777 if (num_tokens(setstr, ':') >= 2) {
778 extract_token(histr, setstr, 1, ':', sizeof histr);
779 if (!strcmp(histr, "*")) {
780 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
784 strcpy(histr, lostr);
789 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
796 // searches for a pattern within a search string
797 // returns position in string
798 int pattern2(char *search, char *patn) {
801 len = strlen (search);
802 plen = strlen (patn);
803 for (a = 0; a < len; ++a) {
804 if (!strncasecmp(&search[a], patn, plen))
812 * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
813 * buf - the string to modify
814 * len - length of the string.
816 void string_trimlen(char *buf, int *len) {
818 if (*len == 0) return;
819 while ((*len > delta) && (isspace(buf[delta]))){
822 memmove (buf, &buf[delta], *len - delta + 1);
825 if (*len == 0) return;
826 while (isspace(buf[(*len) - 1])){
827 buf[--(*len)] = '\0';
833 * Convert all whitespace characters in a supplied string to underscores
835 void convert_spaces_to_underscores(char *str) {
842 for (i=0; i<len; ++i) {
843 if (isspace(str[i])) {
851 * check whether the provided string needs to be qp encoded or not
853 int CheckEncode(const char *pch, long len, const char *pche) {
857 if (((unsigned char) *pch < 32) ||
858 ((unsigned char) *pch > 126)) {