1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

    27  * @(#)MimeMultipart.java     1.31 03/01/29

    28  */

    29 

    30 

    31 

    32 package com.sun.xml.internal.messaging.saaj.packaging.mime.internet;

    33 

    34 import java.io.*;

    35 import java.util.BitSet;

    36 

    37 import javax.activation.DataSource;

    38 

    39 import com.sun.xml.internal.messaging.saaj.packaging.mime.*;

    40 import com.sun.xml.internal.messaging.saaj.packaging.mime.util.*;

    41 

    42 import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;

    43 

    44 /**

    45  * The MimeMultipart class is an implementation of the abstract Multipart

    46  * class that uses MIME conventions for the multipart data. <p>

    47  *

    48  * A MimeMultipart is obtained from a MimePart whose primary type

    49  * is "multipart" (by invoking the part's <code>getContent()</code> method)

    50  * or it can be created by a client as part of creating a new MimeMessage. <p>

    51  *

    52  * The default multipart subtype is "mixed".  The other multipart

    53  * subtypes, such as "alternative", "related", and so on, can be

    54  * implemented as subclasses of MimeMultipart with additional methods

    55  * to implement the additional semantics of that type of multipart

    56  * content. The intent is that service providers, mail JavaBean writers

    57  * and mail clients will write many such subclasses and their Command

    58  * Beans, and will install them into the JavaBeans Activation

    59  * Framework, so that any JavaMail implementation and its clients can

    60  * transparently find and use these classes. Thus, a MIME multipart

    61  * handler is treated just like any other type handler, thereby

    62  * decoupling the process of providing multipart handlers from the

    63  * JavaMail API. Lacking these additional MimeMultipart subclasses,

    64  * all subtypes of MIME multipart data appear as MimeMultipart objects. <p>

    65  *

    66  * An application can directly construct a MIME multipart object of any

    67  * subtype by using the <code>MimeMultipart(String subtype)</code>

    68  * constructor.  For example, to create a "multipart/alternative" object,

    69  * use <code>new MimeMultipart("alternative")</code>.

    70  *

    71  */

    72 

    73 //TODO: cleanup the SharedInputStream handling

    74 public  class BMMimeMultipart extends MimeMultipart {

    75 

    76     /*

    77      * When true it indicates parsing hasnt been done at all

    78      */

    79     private boolean begining = true;

    80 

    81     int[] bcs = new int[256];

    82     int[] gss = null;

    83     private static final int BUFFER_SIZE = 4096;

    84     private byte[] buffer = new byte[BUFFER_SIZE];

    85     private byte[] prevBuffer = new byte[BUFFER_SIZE];

    86     private BitSet lastPartFound = new BitSet(1);

    87 

    88     // cached inputstream which is possibly partially consumed

    89     private InputStream in = null;

    90     private String boundary = null;

    91     // current stream position, set to -1 on EOF

    92     int b = 0;

    93 

    94     // property to indicate if lazyAttachments is ON

    95     private boolean lazyAttachments = false;

    96 

    97     /**

    98      * Default constructor. An empty MimeMultipart object

    99      * is created. Its content type is set to "multipart/mixed".

   100      * A unique boundary string is generated and this string is

   101      * setup as the "boundary" parameter for the

   102      * <code>contentType</code> field. <p>

   103      *

   104      * MimeBodyParts may be added later.

   105      */

   106     public BMMimeMultipart() {

   107         super();

   108         //this("mixed");

   109     }

   110 

   111     /**

   112      * Construct a MimeMultipart object of the given subtype.

   113      * A unique boundary string is generated and this string is

   114      * setup as the "boundary" parameter for the

   115      * <code>contentType</code> field. <p>

   116      *

   117      * MimeBodyParts may be added later.

   118      */

   119     public BMMimeMultipart(String subtype) {

   120         super(subtype);

   121         /*

   122          * Compute a boundary string.

   123         String boundary = UniqueValue.getUniqueBoundaryValue();

   124         ContentType cType = new ContentType("multipart", subtype, null);

   125         contentType.setParameter("boundary", boundary);

   126          */

   127     }

   128 

   129     /**

   130      * Constructs a MimeMultipart object and its bodyparts from the

   131      * given DataSource. <p>

   132      *

   133      * This constructor handles as a special case the situation where the

   134      * given DataSource is a MultipartDataSource object.  In this case, this

   135      * method just invokes the superclass (i.e., Multipart) constructor

   136      * that takes a MultipartDataSource object. <p>

   137      *

   138      * Otherwise, the DataSource is assumed to provide a MIME multipart

   139      * byte stream.  The <code>parsed</code> flag is set to false.  When

   140      * the data for the body parts are needed, the parser extracts the

   141      * "boundary" parameter from the content type of this DataSource,

   142      * skips the 'preamble' and reads bytes till the terminating

   143      * boundary and creates MimeBodyParts for each part of the stream.

   144      *

   145      * @param   ds      DataSource, can be a MultipartDataSource

   146      */

   147     public BMMimeMultipart(DataSource ds, ContentType ct)

   148         throws MessagingException {

   149         super(ds,ct);

   150         boundary = ct.getParameter("boundary");

   151         /*

   152         if (ds instanceof MultipartDataSource) {

   153             // ask super to do this for us.

   154             setMultipartDataSource((MultipartDataSource)ds);

   155             return;

   156         }

   157 

   158         // 'ds' was not a MultipartDataSource, we have

   159         // to parse this ourself.

   160         parsed = false;

   161         this.ds = ds;

   162         if (ct==null)

   163             contentType = new ContentType(ds.getContentType());

   164         else

   165             contentType = ct;

   166        */

   167 

   168     }

   169 

   170     public InputStream initStream() throws MessagingException {

   171 

   172         if (in == null) {

   173             try {

   174                 in = ds.getInputStream();

   175                 if (!(in instanceof ByteArrayInputStream) &&

   176                     !(in instanceof BufferedInputStream) &&

   177                     !(in instanceof SharedInputStream))

   178                     in = new BufferedInputStream(in);

   179             } catch (Exception ex) {

   180                 throw new MessagingException("No inputstream from datasource");

   181             }

   182 

   183             if (!in.markSupported()) {

   184                 throw new MessagingException(

   185                     "InputStream does not support Marking");

   186             }

   187         }

   188         return in;

   189     }

   190 

   191     /**

   192      * Parse the InputStream from our DataSource, constructing the

   193      * appropriate MimeBodyParts.  The <code>parsed</code> flag is

   194      * set to true, and if true on entry nothing is done.  This

   195      * method is called by all other methods that need data for

   196      * the body parts, to make sure the data has been parsed.

   197      *

   198      * @since   JavaMail 1.2

   199      */

   200     protected  void parse() throws  MessagingException {

   201         if (parsed)

   202             return;

   203 

   204         initStream();

   205 

   206         SharedInputStream sin = null;

   207         if (in instanceof SharedInputStream) {

   208             sin = (SharedInputStream)in;

   209         }

   210 

   211         String bnd = "--" + boundary;

   212         byte[] bndbytes = ASCIIUtility.getBytes(bnd);

   213         try {

   214             parse(in, bndbytes, sin);

   215         } catch (IOException ioex) {

   216             throw new MessagingException("IO Error", ioex);

   217         } catch (Exception ex) {

   218             throw new MessagingException("Error", ex);

   219         }

   220 

   221         parsed = true;

   222     }

   223 

   224     public boolean lastBodyPartFound() {

   225         return lastPartFound.get(0);

   226     }

   227 

   228     public MimeBodyPart getNextPart(

   229         InputStream stream, byte[] pattern, SharedInputStream sin)

   230         throws Exception {

   231 

   232         if (!stream.markSupported()) {

   233             throw new Exception("InputStream does not support Marking");

   234         }

   235 

   236         if (begining) {

   237             compile(pattern);

   238             if (!skipPreamble(stream, pattern, sin)) {

   239                 throw new Exception(

   240                     "Missing Start Boundary, or boundary does not start on a new line");

   241             }

   242             begining = false;

   243         }

   244 

   245         if (lastBodyPartFound()) {

   246             throw new Exception("No parts found in Multipart InputStream");

   247         }

   248 

   249         if (sin != null) {

   250             long start = sin.getPosition();

   251             b = readHeaders(stream);

   252             if (b == -1) {

   253                 throw new Exception(

   254                     "End of Stream encountered while reading part headers");

   255             }

   256             long[] v = new long[1];

   257             v[0] = -1; // just to ensure the code later sets it correctly

   258             b = readBody(stream, pattern, v, null, sin);

   259             // looks like this check has to be disabled

   260             // it is allowed to have Mime Package without closing boundary

   261             if (!ignoreMissingEndBoundary) {

   262                 if ((b == -1) && !lastBodyPartFound()) {

   263                     throw new MessagingException("Missing End Boundary for Mime Package : EOF while skipping headers");

   264                 }

   265             }

   266             long end = v[0];

   267             MimeBodyPart mbp = createMimeBodyPart(sin.newStream(start, end));

   268             addBodyPart(mbp);

   269             return mbp;

   270 

   271         } else {

   272             InternetHeaders headers = createInternetHeaders(stream);

   273             ByteOutputStream baos = new ByteOutputStream();

   274             b = readBody(stream, pattern, null,baos, null);

   275             // looks like this check has to be disabled

   276             // in the old impl it is allowed to have Mime Package

   277             // without closing boundary

   278             if (!ignoreMissingEndBoundary) {

   279                 if ((b == -1) && !lastBodyPartFound()) {

   280                     throw new MessagingException("Missing End Boundary for Mime Package : EOF while skipping headers");

   281                 }

   282             }

   283             MimeBodyPart mbp = createMimeBodyPart(

   284                 headers, baos.getBytes(), baos.getCount());

   285             addBodyPart(mbp);

   286             return mbp;

   287         }

   288 

   289     }

   290 

   291     public boolean parse(

   292         InputStream stream, byte[] pattern, SharedInputStream sin)

   293         throws Exception {

   294 

   295         while (!lastPartFound.get(0) && (b != -1)) {

   296            getNextPart(stream, pattern, sin);

   297         }

   298         return true;

   299     }

   300 

   301     private int readHeaders(InputStream is) throws Exception {

   302         // if the headers are to end properly then there has to be CRLF

   303         // actually we just need to mark the start and end positions

   304         int b = is.read();

   305         while(b != -1) {

   306             // when it is a shared input stream no need to copy

   307             if (b == '\r') {

   308                 b = is.read();

   309                 if (b == '\n') {

   310                     b = is.read();

   311                     if (b == '\r') {

   312                         b = is.read();

   313                         if (b == '\n') {

   314                            return b;

   315                         } else {

   316                             continue;

   317                         }

   318                     } else {

   319                         continue;

   320                     }

   321                 } else {

   322                     continue;

   323                 }

   324             }

   325             b = is.read();

   326         }

   327         if (b == -1) {

   328             throw new Exception(

   329             "End of inputstream while reading Mime-Part Headers");

   330         }

   331         return b;

   332     }

   333 

   334     private int readBody(

   335         InputStream is, byte[] pattern, long[] posVector,

   336         ByteOutputStream baos, SharedInputStream sin)

   337         throws Exception {

   338         if (!find(is, pattern, posVector, baos, sin)) {

   339             throw new Exception(

   340             "Missing boundary delimitier while reading Body Part");

   341         }

   342         return b;

   343     }

   344 

   345     private boolean skipPreamble(

   346         InputStream is, byte[] pattern, SharedInputStream sin)

   347         throws Exception {

   348         if (!find(is, pattern, sin)) {

   349             return false;

   350         }

   351         if (lastPartFound.get(0)) {

   352             throw new Exception(

   353             "Found closing boundary delimiter while trying to skip preamble");

   354         }

   355         return true;

   356     }

   357 

   358 

   359     public int  readNext(InputStream is, byte[] buff, int patternLength,

   360         BitSet eof, long[] posVector, SharedInputStream sin)

   361         throws Exception {

   362 

   363         int bufferLength = is.read(buffer, 0, patternLength);

   364         if (bufferLength == -1) {

   365            eof.flip(0);

   366         } else if (bufferLength < patternLength) {

   367             //repeatedly read patternLength - bufferLength

   368             int temp = 0;

   369             long pos = 0;

   370             int i = bufferLength;

   371             for (; i < patternLength; i++) {

   372                 if (sin != null) {

   373                     pos = sin.getPosition();

   374                 }

   375                 temp = is.read();

   376                 if (temp == -1) {

   377                     eof.flip(0);

   378                     if (sin != null) {

   379                         posVector[0] = pos;

   380                     }

   381                     break;

   382                 }

   383                 buffer[i] = (byte)temp;

   384             }

   385             bufferLength=i;

   386         }

   387         return bufferLength;

   388     }

   389 

   390     public boolean find(InputStream is, byte[] pattern, SharedInputStream sin)

   391         throws Exception {

   392         int i;

   393         int l = pattern.length;

   394         int lx = l -1;

   395         BitSet eof = new BitSet(1);

   396         long[] posVector = new long[1];

   397 

   398         while (true) {

   399             is.mark(l);

   400             readNext(is, buffer, l, eof, posVector, sin);

   401             if (eof.get(0)) {

   402                 // End of stream

   403                 return false;

   404             }

   405 

   406             /*

   407             if (bufferLength < l) {

   408                 //is.reset();

   409                 return false;

   410             }*/

   411 

   412             for(i = lx; i >= 0; i--) {

   413                 if (buffer[i] != pattern[i]) {

   414                     break;

   415                 }

   416             }

   417 

   418             if (i < 0) {

   419                 // found the boundary, skip *LWSP-char and CRLF

   420                 if (!skipLWSPAndCRLF(is)) {

   421                     throw new Exception("Boundary does not terminate with CRLF");

   422                 }

   423                 return true;

   424             }

   425 

   426             int s = Math.max(i + 1 - bcs[buffer[i] & 0x7f], gss[i]);

   427             is.reset();

   428             is.skip(s);

   429         }

   430     }

   431 

   432     public boolean find(

   433         InputStream is, byte[] pattern, long[] posVector,

   434         ByteOutputStream out, SharedInputStream sin) throws Exception {

   435         int i;

   436         int l = pattern.length;

   437         int lx = l -1;

   438         int bufferLength = 0;

   439         int s = 0;

   440         long endPos = -1;

   441         byte[] tmp = null;

   442 

   443         boolean first = true;

   444         BitSet eof = new BitSet(1);

   445 

   446         while (true) {

   447             is.mark(l);

   448             if (!first) {

   449                 tmp = prevBuffer;

   450                 prevBuffer = buffer;

   451                 buffer = tmp;

   452             }

   453             if (sin != null) {

   454                 endPos = sin.getPosition();

   455             }

   456 

   457             bufferLength = readNext(is, buffer, l, eof, posVector, sin);

   458 

   459             if (bufferLength == -1) {

   460                 // End of stream

   461                 // looks like it is allowed to not have a closing boundary

   462                 //return false;

   463                 //if (sin != null) {

   464                  //   posVector[0] = endPos;

   465                 //}

   466                 b = -1;

   467                 if ((s == l) && (sin == null)) {

   468                     out.write(prevBuffer, 0, s);

   469                 }

   470                 return true;

   471             }

   472 

   473             if (bufferLength < l) {

   474                 if (sin != null) {

   475                     //endPos = sin.getPosition();

   476                     //posVector[0] = endPos;

   477                 } else {

   478                     // looks like it is allowed to not have a closing boundary

   479                     // in the old implementation

   480                         out.write(buffer, 0, bufferLength);

   481                 }

   482                 // looks like it is allowed to not have a closing boundary

   483                 // in the old implementation

   484                 //return false;

   485                 b = -1;

   486                 return true;

   487             }

   488 

   489             for(i = lx; i >= 0; i--) {

   490                 if (buffer[i] != pattern[i]) {

   491                     break;

   492                 }

   493             }

   494 

   495             if (i < 0) {

   496                 if (s > 0) {

   497                     //looks like the earlier impl allowed just an LF

   498                     // so if s == 1 : it must be an LF

   499                     // if s == 2 : it must be a CR LF

   500                     if (s <= 2) {

   501                         //it could be "some-char\n" so write some-char

   502                         if (s == 2) {

   503                             if (prevBuffer[1] == '\n') {

   504                                 if (prevBuffer[0] != '\r' && prevBuffer[0] != '\n') {

   505                                     out.write(prevBuffer,0,1);

   506                                 }

   507                                 if (sin != null) {

   508                                     posVector[0] = endPos;

   509                                 }

   510 

   511                             } else {

   512                                 throw new Exception(

   513                                         "Boundary characters encountered in part Body " +

   514                                         "without a preceeding CRLF");

   515                             }

   516 

   517                         } else if (s==1) {

   518                             if (prevBuffer[0] != '\n') {

   519                                 throw new Exception(

   520                                         "Boundary characters encountered in part Body " +

   521                                         "without a preceeding CRLF");

   522                             }else {

   523                                 if (sin != null) {

   524                                     posVector[0] = endPos;

   525                                 }

   526                             }

   527                         }

   528 

   529                     } else if (s > 2) {

   530                         if ((prevBuffer[s-2] == '\r') && (prevBuffer[s-1] == '\n')) {

   531                             if (sin != null) {

   532                                 posVector[0] = endPos - 2;

   533                             } else {

   534                                 out.write(prevBuffer, 0, s - 2);

   535                             }

   536                         } else if (prevBuffer[s-1] == '\n') {

   537                             //old impl allowed just a \n

   538                             if (sin != null) {

   539                                 posVector[0] = endPos - 1;

   540                             } else {

   541                                 out.write(prevBuffer, 0, s - 1);

   542                             }

   543                         } else {

   544                             throw new Exception(

   545                                 "Boundary characters encountered in part Body " +

   546                                 "without a preceeding CRLF");

   547                         }

   548                     }

   549                 }

   550                 // found the boundary, skip *LWSP-char and CRLF

   551                 if (!skipLWSPAndCRLF(is)) {

   552                     //throw new Exception(

   553                     //   "Boundary does not terminate with CRLF");

   554                 }

   555                 return true;

   556             }

   557 

   558             if ((s > 0) && (sin == null)) {

   559                 if (prevBuffer[s-1] == (byte)13) {

   560                     // if buffer[0] == (byte)10

   561                     if (buffer[0] == (byte)10) {

   562                         int j;

   563                         for(j = lx-1; j > 0; j--) {

   564                             if (buffer[j+1] != pattern[j]) {

   565                                 break;

   566                              }

   567                          }

   568                          if (j == 0) {

   569                              // matched the pattern excluding the last char of the pattern

   570                              // so dont write the CR into stream

   571                              out.write(prevBuffer,0,s-1);

   572                          } else {

   573                              out.write(prevBuffer,0,s);

   574                          }

   575                     } else {

   576                         out.write(prevBuffer, 0, s);

   577                     }

   578                 } else {

   579                     out.write(prevBuffer, 0, s);

   580                 }

   581             }

   582 

   583             s = Math.max(i + 1 - bcs[buffer[i] & 0x7f], gss[i]);

   584             is.reset();

   585             is.skip(s);

   586             if (first) {

   587                 first = false;

   588             }

   589         }

   590     }

   591 

   592     private boolean skipLWSPAndCRLF(InputStream is) throws Exception {

   593 

   594         b = is.read();

   595         //looks like old impl allowed just a \n as well

   596         if (b == '\n') {

   597             return true;

   598         }

   599 

   600         if (b == '\r') {

   601             b = is.read();

   602             //skip any multiple '\r' "\r\n" --> "\r\r\n" on Win2k

   603             if (b == '\r') {

   604                 b = is.read();

   605             }

   606             if (b == '\n') {

   607                 return true;

   608             } else {

   609                 throw new Exception(

   610                     "transport padding after a Mime Boundary  should end in a CRLF, found CR only");

   611             }

   612         }

   613 

   614         if (b == '-') {

   615             b = is.read();

   616             if (b != '-') {

   617                throw new Exception(

   618                    "Unexpected singular '-' character after Mime Boundary");

   619             } else {

   620                 //System.out.println("Last Part Found");

   621                 lastPartFound.flip(0);

   622                 // read the next char

   623                 b  = is.read();

   624             }

   625         }

   626 

   627         while ((b != -1) && ((b == ' ') || (b == '\t'))) {

   628             b = is.read();

   629             if (b == '\n') {

   630                 return true;

   631             }

   632             if (b == '\r') {

   633                 b = is.read();

   634                 //skip any multiple '\r': "\r\n" --> "\r\r\n" on Win2k

   635                 if (b == '\r') {

   636                     b = is.read();

   637                 }

   638                 if (b == '\n') {

   639                    return true;

   640                 }

   641             }

   642         }

   643 

   644         if (b == -1) {

   645             // the last boundary need not have CRLF

   646             if (!lastPartFound.get(0)) {

   647                 throw new Exception(

   648                         "End of Multipart Stream before encountering  closing boundary delimiter");

   649             }

   650             return true;

   651         }

   652         return false;

   653     }

   654 

   655     private void compile(byte[] pattern) {

   656         int l = pattern.length;

   657 

   658         int i;

   659         int j;

   660 

   661         // Copied from J2SE 1.4 regex code

   662         // java.util.regex.Pattern.java

   663 

   664         // Initialise Bad Character Shift table

   665         for (i = 0; i < l; i++) {

   666             bcs[pattern[i]] = i + 1;

   667         }

   668 

   669         // Initialise Good Suffix Shift table

   670         gss = new int[l];

   671   NEXT: for (i = l; i > 0; i--) {

   672             // j is the beginning index of suffix being considered

   673             for (j = l - 1; j >= i; j--) {

   674                 // Testing for good suffix

   675                 if (pattern[j] == pattern[j - i]) {

   676                     // pattern[j..len] is a good suffix

   677                     gss[j - 1] = i;

   678                 } else {

   679                    // No match. The array has already been

   680                    // filled up with correct values before.

   681                    continue NEXT;

   682                 }

   683             }

   684             while (j > 0) {

   685                 gss[--j] = i;

   686             }

   687         }

   688         gss[l - 1] = 1;

   689     }

   690 

   691 

   692     /**

   693      * Iterates through all the parts and outputs each Mime part

   694      * separated by a boundary.

   695      */

   696 

   697     public void writeTo(OutputStream os)

   698             throws IOException, MessagingException {

   699 

   700         // inputStream was not null

   701         if (in != null) {

   702             contentType.setParameter("boundary", this.boundary);

   703         }

   704 

   705         String bnd = "--" + contentType.getParameter("boundary");

   706         for (int i = 0; i < parts.size(); i++) {

   707             OutputUtil.writeln(bnd, os); // put out boundary

   708             ((MimeBodyPart)parts.get(i)).writeTo(os);

   709             OutputUtil.writeln(os); // put out empty line

   710         }

   711 

   712         if (in != null) {

   713             OutputUtil.writeln(bnd, os); // put out boundary

   714             if ((os instanceof ByteOutputStream) && lazyAttachments) {

   715                 ((ByteOutputStream) os).write(in);

   716             } else {

   717                 ByteOutputStream baos = null;

   718                 try {

   719                     baos = new ByteOutputStream(in.available());

   720                     baos.write(in);

   721                     baos.writeTo(os);

   722                     // reset the inputstream so that we can support a

   723                     // getAttachment later

   724                     in = baos.newInputStream();

   725                 } finally {

   726                     if (baos != null)

   727                         baos.close();

   728                 }

   729             }

   730 

   731             // this will endup writing the end boundary

   732         } else {

   733             // put out last boundary

   734             OutputUtil.writeAsAscii(bnd, os);

   735             OutputUtil.writeAsAscii("--", os);

   736         }

   737     }

   738 

   739     public void setInputStream(InputStream is) {

   740         this.in = is;

   741     }

   742 

   743     public InputStream getInputStream() {

   744         return this.in;

   745     }

   746 

   747     public void setBoundary(String bnd) {

   748         this.boundary = bnd;

   749         if (this.contentType != null) {

   750             this.contentType.setParameter("boundary", bnd);

   751         }

   752     }

   753     public String getBoundary() {

   754         return this.boundary;

   755     }

   756 

   757     public boolean isEndOfStream() {

   758         return (b == -1);

   759     }

   760 

   761     public void setLazyAttachments(boolean flag) {

   762         lazyAttachments = flag;

   763     }

   764 

   765 }