Skip to contentPackage: LengthCounter
LengthCounter
Coverage
1: /*
2: * Copyright (c) 1997, 2023 Oracle and/or its affiliates. All rights reserved.
3: *
4: * This program and the accompanying materials are made available under the
5: * terms of the Eclipse Public License v. 2.0, which is available at
6: * http://www.eclipse.org/legal/epl-2.0.
7: *
8: * This Source Code may also be made available under the following Secondary
9: * Licenses when the conditions for such availability set forth in the
10: * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
11: * version 2 with the GNU Classpath Exception, which is available at
12: * https://www.gnu.org/software/classpath/license.html.
13: *
14: * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
15: */
16:
17: package org.eclipse.angus.mail.imap;
18:
19: import java.util.Date;
20: import java.util.Hashtable;
21: import java.util.List;
22: import java.util.ArrayList;
23: import java.util.Map;
24: import java.util.NoSuchElementException;
25: import java.util.logging.Level;
26: import java.io.*;
27: import java.net.SocketTimeoutException;
28: import java.nio.channels.SocketChannel;
29:
30: import jakarta.mail.*;
31: import jakarta.mail.event.*;
32: import jakarta.mail.internet.*;
33: import jakarta.mail.search.*;
34:
35: import org.eclipse.angus.mail.imap.protocol.FetchItem;
36: import org.eclipse.angus.mail.imap.protocol.FetchResponse;
37: import org.eclipse.angus.mail.imap.protocol.IMAPProtocol;
38: import org.eclipse.angus.mail.imap.protocol.IMAPResponse;
39: import org.eclipse.angus.mail.imap.protocol.Item;
40: import org.eclipse.angus.mail.imap.protocol.ListInfo;
41: import org.eclipse.angus.mail.imap.protocol.MODSEQ;
42: import org.eclipse.angus.mail.imap.protocol.MailboxInfo;
43: import org.eclipse.angus.mail.imap.protocol.MessageSet;
44: import org.eclipse.angus.mail.imap.protocol.Status;
45: import org.eclipse.angus.mail.imap.protocol.UID;
46: import org.eclipse.angus.mail.imap.protocol.UIDSet;
47: import org.eclipse.angus.mail.util.CRLFOutputStream;
48: import org.eclipse.angus.mail.util.MailLogger;
49: import org.eclipse.angus.mail.iap.*;
50: import org.eclipse.angus.mail.imap.protocol.*;
51: import org.eclipse.angus.mail.iap.BadCommandException;
52: import org.eclipse.angus.mail.iap.CommandFailedException;
53: import org.eclipse.angus.mail.iap.ConnectionException;
54: import org.eclipse.angus.mail.iap.Literal;
55: import org.eclipse.angus.mail.iap.ProtocolException;
56: import org.eclipse.angus.mail.iap.Response;
57: import org.eclipse.angus.mail.iap.ResponseHandler;
58: import org.eclipse.angus.mail.imap.protocol.FLAGS;
59:
60: /**
61: * This class implements an IMAP folder. <p>
62: *
63: * A closed IMAPFolder object shares a protocol connection with its IMAPStore
64: * object. When the folder is opened, it gets its own protocol connection. <p>
65: *
66: * Applications that need to make use of IMAP-specific features may cast
67: * a <code>Folder</code> object to an <code>IMAPFolder</code> object and
68: * use the methods on this class. <p>
69: *
70: * The {@link #getQuota getQuota} and
71: * {@link #setQuota setQuota} methods support the IMAP QUOTA extension.
72: * Refer to <A HREF="http://www.ietf.org/rfc/rfc2087.txt">RFC 2087</A>
73: * for more information. <p>
74: *
75: * The {@link #getACL getACL}, {@link #addACL addACL},
76: * {@link #removeACL removeACL}, {@link #addRights addRights},
77: * {@link #removeRights removeRights}, {@link #listRights listRights}, and
78: * {@link #myRights myRights} methods support the IMAP ACL extension.
79: * Refer to <A HREF="http://www.ietf.org/rfc/rfc2086.txt">RFC 2086</A>
80: * for more information. <p>
81: *
82: * The {@link #getSortedMessages getSortedMessages}
83: * methods support the IMAP SORT extension.
84: * Refer to <A HREF="http://www.ietf.org/rfc/rfc5256.txt">RFC 5256</A>
85: * for more information. <p>
86: *
87: * The {@link #open(int, ResyncData) open(int,ResyncData)}
88: * method and {@link ResyncData ResyncData} class supports
89: * the IMAP CONDSTORE and QRESYNC extensions.
90: * Refer to <A HREF="http://www.ietf.org/rfc/rfc4551.txt">RFC 4551</A>
91: * and <A HREF="http://www.ietf.org/rfc/rfc5162.txt">RFC 5162</A>
92: * for more information. <p>
93: *
94: * The {@link #doCommand doCommand} method and
95: * {@link IMAPFolder.ProtocolCommand IMAPFolder.ProtocolCommand}
96: * interface support use of arbitrary IMAP protocol commands. <p>
97: *
98: * See the <a href="package-summary.html">org.eclipse.angus.mail.imap</a> package
99: * documentation for further information on the IMAP protocol provider. <p>
100: *
101: * <strong>WARNING:</strong> The APIs unique to this class should be
102: * considered <strong>EXPERIMENTAL</strong>. They may be changed in the
103: * future in ways that are incompatible with applications using the
104: * current APIs.
105: *
106: * @author John Mani
107: * @author Bill Shannon
108: * @author Jim Glennon
109: */
110:
111: /*
112: * The folder object itself serves as a lock for the folder's state
113: * EXCEPT for the message cache (see below), typically by using
114: * synchronized methods. When checking that a folder is open or
115: * closed, the folder's lock must be held. It's important that the
116: * folder's lock is acquired before the messageCacheLock (see below).
117: * Thus, the locking hierarchy is that the folder lock, while optional,
118: * must be acquired before the messageCacheLock, if it's acquired at
119: * all. Be especially careful of callbacks that occur while holding
120: * the messageCacheLock into (e.g.) superclass Folder methods that are
121: * synchronized. Note that methods in IMAPMessage will acquire the
122: * messageCacheLock without acquiring the folder lock. <p>
123: *
124: * When a folder is opened, it creates a messageCache (a Vector) of
125: * empty IMAPMessage objects. Each Message has a messageNumber - which
126: * is its index into the messageCache, and a sequenceNumber - which is
127: * its IMAP sequence-number. All operations on a Message which involve
128: * communication with the server, use the message's sequenceNumber. <p>
129: *
130: * The most important thing to note here is that the server can send
131: * unsolicited EXPUNGE notifications as part of the responses for "most"
132: * commands. Refer RFC 3501, sections 5.3 & 5.5 for gory details. Also,
133: * the server sends these notifications AFTER the message has been
134: * expunged. And once a message is expunged, the sequence-numbers of
135: * those messages after the expunged one are renumbered. This essentially
136: * means that the mapping between *any* Message and its sequence-number
137: * can change in the period when a IMAP command is issued and its responses
138: * are processed. Hence we impose a strict locking model as follows: <p>
139: *
140: * We define one mutex per folder - this is just a Java Object (named
141: * messageCacheLock). Any time a command is to be issued to the IMAP
142: * server (i.e., anytime the corresponding IMAPProtocol method is
143: * invoked), follow the below style:
144: *                
145: *        synchronized (messageCacheLock) { // ACQUIRE LOCK
146: *         issue command ()
147: *        
148: *         // The response processing is typically done within
149: *         // the handleResponse() callback. A few commands (Fetch,
150: *         // Expunge) return *all* responses and hence their
151: *         // processing is done here itself. Now, as part of the
152: *         // processing unsolicited EXPUNGE responses, we renumber
153: *         // the necessary sequence-numbers. Thus the renumbering
154: *         // happens within this critical-region, surrounded by
155: *         // locks.
156: *         process responses ()
157: *        } // RELEASE LOCK
158: *
159: * This technique is used both by methods in IMAPFolder and by methods
160: * in IMAPMessage and other classes that operate on data in the folder.
161: * Note that holding the messageCacheLock has the side effect of
162: * preventing the folder from being closed, and thus ensuring that the
163: * folder's protocol object is still valid. The protocol object should
164: * only be accessed while holding the messageCacheLock (except for calls
165: * to IMAPProtocol.isREV1(), which don't need to be protected because it
166: * doesn't access the server).
167: *        
168: * Note that interactions with the Store's protocol connection do
169: * not have to be protected as above, since the Store's protocol is
170: * never in a "meaningful" SELECT-ed state.
171: */
172:
173: public class IMAPFolder extends Folder implements UIDFolder, ResponseHandler {
174:
175: protected volatile String fullName;        // full name
176: protected String name;                // name
177: protected int type;                        // folder type.
178: protected char separator;                // separator
179: protected Flags availableFlags;         // available flags
180: protected Flags permanentFlags;         // permanent flags
181: protected volatile boolean exists;        // whether this folder really exists ?
182: protected boolean isNamespace = false; // folder is a namespace name
183: protected volatile String[] attributes;// name attributes from LIST response
184:
185: protected volatile IMAPProtocol protocol; // this folder's protocol object
186: protected MessageCache messageCache;// message cache
187: // accessor lock for message cache
188: protected final Object messageCacheLock = new Object();
189:
190: protected Hashtable<Long, IMAPMessage> uidTable; // UID->Message hashtable
191:
192: /* An IMAP delimiter is a 7bit US-ASCII character. (except NUL).
193: * We use '\uffff' (a non 7bit character) to indicate that we havent
194: * yet determined what the separator character is.
195: * We use '\u0000' (NUL) to indicate that no separator character
196: * exists, i.e., a flat hierarchy
197: */
198: static final protected char UNKNOWN_SEPARATOR = '\uffff';
199:
200: private volatile boolean opened = false;         // is this folder opened ?
201:
202: /* This field tracks the state of this folder. If the folder is closed
203: * due to external causes (i.e, not thru the close() method), then
204: * this field will remain false. If the folder is closed thru the
205: * close() method, then this field is set to true.
206: *
207: * If reallyClosed is false, then a FolderClosedException is
208: * generated when a method is invoked on any Messaging object
209: * owned by this folder. If reallyClosed is true, then the
210: * IllegalStateException runtime exception is thrown.
211: */
212: private boolean reallyClosed = true;
213:
214: /*
215: * The idleState field supports the IDLE command.
216: * Normally when executing an IMAP command we hold the
217: * messageCacheLock and often the folder lock (see above).
218: * While executing the IDLE command we can't hold either
219: * of these locks or it would prevent other threads from
220: * entering Folder methods even far enough to check whether
221: * an IDLE command is in progress. We need to check before
222: * issuing another command so that we can abort the IDLE
223: * command.
224: *
225: * The idleState field is protected by the messageCacheLock.
226: * The RUNNING state is the normal state and means no IDLE
227: * command is in progress. The IDLE state means we've issued
228: * an IDLE command and are reading responses. The ABORTING
229: * state means we've sent the DONE continuation command and
230: * are waiting for the thread running the IDLE command to
231: * break out of its read loop.
232: *
233: * When an IDLE command is in progress, the thread calling
234: * the idle method will be reading from the IMAP connection
235: * while holding neither the folder lock nor the messageCacheLock.
236: * It's obviously critical that no other thread try to send a
237: * command or read from the connection while in this state.
238: * However, other threads can send the DONE continuation
239: * command that will cause the server to break out of the IDLE
240: * loop and send the ending tag response to the IDLE command.
241: * The thread in the idle method that's reading the responses
242: * from the IDLE command will see this ending response and
243: * complete the idle method, setting the idleState field back
244: * to RUNNING, and notifying any threads waiting to use the
245: * connection.
246: *
247: * All uses of the IMAP connection (IMAPProtocol object) must
248: * be done while holding the messageCacheLock and must be
249: * preceeded by a check to make sure an IDLE command is not
250: * running, and abort the IDLE command if necessary. While
251: * waiting for the IDLE command to complete, these other threads
252: * will give up the messageCacheLock, but might still be holding
253: * the folder lock. This check is done by the getProtocol()
254: * method, resulting in a typical usage pattern of:
255: *
256: *         synchronized (messageCacheLock) {
257: *                IMAPProtocol p = getProtocol();        // may block waiting for IDLE
258: *                // ... use protocol
259: *         }
260: */
261: private static final int RUNNING = 0;        // not doing IDLE command
262: private static final int IDLE = 1;                // IDLE command in effect
263: private static final int ABORTING = 2;        // IDLE command aborting
264: private int idleState = RUNNING;
265: private IdleManager idleManager;
266:
267: private volatile int total = -1;        // total number of messages in the
268:                                         // message cache
269: private volatile int recent = -1;        // number of recent messages
270: private int realTotal = -1;                // total number of messages on
271:                                         // the server
272: private long uidvalidity = -1;        // UIDValidity
273: private long uidnext = -1;                // UIDNext
274: private boolean uidNotSticky = false;        // RFC 4315
275: private volatile long highestmodseq = -1;        // RFC 4551 - CONDSTORE
276: private boolean doExpungeNotification = true; // used in expunge handler
277:
278: private Status cachedStatus = null;
279: private long cachedStatusTime = 0;
280:
281: private boolean hasMessageCountListener = false;        // optimize notification
282:
283: protected MailLogger logger;
284: private MailLogger connectionPoolLogger;
285:
286: /**
287: * A fetch profile item for fetching headers.
288: * This inner class extends the <code>FetchProfile.Item</code>
289: * class to add new FetchProfile item types, specific to IMAPFolders.
290: *
291: * @see FetchProfile
292: */
293: public static class FetchProfileItem extends FetchProfile.Item {
294:         protected FetchProfileItem(String name) {
295:          super(name);
296:         }
297:
298:         /**
299:          * HEADERS is a fetch profile item that can be included in a
300:          * <code>FetchProfile</code> during a fetch request to a Folder.
301:          * This item indicates that the headers for messages in the specified
302:          * range are desired to be prefetched. <p>
303:          *
304:          * An example of how a client uses this is below:
305:          * <blockquote><pre>
306:          *
307:          *         FetchProfile fp = new FetchProfile();
308:          *        fp.add(IMAPFolder.FetchProfileItem.HEADERS);
309:          *        folder.fetch(msgs, fp);
310:          *
311:          * </pre></blockquote>
312:          */
313:         public static final FetchProfileItem HEADERS =
314:                 new FetchProfileItem("HEADERS");
315:
316:         /**
317:          * SIZE is a fetch profile item that can be included in a
318:          * <code>FetchProfile</code> during a fetch request to a Folder.
319:          * This item indicates that the sizes of the messages in the specified
320:          * range are desired to be prefetched. <p>
321:          *
322:          * SIZE was moved to FetchProfile.Item in JavaMail 1.5.
323:          *
324:          * @deprecated
325:          */
326:         @Deprecated
327:         public static final FetchProfileItem SIZE =
328:                 new FetchProfileItem("SIZE");
329:
330:         /**
331:          * MESSAGE is a fetch profile item that can be included in a
332:          * <code>FetchProfile</code> during a fetch request to a Folder.
333:          * This item indicates that the entire messages (headers and body,
334:          * including all "attachments") in the specified
335:          * range are desired to be prefetched. Note that the entire message
336:          * content is cached in memory while the Folder is open. The cached
337:          * message will be parsed locally to return header information and
338:          * message content. <p>
339:          *
340:          * An example of how a client uses this is below:
341:          * <blockquote><pre>
342:          *
343:          *         FetchProfile fp = new FetchProfile();
344:          *        fp.add(IMAPFolder.FetchProfileItem.MESSAGE);
345:          *        folder.fetch(msgs, fp);
346:          *
347:          * </pre></blockquote>
348:          *
349:          * @since        JavaMail 1.5.2
350:          */
351:         public static final FetchProfileItem MESSAGE =
352:                 new FetchProfileItem("MESSAGE");
353:
354:         /**
355:          * INTERNALDATE is a fetch profile item that can be included in a
356:          * <code>FetchProfile</code> during a fetch request to a Folder.
357:          * This item indicates that the IMAP INTERNALDATE values
358:          * (received date) of the messages in the specified
359:          * range are desired to be prefetched. <p>
360:          *
361:          * An example of how a client uses this is below:
362:          * <blockquote><pre>
363:          *
364:          *         FetchProfile fp = new FetchProfile();
365:          *        fp.add(IMAPFolder.FetchProfileItem.INTERNALDATE);
366:          *        folder.fetch(msgs, fp);
367:          *
368:          * </pre></blockquote>
369:          *
370:          * @since        JavaMail 1.5.5
371:          */
372:         public static final FetchProfileItem INTERNALDATE =
373:                 new FetchProfileItem("INTERNALDATE");
374: }
375:
376: /**
377: * Constructor used to create a possibly non-existent folder.
378: *
379: * @param fullName        fullname of this folder
380: * @param separator the default separator character for this
381: *                        folder's namespace
382: * @param store        the Store
383: * @param isNamespace if this folder represents a namespace
384: */
385: protected IMAPFolder(String fullName, char separator, IMAPStore store,
386:                                 Boolean isNamespace) {
387:         super(store);
388:         if (fullName == null)
389:          throw new NullPointerException("Folder name is null");
390:         this.fullName = fullName;
391:         this.separator = separator;
392:         logger = new MailLogger(this.getClass(), "DEBUG IMAP",
393:          store.getSession().getDebug(), store.getSession().getDebugOut());
394:         connectionPoolLogger = store.getConnectionPoolLogger();
395:
396:         /*
397:          * Work around apparent bug in Exchange. Exchange
398:          * will return a name of "Public Folders/" from
399:          * LIST "%".
400:          *
401:          * If name has one separator, and it's at the end,
402:          * assume this is a namespace name and treat it
403:          * accordingly. Usually this will happen as a result
404:          * of the list method, but this also allows getFolder
405:          * to work with namespace names.
406:          */
407:         this.isNamespace = false;
408:         if (separator != UNKNOWN_SEPARATOR && separator != '\0') {
409:          int i = this.fullName.indexOf(separator);
410:          if (i > 0 && i == this.fullName.length() - 1) {
411:                 this.fullName = this.fullName.substring(0, i);
412:                 this.isNamespace = true;
413:          }
414:         }
415:
416:         // if we were given a value, override default chosen above
417:         if (isNamespace != null)
418:          this.isNamespace = isNamespace.booleanValue();
419: }
420:
421: /**
422: * Constructor used to create an existing folder.
423: *
424: * @param        li        the ListInfo for this folder
425: * @param        store        the store containing this folder
426: */
427: protected IMAPFolder(ListInfo li, IMAPStore store) {
428:         this(li.name, li.separator, store, null);
429:
430:         if (li.hasInferiors)
431:          type |= HOLDS_FOLDERS;
432:         if (li.canOpen)
433:          type |= HOLDS_MESSAGES;
434:         exists = true;
435:         attributes = li.attrs;
436: }
437:         
438: /*
439: * Ensure that this folder exists. If 'exists' has been set to true,
440: * we don't attempt to validate it with the server again. Note that
441: * this can result in a possible loss of sync with the server.
442: * ASSERT: Must be called with this folder's synchronization lock held.
443: */
444: protected void checkExists() throws MessagingException {
445:         // If the boolean field 'exists' is false, check with the
446:         // server by invoking exists() ..
447:         if (!exists && !exists())
448:          throw new FolderNotFoundException(
449:                 this, fullName + " not found");
450: }
451:
452: /*
453: * Ensure the folder is closed.
454: * ASSERT: Must be called with this folder's synchronization lock held.
455: */
456: protected void checkClosed() {
457:         if (opened)
458:          throw new IllegalStateException(
459:                 "This operation is not allowed on an open folder"
460:                 );
461: }
462:
463: /*
464: * Ensure the folder is open.
465: * ASSERT: Must be called with this folder's synchronization lock held.
466: */
467: protected void checkOpened() throws FolderClosedException {
468:         assert Thread.holdsLock(this);
469:         if (!opened) {
470:          if (reallyClosed)
471:                 throw new IllegalStateException(
472:                  "This operation is not allowed on a closed folder"
473:                  );
474:          else // Folder was closed "implicitly"
475:                 throw new FolderClosedException(this,
476:                  "Lost folder connection to server"
477:                 );
478:         }
479: }
480:
481: /*
482: * Check that the given message number is within the range
483: * of messages present in this folder. If the message
484: * number is out of range, we ping the server to obtain any
485: * pending new message notifications from the server.
486: */
487: protected void checkRange(int msgno) throws MessagingException {
488:         if (msgno < 1) // message-numbers start at 1
489:          throw new IndexOutOfBoundsException("message number < 1");
490:
491:         if (msgno <= total)
492:          return;
493:
494:         // Out of range, let's ping the server and see if
495:         // the server has more messages for us.
496:
497:         synchronized(messageCacheLock) { // Acquire lock
498:          try {
499:                 keepConnectionAlive(false);
500:          } catch (ConnectionException cex) {
501:                 // Oops, lost connection
502:                 throw new FolderClosedException(this, cex.getMessage());
503:          } catch (ProtocolException pex) {
504:                 throw new MessagingException(pex.getMessage(), pex);
505:          }
506:         } // Release lock
507:
508:         if (msgno > total) // Still out of range ? Throw up ...
509:          throw new IndexOutOfBoundsException(msgno + " > " + total);
510: }
511:
512: /*
513: * Check whether the given flags are supported by this server,
514: * and also verify that the folder allows setting flags.
515: */
516: private void checkFlags(Flags flags) throws MessagingException {
517:         assert Thread.holdsLock(this);
518:         if (mode != READ_WRITE)
519:          throw new IllegalStateException(
520:                 "Cannot change flags on READ_ONLY folder: " + fullName
521:                 );
522:         /*
523:         if (!availableFlags.contains(flags))
524:          throw new MessagingException(
525:                 "These flags are not supported by this implementation"
526:                 );
527:         */
528: }
529:
530: /**
531: * Get the name of this folder.
532: */
533: @Override
534: public synchronized String getName() {
535:         /* Return the last component of this Folder's full name.
536:          * Folder components are delimited by the separator character.
537:          */
538:         if (name == null) {
539:          try {
540:                 name =         fullName.substring(
541:                          fullName.lastIndexOf(getSeparator()) + 1
542:                         );
543:          } catch (MessagingException mex) { }
544:         }
545:         return name;
546: }
547:
548: /**
549: * Get the fullname of this folder.
550: */
551: @Override
552: public String getFullName() {
553:         return fullName;        
554: }
555:
556: /**
557: * Get this folder's parent.
558: */
559: @Override
560: public synchronized Folder getParent() throws MessagingException {
561:         char c = getSeparator();
562:         int index;
563:         if ((index = fullName.lastIndexOf(c)) != -1)
564:          return ((IMAPStore)store).newIMAPFolder(
565:                          fullName.substring(0, index), c);
566:         else
567:          return new DefaultFolder((IMAPStore)store);
568: }
569:
570: /**
571: * Check whether this folder really exists on the server.
572: */
573: @Override
574: public synchronized boolean exists() throws MessagingException {
575:         // Check whether this folder exists ..
576:         ListInfo[] li = null;
577:         final String lname;
578:         if (isNamespace && separator != '\0')
579:          lname = fullName + separator;
580:         else
581:          lname = fullName;
582:
583:         li = (ListInfo[])doCommand(new ProtocolCommand() {
584:          @Override
585:          public Object doCommand(IMAPProtocol p) throws ProtocolException {
586:                 return p.list("", lname);
587:          }
588:         });
589:
590:         if (li != null) {
591:          int i = findName(li, lname);
592:          fullName = li[i].name;
593:          separator = li[i].separator;
594:          int len = fullName.length();
595:          if (separator != '\0' && len > 0 &&
596:                  fullName.charAt(len - 1) == separator) {
597:                 fullName = fullName.substring(0, len - 1);
598:          }
599:          type = 0;
600:          if (li[i].hasInferiors)
601:                 type |= HOLDS_FOLDERS;
602:          if (li[i].canOpen)
603:                 type |= HOLDS_MESSAGES;
604:          exists = true;
605:          attributes = li[i].attrs;
606:         } else {
607:          exists = opened;
608:          attributes = null;
609:         }
610:
611:         return exists;
612: }
613:
614: /**
615: * Which entry in <code>li</code> matches <code>lname</code>?
616: * If the name contains wildcards, more than one entry may be
617: * returned.
618: */
619: private int findName(ListInfo[] li, String lname) {
620:         int i;
621:         // if the name contains a wildcard, there might be more than one
622:         for (i = 0; i < li.length; i++) {
623:          if (li[i].name.equals(lname))
624:                 break;
625:         }
626:         if (i >= li.length) {        // nothing matched exactly
627:          // XXX - possibly should fail? But what if server
628:          // is case insensitive and returns the preferred
629:          // case of the name here?
630:          i = 0;                // use first one
631:         }
632:         return i;
633: }
634:
635: /**
636: * List all subfolders matching the specified pattern.
637: */
638: @Override
639: public Folder[] list(String pattern) throws MessagingException {
640:         return doList(pattern, false);
641: }
642:
643: /**
644: * List all subscribed subfolders matching the specified pattern.
645: */
646: @Override
647: public Folder[] listSubscribed(String pattern) throws MessagingException {
648:         return doList(pattern, true);
649: }
650:
651: private synchronized Folder[] doList(final String pattern,
652:                 final boolean subscribed) throws MessagingException {
653:         checkExists(); // insure that this folder does exist.
654:         
655:         // Why waste a roundtrip to the server?
656:         if (attributes != null && !isDirectory())
657:          return new Folder[0];
658:
659:         final char c = getSeparator();
660:
661:         ListInfo[] li = (ListInfo[])doCommandIgnoreFailure(
662:          new ProtocolCommand() {
663:                 @Override
664:                 public Object doCommand(IMAPProtocol p)
665:                         throws ProtocolException {
666:                  if (subscribed)
667:                         return p.lsub("", fullName + c + pattern);
668:                  else
669:                         return p.list("", fullName + c + pattern);
670:                 }
671:          });
672:
673:         if (li == null)
674:          return new Folder[0];
675:
676:         /*
677:          * The UW based IMAP4 servers (e.g. SIMS2.0) include
678:          * current folder (terminated with the separator), when
679:          * the LIST pattern is '%' or '*'. i.e, <LIST "" mail/%>
680:          * returns "mail/" as the first LIST response.
681:          *
682:          * Doesn't make sense to include the current folder in this
683:          * case, so we filter it out. Note that I'm assuming that
684:          * the offending response is the *first* one, my experiments
685:          * with the UW & SIMS2.0 servers indicate that ..
686:          */
687:         int start = 0;
688:         // Check the first LIST response.
689:         if (li.length > 0 && li[0].name.equals(fullName + c))
690:          start = 1; // start from index = 1
691:
692:         IMAPFolder[] folders = new IMAPFolder[li.length - start];
693:         IMAPStore st = (IMAPStore)store;
694:         for (int i = start; i < li.length; i++)
695:          folders[i-start] = st.newIMAPFolder(li[i]);
696:         return folders;
697: }
698:
699: /**
700: * Get the separator character.
701: */
702: @Override
703: public synchronized char getSeparator() throws MessagingException {
704:         if (separator == UNKNOWN_SEPARATOR) {
705:          ListInfo[] li = null;
706:
707:          li = (ListInfo[])doCommand(new ProtocolCommand() {
708:                 @Override
709:                 public Object doCommand(IMAPProtocol p)
710:                         throws ProtocolException {
711:                  // REV1 allows the following LIST format to obtain
712:                  // the hierarchy delimiter of non-existent folders
713:                  if (p.isREV1()) // IMAP4rev1
714:                  return p.list(fullName, "");
715:                  else // IMAP4, note that this folder must exist for this
716:                  // to work :(
717:                  return p.list("", fullName);
718:                 }
719:          });
720:
721:          if (li != null)
722:                 separator = li[0].separator;
723:          else
724:                 separator = '/'; // punt !
725:         }
726:         return separator;
727: }
728:
729: /**
730: * Get the type of this folder.
731: */
732: @Override
733: public synchronized int getType() throws MessagingException {
734:         if (opened) {
735:          // never throw FolderNotFoundException if folder is open
736:          if (attributes == null)
737:                 exists();        // try to fetch attributes
738:         } else {
739:          checkExists();
740:         }
741:         return type;
742: }
743:
744: /**
745: * Check whether this folder is subscribed.
746: */
747: @Override
748: public synchronized boolean isSubscribed() {
749:         ListInfo[] li = null;
750:         final String lname;
751:         if (isNamespace && separator != '\0')
752:          lname = fullName + separator;
753:         else
754:          lname = fullName;
755:
756:         try {
757:          li = (ListInfo[])doProtocolCommand(new ProtocolCommand() {
758:                 @Override
759:                 public Object doCommand(IMAPProtocol p)
760:                         throws ProtocolException {
761:                  return p.lsub("", lname);
762:                 }
763:          });
764:         } catch (ProtocolException pex) {
765: }
766:
767:         if (li != null) {
768:          int i = findName(li, lname);
769:          return li[i].canOpen;
770:         } else
771:          return false;
772: }
773:
774: /**
775: * Subscribe/Unsubscribe this folder.
776: */
777: @Override
778: public synchronized void setSubscribed(final boolean subscribe)
779:                         throws MessagingException {
780:         doCommandIgnoreFailure(new ProtocolCommand() {
781:          @Override
782:          public Object doCommand(IMAPProtocol p) throws ProtocolException {
783:                 if (subscribe)
784:                  p.subscribe(fullName);
785:                 else
786:                  p.unsubscribe(fullName);
787:                 return null;
788:          }
789:         });
790: }
791:         
792: /**
793: * Create this folder, with the specified type.
794: */
795: @Override
796: public synchronized boolean create(final int type)
797:                                 throws MessagingException {
798:
799:         char c = 0;
800:         if ((type & HOLDS_MESSAGES) == 0)        // only holds folders
801:          c = getSeparator();
802:         final char sep = c;
803:         Object ret = doCommandIgnoreFailure(new ProtocolCommand() {
804:          @Override
805:                 public Object doCommand(IMAPProtocol p)
806:                         throws ProtocolException {
807:                  if ((type & HOLDS_MESSAGES) == 0)        // only holds folders
808:                         p.create(fullName + sep);
809:                  else {
810:                         p.create(fullName);
811:
812:                         // Certain IMAP servers do not allow creation of folders
813:                         // that can contain messages *and* subfolders. So, if we
814:                         // were asked to create such a folder, we should verify
815:                         // that we could indeed do so.
816:                         if ((type & HOLDS_FOLDERS) != 0) {
817:                          // we want to hold subfolders and messages. Check
818:                          // whether we could create such a folder.
819:                          ListInfo[] li = p.list("", fullName);
820:                          if (li != null && !li[0].hasInferiors) {
821:                                 // Hmm ..the new folder
822:                                 // doesn't support Inferiors ? Fail
823:                                 p.delete(fullName);
824:                                 throw new ProtocolException("Unsupported type");
825:                          }
826:                         }
827:                  }
828:                  return Boolean.TRUE;
829:                 }
830:          });
831:
832:         if (ret == null)
833:          return false; // CREATE failure, maybe this
834:                          // folder already exists ?
835:
836:         // exists = true;
837:         // this.type = type;
838:         boolean retb = exists();        // set exists, type, and attributes
839:         if (retb)                // Notify listeners on self and our Store
840:          notifyFolderListeners(FolderEvent.CREATED);
841:         return retb;
842: }
843:
844: /**
845: * Check whether this folder has new messages.
846: */
847: @Override
848: public synchronized boolean hasNewMessages() throws MessagingException {
849:         synchronized (messageCacheLock) {
850:          if (opened) { // If we are open, we already have this information
851:                 // Folder is open, make sure information is up to date
852:                 // tickle the folder and store connections.
853:                 try {
854:                  keepConnectionAlive(true);
855:                 } catch (ConnectionException cex) {
856:                  throw new FolderClosedException(this, cex.getMessage());
857:                 } catch (ProtocolException pex) {
858:                  throw new MessagingException(pex.getMessage(), pex);
859:                 }
860:                 return recent > 0 ? true : false;
861:          }
862:         }
863:
864:         // First, the cheap way - use LIST and look for the \Marked
865:         // or \Unmarked tag
866:
867:         ListInfo[] li = null;
868:         final String lname;
869:         if (isNamespace && separator != '\0')
870:          lname = fullName + separator;
871:         else
872:          lname = fullName;
873:         li = (ListInfo[])doCommandIgnoreFailure(new ProtocolCommand() {
874:          @Override
875:          public Object doCommand(IMAPProtocol p) throws ProtocolException {
876:                 return p.list("", lname);
877:          }
878:         });
879:
880:         // if folder doesn't exist, throw exception
881:         if (li == null)
882:          throw new FolderNotFoundException(this, fullName + " not found");
883:
884:         int i = findName(li, lname);
885:         if (li[i].changeState == ListInfo.CHANGED)
886:          return true;
887:         else if (li[i].changeState == ListInfo.UNCHANGED)
888:          return false;
889:
890:         // LIST didn't work. Try the hard way, using STATUS
891:         try {
892:          Status status = getStatus();
893:          if (status.recent > 0)
894:                 return true;
895:          else
896:                 return false;
897:         } catch (BadCommandException bex) {
898:          // Probably doesn't support STATUS, tough luck.
899:          return false;
900:         } catch (ConnectionException cex) {
901:          throw new StoreClosedException(store, cex.getMessage());
902:         } catch (ProtocolException pex) {
903:          throw new MessagingException(pex.getMessage(), pex);
904:         }
905: }
906:
907: /**
908: * Get the named subfolder.
909: */
910: @Override
911: public synchronized Folder getFolder(String name)
912:                                 throws MessagingException {
913:         // If we know that this folder is *not* a directory, don't
914:         // send the request to the server at all ...
915:         if (attributes != null && !isDirectory())
916:          throw new MessagingException("Cannot contain subfolders");
917:
918:         char c = getSeparator();
919:         return ((IMAPStore)store).newIMAPFolder(fullName + c + name, c);
920: }
921:
922: /**
923: * Delete this folder.
924: */
925: @Override
926: public synchronized boolean delete(boolean recurse)
927:                         throws MessagingException {
928:         checkClosed(); // insure that this folder is closed.
929:
930:         if (recurse) {
931:          // Delete all subfolders.
932:          Folder[] f = list();
933:          for (int i = 0; i < f.length; i++)
934:                 f[i].delete(recurse); // ignore intermediate failures
935:         }
936:
937:         // Attempt to delete this folder
938:
939:         Object ret = doCommandIgnoreFailure(new ProtocolCommand() {
940:          @Override
941:          public Object doCommand(IMAPProtocol p) throws ProtocolException {
942:                 p.delete(fullName);
943:                 return Boolean.TRUE;
944:          }
945:         });
946:
947:         if (ret == null)
948:          // Non-existent folder/No permission ??
949:          return false;
950:
951:         // DELETE succeeded.
952:         exists = false;
953:         attributes = null;
954:
955:         // Notify listeners on self and our Store
956:         notifyFolderListeners(FolderEvent.DELETED);
957:         return true;
958: }
959:
960: /**
961: * Rename this folder.
962: */
963: @Override
964: public synchronized boolean renameTo(final Folder f)
965:                                 throws MessagingException {
966:         checkClosed(); // insure that we are closed.
967:         checkExists();
968:         if (f.getStore() != store)
969:          throw new MessagingException("Can't rename across Stores");
970:
971:
972:         Object ret = doCommandIgnoreFailure(new ProtocolCommand() {
973:          @Override
974:          public Object doCommand(IMAPProtocol p) throws ProtocolException {
975:                 p.rename(fullName, f.getFullName());
976:                 return Boolean.TRUE;
977:          }
978:         });
979:
980:         if (ret == null)
981:          return false;
982:
983:         exists = false;
984:         attributes = null;
985:         notifyFolderRenamedListeners(f);
986:         return true;
987: }
988:
989: /**
990: * Open this folder in the given mode.
991: */
992: @Override
993: public synchronized void open(int mode) throws MessagingException {
994:         open(mode, null);
995: }
996:
997: /**
998: * Open this folder in the given mode, with the given
999: * resynchronization data.
1000: *
1001: * @param        mode        the open mode (Folder.READ_WRITE or Folder.READ_ONLY)
1002: * @param        rd        the ResyncData instance
1003: * @return                a List of MailEvent instances, or null if none
1004: * @exception MessagingException        if the open fails
1005: * @since        JavaMail 1.5.1
1006: */
1007: public synchronized List<MailEvent> open(int mode, ResyncData rd)
1008:                                 throws MessagingException {
1009:         checkClosed(); // insure that we are not already open
1010:         
1011:         MailboxInfo mi = null;
1012:         // Request store for our own protocol connection.
1013:         protocol = ((IMAPStore)store).getProtocol(this);
1014:
1015:         List<MailEvent> openEvents = null;
1016:         synchronized(messageCacheLock) { // Acquire messageCacheLock
1017:
1018:          /*
1019:          * Add response handler right away so we get any alerts or
1020:          * notifications that occur during the SELECT or EXAMINE.
1021:          * Have to be sure to remove it if we fail to open the
1022:          * folder.
1023:          */
1024:          protocol.addResponseHandler(this);
1025:
1026:          try {
1027:                 /*
1028:                  * Enable QRESYNC or CONDSTORE if needed and not enabled.
1029:                  * QRESYNC implies CONDSTORE, but servers that support
1030:                  * QRESYNC are not required to support just CONDSTORE
1031:                  * per RFC 5162.
1032:                  */
1033:                 if (rd != null) {
1034:                  if (rd == ResyncData.CONDSTORE) {
1035:                         if (!protocol.isEnabled("CONDSTORE") &&
1036:                          !protocol.isEnabled("QRESYNC")) {
1037:                          if (protocol.hasCapability("CONDSTORE"))
1038:                                 protocol.enable("CONDSTORE");
1039:                          else
1040:                                 protocol.enable("QRESYNC");
1041:                         }
1042:                  } else {
1043:                         if (!protocol.isEnabled("QRESYNC"))
1044:                          protocol.enable("QRESYNC");
1045:                  }
1046:                 }
1047:
1048:                 if (mode == READ_ONLY)
1049:                  mi = protocol.examine(fullName, rd);
1050:                 else
1051:                  mi = protocol.select(fullName, rd);
1052:          } catch (CommandFailedException cex) {
1053:                 /*
1054:                  * Handle SELECT or EXAMINE failure.
1055:                  * Try to figure out why the operation failed so we can
1056:                  * report a more reasonable exception.
1057:                  *
1058:                  * Will use our existing protocol object.
1059:                  */
1060:                 try {
1061:                  checkExists(); // throw exception if folder doesn't exist
1062:
1063:                  if ((type & HOLDS_MESSAGES) == 0)
1064:                         throw new MessagingException(
1065:                          "folder cannot contain messages");
1066:                  throw new MessagingException(cex.getMessage(), cex);
1067:
1068:                 } finally {
1069:                  // folder not open, don't keep this information
1070:                  exists = false;
1071:                  attributes = null;
1072:                  type = 0;
1073:                  // connection still good, return it
1074:                  releaseProtocol(true);
1075:                 }
1076:                 // NOTREACHED
1077:          } catch (ProtocolException pex) {
1078:                 // got a BAD or a BYE; connection may be bad, close it
1079:                 try {
1080:                  throw logoutAndThrow(pex.getMessage(), pex);
1081:                 } finally {
1082:                  releaseProtocol(false);
1083:                 }
1084:          }
1085:
1086:          if (mi.mode != mode) {
1087:                 if (mode == READ_WRITE && mi.mode == READ_ONLY &&
1088:                         ((IMAPStore)store).allowReadOnlySelect()) {
1089:                  ;                // all ok, allow it
1090:                 } else {        // otherwise, it's an error
1091:                  ReadOnlyFolderException ife = new ReadOnlyFolderException(
1092:                          this, "Cannot open in desired mode");
1093:                  throw cleanupAndThrow(ife);
1094:                 }
1095: }
1096:         
1097:          // Initialize stuff.
1098:          opened = true;
1099:          reallyClosed = false;
1100:          this.mode = mi.mode;
1101:          availableFlags = mi.availableFlags;
1102:          permanentFlags = mi.permanentFlags;
1103:          total = realTotal = mi.total;
1104:          recent = mi.recent;
1105:          uidvalidity = mi.uidvalidity;
1106:          uidnext = mi.uidnext;
1107:          uidNotSticky = mi.uidNotSticky;
1108:          highestmodseq = mi.highestmodseq;
1109:
1110:          // Create the message cache of appropriate size
1111:          messageCache = new MessageCache(this, (IMAPStore)store, total);
1112:
1113:          // process saved responses and return corresponding events
1114:          if (mi.responses != null) {
1115:                 openEvents = new ArrayList<>();
1116:                 for (IMAPResponse ir : mi.responses) {
1117:                  if (ir.keyEquals("VANISHED")) {
1118:                         // "VANISHED" SP ["(EARLIER)"] SP known-uids
1119:                         String[] s = ir.readAtomStringList();
1120:                         // check that it really is "EARLIER"
1121:                         if (s == null || s.length != 1 ||
1122:                                          !s[0].equalsIgnoreCase("EARLIER"))
1123:                          continue;        // it's not, what to do with it here?
1124:                         String uids = ir.readAtom();
1125:                         UIDSet[] uidset = UIDSet.parseUIDSets(uids);
1126:                         long[] luid = UIDSet.toArray(uidset, uidnext);
1127:                         if (luid != null && luid.length > 0)
1128:                          openEvents.add(
1129:                                 new MessageVanishedEvent(this, luid));
1130:                  } else if (ir.keyEquals("FETCH")) {
1131:                         assert ir instanceof FetchResponse :
1132:                                 "!ir instanceof FetchResponse";
1133:                         Message msg = processFetchResponse((FetchResponse)ir);
1134:                         if (msg != null)
1135:                          openEvents.add(new MessageChangedEvent(this,
1136:                                  MessageChangedEvent.FLAGS_CHANGED, msg));
1137:                  }
1138:                 }
1139:          }
1140:         } // Release lock
1141:
1142:         exists = true;                // if we opened it, it must exist
1143:         attributes = null;        // but we don't yet know its attributes
1144:         type = HOLDS_MESSAGES;        // lacking more info, we know at least this much
1145:
1146:         // notify listeners
1147:         notifyConnectionListeners(ConnectionEvent.OPENED);
1148:
1149:         return openEvents;
1150: }
1151:
1152: private MessagingException cleanupAndThrow(MessagingException ife) {
1153:         try {
1154:          try {
1155:                 // close mailbox and return connection
1156:                 protocol.close();
1157:                 releaseProtocol(true);
1158:          } catch (ProtocolException pex) {
1159:                 // something went wrong, close connection
1160:                 try {
1161:                  addSuppressed(ife, logoutAndThrow(pex.getMessage(), pex));
1162:                 } finally {
1163:                  releaseProtocol(false);
1164:                 }
1165:          }
1166:         } catch (Throwable thr) {
1167:          addSuppressed(ife, thr);
1168:         }
1169:         return ife;
1170: }
1171:
1172: private MessagingException logoutAndThrow(String why, ProtocolException t) {
1173:         MessagingException ife = new MessagingException(why, t);
1174:         try {
1175:          protocol.logout();
1176:         } catch (Throwable thr) {
1177:          addSuppressed(ife, thr);
1178:         }
1179:         return ife;
1180: }
1181:
1182: private void addSuppressed(Throwable ife, Throwable thr) {
1183:         if (isRecoverable(thr)) {
1184:          ife.addSuppressed(thr);
1185:         } else {
1186:          thr.addSuppressed(ife);
1187:          if (thr instanceof Error) {
1188:                 throw (Error) thr;
1189:          }
1190:          if (thr instanceof RuntimeException) {
1191:                 throw (RuntimeException) thr;
1192:          }
1193:          throw new RuntimeException("unexpected exception", thr);
1194:         }
1195: }
1196:
1197: private boolean isRecoverable(Throwable t) {
1198:         return (t instanceof Exception) || (t instanceof LinkageError);
1199: }
1200:
1201: /**
1202: * Prefetch attributes, based on the given FetchProfile.
1203: */
1204: @Override
1205: public synchronized void fetch(Message[] msgs, FetchProfile fp)
1206:                         throws MessagingException {
1207:         // cache this information in case connection is closed and
1208:         // protocol is set to null
1209:         boolean isRev1;
1210:         FetchItem[] fitems;
1211: synchronized (messageCacheLock) {
1212:          checkOpened();
1213:          isRev1 = protocol.isREV1();
1214:          fitems = protocol.getFetchItems();
1215:         }
1216:
1217:         StringBuilder command = new StringBuilder();
1218:         boolean first = true;
1219:         boolean allHeaders = false;
1220:
1221:         if (fp.contains(FetchProfile.Item.ENVELOPE)) {
1222:          command.append(getEnvelopeCommand());
1223:          first = false;
1224:         }
1225:         if (fp.contains(FetchProfile.Item.FLAGS)) {
1226:          command.append(first ? "FLAGS" : " FLAGS");
1227:          first = false;
1228:         }
1229:         if (fp.contains(FetchProfile.Item.CONTENT_INFO)) {
1230:          command.append(first ? "BODYSTRUCTURE" : " BODYSTRUCTURE");
1231:          first = false;
1232:         }
1233:         if (fp.contains(UIDFolder.FetchProfileItem.UID)) {
1234:          command.append(first ? "UID" : " UID");
1235:          first = false;
1236:         }
1237:         if (fp.contains(IMAPFolder.FetchProfileItem.HEADERS)) {
1238:          allHeaders = true;
1239:          if (isRev1)
1240:                 command.append(first ?
1241:                          "BODY.PEEK[HEADER]" : " BODY.PEEK[HEADER]");
1242:          else
1243:                 command.append(first ? "RFC822.HEADER" : " RFC822.HEADER");
1244:          first = false;
1245:         }
1246:         if (fp.contains(IMAPFolder.FetchProfileItem.MESSAGE)) {
1247:          allHeaders = true;
1248:          if (isRev1)
1249:                 command.append(first ? "BODY.PEEK[]" : " BODY.PEEK[]");
1250:          else
1251:                 command.append(first ? "RFC822" : " RFC822");
1252:          first = false;
1253:         }
1254:         if (fp.contains(FetchProfile.Item.SIZE) ||
1255:                 fp.contains(IMAPFolder.FetchProfileItem.SIZE)) {
1256:          command.append(first ? "RFC822.SIZE" : " RFC822.SIZE");
1257:          first = false;
1258:         }
1259:         if (fp.contains(IMAPFolder.FetchProfileItem.INTERNALDATE)) {
1260:          command.append(first ? "INTERNALDATE" : " INTERNALDATE");
1261:          first = false;
1262:         }
1263:
1264:         // if we're not fetching all headers, fetch individual headers
1265:         String[] hdrs = null;
1266:         if (!allHeaders) {
1267:          hdrs = fp.getHeaderNames();
1268:          if (hdrs.length > 0) {
1269:                 if (!first)
1270:                  command.append(" ");
1271:                 command.append(createHeaderCommand(hdrs, isRev1));
1272:          }
1273:         }
1274:
1275:         /*
1276:          * Add any additional extension fetch items.
1277:          */
1278:         for (int i = 0; i < fitems.length; i++) {
1279:          if (fp.contains(fitems[i].getFetchProfileItem())) {
1280:                 if (command.length() != 0)
1281:                  command.append(" ");
1282:                 command.append(fitems[i].getName());
1283:          }
1284:         }
1285:
1286:         Utility.Condition condition =
1287:          new IMAPMessage.FetchProfileCondition(fp, fitems);
1288:
1289: // Acquire the Folder's MessageCacheLock.
1290: synchronized (messageCacheLock) {
1291:
1292:          // check again to make sure folder is still open
1293:          checkOpened();
1294:
1295:          // Apply the test, and get the sequence-number set for
1296:          // the messages that need to be prefetched.
1297:          MessageSet[] msgsets = Utility.toMessageSetSorted(msgs, condition);
1298:
1299:          if (msgsets == null)
1300:                 // We already have what we need.
1301:                 return;
1302:
1303:          Response[] r = null;
1304:          // to collect non-FETCH responses & unsolicited FETCH FLAG responses
1305:          List<Response> v = new ArrayList<>();
1306:          try {
1307:                 r = getProtocol().fetch(msgsets, command.toString());
1308:          } catch (ConnectionException cex) {
1309:                 throw new FolderClosedException(this, cex.getMessage());
1310:          } catch (CommandFailedException cfx) {
1311:                 // Ignore these, as per RFC 2180
1312:          } catch (ProtocolException pex) {
1313:                 throw new MessagingException(pex.getMessage(), pex);
1314:          }
1315:
1316:          if (r == null)
1317:                 return;
1318:         
1319:          for (int i = 0; i < r.length; i++) {
1320:                 if (r[i] == null)
1321:                  continue;
1322:                 if (!(r[i] instanceof FetchResponse)) {
1323:                  v.add(r[i]); // Unsolicited Non-FETCH response
1324:                  continue;
1325:                 }
1326:
1327:                 // Got a FetchResponse.
1328:                 FetchResponse f = (FetchResponse)r[i];
1329:                 // Get the corresponding message.
1330:                 IMAPMessage msg = getMessageBySeqNumber(f.getNumber());
1331:
1332:                 int count = f.getItemCount();
1333:                 boolean unsolicitedFlags = false;
1334:
1335:                 for (int j = 0; j < count; j++) {
1336:                  Item item = f.getItem(j);
1337:                  // Check for the FLAGS item
1338:                  if (item instanceof Flags &&
1339:                          (!fp.contains(FetchProfile.Item.FLAGS) ||
1340:                                 msg == null)) {
1341:                         // Ok, Unsolicited FLAGS update.
1342:                         unsolicitedFlags = true;
1343:                  } else if (msg != null)
1344:                         msg.handleFetchItem(item, hdrs, allHeaders);
1345:                 }
1346:                 if (msg != null)
1347:                  msg.handleExtensionFetchItems(f.getExtensionItems());
1348:
1349:                 // If this response contains any unsolicited FLAGS
1350:                 // add it to the unsolicited response vector
1351:                 if (unsolicitedFlags)
1352:                  v.add(f);
1353:          }
1354:
1355:          // Dispatch any unsolicited responses
1356:          if (!v.isEmpty()) {
1357:                 Response[] responses = new Response[v.size()];
1358:                 v.toArray(responses);
1359:                 handleResponses(responses);
1360:          }
1361:
1362:         } // Release messageCacheLock
1363: }
1364:
1365: /**
1366: * Return the IMAP FETCH items to request in order to load
1367: * all the "envelope" data. Subclasses can override this
1368: * method to fetch more data when FetchProfile.Item.ENVELOPE
1369: * is requested.
1370: *
1371: * @return        the IMAP FETCH items to request
1372: * @since JavaMail 1.4.6
1373: */
1374: protected String getEnvelopeCommand() {
1375:         return IMAPMessage.EnvelopeCmd;
1376: }
1377:
1378: /**
1379: * Create a new IMAPMessage object to represent the given message number.
1380: * Subclasses of IMAPFolder may override this method to create a
1381: * subclass of IMAPMessage.
1382: *
1383: * @param        msgnum        the message sequence number
1384: * @return        the new IMAPMessage object
1385: * @since JavaMail 1.4.6
1386: */
1387: protected IMAPMessage newIMAPMessage(int msgnum) {
1388:         return new IMAPMessage(this, msgnum);
1389: }
1390:
1391: /**
1392: * Create the appropriate IMAP FETCH command items to fetch the
1393: * requested headers.
1394: */
1395: private String createHeaderCommand(String[] hdrs, boolean isRev1) {
1396:         StringBuilder sb;
1397:
1398:         if (isRev1)
1399:          sb = new StringBuilder("BODY.PEEK[HEADER.FIELDS (");
1400:         else
1401:          sb = new StringBuilder("RFC822.HEADER.LINES (");
1402:
1403:         for (int i = 0; i < hdrs.length; i++) {
1404:          if (i > 0)
1405:                 sb.append(" ");
1406:          sb.append(hdrs[i]);
1407:         }
1408:
1409:         if (isRev1)
1410:          sb.append(")]");
1411:         else
1412:          sb.append(")");
1413:         
1414:         return sb.toString();
1415: }
1416:
1417: /**
1418: * Set the specified flags for the given array of messages.
1419: */
1420: @Override
1421: public synchronized void setFlags(Message[] msgs, Flags flag, boolean value)
1422:                         throws MessagingException {
1423:         checkOpened();
1424:         checkFlags(flag); // validate flags
1425:
1426:         if (msgs.length == 0) // boundary condition
1427:          return;
1428:
1429:         synchronized(messageCacheLock) {
1430:          try {
1431:                 IMAPProtocol p = getProtocol();
1432:                 MessageSet[] ms = Utility.toMessageSetSorted(msgs, null);
1433:                 if (ms == null)
1434:                  throw new MessageRemovedException(
1435:                                         "Messages have been removed");
1436:                 p.storeFlags(ms, flag, value);
1437:          } catch (ConnectionException cex) {
1438:                 throw new FolderClosedException(this, cex.getMessage());
1439:          } catch (ProtocolException pex) {
1440:                 throw new MessagingException(pex.getMessage(), pex);
1441:          }
1442:         }
1443: }
1444:
1445: /**
1446: * Set the specified flags for the given range of message numbers.
1447: */
1448: @Override
1449: public synchronized void setFlags(int start, int end,
1450:                         Flags flag, boolean value) throws MessagingException {
1451:         checkOpened();
1452:         Message[] msgs = new Message[end - start + 1];
1453:         int i = 0;
1454:         for (int n = start; n <= end; n++)
1455:          msgs[i++] = getMessage(n);
1456:         setFlags(msgs, flag, value);
1457: }
1458:
1459: /**
1460: * Set the specified flags for the given array of message numbers.
1461: */
1462: @Override
1463: public synchronized void setFlags(int[] msgnums, Flags flag, boolean value)
1464:                         throws MessagingException {
1465:         checkOpened();
1466:         Message[] msgs = new Message[msgnums.length];
1467:         for (int i = 0; i < msgnums.length; i++)
1468:          msgs[i] = getMessage(msgnums[i]);
1469:         setFlags(msgs, flag, value);
1470: }
1471:
1472: /**
1473: * Close this folder.
1474: */
1475: @Override
1476: public synchronized void close(boolean expunge) throws MessagingException {
1477:         close(expunge, false);
1478: }
1479:
1480: /**
1481: * Close this folder without waiting for the server.
1482: *
1483: * @exception        MessagingException for failures
1484: */
1485: public synchronized void forceClose() throws MessagingException {
1486:         close(false, true);
1487: }
1488:
1489: /*
1490: * Common close method.
1491: */
1492: private void close(boolean expunge, boolean force)
1493:                                 throws MessagingException {
1494:         assert Thread.holdsLock(this);
1495:         synchronized(messageCacheLock) {
1496:          /*
1497:          * If we already know we're closed, this is illegal.
1498:          * Can't use checkOpened() because if we were forcibly
1499:          * closed asynchronously we just want to complete the
1500:          * closing here.
1501:          */
1502:          if (!opened && reallyClosed)
1503:                 throw new IllegalStateException(
1504:                  "This operation is not allowed on a closed folder"
1505:                 );
1506:
1507:          reallyClosed = true; // Ok, lets reset
1508:
1509:          // Maybe this folder is already closed, or maybe another
1510:          // thread which had the messageCacheLock earlier, found
1511:          // that our server connection is dead and cleaned up
1512:          // everything ..
1513:          if (!opened)
1514:                 return;
1515:
1516:          boolean reuseProtocol = true;
1517:          try {
1518:                 waitIfIdle();
1519:                 if (force) {
1520:                  logger.log(Level.FINE, "forcing folder {0} to close",
1521:                                                                  fullName);
1522:                  if (protocol != null)
1523:                         protocol.disconnect();
1524: } else if (((IMAPStore)store).isConnectionPoolFull()) {
1525:                  // If the connection pool is full, logout the connection
1526:                  logger.fine(
1527:                         "pool is full, not adding an Authenticated connection");
1528:
1529:                  // If the expunge flag is set, close the folder first.
1530:                  if (expunge && protocol != null)
1531:                         protocol.close();
1532:
1533:                  if (protocol != null)
1534:                         protocol.logout();
1535: } else {
1536:                  // If the expunge flag is set or we're open read-only we
1537:                  // can just close the folder, otherwise open it read-only
1538:                  // before closing, or unselect it if supported.
1539: if (!expunge && mode == READ_WRITE) {
1540: try {
1541:                          if (protocol != null &&
1542:                                  protocol.hasCapability("UNSELECT"))
1543:                                 protocol.unselect();
1544:                          else {
1545:                                 // Unselect isn't supported so we need to
1546:                                 // select a folder to cause this one to be
1547:                                 // deselected without expunging messages.
1548:                                 // We try to do that by reopening the current
1549:                                 // folder read-only. If the current folder
1550:                                 // was renamed out from under us, the EXAMINE
1551:                                 // might fail, but that's ok because it still
1552:                                 // leaves us with the folder deselected.
1553:                                 if (protocol != null) {
1554:                                  boolean selected = true;
1555:                                  try {
1556:                                         protocol.examine(fullName);
1557:                                         // success, folder still selected
1558:                                  } catch (CommandFailedException ex) {
1559:                                         // EXAMINE failed, folder is no
1560:                                         // longer selected
1561:                                         selected = false;
1562:                                  }
1563:                                  if (selected && protocol != null)
1564:                                         protocol.close();
1565:                                 }
1566:                          }
1567: } catch (ProtocolException pex2) {
1568:                          reuseProtocol = false;        // something went wrong
1569: }
1570: } else {
1571:                         if (protocol != null)
1572:                          protocol.close();
1573:                  }
1574: }
1575:          } catch (ProtocolException pex) {
1576:                 throw new MessagingException(pex.getMessage(), pex);
1577:          } finally {
1578:                 // cleanup if we haven't already
1579:                 if (opened)
1580:                  cleanup(reuseProtocol);
1581:          }
1582:         }
1583: }
1584:
1585: // NOTE: this method can currently be invoked from close() or
1586: // from handleResponses(). Both invocations are conditional,
1587: // based on the "opened" flag, so we are sure that multiple
1588: // Connection.CLOSED events are not generated. Also both
1589: // invocations are from within messageCacheLock-ed areas.
1590: private void cleanup(boolean returnToPool) {
1591:         assert Thread.holdsLock(messageCacheLock);
1592: releaseProtocol(returnToPool);
1593:         messageCache = null;
1594:         uidTable = null;
1595:         exists = false; // to force a recheck in exists().
1596:         attributes = null;
1597: opened = false;
1598:         idleState = RUNNING;        // just in case
1599:         messageCacheLock.notifyAll();        // wake up anyone waiting
1600:         notifyConnectionListeners(ConnectionEvent.CLOSED);
1601: }
1602:
1603: /**
1604: * Check whether this connection is really open.
1605: */
1606: @Override
1607: public synchronized boolean isOpen() {
1608:         synchronized(messageCacheLock) {
1609:          // Probe the connection to make sure its really open.
1610:          if (opened) {
1611:                 try {
1612:                  keepConnectionAlive(false);
1613:                 } catch (ProtocolException pex) { }
1614:          }
1615:         }
1616:
1617:         return opened;
1618: }
1619:
1620: /**
1621: * Return the permanent flags supported by the server.
1622: */
1623: @Override
1624: public synchronized Flags getPermanentFlags() {
1625:         if (permanentFlags == null)
1626:          return null;
1627:         return (Flags)(permanentFlags.clone());
1628: }
1629:
1630: /**
1631: * Get the total message count.
1632: */
1633: @Override
1634: public synchronized int getMessageCount() throws MessagingException {
1635:         synchronized (messageCacheLock) {
1636:          if (opened) {
1637:                 // Folder is open, we know what the total message count is ..
1638:                 // tickle the folder and store connections.
1639:                 try {
1640:                  keepConnectionAlive(true);
1641:                  return total;
1642:                 } catch (ConnectionException cex) {
1643:                  throw new FolderClosedException(this, cex.getMessage());
1644:                 } catch (ProtocolException pex) {
1645:                  throw new MessagingException(pex.getMessage(), pex);
1646:                 }
1647:          }
1648:         }
1649:
1650:         // If this folder is not yet open, we use STATUS to
1651:         // get the total message count
1652:         checkExists();
1653:         try {
1654:          Status status = getStatus();
1655:          return status.total;
1656:         } catch (BadCommandException bex) {
1657:          // doesn't support STATUS, probably vanilla IMAP4 ..
1658:          // lets try EXAMINE
1659:          IMAPProtocol p = null;
1660:
1661:          try {
1662:                 p = getStoreProtocol();        // XXX
1663:                 MailboxInfo minfo = p.examine(fullName);
1664:                 p.close();
1665:                 return minfo.total;
1666:          } catch (ProtocolException pex) {
1667:                 // Give up.
1668:                 throw new MessagingException(pex.getMessage(), pex);
1669:          } finally {
1670:                 releaseStoreProtocol(p);
1671:          }
1672:         } catch (ConnectionException cex) {
1673:          throw new StoreClosedException(store, cex.getMessage());
1674:         } catch (ProtocolException pex) {
1675:          throw new MessagingException(pex.getMessage(), pex);
1676:         }
1677: }
1678:
1679: /**
1680: * Get the new message count.
1681: */
1682: @Override
1683: public synchronized int getNewMessageCount() throws MessagingException {
1684:         synchronized (messageCacheLock) {
1685:          if (opened) {
1686:                 // Folder is open, we know what the new message count is ..
1687:                 // tickle the folder and store connections.
1688:                 try {
1689:                  keepConnectionAlive(true);
1690:                  return recent;
1691:                 } catch (ConnectionException cex) {
1692:                  throw new FolderClosedException(this, cex.getMessage());
1693:                 } catch (ProtocolException pex) {
1694:                  throw new MessagingException(pex.getMessage(), pex);
1695:                 }
1696:          }
1697:         }
1698:
1699:         // If this folder is not yet open, we use STATUS to
1700:         // get the new message count
1701:         checkExists();
1702:         try {
1703:          Status status = getStatus();
1704:          return status.recent;
1705:         } catch (BadCommandException bex) {
1706:          // doesn't support STATUS, probably vanilla IMAP4 ..
1707:          // lets try EXAMINE
1708:          IMAPProtocol p = null;
1709:
1710:          try {
1711:                 p = getStoreProtocol();        // XXX
1712:                 MailboxInfo minfo = p.examine(fullName);
1713:                 p.close();
1714:                 return minfo.recent;
1715:          } catch (ProtocolException pex) {
1716:                 // Give up.
1717:                 throw new MessagingException(pex.getMessage(), pex);
1718:          } finally {
1719:                 releaseStoreProtocol(p);
1720:          }
1721:         } catch (ConnectionException cex) {
1722:          throw new StoreClosedException(store, cex.getMessage());
1723:         } catch (ProtocolException pex) {
1724:          throw new MessagingException(pex.getMessage(), pex);
1725:         }
1726: }
1727:
1728: /**
1729: * Get the unread message count.
1730: */
1731: @Override
1732: public synchronized int getUnreadMessageCount()
1733:                         throws MessagingException {
1734:         if (!opened) {
1735:          checkExists();
1736:          // If this folder is not yet open, we use STATUS to
1737:          // get the unseen message count
1738:          try {
1739:                 Status status = getStatus();
1740:                 return status.unseen;
1741:          } catch (BadCommandException bex) {
1742:                 // doesn't support STATUS, probably vanilla IMAP4 ..
1743:                 // Could EXAMINE, SEARCH for UNREAD messages and
1744:                 // return the count .. bah, not worth it.
1745:                 return -1;
1746:          } catch (ConnectionException cex) {
1747:                 throw new StoreClosedException(store, cex.getMessage());
1748:          } catch (ProtocolException pex) {
1749:                 throw new MessagingException(pex.getMessage(), pex);
1750:          }
1751:         }
1752:
1753:         // if opened, issue server-side search for messages that do
1754:         // *not* have the SEEN flag.
1755:         Flags f = new Flags();
1756:         f.add(Flags.Flag.SEEN);
1757:         try {
1758:          synchronized(messageCacheLock) {
1759:                 int[] matches = getProtocol().search(new FlagTerm(f, false));
1760:                 return matches.length; // NOTE: 'matches' is never null
1761:          }
1762:         } catch (ConnectionException cex) {
1763:          throw new FolderClosedException(this, cex.getMessage());
1764:         } catch (ProtocolException pex) {
1765:          // Shouldn't happen
1766:          throw new MessagingException(pex.getMessage(), pex);
1767:         }
1768: }
1769:
1770: /**
1771: * Get the deleted message count.
1772: */
1773: @Override
1774: public synchronized int getDeletedMessageCount()
1775:                         throws MessagingException {
1776:         if (!opened) {
1777:          checkExists();
1778:          // no way to do this on closed folders
1779:          return -1;
1780:         }
1781:
1782:         // if opened, issue server-side search for messages that do
1783:         // have the DELETED flag.
1784:         Flags f = new Flags();
1785:         f.add(Flags.Flag.DELETED);
1786:         try {
1787:          synchronized(messageCacheLock) {
1788:                 int[] matches = getProtocol().search(new FlagTerm(f, true));
1789:                 return matches.length; // NOTE: 'matches' is never null
1790:          }
1791:         } catch (ConnectionException cex) {
1792:          throw new FolderClosedException(this, cex.getMessage());
1793:         } catch (ProtocolException pex) {
1794:          // Shouldn't happen
1795:          throw new MessagingException(pex.getMessage(), pex);
1796:         }
1797: }
1798:
1799: /*
1800: * Get results of STATUS command for this folder, checking cache first.
1801: * ASSERT: Must be called with this folder's synchronization lock held.
1802: * ASSERT: The folder must be closed.
1803: */
1804: private Status getStatus() throws ProtocolException {
1805:         int statusCacheTimeout = ((IMAPStore)store).getStatusCacheTimeout();
1806:
1807:         // if allowed to cache and our cache is still valid, return it
1808:         if (statusCacheTimeout > 0 && cachedStatus != null &&
1809:          System.currentTimeMillis() - cachedStatusTime < statusCacheTimeout)
1810:          return cachedStatus;
1811:
1812: IMAPProtocol p = null;
1813:
1814:         try {
1815:          p = getStoreProtocol();        // XXX
1816:          Status s = p.status(fullName, null);
1817:          // if allowed to cache, do so
1818:          if (statusCacheTimeout > 0) {
1819:                 cachedStatus = s;
1820:                 cachedStatusTime = System.currentTimeMillis();
1821:          }
1822:          return s;
1823: } finally {
1824: releaseStoreProtocol(p);
1825: }
1826: }
1827:
1828: /**
1829: * Get the specified message.
1830: */
1831: @Override
1832: public synchronized Message getMessage(int msgnum)
1833:                 throws MessagingException {
1834:         checkOpened();
1835:         checkRange(msgnum);
1836:
1837:         return messageCache.getMessage(msgnum);
1838: }
1839:
1840: /**
1841: * {@inheritDoc}
1842: */
1843: @Override
1844: public synchronized Message[] getMessages() throws MessagingException {
1845:         /*
1846:          * Need to override Folder method to throw FolderClosedException
1847:          * instead of IllegalStateException if not really closed.
1848:          */
1849:         checkOpened();
1850:         int total = getMessageCount();
1851:         Message[] msgs = new Message[total];
1852:         for (int i = 1; i <= total; i++)
1853:          msgs[i - 1] = messageCache.getMessage(i);
1854:         return msgs;
1855: }
1856:
1857: /**
1858: * Append the given messages into this folder.
1859: */
1860: @Override
1861: public synchronized void appendMessages(Message[] msgs)
1862:                                 throws MessagingException {
1863:         checkExists(); // verify that self exists
1864:
1865:         // XXX - have to verify that messages are in a different
1866:         // store (if any) than target folder, otherwise could
1867:         // deadlock trying to fetch messages on the same connection
1868:         // we're using for the append.
1869:
1870:         int maxsize = ((IMAPStore)store).getAppendBufferSize();
1871:
1872:         for (int i = 0; i < msgs.length; i++) {
1873:          final Message m = msgs[i];
1874:          Date d = m.getReceivedDate(); // retain dates
1875:          if (d == null)
1876:                 d = m.getSentDate();
1877:          final Date dd = d;
1878:          final Flags f = m.getFlags();
1879:
1880:          final MessageLiteral mos;
1881:          try {
1882:                 // if we know the message is too big, don't buffer any of it
1883:                 mos = new MessageLiteral(m,
1884:                                 m.getSize() > maxsize ? 0 : maxsize);
1885:          } catch (IOException ex) {
1886:                 throw new MessagingException(
1887:                                 "IOException while appending messages", ex);
1888:          } catch (MessageRemovedException mrex) {
1889:                 continue; // just skip this expunged message
1890:          }
1891:
1892:          doCommand(new ProtocolCommand() {
1893:                 @Override
1894:                 public Object doCommand(IMAPProtocol p)
1895:                         throws ProtocolException {
1896:                  p.append(fullName, f, dd, mos);
1897:                  return null;
1898:                 }
1899:          });
1900:         }
1901: }
1902:
1903: /**
1904: * Append the given messages into this folder.
1905: * Return array of AppendUID objects containing
1906: * UIDs of these messages in the destination folder.
1907: * Each element of the returned array corresponds to
1908: * an element of the <code>msgs</code> array. A null
1909: * element means the server didn't return UID information
1910: * for the appended message. <p>
1911: *
1912: * Depends on the APPENDUID response code defined by the
1913: * UIDPLUS extension -
1914: * <A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>.
1915: *
1916: * @param        msgs        the messages to append
1917: * @return                array of AppendUID objects
1918: * @exception        MessagingException for failures
1919: * @since        JavaMail 1.4
1920: */
1921: public synchronized AppendUID[] appendUIDMessages(Message[] msgs)
1922:                                 throws MessagingException {
1923:         checkExists(); // verify that self exists
1924:
1925:         // XXX - have to verify that messages are in a different
1926:         // store (if any) than target folder, otherwise could
1927:         // deadlock trying to fetch messages on the same connection
1928:         // we're using for the append.
1929:
1930:         int maxsize = ((IMAPStore)store).getAppendBufferSize();
1931:
1932:         AppendUID[] uids = new AppendUID[msgs.length];
1933:         for (int i = 0; i < msgs.length; i++) {
1934:          final Message m = msgs[i];
1935:          final MessageLiteral mos;
1936:
1937:          try {
1938:                 // if we know the message is too big, don't buffer any of it
1939:                 mos = new MessageLiteral(m,
1940:                                 m.getSize() > maxsize ? 0 : maxsize);
1941:          } catch (IOException ex) {
1942:                 throw new MessagingException(
1943:                                 "IOException while appending messages", ex);
1944:          } catch (MessageRemovedException mrex) {
1945:                 continue; // just skip this expunged message
1946:          }
1947:
1948:          Date d = m.getReceivedDate(); // retain dates
1949:          if (d == null)
1950:                 d = m.getSentDate();
1951:          final Date dd = d;
1952:          final Flags f = m.getFlags();
1953:          AppendUID auid = (AppendUID)doCommand(new ProtocolCommand() {
1954:                 @Override
1955:                 public Object doCommand(IMAPProtocol p)
1956:                         throws ProtocolException {
1957:                  return p.appenduid(fullName, f, dd, mos);
1958:                 }
1959:          });
1960:          uids[i] = auid;
1961:         }
1962:         return uids;
1963: }
1964:
1965: /**
1966: * Append the given messages into this folder.
1967: * Return array of Message objects representing
1968: * the messages in the destination folder. Note
1969: * that the folder must be open.
1970: * Each element of the returned array corresponds to
1971: * an element of the <code>msgs</code> array. A null
1972: * element means the server didn't return UID information
1973: * for the appended message. <p>
1974: *
1975: * Depends on the APPENDUID response code defined by the
1976: * UIDPLUS extension -
1977: * <A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>.
1978: *
1979: * @param        msgs        the messages to add
1980: * @return                the messages in this folder
1981: * @exception        MessagingException for failures
1982: * @since        JavaMail 1.4
1983: */
1984: public synchronized Message[] addMessages(Message[] msgs)
1985:                                 throws MessagingException {
1986:         checkOpened();
1987:         Message[] rmsgs = new MimeMessage[msgs.length];
1988:         AppendUID[] uids = appendUIDMessages(msgs);
1989:         for (int i = 0; i < uids.length; i++) {
1990:          AppendUID auid = uids[i];
1991:          if (auid != null) {
1992:                 if (auid.uidvalidity == uidvalidity) {
1993:                  try {
1994:                         rmsgs[i] = getMessageByUID(auid.uid);
1995:                  } catch (MessagingException mex) {
1996:                         // ignore errors at this stage
1997:                  }
1998:                 }
1999:          }
2000:         }
2001:         return rmsgs;
2002: }
2003:
2004: /**
2005: * Copy the specified messages from this folder, to the
2006: * specified destination.
2007: */
2008: @Override
2009: public synchronized void copyMessages(Message[] msgs, Folder folder)
2010:                         throws MessagingException {
2011:         copymoveMessages(msgs, folder, false);
2012: }
2013:
2014: /**
2015: * Copy the specified messages from this folder, to the
2016: * specified destination.
2017: * Return array of AppendUID objects containing
2018: * UIDs of these messages in the destination folder.
2019: * Each element of the returned array corresponds to
2020: * an element of the <code>msgs</code> array. A null
2021: * element means the server didn't return UID information
2022: * for the copied message. <p>
2023: *
2024: * Depends on the COPYUID response code defined by the
2025: * UIDPLUS extension -
2026: * <A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>.
2027: *
2028: * @param        msgs        the messages to copy
2029: * @param        folder        the folder to copy the messages to
2030: * @return                array of AppendUID objects
2031: * @exception        MessagingException for failures
2032: * @since        JavaMail 1.5.1
2033: */
2034: public synchronized AppendUID[] copyUIDMessages(Message[] msgs,
2035:                         Folder folder) throws MessagingException {
2036:         return copymoveUIDMessages(msgs, folder, false);
2037: }
2038:
2039: /**
2040: * Move the specified messages from this folder, to the
2041: * specified destination.
2042: *
2043: * Depends on the MOVE extension
2044: * (<A HREF="http://www.ietf.org/rfc/rfc6851.txt">RFC 6851</A>).
2045: *
2046: * @param        msgs        the messages to move
2047: * @param        folder        the folder to move the messages to
2048: * @exception        MessagingException for failures
2049: *
2050: * @since        JavaMail 1.5.4
2051: */
2052: public synchronized void moveMessages(Message[] msgs, Folder folder)
2053:                         throws MessagingException {
2054:         copymoveMessages(msgs, folder, true);
2055: }
2056:
2057: /**
2058: * Move the specified messages from this folder, to the
2059: * specified destination.
2060: * Return array of AppendUID objects containing
2061: * UIDs of these messages in the destination folder.
2062: * Each element of the returned array corresponds to
2063: * an element of the <code>msgs</code> array. A null
2064: * element means the server didn't return UID information
2065: * for the moved message. <p>
2066: *
2067: * Depends on the MOVE extension
2068: * (<A HREF="http://www.ietf.org/rfc/rfc6851.txt">RFC 6851</A>)
2069: * and the COPYUID response code defined by the
2070: * UIDPLUS extension
2071: * (<A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>).
2072: *
2073: * @param        msgs        the messages to move
2074: * @param        folder        the folder to move the messages to
2075: * @return                array of AppendUID objects
2076: * @exception        MessagingException for failures
2077: * @since        JavaMail 1.5.4
2078: */
2079: public synchronized AppendUID[] moveUIDMessages(Message[] msgs,
2080:                         Folder folder) throws MessagingException {
2081:         return copymoveUIDMessages(msgs, folder, true);
2082: }
2083:
2084: /**
2085: * Copy or move the specified messages from this folder, to the
2086: * specified destination.
2087: *
2088: * @since        JavaMail 1.5.4
2089: */
2090: private synchronized void copymoveMessages(Message[] msgs, Folder folder,
2091:                         boolean move) throws MessagingException {
2092:         checkOpened();
2093:
2094:         if (msgs.length == 0) // boundary condition
2095:          return;
2096:
2097:         // If the destination belongs to our same store, optimize
2098:         if (folder.getStore() == store) {
2099:          synchronized(messageCacheLock) {
2100:                 try {
2101:                  IMAPProtocol p = getProtocol();
2102:                  MessageSet[] ms = Utility.toMessageSet(msgs, null);
2103:                  if (ms == null)
2104:                         throw new MessageRemovedException(
2105:                                         "Messages have been removed");
2106:                  if (move)
2107:                         p.move(ms, folder.getFullName());
2108:                  else
2109:                         p.copy(ms, folder.getFullName());
2110:                 } catch (CommandFailedException cfx) {
2111:                  if (cfx.getMessage().indexOf("TRYCREATE") != -1)
2112:                         throw new FolderNotFoundException(
2113: folder,
2114:                          folder.getFullName() + " does not exist"
2115:                          );
2116:                  else
2117:                         throw new MessagingException(cfx.getMessage(), cfx);
2118:                 } catch (ConnectionException cex) {
2119:                  throw new FolderClosedException(this, cex.getMessage());
2120:                 } catch (ProtocolException pex) {
2121:                  throw new MessagingException(pex.getMessage(), pex);
2122:                  }
2123:          }
2124:         } else // destination is a different store.
2125:          if (move)
2126:                 throw new MessagingException(
2127:                                         "Move between stores not supported");
2128:          else
2129:                 super.copyMessages(msgs, folder);
2130: }
2131:
2132: /**
2133: * Copy or move the specified messages from this folder, to the
2134: * specified destination.
2135: * Return array of AppendUID objects containing
2136: * UIDs of these messages in the destination folder.
2137: * Each element of the returned array corresponds to
2138: * an element of the <code>msgs</code> array. A null
2139: * element means the server didn't return UID information
2140: * for the copied message. <p>
2141: *
2142: * Depends on the COPYUID response code defined by the
2143: * UIDPLUS extension -
2144: * <A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>.
2145: * Move depends on the MOVE extension -
2146: * <A HREF="http://www.ietf.org/rfc/rfc6851.txt">RFC 6851</A>.
2147: *
2148: * @param        msgs        the messages to copy
2149: * @param        folder        the folder to copy the messages to
2150: * @param        move        move instead of copy?
2151: * @return                array of AppendUID objects
2152: * @exception        MessagingException for failures
2153: * @since        JavaMail 1.5.4
2154: */
2155: private synchronized AppendUID[] copymoveUIDMessages(Message[] msgs,
2156:                         Folder folder, boolean move) throws MessagingException {
2157:         checkOpened();
2158:
2159:         if (msgs.length == 0) // boundary condition
2160:          return null;
2161:
2162:         // the destination must belong to our same store
2163:         if (folder.getStore() != store) // destination is a different store.
2164:          throw new MessagingException(
2165:                         move ?
2166:                         "can't moveUIDMessages to a different store" :
2167:                         "can't copyUIDMessages to a different store");
2168:
2169:         // call fetch to make sure we have all the UIDs
2170:         // necessary to interpret the COPYUID response
2171:         FetchProfile fp = new FetchProfile();
2172:         fp.add(UIDFolder.FetchProfileItem.UID);
2173:         fetch(msgs, fp);
2174:         // XXX - could pipeline the FETCH with the COPY/MOVE below
2175:
2176:         synchronized (messageCacheLock) {
2177:          try {
2178:                 IMAPProtocol p = getProtocol();
2179:                 // XXX - messages have to be from this Folder, who checks?
2180:                 MessageSet[] ms = Utility.toMessageSet(msgs, null);
2181:                 if (ms == null)
2182:                  throw new MessageRemovedException(
2183:                                  "Messages have been removed");
2184:                 CopyUID cuid;
2185:                 if (move)
2186:                  cuid = p.moveuid(ms, folder.getFullName());
2187:                 else
2188:                  cuid = p.copyuid(ms, folder.getFullName());
2189:
2190:                 /*
2191:                  * Correlate source UIDs with destination UIDs.
2192:                  * This won't be time or space efficient if there's
2193:                  * a lot of messages.
2194:                  *
2195:                  * In order to make sense of the returned UIDs, we need
2196:                  * the UIDs for every one of the original messages.
2197:                  * We fetch them above, to make sure we have them.
2198:                  * This is critical for MOVE since after the MOVE the
2199:                  * messages are gone/expunged.
2200:                  *
2201:                  * Assume the common case is that the messages are
2202:                  * in order by UID. Map the returned source
2203:                  * UIDs to their corresponding Message objects.
2204:                  * Step through the msgs array looking for the
2205:                  * Message object in the returned source message
2206:                  * list. Most commonly the source message (UID)
2207:                  * for the Nth original message will be in the Nth
2208:                  * position in the returned source message (UID)
2209:                  * list. Thus, the destination UID is in the Nth
2210:                  * position in the returned destination UID list.
2211:                  * But if the source message isn't where expected,
2212:                  * we have to search the entire source message
2213:                  * list, starting from where we expect it and
2214:                  * wrapping around until we've searched it all.
2215:                  * (Gmail will often return the lists in an unexpected order.)
2216:                  *
2217:                  * A possible optimization:
2218:                  * If the number of UIDs returned is the same as the
2219:                  * number of messages being copied/moved, we could
2220:                  * sort the source messages by message number, sort
2221:                  * the source and destination parallel arrays by source
2222:                  * UID, and the resulting message and destination UID
2223:                  * arrays will correspond.
2224:                  *
2225:                  * If the returned UID array size is different, some
2226:                  * message was expunged while we were trying to copy/move it.
2227:                  * This should be rare but would mean falling back to the
2228:                  * general algorithm.
2229:                  */
2230:                 long[] srcuids = UIDSet.toArray(cuid.src);
2231:                 long[] dstuids = UIDSet.toArray(cuid.dst);
2232:                 // map source UIDs to Message objects
2233:                 // XXX - could inline/optimize this
2234:                 Message[] srcmsgs = getMessagesByUID(srcuids);
2235:                 AppendUID[] result = new AppendUID[msgs.length];
2236:                 for (int i = 0; i < msgs.length; i++) {
2237:                  int j = i;
2238:                  do {
2239:                         if (msgs[i] == srcmsgs[j]) {
2240:                          result[i] = new AppendUID(
2241:                                          cuid.uidvalidity, dstuids[j]);
2242:                          break;
2243:                         }
2244:                         j++;
2245:                         if (j >= srcmsgs.length)
2246:                          j = 0;
2247:                  } while (j != i);
2248:                 }
2249:                 return result;
2250:          } catch (CommandFailedException cfx) {
2251:                 if (cfx.getMessage().indexOf("TRYCREATE") != -1)
2252:                  throw new FolderNotFoundException(
2253:                         folder,
2254:                         folder.getFullName() + " does not exist"
2255:                  );
2256:                 else
2257:                  throw new MessagingException(cfx.getMessage(), cfx);
2258:          } catch (ConnectionException cex) {
2259:                 throw new FolderClosedException(this, cex.getMessage());
2260:          } catch (ProtocolException pex) {
2261:                 throw new MessagingException(pex.getMessage(), pex);
2262:          }
2263:         }
2264: }
2265:
2266: /**
2267: * Expunge all messages marked as DELETED.
2268: */
2269: @Override
2270: public synchronized Message[] expunge() throws MessagingException {
2271:         return expunge(null);
2272: }
2273:
2274: /**
2275: * Expunge the indicated messages, which must have been marked as DELETED.
2276: *
2277: * Depends on the UIDPLUS extension -
2278: * <A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>.
2279: *
2280: * @param        msgs        the messages to expunge
2281: * @return                the expunged messages
2282: * @exception        MessagingException for failures
2283: */
2284: public synchronized Message[] expunge(Message[] msgs)
2285:                                 throws MessagingException {
2286:         checkOpened();
2287:
2288:         if (msgs != null) {
2289:          // call fetch to make sure we have all the UIDs
2290:          FetchProfile fp = new FetchProfile();
2291:          fp.add(UIDFolder.FetchProfileItem.UID);
2292:          fetch(msgs, fp);
2293:         }
2294:
2295:         IMAPMessage[] rmsgs;
2296:         synchronized(messageCacheLock) {
2297:          doExpungeNotification = false; // We do this ourselves later
2298:          try {
2299:                 IMAPProtocol p = getProtocol();
2300:                 if (msgs != null)
2301:                  p.uidexpunge(Utility.toUIDSet(msgs));
2302:                 else
2303:                  p.expunge();
2304:          } catch (CommandFailedException cfx) {
2305:                 // expunge not allowed, perhaps due to a permission problem?
2306:                 if (mode != READ_WRITE)
2307:                  throw new IllegalStateException(
2308:                         "Cannot expunge READ_ONLY folder: " + fullName);
2309:                 else
2310:                  throw new MessagingException(cfx.getMessage(), cfx);
2311:          } catch (ConnectionException cex) {
2312:                 throw new FolderClosedException(this, cex.getMessage());
2313:          } catch (ProtocolException pex) {
2314:                 // Bad bad server ..
2315:                 throw new MessagingException(pex.getMessage(), pex);
2316:          } finally {
2317:                 doExpungeNotification = true;
2318:          }
2319:
2320:          // Cleanup expunged messages and sync messageCache with reality.
2321:          if (msgs != null)
2322:                 rmsgs = messageCache.removeExpungedMessages(msgs);
2323:          else
2324:                 rmsgs = messageCache.removeExpungedMessages();
2325:          if (uidTable != null) {
2326:                 for (int i = 0; i < rmsgs.length; i++) {
2327:                  IMAPMessage m = rmsgs[i];
2328:                  /* remove this message from the UIDTable */
2329:                  long uid = m.getUID();
2330:                  if (uid != -1)
2331:                         uidTable.remove(Long.valueOf(uid));
2332:                 }
2333:          }
2334:
2335:          // Update 'total'
2336:          total = messageCache.size();
2337:         }
2338:
2339:         // Notify listeners. This time its for real, guys.
2340:         if (rmsgs.length > 0)
2341:          notifyMessageRemovedListeners(true, rmsgs);
2342:         return rmsgs;
2343: }
2344:
2345: /**
2346: * Search whole folder for messages matching the given term.
2347: * If the property <code>mail.imap.throwsearchexception</code> is true,
2348: * and the search term is too complex for the IMAP protocol,
2349: * SearchException is thrown. Otherwise, if the search term is too
2350: * complex, <code>super.search</code> is called to do the search on
2351: * the client.
2352: *
2353: * @param        term        the search term
2354: * @return                the messages that match
2355: * @exception        SearchException if mail.imap.throwsearchexception is
2356: *                        true and the search is too complex for the IMAP protocol
2357: * @exception        MessagingException for other failures
2358: */
2359: @Override
2360: public synchronized Message[] search(SearchTerm term)
2361:                                 throws MessagingException {
2362:         checkOpened();
2363:
2364:         try {
2365:          Message[] matchMsgs = null;
2366:
2367:          synchronized(messageCacheLock) {
2368:                 int[] matches = getProtocol().search(term);
2369:                 if (matches != null)
2370:                  matchMsgs = getMessagesBySeqNumbers(matches);
2371:          }
2372:          return matchMsgs;
2373:
2374:         } catch (CommandFailedException cfx) {
2375:          // unsupported charset or search criterion
2376:          return super.search(term);
2377:         } catch (SearchException sex) {
2378:          // too complex for IMAP
2379:          if (((IMAPStore)store).throwSearchException())
2380:                 throw sex;
2381:          return super.search(term);
2382:         } catch (ConnectionException cex) {
2383:          throw new FolderClosedException(this, cex.getMessage());
2384:         } catch (ProtocolException pex) {
2385:          // bug in our IMAP layer ?
2386:          throw new MessagingException(pex.getMessage(), pex);
2387:         }
2388: }
2389:
2390: /**
2391: * Search the folder for messages matching the given term. Returns
2392: * array of matching messages. Returns an empty array if no matching
2393: * messages are found.
2394: */
2395: @Override
2396: public synchronized Message[] search(SearchTerm term, Message[] msgs)
2397:                         throws MessagingException {
2398:         checkOpened();
2399:
2400:         if (msgs.length == 0)
2401:          // need to return an empty array (not null!)
2402:          return msgs;
2403:
2404:         try {
2405:          Message[] matchMsgs = null;
2406:
2407:          synchronized(messageCacheLock) {
2408:                 IMAPProtocol p = getProtocol();
2409:                 MessageSet[] ms = Utility.toMessageSetSorted(msgs, null);
2410:                 if (ms == null)
2411:                  throw new MessageRemovedException(
2412:                                         "Messages have been removed");
2413:                 int[] matches = p.search(ms, term);
2414:                 if (matches != null)
2415:                  matchMsgs = getMessagesBySeqNumbers(matches);
2416:          }
2417:          return matchMsgs;
2418:
2419:         } catch (CommandFailedException cfx) {
2420:          // unsupported charset or search criterion
2421:          return super.search(term, msgs);
2422:         } catch (SearchException sex) {
2423:          // too complex for IMAP
2424:          return super.search(term, msgs);
2425:         } catch (ConnectionException cex) {
2426:          throw new FolderClosedException(this, cex.getMessage());
2427:         } catch (ProtocolException pex) {
2428:          // bug in our IMAP layer ?
2429:          throw new MessagingException(pex.getMessage(), pex);
2430:         }
2431: }
2432:
2433: /**
2434: * Sort the messages in the folder according to the sort criteria.
2435: * The messages are returned in the sorted order, but the order of
2436: * the messages in the folder is not changed. <p>
2437: *
2438: * Depends on the SORT extension -
2439: * <A HREF="http://www.ietf.org/rfc/rfc5256.txt">RFC 5256</A>.
2440: *
2441: * @param        term        the SortTerms
2442: * @return                the messages in sorted order
2443: * @exception        MessagingException for failures
2444: * @since JavaMail 1.4.4
2445: */
2446: public synchronized Message[] getSortedMessages(SortTerm[] term)
2447:                                 throws MessagingException {
2448:         return getSortedMessages(term, null);
2449: }
2450:
2451: /**
2452: * Sort the messages in the folder according to the sort criteria.
2453: * The messages are returned in the sorted order, but the order of
2454: * the messages in the folder is not changed. Only messages matching
2455: * the search criteria are considered. <p>
2456: *
2457: * Depends on the SORT extension -
2458: * <A HREF="http://www.ietf.org/rfc/rfc5256.txt">RFC 5256</A>.
2459: *
2460: * @param        term        the SortTerms
2461: * @param        sterm        the SearchTerm
2462: * @return                the messages in sorted order
2463: * @exception        MessagingException for failures
2464: * @since JavaMail 1.4.4
2465: */
2466: public synchronized Message[] getSortedMessages(SortTerm[] term,
2467:                                 SearchTerm sterm) throws MessagingException {
2468:         checkOpened();
2469:
2470:         try {
2471:          Message[] matchMsgs = null;
2472:
2473:          synchronized(messageCacheLock) {
2474:                 int[] matches = getProtocol().sort(term, sterm);
2475:                 if (matches != null)
2476:                  matchMsgs = getMessagesBySeqNumbers(matches);
2477:          }
2478:          return matchMsgs;
2479:
2480:         } catch (CommandFailedException cfx) {
2481:          // unsupported charset or search criterion
2482:          throw new MessagingException(cfx.getMessage(), cfx);
2483:         } catch (SearchException sex) {
2484:          // too complex for IMAP
2485:          throw new MessagingException(sex.getMessage(), sex);
2486:         } catch (ConnectionException cex) {
2487:          throw new FolderClosedException(this, cex.getMessage());
2488:         } catch (ProtocolException pex) {
2489:          // bug in our IMAP layer ?
2490:          throw new MessagingException(pex.getMessage(), pex);
2491:         }
2492: }
2493:
2494: /*
2495: * Override Folder method to keep track of whether we have any
2496: * message count listeners. Normally we won't have any, so we
2497: * can avoid creating message objects to pass to the notify
2498: * method. It's too hard to keep track of when all listeners
2499: * are removed, and that's a rare case, so we don't try.
2500: */
2501: @Override
2502: public synchronized void addMessageCountListener(MessageCountListener l) {
2503:         super.addMessageCountListener(l);
2504:         hasMessageCountListener = true;
2505: }
2506:
2507: /***********************************************************
2508: *                UIDFolder interface methods
2509: **********************************************************/
2510:
2511: /**
2512: * Returns the UIDValidity for this folder.
2513: */
2514: @Override
2515: public synchronized long getUIDValidity() throws MessagingException {
2516:         if (opened) // we already have this information
2517:          return uidvalidity;
2518:
2519: IMAPProtocol p = null;
2520: Status status = null;
2521:
2522:         try {
2523:          p = getStoreProtocol();        // XXX
2524:          String[] item = { "UIDVALIDITY" };
2525:          status = p.status(fullName, item);
2526:         } catch (BadCommandException bex) {
2527:          // Probably a RFC1730 server
2528:          throw new MessagingException("Cannot obtain UIDValidity", bex);
2529:         } catch (ConnectionException cex) {
2530: // Oops, the store or folder died on us.
2531: throwClosedException(cex);
2532:         } catch (ProtocolException pex) {
2533:          throw new MessagingException(pex.getMessage(), pex);
2534:         } finally {
2535: releaseStoreProtocol(p);
2536: }
2537:
2538:         if (status == null)
2539:          throw new MessagingException("Cannot obtain UIDValidity");
2540:         return status.uidvalidity;
2541: }
2542:
2543: /**
2544: * Returns the predicted UID that will be assigned to the
2545: * next message that is appended to this folder.
2546: * If the folder is closed, the STATUS command is used to
2547: * retrieve this value. If the folder is open, the value
2548: * returned from the SELECT or EXAMINE command is returned.
2549: * Note that messages may have been appended to the folder
2550: * while it was open and thus this value may be out of
2551: * date. <p>
2552: *
2553: * Servers implementing RFC2060 likely won't return this value
2554: * when a folder is opened. Servers implementing RFC3501
2555: * should return this value when a folder is opened. <p>
2556: *
2557: * @return        the UIDNEXT value, or -1 if unknown
2558: * @exception        MessagingException for failures
2559: * @since        JavaMail 1.3.3
2560: */
2561: @Override
2562: public synchronized long getUIDNext() throws MessagingException {
2563:         if (opened) // we already have this information
2564:          return uidnext;
2565:
2566: IMAPProtocol p = null;
2567: Status status = null;
2568:
2569:         try {
2570:          p = getStoreProtocol();        // XXX
2571:          String[] item = { "UIDNEXT" };
2572:          status = p.status(fullName, item);
2573:         } catch (BadCommandException bex) {
2574:          // Probably a RFC1730 server
2575:          throw new MessagingException("Cannot obtain UIDNext", bex);
2576:         } catch (ConnectionException cex) {
2577: // Oops, the store or folder died on us.
2578: throwClosedException(cex);
2579:         } catch (ProtocolException pex) {
2580:          throw new MessagingException(pex.getMessage(), pex);
2581:         } finally {
2582: releaseStoreProtocol(p);
2583: }
2584:
2585:         if (status == null)
2586:          throw new MessagingException("Cannot obtain UIDNext");
2587:         return status.uidnext;
2588: }
2589:
2590: /**
2591: * Get the Message corresponding to the given UID.
2592: * If no such message exists, <code> null </code> is returned.
2593: */
2594: @Override
2595: public synchronized Message getMessageByUID(long uid)
2596:                         throws MessagingException {
2597:         checkOpened(); // insure folder is open
2598:
2599:         IMAPMessage m = null;
2600:
2601:         try {
2602:          synchronized(messageCacheLock) {
2603:                 Long l = Long.valueOf(uid);
2604:
2605:                 if (uidTable != null) {
2606:                  // Check in uidTable
2607:                  m = uidTable.get(l);
2608:                  if (m != null) // found it
2609:                         return m;
2610:                 } else
2611:                  uidTable = new Hashtable<>();
2612:
2613:                 // Check with the server
2614:                 // Issue UID FETCH command
2615:                 getProtocol().fetchSequenceNumber(uid);
2616:
2617:                 if (uidTable != null) {
2618:                  // Check in uidTable
2619:                  m = uidTable.get(l);
2620:                  if (m != null) // found it
2621:                         return m;
2622:                 }
2623:          }
2624:         } catch(ConnectionException cex) {
2625:          throw new FolderClosedException(this, cex.getMessage());
2626:         } catch (ProtocolException pex) {
2627:          throw new MessagingException(pex.getMessage(), pex);
2628:         }
2629:
2630:         return m;
2631: }
2632:
2633: /**
2634: * Get the Messages specified by the given range. <p>
2635: * Returns Message objects for all valid messages in this range.
2636: * Returns an empty array if no messages are found.
2637: */
2638: @Override
2639: public synchronized Message[] getMessagesByUID(long start, long end)
2640:                         throws MessagingException {
2641:         checkOpened(); // insure that folder is open
2642:
2643:         Message[] msgs; // array of messages to be returned
2644:
2645:         try {
2646:          synchronized(messageCacheLock) {
2647:                 if (uidTable == null)
2648:                  uidTable = new Hashtable<>();
2649:
2650:                 // Issue UID FETCH for given range
2651:                 long[] ua = getProtocol().fetchSequenceNumbers(start, end);
2652:
2653:                 List<Message> ma = new ArrayList<>();
2654:                 // NOTE: Below must be within messageCacheLock region
2655:                 for (int i = 0; i < ua.length; i++) {
2656:                  Message m = uidTable.get(Long.valueOf(ua[i]));
2657:                  if (m != null) // found it
2658:                         ma.add(m);
2659:                 }
2660:                 msgs = ma.toArray(new Message[ma.size()]);
2661:          }
2662:         } catch(ConnectionException cex) {
2663:          throw new FolderClosedException(this, cex.getMessage());
2664:         } catch (ProtocolException pex) {
2665:          throw new MessagingException(pex.getMessage(), pex);
2666:         }
2667:
2668:         return msgs;
2669: }
2670:
2671: /**
2672: * Get the Messages specified by the given array. <p>
2673: *
2674: * <code>uids.length()</code> elements are returned.
2675: * If any UID in the array is invalid, a <code>null</code> entry
2676: * is returned for that element.
2677: */
2678: @Override
2679: public synchronized Message[] getMessagesByUID(long[] uids)
2680:                         throws MessagingException {
2681:         checkOpened(); // insure that folder is open
2682:
2683:         try {
2684:          synchronized(messageCacheLock) {
2685:                 long[] unavailUids = uids;
2686:                 if (uidTable != null) {
2687:                  // to collect unavailable UIDs
2688:                  List<Long> v = new ArrayList<>();
2689:                  for (long uid : uids) {
2690:                         if (!uidTable.containsKey(uid)) {
2691:                          // This UID has not been loaded yet.
2692:                          v.add(uid);
2693:                         }
2694:                  }
2695:
2696:                  int vsize = v.size();
2697:                  unavailUids = new long[vsize];
2698:                  for (int i = 0; i < vsize; i++) {
2699:                         unavailUids[i] = v.get(i);
2700:                  }
2701:                 } else
2702:                  uidTable = new Hashtable<>();
2703:
2704:                 if (unavailUids.length > 0) {
2705:                  // Issue UID FETCH request for given uids
2706:                  getProtocol().fetchSequenceNumbers(unavailUids);
2707:                 }
2708:
2709:                 // Return array of size = uids.length
2710:                 Message[] msgs = new Message[uids.length];
2711:                 for (int i = 0; i < uids.length; i++)
2712:                  msgs[i] = (Message)uidTable.get(Long.valueOf(uids[i]));
2713:                 return msgs;
2714:          }
2715:         } catch(ConnectionException cex) {
2716:          throw new FolderClosedException(this, cex.getMessage());
2717:         } catch (ProtocolException pex) {
2718:          throw new MessagingException(pex.getMessage(), pex);
2719:         }
2720: }
2721:
2722: /**
2723: * Get the UID for the specified message.
2724: */
2725: @Override
2726: public synchronized long getUID(Message message)
2727:                         throws MessagingException {
2728:         if (message.getFolder() != this)
2729:          throw new NoSuchElementException(
2730:                 "Message does not belong to this folder");
2731:
2732:         checkOpened(); // insure that folder is open
2733:
2734:         if (!(message instanceof IMAPMessage))
2735:          throw new MessagingException("message is not an IMAPMessage");
2736:         IMAPMessage m = (IMAPMessage)message;
2737:         // If the message already knows its UID, great ..
2738:         long uid;
2739:         if ((uid = m.getUID()) != -1)
2740:          return uid;
2741:
2742:         synchronized(messageCacheLock) { // Acquire Lock
2743:          try {
2744:                 IMAPProtocol p = getProtocol();
2745:                 m.checkExpunged(); // insure that message is not expunged
2746:                 UID u = p.fetchUID(m.getSequenceNumber());
2747:
2748:                 if (u != null) {
2749:                  uid = u.uid;
2750:                  m.setUID(uid); // set message's UID
2751:
2752:                  // insert this message into uidTable
2753:                  if (uidTable == null)
2754:                         uidTable = new Hashtable<>();
2755:                  uidTable.put(Long.valueOf(uid), m);
2756:                 }
2757:          } catch (ConnectionException cex) {
2758:                 throw new FolderClosedException(this, cex.getMessage());
2759:          } catch (ProtocolException pex) {
2760:                 throw new MessagingException(pex.getMessage(), pex);
2761:          }
2762:         }
2763:
2764:         return uid;
2765: }
2766:
2767: /**
2768: * Servers that support the UIDPLUS extension
2769: * (<A HREF="http://www.ietf.org/rfc/rfc4315.txt">RFC 4315</A>)
2770: * may indicate that this folder does not support persistent UIDs;
2771: * that is, UIDVALIDITY will be different each time the folder is
2772: * opened. Only valid when the folder is open.
2773: *
2774: * @return        true if UIDs are not sticky
2775: * @exception        MessagingException for failures
2776: * @exception        IllegalStateException        if the folder isn't open
2777: * @see "RFC 4315"
2778: * @since        JavaMail 1.6.0
2779: */
2780: public synchronized boolean getUIDNotSticky() throws MessagingException {
2781:         checkOpened();
2782:         return uidNotSticky;
2783: }
2784:
2785: /**
2786: * Get or create Message objects for the UIDs.
2787: */
2788: private Message[] createMessagesForUIDs(long[] uids) {
2789:         IMAPMessage[] msgs = new IMAPMessage[uids.length];
2790:         for (int i = 0; i < uids.length; i++) {
2791:          IMAPMessage m = null;
2792:          if (uidTable != null)
2793:                 m = uidTable.get(Long.valueOf(uids[i]));
2794:          if (m == null) {
2795:                 // fake it, we don't know what message this really is
2796:                 m = newIMAPMessage(-1);        // no sequence number
2797:                 m.setUID(uids[i]);
2798:                 m.setExpunged(true);
2799:          }
2800:          msgs[i++] = m;
2801:         }
2802:         return msgs;
2803: }
2804:
2805: /**
2806: * Returns the HIGHESTMODSEQ for this folder.
2807: *
2808: * @return        the HIGHESTMODSEQ value
2809: * @exception        MessagingException for failures
2810: * @see "RFC 4551"
2811: * @since        JavaMail 1.5.1
2812: */
2813: public synchronized long getHighestModSeq() throws MessagingException {
2814:         if (opened) // we already have this information
2815:          return highestmodseq;
2816:
2817: IMAPProtocol p = null;
2818: Status status = null;
2819:
2820:         try {
2821:          p = getStoreProtocol();        // XXX
2822:          if (!p.hasCapability("CONDSTORE"))
2823:                 throw new BadCommandException("CONDSTORE not supported");
2824:          String[] item = { "HIGHESTMODSEQ" };
2825:          status = p.status(fullName, item);
2826:         } catch (BadCommandException bex) {
2827:          // Probably a RFC1730 server
2828:          throw new MessagingException("Cannot obtain HIGHESTMODSEQ", bex);
2829:         } catch (ConnectionException cex) {
2830: // Oops, the store or folder died on us.
2831: throwClosedException(cex);
2832:         } catch (ProtocolException pex) {
2833:          throw new MessagingException(pex.getMessage(), pex);
2834:         } finally {
2835: releaseStoreProtocol(p);
2836: }
2837:
2838:         if (status == null)
2839:          throw new MessagingException("Cannot obtain HIGHESTMODSEQ");
2840:         return status.highestmodseq;
2841: }
2842:
2843: /**
2844: * Get the messages that have been changed since the given MODSEQ value.
2845: * Also, prefetch the flags for the messages. <p>
2846: *
2847: * The server must support the CONDSTORE extension.
2848: *
2849: * @param        start        the first message number
2850: * @param        end        the last message number
2851: * @param        modseq        the MODSEQ value
2852: * @return        the changed messages
2853: * @exception        MessagingException for failures
2854: * @see "RFC 4551"
2855: * @since        JavaMail 1.5.1
2856: */
2857: public synchronized Message[] getMessagesByUIDChangedSince(
2858:                                 long start, long end, long modseq)
2859:                                 throws MessagingException {
2860:         checkOpened(); // insure that folder is open
2861:
2862:         try {
2863:          synchronized (messageCacheLock) {
2864:                 IMAPProtocol p = getProtocol();
2865:                 if (!p.hasCapability("CONDSTORE"))
2866:                  throw new BadCommandException("CONDSTORE not supported");
2867:
2868:                 // Issue FETCH for given range
2869:                 int[] nums = p.uidfetchChangedSince(start, end, modseq);
2870:                 return getMessagesBySeqNumbers(nums);
2871:          }
2872:         } catch(ConnectionException cex) {
2873:          throw new FolderClosedException(this, cex.getMessage());
2874:         } catch (ProtocolException pex) {
2875:          throw new MessagingException(pex.getMessage(), pex);
2876:         }
2877: }
2878:
2879: /**
2880: * Get the quotas for the quotaroot associated with this
2881: * folder. Note that many folders may have the same quotaroot.
2882: * Quotas are controlled on the basis of a quotaroot, not
2883: * (necessarily) a folder. The relationship between folders
2884: * and quotaroots depends on the IMAP server. Some servers
2885: * might implement a single quotaroot for all folders owned by
2886: * a user. Other servers might implement a separate quotaroot
2887: * for each folder. A single folder can even have multiple
2888: * quotaroots, perhaps controlling quotas for different
2889: * resources.
2890: *
2891: * @return        array of Quota objects for the quotaroots associated with
2892: *                this folder
2893: * @exception MessagingException        if the server doesn't support the
2894: *                                        QUOTA extension
2895: */
2896: public Quota[] getQuota() throws MessagingException {
2897:         return (Quota[])doOptionalCommand("QUOTA not supported",
2898:          new ProtocolCommand() {
2899:                 @Override
2900:                 public Object doCommand(IMAPProtocol p)
2901:                         throws ProtocolException {
2902:                  return p.getQuotaRoot(fullName);
2903:                 }
2904:          });
2905: }
2906:
2907: /**
2908: * Set the quotas for the quotaroot specified in the quota argument.
2909: * Typically this will be one of the quotaroots associated with this
2910: * folder, as obtained from the <code>getQuota</code> method, but it
2911: * need not be.
2912: *
2913: * @param        quota        the quota to set
2914: * @exception MessagingException        if the server doesn't support the
2915: *                                        QUOTA extension
2916: */
2917: public void setQuota(final Quota quota) throws MessagingException {
2918:         doOptionalCommand("QUOTA not supported",
2919:          new ProtocolCommand() {
2920:                 @Override
2921:                 public Object doCommand(IMAPProtocol p)
2922:                         throws ProtocolException {
2923:                  p.setQuota(quota);
2924:                  return null;
2925:                 }
2926:          });
2927: }
2928:
2929: /**
2930: * Get the access control list entries for this folder.
2931: *
2932: * @return        array of access control list entries
2933: * @exception MessagingException        if the server doesn't support the
2934: *                                        ACL extension
2935: */
2936: public ACL[] getACL() throws MessagingException {
2937:         return (ACL[])doOptionalCommand("ACL not supported",
2938:          new ProtocolCommand() {
2939:                 @Override
2940:                 public Object doCommand(IMAPProtocol p)
2941:                         throws ProtocolException {
2942:                  return p.getACL(fullName);
2943:                 }
2944:          });
2945: }
2946:
2947: /**
2948: * Add an access control list entry to the access control list
2949: * for this folder.
2950: *
2951: * @param        acl        the access control list entry to add
2952: * @exception MessagingException        if the server doesn't support the
2953: *                                        ACL extension
2954: */
2955: public void addACL(ACL acl) throws MessagingException {
2956:         setACL(acl, '\0');
2957: }
2958:
2959: /**
2960: * Remove any access control list entry for the given identifier
2961: * from the access control list for this folder.
2962: *
2963: * @param        name        the identifier for which to remove all ACL entries
2964: * @exception MessagingException        if the server doesn't support the
2965: *                                        ACL extension
2966: */
2967: public void removeACL(final String name) throws MessagingException {
2968:         doOptionalCommand("ACL not supported",
2969:          new ProtocolCommand() {
2970:                 @Override
2971:                 public Object doCommand(IMAPProtocol p)
2972:                         throws ProtocolException {
2973:                  p.deleteACL(fullName, name);
2974:                  return null;
2975:                 }
2976:          });
2977: }
2978:
2979: /**
2980: * Add the rights specified in the ACL to the entry for the
2981: * identifier specified in the ACL. If an entry for the identifier
2982: * doesn't already exist, add one.
2983: *
2984: * @param        acl        the identifer and rights to add
2985: * @exception MessagingException        if the server doesn't support the
2986: *                                        ACL extension
2987: */
2988: public void addRights(ACL acl) throws MessagingException {
2989:         setACL(acl, '+');
2990: }
2991:
2992: /**
2993: * Remove the rights specified in the ACL from the entry for the
2994: * identifier specified in the ACL.
2995: *
2996: * @param        acl        the identifer and rights to remove
2997: * @exception MessagingException        if the server doesn't support the
2998: *                                        ACL extension
2999: */
3000: public void removeRights(ACL acl) throws MessagingException {
3001:         setACL(acl, '-');
3002: }
3003:
3004: /**
3005: * Get all the rights that may be allowed to the given identifier.
3006: * Rights are grouped per RFC 2086 and each group is returned as an
3007: * element of the array. The first element of the array is the set
3008: * of rights that are always granted to the identifier. Later
3009: * elements are rights that may be optionally granted to the
3010: * identifier. <p>
3011: *
3012: * Note that this method lists the rights that it is possible to
3013: * assign to the given identifier, <em>not</em> the rights that are
3014: * actually granted to the given identifier. For the latter, see
3015: * the <code>getACL</code> method.
3016: *
3017: * @param        name        the identifier to list rights for
3018: * @return                array of Rights objects representing possible
3019: *                        rights for the identifier
3020: * @exception MessagingException        if the server doesn't support the
3021: *                                        ACL extension
3022: */
3023: public Rights[] listRights(final String name) throws MessagingException {
3024:         return (Rights[])doOptionalCommand("ACL not supported",
3025:          new ProtocolCommand() {
3026:                 @Override
3027:                 public Object doCommand(IMAPProtocol p)
3028:                         throws ProtocolException {
3029:                  return p.listRights(fullName, name);
3030:                 }
3031:          });
3032: }
3033:
3034: /**
3035: * Get the rights allowed to the currently authenticated user.
3036: *
3037: * @return        the rights granted to the current user
3038: * @exception MessagingException        if the server doesn't support the
3039: *                                        ACL extension
3040: */
3041: public Rights myRights() throws MessagingException {
3042:         return (Rights)doOptionalCommand("ACL not supported",
3043:          new ProtocolCommand() {
3044:                 @Override
3045:                 public Object doCommand(IMAPProtocol p)
3046:                         throws ProtocolException {
3047:                  return p.myRights(fullName);
3048:                 }
3049:          });
3050: }
3051:
3052: private void setACL(final ACL acl, final char mod)
3053:                                 throws MessagingException {
3054:         doOptionalCommand("ACL not supported",
3055:          new ProtocolCommand() {
3056:                 @Override
3057:                 public Object doCommand(IMAPProtocol p)
3058:                         throws ProtocolException {
3059:                  p.setACL(fullName, mod, acl);
3060:                  return null;
3061:                 }
3062:          });
3063: }
3064:
3065: /**
3066: * Get the attributes that the IMAP server returns with the
3067: * LIST response.
3068: *
3069: * @return        array of attributes for this folder
3070: * @exception        MessagingException for failures
3071: * @since        JavaMail 1.3.3
3072: */
3073: public synchronized String[] getAttributes() throws MessagingException {
3074:         checkExists();
3075:         if (attributes == null)
3076:          exists();                // do a LIST to set the attributes
3077:         return attributes == null ? new String[0] : attributes.clone();
3078: }
3079:
3080: /**
3081: * Use the IMAP IDLE command (see
3082: * <A HREF="http://www.ietf.org/rfc/rfc2177.txt">RFC 2177</A>),
3083: * if supported by the server, to enter idle mode so that the server
3084: * can send unsolicited notifications of new messages arriving, etc.
3085: * without the need for the client to constantly poll the server.
3086: * Use an appropriate listener to be notified of new messages or
3087: * other events. When another thread (e.g., the listener thread)
3088: * needs to issue an IMAP comand for this folder, the idle mode will
3089: * be terminated and this method will return. Typically the caller
3090: * will invoke this method in a loop. <p>
3091: *
3092: * The mail.imap.minidletime property enforces a minimum delay
3093: * before returning from this method, to ensure that other threads
3094: * have a chance to issue commands before the caller invokes this
3095: * method again. The default delay is 10 milliseconds.
3096: *
3097: * @exception MessagingException        if the server doesn't support the
3098: *                                        IDLE extension
3099: * @exception IllegalStateException        if the folder isn't open
3100: *
3101: * @since        JavaMail 1.4.1
3102: */
3103: public void idle() throws MessagingException {
3104:         idle(false);
3105: }
3106:
3107: /**
3108: * Like {@link #idle}, but if <code>once</code> is true, abort the
3109: * IDLE command after the first notification, to allow the caller
3110: * to process any notification synchronously.
3111: *
3112: * @param        once        only do one notification?
3113: * @exception MessagingException        if the server doesn't support the
3114: *                                        IDLE extension
3115: * @exception IllegalStateException        if the folder isn't open
3116: *
3117: * @since        JavaMail 1.4.3
3118: */
3119: public void idle(boolean once) throws MessagingException {
3120:         synchronized (this) {
3121:          /*
3122:          * We can't support the idle method if we're using SocketChannels
3123:          * because SocketChannels don't allow simultaneous read and write.
3124:          * If we're blocked in a read waiting for IDLE responses, we can't
3125:          * send the DONE message to abort the IDLE. Sigh.
3126:          * XXX - We could do select here too, like IdleManager, instead
3127:          * of blocking in read, but that's more complicated.
3128:          */
3129:          if (protocol != null && protocol.getChannel() != null)
3130:                 throw new MessagingException(
3131:                          "idle method not supported with SocketChannels");
3132:         }
3133:         if (!startIdle(null))
3134:          return;
3135:
3136:         /*
3137:          * We gave up the folder lock so that other threads
3138:          * can get into the folder far enough to see that we're
3139:          * in IDLE and abort the IDLE.
3140:          *
3141:          * Now we read responses from the IDLE command, especially
3142:          * including unsolicited notifications from the server.
3143:          * We don't hold the messageCacheLock while reading because
3144:          * it protects the idleState and other threads need to be
3145:          * able to examine the state.
3146:          *
3147:          * The messageCacheLock is held in handleIdle while processing
3148:          * the responses so that we can update the number of messages
3149:          * in the folder (for example).
3150:          */
3151:         for (;;) {
3152:          if (!handleIdle(once))
3153:                 break;
3154:         }
3155:
3156:         /*
3157:          * Enforce a minimum delay to give time to threads
3158:          * processing the responses that came in while we
3159:          * were idle.
3160:          */
3161:         int minidle = ((IMAPStore)store).getMinIdleTime();
3162:         if (minidle > 0) {
3163:          try {
3164:                 Thread.sleep(minidle);
3165:          } catch (InterruptedException ex) {
3166:                 // restore the interrupted state, which callers might depend on
3167:                 Thread.currentThread().interrupt();
3168:          }
3169:         }
3170: }
3171:
3172: /**
3173: * Start the IDLE command and put this folder into the IDLE state.
3174: * IDLE processing is done later in handleIdle(), e.g., called from
3175: * the IdleManager.
3176: *
3177: * @return        true if IDLE started, false otherwise
3178: * @exception MessagingException        if the server doesn't support the
3179: *                                        IDLE extension
3180: * @exception IllegalStateException        if the folder isn't open
3181: * @since        JavaMail 1.5.2
3182: */
3183: boolean startIdle(final IdleManager im) throws MessagingException {
3184:         // ASSERT: Must NOT be called with this folder's
3185:         // synchronization lock held.
3186:         assert !Thread.holdsLock(this);
3187:         synchronized(this) {
3188:          checkOpened();
3189:          if (im != null && idleManager != null && im != idleManager)
3190:                 throw new MessagingException(
3191:                  "Folder already being watched by another IdleManager");
3192:          Boolean started = (Boolean)doOptionalCommand("IDLE not supported",
3193:                 new ProtocolCommand() {
3194:                  @Override
3195:                  public Object doCommand(IMAPProtocol p)
3196:                          throws ProtocolException {
3197:                         // if the IdleManager is already watching this folder,
3198:                         // there's nothing to do here
3199:                         if (idleState == IDLE &&
3200:                                 im != null && im == idleManager)
3201:                          return Boolean.TRUE;        // already watching it
3202:                         if (idleState == RUNNING) {
3203:                          p.idleStart();
3204:                          logger.finest("startIdle: set to IDLE");
3205:                          idleState = IDLE;
3206:                          idleManager = im;
3207:                          return Boolean.TRUE;
3208:                         } else {
3209:                          // some other thread must be running the IDLE
3210:                          // command, we'll just wait for it to finish
3211:                          // without aborting it ourselves
3212:                          try {
3213:                                 // give up lock and wait to be not idle
3214:                                 messageCacheLock.wait();
3215:                          } catch (InterruptedException ex) {
3216:                                 // restore the interrupted state, which callers
3217:                                 // might depend on
3218:                                 Thread.currentThread().interrupt();
3219:                          }
3220:                          return Boolean.FALSE;
3221:                         }
3222:                  }
3223:                 });
3224:          logger.log(Level.FINEST, "startIdle: return {0}", started);
3225:          return started.booleanValue();
3226:         }
3227: }
3228:
3229: /**
3230: * Read a response from the server while we're in the IDLE state.
3231: * We hold the messageCacheLock while processing the
3232: * responses so that we can update the number of messages
3233: * in the folder (for example).
3234: *
3235: * @param        once        only do one notification?
3236: * @return        true if we should look for more IDLE responses,
3237: *                false if IDLE is done
3238: * @exception MessagingException        for errors
3239: * @since        JavaMail 1.5.2
3240: */
3241: boolean handleIdle(boolean once) throws MessagingException {
3242:         Response r = null;
3243:         do {
3244:          r = protocol.readIdleResponse();
3245:          try {
3246:                 synchronized (messageCacheLock) {
3247:                  if (r.isBYE() && r.isSynthetic() && idleState == IDLE) {
3248:                         /*
3249:                          * If it was a timeout and no bytes were transferred
3250:                          * we ignore it and go back and read again.
3251:                          * If the I/O was otherwise interrupted, and no
3252:                          * bytes were transferred, we take it as a request
3253:                          * to abort the IDLE.
3254:                          */
3255:                         Exception ex = r.getException();
3256:                         if (ex instanceof InterruptedIOException &&
3257:                          ((InterruptedIOException)ex).
3258:                                  bytesTransferred == 0) {
3259:                          if (ex instanceof SocketTimeoutException) {
3260:                                 logger.finest(
3261:                                  "handleIdle: ignoring socket timeout");
3262:                                 r = null;        // repeat do/while loop
3263:                          } else {
3264:                                 logger.finest("handleIdle: interrupting IDLE");
3265:                                 IdleManager im = idleManager;
3266:                                 if (im != null) {
3267:                                  logger.finest(
3268:                                  "handleIdle: request IdleManager to abort");
3269:                                  im.requestAbort(this);
3270:                                 } else {
3271:                                  logger.finest("handleIdle: abort IDLE");
3272:                                  protocol.idleAbort();
3273:                                  idleState = ABORTING;
3274:                                 }
3275:                                 // normally will exit the do/while loop
3276:                          }
3277:                          continue;
3278:                         }
3279:                  }
3280:                  boolean done = true;
3281:                  try {
3282:                         if (protocol == null ||
3283:                                 !protocol.processIdleResponse(r))
3284:                          return false;        // done
3285:                         done = false;
3286:                  } finally {
3287:                         if (done) {
3288:                          logger.finest("handleIdle: set to RUNNING");
3289:                          idleState = RUNNING;
3290:                          idleManager = null;
3291:                          messageCacheLock.notifyAll();
3292:                         }
3293:                  }
3294:                  if (once) {
3295:                         if (idleState == IDLE) {
3296:                          try {
3297:                                 protocol.idleAbort();
3298:                          } catch (Exception ex) {
3299:                                 // ignore any failures, still have to abort.
3300:                                 // connection failures will be detected above
3301:                                 // in the call to readIdleResponse.
3302:                          }
3303:                          idleState = ABORTING;
3304:                         }
3305:                  }
3306:                 }
3307:          } catch (ConnectionException cex) {
3308:                 // Oops, the folder died on us.
3309:                 throw new FolderClosedException(this, cex.getMessage());
3310:          } catch (ProtocolException pex) {
3311:                 throw new MessagingException(pex.getMessage(), pex);
3312:          }
3313:         // keep processing responses already in our buffer
3314:         } while (r == null || protocol.hasResponse());
3315:         return true;
3316: }
3317:
3318: /*
3319: * If an IDLE command is in progress, abort it if necessary,
3320: * and wait until it completes.
3321: * ASSERT: Must be called with the message cache lock held.
3322: */
3323: void waitIfIdle() throws ProtocolException {
3324:         assert Thread.holdsLock(messageCacheLock);
3325:         while (idleState != RUNNING) {
3326:          if (idleState == IDLE) {
3327:                 IdleManager im = idleManager;
3328:                 if (im != null) {
3329:                  logger.finest("waitIfIdle: request IdleManager to abort");
3330:                  im.requestAbort(this);
3331:                 } else {
3332:                  logger.finest("waitIfIdle: abort IDLE");
3333:                  protocol.idleAbort();
3334:                  idleState = ABORTING;
3335:                 }
3336:          } else
3337:                 logger.log(Level.FINEST, "waitIfIdle: idleState {0}", idleState);
3338:          try {
3339:                 // give up lock and wait to be not idle
3340:                 if (logger.isLoggable(Level.FINEST))
3341:                  logger.finest("waitIfIdle: wait to be not idle: " +
3342:                                  Thread.currentThread());
3343:                 messageCacheLock.wait();
3344:                 if (logger.isLoggable(Level.FINEST))
3345:                  logger.finest("waitIfIdle: wait done, idleState " +
3346:                                  idleState + ": " + Thread.currentThread());
3347:          } catch (InterruptedException ex) {
3348:                 // restore the interrupted state, which callers might depend on
3349:                 Thread.currentThread().interrupt();
3350:                 // If someone is trying to interrupt us we can't keep going
3351:                 // around the loop waiting for IDLE to complete, but we can't
3352:                 // just return because callers expect the idleState to be
3353:                 // RUNNING when we return. Throwing this exception seems
3354:                 // like the best choice.
3355:                 throw new ProtocolException("Interrupted waitIfIdle", ex);
3356:          }
3357:         }
3358: }
3359:
3360: /*
3361: * Send the DONE command that aborts the IDLE; used by IdleManager.
3362: */
3363: void idleAbort() {
3364:         synchronized (messageCacheLock) {
3365:          if (idleState == IDLE && protocol != null) {
3366:                 protocol.idleAbort();
3367:                 idleState = ABORTING;
3368:          }
3369:         }
3370: }
3371:
3372: /*
3373: * Send the DONE command that aborts the IDLE and wait for the response;
3374: * used by IdleManager.
3375: */
3376: void idleAbortWait() {
3377:         synchronized (messageCacheLock) {
3378:          if (idleState == IDLE && protocol != null) {
3379:                 protocol.idleAbort();
3380:                 idleState = ABORTING;
3381:
3382:                 // read responses until OK or connection failure
3383:                 try {
3384:                  for (;;) {
3385:                         if (!handleIdle(false))
3386:                          break;
3387:                  }
3388:                 } catch (Exception ex) {
3389:                  // assume it's a connection failure; nothing more to do
3390:                  logger.log(Level.FINEST, "Exception in idleAbortWait", ex);
3391:                 }
3392:                 logger.finest("IDLE aborted");
3393:          }
3394:         }
3395: }
3396:
3397: /**
3398: * Return the SocketChannel for this connection, if any, for use
3399: * in IdleManager.
3400: */
3401: SocketChannel getChannel() {
3402:         return protocol != null ? protocol.getChannel() : null;
3403: }
3404:
3405: /**
3406: * Send the IMAP ID command (if supported by the server) and return
3407: * the result from the server. The ID command identfies the client
3408: * to the server and returns information about the server to the client.
3409: * See <A HREF="http://www.ietf.org/rfc/rfc2971.txt">RFC 2971</A>.
3410: * The returned Map is unmodifiable.
3411: *
3412: * @param        clientParams        a Map of keys and values identifying the client
3413: * @return                        a Map of keys and values identifying the server
3414: * @exception MessagingException        if the server doesn't support the
3415: *                                        ID extension
3416: * @since        JavaMail 1.5.1
3417: */
3418: @SuppressWarnings("unchecked")
3419: public Map<String, String> id(final Map<String, String> clientParams)
3420:                                 throws MessagingException {
3421:         checkOpened();
3422:         return (Map<String,String>)doOptionalCommand("ID not supported",
3423:          new ProtocolCommand() {
3424:                 @Override
3425:                 public Object doCommand(IMAPProtocol p)
3426:                         throws ProtocolException {
3427:                  return p.id(clientParams);
3428:                 }
3429:          });
3430: }
3431:
3432: /**
3433: * Use the IMAP STATUS command to get the indicated item.
3434: * The STATUS item may be a standard item such as "RECENT" or "UNSEEN",
3435: * or may be a server-specific item.
3436: * The folder must be closed. If the item is not found, or the
3437: * folder is open, -1 is returned.
3438: *
3439: * @param        item        the STATUS item to fetch
3440: * @return                the value of the STATUS item, or -1
3441: * @exception MessagingException        for errors
3442: * @since        JavaMail 1.5.2
3443: */
3444: public synchronized long getStatusItem(String item)
3445:                                 throws MessagingException {
3446:         if (!opened) {
3447:          checkExists();
3448:
3449:          IMAPProtocol p = null;
3450:          Status status = null;
3451:          try {
3452:                 p = getStoreProtocol();        // XXX
3453:                 String[] items = { item };
3454:                 status = p.status(fullName, items);
3455:                 return status != null ? status.getItem(item) : -1;
3456:          } catch (BadCommandException bex) {
3457:                 // doesn't support STATUS, probably vanilla IMAP4 ..
3458:                 // Could EXAMINE, SEARCH for UNREAD messages and
3459:                 // return the count .. bah, not worth it.
3460:                 return -1;
3461:          } catch (ConnectionException cex) {
3462:                 throw new StoreClosedException(store, cex.getMessage());
3463:          } catch (ProtocolException pex) {
3464:                 throw new MessagingException(pex.getMessage(), pex);
3465:          } finally {
3466:                 releaseStoreProtocol(p);
3467:          }
3468:         }
3469:         return -1;
3470: }
3471:
3472: /**
3473: * The response handler. This is the callback routine that is
3474: * invoked by the protocol layer.
3475: */
3476: /*
3477: * ASSERT: This method must be called only when holding the
3478: * messageCacheLock.
3479: * ASSERT: This method must *not* invoke any other method that
3480: * might grab the 'folder' lock or 'message' lock (i.e., any
3481: * synchronized methods on IMAPFolder or IMAPMessage)
3482: * since that will result in violating the locking hierarchy.
3483: */
3484: @Override
3485: public void handleResponse(Response r) {
3486:         assert Thread.holdsLock(messageCacheLock);
3487:
3488:         /*
3489:          * First, delegate possible ALERT or notification to the Store.
3490:          */
3491:         if (r.isOK() || r.isNO() || r.isBAD() || r.isBYE())
3492:          ((IMAPStore)store).handleResponseCode(r);
3493:
3494:         /*
3495:          * Now check whether this is a BYE or OK response and
3496:          * handle appropriately.
3497:          */
3498:         if (r.isBYE()) {
3499:          if (opened)                // XXX - accessed without holding folder lock
3500:                 cleanup(false);
3501:          return;
3502:         } else if (r.isOK()) {
3503:          // HIGHESTMODSEQ can be updated on any OK response
3504:          r.skipSpaces();
3505:          if (r.readByte() == '[') {
3506:                 String s = r.readAtom();
3507:                 if (s.equalsIgnoreCase("HIGHESTMODSEQ"))
3508:                  highestmodseq = r.readLong();
3509:          }
3510:          r.reset();
3511:          return;
3512:         } else if (!r.isUnTagged()) {
3513:          return;        // might be a continuation for IDLE
3514:         }
3515:
3516:         /* Now check whether this is an IMAP specific response */
3517:         if (!(r instanceof IMAPResponse)) {
3518:          // Probably a bug in our code !
3519:          // XXX - should be an assert
3520:          logger.fine("UNEXPECTED RESPONSE : " + r.toString());
3521:          return;
3522:         }
3523:
3524:         IMAPResponse ir = (IMAPResponse)r;
3525:
3526:         if (ir.keyEquals("EXISTS")) { // EXISTS
3527:          int exists = ir.getNumber();
3528:          if (exists <= realTotal)
3529:                 // Could be the EXISTS following EXPUNGE, ignore 'em
3530:                 return;
3531:         
3532:          int count = exists - realTotal; // number of new messages
3533:          Message[] msgs = new Message[count];
3534:
3535:          // Add 'count' new IMAPMessage objects into the messageCache
3536:          messageCache.addMessages(count, realTotal + 1);
3537:          int oldtotal = total;        // used in loop below
3538:          realTotal += count;
3539:          total += count;
3540:
3541:          // avoid instantiating Message objects if no listeners.
3542:          if (hasMessageCountListener) {
3543:                 for (int i = 0; i < count; i++)
3544:                  msgs[i] = messageCache.getMessage(++oldtotal);
3545:
3546:                 // Notify listeners.
3547:                 notifyMessageAddedListeners(msgs);
3548:          }
3549:
3550:         } else if (ir.keyEquals("EXPUNGE")) {
3551:          // EXPUNGE response.
3552:
3553:          int seqnum = ir.getNumber();
3554:          if (seqnum > realTotal) {
3555:                 // A message was expunged that we never knew about.
3556:                 // Exchange will do this. Just ignore the notification.
3557:                 // (Alternatively, we could simulate an EXISTS for the
3558:                 // expunged message before expunging it.)
3559:                 return;
3560:          }
3561:          Message[] msgs = null;
3562:          if (doExpungeNotification && hasMessageCountListener) {
3563:                 // save the Message object first; can't look it
3564:                 // up after it's expunged
3565:                 msgs = new Message[] { getMessageBySeqNumber(seqnum) };
3566:                 if (msgs[0] == null)        // XXX - should never happen
3567:                  msgs = null;
3568:          }
3569:
3570:          messageCache.expungeMessage(seqnum);
3571:
3572:          // decrement 'realTotal'; but leave 'total' unchanged
3573:          realTotal--;
3574:
3575:          if (msgs != null)        // Do the notification here.
3576:                 notifyMessageRemovedListeners(false, msgs);
3577:
3578:         } else if (ir.keyEquals("VANISHED")) {
3579:          // after the folder is opened with QRESYNC, a VANISHED response
3580:          // without the (EARLIER) tag is used instead of the EXPUNGE
3581:          // response
3582:
3583:          // "VANISHED" SP ["(EARLIER)"] SP known-uids
3584:          String[] s = ir.readAtomStringList();
3585:          if (s == null) {        // no (EARLIER)
3586:                 String uids = ir.readAtom();
3587:                 UIDSet[] uidset = UIDSet.parseUIDSets(uids);
3588:                 // assume no duplicates and no UIDs out of range
3589:                 realTotal -= UIDSet.size(uidset);
3590:                 long[] luid = UIDSet.toArray(uidset);
3591:                 Message[] msgs = createMessagesForUIDs(luid);
3592:                 for (Message m : msgs) {
3593:                  if (m.getMessageNumber() > 0)
3594:                         messageCache.expungeMessage(m.getMessageNumber());
3595:                 }
3596:                 if (doExpungeNotification && hasMessageCountListener) {
3597:                  notifyMessageRemovedListeners(true, msgs);
3598:                 }
3599:          } // else if (EARLIER), ignore
3600:
3601:         } else if (ir.keyEquals("FETCH")) {
3602:          assert ir instanceof FetchResponse : "!ir instanceof FetchResponse";
3603:          Message msg = processFetchResponse((FetchResponse)ir);
3604:          if (msg != null)
3605:                 notifyMessageChangedListeners(
3606:                         MessageChangedEvent.FLAGS_CHANGED, msg);
3607:
3608:         } else if (ir.keyEquals("RECENT")) {
3609:          // update 'recent'
3610:          recent = ir.getNumber();
3611:         }
3612: }
3613:
3614: /**
3615: * Process a FETCH response.
3616: * The only unsolicited FETCH response that makes sense
3617: * to me (for now) is FLAGS updates, which might include
3618: * UID and MODSEQ information. Ignore any other junk.
3619: */
3620: private Message processFetchResponse(FetchResponse fr) {
3621:         IMAPMessage msg = getMessageBySeqNumber(fr.getNumber());
3622:         if (msg != null) {        // should always be true
3623:          boolean notify = false;
3624:
3625:          UID uid = fr.getItem(UID.class);
3626:          if (uid != null && msg.getUID() != uid.uid) {
3627:                 msg.setUID(uid.uid);
3628:                 if (uidTable == null)
3629:                  uidTable = new Hashtable<>();
3630:                 uidTable.put(Long.valueOf(uid.uid), msg);
3631:                 notify = true;
3632:          }
3633:
3634:          MODSEQ modseq = fr.getItem(MODSEQ.class);
3635:          if (modseq != null && msg._getModSeq() != modseq.modseq) {
3636:                 msg.setModSeq(modseq.modseq);
3637:                 /*
3638:                  * XXX - should we update the folder's HIGHESTMODSEQ or not?
3639:                  *
3640:                 if (modseq.modseq > highestmodseq)
3641:                  highestmodseq = modseq.modseq;
3642:                  */
3643:                 notify = true;
3644:          }
3645:
3646:          // Get FLAGS response, if present
3647:          FLAGS flags = fr.getItem(FLAGS.class);
3648:          if (flags != null) {
3649:                 msg._setFlags(flags);        // assume flags changed
3650:                 notify = true;
3651:          }
3652:
3653:          // handle any extension items that might've changed
3654:          // XXX - no notifications associated with extension items
3655:          msg.handleExtensionFetchItems(fr.getExtensionItems());
3656:
3657:          if (!notify)
3658:                 msg = null;
3659:         }
3660:         return msg;
3661: }
3662:
3663: /**
3664: * Handle the given array of Responses.
3665: *
3666: * ASSERT: This method must be called only when holding the
3667: *         messageCacheLock
3668: */
3669: void handleResponses(Response[] r) {
3670:         for (int i = 0; i < r.length; i++) {
3671:          if (r[i] != null)
3672:                 handleResponse(r[i]);
3673:         }
3674: }
3675:
3676: /**
3677: * Get this folder's Store's protocol connection.
3678: *
3679: * When acquiring a store protocol object, it is important to
3680: * use the following steps:
3681: *
3682: * <blockquote><pre>
3683: * IMAPProtocol p = null;
3684: * try {
3685: * p = getStoreProtocol();
3686: * // perform the command
3687: * } catch (WhateverException ex) {
3688: * // handle it
3689: * } finally {
3690: * releaseStoreProtocol(p);
3691: * }
3692: * </pre></blockquote>
3693: *
3694: * ASSERT: Must be called with this folder's synchronization lock held.
3695: *
3696: * @return        the IMAPProtocol for the Store's connection
3697: * @exception        ProtocolException for protocol errors
3698: */
3699: protected synchronized IMAPProtocol getStoreProtocol()
3700: throws ProtocolException {
3701:         connectionPoolLogger.fine("getStoreProtocol() borrowing a connection");
3702:         return ((IMAPStore)store).getFolderStoreProtocol();
3703: }
3704:
3705: /**
3706: * Throw the appropriate 'closed' exception.
3707: *
3708: * @param        cex        the ConnectionException
3709: * @exception        FolderClosedException if the folder is closed
3710: * @exception        StoreClosedException if the store is closed
3711: */
3712: protected synchronized void throwClosedException(ConnectionException cex)
3713: throws FolderClosedException, StoreClosedException {
3714:         // If it's the folder's protocol object, throw a FolderClosedException;
3715:         // otherwise, throw a StoreClosedException.
3716:         // If a command has failed because the connection is closed,
3717:         // the folder will have already been forced closed by the
3718:         // time we get here and our protocol object will have been
3719:         // released, so if we no longer have a protocol object we base
3720:         // this decision on whether we *think* the folder is open.
3721:         if ((protocol != null && cex.getProtocol() == protocol) ||
3722:                 (protocol == null && !reallyClosed))
3723: throw new FolderClosedException(this, cex.getMessage());
3724: else
3725: throw new StoreClosedException(store, cex.getMessage());
3726: }
3727:
3728: /**
3729: * Return the IMAPProtocol object for this folder. <p>
3730: *
3731: * This method will block if necessary to wait for an IDLE
3732: * command to finish.
3733: *
3734: * @return        the IMAPProtocol object used when the folder is open
3735: * @exception        ProtocolException for protocol errors
3736: */
3737: protected IMAPProtocol getProtocol() throws ProtocolException {
3738:         assert Thread.holdsLock(messageCacheLock);
3739:         waitIfIdle();
3740:         // if we no longer have a protocol object after waiting, it probably
3741:         // means the connection has been closed due to a communnication error,
3742:         // or possibly because the folder has been closed
3743:         if (protocol == null)
3744:          throw new ConnectionException("Connection closed");
3745: return protocol;
3746: }
3747:
3748: /**
3749: * A simple interface for user-defined IMAP protocol commands.
3750: */
3751: public static interface ProtocolCommand {
3752:         /**
3753:          * Execute the user-defined command using the supplied IMAPProtocol
3754:          * object.
3755:          *
3756:          * @param        protocol        the IMAPProtocol for the connection
3757:          * @return                        the results of the command
3758:          * @exception        ProtocolException for protocol errors
3759:          */
3760:         public Object doCommand(IMAPProtocol protocol) throws ProtocolException;
3761: }
3762:
3763: /**
3764: * Execute a user-supplied IMAP command. The command is executed
3765: * in the appropriate context with the necessary locks held and
3766: * using the appropriate <code>IMAPProtocol</code> object. <p>
3767: *
3768: * This method returns whatever the <code>ProtocolCommand</code>
3769: * object's <code>doCommand</code> method returns. If the
3770: * <code>doCommand</code> method throws a <code>ConnectionException</code>
3771: * it is translated into a <code>StoreClosedException</code> or
3772: * <code>FolderClosedException</code> as appropriate. If the
3773: * <code>doCommand</code> method throws a <code>ProtocolException</code>
3774: * it is translated into a <code>MessagingException</code>. <p>
3775: *
3776: * The following example shows how to execute the IMAP NOOP command.
3777: * Executing more complex IMAP commands requires intimate knowledge
3778: * of the <code>org.eclipse.angus.mail.iap</code> and
3779: * <code>org.eclipse.angus.mail.imap.protocol</code> packages, best acquired by
3780: * reading the source code.
3781: *
3782: * <blockquote><pre>
3783: * import org.eclipse.angus.mail.iap.*;
3784: * import org.eclipse.angus.mail.imap.*;
3785: * import org.eclipse.angus.mail.imap.protocol.*;
3786: *
3787: * ...
3788: *
3789: * IMAPFolder f = (IMAPFolder)folder;
3790: * Object val = f.doCommand(new IMAPFolder.ProtocolCommand() {
3791: *        public Object doCommand(IMAPProtocol p)
3792: *                        throws ProtocolException {
3793: *         p.simpleCommand("NOOP", null);
3794: *         return null;
3795: *        }
3796: * });
3797: * </pre></blockquote>
3798: * <p>
3799: *
3800: * Here's a more complex example showing how to use the proposed
3801: * IMAP SORT extension:
3802: *
3803: * <blockquote><pre>
3804: * import org.eclipse.angus.mail.iap.*;
3805: * import org.eclipse.angus.mail.imap.*;
3806: * import org.eclipse.angus.mail.imap.protocol.*;
3807: *
3808: * ...
3809: *
3810: * IMAPFolder f = (IMAPFolder)folder;
3811: * Object val = f.doCommand(new IMAPFolder.ProtocolCommand() {
3812: *        public Object doCommand(IMAPProtocol p)
3813: *                        throws ProtocolException {
3814: *         // Issue command
3815: *         Argument args = new Argument();
3816: *         Argument list = new Argument();
3817: *         list.writeString("SUBJECT");
3818: *         args.writeArgument(list);
3819: *         args.writeString("UTF-8");
3820: *         args.writeString("ALL");
3821: *         Response[] r = p.command("SORT", args);
3822: *         Response response = r[r.length-1];
3823: *
3824: *         // Grab response
3825: *         Vector v = new Vector();
3826: *         if (response.isOK()) { // command succesful
3827: *                for (int i = 0, len = r.length; i < len; i++) {
3828: *                 if (!(r[i] instanceof IMAPResponse))
3829: *                        continue;
3830: *
3831: *                 IMAPResponse ir = (IMAPResponse)r[i];
3832: *                 if (ir.keyEquals("SORT")) {
3833: *                        String num;
3834: *                        while ((num = ir.readAtomString()) != null)
3835: *                         System.out.println(num);
3836: *                        r[i] = null;
3837: *                 }
3838: *                }
3839: *         }
3840: *
3841: *         // dispatch remaining untagged responses
3842: *         p.notifyResponseHandlers(r);
3843: *         p.handleResult(response);
3844: *
3845: *         return null;
3846: *        }
3847: * });
3848: * </pre></blockquote>
3849: *
3850: * @param        cmd        the protocol command
3851: * @return                the result of the command
3852: * @exception        MessagingException for failures
3853: */
3854: public Object doCommand(ProtocolCommand cmd) throws MessagingException {
3855:         try {
3856:          return doProtocolCommand(cmd);
3857:         } catch (ConnectionException cex) {
3858: // Oops, the store or folder died on us.
3859: throwClosedException(cex);
3860:         } catch (ProtocolException pex) {
3861:          throw new MessagingException(pex.getMessage(), pex);
3862:         }
3863:         return null;
3864: }
3865:
3866: public Object doOptionalCommand(String err, ProtocolCommand cmd)
3867:                                 throws MessagingException {
3868:         try {
3869:          return doProtocolCommand(cmd);
3870:         } catch (BadCommandException bex) {
3871:          throw new MessagingException(err, bex);
3872:         } catch (ConnectionException cex) {
3873: // Oops, the store or folder died on us.
3874: throwClosedException(cex);
3875:         } catch (ProtocolException pex) {
3876:          throw new MessagingException(pex.getMessage(), pex);
3877:         }
3878:         return null;
3879: }
3880:
3881: public Object doCommandIgnoreFailure(ProtocolCommand cmd)
3882:                                 throws MessagingException {
3883:         try {
3884:          return doProtocolCommand(cmd);
3885:         } catch (CommandFailedException cfx) {
3886:          return null;
3887:         } catch (ConnectionException cex) {
3888: // Oops, the store or folder died on us.
3889: throwClosedException(cex);
3890:         } catch (ProtocolException pex) {
3891:          throw new MessagingException(pex.getMessage(), pex);
3892:         }
3893:         return null;
3894: }
3895:
3896: protected synchronized Object doProtocolCommand(ProtocolCommand cmd)
3897:                                 throws ProtocolException {
3898:         /*
3899:          * Check whether we have a protocol object, not whether we're
3900:          * opened, to allow use of the exsting protocol object in the
3901:          * open method before the state is changed to "opened".
3902:          */
3903:         if (protocol != null) {
3904:          synchronized (messageCacheLock) {
3905:                 return cmd.doCommand(getProtocol());
3906:          }
3907:         }
3908:
3909:         // only get here if using store's connection
3910:         IMAPProtocol p = null;
3911:
3912:         try {
3913: p = getStoreProtocol();
3914:          return cmd.doCommand(p);
3915:         } finally {
3916:          releaseStoreProtocol(p);
3917:         }
3918: }
3919:
3920: /**
3921: * Release the store protocol object. If we borrowed a protocol
3922: * object from the connection pool, give it back. If we used our
3923: * own protocol object, nothing to do.
3924: *
3925: * ASSERT: Must be called with this folder's synchronization lock held.
3926: *
3927: * @param        p        the IMAPProtocol object
3928: */
3929: protected synchronized void releaseStoreProtocol(IMAPProtocol p) {
3930: if (p != protocol)
3931: ((IMAPStore)store).releaseFolderStoreProtocol(p);
3932:         else {
3933:          // XXX - should never happen
3934:          logger.fine("releasing our protocol as store protocol?");
3935:         }
3936: }
3937:
3938: /**
3939: * Release the protocol object.
3940: *
3941: * ASSERT: This method must be called only when holding the
3942: * messageCacheLock
3943: *
3944: * @param        returnToPool        return the protocol object to the pool?
3945: */
3946: protected void releaseProtocol(boolean returnToPool) {
3947: if (protocol != null) {
3948: protocol.removeResponseHandler(this);
3949:
3950: if (returnToPool)
3951: ((IMAPStore)store).releaseProtocol(this, protocol);
3952: else {
3953:                 protocol.disconnect();        // make sure it's disconnected
3954: ((IMAPStore)store).releaseProtocol(this, null);
3955:          }
3956:          protocol = null;
3957: }
3958: }
3959:
3960: /**
3961: * Issue a noop command for the connection if the connection has not been
3962: * used in more than a second. If <code>keepStoreAlive</code> is true,
3963: * also issue a noop over the store's connection.
3964: *
3965: * ASSERT: This method must be called only when holding the
3966: * messageCacheLock
3967: *
3968: * @param        keepStoreAlive        keep the Store alive too?
3969: * @exception        ProtocolException for protocol errors
3970: */
3971: protected void keepConnectionAlive(boolean keepStoreAlive)
3972: throws ProtocolException {
3973:
3974:         assert Thread.holdsLock(messageCacheLock);
3975:         if (protocol == null)        // in case connection was closed
3976:          return;
3977: if (System.currentTimeMillis() - protocol.getTimestamp() > 1000) {
3978:          waitIfIdle();
3979:          if (protocol != null)
3980:                 protocol.noop();
3981:         }
3982:
3983: if (keepStoreAlive && ((IMAPStore)store).hasSeparateStoreConnection()) {
3984: IMAPProtocol p = null;
3985:          try {
3986:                 p = ((IMAPStore)store).getFolderStoreProtocol();
3987:                 if (System.currentTimeMillis() - p.getTimestamp() > 1000)
3988:                  p.noop();
3989:          } finally {
3990:                 ((IMAPStore)store).releaseFolderStoreProtocol(p);
3991:          }
3992: }
3993: }
3994:
3995: /**
3996: * Get the message object for the given sequence number. If
3997: * none found, null is returned.
3998: *
3999: * ASSERT: This method must be called only when holding the
4000: * messageCacheLock
4001: *
4002: * @param        seqnum        the message sequence number
4003: * @return        the IMAPMessage object
4004: */
4005: protected IMAPMessage getMessageBySeqNumber(int seqnum) {
4006:         if (seqnum > messageCache.size()) {
4007:          // Microsoft Exchange will sometimes return message
4008:          // numbers that it has not yet notified the client
4009:          // about via EXISTS; ignore those messages here.
4010:          // GoDaddy IMAP does this too.
4011:          if (logger.isLoggable(Level.FINE))
4012:                 logger.fine("ignoring message number " +
4013:                  seqnum + " outside range " + messageCache.size());
4014:          return null;
4015:         }
4016:         return messageCache.getMessageBySeqnum(seqnum);
4017: }
4018:
4019: /**
4020: * Get the message objects for the given sequence numbers.
4021: *
4022: * ASSERT: This method must be called only when holding the
4023: * messageCacheLock
4024: *
4025: * @param        seqnums        the array of message sequence numbers
4026: * @return        the IMAPMessage objects
4027: * @since        JavaMail 1.5.3
4028: */
4029: protected IMAPMessage[] getMessagesBySeqNumbers(int[] seqnums) {
4030:         IMAPMessage[] msgs = new IMAPMessage[seqnums.length];
4031:         int nulls = 0;
4032:         // Map seq-numbers into actual Messages.
4033:         for (int i = 0; i < seqnums.length; i++) {
4034:          msgs[i] = getMessageBySeqNumber(seqnums[i]);
4035:          if (msgs[i] == null)
4036:                 nulls++;
4037:         }
4038:         if (nulls > 0) {        // compress the array to remove the nulls
4039:          IMAPMessage[] nmsgs = new IMAPMessage[seqnums.length - nulls];
4040:          for (int i = 0, j = 0; i < msgs.length; i++) {
4041:                 if (msgs[i] != null)
4042:                  nmsgs[j++] = msgs[i];
4043:          }
4044:          msgs = nmsgs;
4045:         }
4046:         return msgs;
4047: }
4048:
4049: private boolean isDirectory() {
4050:         return ((type & HOLDS_FOLDERS) != 0);
4051: }
4052: }
4053:
4054: /**
4055: * An object that holds a Message object
4056: * and reports its size and writes it to another OutputStream
4057: * on demand. Used by appendMessages to avoid the need to
4058: * buffer the entire message in memory in a single byte array
4059: * before sending it to the server.
4060: */
4061: class MessageLiteral implements Literal {
4062: private Message msg;
4063: private int msgSize = -1;
4064: private byte[] buf;                // the buffered message, if not null
4065:
4066: public MessageLiteral(Message msg, int maxsize)
4067:                                 throws MessagingException, IOException {
4068:         this.msg = msg;
4069:         // compute the size here so exceptions can be returned immediately
4070:         LengthCounter lc = new LengthCounter(maxsize);
4071:         OutputStream os = new CRLFOutputStream(lc);
4072:         msg.writeTo(os);
4073:         os.flush();
4074:         msgSize = lc.getSize();
4075:         buf = lc.getBytes();
4076: }
4077:
4078: @Override
4079: public int size() {
4080:         return msgSize;
4081: }
4082:
4083: @Override
4084: public void writeTo(OutputStream os) throws IOException {
4085:         // the message should not change between the constructor and this call
4086:         try {
4087:          if (buf != null)
4088:                 os.write(buf, 0, msgSize);
4089:          else {
4090:                 os = new CRLFOutputStream(os);
4091:                 msg.writeTo(os);
4092:          }
4093:         } catch (MessagingException mex) {
4094:          // exceptions here are bad, "should" never happen
4095:          throw new IOException("MessagingException while appending message: "
4096:                                  + mex);
4097:         }
4098: }
4099: }
4100:
4101: /**
4102: * Count the number of bytes written to the stream.
4103: * Also, save a copy of small messages to avoid having to process
4104: * the data again.
4105: */
4106: class LengthCounter extends OutputStream {
4107: private int size = 0;
4108: private byte[] buf;
4109: private int maxsize;
4110:
4111: public LengthCounter(int maxsize) {
4112:         buf = new byte[8192];
4113:         this.maxsize = maxsize;
4114: }
4115:
4116: @Override
4117: public void write(int b) {
4118:         int newsize = size + 1;
4119:•        if (buf != null) {
4120:•         if (newsize > maxsize && maxsize >= 0) {
4121:                 buf = null;
4122:•         } else if (newsize > buf.length) {
4123:                 byte newbuf[] = new byte[Math.max(buf.length << 1, newsize)];
4124:                 System.arraycopy(buf, 0, newbuf, 0, size);
4125:                 buf = newbuf;
4126:                 buf[size] = (byte)b;
4127:          } else {
4128:                 buf[size] = (byte)b;
4129:          }
4130:         }
4131:         size = newsize;
4132: }
4133:
4134: @Override
4135: public void write(byte b[], int off, int len) {
4136:•        if ((off < 0) || (off > b.length) || (len < 0) ||
4137: ((off + len) > b.length) || ((off + len) < 0)) {
4138:          throw new IndexOutOfBoundsException();
4139:•        } else if (len == 0) {
4140:          return;
4141:         }
4142: int newsize = size + len;
4143:•        if (buf != null) {
4144:•         if (newsize > maxsize && maxsize >= 0) {
4145:                 buf = null;
4146:•         } else if (newsize > buf.length) {
4147:                 byte newbuf[] = new byte[Math.max(buf.length << 1, newsize)];
4148:                 System.arraycopy(buf, 0, newbuf, 0, size);
4149:                 buf = newbuf;
4150:                 System.arraycopy(b, off, buf, size, len);
4151:          } else {
4152:                 System.arraycopy(b, off, buf, size, len);
4153:          }
4154:         }
4155: size = newsize;
4156: }
4157:
4158: @Override
4159: public void write(byte[] b) throws IOException {
4160:         write(b, 0, b.length);
4161: }
4162:
4163: public int getSize() {
4164:         return size;
4165: }
4166:
4167: public byte[] getBytes() {
4168:         return buf;
4169: }
4170: }