* Use ‘alpine -F’ instead of ‘pine -F’ as the browser default pager, as this

[alpine.git] / mapi / rfc1522.c

/*
 * ========================================================================
 * Copyright 2006 University of Washington
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * ========================================================================
 */

/*
 *  rfc1522.c
 *
 *  right now this is just rfc1522_encode (taken straight out of pine/strings.c, 
 *  but if were to become necessary,
 *  it could be made to do rfc1522_decode too, and it already has some strings functions.
 */
#include "pmapi.h"

#define RFC1522_INIT    "=?"
#define RFC1522_INIT_L  2
#define RFC1522_TERM    "?="
#define RFC1522_TERM_L  2
#define RFC1522_DLIM    "?"
#define RFC1522_DLIM_L  1
#define RFC1522_MAXW    75
#define ESPECIALS       "()<>@,;:\"/[]?.="
#define RFC1522_OVERHEAD(S)     (RFC1522_INIT_L + RFC1522_TERM_L +      \
                                 (2 * RFC1522_DLIM_L) + strlen(S) + 1);
#define RFC1522_ENC_CHAR(C)     (((C) & 0x80) || !rfc1522_valtok(C)     \
                                 || (C) == '_' )
#define SPACE           ' '             /* space character      */
#define ESCAPE          '\033'          /* the escape           */
#define UNKNOWN_CHARSET         "X-UNKNOWN"

/*
 * Hex conversion aids
 */
#define HEX_ARRAY       "0123456789ABCDEF"
#define HEX_CHAR1(C)    HEX_ARRAY[((C) & 0xf0) >> 4]
#define HEX_CHAR2(C)    HEX_ARRAY[(C) & 0xf]

#define C2XPAIR(C, S)   { \
                            *(S)++ = HEX_CHAR1(C); \
                            *(S)++ = HEX_CHAR2(C); \
                        }


int            rfc1522_token PROTO((char *, int (*) PROTO((int)), char *,
                                    char **));
int            rfc1522_valtok PROTO((int));
int            rfc1522_valenc PROTO((int));
int            rfc1522_valid PROTO((char *, char **, char **, char **,
                                    char **));
char          *rfc1522_8bit PROTO((void *, int));
char          *rfc1522_binary PROTO((void *, int));
unsigned char *rfc1522_encoded_word PROTO((unsigned char *, int, char *));
char          *strindex PROTO((char *, int));
void        sstrcpy PROTO((char **, char *));
void        sstrncpy PROTO((char **, char *, int));

int         removing_double_quotes PROTO((char *));

static char *known_escapes[] = {
    "(B",  "(J",  "$@",  "$B",                  /* RFC 1468 */
    "(H",
    NULL};
/* different for non-Windows */

int
match_escapes(esc_seq)
    char *esc_seq;
{
    char **p;
    int    n;

    for(p = known_escapes; *p && strncmp(esc_seq, *p, n = strlen(*p)); p++)
      ;

    return(*p ? n + 1 : 0);
}

/*----------------------------------------------------------------------
    A replacement for strchr or index ...

    Returns a pointer to the first occurrence of the character
    'ch' in the specified string or NULL if it doesn't occur

 ....so we don't have to worry if it's there or not. We bring our own.
If we really care about efficiency and think the local one is more
efficient the local one can be used, but most of the things that take
a long time are in the c-client and not in pine.
 ----*/
char *
strindex(buffer, ch)
    char *buffer;
    int ch;
{
    do
      if(*buffer == ch)
        return(buffer);
    while (*buffer++ != '\0');

    return(NULL);
}

/*----------------------------------------------------------------------
  copy the source string onto the destination string returning with
  the destination string pointer at the end of the destination text

  motivation for this is to avoid twice passing over a string that's
  being appended to twice (i.e., strcpy(t, x); t += strlen(t))
 ----*/
void
sstrcpy(d, s)
    char **d;
    char *s;
{
    while((**d = *s++) != '\0')
      (*d)++;
}

void
sstrncpy(d, s, n)
    char **d;
    char *s;
    int n;
{
    while(n-- > 0 && (**d = *s++) != '\0')
      (*d)++;
}

/*
 * rfc1522_token - scan the given source line up to the end_str making
 *                 sure all subsequent chars are "valid" leaving endp
 *                 a the start of the end_str.
 * Returns: TRUE if we got a valid token, FALSE otherwise
 */
int
rfc1522_token(s, valid, end_str, endp)
    char  *s;
    int  (*valid) PROTO((int));
    char  *end_str;
    char **endp;
{
    while(*s){
        if((char) *s == *end_str                /* test for matching end_str */
           && ((end_str[1])
                ? !strncmp((char *)s + 1, end_str + 1, strlen(end_str + 1))
                : 1)){
            *endp = s;
            return(TRUE);
        }

        if(!(*valid)(*s++))                     /* test for valid char */
          break;
    }

    return(FALSE);
}


/*
 * rfc1522_valtok - test for valid character in the RFC 1522 encoded
 *                  word's charset and encoding fields.
 */
int
rfc1522_valtok(c)
    int c;
{
    return(!(c == SPACE || iscntrl(c & 0x7f) || strindex(ESPECIALS, c)));
}


/*
 * rfc1522_valenc - test for valid character in the RFC 1522 encoded
 *                  word's encoded-text field.
 */
int
rfc1522_valenc(c)
    int c;
{
    return(!(c == '?' || c == SPACE) && isprint((unsigned char)c));
}


/*
 * rfc1522_valid - validate the given string as to it's rfc1522-ness
 */
int
rfc1522_valid(s, charset, enc, txt, endp)
    char  *s;
    char **charset;
    char **enc;
    char **txt;
    char **endp;
{
    char *c, *e, *t, *p;
    int   rv;

    rv = rfc1522_token(c = s+RFC1522_INIT_L, rfc1522_valtok, RFC1522_DLIM, &e)
           && rfc1522_token(++e, rfc1522_valtok, RFC1522_DLIM, &t)
           && rfc1522_token(++t, rfc1522_valenc, RFC1522_TERM, &p)
           && p - s <= RFC1522_MAXW;

    if(charset)
      *charset = c;

    if(enc)
      *enc = e;

    if(txt)
      *txt = t;

    if(endp)
      *endp = p;

    return(rv);
}


/*
 * rfc1522_encode - encode the given source string ala RFC 1522,
 *                  IF NECESSARY, into the given destination buffer.
 *                  Don't bother copying if it turns out encoding
 *                  isn't necessary.
 *
 * Returns: pointer to either the destination buffer containing the
 *          encoded text, or a pointer to the source buffer if we didn't
 *          have to encode anything.
 */
char *
rfc1522_encode(d, len, s, charset)
    char          *d;
    size_t         len;         /* length of d */
    unsigned char *s;
    char          *charset;
{
    unsigned char *p, *q;
    int            n;

    if(!s)
      return((char *) s);

    if(!charset)
      charset = UNKNOWN_CHARSET;

    /* look for a reason to encode */
    for(p = s, n = 0; *p; p++)
      if((*p) & 0x80){
          n++;
      }
      else if(*p == RFC1522_INIT[0]
              && !strncmp((char *) p, RFC1522_INIT, RFC1522_INIT_L)){
          if(rfc1522_valid((char *) p, NULL, NULL, NULL, (char **) &q))
            p = q + RFC1522_TERM_L - 1;         /* advance past encoded gunk */
      }
      else if(*p == ESCAPE && match_escapes((char *)(p+1))){
          n++;
      }

    if(n){                                      /* found, encoding to do */
        char *rv  = d, *t,
              enc = (n > (2 * (p - s)) / 3) ? 'B' : 'Q';

        while(*s){
            if(d-rv < len-1-(RFC1522_INIT_L+2*RFC1522_DLIM_L+1)){
                sstrcpy(&d, RFC1522_INIT);      /* insert intro header, */
                sstrcpy(&d, charset);           /* character set tag, */
                sstrcpy(&d, RFC1522_DLIM);      /* and encoding flavor */
                *d++ = enc;
                sstrcpy(&d, RFC1522_DLIM);
            }

            /*
             * feed lines to encoder such that they're guaranteed
             * less than RFC1522_MAXW.
             */
            p = rfc1522_encoded_word(s, enc, charset);
            if(enc == 'B')                      /* insert encoded data */
              sstrncpy(&d, t = rfc1522_binary(s, p - s), len-1-(d-rv));
            else                                /* 'Q' encoding */
              sstrncpy(&d, t = rfc1522_8bit(s, p - s), len-1-(d-rv));

            sstrncpy(&d, RFC1522_TERM, len-1-(d-rv));   /* insert terminator */
            fs_give((void **) &t);
            if(*p)                              /* more src string follows */
              sstrncpy(&d, "\015\012 ", len-1-(d-rv));  /* insert cont. line */

            s = p;                              /* advance s */
        }

        rv[len-1] = '\0';
        return(rv);
    }
    else
      return((char *) s);                       /* no work for us here */
}



/*
 * rfc1522_encoded_word -- cut given string into max length encoded word
 *
 * Return: pointer into 's' such that the encoded 's' is no greater
 *         than RFC1522_MAXW
 *
 *  NOTE: this line break code is NOT cognizant of any SI/SO
 *  charset requirements nor similar strategies using escape
 *  codes.  Hopefully this will matter little and such
 *  representation strategies don't also include 8bit chars.
 */
unsigned char *
rfc1522_encoded_word(s, enc, charset)
    unsigned char *s;
    int            enc;
    char          *charset;
{
    int goal = RFC1522_MAXW - RFC1522_OVERHEAD(charset);

    if(enc == 'B')                      /* base64 encode */
      for(goal = ((goal / 4) * 3) - 2; goal && *s; goal--, s++)
        ;
    else                                /* special 'Q' encoding */
      for(; goal && *s; s++)
        if((goal -= RFC1522_ENC_CHAR(*s) ? 3 : 1) < 0)
          break;

    return(s);
}



/*
 * rfc1522_8bit -- apply RFC 1522 'Q' encoding to the given 8bit buffer
 *
 * Return: alloc'd buffer containing encoded string
 */
char *
rfc1522_8bit(src, slen)
    void *src;
    int   slen;
{
    char *ret = (char *) fs_get ((size_t) (3*slen + 2));
    char *d = ret;
    unsigned char c;
    unsigned char *s = (unsigned char *) src;

    while (slen--) {                            /* for each character */
        if (((c = *s++) == '\015') && (*s == '\012') && slen) {
            *d++ = '\015';                      /* true line break */
            *d++ = *s++;
            slen--;
        }
        else if(c == SPACE){                    /* special encoding case */
            *d++ = '_';
        }
        else if(RFC1522_ENC_CHAR(c)){
            *d++ = '=';                         /* quote character */
            C2XPAIR(c, d);
        }
        else
          *d++ = (char) c;                      /* ordinary character */
    }

    *d = '\0';                                  /* tie off destination */
    return(ret);
}


/*
 * rfc1522_binary -- apply RFC 1522 'B' encoding to the given 8bit buffer
 *
 * Return: alloc'd buffer containing encoded string
 */
char *
rfc1522_binary (src, srcl)
    void *src;
    int   srcl;
{
    static char *v =
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    unsigned char *s = (unsigned char *) src;
    char *ret, *d;

    d = ret = (char *) fs_get ((size_t) ((((srcl + 2) / 3) * 4) + 1));
    for (; srcl; s += 3) {      /* process tuplets */
                                /* byte 1: high 6 bits (1) */
        *d++ = v[s[0] >> 2];
                                /* byte 2: low 2 bits (1), high 4 bits (2) */
        *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f];
                                /* byte 3: low 4 bits (2), high 2 bits (3) */
        *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) :0)) & 0x3f] :'=';
                                /* byte 4: low 6 bits (3) */
        *d++ = srcl ? v[s[2] & 0x3f] : '=';
        if(srcl)
          srcl--;               /* count third character if processed */
    }

    *d = '\0';                  /* tie off string */
    return(ret);                /* return the resulting string */
}


/*
 *  Function to parse the given string into two space-delimited fields
 *  Quotes may be used to surround labels or values with spaces in them.
 *  Backslash negates the special meaning of a quote.
 *  Unescaping of backslashes only happens if the pair member is quoted,
 *    this provides for backwards compatibility.
 *
 * Args -- string -- the source string
 *          label -- the first half of the string, a return value
 *          value -- the last half of the string, a return value
 *        firstws -- if set, the halves are delimited by the first unquoted
 *                    whitespace, else by the last unquoted whitespace
 *   strip_internal_label_quotes -- unescaped quotes in the middle of the label
 *                                   are removed. This is useful for vars
 *                                   like display-filters and url-viewers
 *                                   which may require quoting of an arg
 *                                   inside of a _TOKEN_.
 */
void
get_pair(string, label, value, firstws, strip_internal_label_quotes)
    char *string, **label, **value;
    int   firstws;
    int   strip_internal_label_quotes;
{
    char *p, *q, *tmp, *token = NULL;
    int   quoted = 0;

    *label = *value = NULL;

    /*
     * This for loop just finds the beginning of the value. If firstws
     * is set, then it begins after the first whitespace. Otherwise, it begins
     * after the last whitespace. Quoted whitespace doesn't count as
     * whitespace. If there is no unquoted whitespace, then there is no
     * label, there's just a value.
     */
    for(p = string; p && *p;){
        if(*p == '"')                           /* quoted label? */
          quoted = (quoted) ? 0 : 1;

        if(*p == '\\' && *(p+1) == '"')         /* escaped quote? */
          p++;                                  /* skip it... */

        if(isspace((unsigned char)*p) && !quoted){      /* if space,  */
            while(*++p && isspace((unsigned char)*p))   /* move past it */
              ;

            if(!firstws || !token)
              token = p;                        /* remember start of text */
        }
        else
          p++;
    }

    if(token){                                  /* copy label */
        *label = p = (char *)fs_get(((token - string) + 1) * sizeof(char));

        /* make a copy of the string */
        tmp = (char *)fs_get(((token - string) + 1) * sizeof(char));
        strncpy(tmp, string, token - string);
        tmp[token-string] = '\0';

        removing_leading_and_trailing_white_space(tmp);
        quoted = removing_double_quotes(tmp);
        
        for(q = tmp; *q; q++){
            if(quoted && *q == '\\' && (*(q+1) == '"' || *(q+1) == '\\'))
              *p++ = *++q;
            else if(!(strip_internal_label_quotes && *q == '"'))
              *p++ = *q;
        }

        *p = '\0';                              /* tie off label */
        fs_give((void **)&tmp);
        if(*label == '\0')
          fs_give((void **)label);
    }
    else
      token = string;

    if(token){                                  /* copy value */
        *value = p = (char *)fs_get((strlen(token) + 1) * sizeof(char));

        tmp = cpystr(token);
        removing_leading_and_trailing_white_space(tmp);
        quoted = removing_double_quotes(tmp);

        for(q = tmp; *q ; q++){
            if(quoted && *q == '\\' && (*(q+1) == '"' || *(q+1) == '\\'))
              *p++ = *++q;
            else
              *p++ = *q;
        }

        *p = '\0';                              /* tie off value */
        fs_give((void **)&tmp);
    }
}

void
removing_leading_and_trailing_white_space(string)
     char *string;
{
    register char *p, *q = NULL;

    if(!string)
      return;

    for(p = string; *p; p++)            /* find the first non-blank  */
      if(!isspace((unsigned char)*p)){
          while(*string = *p++){        /* copy back from there... */
              q = (!isspace((unsigned char)*string)) ? NULL : (!q) ? string : q;
              string++;
          }

          if(q)
            *q = '\0';
            
          return;
      }

    if(*string != '\0')
      *string = '\0';
}

/*----------------------------------------------------------------------  
       Remove one set of double quotes surrounding string in place
       Returns 1 if quotes were removed
  
  Args: string -- string to remove quotes from
  ----*/
int
removing_double_quotes(string)
     char *string;
{
    register char *p;
    int ret = 0;

    if(string && string[0] == '"' && string[1] != '\0'){
        p = string + strlen(string) - 1;
        if(*p == '"'){
            ret++;
            *p = '\0';
            for(p = string; *p; p++) 
              *p = *(p+1);
        }
    }

    return(ret);
}