jfmpop3.java

java邮件源程序

			String t_line=untransformed(list,i);
			String line=t_line.substring(0,t_line.length()-2);
			if (line.toUpperCase().indexOf("CONTENT-TRANSFER-ENCODING:")>=0) {
				int index=line.indexOf(":");
				String subvalue=line.substring(index+2,line.length());
				part.setContentEncoding(subvalue);
			}
		}
		String[] message=new String[list.size()-1-email.getEmailHeader().getHeaderLength()];
		for(int i=email.getEmailHeader().getHeaderLength();i<(list.size()-1);i++) message[i-email.getEmailHeader().getHeaderLength()]=transform(list,i,part.getContentCharset());
		part.setContent(message);
		email.addEmailPart(part);
	}
	
	/*
	 * Method used for parsing multipart E-mail. First we must detect part
	 * delimiter and cut part by part out of E-mail. When cutted out, E-mail
	 * part is passed to method for part parsing. This method could be
	 * recursive, as one part can contain more subparts, every subpart
	 * can contain more subsubparts, etc.. For example, this multilevel part 
	 * hierarchy uses Outlook Express.
	 */
	private void beginParseMultipart(JfmEmail email,Vector list,String delimiter) throws CoreException {
		int part_no=0,last=0;
		for(int i=0;i<list.size();i++) {
			String t_line=untransformed(list,i);
			if (t_line.indexOf("--"+delimiter)==0) {
				part_no++;
				if (part_no>1) {
					Vector sublist=cutBuffer(list,last,i);
					decodePart(email,sublist);
				}
				last=i+1;
			}
		}
	}
	
	/*
	 * When decoding multipart E-mail, this i called for parsing single part.
	 * Here we are detecting part properties. If part contains multipart
	 * mime/type, we are initiating recursive call.
	 * All other parts are decoposed and stored into appropriate Java bean
	 * object.
	 */
	private void decodePart(JfmEmail email,Vector list) throws CoreException {
		String __dp_content_type=new String("text/plain");
		String __dp_content_charset=new String("UTF-8");
		String __dp_content_name=new String();
		String __dp_content_encoding=new String("8bit");
		String __dp_subdelimiter=null;
		
		int i=0;
		while(!untransformed(list,i).equals("\r\n")) {
			String t_line=untransformed(list,i);
			String line=t_line.substring(0,t_line.length()-2);
			if (line.toUpperCase().indexOf("CONTENT-TYPE")>=0) {
				int index1=line.indexOf(":");
				int index2=line.indexOf(";");
				if (index2<0) __dp_content_type=line.substring(index1+2,line.length());
				else __dp_content_type=line.substring(index1+2,index2);
			}
			int index=line.toUpperCase().indexOf("CHARSET=");
			if (index>=0) {
				String subvalue=line.substring(index+8,line.length());
				int index1=subvalue.indexOf(" ");
				if (subvalue.charAt(0)=='"') {
					subvalue=subvalue.substring(1,subvalue.length());
					index1=subvalue.indexOf("\"");
				} 
				if (index1<0) index1=subvalue.length();
				__dp_content_charset=subvalue.substring(0,index1);
			}
			index=line.toUpperCase().indexOf("NAME=");
			if (index>=0) {
				String subvalue=line.substring(index+5,line.length());
				int index1=subvalue.indexOf(" ");
				if (subvalue.charAt(0)=='"') {
					subvalue=subvalue.substring(1,subvalue.length());
					index1=subvalue.indexOf("\"");	
				} 
				if (index1<0) index1=subvalue.length();
				__dp_content_name=subvalue.substring(0,index1);
			}
			if (line.toUpperCase().indexOf("CONTENT-TRANSFER-ENCODING")>=0) {
				int index1=line.indexOf(":");
				__dp_content_encoding=line.substring(index1+2,line.length());
			}
			index=line.toUpperCase().indexOf("BOUNDARY=");
			if (index>=0) {
				/*
				 * If this happends, we are reading subparts. After this, recursion
				 * is initiated with part delimiter we gonna read in this block.
				 */
				String subvalue=line.substring(index+9,line.length());
				int index1=subvalue.indexOf(" ");
				if (subvalue.charAt(0)=='"') {
					subvalue=subvalue.substring(1,subvalue.length());
					index1=subvalue.indexOf("\"");	
				}
				if (index1<0) index1=subvalue.length();
				__dp_subdelimiter=subvalue.substring(0,index1);
			}
			i++;
		}
		if (__dp_content_type.toUpperCase().indexOf("MULTIPART")>=0) {
			/*
			 * If this happends, we are reading subparts. After this, recursion
			 * call is initiated.
			 */
			if (__dp_subdelimiter==null) throw new CoreException("COR_005:Multipart without part delimiter");
			beginParseMultipart(email,list,__dp_subdelimiter);
		} else if (__dp_content_type.toUpperCase().indexOf("MESSAGE/RFC822")>=0) {
			/*
			 * We have run onto E-mail inside E-mail 
			 */ 
			 JfmEmailHeader header=new JfmEmailHeader();
			 int j=i+1;
			 while(!untransformed(list,j).equals("\r\n")) {
			 	parseHeaderLine(header,untransformed(list,j));
			 	j++;
			 }
			 header.setHeaderLength(j-i);
			 ByteArrayOutputStream bos=new ByteArrayOutputStream();
			 try {
			 	for(j=i+1;j<list.size();j++) bos.write((byte[])list.elementAt(j));
			 } catch(IOException exc) {
			 	throw new CoreException("COR_010:Error reconstructing binary array for parsing sub E-mail");
			 }
			 JfmEmail new_email=new JfmEmail(header);
			 parseMessage(new_email,bos.toByteArray());
			 email.addEmailPart(new_email);
		}
		else {
			String[] message=new String[list.size()-i-1];
			if (JfmCore.checkTextType(__dp_content_type)) {
					/*
					 * Part we are parsing is pure text or html part. Use appropriate
					 * Java bean to store this text message.
					 */
					JfmEmailTextPart part=new JfmEmailTextPart();
					part.setContentType(__dp_content_type);
					part.setContentCharset(__dp_content_charset);
					part.setContentEncoding(__dp_content_encoding);
					for(int j=i+1;j<list.size();j++)	message[j-(i+1)]=transform(list,j,part.getContentCharset());
					part.setContent(message);
					email.addEmailPart(part);
			} else {
				/*
				 * Part we are parsing is binary part. Use appropriate Java bean
				 * to store binary attachment.
				 */
				JfmEmailBinaryPart part=new JfmEmailBinaryPart();
				part.setContentType(__dp_content_type);
				part.setContentEncoding(__dp_content_encoding);
				part.setContentName(__dp_content_name);
				for(int j=i+1;j<list.size();j++)	message[j-(i+1)]=untransformed(list,j);
				byte[] binary=null;
				/*
				 * Watch following decoding. If we are parsing binary attachment,
				 * we must watch for part encoding. For now, I've supported
				 * base64 encoding as most used. All other encodings will throw
				 * exception. Here you can add your code to support other type
				 * of binary encodings.
				 */
				if (part.getContentEncoding().toUpperCase().indexOf("BASE64")>=0) {
					for (int j=0;j<message.length;j++) message[j]=message[j].substring(0,message[j].length()-2);
					try {
						binary=JfmCore.base64decode(message);
					} catch(IOException exc) {
						throw new CoreException("COR_007:Error during BASE64 decoding");	
					}
				} else throw new CoreException("COR_006:Uknown binary data encoding:"+part.getContentEncoding());
				part.setContent(binary);
				email.addEmailPart(part);
			}
		}
	}
	
	/*
	 * Read byte array from vector and try to form string in wanted
	 * characterset. If not possible throw exception.
	 */
	private String transform(Vector list,int index,String charset) 
	throws CoreException {
		if (charset==null || charset.length()==0) 
			throw new CoreException("COR_001:Ne defined charset for decoding");
		if (index<0 || index>=list.size())
			throw new CoreException("COR_003:E-mail line index out of range");
		byte[] buffer=(byte[])list.elementAt(index);
		String r=null;
		try {
			r=new String(buffer,charset);
		} catch(UnsupportedEncodingException exc) {
			throw new CoreException("COR_007:Unsupported charset");
		}
		return r; 
	}
	
	/*
	 * Read byte array from vector and do not form string with caracterset.
	 * Use OS default characterset to from string. Here could occur problems
	 * when using this component on different operating systems. This method
	 * is tested on RedHat Linux 9.
	 */
	private String untransformed(Vector list,int index) 
	throws CoreException {
		if (index<0 || index>=list.size())
			throw new CoreException("COR_003:E-mail line index out of range");
		byte[] buffer=(byte[])list.elementAt(index);			
		return new String(buffer);
	}
	
	/*
	 * Cut out part of vector. Cutting for multipart E-mails. Cutting out single
	 * part or subpart or subsubpart, etc...
	 */
	private Vector cutBuffer(Vector list,int i1,int i2) {
		Vector r=new Vector();
		for(int i=i1;i<i2;i++) {
			r.addElement(list.elementAt(i));
		}
		return r;
	}
	
	/*
	 * Method for parsing E-mail header. We pass in empty E-mail header
	 * Java bean and downloaded header from POP3 server. We call other
	 * method for parsing for every header line.
	 */
	private void parseHeader(JfmEmailHeader eheader,String[] list) throws CoreException {
		eheader.setHeaderLength(list.length-1);
		for(int i=0;i<list.length;i++)
			parseHeaderLine(eheader,list[i]);
	}
	
	/*
	 * Parsing single line from E-mail header.
	 */
	private void parseHeaderLine(JfmEmailHeader eheader,String line) throws CoreException {
		String test_line=line.toUpperCase();
		int delimiter=test_line.indexOf(":");
		int last=line.length()-2;
		if (delimiter>=0) {
			String value=line.substring(delimiter+2,last);
			if (test_line.indexOf("FROM")>=0) eheader.setFrom(value); 
			if (test_line.indexOf("TO")>=0) eheader.addTo(value); 
			if (test_line.indexOf("CC")>=0) eheader.addCC(value); 
			if (test_line.indexOf("SUBJECT")>=0) decodeSubject(eheader,value);
			if (test_line.indexOf("MESSAGE-ID")>=0) eheader.setMsgId(value);
			if (test_line.indexOf("DATE")>=0) {
				String subvalue=value.substring(0,value.length());
				eheader.setEmailDateStr(subvalue); 
			}
			if (test_line.indexOf("CONTENT-TYPE")>=0) {
				int index=value.indexOf(";");
				if (index<0) eheader.setContentType(value);
				else eheader.setContentType(value.substring(0,index));
			}
			if (test_line.indexOf("RETURN-PATH")>=0) {
				int index1=value.indexOf("<");
				int index2=value.indexOf(">");
				eheader.setReturnAddr(value.substring(index1,index2+1));
			}
		}
		if (test_line.indexOf("BOUNDARY=")>=0) {
			int index1=test_line.indexOf("BOUNDARY=");
			String subvalue=line.substring(index1+9,line.length());
			int index2=subvalue.indexOf(" ");
			if (subvalue.charAt(0)=='"') {
				subvalue=subvalue.substring(1,subvalue.length());
				index2=subvalue.indexOf("\"");
			}
			if (index2<0) index2=subvalue.length()-2;
			subvalue=subvalue.substring(0,index2);
			eheader.setContentTypeDelimiter(subvalue);
		}
		if (test_line.indexOf("CHARSET=")>=0) {
			int index1=test_line.indexOf("CHARSET=");
			String subvalue=line.substring(index1+8,line.length());
			int index2=subvalue.indexOf(" ");
			if (subvalue.charAt(0)=='"') {
				subvalue=subvalue.substring(1,subvalue.length());
				index2=subvalue.indexOf("\"");
			}
			if (index2<0) index2=subvalue.length()-2;
			subvalue=subvalue.substring(0,index2);
			eheader.setContentCharset(subvalue);
		}
	}
	
	/*
	 * Special method for decoding subject line. Subject line can be sent
	 * in base64 format with special characterset. This is used only when
	 * special characterset needed to present subject. All header lines
	 * must be in plain ASCII, so we can't transmit two-byte characters
	 * correctly.
	 */
	private void decodeSubject(JfmEmailHeader eheader,String subject) throws CoreException {
		if (subject.indexOf("=?")==0) {
			int index1=subject.indexOf("?");
			String value=subject.substring(index1+1,subject.length());
			index1=value.indexOf("?");
			eheader.setSubjectCharset(value.substring(0,index1));
			index1=value.indexOf("B?");
			value=value.substring(index1+2,value.length());
			index1=value.indexOf("?=");
			byte[] list=null;
			try {
				list=JfmCore.base64decode(new String[] {value.substring(0,index1)});
			} catch(IOException exc) {
				throw new CoreException("COR_007:Error decoding subject line");
			}
			try {
				eheader.setSubject(new String(list,eheader.getSubjectCharset()));
			} catch(UnsupportedEncodingException exc) {
				throw new CoreException("COR_008:Requested character set not supported");
			}
		} else {
			eheader.setSubjectCharset(new String());
			eheader.setSubject(subject);
		}
	}
}