X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fibex%2Fmail%2FHeaders.java;h=c7813eba12ac52aaa329a171363d6fa0b23df193;hb=0af90c1a1f14e24e1eb6790228be021b3e8e65b4;hp=a68d9d73e7a240dd752e8bb49d5f1a153daf93b0;hpb=440e9bee20802bfbf97061b01f950448d3baf8f5;p=org.ibex.mail.git

diff --git a/src/org/ibex/mail/Headers.java b/src/org/ibex/mail/Headers.java
index a68d9d7..c7813eb 100644
--- a/src/org/ibex/mail/Headers.java
+++ b/src/org/ibex/mail/Headers.java
@@ -14,127 +14,134 @@ 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)
-public abstract class Headers extends JS.Immutable implements Fountain {
+// FEATURE: construct hash lazily?
+public class Headers extends JS.Immutable implements Fountain {
+   
+    /**
+     *  constructs a new set of Headers based on a preexisting set --
+     *  keyval's even-numbered elements are keys, odd elements are
+     *  values -- a null value deletes, non-null value replaces
+     */
+    public Headers(Headers old, String[] keyval) { this(old.updateHeaders(keyval), false); }
+    public Headers(String[] keyval)              { this(new Headers(), keyval); }
 
-    public Headers set(String k, String v) {
-        Stream stream = getStream();
-        StringBuffer all = new StringBuffer();
-        int lines = 0;
+    public Headers() { this(new String[0]); }
+    public Headers(Fountain fountain) throws Malformed { this(fountain, false); }
+    public Headers(Fountain fountain, boolean assumeMime) throws Malformed { this(extractEntries(fountain), assumeMime); }
+
+
+    // public //////////////////////////////////////////////////////////////////////////////
+
+    public String[] getHeaderNames()       { return (String[])head.dumpkeys(new String[head.size()]); }
+    public String   get(String s)          { return (String)head.get(s.toLowerCase()); }
+    public JS       get(JS s) throws JSExn { return JSU.S(get(JSU.toString(s).toLowerCase())); }
+
+    public Stream getStream()   { return fountain().getStream(); }
+    public long   getLength()   { return fountain().getLength(); }
+    public int    getNumLines() { return fountain().getNumLines(); }
+
+
+    // private //////////////////////////////////////////////////////////////////////////////
+
+    private final Hash head = new Hash();
+    private final boolean mime;
+    private final Entry[] entries;
+    private       Fountain fountain = null;
+
+    private synchronized Fountain fountain() {  // lazily constructed
+        if (fountain == null) {
+            StringBuffer sb = new StringBuffer();
+            for(Entry e : entries)
+                sb.append(e.toString());
+            this.fountain = Fountain.Util.create(sb.toString());
+        }
+        return fountain;
+    }
+
+    private static class Entry {
+        public final String key;
+        public final String val;
+        public String toString() { return key+":"+val; }
+        public Entry(String key, String val) throws Malformed {
+            this.key = key;
+            this.val = val;
+            for(int i=0; i<key.length(); i++)
+                if (key.charAt(i) < 33 || key.charAt(i) > 126)
+                    throw new Malformed("Header key \""+key+"\" contains invalid character \"" +
+                                        key.charAt(i) + "\" (0x"+Integer.toString(key.charAt(i), 16) +")");
+        }
+    }
+
+    private Headers(Entry[] entries, boolean assumeMime) {
+        this.entries = entries;
+        this.mime = assumeMime | (get("mime-version") != null && get("mime-version").trim().equals("1.0"));
+        for(Entry e : entries) {
+            String val = (String)head.get(e.key.toLowerCase());
+            val = val==null ? e.val.trim() : val+" "+e.val.trim();  // introduce folding whitespace =(
+            // FEATURE
+            //if (mime) k = Encode.RFC2047.decode(k);
+            //if (mime) v = Encode.RFC2047.decode(v);
+            head.put(e.key.toLowerCase(), val);
+        }
+    }
+
+    private static Entry[] extractEntries(Fountain fountain) throws Malformed {
         String key = null;
+        Stream stream = fountain.getStream();
+        ArrayList<Entry> entries = new ArrayList<Entry>();
         for(String s = stream.readln(); s != null && !s.equals(""); s = stream.readln()) {
-            if (!Character.isSpace(s.charAt(0))) {
-                if (s.indexOf(':') == -1) throw new Malformed("Header line does not contain colon: " + s);
-                key = s.substring(0, s.indexOf(':')).toLowerCase();
-            }
-            if (key.toLowerCase().equals(k.toLowerCase())) {
-                if (v != null) { all.append(k + ": " + v + "\r\n"); lines++; v = null; }
+            s += "\r\n"; // this is the only place where we introduce manglage -- we normalize EOLs
+            if (Character.isSpace(s.charAt(0))) {
+                if (key == null) throw new Malformed("Message began with a blank line; no headers");
+                Entry e = entries.remove(entries.size()-1);
+                entries.add(new Entry(e.key, e.val+s));
                 continue;
             }
-            all.append(s);
-            all.append("\r\n");
-            lines++;
-        }
-        if (v != null) {
-            lines++;
-            all.append(k + ": " + v + "\r\n");
+            if (s.indexOf(':') == -1) throw new Malformed("Header line does not contain colon: " + s);
+            key = s.substring(0, s.indexOf(':'));
+            entries.add(new Entry(key, s.substring(s.indexOf(':') + 1)));
         }
-        all.append("\r\n");
-        return new Original(new Stream(all.toString()));
+        return (Entry[])entries.toArray(new Entry[entries.size()]);
     }
-    
-    // FIXME
-    public abstract String getString();
-
-    public abstract String get(String s);
-    public abstract java.util.Enumeration names();
-
-    public Headers set(String[] keyval) {
-        Headers ret = this;
-        for(int i=0; i<keyval.length; i+=2)
-            ret = ret.set(keyval[i], keyval[i+1]);
-        return ret;
-    }
-    public Headers remove(String key) { return set(key, null); /* FIXME */ }
 
-    public String getLowerCaseTrimmed(String s) {
-        String ret = get(s);
-        return ret==null ? null : ret.toLowerCase();
-    }
-    
-    public static class Original extends Headers {
-        private final Hash head = new Hash();
-        private final Hash headModified = new Hash();
-        public        int lines;
-        public  final boolean mime;
-        private String raw;
-        private StringFountain fountain;
-
-        public String getString() { return raw; }
-        public Stream getStream() { return fountain.getStream(); }
-        public int    getLength() { return fountain.getLength(); }
-        public int    getNumLines() { return fountain.getNumLines(); }
-        public Stream getStreamWithCRLF() { return new Stream(raw+"\r\n"); }
-        public JS get(JS s) throws JSExn { return JSU.S(get(JSU.toString(s).toLowerCase())); }
-        public java.util.Enumeration names() { return head.keys(); }
-        
-        public String get(String s) { return (String)head.get(s.toLowerCase()); }
-        public Original(Stream stream) throws Malformed { this(stream, false); }
-        public Original(Stream stream, boolean assumeMime) throws Malformed {
-            StringBuffer all = new StringBuffer();
-            String key = null;
-            int lines = 0;
-            for(String s = stream.readln(); s != null && !s.equals(""); s = stream.readln()) {
-                all.append(s);
-                all.append("\r\n");
-                lines++;
-                if (Character.isSpace(s.charAt(0))) {
-                    if (key == null) throw new Malformed("Message began with a blank line; no headers");
-                    head.put(key, head.get(key) + " " + s.trim());
-                    continue;
-                }
-                if (s.indexOf(':') == -1) throw new Malformed("Header line does not contain colon: " + s);
-                key = s.substring(0, s.indexOf(':')).toLowerCase();
-                for(int i=0; i<key.length(); i++)
-                    if (key.charAt(i) < 33 || key.charAt(i) > 126)
-                        throw new Malformed("Header key \""+key+"\" contains invalid character \"" + key.charAt(i) + "\"");
-                String val = s.substring(s.indexOf(':') + 1).trim();
-                if (get(key) != null) val = get(key) + " " + val; // just append it to the previous one;
-                head.put(key, val);
+    private Entry[] updateHeaders(String[] keyval) {
+        ArrayList<Entry> entries = new ArrayList<Entry>();
+        for(int i=0; i<this.entries.length; i++)
+            entries.add(this.entries[i]);
+        OUTER: for(int i=0; i<keyval.length; i+=2) {
+            for(int j=0; j<entries.size(); j++) {
+                Entry e = entries.get(j);
+                if (!e.key.toLowerCase().equals(keyval[i].toLowerCase())) continue;
+                if (keyval[i+1]==null)
+                    entries.remove(j);
+                else
+                    entries.set(j, new Entry(keyval[i], keyval[i+1]+"\r\n"));
+                continue OUTER;
             }
-            this.raw = all.toString();
-            this.fountain = new Fountain.StringFountain(this.raw);
-            this.lines = lines;
-            this.mime = assumeMime | (get("mime-version") != null && get("mime-version").trim().equals("1.0"));
-            /*
-              java.util.Enumeration e = head.keys();
-              while(e.hasNext()) {
-              String k = (String)e.next();
-              String v = (String)head.get(k);
-              if (mime) k = Encode.RFC2047.decode(k);
-              v = uncomment(v);
-              if (mime) v = Encode.RFC2047.decode(v);
-              head.put(k, v);
-              }
-            */
+            if (keyval[i+1]!=null)
+                entries.add(0, new Entry(keyval[i], keyval[i+1]+"\r\n"));
         }
-
+        return (Entry[])entries.toArray(new Entry[entries.size()]);
+    }
 
     // Helpers //////////////////////////////////////////////////////////////////////////////
 
     public static Stream skip(Stream stream) {
-        for(String s = stream.readln(); s!=null && s.length() > 0;) s = stream.readln();
+        for(String s = stream.readln(); s!=null && s.trim().length() > 0;)
+            s = stream.readln();
         return stream;
     }
 
-    public static String uncomment(String val) {
+    // designed to remove CFWS, but doesn't work right
+    public static String removeCFWS(String val) {
         boolean inquotes = false;
         for(int i=0; i<val.length(); i++) {
             if (val.charAt(i) == '\"') inquotes = !inquotes;
+            // FIXME: nested comments
             if (val.charAt(i) == '(' && !inquotes)
                 val = val.substring(0, i) + val.substring(val.indexOf(i--, ')') + 1);
         }
         return val;
     }
-    }
+
 }