Java > Open Source Codes > org > enhydra > oyster > smime > BaseSMIMEObject


1 /*
2 * Title: Oyster Project
3 * Description: S/MIME email sending capabilities
4 * @Author Vladimir radisic
5 * @Version 2.1.5
6  */
7
8 package org.enhydra.oyster.smime;
9
10 import org.enhydra.oyster.exception.SMIMEException;
11 import org.enhydra.oyster.activation.StreamDataSource;
12 import org.enhydra.oyster.mail.MultipartGenerator;
13 import org.enhydra.oyster.util.ConvertAssist;
14 import org.enhydra.oyster.util.PFXUtils;
15 import org.enhydra.oyster.mail.ContentAnalyzer;
16 import org.enhydra.oyster.crypto.consts.KeyStoreConstants;
17 import javax.mail.Session ;
18 import javax.mail.Transport ;
19 import javax.mail.MessagingException ;
20 import javax.mail.internet.MimeMessage ;
21 import javax.mail.internet.MimeBodyPart ;
22 import javax.mail.internet.MimeMultipart ;
23 import javax.mail.internet.InternetAddress ;
24 import javax.activation.DataHandler ;
25 import javax.activation.FileDataSource ;
26 import javax.activation.MimetypesFileTypeMap ;
27 import java.util.Vector ;
28 import java.util.Properties ;
29 import java.io.File ;
30 import java.io.InputStream ;
31 import java.io.FileInputStream ;
32 import java.io.ByteArrayInputStream ;
33 import java.security.Security ;
34 import sun.security.provider.Sun;
35 import org.bouncycastle.jce.provider.BouncyCastleProvider;
36 import java.security.KeyStore ;
37 import java.security.cert.X509Certificate ;
38 import java.security.cert.CertificateFactory ;
39
40 import java.io.*;
41
42 /**
43  * This class is used as super class for all four email types with SMIME
44  * cryptography capabilities (Enveloped, Signed Signed and Enveloped and Enveloped
45  * and Signed). It contains the common methods for all this types. Also, this
46  * class is used as a super class for class PureMIME which can be used in creation
47  * and sending of pure MIME messages withouth cryptography posibilities.
48  */
49 public class BaseSMIMEObject implements KeyStoreConstants
50 {
51
52   /**
53    * Container for MIME message
54    */
55   protected MimeMessage message;
56
57   /**
58    * Indicator of the email message content part presence (it can be plain text or
59    * html content). Other part of message contains attachements.
60    */
61   protected boolean contentPresence = false;
62
63   /**
64    * Indicator of the external MimeMessage object presence. This parameter is true
65    * when constructor with MimeMessage object is used.
66    */
67   protected boolean externalMessagePresence = false;
68
69   /**
70    * Storage for MIME bodyparts
71    */
72   protected Vector bodyPartArray = new Vector (0, 1);
73
74
75   /**
76    * Storage for .cer files coresponding to appropriate enveloping session
77    */
78   protected Vector certArray = new Vector (0, 1);
79
80   /**
81    * Indication that at least one recipient must be TO (others may be CC or BCC)
82    */
83   protected boolean indicatorTo = false;
84
85   /**
86    * Character set definition. The given Unicode strings will be charset-encoded
87    * by using theis attribute. The charset is also used to set the "charset"
88    * parameter. For example German letters should be encoded by usage of
89    * 'ISO-8859-1' charset. If charset parameter is null and subject or content
90    * contains non US-ASCII characters, it will be encoded using the platform's
91    * default charset. For more information about character sets refer to
92    * 'Character Encodings' chapter of package java.lang Java documentation page,
93    * or to RFC2278.
94    */
95   protected String charsetEnc = null;
96
97   /**
98    * Simple constructor. Dynamically loads the BC and SUN provider necessary for
99    * cryptography processing. This constructor does not create MIME message
100    * object, so it is obligatory to invoke initMimeMessage() method after this
101    * constructor.
102    */
103   protected BaseSMIMEObject ()
104   {
105     Security.addProvider(new BouncyCastleProvider()); // Dynamic loading the BC provider
106 Security.addProvider(new Sun()); // Dynamic loading the SUN provider necessary for SHA1withRSA
107 }
108
109   /**
110    * Initializes the JavaMail session for SMTP and the MimeMessage object for message
111    * which will be sent. Dynamically loads the BC and SUN provider necessary for
112    * cryptography processing. This constructor is used for creating message with
113    * text/plain content. For creating html formated content (text/html), other
114    * constructor should be used in combination with one of setContent methods.
115    * Note that after using this constructor setContent method can be used only
116    * if "content" argument of constructor was given as null, otherwise setContent
117    * method can't be used because content is already set as text/plain.
118    * @param smtpHost name of SMTP host used for sending email
119    * @param fromAddress email address of sender (FROM field in email header)
120    * @param subject subject of email (SUBJECT field in email header). This
121    * argument can be null, but email message will be sent withouth SUBJECT.
122    * @param content text/plain content of email message. This argument can be
123    * null, but later one of setContent() methods or one of addAttachment()
124    * methods should be called
125    * @param charset character set for passed subject and content. The given
126    * Unicode string will be charset-encoded using the specified charset. The
127    * charset is also used to set the "charset" parameter. For example German
128    * letters should be encoded by usage of 'ISO-8859-1' charset. If charset
129    * parameter is null and subject or content contains non US-ASCII characters,
130    * it will be encoded using the platform's default charset.
131    * @exception SMIMEException if smtpHost or fromAddress parameters are null.
132    * Also, it can be caused by non SMIMEException which is MessagingException.
133    */
134   protected BaseSMIMEObject (String smtpHost, String fromAddress, String subject,
135                           String content, String charset) throws SMIMEException
136   {
137     this();
138     try {
139       initMimeMessage(smtpHost, fromAddress, subject, content, charset);
140     }
141     catch(Exception e) {
142       throw SMIMEException.getInstance(this, e, "constructor");
143     }
144   }
145
146
147   /**
148    * Initializes the JavaMail session for SMTP and the MimeMessage object for message
149    * which will be sent. Dynamically loads the BC and SUN provider necessary for
150    * cryptography processing. This constructor does not create content of message
151    * and it can be set later with one of setContent methods. Also, message can be
152    * left withouth content, but then at least one attachement must be added.
153    * @param smtpHost name of SMTP host used for sending email
154    * @param fromAddress email address of sender (FROM field in email header)
155    * @param subject subject of email (SUBJECT field in email header). This
156    * argument can be null, but email message will be sent withouth SUBJECT.
157    * @param charset character set for passed subject and content. The given
158    * Unicode string will be charset-encoded using the specified charset. The
159    * charset is also used to set the "charset" parameter. For example German
160    * letters should be encoded by usage of 'ISO-8859-1' charset. If charset
161    * parameter is null and subject or content contains non US-ASCII characters,
162    * it will be encoded using the platform's default charset.
163    * @exception SMIMEException if smtpHost or fromAddress parameters are null.
164    * Also, it can be caused by non SMIMEException which is MessagingException.
165    */
166   protected BaseSMIMEObject (String smtpHost, String fromAddress, String subject,
167                           String charset) throws SMIMEException
168   {
169     this(smtpHost, fromAddress, subject, null, charset);
170   }
171
172
173   /**
174    * Construction of message with external prepared MimeMessage object. Usage of
175    * this constructor disables usage of setContent() and addAttachment() methods.
176    * Also, all recipients (TO, CC or BCC type) must be declared again via
177    * setRecipient() method, even if they were previously set. Be very carefull
178    * with usage of this constructor because all MimeBodyPart objects and
179    * MimeMultipart objects used in construction of given MimeMessage object,
180    * must have correct defined Content header arguments, and contents. Contents
181    * must be formed in format which can be recognised and appropriate interpreted
182    * in the process of sending mail. If there is any special content object
183    * added to MimeBodyPart object or MimeMultipart object, the appropriate
184    * DataContent handler must be created for that object and set to corresponding
185    * BodyPart.
186    * @param mimeMessage external created MimeMessage object
187    * @exception SMIMEException if smtpHost or fromAddress parameter is null.
188    * Also, it can be caused by non SMIMEException which is MessagingException.
189    */
190   protected BaseSMIMEObject (MimeMessage mimeMessage) throws SMIMEException
191   {
192     try {
193       Security.addProvider(new BouncyCastleProvider()); // Dynamic loading the BC provider
194 Security.addProvider(new Sun()); // Dynamic loading the SUN provider necessary for SHA1withRSA
195
196       this.message = new MimeMessage (mimeMessage);
197       message.removeHeader("TO");
198       message.removeHeader("CC");
199       message.removeHeader("BCC");
200
201       externalMessagePresence = true;
202     }
203     catch(Exception e) {
204       throw SMIMEException.getInstance(this, e, "constructor");
205     }
206   }
207
208
209   /**
210    * Initializes the JavaMail session for SMTP and the MimeMessage object for
211    * message which will be sent. If the argument 'content' is not given as null
212    * this method is used for creating new message with text/plain content. For
213    * creating html formated content (text/html), argument 'content' should be
214    * given as null, and content of message should be set with one of setContent
215    * methods. Note that after using initMimeMessage method, setContent method
216    * can be used only if 'content' argument of constructor was given as null,
217    * otherwise setContent method can't be used because content is already set as
218    * text/plain.
219    * @param smtpHost name of SMTP host used for sending email
220    * @param fromAddress email address of sender (FROM field in email header)
221    * @param subject subject of email (SUBJECT field in email header). This
222    * argument can be null, but email message will be sent withouth SUBJECT.
223    * @param content text/plain content of email message
224    * @param charset character set for passed subject and content. The given
225    * Unicode string will be charset-encoded using the specified charset. The
226    * charset is also used to set the "charset" parameter. For example German
227    * letters should be encoded by usage of 'ISO-8859-1' charset. If 'charset'
228    * argument is null and subject or content contains non US-ASCII characters,
229    * it will be encoded using the platform's default charset.
230    * @exception SMIMEException if smtpHost or fromAddress parameters are null.
231    * Also, it can be caused by non SMIMEException which is MessagingException.
232    */
233   public void initMimeMessage(String smtpHost, String fromAddress, String subject,
234                              String content, String charset) throws SMIMEException
235   {
236     if (smtpHost == null | fromAddress == null)
237       throw new SMIMEException(this, 1041);
238
239     this.charsetEnc = charset;
240
241     Properties sesProp = new Properties ();
242     sesProp.setProperty("mail.smtp.host", smtpHost);
243     Session ses = Session.getInstance(sesProp);
244     message = new MimeMessage (ses);
245     try {
246       InternetAddress from = new InternetAddress (fromAddress);
247       message.setFrom(from);
248       if (subject != null) {
249         if(charset != null)
250           message.setSubject(subject, charset);
251         else
252           message.setSubject(subject);
253       }
254       if (content != null) {
255         MimeBodyPart mbp = new MimeBodyPart ();
256         if(charset != null)
257           mbp.setText(content, charset);
258         else
259           mbp.setText(content);
260         mbp.setText(content);
261         bodyPartArray.addElement(mbp);
262         contentPresence = true;
263       }
264     }
265     catch(Exception e) {
266       throw SMIMEException.getInstance(this, e, "initMimeMessage");
267     }
268   }
269
270
271   /**
272    * Sets the character set encoding. This attribute also can be set during the
273    * construction of object, or by invoking initMimeMessage() method. By
274    * invoking this method, previously set parameter will be overriden.
275    * @param charset characterset encoding definition which will be used in
276    * process of string to byte array (and vice versa) transformation. The
277    * 'charset' argument is also used to set the 'charset' parameter in message
278    * or body header. For example German letters should be encoded by usage of
279    * 'ISO-8859-1' charset. If 'charset' argument is null and String contains non
280    * US-ASCII characters it will be encoded using the platform's default charset.
281    */
282   public void setCharsetEncoding(String charset) {
283     this.charsetEnc = charset;
284   }
285
286
287   /**
288    * Sets message content. Message content can be given in two differrent forms:
289    * text and html code. If content is type of text, parameter "type" should be
290    * "text/plain" and other two parameters are not in use (should be set to null).
291    * If content is type of html code, parameter "type" should be set as "text/html",
292    * otherwise (if it is set as "text/plain") html code is processed as plain
293    * text. This method can be performed only once.<BR>
294    * <BR>
295    * In case of html content, it is essential to (on appropriate way) associate some
296    * attributes of particular elements in html code ("background" or "src" atributes)
297    * with corresponding ressources (URL-s, relative file addresses or byte array
298    * streams). This resources should all be sent with message to enable recipient
299    * to see complete html message. Location of resources can be given in few
300    * different forms and depending on that, allocation resolving can be successful or
301    * not. Following text represents different possibilities for defining locations
302    * of resources (pictures, animations, sound...) inside of html code passed to
303    * this method, and necessery passed additional parameters used for resolving
304    * this resource locations.<BR>
305    * <BR>
306    * <UL>
307    * <LI>URL defined as: http://... is left unchanged. This resource is not sent
308    * with the message and it couldn't be seen by recipient if it is not online on
309    * the internet.</LI>
310    * <LI>URL defined as: file://... is transformed to corresponding Content ID if
311    * the resource can be found on specified location and it is sent with message.</LI>
312    * <LI>Absolute path, for example defined as: "c:\tmp\test\picture.bmp", is
313    * transformed to corresponding Content ID if the resource can be found on
314    * specified location, and is sent with message. If all resources in html
315    * code are specified with its absolute path, the 3rd parameter in this method
316    * can be null.</LI>
317    * <LI>Relative path of all resources specified in html code, for example
318    * defined as: ".\test\picture.bmp" and ".\example\flush.swf", must be defined
319    * to be relative to same directory path (in this case it is c:\tmp). This parameter
320    * (common directory path) is given as 3rd parameter in this method, and is named
321    * "path". If html code is obtained from .html file, necessery common directory
322    * path is usually path to this .html file. Location of resource is transformed
323    * to corresponding Content ID if the resource can be found on specified location.
324    * This location is sent with the message.</LI>
325    * <LI>Byte array stream as resource for html attribute must be referenced from
326    * html code as: <BR>
327    * <BR><PRE>
328    * *****nnn&lt;virtual_file_name&gt;<BR>
329    * <BR></PRE>
330    * Five '*' characters (must be five) define that it is resource expected from
331    * the stream. Other three characters must be digits (000-999) and represent
332    * index of corresponding stream in stream array. virtual_file_name is name and
333    * extension assigned to data passed from stream. Name is used in construction of
334    * "name" parameter in Content-Type, while extension of file name is used in
335    * detection of appropriate mime-type. Lenght of virtual_file_name is not
336    * important. If there is no data referenced from byte array stream ,4th
337    * parameter of this method named "resources" can be null. Also, if all resources
338    * are passed through the array of streams, 3th parameter ("path") can be null.
339    * Location of resource is transformed to corresponding Content ID if no error
340    * has occured during the process of allocation.</LI>
341    * </UL>
342    * <BR>
343    * All mentioned resource allocation types can be combined together in the same
344    * html code, and all will be processed with appropriate use of this method.<BR>
345    * <BR>
346    * Note that number of resource references that are defined in html code by
347    * using virtual_file_names must be greater than or equal to number of elements
348    * in array of InputStream (4th parameter). If one resource (one element in array
349    * of IputStream) is used in html code more than once, it is advisable to use
350    * same virtual_file_name in html code because message is then sent with only
351    * one attached resource (image, movie...). It is essetntial that desired resource
352    * in input stream array corresponds to specified "nnn" part of virtual_file_name.<BR>
353    * <BR>
354    * If resources specified on any described name can not be found or resolved,
355    * or if any exception has occured during its processing, they won't be added and
356    * html message will be sent withouth them.
357    * @param content String representation of message content (text or html code).
358    * This argument is mandatory.
359    * @param type type of given content. It can take values: "text/plain" or
360    * "text/html". This argument is mandatory.
361    * @param path common directory path for relative file locations in html code.
362    * It can be null if all resources set absolute path or are defined by
363    * byte array streams, or if sending resources with relative address it is not desired.
364    * Also, it is set to null in case of text/plain message.
365    * @param resources way for representing resources used in the given html code
366    * which will be added to message as array of InputStream. Detail use
367    * of this argument is described above. It can be null if no resources as byte
368    * array stream are used, or if sending resources given in that way is not desired.
369    * Also, it is set to null in case of text/plain message.
370    * @param externalPlainText external text/plain message represented as String.
371    * This argument is used as alternative message to given html message in the process
372    * of generation multipart/alternative MimeMultipart message. If this argument
373    * has value null then autogeneration of text/plain message is performed
374    * according to passed html code (content argument). Also, it is set to null
375    * in case of text/plain message.
376    * @exception SMIMEException if content is tried to be added twice, or in case of
377    * wrong "type" parameter. Also, it can be caused by non SMIMEException which can
378    * be one of the following: MessagingException UnsoportedEncodingException.
379    */
380   public void setContent(String content, String type, String path, InputStream [] resources,
381                          String externalPlainText) throws SMIMEException {
382
383     if(content != null) {
384       ByteArrayInputStream bais = null;
385       try {
386         if(this.charsetEnc != null)
387           bais = new ByteArrayInputStream ( content.getBytes(this.charsetEnc) );
388         else
389           bais = new ByteArrayInputStream ( content.getBytes("ISO-8859-1") );
390       }
391       catch(Exception e) {
392         throw SMIMEException.getInstance(this, e, "setContent");
393       }
394       this.setContent(bais, type, path, resources, externalPlainText);
395
396     }
397     else
398       throw new SMIMEException(this, 1035);
399   }
400
401   /**
402    * Sets message content from String. This method can be performed only once.
403    * Method is the same as corresponding method setContent with five parameters,
404    * where fifth parameter is set to null. This setContent method (in case that second
405    * argument - type has value text/html) is used with autogeneration of text/plain
406    * message according to given html code in the process of generation
407    * multipart/alternative MimeMultipart message. For further information refer
408    * to setContent method with five arguments.
409    * @param content String representation of message content (text or html code).
410    * This argument is mandatory.
411    * @param type type of given content. It can take values: "text/plain" or
412    * "text/html". This argument is mandatory.
413    * @param path common directory path for relative file locations in html code.
414    * It can be null if all resources set absolute path or are defined by
415    * byte array streams, or if sending resources with relative address it is not desired.
416    * Also, it is set to null in case of text/plain message.
417    * @param resources way for representing resources used in the given html code
418    * which will be added to message as array of InputStream. Detail use
419    * of this argument is described above. It can be null if no resources as byte
420    * array stream are used, or if sending resources given in that way is not desired.
421    * Also, it is set to null in case of text/plain message.
422    * @exception SMIMEException if content is tried to be added twice, or in case of
423    * wrong "type" parameter. Also, it can be caused by non SMIMEException which can
424    * be one of the following: MessagingException UnsoportedEncodingException.
425    */
426   public void setContent(String content, String type, String path, InputStream [] resources)
427       throws SMIMEException {
428
429     this.setContent(content, type, path, resources, null);
430   }
431
432
433   /**
434    * Sets message content from InputStream. This method can be performed only once.
435    * Message content can be given in two differrent forms: text and html code. If
436    * content is type of text, parameter "type" should be "text/plain", while if
437    * content is type of html code, parameter "type" should be set as "html/code".
438    * For further information refer to setContent method with five arguments
439    * (String, String, String, InputStream[], String) which is called by this method.
440    * @param content message content data given from any InputStream.
441    * Data can be text or html code and will be interpreted according to second
442    * parameter: "type".
443    * @param type type of given content. It can take values: "text/plain" or
444    * "text/html". This argument is mandatory.
445    * @param path common directory path for relative file locations in html code.
446    * It can be null if all resources in html code have set absolute path or are
447    * defined by byte array streams, or if sending resources with relative address
448    * is not desired. Also, it is set to null in case of text/plain message.
449    * @param resources way for representing resources used in the given html code
450    * which will be added to message as array of InputStreams. Detail use
451    * of this argument is described in other setContent methods mentioned before.
452    * It can be null if no resources as byte array stream are used, or if sending
453    * resources given in that way is not desired. Also, it is set to null in case
454    * of text/plain message.
455    * @param externalPlainText external text/plain message represented as String.
456    * This argument is used as alternative message to given html message in the process
457    * of generation multipart/alternative MimeMultipart message. If this argument
458    * has value null then autogeneration of text/plain message is performed
459    * according to passed html code (content argument). Also, it is set to null
460    * in case of text/plain message.
461    * @exception SMIMEException if content is tried to be added twice , in case of
462    * wrong "type" parameter or in case when parameter content is null. Also, it can
463    * be caused by non SMIMEException which is MessagingException.
464    */
465   public void setContent(InputStream content, String type, String path,
466                          InputStream [] resources, String externalPlainText) throws SMIMEException {
467     if(contentPresence)
468       throw new SMIMEException(this, 1049);
469     if(content != null) {
470       try {
471         if(type.equalsIgnoreCase("text/plain")) {
472           MimeBodyPart mbp = new MimeBodyPart ();
473           String temp = null;
474           if(this.charsetEnc != null) {
475             temp = new String (ConvertAssist.inStreamToByteArray(content), this.charsetEnc);
476             mbp.setText(temp, this.charsetEnc);
477           }
478           else {
479             temp = new String (ConvertAssist.inStreamToByteArray(content), "ISO-8859-1");
480             mbp.setText(temp, "ISO-8859-1");
481           }
482           bodyPartArray.add(0, mbp);
483           contentPresence = true;
484         }
485         else if(type.equalsIgnoreCase("text/html")) {
486           MimeMultipart htmlMultipart =
487               MultipartGenerator.getHtmlMultipart(content, path, resources, externalPlainText);
488           bodyPartArray.add(0, htmlMultipart);
489           contentPresence = true;
490         }
491         else
492           throw new SMIMEException(this, 1048);
493       }
494       catch(Exception e) {
495         throw SMIMEException.getInstance(this, e, "setContent");
496       }
497     }
498     else
499       throw new SMIMEException(this, 1035);
500   }
501
502
503   /**
504    * Sets message content from InputStream. This method can be performed only once.
505    * Method is same as corresponding method setContent with five parameters, where
506    * fifth parameter is set to null. This setContent method (in case that second
507    * argument - type has value text/html) is used with autogeneration of text/plain
508    * message according to given html code in process of generation multipart/alternative
509    * MimeMultipart message. For further information refer to setContent method with
510    * five arguments (InputStream, String, String, InputStream[], String) which is
511    * called by this method.
512    * @param content message content data given from any InputStream.
513    * Data can be text or html code and will be interpreted according to second
514    * parameter: "type".
515    * @param type type of given content. It can take values: "text/plain" or
516    * "text/html". This argument is mandatory.
517    * @param path common directory path for relative file locations in html code.
518    * It can be null if all resources in html code have set absolute path or are
519    * defined by byte array streams, or if sending resources with relative address
520    * is not desired. Also, it is set to null in case of text/plain message.
521    * @param resources way for representing resources used in the given html code
522    * which will be added to message as array of InputStreams. Detail use
523    * of this argument is described in other setContent methods mentioned before.
524    * It can be null if no resources as byte array stream are used, or if sending
525    * resources given in that way is not desired. Also, it is set to null in case
526    * of text/plain message.
527    * @exception SMIMEException if content is tried to be added twice , in case of
528    * wrong "type" parameter or in case when parameter content is null. Also, it can
529    * be caused by non SMIMEException which is MessagingException.
530    */
531   public void setContent(InputStream content, String type, String path,
532                          InputStream [] resources) throws SMIMEException {
533     this.setContent(content, type, path, resources, null);
534   }
535
536
537   /**
538    * Sets message content from InputStream. This method can be performed only once.
539    * Message content can be given in two differrent forms: text and html code. If
540    * content is type of text, parameter "type" should be "text/plain", while if
541    * content is type of html code, parameter "type" should be set as "html/code".
542    * If html code content is set by this method, message will be generated withouth
543    * inclusion of the resources defined in paricular html element's attribute ("src" and
544    * "background"). Only plain html code will be sent and any reference to local
545    * file system resources will be useless for recipient of the message. HTTP referenced
546    * resources can still be available if recipient is online on Internet. Message
547    * generated on this way is smaller so encrypting process should be faster.
548    * @param content message content data given from any InputStream.
549    * Data could be text or html code and will be interpreted according to second
550    * parameter: "type". This argument is mandatory.
551    * @param type type of given content. It can take values: "text/plain" or
552    * "text/html". This argument is mandatory.
553    * @param externalPlainText external text/plain message represented as String.
554    * This argument is used as alternative message to given html message in the process
555    * of generation multipart/alternative MimeMultipart message. If this argument
556    * has value null then autogeneration of text/plain message is performed
557    * according to passed html code (content argument). Also, it is set to null
558    * in case of text/plain message.
559    * @exception SMIMEException if content is tried to be added twice , in case of
560    * wrong "type" parameter or in case when parameter content is null. Also, it can
561    * be caused by non SMIMEException which is MessagingException.
562    */
563   public void setContent(InputStream content, String type, String externalPlainText) throws SMIMEException {
564     if(contentPresence)
565       throw new SMIMEException(this, 1049);
566     if(content != null) {
567       try {
568         if(type.equalsIgnoreCase("text/plain")) {
569           MimeBodyPart mbp = new MimeBodyPart ();
570           String temp = null;
571           if(this.charsetEnc != null) {
572             temp = new String (ConvertAssist.inStreamToByteArray(content), this.charsetEnc);
573             mbp.setText(temp, this.charsetEnc);
574           }
575           else {
576             temp = new String (ConvertAssist.inStreamToByteArray(content), "ISO-8859-1");
577             mbp.setText(temp, "ISO-8859-1");
578           }
579
580           bodyPartArray.add(0, mbp);
581           contentPresence = true;
582         }
583         else if(type.equalsIgnoreCase("text/html")) {
584           MimeMultipart htmlMultipart = MultipartGenerator.getHtmlMultipart(content);
585           bodyPartArray.add(0, htmlMultipart);
586           contentPresence = true;
587         }
588         else
589           throw new SMIMEException(this, 1048);
590       }
591       catch(Exception e) {
592         throw SMIMEException.getInstance(this, e, "setContent");
593       }
594     }
595     else
596       throw new SMIMEException(this, 1035);
597   }
598
599
600   /**
601    * Sets message content from InputStream. This method can be performed only once.
602    * Method is the same as corresponding method setContent with three parameters,
603    * where third parameter is set to null. This setContent method (in case that second
604    * argument - type has value text/html) is used with autogeneration of text/plain
605    * message according to given html code in the process of generation
606    * multipart/alternative MimeMultipart message. For further information refer
607    * to setContent method with thre arguments.
608    * @param content message content data given from any InputStream.
609    * Data could be text or html code and will be interpreted according to second
610    * parameter: "type". This argument is mandatory.
611    * @param type type of given content. It can take values: "text/plain" or
612    * "text/html". This argument is mandatory.
613    * @exception SMIMEException if content is tried to be added twice , in case of
614    * wrong "type" parameter or in case when parameter content is null. Also, it can
615    * be caused by non SMIMEException which is MessagingException.
616    */
617   public void setContent(InputStream content, String type) throws SMIMEException {
618     this.setContent(content, type, null);
619   }
620
621
622
623   /**
624    * Sets message content from String. This method can be performed only once.
625    * Message content can be given in two differrent forms: text and html code. If
626    * content is type of text, parameter "type" should be "text/plain", while if
627    * content is type of html code, parameter "type" should be set as "html/code".
628    * If html code content is set by this method, message will be generated withouth
629    * inclusion of the resources defined in paricular html element's attribute ("src" or
630    * "background"). Only plain html code will be sent and any reference to local
631    * file system resources will be useless for recipient of the message. HTTP referenced
632    * resources can still be available if recipient is online on Internet. Message
633    * generated on this way is smaller, so encrypting process should be faster.
634    * @param content message content data given as String which can
635    * be text or html code and will be interpreted according to second parameter:
636    * "type". This argument is mandatory.
637    * @param type type of given content. It can take values: "text/plain" or
638    * "text/html". This argument is mandatory.
639    * @param externalPlainText external text/plain message represented as String.
640    * This argument is used as alternative message to given html message in the process
641    * of generation multipart/alternative MimeMultipart message. If this argument
642    * has value null then autogeneration of text/plain message is performed
643    * according to passed html code (content argument). Also, it is set to null
644    * in case of text/plain message.
645    * @exception SMIMEException if content is tried to be added twice, or in case of
646    * wrong "type" parameter. Also, it can be caused by non SMIMEException which can
647    * be one of the following: MessagingException UnsoportedEncodingException.
648    */
649   public void setContent(String content, String type, String externalPlainText) throws SMIMEException {
650
651     if(content != null) {
652       ByteArrayInputStream bais = null;
653       try {
654         if(this.charsetEnc != null)
655           bais = new ByteArrayInputStream ( content.getBytes(this.charsetEnc) );
656         else
657           bais = new ByteArrayInputStream ( content.getBytes("ISO-8859-1") );
658       }
659       catch(Exception e) {
660         throw SMIMEException.getInstance(this, e, "setContent");
661       }
662       this.setContent(bais, type);
663
664     }
665     else
666       throw new SMIMEException(this, 1035);
667   }
668
669
670   /**
671    * Sets message content from String. This method can be performed only once.
672    * Method is same as corresponding method setContent with three parameters,
673    * where third parameter is set to null. This setContent method (in case that second
674    * argument - type has value text/html) is used with autogeneration of text/plain
675    * message according to given html code in the process of generation
676    * multipart/alternative MimeMultipart message. For further information refer
677    * to setContent method with three arguments.
678    * @param content message content data given as String which can
679    * be text or html code and will be interpreted according to second parameter:
680    * "type". This argument is mandatory.
681    * @param type type of given content. It can take values: "text/plain" or
682    * "text/html". This argument is mandatory.
683    * @exception SMIMEException if content is tried to be added twice , in case of
684    * wrong "type" parameter or in case when parameter content is null. Also, it can
685    * be caused by non SMIMEException which is MessagingException.
686    */
687   public void setContent(String content, String type) throws SMIMEException {
688
689     this.setContent(content, type, null);
690   }
691
692   /**
693    * Sets message content from file represented by File object. This method can be
694    * performed only once. Message content can be given in two differrent forms:
695    * text and html code. If content is type of text, parameter "type" should be
696    * "text/plain", while if content is type of html code, parameter "type" should
697    * be set as "html/code". Note that for this method, location of resources
698    * needed by html file (pictures, sounds... ) shouldn't be defined in html code
699    * as they should be passed as InputStream arrays. For further information refer
700    * to setContent method with five arguments (String, String, String, InputStream[], String)
701    * which is called by this method.
702    * @param inFile location of file which is used for content of the message.
703    * This argument is mandatory.
704    * @param type type of given content. It can take values: "text/plain" or
705    * "text/html". This argument is mandatory.
706    * @param externalPlainText external text/plain message represented as String.
707    * This argument is used as alternative message to given html message in the process
708    * of generation multipart/alternative MimeMultipart message. If this argument
709    * has value null then autogeneration of text/plain message is performed
710    * according to passed html code (content argument). Also, it is set to null
711    * in case of text/plain message.
712    * @exception SMIMEException if content is tried to be added twice, in case of
713    * wrong "type" parameter, or if passed file (as File object) does not exist in
714    * file sistem. Also, it can be caused by non SMIMEException which can be one of
715    * the following: MessagingException or IOException.
716    */
717   public void setContent(File inFile, String type, String externalPlainText) throws SMIMEException {
718
719     if(contentPresence)
720       throw new SMIMEException(this, 1049);
721     if(inFile != null && inFile.exists()) {
722       try {
723         File inFileAbs = inFile.getAbsoluteFile().getCanonicalFile();
724         String content = ConvertAssist.fileToString(inFileAbs);
725         this.setContent(content, type, inFile.getParent(), null, externalPlainText);
726       }
727       catch(Exception e) {
728         throw SMIMEException.getInstance(this, e, "setContent");
729       }
730     }
731     else
732       throw new SMIMEException(this, 1034);
733   }
734
735   /**
736    * Sets message content from file represented by File object. This method can be
737    * performed only once. Method is the same as corresponding method setContent with
738    * three parameters, where third parameter is set to null. This setContent
739    * method (in case that second argument - type has value text/html) is used
740    * with autogeneration of text/plain message according to given html code in
741    * the process of generation multipart/alternative MimeMultipart message. For further
742    * information refer to corresponding setContent method with thre arguments.
743    * @param inFile location of file which is used for content of the message.
744    * This argument is mandatory.
745    * @param type type of given content. It can take values: "text/plain" or
746    * "text/html".
747    * @exception SMIMEException if content is tried to be added twice , in case of
748    * wrong "type" parameter or in case when parameter content is null. Also, it can
749    * be caused by non SMIMEException which is MessagingException.
750    */
751   public void setContent(File inFile, String type) throws SMIMEException {
752     this.setContent(inFile, type, null);
753   }
754
755   /**
756    * Adds file as attachment to email message. Content-Type will be automatically
757    * detected. Note that for linux files, if they are recognised as files with
758    * text/... MIME Content-Type, line breaks (LF) will be transformed to Windows
759    * line breaks (CRLF). Same transformation will be performed to single Carriage
760    * Return (CR) character. If linux textual file should be transported via
761    * email untouched, the best solution is to force usage of BASE64 encoding with
762    * other addAttachment() method.
763    * @param fileName path and file name used for attachment
764    * @exception SMIMEException if passed file (as File object) does not exist in
765    * the file sistem. Also, it can be caused by non SMIMEException which is
766    * MessagingException
767    */
768   public void addAttachment (String fileName) throws SMIMEException
769   {
770     File fn = new File (fileName);
771     this.addAttachment(fn);
772   }
773
774   /**
775    * Adds file as attachment to email message with given value for prefered
776    * Content-Transfer-Encoding argument. Attachment will be encoded acording to
777    * this parameter. Be carful with usage of this method, because you must know
778    * nature and content of file well, to avoid errors in encoding. Since this
779    * method does not employ automatic detection of Content-Transfer-Encoding,
780    * it is sligtly faster. Note that for linux textual files, if they are encoded
781    * as quoted-printable, line breaks (LF) will be transformed to Windows line
782    * breaks (CRLF). Same transformation will be performed to single Carriage
783    * Return (CR) character. If linux textual file should be transported
784    * via email untouched, the best solution is to force usage of BASE64 encoding.
785    * @param fileName path and file name used for attachment
786    * @param encoding Content-Transfer-Encoding value. It can take values: 7bit,
787    * quoted-printable, and base64
788    * @exception SMIMEException if passed file (as File object) does not exist in
789    * the file sistem. Also, it can be caused by non SMIMEException which is
790    * MessagingException
791    */
792   public void addAttachment (String fileName, String encoding) throws SMIMEException
793   {
794     File fn = new File (fileName);
795     this.addAttachment(fn, encoding);
796   }
797
798   /**
799    * Adds file as attachment to email message. Content-Type will be automatically
800    * detected. Note that for linux files, if they are recognised as files with
801    * text/... MIME Content-Type, line breaks (LF) will be transformed to Windows
802    * line breaks (CRLF). Same transformation will be performed to single Carriage
803    * Return (CR) character. If linux textual file should be transported via
804    * email untouched, the best solution is to force usage of BASE64 encoding with
805    * other addAttachment() method.
806    * @param file used for attachment represented as File object
807    * @exception SMIMEException if passed file (as File object) does not exist in
808    * the file sistem. Also, it can be caused by non SMIMEException which is
809    * MessagingException or IOException
810    */
811   public void addAttachment (File file) throws SMIMEException
812   {
813     if(!file.exists())
814       throw new SMIMEException(this, 1034);
815     try {
816       FileInputStream fis = new FileInputStream (file);
817       int u = fis.available();
818       this.addAttachment(fis, file.getName());
819     }
820     catch(Exception e) {
821       throw SMIMEException.getInstance(this, e, "addAttachment");
822     }
823   }
824
825   /**
826    * Adds file as attachment to email message with given value for prefered
827    * Content-Transfer-Encoding argument. Attachment will be encoded acording to
828    * this parameter. Be carful with usage of this method, because you must know
829    * nature and content of file well, to avoid errors in encoding. Since this
830    * method does not employ automatic detection of Content-Transfer-Encoding,
831    * it is sligtly faster. Note that for linux textual files, if they are encoded
832    * as quoted-printable, line breaks (LF) will be transformed to Windows line
833    * breaks (CRLF). Same transformation will be performed to single Carriage
834    * Return (CR) character. If linux tex