src/org/ibex/mail/Message.java

   1 package org.ibex.mail;
   2 import org.ibex.crypto.*;
   3 import org.ibex.util.*;
   4 import org.ibex.mail.protocol.*;
   5 import org.ibex.io.*;
   6 import java.util.*;
   7 import java.net.*;
   8 import java.io.*;
   9
  10 // FIXME this is important: folded headers: can insert CRLF anywhere that whitespace appears (before the whitespace)
  11
  12 // soft line limit (suggested): 78 chars /  hard line limit: 998 chars
  13 // date/time parsing: see spec, 3.3
  14
  15 // FIXME: messages must NEVER contain 8-bit binary data; this is a violation of IMAP
  16
  17 // FEATURE: PGP-signature-parsing
  18 // FEATURE: mailing list header parsing
  19 // FEATURE: delivery status notification (and the sneaky variety)
  20 // FEATURE: threading as in http://www.jwz.org/doc/threading.html
  21 // FEATURE: lazy body
  22 // FIXME RFC822 1,000-char limit per line
  23
  24 /**
  25  *  [immutable] This class encapsulates a message "floating in the
  26  *  ether": RFC2822 data but no storage-specific flags or other
  27  *  metadata.
  28  */
  29 public class Message extends MIME.Part {
  30
  31     // Envelope //////////////////////////////////////////////////////////////////////////////
  32
  33     public final Envelope    envelope;
  34     public static class Envelope extends org.ibex.js.JSReflection {
  35         public Envelope(Address from, Address to, Date arrival) { this.to = to; this.from = from; this.arrival = arrival; }
  36         public final Date arrival;
  37         public final Address to;
  38         public final Address from;
  39         public static Envelope augment(Envelope e, MIME.Headers h) {
  40             if (e.from != null && e.to != null) return e;
  41             Address to   = e.to   == null ? Address.parse(h.gets("X-org.ibex.mail.headers.envelope.To"))   : e.to;
  42             Address from = e.from == null ? Address.parse(h.gets("X-org.ibex.mail.headers.envelope.From")) : e.from;
  43             return new Envelope(from, to, e.arrival);
  44         }
  45     }
  46
  47
  48     // Parsed Headers //////////////////////////////////////////////////////////////////////////////
  49
  50     public final Address     to;
  51     public final Address     from;                // if multiple From entries, this is sender
  52     public final Date        date;
  53     public final Address     replyto;             // if none provided, this is equal to sender
  54     public final String      subject;
  55     public final String      messageid;
  56     public final Address[]   cc;
  57     public final Address[]   bcc;
  58     public final Hashtable[] resent;
  59
  60     public Message(Stream stream, Envelope envelope) throws Malformed {
  61         super(stream, null, false);
  62         Vec resent = new Vec(), traces = new Vec();
  63         this.envelope     = Envelope.augment(envelope, headers);
  64         this.to           = headers.gets("To") == null       ? envelope.to    : Address.parse(headers.gets("To"));
  65         this.from         = headers.gets("From") == null     ? envelope.from  : Address.parse(headers.gets("From"));
  66         this.replyto      = headers.gets("Reply-To") == null ? null           : Address.parse(headers.gets("Reply-To"));
  67         this.subject      = headers.gets("Subject");
  68         this.messageid    = headers.gets("Message-Id");
  69         this.cc           = Address.list(headers.gets("Cc"));
  70         this.bcc          = Address.list(headers.gets("BCc"));
  71         this.date         = parseDate(headers.gets("Date"));
  72         resent.copyInto(this.resent = new Hashtable[resent.size()]);
  73         traces.copyInto(this.traces = new Trace[traces.size()]);
  74     }
  75
  76
  77     // Helpers /////////////////////////////////////////////////////////////////////////////
  78
  79     // http://www.jwz.org/doc/mid.html
  80     private static final Random random = new Random();
  81     public static String generateFreshMessageId() {
  82         StringBuffer ret = new StringBuffer();
  83         ret.append('<');
  84         ret.append(Base36.encode(System.currentTimeMillis()));
  85         ret.append('.');
  86         ret.append(Base36.encode(random.nextLong()));
  87         ret.append('.');
  88         try { ret.append(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { /* DELIBERATE */ }
  89         ret.append('>');
  90         return ret.toString();
  91     }
  92
  93     public static Date parseDate(String s) { return null; } // FIXME!!!
  94
  95     //  use null-sender for error messages (don't send errors to the null addr)
  96     public Message bounce(String reason) {
  97         Log.warn(Message.class, "bounce not implemented");
  98         return null;
  99     }  // FIXME!
 100
 101     public String summary() { return "[" + envelope.from + " -> " + envelope.to + "] " + subject; }
 102
 103     public void dump(Stream s) {
 104         s.setNewline("\r\n");
 105         s.println(headers.raw);
 106         s.println();
 107         s.println(body);
 108         s.flush();
 109     }
 110
 111     public int size()        { return headers.raw.length() + 2 /* CRLF */ + body.length(); }
 112     public String toString() { return headers.raw + "\r\n" + body; }
 113
 114
 115     // SMTP Traces //////////////////////////////////////////////////////////////////////////////
 116
 117     public final Trace[]     traces;
 118     public class Trace {
 119         final String returnPath;
 120         final Element[] elements;
 121         public Trace(Stream stream) throws Trace.Malformed {
 122             String retPath = stream.readln();
 123             if (!retPath.startsWith("Return-Path:")) throw new Trace.Malformed("trace did not start with Return-Path header");
 124             returnPath = retPath.substring(12).trim();
 125             Vec el = new Vec();
 126             while(true) {
 127                 String s = stream.readln();
 128                 if (s == null) break;
 129                 if (!s.startsWith("Received:")) { stream.unread(s); break; }
 130                 s = s.substring(9).trim();
 131                 el.addElement(new Element(s));
 132             }
 133             elements = new Element[el.size()];
 134             el.copyInto(elements);
 135         }
 136         public class Element {
 137              String fromDomain;
 138              String fromIP;
 139              String toDomain;
 140              String forWhom;
 141              Date date;
 142             public Element(String fromDomain, String fromIP, String toDomain, String forWhom, Date date) {
 143                 this.fromDomain=fromDomain; this.fromIP=fromIP; this.toDomain=toDomain; this.forWhom=forWhom; this.date=date; }
 144             public Element(String s) throws Trace.Malformed {
 145                 StringTokenizer st = new StringTokenizer(s);
 146                 if (!st.nextToken().equals("FROM")) throw new Trace.Malformed("trace did note have a FROM element: " + s);
 147                 fromDomain = st.nextToken();
 148                 if (!st.nextToken().equals("BY")) throw new Trace.Malformed("trace did note have a BY element: " + s);
 149                 toDomain = st.nextToken();
 150                 // FIXME not done yet
 151             }
 152         }
 153         public class Malformed extends Message.Malformed { public Malformed(String s) { super(s); } }
 154     }
 155
 156     public static class Malformed extends Exception { public Malformed(String s) { super(s); } }
 157
 158 }
 159
 160         /*
 161             if (key.startsWith("Resent-")) {
 162                 if (resent.size() == 0 || key.startsWith("Resent-From")) resent.addElement(new Hashtable());
 163                 ((Hashtable)resent.lastElement()).put(key.substring(7), val);
 164             } else if (key.startsWith("Return-Path")) {
 165                 stream.unread(s);
 166                 traces.addElement(new Trace(stream));
 167         */