Java > Open Source Codes > org > apache > james > fetchmail > MessageProcessor


1 /***********************************************************************
2  * Copyright (c) 2003-2004 The Apache Software Foundation. *
3  * All rights reserved. *
4  * ------------------------------------------------------------------- *
5  * Licensed under the Apache License, Version 2.0 (the "License"); you *
6  * may not use this file except in compliance with the License. You *
7  * may obtain a copy of the License at: *
8  * *
9  * http://www.apache.org/licenses/LICENSE-2.0 *
10  * *
11  * Unless required by applicable law or agreed to in writing, software *
12  * distributed under the License is distributed on an "AS IS" BASIS, *
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or *
14  * implied. See the License for the specific language governing *
15  * permissions and limitations under the License. *
16  ***********************************************************************/
17  
18 package org.apache.james.fetchmail;
19
20 import java.io.InputStream;
21 import java.net.InetAddress;
22 import java.net.UnknownHostException;
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.Enumeration;
26 import java.util.Iterator;
27 import java.util.StringTokenizer;
28
29 import javax.mail.Address;
30 import javax.mail.Flags;
31 import javax.mail.Folder;
32 import javax.mail.MessagingException;
33 import javax.mail.Session;
34 import javax.mail.internet.InternetAddress;
35 import javax.mail.internet.InternetHeaders;
36 import javax.mail.internet.MimeMessage;
37 import javax.mail.internet.ParseException;
38
39 import org.apache.james.core.MailImpl;
40 import org.apache.james.util.RFC2822Headers;
41 import org.apache.mailet.Mail;
42 import org.apache.mailet.MailAddress;
43
44 /**
45  * <p>Class <code>MessageProcessor</code> handles the delivery of
46  * <code>MimeMessages</code> to the James input spool.</p>
47  *
48  * <p>Messages written to the input spool always have the following Mail
49  * Attributes set:</p>
50  * <dl>
51  * <dt>org.apache.james.fetchmail.taskName (java.lang.String)</dt>
52  * <dd>The name of the fetch task that processed the message</dd>
53  * <dt>org.apache.james.fetchmail.folderName (java.lang.String)</dt>
54  * <dd>The name of the folder from which the message was fetched</dd>
55  * </dl>
56  *
57  * <p>Messages written to the input spool have the following Mail Attributes
58  * set if the corresponding condition is satisfied:
59  * <dl>
60  * <dt>org.apache.james.fetchmail.isBlacklistedRecipient</dt>
61  * <dd>The recipient is in the configured blacklist</dd>
62  * <dt>org.apache.james.fetchmail.isMaxMessageSizeExceeded (java.lang.String)</dt>
63  * <dd>The message size exceeds the configured limit. An empty message is
64  * written to the input spool. The Mail Attribute value is a String
65  * representing the size of the original message in bytes.</dd>
66  * <dt>org.apache.james.fetchmail.isRecipientNotFound</dt>
67  * <dd>The recipient could not be found. Delivery is to the configured recipient.
68  * See the discussion of delivery to a sole intended recipient below.</dd>
69  * <dt>org.apache.james.fetchmail.isRemoteRecievedHeaderInvalid</dt>
70  * <dd>The Receieved header at the index specified by parameter
71  * <code>remoteReceivedHeaderIndex</code> is invalid.</dd>
72  * <dt>org.apache.james.fetchmail.isRemoteRecipient</dt>
73  * <dd>The recipient is on a remote host</dd>
74  * <dt>org.apache.james.fetchmail.isUserUndefined</dt>
75  * <dd>The recipient is on a localhost but not defined to James</dd>
76  * </dl>
77  *
78  * <p>Configuration settings -
79  * see <code>org.apache.james.fetchmail.ParsedConfiguration</code>
80  * - control the messages that are written to the James input spool, those that
81  * are rejected and what happens to messages that are rejected.</p>
82  *
83  * <p>Rejection processing is based on the following filters:</p>
84  * <dl>
85  * <dt>RejectRemoteRecipient</dt>
86  * <dd>Rejects recipients on remote hosts</dd>
87  * <dt>RejectBlacklistedRecipient</dt>
88  * <dd>Rejects recipients configured in a blacklist</dd>
89  * <dt>RejectUserUndefined</dt>
90  * <dd>Rejects recipients on local hosts who are not defined as James users</dd>
91  * <dt>RejectRecipientNotFound</dt>
92  * <dd>See the discussion of delivery to a sole intended recipient below</dd>
93  * <dt>RejectMaxMessageSizeExceeded</dt>
94  * <dd>Rejects messages whose size exceeds the configured limit</dd>
95  * <dt>RejectRemoteReceievedHeaderInvalid</dt>
96  * <dd>Rejects messages whose Received header is invalid.</dd>
97  * </dl>
98  *
99  * <p>Rejection processing is intentionally limited to managing the status of the
100  * messages that are rejected on the server from which they were fetched. View
101  * it as a simple automation of the manual processing an end-user would perform
102  * through a mail client. Messages may be marked as seen or be deleted.</p>
103  *
104  * <p>Further processing can be achieved by configuring to disable rejection for
105  * one or more filters. This enables Messages that would have been rejected to
106  * be written to the James input spool. The conditional Mail Attributes
107  * described above identify the filter states. The Matcher/Mailet chain can
108  * then be used to perform any further processing required, such as notifying
109  * the Postmaster and/or sender, marking the message for error processing, etc.</p>
110  *
111  * <p>Note that in the case of a message exceeding the message size limit, the
112  * message that is written to the input spool has no content. This enables
113  * configuration of a mailet notifying the sender that their mail has not been
114  * delivered due to its size while maintaining the purpose of the filter which is
115  * to avoid injecting excessively large messages into the input spool.</p>
116  *
117  * <p>Delivery is to a sole intended recipient. The recipient is determined in the
118  * following manner:</p>
119  *
120  * <ol>
121  * <li>If isIgnoreIntendedRecipient(), use the configured recipient</li>
122  * <li>If the Envelope contains a for: stanza, use the recipient in the stanza</li>
123  * <li>If the Message has a sole intended recipient, use this recipient</li>
124  * <li>If not rejectRecipientNotFound(), use the configured recipient</li>
125  * </ol>
126  *
127  * <p>If a recipient cannot be determined after these steps, the message is
128  * rejected.</p>
129  *
130  * <p>Every delivered message CURRENTLY has an "X-fetched-from" header added
131  * containing the name of the fetch task. Its primary uses are to detect bouncing
132  * mail and provide backwards compatibility with the fetchPop task that inserted
133  * this header to enable injected messages to be detected in the Matcher/Mailet
134  * chain. This header is DEPRECATED and WILL BE REMOVED in a future version of
135  * fetchmail. Use the Mail Attribute <code>org.apache.james.fetchmail.taskName</code>
136  * instead.
137  *
138  * <p><code>MessageProcessor</code> is as agnostic as it can be about the format
139  * and contents of the messages it delivers. There are no RFCs that govern its
140  * behavior. The most releveant RFCs relate to the exchange of messages between
141  * MTA servers, but not POP3 or IMAP servers which are normally end-point
142  * servers and not expected to re-inject mail into MTAs. None the less, the
143  * intent is to conform to the 'spirit' of the RFCs.
144  * <code>MessageProcessor</code> relies on the MTA (James in this
145  * implementation) to manage and validate the injected mail just as it would
146  * when receiving mail from an upstream MTA.</p>
147  *
148  * <p>The only correction applied by <code>MessageProcessor</code> is to correct a
149  * partial originator address. If the originator address has a valid user part
150  * but no domain part, a domain part is added. The added domain is either the
151  * default domain specified in the configuration, or if not specified, the
152  * fully qualified name of the machine on which the fetch task is running.</p>
153  *
154  * <p>The status of messages on the server from which they were fetched that
155  * cannot be injected into the input spool due to non-correctable errors is
156  * determined by the undeliverable configuration options.</p>
157  *
158  * <p>Creation Date: 27-May-03</p>
159  *
160  */
161 public class MessageProcessor extends ProcessorAbstract
162 {
163     private MimeMessage fieldMessageIn;
164
165     /**
166      * Recipient cannot be found
167      */
168     private boolean fieldRecipientNotFound = false;
169
170     /**
171      * Recipient is a local user on a local host
172      */
173     private boolean fieldRemoteRecipient = true;
174
175     /**
176      * The mail's Received header at index remoteReceivedHeaderIndex is invalid.
177      */
178     private Boolean fieldRemoteReceivedHeaderInvalid;
179
180     /**
181      * Recipient is not a local user
182      */
183     private boolean fieldUserUndefined = false;
184     
185     /**
186      * The Maximum Message has been exceeded
187      */
188     private Boolean fieldMaxMessageSizeExceeded;
189     
190     
191     /**
192      * Field names for an RFC2822 compliant RECEIVED Header
193      */
194     static final private String fieldRFC2822RECEIVEDHeaderFields =
195         "from by via with id for ;";
196     
197     /**
198      * Recipient is blacklisted
199      */
200     private boolean fieldBlacklistedRecipient = false;
201     
202     /**
203      * The RFC2822 compliant "Received : from" domain
204      */
205     private String fieldRemoteDomain;
206     
207     /**
208      * The remote address derived from the remote domain
209      */
210     private String fieldRemoteAddress;
211     
212     /**
213      * The remote host name derived from the remote domain
214      */
215     private String fieldRemoteHostName;
216     
217     /**
218      * Constructor for MessageProcessor.
219      *
220      * @param account
221      */
222     private MessageProcessor(Account account)
223     {
224         super(account);
225     }
226     
227     /**
228      * Constructor for MessageProcessor.
229      *
230      * @param messageIn
231      * @param account
232      */
233
234     MessageProcessor(
235         MimeMessage messageIn,
236          Account account)
237     {
238         this(account);
239         setMessageIn(messageIn);
240     }
241
242     
243     /**
244      * Method process attempts to deliver a fetched message.
245      *
246      * @see org.apache.james.fetchmail.ProcessorAbstract#process()
247      */
248     public void process() throws MessagingException
249     {
250         // Log delivery attempt
251 if (getLogger().isDebugEnabled())
252         {
253             StringBuffer logMessageBuffer =
254                 new StringBuffer("Attempting delivery of message with id. ");
255             logMessageBuffer.append(getMessageIn().getMessageID());
256             getLogger().debug(logMessageBuffer.toString());
257         }
258
259         // Determine the intended recipient
260 MailAddress intendedRecipient = getIntendedRecipient();
261         setRecipientNotFound(null == intendedRecipient);
262
263         if (isRecipientNotFound())
264         {
265             if (isDeferRecipientNotFound())
266             {
267
268                 String messageID = getMessageIn().getMessageID();
269                 if (!getDeferredRecipientNotFoundMessageIDs()
270                     .contains(messageID))
271                 {
272                     getDeferredRecipientNotFoundMessageIDs().add(messageID);
273                     if (getLogger().isDebugEnabled())
274                     {
275                         StringBuffer messageBuffer =
276                             new StringBuffer("Deferred processing of message for which the intended recipient could not be found. Message ID: ");
277                         messageBuffer.append(messageID);
278                         getLogger().debug(messageBuffer.toString());
279                     }
280                     return;
281                 }
282                 else
283                 {
284                     getDeferredRecipientNotFoundMessageIDs().remove(messageID);
285                     if (getLogger().isDebugEnabled())
286                     {
287                         StringBuffer messageBuffer =
288                             new StringBuffer("Processing deferred message for which the intended recipient could not be found. Message ID: ");
289                         messageBuffer.append(messageID);
290                         getLogger().debug(messageBuffer.toString());
291                     }
292                 }
293             }
294
295             if (isRejectRecipientNotFound())
296             {
297                 rejectRecipientNotFound();
298                 return;
299             }
300             intendedRecipient = getRecipient();
301             StringBuffer messageBuffer =
302                 new StringBuffer("Intended recipient not found. Using configured recipient as new envelope recipient - ");
303             messageBuffer.append(intendedRecipient);
304             messageBuffer.append('.');
305             logStatusInfo(messageBuffer.toString());
306         }
307
308         // Set the filter states
309 setBlacklistedRecipient(isBlacklistedRecipient(intendedRecipient));
310         setRemoteRecipient(!isLocalServer(intendedRecipient));
311         setUserUndefined(!isLocalRecipient(intendedRecipient));
312
313         // Apply the filters. Return if rejected
314 if (isRejectBlacklisted() && isBlacklistedRecipient())
315         {
316             rejectBlacklistedRecipient(intendedRecipient);
317             return;
318         }
319
320         if (isRejectRemoteRecipient() && isRemoteRecipient())
321         {
322             rejectRemoteRecipient(intendedRecipient);
323             return;
324         }
325
326         if (isRejectUserUndefined() && isUserUndefined())
327         {
328             rejectUserUndefined(intendedRecipient);
329             return;
330         }
331
332         if (isRejectMaxMessageSizeExceeded()
333             && isMaxMessageSizeExceeded().booleanValue())
334         {
335             rejectMaxMessageSizeExceeded(getMessageIn().getSize());
336             return;
337         }
338         
339         if (isRejectRemoteReceivedHeaderInvalid()
340             && isRemoteReceivedHeaderInvalid().booleanValue())
341         {
342             rejectRemoteReceivedHeaderInvalid();
343             return;
344         }
345
346         // Create the mail
347 // If any of the mail addresses are malformed, we will get a
348 // ParseException.
349 // If the IP address and host name for the remote domain cannot
350 // be found, we will get an UnknownHostException.
351 // In both cases, we log the problem and
352 // return. The message disposition is defined by the
353 // <undeliverable> attributes.
354 Mail mail = null;
355         try
356         {
357             mail = createMail(createMessage(), intendedRecipient);
358         }
359         catch (ParseException ex)
360         {
361             handleParseException(ex);
362             return;
363         }
364         catch (UnknownHostException ex)
365         {
366             handleUnknownHostException(ex);
367             return;
368         }
369
370         addMailAttributes(mail);
371         addErrorMessages(mail);
372
373         // If this mail is bouncing move it to the ERROR repository
374 if (isBouncing())
375         {
376             handleBouncing(mail);
377             return;
378         }
379
380         // OK, lets send that mail!
381 sendMail(mail);
382     }
383
384     /**
385      * Method rejectRemoteRecipient.
386      * @param recipient
387      * @throws MessagingException
388      */
389     protected void rejectRemoteRecipient(MailAddress recipient)
390         throws MessagingException
391     {
392         // Update the flags of the received message
393 if (!isLeaveRemoteRecipient())
394             setMessageDeleted();
395
396         if (isMarkRemoteRecipientSeen())
397             setMessageSeen();
398
399         StringBuffer messageBuffer =
400             new StringBuffer("Rejected mail intended for remote recipient: ");
401         messageBuffer.append(recipient);
402         messageBuffer.append('.');
403         logStatusInfo(messageBuffer.toString());
404
405         return;
406     }
407     
408     /**
409      * Method rejectBlacklistedRecipient.
410      * @param recipient
411      * @throws MessagingException
412      */
413     protected void rejectBlacklistedRecipient(MailAddress recipient)
414         throws MessagingException
415     {
416         // Update the flags of the received message
417 if (!isLeaveBlacklisted())
418             setMessageDeleted();
419         if (isMarkBlacklistedSeen())
420             setMessageSeen();
421
422         StringBuffer messageBuffer =
423             new StringBuffer("Rejected mail intended for blacklisted recipient: ");
424         messageBuffer.append(recipient);
425         messageBuffer.append('.');
426         logStatusInfo(messageBuffer.toString());
427
428         return;
429     }
430
431     /**
432      * Method rejectRecipientNotFound.
433      * @throws MessagingException
434      */
435     protected void rejectRecipientNotFound() throws MessagingException
436     {
437         // Update the flags of the received message
438 if (!isLeaveRecipientNotFound())
439             setMessageDeleted();
440
441         if (isMarkRecipientNotFoundSeen())
442             setMessageSeen();
443
444         StringBuffer messageBuffer =
445             new StringBuffer("Rejected mail for which a sole intended recipient could not be found.");
446         messageBuffer.append(" Recipients: ");
447         Address[] allRecipients = getMessageIn().getAllRecipients();
448         for (int i = 0; i < allRecipients.length; i++)
449         {
450             messageBuffer.append(allRecipients[i]);
451             messageBuffer.append(' ');
452         }
453         messageBuffer.append('.');
454         logStatusInfo(messageBuffer.toString());
455         return;
456     }
457     
458     /**
459      * Method rejectUserUndefined.
460      * @param recipient
461      * @throws MessagingException
462      */
463     protected void rejectUserUndefined(MailAddress recipient)
464         throws MessagingException
465     {
466         // Update the flags of the received message
467 if (!isLeaveUserUndefined())
468             setMessageDeleted();
469
470         if (isMarkUserUndefinedSeen())
471             setMessageSeen();
472
473         StringBuffer messageBuffer =
474             new StringBuffer("Rejected mail intended for undefined user: ");
475         messageBuffer.append(recipient);
476         messageBuffer.append('.');
477         logStatusInfo(messageBuffer.toString());
478
479         return;
480     }
481     
482     /**
483      * Method rejectMaxMessageSizeExceeded.
484      * @param message size
485      * @throws MessagingException
486      */
487     protected void rejectMaxMessageSizeExceeded(int messageSize)
488         throws MessagingException
489     {
490         // Update the flags of the received message
491 if (!isLeaveMaxMessageSizeExceeded())
492             setMessageDeleted();
493
494         if (isMarkMaxMessageSizeExceededSeen())
495             setMessageSeen();
496
497         StringBuffer messageBuffer =
498             new StringBuffer("Rejected mail exceeding message size limit. Message size: ");
499         messageBuffer.append(messageSize/1024);
500         messageBuffer.append("KB.");
501         logStatusInfo(messageBuffer.toString());
502
503         return;
504     }
505     
506     /**
507      * Method rejectRemoteReceivedHeaderInvalid.
508      * @throws MessagingException
509      */
510     protected void rejectRemoteReceivedHeaderInvalid()
511         throws MessagingException
512     {
513         // Update the flags of the received message
514 if (!isLeaveRemoteReceivedHeaderInvalid())
515             setMessageDeleted();
516
517         if (isMarkRemoteReceivedHeaderInvalidSeen())
518             setMessageSeen();
519
520         StringBuffer messageBuffer =
521             new StringBuffer("Rejected mail with an invalid Received: header at index ");
522         messageBuffer.append(getRemoteReceivedHeaderIndex());
523         messageBuffer.append(".");
524         logStatusInfo(messageBuffer.toString());
525         return;
526     }
527     
528     /**
529      * <p>Method createMessage answers a new <code>MimeMessage</code> from the
530      * fetched message.</p>
531      *
532      * <p>If the maximum message size is exceeded, an empty message is created,
533      * else the new message is a copy of the received message.</p>
534      *
535      * @return MimeMessage
536      * @throws MessagingException
537      */
538     protected MimeMessage createMessage() throws MessagingException
539     {
540         // Create a new messsage from the received message
541 MimeMessage messageOut = null;
542         if (isMaxMessageSizeExceeded().booleanValue())
543             messageOut = createEmptyMessage();
544         else
545             messageOut = new MimeMessage(getMessageIn());
546
547         // set the X-fetched headers
548 // Note this is still required to detect bouncing mail and
549 // for backwards compatibility with fetchPop
550 messageOut.addHeader("X-fetched-from", getFetchTaskName());
551
552         return messageOut;
553     }
554     
555     /**
556      * Method createEmptyMessage answers a new
557      * <code>MimeMessage</code> from the fetched message with the message
558      * contents removed.
559      *
560      * @return MimeMessage
561      * @throws MessagingException
562      */
563     protected MimeMessage createEmptyMessage()
564         throws MessagingException
565     {
566         // Create an empty messsage
567 MimeMessage messageOut = new MimeMessage(getSession());
568
569         // Propogate the headers and subject
570 Enumeration headersInEnum = getMessageIn().getAllHeaderLines();
571         while (headersInEnum.hasMoreElements())
572             messageOut.addHeaderLine((String) headersInEnum.nextElement());
573         messageOut.setSubject(getMessageIn().getSubject());
574
575         // Add empty text
576 messageOut.setText("");
577
578         // Save
579 messageOut.saveChanges();
580
581         return messageOut;
582     }
583
584     /**
585      * Method createMail creates a new <code>Mail</code>.
586      *
587      * @param message
588      * @param recipient
589      * @return Mail
590      * @throws MessagingException
591      */
592     protected Mail createMail(MimeMessage message, MailAddress recipient)
593         throws MessagingException, UnknownHostException
594     {
595         Collection recipients = new ArrayList(1);
596         recipients.add(recipient);
597         MailImpl mail =
598             new MailImpl(getServer().getId(), getSender(), recipients, message);
599         // Ensure the mail is created with non-null remote host name and address,
600 // otherwise the Mailet chain may go splat!
601 if (getRemoteAddress() == null || getRemoteHostName() == null)
602         {
603             mail.setRemoteAddr("127.0.0.1");
604             mail.setRemoteHost("localhost");
605         }
606         else
607         {
608             mail.setRemoteAddr(getRemoteAddress());
609             mail.setRemoteHost(getRemoteHostName());
610         }
611
612         if (getLogger().isDebugEnabled())
613         {
614             StringBuffer messageBuffer =
615                 new StringBuffer("Created mail with name: ");
616             messageBuffer.append(mail.getName());
617             messageBuffer.append(", sender: ");
618             messageBuffer.append(mail.getSender());
619             messageBuffer.append(", recipients: ");
620             Iterator recipientIterator = mail.getRecipients().iterator();
621             while (recipientIterator.hasNext())
622             {
623                 messageBuffer.append(recipientIterator.next());
624                 messageBuffer.append(' ');
625             }
626             messageBuffer.append(", remote address: ");
627             messageBuffer.append(mail.getRemoteAddr());
628             messageBuffer.append(", remote host name: ");
629             messageBuffer.append(mail.getRemoteHost());
630             messageBuffer.append('.');
631             getLogger().debug(messageBuffer.toString());
632         }
633         return mail;
634     }
635      
636
637     /**
638      * Method getSender answers a <code>MailAddress</code> for the sender.
639      *
640      * @return MailAddress
641      * @throws MessagingException
642      */
643     protected MailAddress getSender() throws MessagingException
644     {
645         String from = "FETCHMAIL-SERVICE";
646         try {
647             from = ((InternetAddress) getMessageIn().getFrom()[0]).getAddress().trim();
648         }
649         catch (Exception _) {
650             getLogger().info("Could not identify sender -- using default value");
651         }
652
653         InternetAddress internetAddress = null;
654
655         // Check for domain part, add default if missing
656 if (from.indexOf('@') < 0)
657         {
658             StringBuffer fromBuffer = new StringBuffer(from);
659             fromBuffer.append('@');
660             fromBuffer.append(getDefaultDomainName());
661             internetAddress = new InternetAddress(fromBuffer.toString());
662         }
663         else
664             internetAddress = new InternetAddress(from);
665
666         return new MailAddress(internetAddress);
667     }
668     
669     /**
670      * <p>Method computeRemoteDomain answers a <code>String</code> that is the
671      * RFC2822 compliant "Received : from" domain extracted from the message
672      * being processed.</p>
673      *
674      * <p>Normally this is the domain that sent the message to the host for the
675      * message store as reported by the second "received" header. The index of
676      * the header to use is specified by the configuration parameter
677      * <code>RemoteReceivedHeaderIndex</code>. If a header at this index does
678      * not exist, the domain of the successively closer "received" headers
679      * is tried until they are exhausted, then "localhost" is used.</p>
680      *
681      * @return String
682      */
683     protected String computeRemoteDomain() throws MessagingException
684     {
685         StringBuffer domainBuffer = new StringBuffer();
686         String[] headers = null;
687         if (getRemoteReceivedHeaderIndex() > -1)
688               getMessageIn().getHeader(RFC2822Headers.RECEIVED);
689               
690         if (null != headers)
691         {
692             // If there are RECEIVED headers and the index to begin at is greater
693 // than -1, try and extract the domain
694 if (headers.length > 0)
695             {
696                 final String headerTokens = " \n\r";
697
698                 // Search the headers for a domain
699 for (int headerIndex =
700                     headers.length > getRemoteReceivedHeaderIndex()
701                         ? getRemoteReceivedHeaderIndex()
702                         : headers.length - 1;
703                     headerIndex >= 0 && domainBuffer.length() == 0;
704                     headerIndex--)
705                 {
706                     // Find the "from" token
707 StringTokenizer tokenizer =
708                         new StringTokenizer(headers[headerIndex], headerTokens);
709                     boolean inFrom = false;
710                     while (!inFrom && tokenizer.hasMoreTokens())
711                         inFrom = tokenizer.nextToken().equals("from");
712
713                     // Add subsequent tokens to the domain buffer until another
714 // field is encountered or there are no more tokens
715 while (inFrom && tokenizer.hasMoreTokens())
716                     {
717                         String token = tokenizer.nextToken();
718                         if (inFrom =
719                             getRFC2822RECEIVEDHeaderFields().indexOf(token)
720                                 == -1)
721                         {
722                             domainBuffer.append(token);
723                             domainBuffer.append(' ');
724                         }
725                     }
726                 }
727             }
728         }
729
730         // Default is "localhost"
731 if (domainBuffer.length() == 0)
732             domainBuffer.append("localhost");
733
734         return domainBuffer.toString().trim();
735     }
736     
737     /**
738      * Method handleBouncing sets the Mail state to ERROR and delete from
739      * the message store.
740      *
741      * @param mail
742      */
743     protected void handleBouncing(Mail mail) throws MessagingException
744     {
745         mail.setState(Mail.ERROR);
746         setMessageDeleted();
747
748         mail.setErrorMessage(
749             "This mail from FetchMail task "
750                 + getFetchTaskName()
751                 + " seems to be bouncing!");
752         logStatusError("Message is bouncing! Deleted from message store and moved to the Error repository.");
753     }
754     
755     /**
756      * Method handleParseException.
757      * @param ex
758      * @throws MessagingException
759      */
760     protected void handleParseException(ParseException ex)
761         throws MessagingException
762     {
763         // Update the flags of the received message
764 if (!isLeaveUndeliverable())
765             setMessageDeleted();
766         if (isMarkUndeliverableSeen())
767             setMessageSeen();
768         logStatusWarn("Message could not be delivered due to an error parsing a mail address.");
769         if (getLogger().isDebugEnabled())
770         {
771             StringBuffer messageBuffer =
772                 new StringBuffer("UNDELIVERABLE Message ID: ");
773             messageBuffer.append(getMessageIn().getMessageID());
774             getLogger().debug(messageBuffer.toString(), ex);
775         }
776     }
777     
778     /**
779      * Method handleUnknownHostException.
780      * @param ex
781      * @throws MessagingException
782      */
783     protected void handleUnknownHostException(UnknownHostException ex)
784         throws MessagingException
785     {
786         // Update the flags of the received message
787 if (!isLeaveUndeliverable())
788             setMessageDeleted();
789     
790         if (isMarkUndeliverableSeen())
791             setMessageSeen();
792     
793         logStatusWarn("Message could not be delivered due to an error determining the remote domain.");
794         if (getLogger().isDebugEnabled())
795         {
796             StringBuffer messageBuffer =
797                 new StringBuffer("UNDELIVERABLE Message ID: ");
798             messageBuffer.append(getMessageIn().getMessageID());
799             getLogger().debug(messageBuffer.toString(), ex);
800         }
801     }
802     
803     /**
804      * Method isLocalRecipient.
805      * @param recipient
806      * @return boolean
807      */
808     protected boolean isLocalRecipient(MailAddress recipient)
809     {
810         return isLocalUser(recipient) && isLocalServer(recipient);
811     }
812     
813     /**
814      * Method isLocalServer.
815      * @param recipient
816      * @return boolean
817      */
818     protected boolean isLocalServer(MailAddress recipient)
819     {
820         return getServer().isLocalServer(recipient.getHost());
821     }
822     
823     /**
824      * Method isLocalUser.
825      * @param recipient
826      * @return boolean
827      */
828     protected boolean isLocalUser(MailAddress recipient)
829     {
830         return getLocalUsers().containsCaseInsensitive(recipient.getUser());
831     }
832     
833     /**
834      * Method isBlacklistedRecipient.
835      * @param recipient
836      * @return boolean
837      */
838     protected boolean isBlacklistedRecipient(MailAddress recipient)
839     {
840         return getBlacklist().contains(recipient);
841     }
842
843     /**
844      * Check if this mail has been bouncing by counting the X-fetched-from
845      * headers for this task
846      *
847      * @return boolean
848      */
849     protected boolean isBouncing() throws MessagingException
850     {
851         Enumeration enum =
852             getMessageIn().getMatchingHeaderLines(
853                 new String[] { "X-fetched-from" });
854         int count = 0;
855         while (enum.hasMoreElements())
856         {
857             String header = (String) enum.nextElement();
858             if (header.equals(getFetchTaskName()))
859                 count++;
860         }
861         return count >= 3;
862     }
863     
864     /**
865      * Method sendMail.
866      * @param mail
867      * @throws MessagingException
868      */
869     protected void sendMail(Mail mail) throws MessagingException
870     {
871         // send the mail
872 getServer().sendMail(mail);
873
874         // Update the flags of the received message
875 if (!isLeave())
876             setMessageDeleted();
877
878         if (isMarkSeen())
879             setMessageSeen();
880
881         // Log the status
882 StringBuffer messageBuffer =
883             new StringBuffer("Spooled message to recipients: ");
884         Iterator recipientIterator = mail.getRecipients().iterator();
885         while (recipientIterator.hasNext())
886         {
887             messageBuffer.append(recipientIterator.next());
888             messageBuffer.append(' ');
889         }
890         messageBuffer.append('.');
891         logStatusInfo(messageBuffer.toString());
892     }
893
894
895     /**
896      * Method getEnvelopeRecipient answers the recipient if found else null.
897      *
898      * Try and parse the "for" parameter from a Received header
899      * Maybe not the most accurate parsing in the world but it should do
900      * I opted not to use ORO (maybe I should have)
901      *
902      * @param msg
903      * @return String
904      */
905
906     protected String getEnvelopeRecipient(MimeMessage msg) throws MessagingException
907     {
908         try
909         {
910             Enumeration enum =
911                 msg.getMatchingHeaderLines(new String[] { "Received" });
912             while (enum.hasMoreElements())
913             {
914                 String received = (String) enum.nextElement();
915
916                 int nextSearchAt = 0;
917                 int i = 0;
918                 int start = 0;
919                 int end = 0;
920                 boolean hasBracket = false;
921                 boolean usableAddress = false;
922                 while (!usableAddress && (i != -1))
923                 {
924                     hasBracket = false;
925                     i = received.indexOf("for ", nextSearchAt);
926                     if (i > 0)
927                     {
928                         start = i + 4;
929                         end = 0;
930                         nextSearchAt = start;
931                         for (int c = start; c < received.length(); c++)
932                         {
933                             char ch = received.charAt(c);
934                             switch (ch)
935                             {
936                                 case '<' :
937                                     hasBracket = true;
938                                     continue;
939                                 case '@' :
940                                     usableAddress = true;
941                                     continue;
942                                 case ' ' :
943                                     end = c;
944             &