[disorder] / lib / mime.c

/*
 * This file is part of DisOrder
 * Copyright (C) 2005, 2007 Richard Kettlewell
 *
 * This program is free 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 2 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
 */
/** @file lib/mime.c
 * @brief Support for MIME and allied protocols
 */

#include <config.h>
#include "types.h"

#include <string.h>
#include <ctype.h>

#include <stdio.h>

#include "mem.h"
#include "mime.h"
#include "vector.h"
#include "hex.h"
#include "log.h"
#include "base64.h"
#include "kvp.h"

/** @brief Match whitespace characters */
static int whitespace(int c) {
  switch(c) {
  case ' ':
  case '\t':
  case '\r':
  case '\n':
    return 1;
  default:
    return 0;
  }
}

/** @brief Match RFC2045 tspecial characters */
static int tspecial(int c) {
  switch(c) {
  case '(':
  case ')':
  case '<':
  case '>':
  case '@':
  case ',':
  case ';':
  case ':':
  case '\\':
  case '"':
  case '/':
  case '[':
  case ']':
  case '?':
  case '=':
    return 1;
  default:
    return 0;
  }
}

/** @brief Match RFC2616 separator characters */
static int http_separator(int c) {
  switch(c) {
  case '(':
  case ')':
  case '<':
  case '>':
  case '@':
  case ',':
  case ';':
  case ':':
  case '\\':
  case '"':
  case '/':
  case '[':
  case ']':
  case '?':
  case '=':
  case '{':
  case '}':
  case ' ':
  case '\t':
    return 1;
  default:
    return 0;
  }
}

/** @brief Match CRLF */
static int iscrlf(const char *ptr) {
  return ptr[0] == '\r' && ptr[1] == '\n';
}

/** @brief Skip whitespace
 * @param s Pointer into string
 * @param rfc822_comments If true, skip RFC822 nested comments
 * @return Pointer into string after whitespace
 */
static const char *skipwhite(const char *s, int rfc822_comments) {
  int c, depth;
  
  for(;;) {
    switch(c = *s) {
    case ' ':
    case '\t':
    case '\r':
    case '\n':
      ++s;
      break;
    case '(':
      if(!rfc822_comments)
	return s;
      ++s;
      depth = 1;
      while(*s && depth) {
	c = *s++;
	switch(c) {
	case '(': ++depth; break;
	case ')': --depth; break;
	case '\\':
	  if(!*s)
	    return 0;
	  ++s;
	  break;
	}
      }
      if(depth)
	return 0;
      break;
    default:
      return s;
    }
  }
}

/** @brief Test for a word character
 * @param c Character to test
 * @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
 * @return 1 if @p c is a word character, else 0
 */
static int iswordchar(int c, int (*special)(int)) {
  return !(c <= ' ' || c > '~' || special(c));
}

/** @brief Parse an RFC1521/RFC2616 word
 * @param s Pointer to start of word
 * @param valuep Where to store value
 * @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
 * @return Pointer just after end of word or NULL if there's no word
 *
 * A word is a token or a quoted-string.
 */
static const char *parseword(const char *s, char **valuep,
			     int (*special)(int)) {
  struct dynstr value[1];
  int c;

  dynstr_init(value);
  if(*s == '"') {
    ++s;
    while((c = *s++) != '"') {
      switch(c) {
      case '\\':
	if(!(c = *s++))
	  return 0;
      default:
	dynstr_append(value, c);
	break;
      }
    }
    if(!c)
      return 0;
  } else {
    if(!iswordchar((unsigned char)*s, special))
      return NULL;
    dynstr_init(value);
    while(iswordchar((unsigned char)*s, special))
      dynstr_append(value, *s++);
  }
  dynstr_terminate(value);
  *valuep = value->vec;
  return s;
}

/** @brief Parse an RFC1521/RFC2616 token
 * @param s Pointer to start of token
 * @param valuep Where to store value
 * @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
 * @return Pointer just after end of token or NULL if there's no token
 */
static const char *parsetoken(const char *s, char **valuep,
			      int (*special)(int)) {
  if(*s == '"')
    return 0;
  return parseword(s, valuep, special);
}

/** @brief Parse a MIME content-type field
 * @param s Start of field
 * @param typep Where to store type
 * @param parametersp Where to store parameter list
 * @return 0 on success, non-0 on error
 *
 * See <a href="http://tools.ietf.org/html/rfc2045#section-5">RFC 2045 s5</a>.
 */
int mime_content_type(const char *s,
		      char **typep,
		      struct kvp **parametersp) {
  struct dynstr type, parametername;
  struct kvp *parameters = 0;
  char *parametervalue;

  dynstr_init(&type);
  if(!(s = skipwhite(s, 1)))
    return -1;
  if(!*s)
    return -1;
  while(*s && !tspecial(*s) && !whitespace(*s))
    dynstr_append(&type, tolower((unsigned char)*s++));
  if(!(s = skipwhite(s, 1)))
    return -1;
  if(*s++ != '/')
    return -1;
  dynstr_append(&type, '/');
  if(!(s = skipwhite(s, 1)))
    return -1;
  while(*s && !tspecial(*s) && !whitespace(*s))
    dynstr_append(&type, tolower((unsigned char)*s++));
  if(!(s = skipwhite(s, 1)))
    return -1;

  while(*s == ';') {
    dynstr_init(&parametername);
    ++s;
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(!*s)
      return -1;
    while(*s && !tspecial(*s) && !whitespace(*s))
      dynstr_append(&parametername, tolower((unsigned char)*s++));
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(*s++ != '=')
      return -1;
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(!(s = parseword(s, &parametervalue, tspecial)))
      return -1;
    if(!(s = skipwhite(s, 1)))
      return -1;
    dynstr_terminate(&parametername);
    kvp_set(&parameters, parametername.vec, parametervalue);
  }
  dynstr_terminate(&type);
  *typep = type.vec;
  *parametersp = parameters;
  return 0;
}

/** @brief Parse a MIME message
 * @param s Start of message
 * @param callback Called for each header field
 * @param u Passed to callback
 * @return Pointer to decoded body (might be in original string), or NULL on error
 *
 * This does an RFC 822-style parse and honors Content-Transfer-Encoding as
 * described in <a href="http://tools.ietf.org/html/rfc2045#section-6">RFC 2045
 * s6</a>.  @p callback is called for each header field encountered, in order,
 * with ASCII characters in the header name forced to lower case.
 */
const char *mime_parse(const char *s,
		       int (*callback)(const char *name, const char *value,
				       void *u),
		       void *u) {
  struct dynstr name, value;
  char *cte = 0, *p;
  
  while(*s && !iscrlf(s)) {
    dynstr_init(&name);
    dynstr_init(&value);
    while(*s && !tspecial(*s) && !whitespace(*s))
      dynstr_append(&name, tolower((unsigned char)*s++));
    if(!(s = skipwhite(s, 1)))
      return 0;
    if(*s != ':')
      return 0;
    ++s;
    while(*s && !(*s == '\n' && !(s[1] == ' ' || s[1] == '\t'))) {
      const int c = *s++;
      /* Strip leading whitespace */
      if(value.nvec || !(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
	dynstr_append(&value, c);
    }
    /* Strip trailing whitespace */
    while(value.nvec > 0 && (value.vec[value.nvec - 1] == ' '
			     || value.vec[value.nvec - 1] == '\t'
			     || value.vec[value.nvec - 1] == '\n'
			     || value.vec[value.nvec - 1] == '\r'))
      --value.nvec;
    if(*s)
      ++s;
    dynstr_terminate(&name);
    dynstr_terminate(&value);
    if(!strcmp(name.vec, "content-transfer-encoding")) {
      cte = xstrdup(value.vec);
      for(p = cte; *p; p++)
	*p = tolower((unsigned char)*p);
    }
    if(callback(name.vec, value.vec, u))
      return 0;
  }
  if(*s)
    s += 2;
  if(cte) {
    if(!strcmp(cte, "base64"))
      return mime_base64(s, 0);
    if(!strcmp(cte, "quoted-printable"))
      return mime_qp(s);
    if(!strcmp(cte, "7bit") || !strcmp(cte, "8bit"))
      return s;
    error(0, "unknown content-transfer-encoding '%s'", cte);
    return 0;
  }
  return s;
}

/** @brief Match the boundary string */
static int isboundary(const char *ptr, const char *boundary, size_t bl) {
  return (ptr[0] == '-'
	  && ptr[1] == '-'
	  && !strncmp(ptr + 2, boundary, bl)
	  && (iscrlf(ptr + bl + 2)
	      || (ptr[bl + 2] == '-'
		  && ptr[bl + 3] == '-'
		  && (iscrlf(ptr + bl + 4) || *(ptr + bl + 4) == 0))));
}

/** @brief Match the final boundary string */
static int isfinal(const char *ptr, const char *boundary, size_t bl) {
  return (ptr[0] == '-'
	  && ptr[1] == '-'
	  && !strncmp(ptr + 2, boundary, bl)
	  && ptr[bl + 2] == '-'
	  && ptr[bl + 3] == '-'
	  && (iscrlf(ptr + bl + 4) || *(ptr + bl + 4) == 0));
}

/** @brief Parse a multipart MIME body
 * @param s Start of message
 * @param callback Callback for each part
 * @param boundary Boundary string
 * @param u Passed to callback
 * @return 0 on success, non-0 on error
 * 
 * See <a href="http://tools.ietf.org/html/rfc2046#section-5.1">RFC 2046
 * s5.1</a>.  @p callback is called for each part (not yet decoded in any way)
 * in succession; you should probably call mime_parse() for each part.
 */
int mime_multipart(const char *s,
		   int (*callback)(const char *s, void *u),
		   const char *boundary,
		   void *u) {
  size_t bl = strlen(boundary);
  const char *start, *e;
  int ret;

  /* We must start with a boundary string */
  if(!isboundary(s, boundary, bl))
    return -1;
  /* Keep going until we hit a final boundary */
  while(!isfinal(s, boundary, bl)) {
    s = strstr(s, "\r\n") + 2;
    start = s;
    while(!isboundary(s, boundary, bl)) {
      if(!(e = strstr(s, "\r\n")))
	return -1;
      s = e + 2;
    }
    if((ret = callback(xstrndup(start,
				s == start ? 0 : s - start - 2),
		       u)))
      return ret;
  }
  return 0;
}

/** @brief Parse an RFC2388-style content-disposition field
 * @param s Start of field
 * @param dispositionp Where to store disposition
 * @param parameternamep Where to store parameter name
 * @param parametervaluep Wher to store parameter value
 * @return 0 on success, non-0 on error
 *
 * See <a href="http://tools.ietf.org/html/rfc2388#section-3">RFC 2388 s3</a>
 * and <a href="http://tools.ietf.org/html/rfc2183">RFC 2183</a>.
 */
int mime_rfc2388_content_disposition(const char *s,
				     char **dispositionp,
				     char **parameternamep,
				     char **parametervaluep) {
  struct dynstr disposition, parametername;

  dynstr_init(&disposition);
  if(!(s = skipwhite(s, 1)))
    return -1;
  if(!*s)
    return -1;
  while(*s && !tspecial(*s) && !whitespace(*s))
    dynstr_append(&disposition, tolower((unsigned char)*s++));
  if(!(s = skipwhite(s, 1)))
    return -1;

  if(*s == ';') {
    dynstr_init(&parametername);
    ++s;
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(!*s)
      return -1;
    while(*s && !tspecial(*s) && !whitespace(*s))
      dynstr_append(&parametername, tolower((unsigned char)*s++));
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(*s++ != '=')
      return -1;
    if(!(s = skipwhite(s, 1)))
      return -1;
    if(!(s = parseword(s, parametervaluep, tspecial)))
      return -1;
    if(!(s = skipwhite(s, 1)))
      return -1;
    dynstr_terminate(&parametername);
    *parameternamep = parametername.vec;
  } else
    *parametervaluep = *parameternamep = 0;
  dynstr_terminate(&disposition);
  *dispositionp = disposition.vec;
  return 0;
}

/** @brief Convert MIME quoted-printable
 * @param s Quoted-printable data
 * @return Decoded data
 *
 * See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC 2045
 * s6.7</a>.
 */
char *mime_qp(const char *s) {
  struct dynstr d;
  int c, a, b;
  const char *t;

  dynstr_init(&d);
  while((c = *s++)) {
    switch(c) {
    case '=':
      if((a = unhexdigitq(s[0])) != -1
	 && (b = unhexdigitq(s[1])) != -1) {
	dynstr_append(&d, a * 16 + b);
	s += 2;
      } else {
	t = s;
	while(*t == ' ' || *t == '\t') ++t;
	if(iscrlf(t)) {
	  /* soft line break */
	  s = t + 2;
	} else
	  return 0;
      }
      break;
    case ' ':
    case '\t':
      t = s;
      while(*t == ' ' || *t == '\t') ++t;
      if(iscrlf(t))
	/* trailing space is always eliminated */
	s = t;
      else
	dynstr_append(&d, c);
      break;
    default:
      dynstr_append(&d, c);
      break;
    }
  }
  dynstr_terminate(&d);
  return d.vec;
}

/** @brief Parse a RFC2109 Cookie: header
 * @param s Header field value
 * @param cd Where to store result
 * @return 0 on success, non-0 on error
 *
 * See <a href="http://tools.ietf.org/html/rfc2109">RFC 2109</a>.
 */
int parse_cookie(const char *s,
		 struct cookiedata *cd) {
  char *n = 0, *v = 0;

  memset(cd, 0, sizeof *cd);
  s = skipwhite(s, 0);
  while(*s) {
    /* Skip separators */
    if(*s == ';' || *s == ',') {
      ++s;
      s = skipwhite(s, 0);
      continue;
    }
    if(!(s = parsetoken(s, &n, http_separator)))
      return -1;
    s = skipwhite(s, 0);
    if(*s++ != '=')
      return -1;
    s = skipwhite(s, 0);
    if(!(s = parseword(s, &v, http_separator)))
      return -1;
    if(n[0] == '$') {
      /* Some bit of meta-information */
      if(!strcmp(n, "$Version"))
	cd->version = v;
      else if(!strcmp(n, "$Path")) {
	if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].path == 0)
	  cd->cookies[cd->ncookies-1].path = v;
	else {
	  error(0, "redundant $Path in Cookie: header");
	  return -1;
	}
      } else if(!strcmp(n, "$Domain")) {
	if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].domain == 0)
	  cd->cookies[cd->ncookies-1].domain = v;
	else {
	  error(0, "redundant $Domain in Cookie: header");
	  return -1;
	}
      }
    } else {
      /* It's a new cookie */
      cd->cookies = xrealloc(cd->cookies,
			     (cd->ncookies + 1) * sizeof (struct cookie));
      cd->cookies[cd->ncookies].name = n;
      cd->cookies[cd->ncookies].value = v;
      cd->cookies[cd->ncookies].path = 0;
      cd->cookies[cd->ncookies].domain = 0;
      ++cd->ncookies;
    }
    s = skipwhite(s, 0);
    if(*s && (*s != ',' && *s != ';')) {
      error(0, "missing separator in Cookie: header");
      return -1;
    }
  }
  return 0;
}

/** @brief Find a named cookie
 * @param cd Parse cookie data
 * @param name Name of cookie
 * @return Cookie structure or NULL if not found
 */
const struct cookie *find_cookie(const struct cookiedata *cd,
				 const char *name) {
  int n;

  for(n = 0; n < cd->ncookies; ++n)
    if(!strcmp(cd->cookies[n].name, name))
      return &cd->cookies[n];
  return 0;
}

/** @brief RFC822 quoting
 * @param s String to quote
 * @param force If non-0, always quote
 * @return Possibly quoted string
 */
char *quote822(const char *s, int force) {
  const char *t;
  struct dynstr d[1];
  int c;

  if(!force) {
    /* See if we need to quote */
    for(t = s; (c = (unsigned char)*t); ++t) {
      if(tspecial(c) || http_separator(c) || whitespace(c))
	break;
    }
    if(*t)
      force = 1;
  }

  if(!force)
    return xstrdup(s);

  dynstr_init(d);
  dynstr_append(d, '"');
  for(t = s; (c = (unsigned char)*t); ++t) {
    if(c == '"' || c == '\\')
      dynstr_append(d, '\\');
    dynstr_append(d, c);
  }
  dynstr_append(d, '"');
  dynstr_terminate(d);
  return d->vec;
}

/** @brief Return true if @p ptr points at trailing space */
static int is_trailing_space(const char *ptr) {
  if(*ptr == ' ' || *ptr == '\t') {
    while(*ptr == ' ' || *ptr == '\t')
      ++ptr;
    return *ptr == '\n' || *ptr == 0;
  } else
    return 0;
}

/** @brief Encoding text as quoted-printable
 * @param text String to encode
 * @return Encoded string
 *
 * See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC2045
 * s6.7</a>.
 */
char *mime_to_qp(const char *text) {
  struct dynstr d[1];
  int linelength = 0;			/* length of current line */
  char buffer[10];

  dynstr_init(d);
  /* The rules are:
   * 1. Anything except newline can be replaced with =%02X
   * 2. Newline, 33-60 and 62-126 stand for themselves (i.e. not '=')
   * 3. Non-trailing space/tab stand for themselves.
   * 4. Output lines are limited to 76 chars, with =<newline> being used
   *    as a soft line break
   * 5. Newlines aren't counted towards the 76 char limit.
   */
  while(*text) {
    const int c = (unsigned char)*text;
    if(c == '\n') {
      /* Newline stands as itself */
      dynstr_append(d, '\n');
      linelength = 0;
    } else if((c >= 33 && c <= 126 && c != '=')
	      || ((c == ' ' || c == '\t')
		  && !is_trailing_space(text))) {
      /* Things that can stand for themselves  */
      dynstr_append(d, c);
      ++linelength;
    } else {
      /* Anything else that needs encoding */
      snprintf(buffer, sizeof buffer, "=%02X", c);
      dynstr_append_string(d, buffer);
      linelength += 3;
    }
    ++text;
    if(linelength > 73 && *text && *text != '\n') {
      /* Next character might overflow 76 character limit if encoded, so we
       * insert a soft break */
      dynstr_append_string(d, "=\n");
      linelength = 0;
    }
  }
  /* Ensure there is a final newline */
  if(linelength)
    dynstr_append(d, '\n');
  /* That's all */
  dynstr_terminate(d);
  return d->vec;
}

/** @brief Encode text
 * @param text Underlying UTF-8 text
 * @param charsetp Where to store charset string
 * @param encodingp Where to store encoding string
 * @return Encoded text (might be @ref text)
 */
const char *mime_encode_text(const char *text,
			     const char **charsetp,
			     const char **encodingp) {
  const char *ptr;

  /* See if there are in fact any non-ASCII characters */
  for(ptr = text; *ptr; ++ptr)
    if((unsigned char)*ptr >= 128)
      break;
  if(!*ptr) {
    /* Plain old ASCII, no encoding required */
    *charsetp = "us-ascii";
    *encodingp = "7bit";
    return text;
  }
  *charsetp = "utf-8";
  *encodingp = "quoted-printable";
  return mime_to_qp(text);
}

/*
Local Variables:
c-basic-offset:2
comment-column:40
fill-column:79
End:
*/
Commit	Line	Data
460b9539	1	/*
460b9539	2	* This file is part of DisOrder
39d4aa6b	3	* Copyright (C) 2005, 2007 Richard Kettlewell
460b9539	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	18	* USA
	19	*/
39d4aa6b RK	20	/** @file lib/mime.c
	21	* @brief Support for MIME and allied protocols
	22	*/
460b9539	23
	24	#include <config.h>
	25	#include "types.h"
	26
	27	#include <string.h>
	28	#include <ctype.h>
	29
22896b25 RK	30	#include <stdio.h>
22896b25 RK	31
460b9539	32	#include "mem.h"
	33	#include "mime.h"
	34	#include "vector.h"
	35	#include "hex.h"
39d4aa6b	36	#include "log.h"
fce810c2	37	#include "base64.h"
9bce81d1	38	#include "kvp.h"
460b9539	39
39d4aa6b	40	/** @brief Match whitespace characters */
460b9539	41	static int whitespace(int c) {
	42	switch(c) {
	43	case ' ':
	44	case '\t':
	45	case '\r':
	46	case '\n':
	47	return 1;
	48	default:
	49	return 0;
	50	}
	51	}
	52
39d4aa6b	53	/** @brief Match RFC2045 tspecial characters */
460b9539	54	static int tspecial(int c) {
	55	switch(c) {
	56	case '(':
	57	case ')':
	58	case '<':
	59	case '>':
	60	case '@':
	61	case ',':
	62	case ';':
	63	case ':':
	64	case '\\':
	65	case '"':
	66	case '/':
	67	case '[':
	68	case ']':
	69	case '?':
	70	case '=':
	71	return 1;
	72	default:
	73	return 0;
	74	}
	75	}
	76
82c01b31	77	/** @brief Match RFC2616 separator characters */
39d4aa6b RK	78	static int http_separator(int c) {
	79	switch(c) {
	80	case '(':
	81	case ')':
	82	case '<':
	83	case '>':
	84	case '@':
	85	case ',':
	86	case ';':
	87	case ':':
	88	case '\\':
	89	case '"':
	90	case '/':
	91	case '[':
	92	case ']':
	93	case '?':
	94	case '=':
	95	case '{':
	96	case '}':
	97	case ' ':
	98	case '\t':
	99	return 1;
	100	default:
	101	return 0;
	102	}
	103	}
	104
	105	/** @brief Match CRLF */
	106	static int iscrlf(const char *ptr) {
	107	return ptr[0] == '\r' && ptr[1] == '\n';
	108	}
	109
	110	/** @brief Skip whitespace
158d0961	111	* @param s Pointer into string
39d4aa6b	112	* @param rfc822_comments If true, skip RFC822 nested comments
158d0961	113	* @return Pointer into string after whitespace
39d4aa6b RK	114	*/
39d4aa6b RK	115	static const char skipwhite(const char s, int rfc822_comments) {
460b9539	116	int c, depth;
	117
	118	for(;;) {
	119	switch(c = *s) {
	120	case ' ':
	121	case '\t':
	122	case '\r':
	123	case '\n':
	124	++s;
	125	break;
	126	case '(':
39d4aa6b RK	127	if(!rfc822_comments)
39d4aa6b RK	128	return s;
460b9539	129	++s;
	130	depth = 1;
	131	while(*s && depth) {
	132	c = *s++;
	133	switch(c) {
	134	case '(': ++depth; break;
	135	case ')': --depth; break;
	136	case '\\':
121f51ac RK	137	if(!*s)
121f51ac RK	138	return 0;
460b9539	139	++s;
	140	break;
	141	}
	142	}
121f51ac RK	143	if(depth)
121f51ac RK	144	return 0;
460b9539	145	break;
	146	default:
	147	return s;
	148	}
	149	}
	150	}
	151
39d4aa6b RK	152	/** @brief Test for a word character
	153	* @param c Character to test
	154	* @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
	155	* @return 1 if @p c is a word character, else 0
	156	*/
	157	static int iswordchar(int c, int (*special)(int)) {
	158	return !(c <= ' ' \|\| c > '~' \|\| special(c));
	159	}
	160
	161	/** @brief Parse an RFC1521/RFC2616 word
	162	* @param s Pointer to start of word
	163	* @param valuep Where to store value
	164	* @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
	165	* @return Pointer just after end of word or NULL if there's no word
	166	*
	167	* A word is a token or a quoted-string.
	168	*/
	169	static const char parseword(const char s, char **valuep,
	170	int (*special)(int)) {
	171	struct dynstr value[1];
460b9539	172	int c;
460b9539	173
39d4aa6b RK	174	dynstr_init(value);
	175	if(*s == '"') {
	176	++s;
	177	while((c = *s++) != '"') {
	178	switch(c) {
	179	case '\\':
121f51ac RK	180	if(!(c = *s++))
121f51ac RK	181	return 0;
39d4aa6b RK	182	default:
	183	dynstr_append(value, c);
	184	break;
	185	}
460b9539	186	}
121f51ac RK	187	if(!c)
121f51ac RK	188	return 0;
39d4aa6b RK	189	} else {
	190	if(!iswordchar((unsigned char)*s, special))
	191	return NULL;
	192	dynstr_init(value);
	193	while(iswordchar((unsigned char)*s, special))
	194	dynstr_append(value, *s++);
460b9539	195	}
39d4aa6b RK	196	dynstr_terminate(value);
39d4aa6b RK	197	*valuep = value->vec;
460b9539	198	return s;
	199	}
	200
39d4aa6b RK	201	/** @brief Parse an RFC1521/RFC2616 token
	202	* @param s Pointer to start of token
	203	* @param valuep Where to store value
	204	* @param special tspecial() (MIME/RFC2405) or http_separator() (HTTP/RFC2616)
	205	* @return Pointer just after end of token or NULL if there's no token
	206	*/
	207	static const char parsetoken(const char s, char **valuep,
	208	int (*special)(int)) {
121f51ac RK	209	if(*s == '"')
121f51ac RK	210	return 0;
39d4aa6b RK	211	return parseword(s, valuep, special);
	212	}
	213
	214	/** @brief Parse a MIME content-type field
	215	* @param s Start of field
	216	* @param typep Where to store type
9bce81d1	217	* @param parametersp Where to store parameter list
39d4aa6b	218	* @return 0 on success, non-0 on error
78d8e29d RK	219	*
78d8e29d RK	220	* See <a href="http://tools.ietf.org/html/rfc2045#section-5">RFC 2045 s5</a>.
39d4aa6b	221	*/
460b9539	222	int mime_content_type(const char *s,
460b9539	223	char **typep,
9bce81d1	224	struct kvp **parametersp) {
39d4aa6b	225	struct dynstr type, parametername;
9bce81d1	226	struct kvp *parameters = 0;
9bce81d1	227	char *parametervalue;
460b9539	228
460b9539	229	dynstr_init(&type);
121f51ac RK	230	if(!(s = skipwhite(s, 1)))
	231	return -1;
	232	if(!*s)
	233	return -1;
460b9539	234	while(s && !tspecial(s) && !whitespace(*s))
460b9539	235	dynstr_append(&type, tolower((unsigned char)*s++));
121f51ac RK	236	if(!(s = skipwhite(s, 1)))
	237	return -1;
	238	if(*s++ != '/')
	239	return -1;
460b9539	240	dynstr_append(&type, '/');
121f51ac RK	241	if(!(s = skipwhite(s, 1)))
121f51ac RK	242	return -1;
460b9539	243	while(s && !tspecial(s) && !whitespace(*s))
460b9539	244	dynstr_append(&type, tolower((unsigned char)*s++));
121f51ac RK	245	if(!(s = skipwhite(s, 1)))
121f51ac RK	246	return -1;
460b9539	247
9bce81d1	248	while(*s == ';') {
460b9539	249	dynstr_init(&parametername);
460b9539	250	++s;
121f51ac RK	251	if(!(s = skipwhite(s, 1)))
	252	return -1;
	253	if(!*s)
	254	return -1;
460b9539	255	while(s && !tspecial(s) && !whitespace(*s))
460b9539	256	dynstr_append(&parametername, tolower((unsigned char)*s++));
121f51ac RK	257	if(!(s = skipwhite(s, 1)))
	258	return -1;
	259	if(*s++ != '=')
	260	return -1;
	261	if(!(s = skipwhite(s, 1)))
	262	return -1;
	263	if(!(s = parseword(s, &parametervalue, tspecial)))
	264	return -1;
	265	if(!(s = skipwhite(s, 1)))
	266	return -1;
460b9539	267	dynstr_terminate(&parametername);
9bce81d1	268	kvp_set(&parameters, parametername.vec, parametervalue);
9bce81d1	269	}
460b9539	270	dynstr_terminate(&type);
460b9539	271	*typep = type.vec;
9bce81d1	272	*parametersp = parameters;
460b9539	273	return 0;
	274	}
	275
39d4aa6b RK	276	/** @brief Parse a MIME message
	277	* @param s Start of message
	278	* @param callback Called for each header field
	279	* @param u Passed to callback
78d8e29d RK	280	* @return Pointer to decoded body (might be in original string), or NULL on error
	281	*
	282	* This does an RFC 822-style parse and honors Content-Transfer-Encoding as
	283	* described in <a href="http://tools.ietf.org/html/rfc2045#section-6">RFC 2045
	284	* s6</a>. @p callback is called for each header field encountered, in order,
	285	* with ASCII characters in the header name forced to lower case.
39d4aa6b	286	*/
460b9539	287	const char mime_parse(const char s,
	288	int (callback)(const char name, const char *value,
	289	void *u),
	290	void *u) {
	291	struct dynstr name, value;
	292	char cte = 0, p;
	293
	294	while(*s && !iscrlf(s)) {
	295	dynstr_init(&name);
	296	dynstr_init(&value);
	297	while(s && !tspecial(s) && !whitespace(*s))
	298	dynstr_append(&name, tolower((unsigned char)*s++));
121f51ac RK	299	if(!(s = skipwhite(s, 1)))
	300	return 0;
	301	if(*s != ':')
	302	return 0;
460b9539	303	++s;
121f51ac RK	304	while(s && !(s == '\n' && !(s[1] == ' ' \|\| s[1] == '\t'))) {
	305	const int c = *s++;
	306	/* Strip leading whitespace */
	307	if(value.nvec \|\| !(c == ' ' \|\| c == '\t' \|\| c == '\n' \|\| c == '\r'))
	308	dynstr_append(&value, c);
	309	}
	310	/* Strip trailing whitespace */
	311	while(value.nvec > 0 && (value.vec[value.nvec - 1] == ' '
	312	\|\| value.vec[value.nvec - 1] == '\t'
	313	\|\| value.vec[value.nvec - 1] == '\n'
	314	\|\| value.vec[value.nvec - 1] == '\r'))
	315	--value.nvec;
	316	if(*s)
	317	++s;
460b9539	318	dynstr_terminate(&name);
	319	dynstr_terminate(&value);
	320	if(!strcmp(name.vec, "content-transfer-encoding")) {
	321	cte = xstrdup(value.vec);
	322	for(p = cte; *p; p++)
	323	p = tolower((unsigned char)p);
	324	}
121f51ac RK	325	if(callback(name.vec, value.vec, u))
121f51ac RK	326	return 0;
460b9539	327	}
121f51ac RK	328	if(*s)
121f51ac RK	329	s += 2;
460b9539	330	if(cte) {
121f51ac RK	331	if(!strcmp(cte, "base64"))
	332	return mime_base64(s, 0);
	333	if(!strcmp(cte, "quoted-printable"))
	334	return mime_qp(s);
	335	if(!strcmp(cte, "7bit") \|\| !strcmp(cte, "8bit"))
	336	return s;
	337	error(0, "unknown content-transfer-encoding '%s'", cte);
	338	return 0;
460b9539	339	}
	340	return s;
	341	}
	342
78d8e29d	343	/** @brief Match the boundary string */
460b9539	344	static int isboundary(const char ptr, const char boundary, size_t bl) {
	345	return (ptr[0] == '-'
	346	&& ptr[1] == '-'
	347	&& !strncmp(ptr + 2, boundary, bl)
	348	&& (iscrlf(ptr + bl + 2)
	349	\|\| (ptr[bl + 2] == '-'
	350	&& ptr[bl + 3] == '-'
22896b25	351	&& (iscrlf(ptr + bl + 4) \|\| *(ptr + bl + 4) == 0))));
460b9539	352	}
460b9539	353
78d8e29d	354	/** @brief Match the final boundary string */
460b9539	355	static int isfinal(const char ptr, const char boundary, size_t bl) {
	356	return (ptr[0] == '-'
	357	&& ptr[1] == '-'
	358	&& !strncmp(ptr + 2, boundary, bl)
	359	&& ptr[bl + 2] == '-'
	360	&& ptr[bl + 3] == '-'
22896b25	361	&& (iscrlf(ptr + bl + 4) \|\| *(ptr + bl + 4) == 0));
460b9539	362	}
460b9539	363
39d4aa6b RK	364	/** @brief Parse a multipart MIME body
39d4aa6b RK	365	* @param s Start of message
78d8e29d	366	* @param callback Callback for each part
39d4aa6b RK	367	* @param boundary Boundary string
	368	* @param u Passed to callback
	369	* @return 0 on success, non-0 on error
78d8e29d RK	370	*
	371	* See <a href="http://tools.ietf.org/html/rfc2046#section-5.1">RFC 2046
	372	* s5.1</a>. @p callback is called for each part (not yet decoded in any way)
	373	* in succession; you should probably call mime_parse() for each part.
39d4aa6b	374	*/
460b9539	375	int mime_multipart(const char *s,
	376	int (callback)(const char s, void *u),
	377	const char *boundary,
	378	void *u) {
	379	size_t bl = strlen(boundary);
	380	const char start, e;
	381	int ret;
	382
22896b25 RK	383	/* We must start with a boundary string */
	384	if(!isboundary(s, boundary, bl))
	385	return -1;
	386	/* Keep going until we hit a final boundary */
460b9539	387	while(!isfinal(s, boundary, bl)) {
	388	s = strstr(s, "\r\n") + 2;
	389	start = s;
	390	while(!isboundary(s, boundary, bl)) {
22896b25 RK	391	if(!(e = strstr(s, "\r\n")))
22896b25 RK	392	return -1;
460b9539	393	s = e + 2;
	394	}
	395	if((ret = callback(xstrndup(start,
	396	s == start ? 0 : s - start - 2),
	397	u)))
	398	return ret;
	399	}
	400	return 0;
	401	}
	402
39d4aa6b RK	403	/** @brief Parse an RFC2388-style content-disposition field
39d4aa6b RK	404	* @param s Start of field
158d0961	405	* @param dispositionp Where to store disposition
39d4aa6b	406	* @param parameternamep Where to store parameter name
158d0961	407	* @param parametervaluep Wher to store parameter value
39d4aa6b	408	* @return 0 on success, non-0 on error
78d8e29d RK	409	*
	410	* See <a href="http://tools.ietf.org/html/rfc2388#section-3">RFC 2388 s3</a>
	411	* and <a href="http://tools.ietf.org/html/rfc2183">RFC 2183</a>.
39d4aa6b	412	*/
460b9539	413	int mime_rfc2388_content_disposition(const char *s,
	414	char **dispositionp,
	415	char **parameternamep,
	416	char **parametervaluep) {
39d4aa6b	417	struct dynstr disposition, parametername;
460b9539	418
460b9539	419	dynstr_init(&disposition);
121f51ac RK	420	if(!(s = skipwhite(s, 1)))
	421	return -1;
	422	if(!*s)
	423	return -1;
460b9539	424	while(s && !tspecial(s) && !whitespace(*s))
460b9539	425	dynstr_append(&disposition, tolower((unsigned char)*s++));
121f51ac RK	426	if(!(s = skipwhite(s, 1)))
121f51ac RK	427	return -1;
460b9539	428
	429	if(*s == ';') {
	430	dynstr_init(&parametername);
	431	++s;
121f51ac RK	432	if(!(s = skipwhite(s, 1)))
	433	return -1;
	434	if(!*s)
	435	return -1;
460b9539	436	while(s && !tspecial(s) && !whitespace(*s))
460b9539	437	dynstr_append(&parametername, tolower((unsigned char)*s++));
121f51ac RK	438	if(!(s = skipwhite(s, 1)))
	439	return -1;
	440	if(*s++ != '=')
	441	return -1;
	442	if(!(s = skipwhite(s, 1)))
	443	return -1;
	444	if(!(s = parseword(s, parametervaluep, tspecial)))
	445	return -1;
	446	if(!(s = skipwhite(s, 1)))
	447	return -1;
460b9539	448	dynstr_terminate(&parametername);
	449	*parameternamep = parametername.vec;
	450	} else
	451	parametervaluep = parameternamep = 0;
	452	dynstr_terminate(&disposition);
	453	*dispositionp = disposition.vec;
	454	return 0;
	455	}
	456
39d4aa6b RK	457	/** @brief Convert MIME quoted-printable
	458	* @param s Quoted-printable data
	459	* @return Decoded data
78d8e29d RK	460	*
	461	* See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC 2045
	462	* s6.7</a>.
39d4aa6b	463	*/
460b9539	464	char mime_qp(const char s) {
	465	struct dynstr d;
	466	int c, a, b;
	467	const char *t;
	468
	469	dynstr_init(&d);
	470	while((c = *s++)) {
	471	switch(c) {
	472	case '=':
	473	if((a = unhexdigitq(s[0])) != -1
	474	&& (b = unhexdigitq(s[1])) != -1) {
	475	dynstr_append(&d, a * 16 + b);
	476	s += 2;
	477	} else {
	478	t = s;
	479	while(t == ' ' \|\| t == '\t') ++t;
	480	if(iscrlf(t)) {
	481	/* soft line break */
	482	s = t + 2;
	483	} else
	484	return 0;
	485	}
	486	break;
	487	case ' ':
	488	case '\t':
	489	t = s;
	490	while(t == ' ' \|\| t == '\t') ++t;
	491	if(iscrlf(t))
	492	/* trailing space is always eliminated */
	493	s = t;
	494	else
	495	dynstr_append(&d, c);
	496	break;
	497	default:
	498	dynstr_append(&d, c);
	499	break;
	500	}
	501	}
	502	dynstr_terminate(&d);
	503	return d.vec;
	504	}
	505
39d4aa6b RK	506	/** @brief Parse a RFC2109 Cookie: header
	507	* @param s Header field value
	508	* @param cd Where to store result
	509	* @return 0 on success, non-0 on error
36bde473	510	*
36bde473	511	* See <a href="http://tools.ietf.org/html/rfc2109">RFC 2109</a>.
39d4aa6b RK	512	*/
	513	int parse_cookie(const char *s,
	514	struct cookiedata *cd) {
	515	char n = 0, v = 0;
	516
	517	memset(cd, 0, sizeof *cd);
	518	s = skipwhite(s, 0);
	519	while(*s) {
	520	/* Skip separators */
	521	if(s == ';' \|\| s == ',') {
	522	++s;
	523	s = skipwhite(s, 0);
	524	continue;
	525	}
121f51ac RK	526	if(!(s = parsetoken(s, &n, http_separator)))
121f51ac RK	527	return -1;
39d4aa6b	528	s = skipwhite(s, 0);
121f51ac RK	529	if(*s++ != '=')
121f51ac RK	530	return -1;
39d4aa6b	531	s = skipwhite(s, 0);
121f51ac RK	532	if(!(s = parseword(s, &v, http_separator)))
121f51ac RK	533	return -1;
39d4aa6b RK	534	if(n[0] == '$') {
	535	/* Some bit of meta-information */
	536	if(!strcmp(n, "$Version"))
	537	cd->version = v;
	538	else if(!strcmp(n, "$Path")) {
	539	if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].path == 0)
	540	cd->cookies[cd->ncookies-1].path = v;
	541	else {
	542	error(0, "redundant $Path in Cookie: header");
	543	return -1;
	544	}
	545	} else if(!strcmp(n, "$Domain")) {
	546	if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].domain == 0)
	547	cd->cookies[cd->ncookies-1].domain = v;
	548	else {
	549	error(0, "redundant $Domain in Cookie: header");
	550	return -1;
	551	}
	552	}
	553	} else {
	554	/* It's a new cookie */
	555	cd->cookies = xrealloc(cd->cookies,
	556	(cd->ncookies + 1) * sizeof (struct cookie));
	557	cd->cookies[cd->ncookies].name = n;
	558	cd->cookies[cd->ncookies].value = v;
	559	cd->cookies[cd->ncookies].path = 0;
	560	cd->cookies[cd->ncookies].domain = 0;
	561	++cd->ncookies;
	562	}
	563	s = skipwhite(s, 0);
	564	if(s && (s != ',' && *s != ';')) {
	565	error(0, "missing separator in Cookie: header");
	566	return -1;
	567	}
	568	}
	569	return 0;
	570	}
	571
	572	/** @brief Find a named cookie
	573	* @param cd Parse cookie data
	574	* @param name Name of cookie
	575	* @return Cookie structure or NULL if not found
	576	*/
	577	const struct cookie find_cookie(const struct cookiedata cd,
	578	const char *name) {
	579	int n;
	580
	581	for(n = 0; n < cd->ncookies; ++n)
	582	if(!strcmp(cd->cookies[n].name, name))
	583	return &cd->cookies[n];
	584	return 0;
	585	}
	586
36bde473	587	/** @brief RFC822 quoting
	588	* @param s String to quote
	589	* @param force If non-0, always quote
	590	* @return Possibly quoted string
	591	*/
	592	char quote822(const char s, int force) {
	593	const char *t;
	594	struct dynstr d[1];
	595	int c;
	596
	597	if(!force) {
	598	/* See if we need to quote */
	599	for(t = s; (c = (unsigned char)*t); ++t) {
	600	if(tspecial(c) \|\| http_separator(c) \|\| whitespace(c))
	601	break;
	602	}
	603	if(*t)
	604	force = 1;
	605	}
	606
	607	if(!force)
	608	return xstrdup(s);
	609
	610	dynstr_init(d);
	611	dynstr_append(d, '"');
	612	for(t = s; (c = (unsigned char)*t); ++t) {
	613	if(c == '"' \|\| c == '\\')
	614	dynstr_append(d, '\\');
	615	dynstr_append(d, c);
	616	}
	617	dynstr_append(d, '"');
	618	dynstr_terminate(d);
	619	return d->vec;
	620	}
	621
bb6ae3fb	622	/** @brief Return true if @p ptr points at trailing space */
	623	static int is_trailing_space(const char *ptr) {
	624	if(ptr == ' ' \|\| ptr == '\t') {
	625	while(ptr == ' ' \|\| ptr == '\t')
	626	++ptr;
	627	return ptr == '\n' \|\| ptr == 0;
	628	} else
	629	return 0;
	630	}
	631
	632	/** @brief Encoding text as quoted-printable
	633	* @param text String to encode
	634	* @return Encoded string
	635	*
	636	* See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC2045
	637	* s6.7</a>.
	638	*/
	639	char mime_to_qp(const char text) {
	640	struct dynstr d[1];
	641	int linelength = 0; /* length of current line */
	642	char buffer[10];
	643
	644	dynstr_init(d);
	645	/* The rules are:
	646	* 1. Anything except newline can be replaced with =%02X
	647	* 2. Newline, 33-60 and 62-126 stand for themselves (i.e. not '=')
	648	* 3. Non-trailing space/tab stand for themselves.
	649	* 4. Output lines are limited to 76 chars, with =<newline> being used
	650	* as a soft line break
	651	* 5. Newlines aren't counted towards the 76 char limit.
	652	*/
	653	while(*text) {
	654	const int c = (unsigned char)*text;
	655	if(c == '\n') {
	656	/* Newline stands as itself */
	657	dynstr_append(d, '\n');
	658	linelength = 0;
	659	} else if((c >= 33 && c <= 126 && c != '=')
	660	\|\| ((c == ' ' \|\| c == '\t')
	661	&& !is_trailing_space(text))) {
	662	/* Things that can stand for themselves */
	663	dynstr_append(d, c);
	664	++linelength;
	665	} else {
	666	/* Anything else that needs encoding */
	667	snprintf(buffer, sizeof buffer, "=%02X", c);
	668	dynstr_append_string(d, buffer);
	669	linelength += 3;
	670	}
	671	++text;
	672	if(linelength > 73 && text && text != '\n') {
	673	/* Next character might overflow 76 character limit if encoded, so we
	674	* insert a soft break */
	675	dynstr_append_string(d, "=\n");
	676	linelength = 0;
	677	}
	678	}
	679	/* Ensure there is a final newline */
	680	if(linelength)
	681	dynstr_append(d, '\n');
	682	/* That's all */
	683	dynstr_terminate(d);
	684	return d->vec;
	685	}
686
687	/** @brief Encode text
688	* @param text Underlying UTF-8 text
689	* @param charsetp Where to store charset string
690	* @param encodingp Where to store encoding string
691	* @return Encoded text (might be @ref text)
692	*/
693	const char mime_encode_text(const char text,
694	const char **charsetp,
695	const char **encodingp) {
696	const char *ptr;
697
698	/* See if there are in fact any non-ASCII characters */
699	for(ptr = text; *ptr; ++ptr)
700	if((unsigned char)*ptr >= 128)
701	break;
702	if(!*ptr) {
703	/* Plain old ASCII, no encoding required */
704	*charsetp = "us-ascii";
705	*encodingp = "7bit";
706	return text;
707	}
708	*charsetp = "utf-8";
709	*encodingp = "quoted-printable";
710	return mime_to_qp(text);
711	}
712
460b9539	713	/*
	714	Local Variables:
	715	c-basic-offset:2
	716	comment-column:40
	717	fill-column:79
	718	End:
	719	*/