/* * Created on 2004.08.19 * JFreeMail - Java mail component * Copyright (C) 2004 Dalibor Krleza *  * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. *  * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. *  * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */ package org.jfreemail.core;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.util.Vector;/** * Class for basic encoding, decoding and checking operations needed in * all other classes. */public class JfmCore {	/**	 * Static procedure for base64 decoding. Most of E-mail binaries 	 * are base64 coded. There could be other encodings, which should 	 * be implemented in future, as needed.	 * @param data List of strings representing binary value.	 * @return Decoded binary array.	 * @throws IOException Thrown on decoding exception.	 */	public static byte[] base64decode(String[] data) throws IOException {		ByteArrayOutputStream bos=new ByteArrayOutputStream();		long __data=0x00000000;		int turn=3;		byte[] temp_buffer=new byte[3];		for(int i=0;i<data.length;i++) {			for(int j=0;j<data[i].length();j++) {				byte in=base64fielde(data[i].charAt(j));				if (in>=0 && in<64) {					long __temp1=(byte)in & 0x000000FF;					__temp1<<=(turn*6);					__data|=__temp1;					turn--;				} else {					turn=-1;				}				if (turn<0) {					for(int k=0;k<3;k++) {						temp_buffer[2-k]=(byte)__data;						__data>>=8;					}					bos.write(temp_buffer);					turn=3;					__data=0;							}			}		}		return bos.toByteArray();	}	/**	 * Static procedure for base64 encoding. Used for binaries in E-mail.	 * Attachments etc...	 * @param data Binary array for encoding.	 * @return List of base64 encoded strings.	 * @throws IOException Thrown on encoding exception.	 */	public static String[] base64encode(byte[] data) throws IOException {		Vector lista_vec=new Vector();		long __data=0;		int chars=0;		String out=new String("");		boolean end_flag=false;				for(int i=0;i<data.length;i+=3) {			__data=0;			if (i<data.length) {				/* 				 * Java uses obsolete type of binary representation.				 * Every varijable uses MSB for sign representation. This doesn't				 * affect arithmetic operations. When performing logical operations,				 * MSB is allways calculated from both MSB's. This results				 * with MSB comparison no matter variable size.				 * For example, int's (16-bit) MSB is compared with byte's				 * (8 bit) MSB. Like:				 * 		              10100100 - negative number				 * OR 0xxxxxxx11111111 - positive number				 *        1xxxxxxx11111111 - negativne number				 * I ask myself how do they implement this operation in hardware??				 * No wonder Java is so terriby slow. We use a trick for negative				 * number correction in wider variable type, and then perform				 * logical operation.				 */				int b=(int)data[i];				if (b<0) b+=256;				__data|=(b<<16);			} else end_flag=true;			if ((i+1)<data.length) {				int b=(int)data[i+1];				if (b<0) b+=256;				__data|=(b<<8);			} else end_flag=true;			if ((i+2)<data.length) {				int b=(int)data[i+2];				if (b<0) b+=256;				__data|=(b);			} else end_flag=true;						for(int j=0;j<4;j++) {				__data<<=6;				long x=__data & 0xFF000000;				__data&=0x00FFFFFF;				x>>=24;				byte y=(byte)x;				if (end_flag) {					char c='=';					if (y>0) c=base64fieldd(y);					out+=c;				} else {					char c=base64fieldd(y);					out+=c;				}				chars++;				if (chars==76) {					lista_vec.add(out);					out=new String("");					chars=0;				}			}		}		lista_vec.add(out);		String[] lista=new String[lista_vec.size()];		for(int i=0;i<lista_vec.size();i++)			lista[i]=(String)lista_vec.elementAt(i);		return lista;	}		/**	 * Procedure for character into byte tranformation. Used when decoding	 * base64 content. This procedure converts 8-bit character information	 * into 6-bit information used for decoding.	 * @param c Character for converting into 6-bit info. 	 * @return 6-bit info in byte variable.	 */	public static byte base64fielde(char c) {		byte x=(byte)c;		if (x>=65 && x<=90) return (byte)(x-65);		if (x>=97 && x<=122) return (byte)(x-71);		if (x>=48 && x<=57) return (byte)(x+4);		if (x==43) return (byte)62;		if (x==47) return (byte)63;		if (c=='=') return (byte)0x00;		return (byte)0xFF;	}		/**	 * Procedure for byte into character transformation. Used when encoding	 * base64 content. This procedure convert 6-bit info in byte variable into	 * character.	 * @param b 6-bit info in byte variable.	 * @return Character accoring to 6-bit info.	 */	public static char base64fieldd(byte b) {		if (b>=0 && b<=25) return (char)(b+65);		if (b>25 && b<=51) return (char)(b+71);		if (b>51 && b<=61) return (char)(b-4);		if (b==62) return(char)43;		if (b==63) return(char)47;		return '=';	}		/**	 * Inner procedure for checking positive or negative result from SMTP.	 * @param line Resulting line, answered from server.	 * @return Operation succesfull or not.	 */	public static boolean checkSMTPresult(String line) {		if (line.charAt(0)=='1' || line.charAt(0)=='2' || line.charAt(0)=='3') return true;		return false;	}		/**	 * Method for checking text mime types. See JfmConsts for details.	 * @param mime_type Mime/type to check.	 * @return true if text mime/type otherwise false.	 */	public static boolean checkTextType(String mime_type) {		boolean result=false;		for(int i=0;i<JfmConsts.TEXT_MIME_TYPES.length;i++) {			if (mime_type.toUpperCase().equals(JfmConsts.TEXT_MIME_TYPES[i]))				result=true;		}		return result;	}}