/*
* Parse the contents of this multipart message and create the
* child body parts.
*/
protected synchronized void parse() throws MessagingException {
if (parsed) return;
InputStream in = null;
try {
in = ds.getInputStream();
if (!(in instanceof ByteArrayInputStream) && !(in instanceof BufferedInputStream))
in = new BufferedInputStream(in);
} catch (Exception ex) {
throw new MessagingException("No inputstream from datasource");
}
String line;
int bl = boundary.length();
byte[] bndbytes = new byte[bl];
boundary.getBytes(0, bl, bndbytes, 0);
try {
/*
* Skip any kind of junk until we get to the first
* boundary line.
*/
LineInputStream lin = new LineInputStream(in);
while ((line = lin.readLine()) != null) {
if (line.trim().equals(boundary)) break;
}
if (line == null) throw new MessagingException("Missing start boundary");
/*
* Read and process body parts until we see the
* terminating boundary line (or EOF).
*/
for (; ; ) {
/*
* Collect the headers for this body part.
*/
InternetHeaders headers = new InternetHeaders(in);
if (!in.markSupported()) throw new MessagingException("Stream doesn't support mark");
ByteArrayOutputStream buf = new ByteArrayOutputStream();
int b;
/*
* Read and save the content bytes in buf.
*/
while ((b = in.read()) >= 0) {
if (b == '\r' || b == '\n') {
/*
* Found the end of a line, check whether the
* next line is a boundary.
*/
int i;
in.mark(bl + 4 + 1); // "4" for possible "--\r\n"
if (b == '\r' && in.read() != '\n') {
in.reset();
in.mark(bl + 4);
}
// read bytes, matching against the boundary
for (i = 0; i < bl; i++) if (in.read() != bndbytes[i]) break;
if (i == bl) {
int b2 = in.read();
// check for end of line
if (b2 == '\n') break; // got it! break out of the while loop
if (b2 == '\r') {
in.mark(1);
if (in.read() != '\n') in.reset();
break; // got it! break out of the while loop
}
}
// failed to match, reset and proceed normally
in.reset();
}
buf.write(b);
}
/*
* Create a SunV3BodyPart to represent this body part.
*/
SunV3BodyPart body = new SunV3BodyPart(headers, buf.toByteArray());
addBodyPart(body);
if (b < 0) break;
}
} catch (IOException e) {
throw new MessagingException("IO Error"); // XXX
}
parsed = true;
}
public static void dumpPart(Part p, biz.systempartners.claims.ClaimsViewer claimsViewer)
throws Exception {
if (p instanceof Message) dumpEnvelope((Message) p);
/**
* Dump input stream ..
*
* <p>InputStream is = p.getInputStream(); // If "is" is not already buffered, wrap a
* BufferedInputStream // around it. if (!(is instanceof BufferedInputStream)) is = new
* BufferedInputStream(is); int c; while ((c = is.read()) != -1) System.out.write(c);
*/
String ct = p.getContentType();
try {
pr("CONTENT-TYPE: " + (new ContentType(ct)).toString());
} catch (ParseException pex) {
pr("BAD CONTENT-TYPE: " + ct);
}
String filename = p.getFileName();
if (filename != null) pr("FILENAME: " + filename);
/*
* Using isMimeType to determine the content type avoids
* fetching the actual content data until we need it.
*/
if (p.isMimeType("text/plain")) {
pr("This is plain text");
pr("---------------------------");
if (!showStructure && !saveAttachments) System.out.println((String) p.getContent());
} else if (p.isMimeType("multipart/*")) {
pr("This is a Multipart");
pr("---------------------------");
Multipart mp = (Multipart) p.getContent();
level++;
int count = mp.getCount();
for (int i = 0; i < count; i++) dumpPart(mp.getBodyPart(i), claimsViewer);
level--;
} else if (p.isMimeType("message/rfc822")) {
pr("This is a Nested Message");
pr("---------------------------");
level++;
dumpPart((Part) p.getContent(), claimsViewer);
level--;
} else {
if (!showStructure && !saveAttachments) {
/*
* If we actually want to see the data, and it's not a
* MIME type we know, fetch it and check its Java type.
*/
Object o = p.getContent();
if (o instanceof String) {
pr("This is a string");
pr("---------------------------");
System.out.println((String) o);
} else if (o instanceof InputStream) {
pr("This is just an input stream");
pr("---------------------------");
InputStream is = (InputStream) o;
int c;
while ((c = is.read()) != -1) System.out.write(c);
} else {
pr("This is an unknown type");
pr("---------------------------");
pr(o.toString());
}
} else {
// just a separator
pr("---------------------------");
}
}
/*
* If we're saving attachments, write out anything that
* looks like an attachment into an appropriately named
* file. Don't overwrite existing files to prevent
* mistakes.
*/
if (saveAttachments && level != 0 && !p.isMimeType("multipart/*")) {
String disp = p.getDisposition();
// many mailers don't include a Content-Disposition
if (disp == null || disp.equalsIgnoreCase(Part.ATTACHMENT)) {
if (filename == null) filename = "Attachment" + attnum++;
pr("Saving attachment to file " + filename);
try {
File f = new File(System.getProperty("user.dir"), filename);
/* if (f.exists())
// XXX - could try a series of names
throw new IOException("file exists");*/
OutputStream os = new BufferedOutputStream(new FileOutputStream(f));
InputStream is = p.getInputStream();
int c;
while ((c = is.read()) != -1) os.write(c);
os.close();
if (p.isMimeType("text/xml") || p.isMimeType("application/octet-stream")) {
processBrRequisitionFile(
f, claimsViewer, claimsViewer.getInvoiceVector(), claimsViewer.getFilesVector());
}
System.out.println("I have saved file [" + f.getAbsolutePath() + "]");
} catch (IOException ex) {
pr("Failed to save attachment: " + ex);
}
pr("---------------------------");
}
}
}
public static void dumpPart(Part p) throws Exception {
if (p instanceof Message) {
Message m = (Message) p;
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++) System.out.println("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++) System.out.println("TO: " + a[j].toString());
}
// SUBJECT
System.out.println("SUBJECT: " + m.getSubject());
// DATE
Date d = m.getSentDate();
System.out.println("SendDate: " + (d != null ? d.toLocaleString() : "UNKNOWN"));
// FLAGS:
Flags flags = m.getFlags();
StringBuffer sb = new StringBuffer();
Flags.Flag[] sf = flags.getSystemFlags(); // get the system flags
boolean first = true;
for (int i = 0; i < sf.length; i++) {
String s;
Flags.Flag f = sf[i];
if (f == Flags.Flag.ANSWERED) s = "\\Answered";
else if (f == Flags.Flag.DELETED) s = "\\Deleted";
else if (f == Flags.Flag.DRAFT) s = "\\Draft";
else if (f == Flags.Flag.FLAGGED) s = "\\Flagged";
else if (f == Flags.Flag.RECENT) s = "\\Recent";
else if (f == Flags.Flag.SEEN) s = "\\Seen";
else continue; // skip it
if (first) first = false;
else sb.append(' ');
sb.append(s);
}
String[] uf = flags.getUserFlags(); // get the user flag strings
for (int i = 0; i < uf.length; i++) {
if (first) first = false;
else sb.append(' ');
sb.append(uf[i]);
}
System.out.println("FLAGS = " + sb.toString());
}
System.out.println("CONTENT-TYPE: " + p.getContentType());
/* Dump input stream
InputStream is = ((MimeMessage)m).getInputStream();
int c;
while ((c = is.read()) != -1)
System.out.write(c);
*/
Object o = p.getContent();
if (o instanceof String) {
System.out.println("This is a String");
System.out.println((String) o);
} else if (o instanceof Multipart) {
System.out.println("This is a Multipart");
Multipart mp = (Multipart) o;
int count = mp.getCount();
for (int i = 0; i < count; i++) dumpPart(mp.getBodyPart(i));
} else if (o instanceof InputStream) {
System.out.println("This is just an input stream");
InputStream is = (InputStream) o;
int c;
while ((c = is.read()) != -1) System.out.write(c);
}
}