synthesize messageids when necessary
[org.ibex.mail.git] / src / org / ibex / mail / Message.java
index 1243c56..73ab0f8 100644 (file)
@@ -1,25 +1,21 @@
+// Copyright 2000-2005 the Contributors, as shown in the revision logs.
+// Licensed under the Apache Public Source License 2.0 ("the License").
+// You may not use this file except in compliance with the License.
+
 package org.ibex.mail;
 import org.ibex.crypto.*;
 import org.ibex.util.*;
 import org.ibex.mail.protocol.*;
+import org.ibex.js.*;
 import org.ibex.io.*;
+import org.ibex.io.Fountain;
 import java.util.*;
 import java.net.*;
 import java.io.*;
 
-// FIXME this is important: folded headers: can insert CRLF anywhere that whitespace appears (before the whitespace)
-
-// soft line limit (suggested): 78 chars /  hard line limit: 998 chars
-// date/time parsing: see spec, 3.3
-
-// FIXME: messages must NEVER contain 8-bit binary data; this is a violation of IMAP
-
-// FEATURE: PGP-signature-parsing
-// FEATURE: mailing list header parsing
-// FEATURE: delivery status notification (and the sneaky variety)
-// FEATURE: threading as in http://www.jwz.org/doc/threading.html
-// FEATURE: lazy body
-// FIXME RFC822 1,000-char limit per line
+// FEATURE: body constraints (how to enforce without reading stream, though?)
+//   - messages must NEVER contain 8-bit binary data; this is a violation of IMAP
+//   - RFC822 1,000-char limit per line [soft line limit (suggested): 78 chars /  hard line limit: 998 chars]
 
 /** 
  *  [immutable] This class encapsulates a message "floating in the
@@ -28,49 +24,71 @@ import java.io.*;
  */
 public class Message extends MIME.Part {
 
-    // Envelope //////////////////////////////////////////////////////////////////////////////
-
-    public final Envelope    envelope;
-    public static class Envelope extends org.ibex.js.JSReflection {
-        public Envelope(Address from, Address to, Date arrival) { this.to = to; this.from = from; this.arrival = arrival; }
-        public final Date arrival;
-        public final Address to;
-        public final Address from;
-        public static Envelope augment(Envelope e, MIME.Headers h) {
-            if (e.from != null && e.to != null) return e;
-            Address to   = e.to   == null ? Address.parse(h.get("X-org.ibex.mail.headers.envelope.To"))   : e.to;
-            Address from = e.from == null ? Address.parse(h.get("X-org.ibex.mail.headers.envelope.From")) : e.from;
-            return new Envelope(from, to, e.arrival);
-        }
-    }
-
-
     // Parsed Headers //////////////////////////////////////////////////////////////////////////////
 
     public final Address     to;
     public final Address     from;                // if multiple From entries, this is sender
+    public final Address     envelopeFrom;
+    public final Address     envelopeTo;
     public final Date        date;
+    public final Date        arrival;
     public final Address     replyto;             // if none provided, this is equal to sender
     public final String      subject;
     public final String      messageid;
     public final Address[]   cc;
     public final Address[]   bcc;
-    public final Hashtable[] resent;
-
-    public Message(Stream stream, Envelope envelope) throws Malformed {
-        super(stream, null, false);
-        Vec resent = new Vec(), traces = new Vec();
-        this.envelope     = Envelope.augment(envelope, headers);
-        this.to           = headers.get("To") == null       ? envelope.to    : Address.parse(headers.get("To"));
-        this.from         = headers.get("From") == null     ? envelope.from  : Address.parse(headers.get("From"));
-        this.replyto      = headers.get("Reply-To") == null ? null           : Address.parse(headers.get("Reply-To"));
+
+    public static Message newMessage(Fountain in) throws Malformed { return new Message(in, null); }
+    public static Message newMessageFromHeadersAndBody(Headers head, Fountain body, Address from, Address to) throws Malformed {
+        return new Message(Fountain.Util.concat(head, Fountain.Util.create("\r\n"), body),
+                           new String[] {
+                               "Return-Path", from==null ? "<>" : from.toString(true),
+                               "Envelope-To", to.toString(true)
+                           });
+    }
+    /*
+    public static Message newMessageWithEnvelope(Fountain in, Address from, Address to) throws Malformed {
+        return new Message(in,
+                           new String[] {
+                               "Return-Path", from==null ? "<>" : from.toString(true),
+                               "Envelope-To", to.toString(true)
+                           });
+    }
+    */
+    public Message withEnvelope(Address from, Address to) {
+        return new Message(this,
+                           new String[] {
+                               "Return-Path", from==null ? "<>" : from.toString(true),
+                               "Envelope-To", to.toString(true)
+                           });
+    }
+    private Message(Fountain in, String[] keyval) throws Malformed {
+        super(in, keyval);
+
+        this.envelopeTo   = headers.get("Envelope-To") != null ? Address.parse(headers.get("Envelope-To")) : null;
+        this.envelopeFrom = headers.get("Return-Path") != null ? Address.parse(headers.get("Return-Path")) : null;
+        this.to           = headers.get("To") != null ? Address.parse(headers.get("To")) : this.envelopeTo;
+        this.from         = headers.get("From") != null ? Address.parse(headers.get("From")) : this.envelopeFrom;
+        this.replyto      = headers.get("Reply-To") == null ? null : Address.parse(headers.get("Reply-To"));
         this.subject      = headers.get("Subject");
-        this.messageid    = headers.get("Message-Id");
+        String messageid  = headers.get("Message-Id");
         this.cc           = Address.list(headers.get("Cc"));
-        this.bcc          = Address.list(headers.get("BCc"));
-        this.date         = parseDate(headers.get("Date"));
-        resent.copyInto(this.resent = new Hashtable[resent.size()]);
-        traces.copyInto(this.traces = new Trace[traces.size()]);
+        this.bcc          = Address.list(headers.get("Bcc"));
+        Date date         = RobustDateParser.parseDate(headers.get("Date"));
+        this.date         = date==null ? new Date() : date;
+        this.arrival      = this.date; // FIXME wrong: should grab this from traces, I think?
+
+        if (messageid == null) {
+            SHA1 sha1 = new SHA1();
+            Stream s = this.getStream();
+            s.setInputDigest(sha1);
+            s.transcribe(new Stream(new NullOutputStream()));
+            byte[] end = new byte[sha1.getDigestSize()];
+            sha1.doFinal(end, 0);
+            messageid = "<synthetic.messageid." + Encode.toBase64String(end) + ">";
+            Log.info(this, "synthesized messageid " + messageid);
+        }
+        this.messageid = messageid;
     }
 
 
@@ -79,92 +97,84 @@ public class Message extends MIME.Part {
     // http://www.jwz.org/doc/mid.html
     private static final Random random = new Random();
     public static String generateFreshMessageId() {
+        return generateFreshMessageId(Base36.encode(System.currentTimeMillis())+'.'+
+                                      Base36.encode(random.nextLong()));
+    }
+    // FEATURE: sha1-based deterministic messageids?  probably only useful for some virtual Mailbox impls though
+    public static String generateFreshMessageId(String seed) {
         StringBuffer ret = new StringBuffer();
         ret.append('<');
-        ret.append(Base36.encode(System.currentTimeMillis()));
-        ret.append('.');
-        ret.append(Base36.encode(random.nextLong()));
-        ret.append('.');
+        ret.append(seed);
+        ret.append('@');
         try { ret.append(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { /* DELIBERATE */ }
         ret.append('>');
         return ret.toString();
     }
 
-    public static Date parseDate(String s) { return null; } // FIXME!!!
-   
-    //  use null-sender for error messages (don't send errors to the null addr)
-    public Message bounce(String reason) { throw new RuntimeException("bounce not implemented"); }  // FIXME!
-    public String summary() {
-        return
-            "          Subject: " + subject + "\n" +
-            "     EnvelopeFrom: " + envelope.from + "\n" +
-            "       EnvelopeTo: " + envelope.to + "\n" +
-            "        MessageId: " + messageid;
+    // FIXME: untested.  Do we really want to duplicate all the old headers???
+    public Message reply(Fountain body, Address from, boolean includeReInSubject) throws Malformed {
+        return reply(new String[0], body, from, includeReInSubject);
     }
-
-    public void dump(Stream s) {
-        s.setNewline("\r\n");
-        s.println(headers.raw);
-        s.println();
-        s.println(body);
-        s.flush();
+    public Message reply(String[] keyval, Fountain body, Address envelopeFrom, boolean includeReInSubject) throws Malformed {
+       Address to = null;
+       if (to==null) to = Address.parse(headers.get("reply-to"));
+       if (to==null) to = Address.parse(headers.get("from"));
+       if (to==null) to = this.envelopeFrom;
+        if (to==null) throw new Malformed("cannot reply to a message without a return address");
+       String references = headers.get("references");
+        String subject = this.subject;
+       if (includeReInSubject && subject!=null && !subject.toLowerCase().trim().startsWith("re:"))
+           subject = "Re: "+subject;
+       Headers h = new Headers(new Headers(new String[] {
+            "To",          to.toString(true),
+            "Message-Id",  generateFreshMessageId(),
+            "Date",        new Date()+"" /*FIXME!!!*/,
+            "Subject",     subject,
+            "In-Reply-To", messageid,
+            "References",  messageid + (references==null?"":(" "+references))
+            }), keyval);
+        return newMessageFromHeadersAndBody(h, body, from, to);
     }
 
-    public int size()        { return headers.raw.length() + 2 /* CRLF */ + body.length(); }
-    public String toString() { return headers.raw + "\r\n" + body; }
-
-
-    // SMTP Traces //////////////////////////////////////////////////////////////////////////////
-
-    public final Trace[]     traces;
-    public class Trace {
-        final String returnPath;
-        final Element[] elements;
-        public Trace(Stream stream) throws Trace.Malformed {
-            String retPath = stream.readln();
-            if (!retPath.startsWith("Return-Path:")) throw new Trace.Malformed("trace did not start with Return-Path header");
-            returnPath = retPath.substring(12).trim();
-            Vec el = new Vec();
-            while(true) {
-                String s = stream.readln();
-                if (s == null) break;
-                if (!s.startsWith("Received:")) { stream.unread(s); break; }
-                s = s.substring(9).trim();
-                el.addElement(new Element(s));
-            }
-            elements = new Element[el.size()];
-            el.copyInto(elements);
-        }
-        public class Element {
-             String fromDomain;
-             String fromIP;
-             String toDomain;
-             String forWhom;
-             Date date;
-            public Element(String fromDomain, String fromIP, String toDomain, String forWhom, Date date) {
-                this.fromDomain=fromDomain; this.fromIP=fromIP; this.toDomain=toDomain; this.forWhom=forWhom; this.date=date; }
-            public Element(String s) throws Trace.Malformed {
-                StringTokenizer st = new StringTokenizer(s);
-                if (!st.nextToken().equals("FROM")) throw new Trace.Malformed("trace did note have a FROM element: " + s);
-                fromDomain = st.nextToken();
-                if (!st.nextToken().equals("BY")) throw new Trace.Malformed("trace did note have a BY element: " + s);
-                toDomain = st.nextToken();
-                // FIXME not done yet
-            }
+    // this is belived to be compliant with QSBMF (http://cr.yp.to/proto/qsbmf.txt)
+    public Message bounce(String reason) {
+        if (envelopeFrom==null || envelopeFrom.toString().equals("")) return null;
+
+        // FIXME: limit bounce body size
+        // FIXME: include headers from  bounced message
+        Log.warn(Message.class, "bouncing message due to: " + reason);
+        Headers h = new Headers(headers, new String[] {
+            "Envelope-To", envelopeFrom.toString(),
+            "Return-Path", "<>",
+            "From",        "MAILER-DAEMON <>",
+            "To",          envelopeFrom.toString(),
+            "Subject",     "failure notice"
+        });
+
+        String error =
+            "\r\n"+
+            "Hi. This is the Ibex Mail Server.  I'm afraid I wasn't able to deliver\r\n"+
+            "your message to the following addresses. This is a permanent error;\r\n"+
+            "I've given up.  Sorry it didn't work out\r\n."+
+            "\r\n"+
+            "<"+envelopeTo.toString()+">:\r\n"+
+            reason+"\r\n"+
+            "\r\n"+
+            "--- Below this line is a copy of the message.\r\n"+
+            "\r\n";
+
+        try {
+            return newMessage(Fountain.Util.concat(h, Fountain.Util.create(error), getBody()));
+        } catch (Message.Malformed e) {
+            Log.error(this, "caught Message.Malformed in Message.bounce(); this should never happen");
+            Log.error(this, e);
+            return null;
         }
-        public class Malformed extends Message.Malformed { public Malformed(String s) { super(s); } }
     }
 
-    public static class Malformed extends Exception { public Malformed(String s) { super(s); } }
+    public       String toString() { throw new RuntimeException("Message.toString() called"); }
+    public final String summary() { return "[" + envelopeFrom + " -> " + envelopeTo + "] " + subject; }
 
+    public static class Malformed extends MailException { public Malformed(String s) { super(s); } }
 }
 
-        /*
-            if (key.startsWith("Resent-")) {
-                if (resent.size() == 0 || key.startsWith("Resent-From")) resent.addElement(new Hashtable());
-                ((Hashtable)resent.lastElement()).put(key.substring(7), val);
-            } else if (key.startsWith("Return-Path")) {
-                stream.unread(s);
-                traces.addElement(new Trace(stream));
-        */