Mix/Src/mime.c

/* Mixmaster version 2.9  --  (C) 1999 - 2002 Anonymizer Inc. and others.

   Mixmaster may be redistributed and modified under certain conditions.
   This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
   ANY KIND, either express or implied. See the file COPYRIGHT for
   details.

   MIME functions
   $Id: mime.c,v 1.3.2.2 2002/12/16 22:38:07 rabbi Exp $ */


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

#define hex(i) (isdigit(i) ? (i) - '0' : tolower(i) - 'a' + 10)

#define hexdigit(i) ((byte)(i < 10 ? i + '0' : i - 10 + 'A'))

static void encode_word(BUFFER *in)
{
  BUFFER *out;
  int i;

  out = buf_new();
  for (i = 0; i < in->length; i++)
    if (in->data[i] < 32 || in->data[i] >= 127 || in->data[i] == '='
        || in->data[i] == '?' || in->data[i] == '_') {
      buf_appendc(out, '=');
      buf_appendc(out, hexdigit(in->data[i] / 16));
      buf_appendc(out, hexdigit(in->data[i] % 16));
    } else if (in->data[i] == ' ')
      buf_appendc(out, '_');
    else
      buf_appendc(out, in->data[i]);
  buf_move(in, out);
  buf_free(out);
}

void body_encode(BUFFER *in, int transport, BUFFER *hdr)
{
  BUFFER *out;
  int c, l=0, encoding = 0;
  out = buf_new();

  buf_clear(hdr);

  l = in->ptr;
  while ((c = buf_getc(in)) != -1 && encoding != 2) {
    if (c >= 160)
      encoding = 1;
    else if (c == ' ') {
      if (buf_getc(in) == '\n')
        encoding = 1;
      buf_ungetc(in);
    } else if ((c < 32 && c != ' ' && c != '\n' && c != '\t') ||
               (c >= 127 && c < 160)) {
      encoding = 2;
    }
  }
  in->ptr = l;

  if (encoding == 2) {
    buf_sets(hdr, "Content-Transfer-Encoding: base64\n");
    encode(in, 76);
  } else {

#if 0
    if (encoding == 0)
      buf_sets(hdr, "Content-Transfer-Encoding: 7bit\n");
#endif
    if (encoding != 0 && transport == MIME_8BIT)
      buf_sets(hdr, "Content-Transfer-Encoding: 8bit\n");
    if (encoding == 0 || transport == MIME_8BIT) {
      buf_rest(out, in); /* transparent */
      buf_move(in, out);
    } else {
      buf_sets(hdr, "Content-Transfer-Encoding: quoted-printable\n");
      l = 0;
      while ((c = buf_getc(in)) != -1) {
        if (c == '\n') {
          buf_nl(out);
          l = 0;
        }
        else if (c < 32 || c >= 127 || c == '=') {
          if (l > 73) {
            buf_appends(out, "=\n");
            l = 0;
          }
          buf_appendc(out, '=');
          buf_appendc(out, hexdigit(c / 16));
          buf_appendc(out, hexdigit(c % 16));
          l += 3;
        } else if (c == ' ') {
          if (buf_getc(in) == '\n') {
            buf_appendc(out, '=');
            buf_appendc(out, hexdigit(c / 16));
            buf_appendc(out, hexdigit(c % 16));
            buf_nl(out);
            l = 0;
          } else {
            buf_appendc(out, c);
            buf_ungetc(in);
            l++;
          }
        } else {
          buf_appendc(out, c);
          l++;
        }
      }
      buf_move(in, out);
    }
  }
  buf_free(out);
}

int mail_encode(BUFFER *in, int encoding)
{
  BUFFER *out, *line, *tmp;

  out = buf_new();
  line = buf_new();
  tmp = buf_new();

  while (buf_getline(in, line) == 0) {
    hdr_encode(line, 255);
    buf_cat(out, line);
    buf_nl(out);
  }
  if (in->ptr < in->length) {
    /* no newline if only encoding header lines */
    if (encoding == 0) {
      buf_nl(out);
      buf_rest(out, in);
    }
    else {
      body_encode(in, encoding, line);
      buf_cat(out, line);
      buf_nl(out);
      buf_cat(out, in);
    }
  }
  buf_move(in, out);
  buf_free(line);
  buf_free(tmp);
  buf_free(out);
  return (0);
}

int hdr_encode(BUFFER *in, int n)
{
  int i;
  int encodeword = 0, encode = 0;
  BUFFER *out, *word, *space;

  out = buf_new();
  word = buf_new();
  space = buf_new();
  for (i = 0; i <= in->length; i++) {
    if (isspace(in->data[i]) || in->data[i] == '\0') {
      if (word->length) {
        if (encodeword) {
          if (encode == 0) {
            buf_cat(out, space);
            buf_clear(space);
            buf_appends(out, "=?");
            buf_appends(out, MIMECHARSET);
            buf_appends(out, "?Q?");
            encode = 1;
          } else {
            buf_cat(space, word);
            buf_move(word, space);
          }
          encode_word(word);
        }
        if (encode && !encodeword) {
          encode = 0;
          buf_appends(out, "?=");
        }
        buf_cat(out, space);
        buf_cat(out, word);
        encodeword = 0;
        buf_clear(space);
        buf_clear(word);
      }
      buf_appendc(space, in->data[i]);
    } else {
      if (in->data[i] < 32 || in->data[i] >= 127)
        encodeword = 1;
      buf_appendc(word, in->data[i]);
    }
  }
  if (encode)
    buf_appends(out, "?=");

  buf_move(in, out);
  while (n > 0 && in->length - in->ptr > n) {
    for (i = 1; i < in->length - in->ptr; i++)
      if (isspace(in->data[in->length - i]))
        break;
    buf_get(in, out, in->length - i);
    buf_appends(out, "\n\t");
  }
  buf_rest(out, in);
  buf_move(in, out);
  buf_free(out);
  buf_free(space);
  buf_free(word);
  return (0);
}

void addprintable(BUFFER *out, int c)
{
  if (c == '\n')
    buf_appendc(out, (char) c);
  else if (c == '\t')
    buf_appends(out, "        ");
  else if (c == '\014')
    buf_appends(out, "^L");
  else if (c == '\r') ;
  else if (c <= 31 || (c >= 128 && c <= 128 + 31))
    buf_appendc(out, '?');
  else
    buf_appendc(out, (char) c);
}

void addprintablebuf(BUFFER *out, BUFFER *in)
{
  int c;

  while ((c = buf_getc(in)) != -1)
    addprintable(out, c);
}

int decode_line(BUFFER *line)
{
  BUFFER *out;
  unsigned int i;
  int c, softbreak = 0;

  out = buf_new();
  for (i = 0; line->data[i] != '\0'; i++) {
    if (line->data[i] == '=') {
      if (isxdigit(line->data[i + 1]) && isxdigit(line->data[i + 2])) {
        c = hex(line->data[i + 1]) * 16 + hex(line->data[i + 2]);
        i += 2;
        addprintable(out, c);
      } else if (line->data[i + 1] == '\0') {
        softbreak = 1;
        break;
      }
    } else
      addprintable(out, line->data[i]);
  }

  buf_move(line, out);
  buf_free(out);
  return (softbreak);
}

int decode_header(BUFFER *in)
{
  int encoded = 0;
  int c;
  int err = 0;
  int last = 0;
  BUFFER *out;

  out = buf_new();
  for (in->ptr = 0; in->data[in->ptr] != '\0'; in->ptr++) {
    if (encoded == 'q' && in->data[in->ptr] == '=' &&
        isxdigit(in->data[in->ptr + 1])
        && isxdigit(in->data[in->ptr + 2])) {
      c = hex(in->data[in->ptr + 1]) * 16 + hex(in->data[in->ptr + 2]);
      in->ptr += 2;
      addprintable(out, c);
    } else if (encoded == 'q' && in->data[in->ptr] == '_')
      buf_appendc(out, ' ');
    else if (in->data[in->ptr] == '=' && in->data[in->ptr + 1] == '?' &&
             in->data[in->ptr + 2] != '\0') {
      if (last > 0 && out->length > last) {
        out->data[last] = '\0';
        out->length = last;
      }
      in->ptr++;
      while (in->data[++in->ptr] != '?')
        if (in->data[in->ptr] == 0) {
          err = -1;
          goto end;
        }
      if (in->data[in->ptr + 1] != '\0' && in->data[in->ptr + 2] == '?') {
        encoded = tolower(in->data[in->ptr + 1]);
        in->ptr += 2;
        if (encoded == 'b') {
          BUFFER *tmp;

          tmp = buf_new();
          decode(in, tmp);
          addprintablebuf(out, tmp);
          last = out->length;
          buf_free(tmp);
        } else if (encoded != 'q')
          err = 1;
      } else {
        err = -1;
        goto end;
      }
    } else if (encoded && in->data[in->ptr] == '?' &&
               in->data[in->ptr + 1] == '=') {
      in->ptr++;
      last = out->length;
      encoded = 0;
    } else {
      addprintable(out, in->data[in->ptr]);
      if (!encoded || !isspace(in->data[in->ptr]))
        last = out->length;
    }
  }
end:
  if (err == -1)
    buf_set(out, in);

  buf_move(in, out);
  buf_free(out);
  return (err);
}

#define delimclose 2

int boundary(BUFFER *line, BUFFER *boundary)
{
  int c;

  if (boundary->length == 0 || !bufleft(line, "--") ||
      !strleft(line->data + 2, boundary->data))
    return (0);
  line->ptr = boundary->length + 2;
  for (;;) {
    c = buf_getc(line);
    if (c == -1)
      return (1);
    if (c == '-' && buf_getc(line) == '-')
      return (delimclose);
    if (!isspace(c))
      return (0);
  }
}

#define pgpenc 1
#define pgpsig 2

/*
 * decodes non-multipart quoted printable message
 */
int qp_decode_message(BUFFER *msg)
{
  BUFFER *out, *line, *field, *content;
  out     = buf_new();
  line    = buf_new();
  field   = buf_new();
  content = buf_new();

  buf_rewind(msg);

  /* copy over headers without decoding */
  while (buf_getheader(msg, field, content) == 0) {
    if (bufieq(field, "content-transfer-encoding")
        && bufieq(content, "quoted-printable")) {
      continue;                 /* no longer quoted-printable */
    } else {
      buf_appendheader(out, field, content);
    }
  }

  buf_nl(out);

  /* copy over body, quoted-printable decoding as we go */
  while (buf_getline(msg, line) != -1) {
    int softbreak;
    softbreak = decode_line(line);
    buf_cat(out, line);
    if (!softbreak)
      buf_nl(out);
  }
  buf_move(msg, out);
  buf_free(out);
  buf_free(line);
  buf_free(field);
  buf_free(content);
  return 0;
}


int entity_decode(BUFFER *msg, int message, int mptype, BUFFER *data)
{
  BUFFER *out, *line, *field, *content, *type, *subtype, *disposition,
      *mboundary, *part, *sigdata;
  int ret = 0, ptype = 0, partno = 0;
  int p, encoded = 0;

  out = buf_new();
  line = buf_new();
  field = buf_new();
  content = buf_new();
  type = buf_new();
  subtype = buf_new();
  disposition = buf_new();
  mboundary = buf_new();
  part = buf_new();
  sigdata = buf_new();

  if (message && bufileft(msg, "From ")) {
    buf_getline(msg, out); /* envelope from */
    buf_nl(out);
  }

  while (buf_getheader(msg, field, content) == 0) {
    if (bufieq(field, "content-transfer-encoding") &&
        bufieq(content, "quoted-printable"))
      encoded = 'q';
    if (bufieq(field, "content-type")) {
      get_type(content, type, subtype);
      if (bufieq(type, "multipart"))
        get_parameter(content, "boundary", mboundary);
      if (bufieq(type, "multipart") && bufieq(subtype, "encrypted")) {
        get_parameter(content, "protocol", line);
        if (bufieq(line, "application/pgp-encrypted"))
          ptype = pgpenc;
      }
      if (bufieq(type, "multipart") && bufieq(subtype, "signed")) {
        get_parameter(content, "protocol", line);
        if (bufieq(line, "application/pgp-signature"))
          ptype = pgpsig;
      }
    }
    if (bufieq(field, "content-disposition"))
      buf_set(disposition, content);
    if (message) {
      decode_header(content);
      buf_appendheader(out, field, content);
    }
  }

  if (message)
    buf_nl(out);

  if (bufifind(disposition, "attachment")) {
    buf_appendf(out, "[-- %b attachment", type);
    get_parameter(disposition, "filename", line);
    if (line->length)
       buf_appendf(out, " (%b)", line);
    buf_appends(out, " --]\n");
  }

  if (mboundary->length) {
  /* multipart */
    while (buf_getline(msg, line) > -1 && !boundary(line, mboundary))
      ; /* ignore preamble */
    while (buf_getline(msg, line) != -1) {
      p = boundary(line, mboundary);
      if (p) {
        if (part->data[part->length - 1] == '\n')
          part->data[--(part->length)] = '\0';
        partno++;
        if (ptype == pgpsig && partno == 1)
          buf_set(sigdata, part);
        ret += entity_decode(part, 0, ptype, sigdata);
        buf_cat(out, part);
        buf_clear(part);
        if (p == delimclose)
          break;
        if (bufieq(subtype, "alternative") && ret > 0)
          break;
        if (bufieq(subtype, "mixed"))
          buf_appends(out,
                      "[-------------------------------------------------------------------------]\n");
      } else {
        buf_cat(part, line);
        buf_nl(part);
      }
    }
  } else if (mptype == pgpenc && bufieq(type, "application") &&
             bufieq(subtype, "pgp-encrypted")) {
    /* application/pgp-encrypted part of multipart/encrypted */
    ; /* skip */
  } else if (mptype == pgpenc && bufieq(type, "application") &&
             bufieq(subtype, "octet-stream")) {
    /* application/octet-stream part of multipart/encrypted */
    int ok = 0;
    buf_getline(msg, line);
    if (bufleft(line, info_beginpgp)) {
      if (buffind(line, "(SIGNED)")) {
          buf_getline(msg, line);
          buf_appends(out, "[-- OpenPGP message with signature --]\n");
          if (bufleft(line, info_pgpsig))
            buf_appendf(out, "[%s]\n",
                        line->data + sizeof(info_pgpsig) - 1);
          else
            buf_appends(out, "[Signature invalid]\n");
      } else
        buf_appends(out, "[-- OpenPGP message --]\n");
      while (buf_getline(msg, line) != -1) {
        if (bufleft(line, info_endpgp)) {
          ret += entity_decode(part, 0, 0, NULL);
          buf_cat(out, part);
          buf_appends(out, "[-- End OpenPGP message --]\n");
          ok = 1, ret++;
          break;
        }
        buf_cat(part, line);
        buf_nl(part);
      }
    }
    if (!ok) {
      buf_appends(out, "[-- Bad OpenPGP message --]\n");
      buf_cat(out, msg);
    }
  } else if (mptype == pgpsig && bufeq(type, "application") &&
             bufieq(subtype, "pgp-signature")) {
    buf_rest(part, msg);
    if (pgp_decrypt(part, NULL, data, PGPPUBRING, NULL) == PGP_SIGOK)
      buf_appendf(out, "[-- OpenPGP signature from:\n    %b --]\n", data);
    else
      buf_appends(out, "[-- Invalid OpenPGP signature --]\n");
  } else if (type->length == 0 || bufieq(type, "text")) {
    while (buf_getline(msg, line) != -1) {
      int softbreak;
      softbreak = encoded ? decode_line(line) : 0;
      buf_cat(out, line);
      if (!softbreak)
        buf_nl(out);
    }
    ret++;
  } else {
    buf_appendf(out, "[-- %b/%b message part --]\n", type, subtype);
    buf_cat(out, msg);
  }

  buf_move(msg, out);
  buf_free(line);
  buf_free(out);
  buf_free(field);
  buf_free(content);
  buf_free(type);
  buf_free(subtype);
  buf_free(disposition);
  buf_free(mboundary);
  buf_free(part);
  buf_free(sigdata);
  return (0);
}

void mimedecode(BUFFER *msg)
{
  entity_decode(msg, 1, 0, NULL);
}

int attachfile(BUFFER *message, BUFFER *filename)
{
  BUFFER *type, *attachment;
  FILE *f;
  int ret = -1;

  type = buf_new();
  attachment = buf_new();

  if ((bufiright(filename, ".txt") || !bufifind(filename, ".")) &&(strlen(DEFLTENTITY) != 0))
    buf_sets(type, DEFLTENTITY);
  else if (bufiright(filename, ".htm") || bufiright(filename, ".html"))
    buf_sets(type, "text/html");
  else if (bufiright(filename, ".jpeg"))
    buf_sets(type, "image/jpeg");
  else if (bufiright(filename, ".gif"))
    buf_sets(type, "image/gif");
  else if (bufiright(filename, ".pcm"))
    buf_sets(type, "audio/basic");
  else if (bufiright(filename, ".mpg") || bufiright(filename, ".mpeg"))
    buf_sets(type, "video/mpeg");
  else if (bufiright(filename, ".ps"))
    buf_sets(type, "application/postscript");
  else
    buf_sets(type, "application/octet-stream");

  f = fopen(filename->data, "r");
  if (f) {
    buf_read(attachment, f);
    fclose(f);
    ret = mime_attach(message, attachment, type);
  }

  buf_free(attachment);
  buf_free(type);
  return(ret);
}

int mime_attach(BUFFER *message, BUFFER *attachment, BUFFER *attachtype)
{
  BUFFER *out, *part, *line, *type, *subtype, *mboundary, *field, *content;
  int mimeheader = 0, multipart = 0, versionheader = 0;

  out = buf_new();
  line = buf_new();
  part = buf_new();
  type = buf_new();
  subtype = buf_new();
  mboundary = buf_new();
  field = buf_new();
  content = buf_new();

  buf_rewind(message);
  while (buf_getheader(message, field, content) == 0) {
    if (bufieq(field, "mime-version"))
      versionheader = 1;
    if (bufieq(field, "content-type")) {
      get_type(content, type, subtype);
      if (bufieq(type, "multipart") && bufieq(subtype, "mixed")) {
        multipart = 1;
        get_parameter(content, "boundary", mboundary);
      }
    }
    if (bufileft(field, "content-"))
      mimeheader = 1;
  }

  if (mimeheader && !multipart) {
    buf_rewind(message);
    while (buf_getheader(message, field, content) == 0) {
      if (bufileft(field, "content-"))
        buf_appendheader(part, field, content);
      else
        buf_appendheader(out, field, content);
    }
  } else {
    buf_ungetc(message);
    buf_append(out, message->data, message->ptr);
    buf_getc(message);
  }

  if (!versionheader)
    buf_appends(out, "MIME-Version: 1.0\n");

  if (!multipart) {
    buf_setrnd(mboundary, 18);
    encode(mboundary, 0);
    buf_appendf(out, "Content-Type: multipart/mixed; boundary=\"%b\"\n",
                mboundary);
  }
  buf_nl(out);

  if (multipart) {
    while (buf_getline(message, line) != -1) {
      if (boundary(line, mboundary) == delimclose)
        break;
      buf_cat(out, line);
      buf_nl(out);
    }
  } else {
    buf_appendf(out, "--%b\n", mboundary);
    if (part->length) {
      buf_cat(out, part); /* body part header */
    }
    else {
      if (strlen(DEFLTENTITY))
        buf_appendf(out, "Content-Type: %s\n", DEFLTENTITY);
    }

    buf_nl(out);
    buf_cat(out, message);
    buf_nl(out);
  }

  buf_appendf(out, "--%b\n", mboundary);
  buf_appendf(out, "Content-Type: %b\n", attachtype);

  body_encode(attachment, MIME_8BIT, line);
  buf_cat(out, line);
  buf_nl(out);
  buf_cat(out, attachment);
  buf_appendf(out, "\n--%b--\n", mboundary);

  buf_move(message, out);

  buf_free(out);
  buf_free(line);
  buf_free(part);
  buf_free(type);
  buf_free(subtype);
  buf_free(mboundary);
  buf_free(field);
  buf_free(content);
  return (1);
}

static int entity_encode(BUFFER *message, BUFFER *out, BUFFER *messagehdr,
                         int encoding)
{
  BUFFER *field, *content, *mboundary, *part, *line, *line2, *tmp;

  field = buf_new();
  content = buf_new();
  mboundary = buf_new();
  part = buf_new();
  line = buf_new();
  line2 = buf_new();
  tmp = buf_new();

  buf_rewind(message);
  buf_clear(out);
  buf_clear(messagehdr);

  while (buf_getheader(message, field, content) == 0) {
    if (bufileft(field, "content-"))
      buf_appendheader(out, field, content);
    else if (messagehdr)
      buf_appendheader(messagehdr, field, content);

    if (bufieq(field, "content-type")) {
      get_type(content, line, tmp);
      if (bufieq(line, "multipart"))
        get_parameter(content, "boundary", mboundary);
    }
  }

  buf_nl(out);
  if (mboundary->length) {
      while (buf_getline(message, line) != -1) {
        buf_cat(out, line);
        buf_nl(out);
        if (boundary(line, mboundary))
          break;
      }
      while (buf_getline(message, line) != -1) {
          if (boundary(line, mboundary)) {
            entity_encode(part, tmp, line2, encoding);
            buf_cat(out, line2);
            buf_cat(out, tmp);
            buf_cat(out, line);
            buf_nl(out);
            buf_clear(part);
            if (boundary(line, mboundary) == delimclose)
              break;
          } else {
            buf_cat(part, line);
            buf_nl(part);
          }
      }
  } else
    buf_rest(out, message);
  buf_rewind(out);
  mail_encode(out, encoding);

  buf_free(field);
  buf_free(content);
  buf_free(mboundary);
  buf_free(part);
  buf_free(line);
  buf_free(line2);
  buf_free(tmp);
  return (1);
}

int pgpmime_sign(BUFFER *message, BUFFER *uid, BUFFER *pass, char *secring)
{
  BUFFER *out, *body, *mboundary, *algo;
  int err;

  out = buf_new();
  body = buf_new();
  mboundary = buf_new();
  algo = buf_new();

  pgp_signhashalgo(algo, uid, secring, pass);

  entity_encode(message, body, out, MIME_7BIT);

  buf_setrnd(mboundary, 18);
  encode(mboundary, 0);
  buf_appendf(out, "Content-Type: multipart/signed; boundary=\"%b\";\n",
              mboundary);
  buf_appendf(out,
              "\tmicalg=pgp-%b; protocol=\"application/pgp-signature\"\n",
              algo);
  buf_nl(out);

  buf_appendf(out, "--%b\n", mboundary);
  buf_cat(out, body);
  buf_nl(out);
  buf_appendf(out, "--%b\n", mboundary);

  err = pgp_encrypt(PGP_SIGN | PGP_TEXT | PGP_DETACHEDSIG, body, NULL,
                    uid, pass, NULL, secring);

  buf_appends(out, "Content-Type: application/pgp-signature\n");
  buf_nl(out);
  buf_cat(out, body);
  buf_nl(out);
  buf_appendf(out, "--%b--\n", mboundary);
  if (err == 0)
    buf_move(message, out);

  buf_free(out);
  buf_free(body);
  buf_free(mboundary);
  buf_free(algo);
  return (err);
}
1	/* Mixmaster version 2.9 -- (C) 1999 - 2002 Anonymizer Inc. and others.
2
3	Mixmaster may be redistributed and modified under certain conditions.
4	This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
5	ANY KIND, either express or implied. See the file COPYRIGHT for
6	details.
7
8	MIME functions
9	$Id: mime.c,v 1.3.2.2 2002/12/16 22:38:07 rabbi Exp $ */
10
11
12	#include "mix3.h"
13	#include <ctype.h>
14	#include <string.h>
15
16	#define hex(i) (isdigit(i) ? (i) - '0' : tolower(i) - 'a' + 10)
17
18	#define hexdigit(i) ((byte)(i < 10 ? i + '0' : i - 10 + 'A'))
19
20	static void encode_word(BUFFER *in)
21	{
22	BUFFER *out;
23	int i;
24
25	out = buf_new();
26	for (i = 0; i < in->length; i++)
27	if (in->data[i] < 32 \|\| in->data[i] >= 127 \|\| in->data[i] == '='
28	\|\| in->data[i] == '?' \|\| in->data[i] == '_') {
29	buf_appendc(out, '=');
30	buf_appendc(out, hexdigit(in->data[i] / 16));
31	buf_appendc(out, hexdigit(in->data[i] % 16));
32	} else if (in->data[i] == ' ')
33	buf_appendc(out, '_');
34	else
35	buf_appendc(out, in->data[i]);
36	buf_move(in, out);
37	buf_free(out);
38	}
39
40	void body_encode(BUFFER in, int transport, BUFFER hdr)
41	{
42	BUFFER *out;
43	int c, l=0, encoding = 0;
44	out = buf_new();
45
46	buf_clear(hdr);
47
48	l = in->ptr;
49	while ((c = buf_getc(in)) != -1 && encoding != 2) {
50	if (c >= 160)
51	encoding = 1;
52	else if (c == ' ') {
53	if (buf_getc(in) == '\n')
54	encoding = 1;
55	buf_ungetc(in);
56	} else if ((c < 32 && c != ' ' && c != '\n' && c != '\t') \|\|
57	(c >= 127 && c < 160)) {
58	encoding = 2;
59	}
60	}
61	in->ptr = l;
62
63	if (encoding == 2) {
64	buf_sets(hdr, "Content-Transfer-Encoding: base64\n");
65	encode(in, 76);
66	} else {
67
68	#if 0
69	if (encoding == 0)
70	buf_sets(hdr, "Content-Transfer-Encoding: 7bit\n");
71	#endif
72	if (encoding != 0 && transport == MIME_8BIT)
73	buf_sets(hdr, "Content-Transfer-Encoding: 8bit\n");
74	if (encoding == 0 \|\| transport == MIME_8BIT) {
75	buf_rest(out, in); /* transparent */
76	buf_move(in, out);
77	} else {
78	buf_sets(hdr, "Content-Transfer-Encoding: quoted-printable\n");
79	l = 0;
80	while ((c = buf_getc(in)) != -1) {
81	if (c == '\n') {
82	buf_nl(out);
83	l = 0;
84	}
85	else if (c < 32 \|\| c >= 127 \|\| c == '=') {
86	if (l > 73) {
87	buf_appends(out, "=\n");
88	l = 0;
89	}
90	buf_appendc(out, '=');
91	buf_appendc(out, hexdigit(c / 16));
92	buf_appendc(out, hexdigit(c % 16));
93	l += 3;
94	} else if (c == ' ') {
95	if (buf_getc(in) == '\n') {
96	buf_appendc(out, '=');
97	buf_appendc(out, hexdigit(c / 16));
98	buf_appendc(out, hexdigit(c % 16));
99	buf_nl(out);
100	l = 0;
101	} else {
102	buf_appendc(out, c);
103	buf_ungetc(in);
104	l++;
105	}
106	} else {
107	buf_appendc(out, c);
108	l++;
109	}
110	}
111	buf_move(in, out);
112	}
113	}
114	buf_free(out);
115	}
116
117	int mail_encode(BUFFER *in, int encoding)
118	{
119	BUFFER out, line, *tmp;
120
121	out = buf_new();
122	line = buf_new();
123	tmp = buf_new();
124
125	while (buf_getline(in, line) == 0) {
126	hdr_encode(line, 255);
127	buf_cat(out, line);
128	buf_nl(out);
129	}
130	if (in->ptr < in->length) {
131	/* no newline if only encoding header lines */
132	if (encoding == 0) {
133	buf_nl(out);
134	buf_rest(out, in);
135	}
136	else {
137	body_encode(in, encoding, line);
138	buf_cat(out, line);
139	buf_nl(out);
140	buf_cat(out, in);
141	}
142	}
143	buf_move(in, out);
144	buf_free(line);
145	buf_free(tmp);
146	buf_free(out);
147	return (0);
148	}
149
150	int hdr_encode(BUFFER *in, int n)
151	{
152	int i;
153	int encodeword = 0, encode = 0;
154	BUFFER out, word, *space;
155
156	out = buf_new();
157	word = buf_new();
158	space = buf_new();
159	for (i = 0; i <= in->length; i++) {
160	if (isspace(in->data[i]) \|\| in->data[i] == '\0') {
161	if (word->length) {
162	if (encodeword) {
163	if (encode == 0) {
164	buf_cat(out, space);
165	buf_clear(space);
166	buf_appends(out, "=?");
167	buf_appends(out, MIMECHARSET);
168	buf_appends(out, "?Q?");
169	encode = 1;
170	} else {
171	buf_cat(space, word);
172	buf_move(word, space);
173	}
174	encode_word(word);
175	}
176	if (encode && !encodeword) {
177	encode = 0;
178	buf_appends(out, "?=");
179	}
180	buf_cat(out, space);
181	buf_cat(out, word);
182	encodeword = 0;
183	buf_clear(space);
184	buf_clear(word);
185	}
186	buf_appendc(space, in->data[i]);
187	} else {
188	if (in->data[i] < 32 \|\| in->data[i] >= 127)
189	encodeword = 1;
190	buf_appendc(word, in->data[i]);
191	}
192	}
193	if (encode)
194	buf_appends(out, "?=");
195
196	buf_move(in, out);
197	while (n > 0 && in->length - in->ptr > n) {
198	for (i = 1; i < in->length - in->ptr; i++)
199	if (isspace(in->data[in->length - i]))
200	break;
201	buf_get(in, out, in->length - i);
202	buf_appends(out, "\n\t");
203	}
204	buf_rest(out, in);
205	buf_move(in, out);
206	buf_free(out);
207	buf_free(space);
208	buf_free(word);
209	return (0);
210	}
211
212	void addprintable(BUFFER *out, int c)
213	{
214	if (c == '\n')
215	buf_appendc(out, (char) c);
216	else if (c == '\t')
217	buf_appends(out, " ");
218	else if (c == '\014')
219	buf_appends(out, "^L");
220	else if (c == '\r') ;
221	else if (c <= 31 \|\| (c >= 128 && c <= 128 + 31))
222	buf_appendc(out, '?');
223	else
224	buf_appendc(out, (char) c);
225	}
226
227	void addprintablebuf(BUFFER out, BUFFER in)
228	{
229	int c;
230
231	while ((c = buf_getc(in)) != -1)
232	addprintable(out, c);
233	}
234
235	int decode_line(BUFFER *line)
236	{
237	BUFFER *out;
238	unsigned int i;
239	int c, softbreak = 0;
240
241	out = buf_new();
242	for (i = 0; line->data[i] != '\0'; i++) {
243	if (line->data[i] == '=') {
244	if (isxdigit(line->data[i + 1]) && isxdigit(line->data[i + 2])) {
245	c = hex(line->data[i + 1]) * 16 + hex(line->data[i + 2]);
246	i += 2;
247	addprintable(out, c);
248	} else if (line->data[i + 1] == '\0') {
249	softbreak = 1;
250	break;
251	}
252	} else
253	addprintable(out, line->data[i]);
254	}
255
256	buf_move(line, out);
257	buf_free(out);
258	return (softbreak);
259	}
260
261	int decode_header(BUFFER *in)
262	{
263	int encoded = 0;
264	int c;
265	int err = 0;
266	int last = 0;
267	BUFFER *out;
268
269	out = buf_new();
270	for (in->ptr = 0; in->data[in->ptr] != '\0'; in->ptr++) {
271	if (encoded == 'q' && in->data[in->ptr] == '=' &&
272	isxdigit(in->data[in->ptr + 1])
273	&& isxdigit(in->data[in->ptr + 2])) {
274	c = hex(in->data[in->ptr + 1]) * 16 + hex(in->data[in->ptr + 2]);
275	in->ptr += 2;
276	addprintable(out, c);
277	} else if (encoded == 'q' && in->data[in->ptr] == '_')
278	buf_appendc(out, ' ');
279	else if (in->data[in->ptr] == '=' && in->data[in->ptr + 1] == '?' &&
280	in->data[in->ptr + 2] != '\0') {
281	if (last > 0 && out->length > last) {
282	out->data[last] = '\0';
283	out->length = last;
284	}
285	in->ptr++;
286	while (in->data[++in->ptr] != '?')
287	if (in->data[in->ptr] == 0) {
288	err = -1;
289	goto end;
290	}
291	if (in->data[in->ptr + 1] != '\0' && in->data[in->ptr + 2] == '?') {
292	encoded = tolower(in->data[in->ptr + 1]);
293	in->ptr += 2;
294	if (encoded == 'b') {
295	BUFFER *tmp;
296
297	tmp = buf_new();
298	decode(in, tmp);
299	addprintablebuf(out, tmp);
300	last = out->length;
301	buf_free(tmp);
302	} else if (encoded != 'q')
303	err = 1;
304	} else {
305	err = -1;
306	goto end;
307	}
308	} else if (encoded && in->data[in->ptr] == '?' &&
309	in->data[in->ptr + 1] == '=') {
310	in->ptr++;
311	last = out->length;
312	encoded = 0;
313	} else {
314	addprintable(out, in->data[in->ptr]);
315	if (!encoded \|\| !isspace(in->data[in->ptr]))
316	last = out->length;
317	}
318	}
319	end:
320	if (err == -1)
321	buf_set(out, in);
322
323	buf_move(in, out);
324	buf_free(out);
325	return (err);
326	}
327
328	#define delimclose 2
329
330	int boundary(BUFFER line, BUFFER boundary)
331	{
332	int c;
333
334	if (boundary->length == 0 \|\| !bufleft(line, "--") \|\|
335	!strleft(line->data + 2, boundary->data))
336	return (0);
337	line->ptr = boundary->length + 2;
338	for (;;) {
339	c = buf_getc(line);
340	if (c == -1)
341	return (1);
342	if (c == '-' && buf_getc(line) == '-')
343	return (delimclose);
344	if (!isspace(c))
345	return (0);
346	}
347	}
348
349	#define pgpenc 1
350	#define pgpsig 2
351
352	/*
353	* decodes non-multipart quoted printable message
354	*/
355	int qp_decode_message(BUFFER *msg)
356	{
357	BUFFER out, line, field, content;
358	out = buf_new();
359	line = buf_new();
360	field = buf_new();
361	content = buf_new();
362
363	buf_rewind(msg);
364
365	/* copy over headers without decoding */
366	while (buf_getheader(msg, field, content) == 0) {
367	if (bufieq(field, "content-transfer-encoding")
368	&& bufieq(content, "quoted-printable")) {
369	continue; /* no longer quoted-printable */
370	} else {
371	buf_appendheader(out, field, content);
372	}
373	}
374
375	buf_nl(out);
376
377	/* copy over body, quoted-printable decoding as we go */
378	while (buf_getline(msg, line) != -1) {
379	int softbreak;
380	softbreak = decode_line(line);
381	buf_cat(out, line);
382	if (!softbreak)
383	buf_nl(out);
384	}
385	buf_move(msg, out);
386	buf_free(out);
387	buf_free(line);
388	buf_free(field);
389	buf_free(content);
390	return 0;
391	}
392
393
394	int entity_decode(BUFFER msg, int message, int mptype, BUFFER data)
395	{
396	BUFFER out, line, field, content, type, subtype, *disposition,
397	mboundary, part, *sigdata;
398	int ret = 0, ptype = 0, partno = 0;
399	int p, encoded = 0;
400
401	out = buf_new();
402	line = buf_new();
403	field = buf_new();
404	content = buf_new();
405	type = buf_new();
406	subtype = buf_new();
407	disposition = buf_new();
408	mboundary = buf_new();
409	part = buf_new();
410	sigdata = buf_new();
411
412	if (message && bufileft(msg, "From ")) {
413	buf_getline(msg, out); /* envelope from */
414	buf_nl(out);
415	}
416
417	while (buf_getheader(msg, field, content) == 0) {
418	if (bufieq(field, "content-transfer-encoding") &&
419	bufieq(content, "quoted-printable"))
420	encoded = 'q';
421	if (bufieq(field, "content-type")) {
422	get_type(content, type, subtype);
423	if (bufieq(type, "multipart"))
424	get_parameter(content, "boundary", mboundary);
425	if (bufieq(type, "multipart") && bufieq(subtype, "encrypted")) {
426	get_parameter(content, "protocol", line);
427	if (bufieq(line, "application/pgp-encrypted"))
428	ptype = pgpenc;
429	}
430	if (bufieq(type, "multipart") && bufieq(subtype, "signed")) {
431	get_parameter(content, "protocol", line);
432	if (bufieq(line, "application/pgp-signature"))
433	ptype = pgpsig;
434	}
435	}
436	if (bufieq(field, "content-disposition"))
437	buf_set(disposition, content);
438	if (message) {
439	decode_header(content);
440	buf_appendheader(out, field, content);
441	}
442	}
443
444	if (message)
445	buf_nl(out);
446
447	if (bufifind(disposition, "attachment")) {
448	buf_appendf(out, "[-- %b attachment", type);
449	get_parameter(disposition, "filename", line);
450	if (line->length)
451	buf_appendf(out, " (%b)", line);
452	buf_appends(out, " --]\n");
453	}
454
455	if (mboundary->length) {
456	/* multipart */
457	while (buf_getline(msg, line) > -1 && !boundary(line, mboundary))
458	; /* ignore preamble */
459	while (buf_getline(msg, line) != -1) {
460	p = boundary(line, mboundary);
461	if (p) {
462	if (part->data[part->length - 1] == '\n')
463	part->data[--(part->length)] = '\0';
464	partno++;
465	if (ptype == pgpsig && partno == 1)
466	buf_set(sigdata, part);
467	ret += entity_decode(part, 0, ptype, sigdata);
468	buf_cat(out, part);
469	buf_clear(part);
470	if (p == delimclose)
471	break;
472	if (bufieq(subtype, "alternative") && ret > 0)
473	break;
474	if (bufieq(subtype, "mixed"))
475	buf_appends(out,
476	"[-------------------------------------------------------------------------]\n");
477	} else {
478	buf_cat(part, line);
479	buf_nl(part);
480	}
481	}
482	} else if (mptype == pgpenc && bufieq(type, "application") &&
483	bufieq(subtype, "pgp-encrypted")) {
484	/* application/pgp-encrypted part of multipart/encrypted */
485	; /* skip */
486	} else if (mptype == pgpenc && bufieq(type, "application") &&
487	bufieq(subtype, "octet-stream")) {
488	/* application/octet-stream part of multipart/encrypted */
489	int ok = 0;
490	buf_getline(msg, line);
491	if (bufleft(line, info_beginpgp)) {
492	if (buffind(line, "(SIGNED)")) {
493	buf_getline(msg, line);
494	buf_appends(out, "[-- OpenPGP message with signature --]\n");
495	if (bufleft(line, info_pgpsig))
496	buf_appendf(out, "[%s]\n",
497	line->data + sizeof(info_pgpsig) - 1);
498	else
499	buf_appends(out, "[Signature invalid]\n");
500	} else
501	buf_appends(out, "[-- OpenPGP message --]\n");
502	while (buf_getline(msg, line) != -1) {
503	if (bufleft(line, info_endpgp)) {
504	ret += entity_decode(part, 0, 0, NULL);
505	buf_cat(out, part);
506	buf_appends(out, "[-- End OpenPGP message --]\n");
507	ok = 1, ret++;
508	break;
509	}
510	buf_cat(part, line);
511	buf_nl(part);
512	}
513	}
514	if (!ok) {
515	buf_appends(out, "[-- Bad OpenPGP message --]\n");
516	buf_cat(out, msg);
517	}
518	} else if (mptype == pgpsig && bufeq(type, "application") &&
519	bufieq(subtype, "pgp-signature")) {
520	buf_rest(part, msg);
521	if (pgp_decrypt(part, NULL, data, PGPPUBRING, NULL) == PGP_SIGOK)
522	buf_appendf(out, "[-- OpenPGP signature from:\n %b --]\n", data);
523	else
524	buf_appends(out, "[-- Invalid OpenPGP signature --]\n");
525	} else if (type->length == 0 \|\| bufieq(type, "text")) {
526	while (buf_getline(msg, line) != -1) {
527	int softbreak;
528	softbreak = encoded ? decode_line(line) : 0;
529	buf_cat(out, line);
530	if (!softbreak)
531	buf_nl(out);
532	}
533	ret++;
534	} else {
535	buf_appendf(out, "[-- %b/%b message part --]\n", type, subtype);
536	buf_cat(out, msg);
537	}
538
539	buf_move(msg, out);
540	buf_free(line);
541	buf_free(out);
542	buf_free(field);
543	buf_free(content);
544	buf_free(type);
545	buf_free(subtype);
546	buf_free(disposition);
547	buf_free(mboundary);
548	buf_free(part);
549	buf_free(sigdata);
550	return (0);
551	}
552
553	void mimedecode(BUFFER *msg)
554	{
555	entity_decode(msg, 1, 0, NULL);
556	}
557
558	int attachfile(BUFFER message, BUFFER filename)
559	{
560	BUFFER type, attachment;
561	FILE *f;
562	int ret = -1;
563
564	type = buf_new();
565	attachment = buf_new();
566
567	if ((bufiright(filename, ".txt") \|\| !bufifind(filename, ".")) &&(strlen(DEFLTENTITY) != 0))
568	buf_sets(type, DEFLTENTITY);
569	else if (bufiright(filename, ".htm") \|\| bufiright(filename, ".html"))
570	buf_sets(type, "text/html");
571	else if (bufiright(filename, ".jpeg"))
572	buf_sets(type, "image/jpeg");
573	else if (bufiright(filename, ".gif"))
574	buf_sets(type, "image/gif");
575	else if (bufiright(filename, ".pcm"))
576	buf_sets(type, "audio/basic");
577	else if (bufiright(filename, ".mpg") \|\| bufiright(filename, ".mpeg"))
578	buf_sets(type, "video/mpeg");
579	else if (bufiright(filename, ".ps"))
580	buf_sets(type, "application/postscript");
581	else
582	buf_sets(type, "application/octet-stream");
583
584	f = fopen(filename->data, "r");
585	if (f) {
586	buf_read(attachment, f);
587	fclose(f);
588	ret = mime_attach(message, attachment, type);
589	}
590
591	buf_free(attachment);
592	buf_free(type);
593	return(ret);
594	}
595
596	int mime_attach(BUFFER message, BUFFER attachment, BUFFER *attachtype)
597	{
598	BUFFER out, part, line, type, subtype, mboundary, field, content;
599	int mimeheader = 0, multipart = 0, versionheader = 0;
600
601	out = buf_new();
602	line = buf_new();
603	part = buf_new();
604	type = buf_new();
605	subtype = buf_new();
606	mboundary = buf_new();
607	field = buf_new();
608	content = buf_new();
609
610	buf_rewind(message);
611	while (buf_getheader(message, field, content) == 0) {
612	if (bufieq(field, "mime-version"))
613	versionheader = 1;
614	if (bufieq(field, "content-type")) {
615	get_type(content, type, subtype);
616	if (bufieq(type, "multipart") && bufieq(subtype, "mixed")) {
617	multipart = 1;
618	get_parameter(content, "boundary", mboundary);
619	}
620	}
621	if (bufileft(field, "content-"))
622	mimeheader = 1;
623	}
624
625	if (mimeheader && !multipart) {
626	buf_rewind(message);
627	while (buf_getheader(message, field, content) == 0) {
628	if (bufileft(field, "content-"))
629	buf_appendheader(part, field, content);
630	else
631	buf_appendheader(out, field, content);
632	}
633	} else {
634	buf_ungetc(message);
635	buf_append(out, message->data, message->ptr);
636	buf_getc(message);
637	}
638
639	if (!versionheader)
640	buf_appends(out, "MIME-Version: 1.0\n");
641
642	if (!multipart) {
643	buf_setrnd(mboundary, 18);
644	encode(mboundary, 0);
645	buf_appendf(out, "Content-Type: multipart/mixed; boundary=\"%b\"\n",
646	mboundary);
647	}
648	buf_nl(out);
649
650	if (multipart) {
651	while (buf_getline(message, line) != -1) {
652	if (boundary(line, mboundary) == delimclose)
653	break;
654	buf_cat(out, line);
655	buf_nl(out);
656	}
657	} else {
658	buf_appendf(out, "--%b\n", mboundary);
659	if (part->length) {
660	buf_cat(out, part); /* body part header */
661	}
662	else {
663	if (strlen(DEFLTENTITY))
664	buf_appendf(out, "Content-Type: %s\n", DEFLTENTITY);
665	}
666
667	buf_nl(out);
668	buf_cat(out, message);
669	buf_nl(out);
670	}
671
672	buf_appendf(out, "--%b\n", mboundary);
673	buf_appendf(out, "Content-Type: %b\n", attachtype);
674
675	body_encode(attachment, MIME_8BIT, line);
676	buf_cat(out, line);
677	buf_nl(out);
678	buf_cat(out, attachment);
679	buf_appendf(out, "\n--%b--\n", mboundary);
680
681	buf_move(message, out);
682
683	buf_free(out);
684	buf_free(line);
685	buf_free(part);
686	buf_free(type);
687	buf_free(subtype);
688	buf_free(mboundary);
689	buf_free(field);
690	buf_free(content);
691	return (1);
692	}
693
694	static int entity_encode(BUFFER message, BUFFER out, BUFFER *messagehdr,
695	int encoding)
696	{
697	BUFFER field, content, mboundary, part, line, line2, *tmp;
698
699	field = buf_new();
700	content = buf_new();
701	mboundary = buf_new();
702	part = buf_new();
703	line = buf_new();
704	line2 = buf_new();
705	tmp = buf_new();
706
707	buf_rewind(message);
708	buf_clear(out);
709	buf_clear(messagehdr);
710
711	while (buf_getheader(message, field, content) == 0) {
712	if (bufileft(field, "content-"))
713	buf_appendheader(out, field, content);
714	else if (messagehdr)
715	buf_appendheader(messagehdr, field, content);
716
717	if (bufieq(field, "content-type")) {
718	get_type(content, line, tmp);
719	if (bufieq(line, "multipart"))
720	get_parameter(content, "boundary", mboundary);
721	}
722	}
723
724	buf_nl(out);
725	if (mboundary->length) {
726	while (buf_getline(message, line) != -1) {
727	buf_cat(out, line);
728	buf_nl(out);
729	if (boundary(line, mboundary))
730	break;
731	}
732	while (buf_getline(message, line) != -1) {
733	if (boundary(line, mboundary)) {
734	entity_encode(part, tmp, line2, encoding);
735	buf_cat(out, line2);
736	buf_cat(out, tmp);
737	buf_cat(out, line);
738	buf_nl(out);
739	buf_clear(part);
740	if (boundary(line, mboundary) == delimclose)
741	break;
742	} else {
743	buf_cat(part, line);
744	buf_nl(part);
745	}
746	}
747	} else
748	buf_rest(out, message);
749	buf_rewind(out);
750	mail_encode(out, encoding);
751
752	buf_free(field);
753	buf_free(content);
754	buf_free(mboundary);
755	buf_free(part);
756	buf_free(line);
757	buf_free(line2);
758	buf_free(tmp);
759	return (1);
760	}
761
762	int pgpmime_sign(BUFFER message, BUFFER uid, BUFFER pass, char secring)
763	{
764	BUFFER out, body, mboundary, algo;
765	int err;
766
767	out = buf_new();
768	body = buf_new();
769	mboundary = buf_new();
770	algo = buf_new();
771
772	pgp_signhashalgo(algo, uid, secring, pass);
773
774	entity_encode(message, body, out, MIME_7BIT);
775
776	buf_setrnd(mboundary, 18);
777	encode(mboundary, 0);
778	buf_appendf(out, "Content-Type: multipart/signed; boundary=\"%b\";\n",
779	mboundary);
780	buf_appendf(out,
781	"\tmicalg=pgp-%b; protocol=\"application/pgp-signature\"\n",
782	algo);
783	buf_nl(out);
784
785	buf_appendf(out, "--%b\n", mboundary);
786	buf_cat(out, body);
787	buf_nl(out);
788	buf_appendf(out, "--%b\n", mboundary);
789
790	err = pgp_encrypt(PGP_SIGN \| PGP_TEXT \| PGP_DETACHEDSIG, body, NULL,
791	uid, pass, NULL, secring);
792
793	buf_appends(out, "Content-Type: application/pgp-signature\n");
794	buf_nl(out);
795	buf_cat(out, body);
796	buf_nl(out);
797	buf_appendf(out, "--%b--\n", mboundary);
798	if (err == 0)
799	buf_move(message, out);
800
801	buf_free(out);
802	buf_free(body);
803	buf_free(mboundary);
804	buf_free(algo);
805	return (err);
806	}