Mix/Src/mime.c

/* Mixmaster version 3  --  (C) 1999 Anonymizer Inc.

   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.2 2001/12/12 19:29:52 rabbi Exp $ */


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