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 // Strip leading and trailing spaces from a string
248 size_t striplt(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);
280 * check for the presence of a character within a string (returns count)
281 * st the string to examine
282 * ch the char to search
283 * returns the number of times ch appears in st
285 int haschar(const char *st, int ch)
291 while (!IsEmptyStr(ptr))
302 * Determine whether the specified message number is contained within the
303 * specified sequence set.
305 int is_msg_in_sequence_set(const char *mset, long msgnum)
309 char setstr[128], lostr[128], histr[128];
312 num_sets = num_tokens(mset, ',');
313 for (s=0; s<num_sets; ++s) {
314 extract_token(setstr, mset, s, ',', sizeof setstr);
316 extract_token(lostr, setstr, 0, ':', sizeof lostr);
317 if (num_tokens(setstr, ':') >= 2)
319 extract_token(histr, setstr, 1, ':', sizeof histr);
320 if (!strcmp(histr, "*"))
322 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
327 strcpy(histr, lostr);
332 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
339 * Utility function to "readline" from memory
340 * start Location in memory from which we are reading.
341 * buf the buffer to place the string in.
342 * maxlen Size of string buffer
343 * returns pointer to the source memory right after we stopped reading.
345 char *memreadline(char *start, char *buf, int maxlen)
349 int len = 0; /* tally our own length to avoid strlen() delays */
355 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
358 if ((ch == 10) || (ch == 0)) {
367 * Utility function to "readline" from memory
368 * start Location in memory from which we are reading.
369 * buf the buffer to place the string in.
370 * maxlen Size of string buffer
371 * retlen the length of the returned string
372 * returns a pointer to the source memory right after we stopped reading.
374 char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen)
378 int len = 0; /* tally our own length to avoid strlen() delays */
385 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10))
389 if ((ch == 10) || (ch == 0))
400 * \brief Utility function to "readline" from memory
401 * \param start Location in memory from which we are reading.
402 * \param buf the buffer to place the string in.
403 * \param maxlen Size of string buffer
404 * \return Pointer to the source memory right after we stopped reading.
406 const char *cmemreadline(const char *start, char *buf, int maxlen)
410 int len = 0; /**< tally our own length to avoid strlen() delays */
416 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
419 if ((ch == 10) || (ch == 0)) {
428 * \brief Utility function to "readline" from memory
429 * \param start Location in memory from which we are reading.
430 * \param buf the buffer to place the string in.
431 * \param maxlen Size of string buffer
432 * \param retlen the length of the returned string
433 * \return Pointer to the source memory right after we stopped reading.
435 const char *cmemreadlinelen(const char *start, char *buf, int maxlen, int *retlen)
439 int len = 0; /**< tally our own length to avoid strlen() delays */
445 if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) {
448 if ((ch == 10) || (ch == 0)) {
458 * Strip a boundarized substring out of a string (for example, remove
459 * parentheses and anything inside them).
461 int stripout(char *str, char leftboundary, char rightboundary) {
466 for (a = 0; a < strlen(str); ++a) {
467 if (str[a] == leftboundary) lb = a;
468 if (str[a] == rightboundary) rb = a;
471 if ( (lb > 0) && (rb > lb) ) {
472 strcpy(&str[lb - 1], &str[rb + 1]);
476 else if ( (lb == 0) && (rb > lb) ) {
477 strcpy(str, &str[rb + 1]);
485 * Reduce a string down to a boundarized substring (for example, remove
486 * parentheses and anything outside them).
488 long stripallbut(char *str, char leftboundary, char rightboundary) {
494 lb = strrchr(str, leftboundary);
497 rb = strchr(str, rightboundary);
498 if ((rb != NULL) && (rb >= lb)) {
501 len = (long)rb - (long)lb;
502 memmove(str, lb, len);
508 return (long)strlen(str);
512 char *myfgets(char *s, int size, FILE *stream) {
513 char *ret = fgets(s, size, stream);
517 nl = strchr(s, '\n');
527 * \brief Escape a string for feeding out as a URL.
528 * \param outbuf the output buffer
529 * \param oblen the size of outbuf to sanitize
530 * \param strbuf the input buffer
532 void urlesc(char *outbuf, size_t oblen, char *strbuf)
534 int a, b, c, len, eclen, olen;
535 char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";
538 len = strlen(strbuf);
541 for (a = 0; a < len; ++a) {
543 for (b = 0; b < eclen; ++b) {
544 if (strbuf[a] == ec[b])
548 snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
552 outbuf[olen ++] = strbuf[a];
560 * In our world, we want strcpy() to be able to work with overlapping strings.
565 char *strcpy(char *dest, const char *src) {
566 memmove(dest, src, (strlen(src) + 1) );
572 * Generate a new, globally unique UID parameter for a calendar etc. object
574 void generate_uuid(char *buf) {
575 static int seq = (-1);
576 static int no_kernel_uuid = 0;
578 /* If we are running on Linux then we have a kernelspace uuid generator available */
580 if (no_kernel_uuid == 0) {
582 fp = fopen("/proc/sys/kernel/random/uuid", "rb");
585 rv = fread(buf, 36, 1, fp);
594 /* If the kernel didn't provide us with a uuid, we generate a pseudo-random one */
602 seq = (seq % 0x0FFF) ;
604 sprintf(buf, "%08lx-%04lx-4%03x-a%03x-%012lx",
614 * bmstrcasestr() -- case-insensitive substring search
616 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
617 * The code is roughly based on the strstr() replacement from 'tin' written
620 inline static char *_bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
622 register unsigned char *p, *t;
623 register int i, j, *delta;
627 if (!text) return(NULL);
628 if (!pattern) return(NULL);
630 /* algorithm fails if pattern is empty */
631 if ((p1 = patlen) == 0)
634 /* code below fails (whenever i is unsigned) if pattern too long */
640 for (i = 0; i <= 255; i++)
642 for (p = (unsigned char *) pattern, i = p1; --i > 0;)
643 delta[tolower(*p++)] = i;
646 * From now on, we want patlen - 1.
647 * In the loop below, p points to the end of the pattern,
648 * t points to the end of the text to be tested against the
649 * pattern, and i counts the amount of text remaining, not
650 * including the part to be tested.
653 p = (unsigned char *) pattern + p1;
654 t = (unsigned char *) text + p1;
655 i = textlen - patlen;
657 if (tolower(p[0]) == tolower(t[0])) {
658 if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
659 return ((char *)t - p1);
662 j = delta[tolower(t[0])];
672 * bmstrcasestr() -- case-insensitive substring search
674 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
675 * The code is roughly based on the strstr() replacement from 'tin' written
678 char *bmstrcasestr(char *text, const char *pattern) {
682 if (!text) return(NULL);
683 if (!pattern) return(NULL);
685 textlen = strlen (text);
686 patlen = strlen (pattern);
688 return _bmstrcasestr_len(text, textlen, pattern, patlen);
691 char *bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) {
692 return _bmstrcasestr_len(text, textlen, pattern, patlen);
699 * bmstrcasestr() -- case-insensitive substring search
701 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
702 * The code is roughly based on the strstr() replacement from 'tin' written
705 inline static const char *_cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
707 register unsigned char *p, *t;
708 register int i, j, *delta;
712 if (!text) return(NULL);
713 if (!pattern) return(NULL);
715 /* algorithm fails if pattern is empty */
716 if ((p1 = patlen) == 0)
719 /* code below fails (whenever i is unsigned) if pattern too long */
725 for (i = 0; i <= 255; i++)
727 for (p = (unsigned char *) pattern, i = p1; --i > 0;)
728 delta[tolower(*p++)] = i;
731 * From now on, we want patlen - 1.
732 * In the loop below, p points to the end of the pattern,
733 * t points to the end of the text to be tested against the
734 * pattern, and i counts the amount of text remaining, not
735 * including the part to be tested.
738 p = (unsigned char *) pattern + p1;
739 t = (unsigned char *) text + p1;
740 i = textlen - patlen;
742 if (tolower(p[0]) == tolower(t[0])) {
743 if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) {
744 return ((char *)t - p1);
747 j = delta[tolower(t[0])];
757 * bmstrcasestr() -- case-insensitive substring search
759 * This uses the Boyer-Moore search algorithm and is therefore quite fast.
760 * The code is roughly based on the strstr() replacement from 'tin' written
763 const char *cbmstrcasestr(const char *text, const char *pattern) {
767 if (!text) return(NULL);
768 if (!pattern) return(NULL);
770 textlen = strlen (text);
771 patlen = strlen (pattern);
773 return _cbmstrcasestr_len(text, textlen, pattern, patlen);
776 const char *cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) {
777 return _cbmstrcasestr_len(text, textlen, pattern, patlen);
781 * Local replacement for controversial C library function that generates
782 * names for temporary files. Included to shut up compiler warnings.
784 void CtdlMakeTempFileName(char *name, int len) {
787 while (i++, i < 100) {
788 snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
792 if (!access(name, F_OK)) {
801 * Determine whether the specified message number is contained within the specified set.
802 * Returns nonzero if the specified message number is in the specified message set string.
804 int is_msg_in_mset(const char *mset, long msgnum) {
807 char setstr[SIZ], lostr[SIZ], histr[SIZ]; /* was 1024 */
811 * Now set it for all specified messages.
813 num_sets = num_tokens(mset, ',');
814 for (s=0; s<num_sets; ++s) {
815 extract_token(setstr, mset, s, ',', sizeof setstr);
817 extract_token(lostr, setstr, 0, ':', sizeof lostr);
818 if (num_tokens(setstr, ':') >= 2) {
819 extract_token(histr, setstr, 1, ':', sizeof histr);
820 if (!strcmp(histr, "*")) {
821 snprintf(histr, sizeof histr, "%ld", LONG_MAX);
825 strcpy(histr, lostr);
830 if ((msgnum >= lo) && (msgnum <= hi)) return(1);
838 * searches for a pattern within a search string
839 * returns position in string
841 int pattern2(char *search, char *patn)
845 len = strlen (search);
846 plen = strlen (patn);
847 for (a = 0; a < len; ++a) {
848 if (!strncasecmp(&search[a], patn, plen))
856 * Strip leading and trailing spaces from a string; with premeasured and adjusted length.
857 * buf - the string to modify
858 * len - length of the string.
860 void stripltlen(char *buf, int *len)
863 if (*len == 0) return;
864 while ((*len > delta) && (isspace(buf[delta]))){
867 memmove (buf, &buf[delta], *len - delta + 1);
870 if (*len == 0) return;
871 while (isspace(buf[(*len) - 1])){
872 buf[--(*len)] = '\0';
878 * Convert all whitespace characters in a supplied string to underscores
880 void convert_spaces_to_underscores(char *str)
888 for (i=0; i<len; ++i) {
889 if (isspace(str[i])) {
897 * check whether the provided string needs to be qp encoded or not
899 int CheckEncode(const char *pch, long len, const char *pche)
904 if (((unsigned char) *pch < 32) ||
905 ((unsigned char) *pch > 126)) {