src/org/ibex/mail/Mailbox.java

   1 // Copyright 2000-2005 the Contributors, as shown in the revision logs.
   2 // Licensed under the Apache Public Source License 2.0 ("the License").
   3 // You may not use this file except in compliance with the License.
   4
   5 package org.ibex.mail;
   6 import org.ibex.mail.*;
   7 import org.ibex.util.*;
   8 import org.ibex.mail.*;
   9 import org.ibex.js.*;
  10 import java.io.*;
  11 import java.net.*;
  12 import java.util.*;
  13 import java.text.*;
  14
  15 /** abstract superclass for mailboxes, which store messages along with their flags */
  16 public abstract class Mailbox extends JS.Obj implements Target {
  17
  18     public static final String STORAGE_ROOT =
  19         System.getProperty("ibex.mail.root", File.separatorChar + "var" + File.separatorChar + "org.ibex.mail");
  20
  21
  22     // Required Methods //////////////////////////////////////////////////////////////////////////////
  23
  24     public abstract Mailbox.Iterator iterator(Query q);
  25
  26     public abstract void             insert(Message message, int flags);
  27     public abstract void             post(Message message);
  28     public abstract void             move(Query q, Mailbox dest);
  29     public abstract void             copy(Query q, Mailbox dest);
  30     public abstract int              count(Query q);
  31     public abstract int              uidNext();
  32
  33     // Thunks ////////////////////////////////////////////////////////////////////////////
  34
  35     public          void             accept(Message m) { insert(m, Flag.RECENT); }
  36     public          Mailbox.Iterator iterator() { return iterator(Query.all()); }
  37
  38
  39     // Default Implementation //////////////////////////////////////////////////////////////////////////////
  40
  41     private int randomUidValidity = new Random().nextInt();
  42     public  int uidValidity()  { return randomUidValidity; }
  43
  44     public int maxuid() {
  45         int ret = -1;
  46         for(Mailbox.Iterator it = iterator(); it.next(); ) ret = Math.max(ret, it.uid());
  47         return ret;
  48     }
  49
  50     /** default, inefficient implementation of Mailbox; only requires a few methods to be implemented */
  51     public static abstract class Default extends Mailbox /* implements MailTree? */ {
  52         public Mailbox.Iterator iterator(Query q) { return new Mailbox.Iterator.QueryIterator(q, this); }
  53         public void copy(Query q, Mailbox dest) { for(Mailbox.Iterator it = iterator(q); it.next();) dest.insert(it.cur(), it.getFlags()); }
  54         public int count(Query q) { int count = 0; for(Mailbox.Iterator it = iterator(q); it.next();) count++; return count; }
  55         public MailTree slash(String name, boolean create) { return null; }
  56         public String[] children() { return new String[] { }; }
  57         public void post(Message message) { insert(message, Flag.RECENT); }
  58         public JS get(JS key) throws JSExn {
  59             return (JS)slash(JSU.toString(key), true);
  60         }
  61         public void move(Query q, Mailbox dest) {
  62             for(Mailbox.Iterator it = iterator(q);it.next();) { dest.insert(it.cur(), it.getFlags()); it.delete(); }
  63         }
  64         public static abstract class Iterator implements Mailbox.Iterator {
  65             // FIXME: NNTP spec allows us to use longs (64-bit) here
  66             // FIXME: NNTP spec requires that the minimum nntpNumber of a group must never, ever decrease (no, that's not a typo)
  67             public int     nntpNumber() { throw new MailException("not supported"); }
  68             public int     getFlags() { return 0; }
  69             public void    setFlags(int flags) { throw new MailException("not supported"); }
  70         }
  71     }
  72
  73
  74     // Iterator Definition //////////////////////////////////////////////////////////////////////////////
  75
  76     public static interface Iterator {
  77         public abstract Message cur();
  78         public abstract Headers head();
  79
  80         // FIXME: change all code to actually use this convention!
  81         /** JDBC convention: iterator starts "before the first element" */
  82         public abstract boolean next();
  83
  84         public abstract void    delete();
  85
  86         /** a unique identifier for this message */
  87         public abstract int     uid();
  88
  89         /**
  90          *  Message number according to IMAP semantics.
  91          *    - must range from 1..numMessagesInMailbox
  92          *    - no two messages in the same mailbox may have the same imapNumber
  93          *    - sorting by uid must yield the same order as sorting them by imapNumber
  94          *    - imapNumber changes when messages with lower imapNumbers are deleted
  95          */
  96         public abstract int     imapNumber();
  97
  98         /**
  99          *  Message number according to NNTP semantics.
 100          *    - no two messages in the same mailbox may have the same nntpNumber
 101          *    - article number may NEVER change or EVER be reused
 102          *    - uidValidity is irrelevant
 103          */
 104         public abstract int     nntpNumber();
 105
 106         public abstract int     getFlags();
 107         public abstract void    setFlags(int flags);
 108
 109         public static class Wrapper implements Iterator {
 110             private Iterator it;
 111             public Wrapper(Iterator it) { this.it = it; }
 112             public Message cur() { return it.cur(); }
 113             public Headers head() { return it.head(); }
 114             public boolean next() { return it.next(); }
 115             public int     uid() { return it.uid(); }
 116             public int     nntpNumber() { return it.nntpNumber(); }
 117             public int     imapNumber() { return it.imapNumber(); }
 118             public void    delete() { it.delete(); }
 119             public int     getFlags() { return it.getFlags(); }
 120             public void    setFlags(int flags) { it.setFlags(flags); }
 121         }
 122
 123         public static class AclWrapper extends Wrapper {
 124             private Acl.Entry acl;
 125             public AclWrapper(Iterator it, Acl.Entry acl) { super(it); this.acl = acl; }
 126             public Message cur() { if (acl.read && acl.list) return super.cur(); else throw new Acl.PermissionDenied(); }
 127             public Headers head() { if (acl.read && acl.list) return super.head(); else throw new Acl.PermissionDenied(); }
 128             public boolean next() { if (acl.list) return super.next(); else throw new Acl.PermissionDenied(); }
 129             public int     uid() { if (acl.list) return super.uid(); else throw new Acl.PermissionDenied(); }
 130             public int     nntpNumber() { if (acl.list) return super.nntpNumber(); else throw new Acl.PermissionDenied(); }
 131             public int     imapNumber() { if (acl.list) return super.imapNumber(); else throw new Acl.PermissionDenied(); }
 132             public void    delete() { if (acl.delete) super.delete(); else throw new Acl.PermissionDenied(); }
 133             public int     getFlags() { if (acl.list) return super.getFlags(); else throw new Acl.PermissionDenied(); }
 134             public void    setFlags(int flags) { if (acl.flags) super.setFlags(flags); else throw new Acl.PermissionDenied(); }
 135         }
 136
 137         class QueryIterator extends Mailbox.Iterator.Wrapper {
 138             Query q;
 139             public QueryIterator(Query q, Mailbox m) { super(m.iterator()); this.q = q; }
 140             public boolean next() {
 141                 if (q == null) return false;
 142                 do { if (!super.next()) return false; } while(!q.match(this)); return true; }
 143         }
 144
 145         public static class NullIterator extends Mailbox.Default.Iterator {
 146             public NullIterator() { }
 147             public Message cur() { return null; }
 148             public Headers head() { return null; }
 149             public boolean next() { return false; }
 150             public int     uid() { return 0; }
 151             public void    delete() { }
 152             public int     imapNumber() { return 0; }
 153             public int     nntpNumber() { throw new RuntimeException("this mailbox does not keep article numbers"); }
 154         }
 155     }
 156
 157     /** constants for the six IMAP flags */
 158     public static class Flag {
 159         public static final int DELETED  = 0x0001;
 160         public static final int SEEN     = 0x0002;
 161         public static final int FLAGGED  = 0x0004;
 162         public static final int DRAFT    = 0x0008;
 163         public static final int ANSWERED = 0x0010;
 164         public static final int RECENT   = 0x0020;
 165         public static final int[] all = new int[] { DELETED, SEEN, FLAGGED, DRAFT, ANSWERED, RECENT };
 166         public static final int defaultFlags = RECENT;
 167     }
 168
 169     public static class MailboxWrapper extends Mailbox {
 170         private Mailbox m;
 171         public MailboxWrapper(Mailbox m) { this.m = m; }
 172
 173         public Mailbox.Iterator iterator() { return m.iterator(); }
 174         public Mailbox.Iterator iterator(Query q) { return m.iterator(q); }
 175         public void             insert(Message message, int flags) { m.insert(message, flags); }
 176         public void             post(Message message) { m.insert(message, Flag.RECENT); }
 177         public void             move(Query q, Mailbox dest) { m.move(q, dest); }
 178         public void             copy(Query q, Mailbox dest) { m.copy(q, dest); }
 179         public int              count(Query q) { return m.count(q); }
 180         public int              uidNext() { return m.uidNext(); }
 181         public int              uidValidity()  { return m.uidValidity(); }
 182     }
 183
 184     public static class AclWrapper extends MailboxWrapper {
 185         private Mailbox m;
 186         private Acl.Entry acl;
 187         public AclWrapper(Mailbox m, Acl.Entry acl) { super(m); this.acl = acl; }
 188         public Mailbox.Iterator iterator(Query q) { if (acl.list) return new Mailbox.Iterator.AclWrapper(m.iterator(q), acl); else throw new Acl.PermissionDenied(); }
 189         public Mailbox.Iterator iterator() { if (acl.list) return new Mailbox.Iterator.AclWrapper(m.iterator(), acl); else throw new Acl.PermissionDenied(); }
 190         public void             insert(Message message, int flags) { if (acl.insert) m.insert(message, flags); else throw new Acl.PermissionDenied(); }
 191         public int              uidValidity()  { if (acl.list) return m.uidValidity(); else throw new Acl.PermissionDenied(); }
 192         public void             post(Message message) { if (acl.post) m.insert(message, Flag.RECENT); else throw new Acl.PermissionDenied(); }
 193         public void             move(Query q, Mailbox dest) { if (acl.list && acl.read && acl.delete) m.move(q, dest); else throw new Acl.PermissionDenied(); }
 194         public void             copy(Query q, Mailbox dest) { if (acl.list && acl.read) m.copy(q, dest); else throw new Acl.PermissionDenied(); }
 195         public int              count(Query q) { if (acl.list) return m.count(q); else throw new Acl.PermissionDenied(); }
 196         public int              uidNext() { if (acl.list) return m.uidNext(); else throw new Acl.PermissionDenied(); }
 197     }
 198 }