Back to index

libcitadel  8.12
Defines | Typedefs | Functions | Variables
tools.c File Reference
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <ctype.h>
#include <string.h>
#include <sys/stat.h>
#include <errno.h>
#include <limits.h>
#include <time.h>
#include "libcitadel.h"

Go to the source code of this file.

Defines

#define TRUE   1
#define FALSE   0
#define UTF8_HEADER   "=?UTF-8?B?"

Typedefs

typedef unsigned char byte

Functions

int safestrncpy (char *dest, const char *src, size_t n)
int num_tokens (const char *source, char tok)
long extract_token (char *dest, const char *source, int parmnum, char separator, int maxlen)
void remove_token (char *source, int parmnum, char separator)
int extract_int (const char *source, int parmnum)
long extract_long (const char *source, int parmnum)
unsigned long extract_unsigned_long (const char *source, int parmnum)
size_t CtdlEncodeBase64 (char *dest, const char *source, size_t sourcelen, int linebreaks)
int CtdlDecodeBase64 (char *dest, const char *source, size_t length)
char * rfc2047encode (char *line, long length)
void StripSlashes (char *Dir, int TrailingSlash)
size_t striplt (char *buf)
int haschar (const char *st, int ch)
 check for the presence of a character within a string (returns count)
void fmt_date (char *buf, size_t n, time_t thetime, int seconds)
int is_msg_in_sequence_set (const char *mset, long msgnum)
char * memreadline (char *start, char *buf, int maxlen)
 Utility function to "readline" from memory.
char * memreadlinelen (char *start, char *buf, int maxlen, int *retlen)
 Utility function to "readline" from memory.
const char * cmemreadline (const char *start, char *buf, int maxlen)
 Utility function to "readline" from memory.
const char * cmemreadlinelen (const char *start, char *buf, int maxlen, int *retlen)
 Utility function to "readline" from memory.
int stripout (char *str, char leftboundary, char rightboundary)
long stripallbut (char *str, char leftboundary, char rightboundary)
char * myfgets (char *s, int size, FILE *stream)
void urlesc (char *outbuf, size_t oblen, char *strbuf)
 Escape a string for feeding out as a URL.
char * strcpy (char *dest, const char *src)
void generate_uuid (char *buf)
static char * _bmstrcasestr_len (char *text, size_t textlen, const char *pattern, size_t patlen)
char * bmstrcasestr (char *text, const char *pattern)
char * bmstrcasestr_len (char *text, size_t textlen, const char *pattern, size_t patlen)
static const char * _cbmstrcasestr_len (const char *text, size_t textlen, const char *pattern, size_t patlen)
const char * cbmstrcasestr (const char *text, const char *pattern)
const char * cbmstrcasestr_len (const char *text, size_t textlen, const char *pattern, size_t patlen)
void CtdlMakeTempFileName (char *name, int len)
int is_msg_in_mset (const char *mset, long msgnum)
int pattern2 (char *search, char *patn)
void stripltlen (char *buf, int *len)
void convert_spaces_to_underscores (char *str)
int CheckEncode (const char *pch, long len, const char *pche)

Variables

const byte etable [256]
const byte dtable [256]

Define Documentation

#define FALSE   0

Definition at line 49 of file tools.c.

#define TRUE   1

Definition at line 48 of file tools.c.

#define UTF8_HEADER   "=?UTF-8?B?"

Typedef Documentation

typedef unsigned char byte

Definition at line 51 of file tools.c.


Function Documentation

static char* _bmstrcasestr_len ( char *  text,
size_t  textlen,
const char *  pattern,
size_t  patlen 
) [inline, static]

Definition at line 918 of file tools.c.

                                                                                                      {

       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);
}

Here is the caller graph for this function:

static const char* _cbmstrcasestr_len ( const char *  text,
size_t  textlen,
const char *  pattern,
size_t  patlen 
) [inline, static]

Definition at line 1003 of file tools.c.

                                                                                                                   {

       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);
}

Here is the caller graph for this function:

char* bmstrcasestr ( char *  text,
const char *  pattern 
)

Definition at line 976 of file tools.c.

                                                    {
       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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* bmstrcasestr_len ( char *  text,
size_t  textlen,
const char *  pattern,
size_t  patlen 
)

Definition at line 989 of file tools.c.

                                                                                       {
       return _bmstrcasestr_len(text, textlen, pattern, patlen);
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* cbmstrcasestr ( const char *  text,
const char *  pattern 
)

Definition at line 1061 of file tools.c.

                                                                 {
       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);
}

Here is the call graph for this function:

const char* cbmstrcasestr_len ( const char *  text,
size_t  textlen,
const char *  pattern,
size_t  patlen 
)

Definition at line 1074 of file tools.c.

                                                                                                    {
       return _cbmstrcasestr_len(text, textlen, pattern, patlen);
}

Here is the call graph for this function:

int CheckEncode ( const char *  pch,
long  len,
const char *  pche 
)

Definition at line 1197 of file tools.c.

{
       if (pche == NULL)
              pche = pch + len;
       while (pch < pche) {
              if (((unsigned char) *pch < 32) || 
                  ((unsigned char) *pch > 126)) {
                     return 1;
              }
              pch++;
       }
       return 0;
}

Here is the caller graph for this function:

const char* cmemreadline ( const char *  start,
char *  buf,
int  maxlen 
)

Utility function to "readline" from memory.

Parameters:
startLocation in memory from which we are reading.
bufthe buffer to place the string in.
maxlenSize of string buffer
Returns:
Pointer to the source memory right after we stopped reading.

< tally our own length to avoid strlen() delays

Definition at line 705 of file tools.c.

{
       char ch;
       const char *ptr;
       int len = 0;         
       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;
              }
       }
}
const char* cmemreadlinelen ( const char *  start,
char *  buf,
int  maxlen,
int *  retlen 
)

Utility function to "readline" from memory.

Parameters:
startLocation in memory from which we are reading.
bufthe buffer to place the string in.
maxlenSize of string buffer
retlenthe length of the returned string
Returns:
Pointer to the source memory right after we stopped reading.

< tally our own length to avoid strlen() delays

Definition at line 734 of file tools.c.

{
       char ch;
       const char *ptr;
       int len = 0;         
       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;
              }
       }
}
void convert_spaces_to_underscores ( char *  str)

Definition at line 1178 of file tools.c.

{
       int len;
       int i;

       if (!str) return;

       len = strlen(str);
       for (i=0; i<len; ++i) {
              if (isspace(str[i])) {
                     str[i] = '_';
              }
       }
}
int CtdlDecodeBase64 ( char *  dest,
const char *  source,
size_t  length 
)

Definition at line 401 of file tools.c.

{
    int i, c;
    int dpos = 0;
    int spos = 0;

    while (TRUE) {
       byte a[4], b[4], o[3];

       for (i = 0; i < 4; i++) {
           if (spos >= length) {
              return(dpos);
           }
           c = source[spos++];

           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);
       }
    }
}

Here is the caller graph for this function:

size_t CtdlEncodeBase64 ( char *  dest,
const char *  source,
size_t  sourcelen,
int  linebreaks 
)

Definition at line 331 of file tools.c.

{
       int i, hiteof = FALSE;
       int spos = 0;
       int dpos = 0;
       int thisline = 0;

       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] = etable[igroup[0] >> 2];
                     ogroup[1] =
                         etable[((igroup[0] & 3) << 4) |
                               (igroup[1] >> 4)];
                     ogroup[2] =
                         etable[((igroup[1] & 0xF) << 2) |
                               (igroup[2] >> 6)];
                     ogroup[3] = etable[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;
                     }
              }
       }
       if ( (linebreaks) && (thisline > 70) ) {
              dest[dpos++] = '\r';
              dest[dpos++] = '\n';
              dest[dpos] = 0;
       }

       return(dpos);
}

Here is the caller graph for this function:

void CtdlMakeTempFileName ( char *  name,
int  len 
)

Definition at line 1082 of file tools.c.

                                               {
       int i = 0;

       while (i++, i < 100) {
              snprintf(name, len, "/tmp/ctdl.%04lx.%04x",
                     (long)getpid(),
                     rand()
              );
              if (!access(name, F_OK)) {
                     return;
              }
       }
}
int extract_int ( const char *  source,
int  parmnum 
)

Definition at line 289 of file tools.c.

{
       char buf[32];
       
       if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
              return(atoi(buf));
       else
              return 0;
}

Here is the call graph for this function:

long extract_long ( const char *  source,
int  parmnum 
)

Definition at line 302 of file tools.c.

{
       char buf[32];
       
       if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
              return(atol(buf));
       else
              return 0;
}

Here is the call graph for this function:

long extract_token ( char *  dest,
const char *  source,
int  parmnum,
char  separator,
int  maxlen 
)

Definition at line 149 of file tools.c.

{
       const char *s;                     //* source * /
       int len = 0;                //* running total length of extracted string * /
       int current_token = 0;             //* token currently being processed * /

       s = source;

       if (dest == NULL) {
              return(-1);
       }

       //cit_backtrace();
       //lprintf (CTDL_DEBUG, "test >: n: %d sep: %c source: %s \n willi \n", parmnum, separator, source);
       dest[0] = 0;

       if (s == NULL) {
              return(-1);
       }
       
       maxlen--;

       while (*s) {
              if (*s == separator) {
                     ++current_token;
              }
              if ( (current_token == parmnum) && 
                   (*s != separator) && 
                   (len < maxlen) ) {
                     dest[len] = *s;
                     ++len;
              }
              else if ((current_token > parmnum) || (len >= maxlen)) {
                     break;
              }
              ++s;
       }

       dest[len] = '\0';
       if (current_token < parmnum) {
              //lprintf (CTDL_DEBUG,"test <!: %s\n", dest);
              return(-1);
       }
       //lprintf (CTDL_DEBUG,"test <: %d; %s\n", len, dest);
       return(len);
}

Here is the caller graph for this function:

unsigned long extract_unsigned_long ( const char *  source,
int  parmnum 
)

Definition at line 316 of file tools.c.

{
       char buf[32];

       if (extract_token(buf, source, parmnum, '|', sizeof buf) > 0)
              return strtoul(buf, NULL, 10);
       else 
              return 0;
}

Here is the call graph for this function:

void fmt_date ( char *  buf,
size_t  n,
time_t  thetime,
int  seconds 
)

Definition at line 567 of file tools.c.

                                                                {
       struct tm tm;
       int hour;

       /* Month strings for date conversions ... this needs to be localized eventually */
       char *fmt_date_months[12] = {
              "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
       };

       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",
                     fmt_date_months[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",
                     fmt_date_months[tm.tm_mon],
                     tm.tm_mday,
                     tm.tm_year + 1900,
                     hour,
                     tm.tm_min,
                     ( (tm.tm_hour >= 12) ? "pm" : "am" )
              );
       }
}

Here is the call graph for this function:

void generate_uuid ( char *  buf)

Definition at line 875 of file tools.c.

                              {
       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) return;
              }
       }

       /* If the kernel didn't provide us with a uuid, we generate a pseudo-random one */

       no_kernel_uuid = 1;

       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,
              (long)rand()
       );
}
int haschar ( const char *  st,
int  ch 
)

check for the presence of a character within a string (returns count)

Parameters:
stthe string to examine
chthe char to search
Returns:
the number of times ch appears in st

Definition at line 544 of file tools.c.

{
       const char *ptr;
       int b;
       b = 0;
       ptr = st;
       while (!IsEmptyStr(ptr))
       {
              if (*ptr == ch)
                     ++b;
              ptr ++;
       }
       return (b);
}
int is_msg_in_mset ( const char *  mset,
long  msgnum 
)

Definition at line 1102 of file tools.c.

                                                  {
       int num_sets;
       int s;
       char setstr[SIZ], lostr[SIZ], histr[SIZ];       /* was 1024 */
       long lo, hi;

       /*
        * Now set it for all specified messages.
        */
       num_sets = num_tokens(mset, ',');
       for (s=0; s<num_sets; ++s) {
              extract_token(setstr, mset, s, ',', sizeof setstr);

              extract_token(lostr, setstr, 0, ':', sizeof lostr);
              if (num_tokens(setstr, ':') >= 2) {
                     extract_token(histr, setstr, 1, ':', sizeof histr);
                     if (!strcmp(histr, "*")) {
                            snprintf(histr, sizeof histr, "%ld", LONG_MAX);
                     }
              }
              else {
                     strcpy(histr, lostr);
              }
              lo = atol(lostr);
              hi = atol(histr);

              if ((msgnum >= lo) && (msgnum <= hi)) return(1);
       }

       return(0);
}

Here is the call graph for this function:

int is_msg_in_sequence_set ( const char *  mset,
long  msgnum 
)

Definition at line 611 of file tools.c.

                                                          {
       int num_sets;
       int s;
       char setstr[128], lostr[128], histr[128];
       long lo, hi;

       num_sets = num_tokens(mset, ',');
       for (s=0; s<num_sets; ++s) {
              extract_token(setstr, mset, s, ',', sizeof setstr);

              extract_token(lostr, setstr, 0, ':', sizeof lostr);
              if (num_tokens(setstr, ':') >= 2) {
                     extract_token(histr, setstr, 1, ':', sizeof histr);
                     if (!strcmp(histr, "*")) {
                            snprintf(histr, sizeof histr, "%ld", LONG_MAX);
                     }
              } 
              else {
                     strcpy(histr, lostr);
              }
              lo = atol(lostr);
              hi = atol(histr);

              if ((msgnum >= lo) && (msgnum <= hi)) return(1);
       }

       return(0);
}

Here is the call graph for this function:

char* memreadline ( char *  start,
char *  buf,
int  maxlen 
)

Utility function to "readline" from memory.

Parameters:
startLocation in memory from which we are reading.
bufthe buffer to place the string in.
maxlenSize of string buffer
Returns:
Pointer to the source memory right after we stopped reading.

< tally our own length to avoid strlen() delays

Definition at line 647 of file tools.c.

{
       char ch;
       char *ptr;
       int len = 0;         
       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;
              }
       }
}
char* memreadlinelen ( char *  start,
char *  buf,
int  maxlen,
int *  retlen 
)

Utility function to "readline" from memory.

Parameters:
startLocation in memory from which we are reading.
bufthe buffer to place the string in.
maxlenSize of string buffer
retlenthe length of the returned string
Returns:
Pointer to the source memory right after we stopped reading.

< tally our own length to avoid strlen() delays

Definition at line 676 of file tools.c.

{
       char ch;
       char *ptr;
       int len = 0;         
       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;
              }
       }
}

Here is the caller graph for this function:

char* myfgets ( char *  s,
int  size,
FILE *  stream 
)

Definition at line 813 of file tools.c.

                                               {
       char *ret = fgets(s, size, stream);
       char *nl;

       if (ret != NULL) {
              nl = strchr(s, '\n');

              if (nl != NULL)
                     *nl = 0;
       }

       return ret;
}
int num_tokens ( const char *  source,
char  tok 
)

Definition at line 124 of file tools.c.

{
       int count = 1;
       const char *ptr = source;

       if (source == NULL) {
              return (0);
       }

       while (*ptr != '\0') {
              if (*ptr++ == tok) {
                     ++count;
              }
       }
       
       return (count);
}

Here is the caller graph for this function:

int pattern2 ( char *  search,
char *  patn 
)

Definition at line 1139 of file tools.c.

{
       int a;
       int len, plen;
       len = strlen (search);
       plen = strlen (patn);
       for (a = 0; a < len; ++a) {
              if (!strncasecmp(&search[a], patn, plen))
                     return (a);
       }
       return (-1);
}

Here is the caller graph for this function:

void remove_token ( char *  source,
int  parmnum,
char  separator 
)

Definition at line 244 of file tools.c.

{
       char *d, *s;         /* dest, source */
       int count = 0;

       /* Find desired parameter */
       d = source;
       while (count < parmnum) {
              /* End of string, bail! */
              if (!*d) {
                     d = NULL;
                     break;
              }
              if (*d == separator) {
                     count++;
              }
              d++;
       }
       if (!d) return;             /* Parameter not found */

       /* Find next parameter */
       s = d;
       while (*s && *s != separator) {
              s++;
       }

       /* Hack and slash */
       if (*s)
              strcpy(d, ++s);
       else if (d == source)
              *d = 0;
       else
              *--d = 0;
       /*
       while (*s) {
              *d++ = *s++;
       }
       *d = 0;
       */
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* rfc2047encode ( char *  line,
long  length 
)

Definition at line 448 of file tools.c.

{
       char *AlreadyEncoded;
       char *result;
       long end;
#define UTF8_HEADER "=?UTF-8?B?"

       /* check if we're already done */
       AlreadyEncoded = strstr(line, "=?");
       if ((AlreadyEncoded != NULL) &&
           ((strstr(AlreadyEncoded, "?B?") != NULL)||
            (strstr(AlreadyEncoded, "?Q?") != NULL)))
       {
              return strdup(line);
       }

       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);
        result[end]='?';
       result[end+1]='=';
       result[end+2]='\0';
       return result;
}

Here is the call graph for this function:

int safestrncpy ( char *  dest,
const char *  src,
size_t  n 
)

Definition at line 101 of file tools.c.

{
       int i = 0;

       if (dest == NULL || src == NULL) {
              fprintf(stderr, "safestrncpy: NULL argument\n");
              abort();
       }

       do {
              dest[i] = src[i];
              if (dest[i] == 0) return i;
              ++i;
       } while (i<n);
       dest[n - 1] = 0;
       return -i;
}

Here is the caller graph for this function:

char* strcpy ( char *  dest,
const char *  src 
)

Definition at line 866 of file tools.c.

                                          {
       memmove(dest, src, (strlen(src) + 1) );
       return(dest);
}

Here is the caller graph for this function:

long stripallbut ( char *  str,
char  leftboundary,
char  rightboundary 
)

Definition at line 789 of file tools.c.

                                                                   {
       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);
}

Here is the caller graph for this function:

size_t striplt ( char *  buf)

Definition at line 507 of file tools.c.

                          {
       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;
}

Here is the caller graph for this function:

void stripltlen ( char *  buf,
int *  len 
)

Definition at line 1158 of file tools.c.

{
       int delta = 0;
       if (*len == 0) return;
       while ((*len > delta) && (isspace(buf[delta]))){
              delta ++;
       }
       memmove (buf, &buf[delta], *len - delta + 1);
       (*len) -=delta;

       if (*len == 0) return;
       while (isspace(buf[(*len) - 1])){
              buf[--(*len)] = '\0';
       }
}
int stripout ( char *  str,
char  leftboundary,
char  rightboundary 
)

Definition at line 762 of file tools.c.

                                                               {
       int a;
        int lb = (-1);
        int rb = (-1);

        for (a = 0; a < strlen(str); ++a) {
                if (str[a] == leftboundary) lb = a;
                if (str[a] == rightboundary) rb = a;
        }

        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;
}

Here is the call graph for this function:

void StripSlashes ( char *  Dir,
int  TrailingSlash 
)

Definition at line 478 of file tools.c.

{
       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';

}
void urlesc ( char *  outbuf,
size_t  oblen,
char *  strbuf 
)

Escape a string for feeding out as a URL.

Parameters:
outbufthe output buffer
oblenthe size of outbuf to sanitize
strbufthe input buffer

Definition at line 833 of file tools.c.

{
       int a, b, c, len, eclen, olen;
       char *ec = " +#&;`'|*?-~<>^()[]{}/$\"\\";

       strcpy(outbuf, "");
       len = strlen(strbuf);
       eclen = strlen(ec);
       olen = 0;
       for (a = 0; a < len; ++a) {
              c = 0;
              for (b = 0; b < eclen; ++b) {
                     if (strbuf[a] == ec[b])
                            c = 1;
              }
              if (c == 1) {
                     snprintf(&outbuf[olen], oblen - olen, "%%%02x", strbuf[a]);
                     olen += 3;
              }
              else 
                     outbuf[olen ++] = strbuf[a];
       }
       outbuf[olen] = '\0';
}

Here is the call graph for this function:


Variable Documentation

const byte dtable[256]
Initial value:
 {
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
       128, 128, 128, 0, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
       12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128,
       128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
       40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
       128, 128, 0
}

Definition at line 71 of file tools.c.

const byte etable[256]
Initial value:
 {
       65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
       82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103,
       104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
       118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43,
       47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0
}

Definition at line 54 of file tools.c.