X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=libcitadel%2Flib%2Ftools.c;h=b50cd66b5842f1fbad54db57f424dfa1e70b13dd;hb=61ee61844618c781da76b236c6a119528c23e867;hp=e3882c7bb7033d286e57f96fd76c75e6b25ea4df;hpb=1e656d277fe91b7c4f5d73eab4a0dd0b7a173145;p=citadel.git diff --git a/libcitadel/lib/tools.c b/libcitadel/lib/tools.c index e3882c7bb..b50cd66b5 100644 --- a/libcitadel/lib/tools.c +++ b/libcitadel/lib/tools.c @@ -1,5 +1,22 @@ /* + * A basic toolset containing miscellaneous functions for string manipluation, + * encoding/decoding, and a bunch of other stuff. * + * Copyright (c) 1987-2017 by the citadel.org team + * + * This program is open source software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ @@ -13,6 +30,8 @@ #include #include #include +#include "b64/cencode.h" +#include "b64/cdecode.h" #if TIME_WITH_SYS_TIME # include @@ -32,35 +51,36 @@ #define FALSE 0 typedef unsigned char byte; /* Byte type */ -static byte dtable[256] = "\0"; /* base64 decode table */ -static byte etable[256] = "\0"; /* base64 encode table */ -/* Month strings for date conversions */ -char *ascmonths[12] = { - "Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" -}; - -char *safestrncpy(char *dest, const char *src, size_t n) +/* + * copy a string into a buffer of a known size. abort if we exceed the limits + * + * dest the targetbuffer + * src the source string + * n the size od dest + * + * returns the number of characters copied if dest is big enough, -n if not. + */ +int safestrncpy(char *dest, const char *src, size_t n) { int i = 0; - if (dest == NULL || src == NULL) { + if (dest == NULL || src == NULL) + { fprintf(stderr, "safestrncpy: NULL argument\n"); abort(); } do { dest[i] = src[i]; - if (dest[i] == 0) return(dest); + if (dest[i] == 0) return i; ++i; } while (i: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source); dest[0] = 0; - if (s == NULL) { + if (s == NULL) + { return(-1); } maxlen--; - while (*s) { - if (*s == separator) { + while (*s) + { + if (*s == separator) + { ++current_token; } - if ( (current_token == parmnum) && - (*s != separator) && - (len < maxlen) ) { + if ( (current_token == parmnum) && (*s != separator) && (len < maxlen) ) + { dest[len] = *s; ++len; } - else if ((current_token > parmnum) || (len >= maxlen)) { + else if ((current_token > parmnum) || (len >= maxlen)) + { break; } ++s; } dest[len] = '\0'; - if (current_token < parmnum) { -// lprintf (CTDL_DEBUG,"test : n: %d sep: %c source: %s \n willi \n", parmnum, separator, source); - strcpy(dest, ""); - - // Locate desired parameter - s = source; - while (count < parmnum) { - // End of string, bail! - if (!*s) { - s = NULL; - break; - } - if (*s == separator) { - count++; - } - s++; - } - if (!s) { - lprintf (CTDL_DEBUG,"test 0) + return(atoi(buf)); + else + return 0; } + /* * extract_long() - extract an long parm w/o supplying a buffer */ @@ -244,8 +222,10 @@ long extract_long(const char *source, int parmnum) { char buf[32]; - extract_token(buf, source, parmnum, '|', sizeof buf); - return(atol(buf)); + if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0) + return(atol(buf)); + else + return 0; } @@ -256,186 +236,78 @@ unsigned long extract_unsigned_long(const char *source, int parmnum) { char buf[32]; - extract_token(buf, source, parmnum, '|', sizeof buf); - return strtoul(buf, NULL, 10); + if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0) + return strtoul(buf, NULL, 10); + else + return 0; } - -void CtdlInitBase64Table(void) -{ - int i; - /* Fill dtable with character encodings. */ - - /* Encoder Table */ - for (i = 0; i < 26; i++) { - etable[i] = 'A' + i; - etable[26 + i] = 'a' + i; - } - for (i = 0; i < 10; i++) { - etable[52 + i] = '0' + i; - } - etable[62] = '+'; - etable[63] = '/'; - - /* Decoder Table */ - for (i = 0; i < 255; i++) { - dtable[i] = 0x80; - } - for (i = 'A'; i <= 'Z'; i++) { - dtable[i] = 0 + (i - 'A'); - } - for (i = 'a'; i <= 'z'; i++) { - dtable[i] = 26 + (i - 'a'); - } - for (i = '0'; i <= '9'; i++) { - dtable[i] = 52 + (i - '0'); - } - dtable['+'] = 62; - dtable['/'] = 63; - dtable['='] = 0; -} - - -/* - * CtdlDecodeBase64() and CtdlEncodeBase64() are adaptations of code by John Walker. - */ - size_t CtdlEncodeBase64(char *dest, const char *source, size_t sourcelen, int linebreaks) { - int i, hiteof = FALSE; - int spos = 0; - int dpos = 0; - int thisline = 0; - - /** Fill dtable with character encodings. */ + int breaklength = 68; // must be a multiple of 4 + int readlength = 3 * breaklength / 4; + + int destoffset; + int sourceoffset; + int sourceremaining; + + base64_encodestate _state; + + base64_init_encodestate(&_state); + + if (linebreaks) { + sourceremaining = sourcelen; + destoffset = 0; + sourceoffset = 0; + + while (sourceremaining > 0) { + destoffset += base64_encode_block( + &(source[sourceoffset]), + (readlength > sourceremaining ? sourceremaining : readlength), + &(dest[destoffset]), + &_state); + sourceoffset += readlength; + sourceremaining -= readlength; + dest[destoffset++] = '\r'; + dest[destoffset++] = '\n'; + } - for (i = 0; i < 26; i++) { - dtable[i] = 'A' + i; - dtable[26 + i] = 'a' + i; - } - for (i = 0; i < 10; i++) { - dtable[52 + i] = '0' + i; + destoffset += base64_encode_blockend(&(dest[destoffset]), &_state, 0); } - dtable[62] = '+'; - dtable[63] = '/'; + else { + destoffset = base64_encode_block(source, sourcelen, dest, &_state); - while (!hiteof) { - byte igroup[3], ogroup[4]; - int c, n; - - igroup[0] = igroup[1] = igroup[2] = 0; - for (n = 0; n < 3; n++) { - if (spos >= sourcelen) { - hiteof = TRUE; - break; - } - c = source[spos++]; - igroup[n] = (byte) c; - } - if (n > 0) { - ogroup[0] = dtable[igroup[0] >> 2]; - ogroup[1] = - dtable[((igroup[0] & 3) << 4) | - (igroup[1] >> 4)]; - ogroup[2] = - dtable[((igroup[1] & 0xF) << 2) | - (igroup[2] >> 6)]; - ogroup[3] = dtable[igroup[2] & 0x3F]; - - /** - * Replace characters in output stream with "=" pad - * characters if fewer than three characters were - * read from the end of the input stream. - */ - - if (n < 3) { - ogroup[3] = '='; - if (n < 2) { - ogroup[2] = '='; - } - } - for (i = 0; i < 4; i++) { - dest[dpos++] = ogroup[i]; - dest[dpos] = 0; - } - thisline += 4; - if ( (linebreaks) && (thisline > 70) ) { - dest[dpos++] = '\r'; - dest[dpos++] = '\n'; - dest[dpos] = 0; - thisline = 0; - } - } + destoffset += base64_encode_blockend(&(dest[destoffset]), &_state, 0); } - if ( (linebreaks) && (thisline > 70) ) { - dest[dpos++] = '\r'; - dest[dpos++] = '\n'; - dest[dpos] = 0; - thisline = 0; - } - - return(dpos); + dest[destoffset] = 0; + return destoffset; } - /* * Convert base64-encoded to binary. Returns the length of the decoded data. * It will stop after reading 'length' bytes. */ int CtdlDecodeBase64(char *dest, const char *source, size_t length) { - int i, c; - int dpos = 0; - int spos = 0; - - - /*CONSTANTCONDITION*/ - while (TRUE) { - byte a[4], b[4], o[3]; + base64_decodestate _state; + int len; - for (i = 0; i < 4; i++) { - if (spos >= length) { - return(dpos); - } - c = source[spos++]; + base64_init_decodestate(&_state); - if (c == 0) { - if (i > 0) { - return(dpos); - } - return(dpos); - } - if (dtable[c] & 0x80) { - /* Ignoring errors: discard invalid character. */ - i--; - continue; - } - a[i] = (byte) c; - b[i] = (byte) dtable[c]; - } - o[0] = (b[0] << 2) | (b[1] >> 4); - o[1] = (b[1] << 4) | (b[2] >> 2); - o[2] = (b[2] << 6) | b[3]; - i = a[2] == '=' ? 1 : (a[3] == '=' ? 2 : 3); - if (i>=1) dest[dpos++] = o[0]; - if (i>=2) dest[dpos++] = o[1]; - if (i>=3) dest[dpos++] = o[2]; - dest[dpos] = 0; - if (i < 3) { - return(dpos); - } - } + len = base64_decode_block(source, length, dest, &_state); + dest[len] = '\0'; + return len; } /* * if we send out non ascii subjects, we encode it this way. */ -char *rfc2047encode(char *line, long length) +char *rfc2047encode(const char *line, long length) { - char *AlreadyEncoded; + const char *AlreadyEncoded; char *result; long end; #define UTF8_HEADER "=?UTF-8?B?" @@ -449,7 +321,7 @@ char *rfc2047encode(char *line, long length) return strdup(line); } - result = (char*) malloc(strlen(UTF8_HEADER) + 4 + length * 2); + result = (char*) malloc(sizeof(UTF8_HEADER) + 4 + length * 2); strncpy (result, UTF8_HEADER, strlen (UTF8_HEADER)); CtdlEncodeBase64(result + strlen(UTF8_HEADER), line, length, 0); end = strlen (result); @@ -459,39 +331,78 @@ char *rfc2047encode(char *line, long length) return result; } - /* - * Strip leading and trailing spaces from a string + * removes double slashes from pathnames + * allows / disallows trailing slashes */ -void striplt(char *buf) +void StripSlashes(char *Dir, int TrailingSlash) { - size_t len; - int a; + char *a, *b; + + a = b = Dir; + + while (!IsEmptyStr(a)) { + if (*a == '/') { + while (*a == '/') + a++; + *b = '/'; + b++; + } + else { + *b = *a; + b++; a++; + } + } + if ((TrailingSlash) && (*(b - 1) != '/')){ + *b = '/'; + b++; + } + *b = '\0'; - if (buf==NULL) return; - if (IsEmptyStr(buf)) return; - len = strlen(buf); - while ((!IsEmptyStr(buf)) && (isspace(buf[len - 1]))) - buf[--len] = 0; - if (IsEmptyStr(buf)) return; - a = 0; - while ((!IsEmptyStr(buf)) && (isspace(buf[a]))) - a++; - if (a > 0) - memmove(buf, &buf[a], len - a + 1); } +/* + * Strip leading and trailing spaces from a string + */ +size_t striplt(char *buf) { + char *first_nonspace = NULL; + char *last_nonspace = NULL; + char *ptr; + size_t new_len = 0; + + if ((buf == NULL) || (*buf == '\0')) { + return 0; + } + + for (ptr=buf; *ptr!=0; ++ptr) { + if (!isspace(*ptr)) { + if (!first_nonspace) { + first_nonspace = ptr; + } + last_nonspace = ptr; + } + } + + if ((!first_nonspace) || (!last_nonspace)) { + buf[0] = 0; + return 0; + } + new_len = last_nonspace - first_nonspace + 1; + memmove(buf, first_nonspace, new_len); + buf[new_len] = 0; + return new_len; +} -/** - * \brief check for the presence of a character within a string (returns count) - * \param st the string to examine - * \param ch the char to search - * \return the position inside of st +/* + * check for the presence of a character within a string (returns count) + * st the string to examine + * ch the char to search + * returns the number of times ch appears in st */ -int haschar(const char *st,int ch) +int haschar(const char *st, int ch) { const char *ptr; int b; @@ -507,53 +418,12 @@ int haschar(const char *st,int ch) } - - - -/* - * Format a date/time stamp for output - * seconds is whether to print the seconds - */ -void fmt_date(char *buf, size_t n, time_t thetime, int seconds) { - struct tm tm; - int hour; - - strcpy(buf, ""); - localtime_r(&thetime, &tm); - - hour = tm.tm_hour; - if (hour == 0) hour = 12; - else if (hour > 12) hour = hour - 12; - - if (seconds) { - snprintf(buf, n, "%s %d %4d %d:%02d:%02d%s", - ascmonths[tm.tm_mon], - tm.tm_mday, - tm.tm_year + 1900, - hour, - tm.tm_min, - tm.tm_sec, - ( (tm.tm_hour >= 12) ? "pm" : "am" ) - ); - } else { - snprintf(buf, n, "%s %d %4d %d:%02d%s", - ascmonths[tm.tm_mon], - tm.tm_mday, - tm.tm_year + 1900, - hour, - tm.tm_min, - ( (tm.tm_hour >= 12) ? "pm" : "am" ) - ); - } -} - - - /* * Determine whether the specified message number is contained within the * specified sequence set. */ -int is_msg_in_sequence_set(char *mset, long msgnum) { +int is_msg_in_sequence_set(const char *mset, long msgnum) +{ int num_sets; int s; char setstr[128], lostr[128], histr[128]; @@ -564,13 +434,16 @@ int is_msg_in_sequence_set(char *mset, long msgnum) { extract_token(setstr, mset, s, ',', sizeof setstr); extract_token(lostr, setstr, 0, ':', sizeof lostr); - if (num_tokens(setstr, ':') >= 2) { + if (num_tokens(setstr, ':') >= 2) + { extract_token(histr, setstr, 1, ':', sizeof histr); - if (!strcmp(histr, "*")) { + if (!strcmp(histr, "*")) + { snprintf(histr, sizeof histr, "%ld", LONG_MAX); } } - else { + else + { strcpy(histr, lostr); } lo = atol(lostr); @@ -582,6 +455,67 @@ int is_msg_in_sequence_set(char *mset, long msgnum) { return(0); } +/* + * Utility function to "readline" from memory + * start Location in memory from which we are reading. + * buf the buffer to place the string in. + * maxlen Size of string buffer + * returns pointer to the source memory right after we stopped reading. + */ +char *memreadline(char *start, char *buf, int maxlen) +{ + char ch; + char *ptr; + int len = 0; /* tally our own length to avoid strlen() delays */ + + ptr = start; + + while (1) { + ch = *ptr++; + if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) { + buf[len++] = ch; + } + if ((ch == 10) || (ch == 0)) { + buf[len] = 0; + return ptr; + } + } +} + + +/* + * Utility function to "readline" from memory + * start Location in memory from which we are reading. + * buf the buffer to place the string in. + * maxlen Size of string buffer + * retlen the length of the returned string + * returns a pointer to the source memory right after we stopped reading. + */ +char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen) +{ + char ch; + char *ptr; + int len = 0; /* tally our own length to avoid strlen() delays */ + + ptr = start; + + while (1) + { + ch = *ptr++; + if ((len + 1 < (maxlen)) && (ch != 13) && (ch != 10)) + { + buf[len++] = ch; + } + if ((ch == 10) || (ch == 0)) + { + buf[len] = 0; + *retlen = len; + return ptr; + } + } +} + + /** * \brief Utility function to "readline" from memory * \param start Location in memory from which we are reading. @@ -589,10 +523,10 @@ int is_msg_in_sequence_set(char *mset, long msgnum) { * \param maxlen Size of string buffer * \return Pointer to the source memory right after we stopped reading. */ -char *memreadline(char *start, char *buf, int maxlen) +const char *cmemreadline(const char *start, char *buf, int maxlen) { char ch; - char *ptr; + const char *ptr; int len = 0; /**< tally our own length to avoid strlen() delays */ ptr = start; @@ -618,10 +552,10 @@ char *memreadline(char *start, char *buf, int maxlen) * \param retlen the length of the returned string * \return Pointer to the source memory right after we stopped reading. */ -char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen) +const char *cmemreadlinelen(const char *start, char *buf, int maxlen, int *retlen) { char ch; - char *ptr; + const char *ptr; int len = 0; /**< tally our own length to avoid strlen() delays */ ptr = start; @@ -646,7 +580,7 @@ char *memreadlinelen(char *start, char *buf, int maxlen, int *retlen) * Strip a boundarized substring out of a string (for example, remove * parentheses and anything inside them). */ -void stripout(char *str, char leftboundary, char rightboundary) { +int stripout(char *str, char leftboundary, char rightboundary) { int a; int lb = (-1); int rb = (-1); @@ -658,12 +592,14 @@ void stripout(char *str, char leftboundary, char rightboundary) { if ( (lb > 0) && (rb > lb) ) { strcpy(&str[lb - 1], &str[rb + 1]); + return 1; } else if ( (lb == 0) && (rb > lb) ) { strcpy(str, &str[rb + 1]); + return 1; } - + return 0; } @@ -671,19 +607,30 @@ void stripout(char *str, char leftboundary, char rightboundary) { * Reduce a string down to a boundarized substring (for example, remove * parentheses and anything outside them). */ -void stripallbut(char *str, char leftboundary, char rightboundary) { - int a; - - for (a = 0; a < strlen(str); ++ a) { - if (str[a] == leftboundary) strcpy(str, &str[a+1]); - } - - for (a = 0; a < strlen(str); ++ a) { - if (str[a] == rightboundary) str[a] = 0; +long stripallbut(char *str, char leftboundary, char rightboundary) { + long len = 0; + + char *lb = NULL; + char *rb = NULL; + + lb = strrchr(str, leftboundary); + if (lb != NULL) { + ++lb; + rb = strchr(str, rightboundary); + if ((rb != NULL) && (rb >= lb)) { + *rb = 0; + fflush(stderr); + len = (long)rb - (long)lb; + memmove(str, lb, len); + str[len] = 0; + return(len); + } } + return (long)strlen(str); } + char *myfgets(char *s, int size, FILE *stream) { char *ret = fgets(s, size, stream); char *nl; @@ -698,29 +645,35 @@ char *myfgets(char *s, int size, FILE *stream) { return ret; } -/* - * Escape a string for feeding out as a URL. - * Output buffer must be big enough to handle escape expansion! +/** + * \brief Escape a string for feeding out as a URL. + * \param outbuf the output buffer + * \param oblen the size of outbuf to sanitize + * \param strbuf the input buffer */ -void urlesc(char *outbuf, char *strbuf) +void urlesc(char *outbuf, size_t oblen, char *strbuf) { - int a, b, c; - char *ec = " #&;`'|*?-~<>^()[]{}$\\"; + int a, b, c, len, eclen, olen; + char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\"; - strcpy(outbuf, ""); - - for (a = 0; a < (int)strlen(strbuf); ++a) { + *outbuf = '\0'; + len = strlen(strbuf); + eclen = strlen(ec); + olen = 0; + for (a = 0; a < len; ++a) { c = 0; - for (b = 0; b < strlen(ec); ++b) { + for (b = 0; b < eclen; ++b) { if (strbuf[a] == ec[b]) c = 1; } - b = strlen(outbuf); - if (c == 1) - sprintf(&outbuf[b], "%%%02x", strbuf[a]); - else - sprintf(&outbuf[b], "%c", strbuf[a]); + if (c == 1) { + snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]); + olen += 3; + } + else + outbuf[olen ++] = strbuf[a]; } + outbuf[olen] = '\0'; } @@ -741,12 +694,41 @@ char *strcpy(char *dest, const char *src) { * Generate a new, globally unique UID parameter for a calendar etc. object */ void generate_uuid(char *buf) { - static int seq = 0; + static int seq = (-1); + static int no_kernel_uuid = 0; + + /* If we are running on Linux then we have a kernelspace uuid generator available */ + + if (no_kernel_uuid == 0) { + FILE *fp; + fp = fopen("/proc/sys/kernel/random/uuid", "rb"); + if (fp) { + int rv; + rv = fread(buf, 36, 1, fp); + fclose(fp); + if (rv == 1) { + buf[36] = 0; + return; + } + } + } + + /* If the kernel didn't provide us with a uuid, we generate a pseudo-random one */ + + no_kernel_uuid = 1; - sprintf(buf, "%lx-%lx-%x", - time(NULL), + if (seq == (-1)) { + seq = (int)rand(); + } + ++seq; + seq = (seq % 0x0FFF) ; + + sprintf(buf, "%08lx-%04lx-4%03x-a%03x-%012lx", + (long)time(NULL), (long)getpid(), - (seq++) + seq, + seq, + (long)rand() ); } @@ -757,18 +739,101 @@ void generate_uuid(char *buf) { * The code is roughly based on the strstr() replacement from 'tin' written * by Urs Jannsen. */ -char *bmstrcasestr(char *text, char *pattern) { +inline static char *_bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) { register unsigned char *p, *t; register int i, j, *delta; register size_t p1; int deltaspace[256]; + + if (!text) return(NULL); + if (!pattern) return(NULL); + + /* algorithm fails if pattern is empty */ + if ((p1 = patlen) == 0) + return (text); + + /* code below fails (whenever i is unsigned) if pattern too long */ + if (p1 > textlen) + return (NULL); + + /* set up deltas */ + delta = deltaspace; + for (i = 0; i <= 255; i++) + delta[i] = p1; + for (p = (unsigned char *) pattern, i = p1; --i > 0;) + delta[tolower(*p++)] = i; + + /* + * From now on, we want patlen - 1. + * In the loop below, p points to the end of the pattern, + * t points to the end of the text to be tested against the + * pattern, and i counts the amount of text remaining, not + * including the part to be tested. + */ + p1--; + p = (unsigned char *) pattern + p1; + t = (unsigned char *) text + p1; + i = textlen - patlen; + while(1) { + if (tolower(p[0]) == tolower(t[0])) { + if (strncasecmp ((const char *)(p - p1), (const char *)(t - p1), p1) == 0) { + return ((char *)t - p1); + } + } + j = delta[tolower(t[0])]; + if (i < j) + break; + i -= j; + t += j; + } + return (NULL); +} + +/* + * bmstrcasestr() -- case-insensitive substring search + * + * This uses the Boyer-Moore search algorithm and is therefore quite fast. + * The code is roughly based on the strstr() replacement from 'tin' written + * by Urs Jannsen. + */ +char *bmstrcasestr(char *text, const char *pattern) { size_t textlen; size_t patlen; + if (!text) return(NULL); + if (!pattern) return(NULL); + textlen = strlen (text); patlen = strlen (pattern); + return _bmstrcasestr_len(text, textlen, pattern, patlen); +} + +char *bmstrcasestr_len(char *text, size_t textlen, const char *pattern, size_t patlen) { + return _bmstrcasestr_len(text, textlen, pattern, patlen); +} + + + + +/* + * bmstrcasestr() -- case-insensitive substring search + * + * This uses the Boyer-Moore search algorithm and is therefore quite fast. + * The code is roughly based on the strstr() replacement from 'tin' written + * by Urs Jannsen. + */ +inline static const char *_cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) { + + register unsigned char *p, *t; + register int i, j, *delta; + register size_t p1; + int deltaspace[256]; + + if (!text) return(NULL); + if (!pattern) return(NULL); + /* algorithm fails if pattern is empty */ if ((p1 = patlen) == 0) return (text); @@ -810,7 +875,29 @@ char *bmstrcasestr(char *text, char *pattern) { return (NULL); } +/* + * bmstrcasestr() -- case-insensitive substring search + * + * This uses the Boyer-Moore search algorithm and is therefore quite fast. + * The code is roughly based on the strstr() replacement from 'tin' written + * by Urs Jannsen. + */ +const char *cbmstrcasestr(const char *text, const char *pattern) { + size_t textlen; + size_t patlen; + if (!text) return(NULL); + if (!pattern) return(NULL); + + textlen = strlen (text); + patlen = strlen (pattern); + + return _cbmstrcasestr_len(text, textlen, pattern, patlen); +} + +const char *cbmstrcasestr_len(const char *text, size_t textlen, const char *pattern, size_t patlen) { + return _cbmstrcasestr_len(text, textlen, pattern, patlen); +} /* * Local replacement for controversial C library function that generates @@ -820,7 +907,7 @@ void CtdlMakeTempFileName(char *name, int len) { int i = 0; while (i++, i < 100) { - snprintf(name, len, "/tmp/ctdl.%4lx.%04x", + snprintf(name, len, "/tmp/ctdl.%04lx.%04x", (long)getpid(), rand() ); @@ -836,7 +923,7 @@ void CtdlMakeTempFileName(char *name, int len) { * Determine whether the specified message number is contained within the specified set. * Returns nonzero if the specified message number is in the specified message set string. */ -int is_msg_in_mset(char *mset, long msgnum) { +int is_msg_in_mset(const char *mset, long msgnum) { int num_sets; int s; char setstr[SIZ], lostr[SIZ], histr[SIZ]; /* was 1024 */ @@ -869,11 +956,9 @@ int is_msg_in_mset(char *mset, long msgnum) { } -/** - * \brief searches for a paternn within asearch string - * \param search the string to search - * \param patn the pattern to find in string - * \returns position in string +/* + * searches for a pattern within a search string + * returns position in string */ int pattern2(char *search, char *patn) { @@ -889,10 +974,10 @@ int pattern2(char *search, char *patn) } -/** - * \brief Strip leading and trailing spaces from a string; with premeasured and adjusted length. - * \param buf the string to modify - * \param len length of the string. +/* + * Strip leading and trailing spaces from a string; with premeasured and adjusted length. + * buf - the string to modify + * len - length of the string. */ void stripltlen(char *buf, int *len) { @@ -910,3 +995,40 @@ void stripltlen(char *buf, int *len) } } + +/* + * Convert all whitespace characters in a supplied string to underscores + */ +void convert_spaces_to_underscores(char *str) +{ + int len; + int i; + + if (!str) return; + + len = strlen(str); + for (i=0; i 126)) { + return 1; + } + pch++; + } + return 0; +} +