| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package javax.mail; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.PrintStream; |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.InvocationTargetException; |
| import java.net.InetAddress; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.StringTokenizer; |
| import java.util.WeakHashMap; |
| |
| |
| /** |
| * OK, so we have a final class in the API with a heck of a lot of implementation required... |
| * let's try and figure out what it is meant to do. |
| * <p/> |
| * It is supposed to collect together properties and defaults so that they can be |
| * shared by multiple applications on a desktop; with process isolation and no |
| * real concept of shared memory, this seems challenging. These properties and |
| * defaults rely on system properties, making management in a app server harder, |
| * and on resources loaded from "mail.jar" which may lead to skew between |
| * differnet independent implementations of this API. |
| * |
| * @version $Rev$ $Date$ |
| */ |
| public final class Session { |
| private static final Class[] PARAM_TYPES = {Session.class, URLName.class}; |
| private static final WeakHashMap addressMapsByClassLoader = new WeakHashMap(); |
| private static Session DEFAULT_SESSION; |
| |
| private Map passwordAuthentications = new HashMap(); |
| |
| private final Properties properties; |
| private final Authenticator authenticator; |
| private boolean debug; |
| private PrintStream debugOut = System.out; |
| |
| private static final WeakHashMap providersByClassLoader = new WeakHashMap(); |
| |
| /** |
| * No public constrcutor allowed. |
| */ |
| private Session(Properties properties, Authenticator authenticator) { |
| this.properties = properties; |
| this.authenticator = authenticator; |
| debug = Boolean.valueOf(properties.getProperty("mail.debug")).booleanValue(); |
| } |
| |
| /** |
| * Create a new session initialized with the supplied properties which uses the supplied authenticator. |
| * Clients should ensure the properties listed in Appendix A of the JavaMail specification are |
| * set as the defaults are unlikey to work in most scenarios; particular attention should be given |
| * to: |
| * <ul> |
| * <li>mail.store.protocol</li> |
| * <li>mail.transport.protocol</li> |
| * <li>mail.host</li> |
| * <li>mail.user</li> |
| * <li>mail.from</li> |
| * </ul> |
| * |
| * @param properties the session properties |
| * @param authenticator an authenticator for callbacks to the user |
| * @return a new session |
| */ |
| public static Session getInstance(Properties properties, Authenticator authenticator) { |
| return new Session(new Properties(properties), authenticator); |
| } |
| |
| /** |
| * Create a new session initialized with the supplied properties with no authenticator. |
| * |
| * @param properties the session properties |
| * @return a new session |
| * @see #getInstance(java.util.Properties, Authenticator) |
| */ |
| public static Session getInstance(Properties properties) { |
| return getInstance(properties, null); |
| } |
| |
| /** |
| * Get the "default" instance assuming no authenticator is required. |
| * |
| * @param properties the session properties |
| * @return if "default" session |
| * @throws SecurityException if the does not have permission to access the default session |
| */ |
| public synchronized static Session getDefaultInstance(Properties properties) { |
| return getDefaultInstance(properties, null); |
| } |
| |
| /** |
| * Get the "default" session. |
| * If there is not current "default", a new Session is created and installed as the default. |
| * |
| * @param properties |
| * @param authenticator |
| * @return if "default" session |
| * @throws SecurityException if the does not have permission to access the default session |
| */ |
| public synchronized static Session getDefaultInstance(Properties properties, Authenticator authenticator) { |
| if (DEFAULT_SESSION == null) { |
| DEFAULT_SESSION = getInstance(properties, authenticator); |
| } else { |
| if (authenticator != DEFAULT_SESSION.authenticator) { |
| if (authenticator == null || DEFAULT_SESSION.authenticator == null || authenticator.getClass().getClassLoader() != DEFAULT_SESSION.authenticator.getClass().getClassLoader()) { |
| throw new SecurityException(); |
| } |
| } |
| // todo we should check with the SecurityManager here as well |
| } |
| return DEFAULT_SESSION; |
| } |
| |
| /** |
| * Enable debugging for this session. |
| * Debugging can also be enabled by setting the "mail.debug" property to true when |
| * the session is being created. |
| * |
| * @param debug the debug setting |
| */ |
| public void setDebug(boolean debug) { |
| this.debug = debug; |
| } |
| |
| /** |
| * Get the debug setting for this session. |
| * |
| * @return the debug setting |
| */ |
| public boolean getDebug() { |
| return debug; |
| } |
| |
| /** |
| * Set the output stream where debug information should be sent. |
| * If set to null, System.out will be used. |
| * |
| * @param out the stream to write debug information to |
| */ |
| public void setDebugOut(PrintStream out) { |
| debugOut = out == null ? System.out : out; |
| } |
| |
| /** |
| * Return the debug output stream. |
| * |
| * @return the debug output stream |
| */ |
| public PrintStream getDebugOut() { |
| return debugOut; |
| } |
| |
| /** |
| * Return the list of providers available to this application. |
| * This method searches for providers that are defined in the javamail.providers |
| * and javamail.default.providers resources available through the current context |
| * classloader, or if that is not available, the classloader that loaded this class. |
| * <p/> |
| * As searching for providers is potentially expensive, this implementation maintains |
| * a WeakHashMap of providers indexed by ClassLoader. |
| * |
| * @return an array of providers |
| */ |
| public Provider[] getProviders() { |
| ProviderInfo info = getProviderInfo(); |
| return (Provider[]) info.all.toArray(new Provider[info.all.size()]); |
| } |
| |
| /** |
| * Return the provider for a specific protocol. |
| * This implementation initially looks in the Session properties for an property with the name |
| * "mail.<protocol>.class"; if found it attempts to create an instance of the class named in that |
| * property throwing a NoSuchProviderException if the class cannot be loaded. |
| * If this property is not found, it searches the providers returned by {@link #getProviders()} |
| * for a entry for the specified protocol. |
| * |
| * @param protocol the protocol to get a provider for |
| * @return a provider for that protocol |
| * @throws NoSuchProviderException |
| */ |
| public Provider getProvider(String protocol) throws NoSuchProviderException { |
| //If we are deployed into an OSGi environment, leverage it |
| Class<? extends Provider> providerClass = org.apache.servicemix.specs.locator.OsgiLocator.locate(Provider.class, protocol); |
| if (providerClass != null) { |
| try { |
| return (Provider) providerClass.newInstance(); |
| } catch (InstantiationException e) { |
| throw new NoSuchProviderException(e.getMessage()); |
| } catch (IllegalAccessException e) { |
| throw new NoSuchProviderException(e.getMessage()); |
| } |
| } |
| |
| ProviderInfo info = getProviderInfo(); |
| Provider provider = null; |
| String providerName = properties.getProperty("mail." + protocol + ".class"); |
| if (providerName != null) { |
| provider = (Provider) info.byClassName.get(providerName); |
| if (debug) { |
| writeDebug("DEBUG: new provider loaded: " + provider.toString()); |
| } |
| } |
| |
| // if not able to locate this by class name, just grab a registered protocol. |
| if (provider == null) { |
| provider = (Provider) info.byProtocol.get(protocol); |
| } |
| |
| if (provider == null) { |
| throw new NoSuchProviderException("Unable to locate provider for protocol: " + protocol); |
| } |
| if (debug) { |
| writeDebug("DEBUG: getProvider() returning provider " + provider.toString()); |
| } |
| return provider; |
| } |
| |
| /** |
| * Make the supplied Provider the default for its protocol. |
| * |
| * @param provider the new default Provider |
| * @throws NoSuchProviderException |
| */ |
| public void setProvider(Provider provider) throws NoSuchProviderException { |
| ProviderInfo info = getProviderInfo(); |
| info.byProtocol.put(provider.getProtocol(), provider); |
| } |
| |
| /** |
| * Return a Store for the default protocol defined by the mail.store.protocol property. |
| * |
| * @return the store for the default protocol |
| * @throws NoSuchProviderException |
| */ |
| public Store getStore() throws NoSuchProviderException { |
| String protocol = properties.getProperty("mail.store.protocol"); |
| if (protocol == null) { |
| throw new NoSuchProviderException("mail.store.protocol property is not set"); |
| } |
| return getStore(protocol); |
| } |
| |
| /** |
| * Return a Store for the specified protocol. |
| * |
| * @param protocol the protocol to get a Store for |
| * @return a Store |
| * @throws NoSuchProviderException if no provider is defined for the specified protocol |
| */ |
| public Store getStore(String protocol) throws NoSuchProviderException { |
| Provider provider = getProvider(protocol); |
| return getStore(provider); |
| } |
| |
| /** |
| * Return a Store for the protocol specified in the given URL |
| * |
| * @param url the URL of the Store |
| * @return a Store |
| * @throws NoSuchProviderException if no provider is defined for the specified protocol |
| */ |
| public Store getStore(URLName url) throws NoSuchProviderException { |
| return (Store) getService(getProvider(url.getProtocol()), url); |
| } |
| |
| /** |
| * Return the Store specified by the given provider. |
| * |
| * @param provider the provider to create from |
| * @return a Store |
| * @throws NoSuchProviderException if there was a problem creating the Store |
| */ |
| public Store getStore(Provider provider) throws NoSuchProviderException { |
| if (Provider.Type.STORE != provider.getType()) { |
| throw new NoSuchProviderException("Not a Store Provider: " + provider); |
| } |
| return (Store) getService(provider, null); |
| } |
| |
| /** |
| * Return a closed folder for the supplied URLName, or null if it cannot be obtained. |
| * <p/> |
| * The scheme portion of the URL is used to locate the Provider and create the Store; |
| * the returned Store is then used to obtain the folder. |
| * |
| * @param name the location of the folder |
| * @return the requested folder, or null if it is unavailable |
| * @throws NoSuchProviderException if there is no provider |
| * @throws MessagingException if there was a problem accessing the Store |
| */ |
| public Folder getFolder(URLName name) throws MessagingException { |
| Store store = getStore(name); |
| return store.getFolder(name); |
| } |
| |
| /** |
| * Return a Transport for the default protocol specified by the |
| * <code>mail.transport.protocol</code> property. |
| * |
| * @return a Transport |
| * @throws NoSuchProviderException |
| */ |
| public Transport getTransport() throws NoSuchProviderException { |
| String protocol = properties.getProperty("mail.transport.protocol"); |
| if (protocol == null) { |
| throw new NoSuchProviderException("mail.transport.protocol property is not set"); |
| } |
| return getTransport(protocol); |
| } |
| |
| /** |
| * Return a Transport for the specified protocol. |
| * |
| * @param protocol the protocol to use |
| * @return a Transport |
| * @throws NoSuchProviderException |
| */ |
| public Transport getTransport(String protocol) throws NoSuchProviderException { |
| Provider provider = getProvider(protocol); |
| return getTransport(provider); |
| } |
| |
| /** |
| * Return a transport for the protocol specified in the URL. |
| * |
| * @param name the URL whose scheme specifies the protocol |
| * @return a Transport |
| * @throws NoSuchProviderException |
| */ |
| public Transport getTransport(URLName name) throws NoSuchProviderException { |
| return (Transport) getService(getProvider(name.getProtocol()), name); |
| } |
| |
| /** |
| * Return a transport for the protocol associated with the type of this address. |
| * |
| * @param address the address we are trying to deliver to |
| * @return a Transport |
| * @throws NoSuchProviderException |
| */ |
| public Transport getTransport(Address address) throws NoSuchProviderException { |
| String type = address.getType(); |
| // load the address map from the resource files. |
| Map addressMap = getAddressMap(); |
| String protocolName = (String)addressMap.get(type); |
| if (protocolName == null) { |
| throw new NoSuchProviderException("No provider for address type " + type); |
| } |
| return getTransport(protocolName); |
| } |
| |
| /** |
| * Return the Transport specified by a Provider |
| * |
| * @param provider the defining Provider |
| * @return a Transport |
| * @throws NoSuchProviderException |
| */ |
| public Transport getTransport(Provider provider) throws NoSuchProviderException { |
| return (Transport) getService(provider, null); |
| } |
| |
| /** |
| * Set the password authentication associated with a URL. |
| * |
| * @param name the url |
| * @param authenticator the authenticator |
| */ |
| public void setPasswordAuthentication(URLName name, PasswordAuthentication authenticator) { |
| if (authenticator == null) { |
| passwordAuthentications.remove(name); |
| } else { |
| passwordAuthentications.put(name, authenticator); |
| } |
| } |
| |
| /** |
| * Get the password authentication associated with a URL |
| * |
| * @param name the URL |
| * @return any authenticator for that url, or null if none |
| */ |
| public PasswordAuthentication getPasswordAuthentication(URLName name) { |
| return (PasswordAuthentication) passwordAuthentications.get(name); |
| } |
| |
| /** |
| * Call back to the application supplied authenticator to get the needed username add password. |
| * |
| * @param host the host we are trying to connect to, may be null |
| * @param port the port on that host |
| * @param protocol the protocol trying to be used |
| * @param prompt a String to show as part of the prompt, may be null |
| * @param defaultUserName the default username, may be null |
| * @return the authentication information collected by the authenticator; may be null |
| */ |
| public PasswordAuthentication requestPasswordAuthentication(InetAddress host, int port, String protocol, String prompt, String defaultUserName) { |
| if (authenticator == null) { |
| return null; |
| } |
| return authenticator.authenticate(host, port, protocol, prompt, defaultUserName); |
| } |
| |
| /** |
| * Return the properties object for this Session; this is a live collection. |
| * |
| * @return the properties for the Session |
| */ |
| public Properties getProperties() { |
| return properties; |
| } |
| |
| /** |
| * Return the specified property. |
| * |
| * @param property the property to get |
| * @return its value, or null if not present |
| */ |
| public String getProperty(String property) { |
| return getProperties().getProperty(property); |
| } |
| |
| |
| /** |
| * Add a provider to the Session managed provider list. |
| * |
| * @param provider The new provider to add. |
| */ |
| public synchronized void addProvider(Provider provider) { |
| ProviderInfo info = getProviderInfo(); |
| info.addProvider(provider); |
| } |
| |
| |
| |
| /** |
| * Add a mapping between an address type and a protocol used |
| * to process that address type. |
| * |
| * @param addressType |
| * The address type identifier. |
| * @param protocol The protocol name mapping. |
| */ |
| public void setProtocolForAddress(String addressType, String protocol) { |
| Map addressMap = getAddressMap(); |
| |
| // no protocol specified is a removal |
| if (protocol == null) { |
| addressMap.remove(addressType); |
| } |
| else { |
| addressMap.put(addressType, protocol); |
| } |
| } |
| |
| |
| private Service getService(Provider provider, URLName name) throws NoSuchProviderException { |
| try { |
| if (name == null) { |
| name = new URLName(provider.getProtocol(), null, -1, null, null, null); |
| } |
| |
| //If we are deployed into an OSGi environment, leverage it |
| Class<? extends Service> providerClass = org.apache.servicemix.specs.locator.OsgiLocator.locate(Service.class, provider.getClassName()); |
| if (providerClass != null) { |
| try { |
| Constructor ctr = providerClass.getConstructor(PARAM_TYPES); |
| return (Service) ctr.newInstance(this, name); |
| } catch (InstantiationException e) { |
| throw new NoSuchProviderException(e.getMessage()); |
| } catch (IllegalAccessException e) { |
| throw new NoSuchProviderException(e.getMessage()); |
| } |
| } |
| |
| ClassLoader cl = getClassLoader(); |
| Class clazz = cl.loadClass(provider.getClassName()); |
| Constructor ctr = clazz.getConstructor(PARAM_TYPES); |
| return (Service) ctr.newInstance(this, name); |
| } catch (ClassNotFoundException e) { |
| throw (NoSuchProviderException) new NoSuchProviderException("Unable to load class for provider: " + provider).initCause(e); |
| } catch (NoSuchMethodException e) { |
| throw (NoSuchProviderException) new NoSuchProviderException("Provider class does not have a constructor(Session, URLName): " + provider).initCause(e); |
| } catch (InstantiationException e) { |
| throw (NoSuchProviderException) new NoSuchProviderException("Unable to instantiate provider class: " + provider).initCause(e); |
| } catch (IllegalAccessException e) { |
| throw (NoSuchProviderException) new NoSuchProviderException("Unable to instantiate provider class: " + provider).initCause(e); |
| } catch (InvocationTargetException e) { |
| throw (NoSuchProviderException) new NoSuchProviderException("Exception from constructor of provider class: " + provider).initCause(e.getCause()); |
| } |
| } |
| |
| private ProviderInfo getProviderInfo() { |
| ClassLoader cl = getClassLoader(); |
| ProviderInfo info = (ProviderInfo) providersByClassLoader.get(cl); |
| if (info == null) { |
| info = loadProviders(cl); |
| } |
| return info; |
| } |
| |
| private Map getAddressMap() { |
| ClassLoader cl = getClassLoader(); |
| Map addressMap = (Map)addressMapsByClassLoader.get(cl); |
| if (addressMap == null) { |
| addressMap = loadAddressMap(cl); |
| } |
| return addressMap; |
| } |
| |
| |
| /** |
| * Resolve a class loader used to resolve context resources. The |
| * class loader used is either a current thread context class |
| * loader (if set), the class loader used to load an authenticator |
| * we've been initialized with, or the class loader used to load |
| * this class instance (which may be a subclass of Session). |
| * |
| * @return The class loader used to load resources. |
| */ |
| private ClassLoader getClassLoader() { |
| ClassLoader cl = Thread.currentThread().getContextClassLoader(); |
| if (cl == null) { |
| if (authenticator != null) { |
| cl = authenticator.getClass().getClassLoader(); |
| } |
| else { |
| cl = this.getClass().getClassLoader(); |
| } |
| } |
| return cl; |
| } |
| |
| private ProviderInfo loadProviders(ClassLoader cl) { |
| // we create a merged map from reading all of the potential address map entries. The locations |
| // searched are: |
| // 1. java.home/lib/javamail.address.map |
| // 2. META-INF/javamail.address.map |
| // 3. META-INF/javamail.default.address.map |
| // |
| ProviderInfo info = new ProviderInfo(); |
| |
| // make sure this is added to the global map. |
| providersByClassLoader.put(cl, info); |
| |
| |
| // NOTE: Unlike the addressMap, we process these in the defined order. The loading routine |
| // will not overwrite entries if they already exist in the map. |
| |
| try { |
| File file = new File(System.getProperty("java.home"), "lib/javamail.providers"); |
| InputStream is = new FileInputStream(file); |
| try { |
| loadProviders(info, is); |
| if (debug) { |
| writeDebug("Loaded lib/javamail.providers from " + file.toString()); |
| } |
| } finally{ |
| is.close(); |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| try { |
| Enumeration e = cl.getResources("META-INF/javamail.providers"); |
| while (e.hasMoreElements()) { |
| URL url = (URL) e.nextElement(); |
| if (debug) { |
| writeDebug("Loading META-INF/javamail.providers from " + url.toString()); |
| } |
| InputStream is = url.openStream(); |
| try { |
| loadProviders(info, is); |
| } finally{ |
| is.close(); |
| } |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| try { |
| Enumeration e = cl.getResources("META-INF/javamail.default.providers"); |
| while (e.hasMoreElements()) { |
| URL url = (URL) e.nextElement(); |
| if (debug) { |
| writeDebug("Loading javamail.default.providers from " + url.toString()); |
| } |
| |
| InputStream is = url.openStream(); |
| try { |
| loadProviders(info, is); |
| } finally{ |
| is.close(); |
| } |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| return info; |
| } |
| |
| private void loadProviders(ProviderInfo info, InputStream is) throws IOException { |
| BufferedReader reader = new BufferedReader(new InputStreamReader(is)); |
| String line; |
| while ((line = reader.readLine()) != null) { |
| // Lines beginning with "#" are just comments. |
| if (line.startsWith("#")) { |
| continue; |
| } |
| |
| StringTokenizer tok = new StringTokenizer(line, ";"); |
| String protocol = null; |
| Provider.Type type = null; |
| String className = null; |
| String vendor = null; |
| String version = null; |
| while (tok.hasMoreTokens()) { |
| String property = tok.nextToken(); |
| int index = property.indexOf('='); |
| if (index == -1) { |
| continue; |
| } |
| String key = property.substring(0, index).trim().toLowerCase(); |
| String value = property.substring(index+1).trim(); |
| if (protocol == null && "protocol".equals(key)) { |
| protocol = value; |
| } else if (type == null && "type".equals(key)) { |
| if ("store".equals(value)) { |
| type = Provider.Type.STORE; |
| } else if ("transport".equals(value)) { |
| type = Provider.Type.TRANSPORT; |
| } |
| } else if (className == null && "class".equals(key)) { |
| className = value; |
| } else if ("vendor".equals(key)) { |
| vendor = value; |
| } else if ("version".equals(key)) { |
| version = value; |
| } |
| } |
| if (protocol == null || type == null || className == null) { |
| //todo should we log a warning? |
| continue; |
| } |
| |
| if (debug) { |
| writeDebug("DEBUG: loading new provider protocol=" + protocol + ", className=" + className + ", vendor=" + vendor + ", version=" + version); |
| } |
| Provider provider = new Provider(type, protocol, className, vendor, version); |
| // add to the info list. |
| info.addProvider(provider); |
| } |
| } |
| |
| /** |
| * Load up an address map associated with a using class loader |
| * instance. |
| * |
| * @param cl The class loader used to resolve the address map. |
| * |
| * @return A map containing the entries associated with this classloader |
| * instance. |
| */ |
| private static Map loadAddressMap(ClassLoader cl) { |
| // we create a merged map from reading all of the potential address map entries. The locations |
| // searched are: |
| // 1. java.home/lib/javamail.address.map |
| // 2. META-INF/javamail.address.map |
| // 3. META-INF/javamail.default.address.map |
| // |
| // if all of the above searches fail, we just set up some "default" defaults. |
| |
| // the format of the address.map file is defined as a property file. We can cheat and |
| // just use Properties.load() to read in the files. |
| Properties addressMap = new Properties(); |
| |
| // add this to the tracking map. |
| addressMapsByClassLoader.put(cl, addressMap); |
| |
| // NOTE: We are reading these resources in reverse order of what's cited above. This allows |
| // user defined entries to overwrite default entries if there are similarly named items. |
| |
| try { |
| Enumeration e = cl.getResources("META-INF/javamail.default.address.map"); |
| while (e.hasMoreElements()) { |
| URL url = (URL) e.nextElement(); |
| InputStream is = url.openStream(); |
| try { |
| // load as a property file |
| addressMap.load(is); |
| } finally{ |
| is.close(); |
| } |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| |
| try { |
| Enumeration e = cl.getResources("META-INF/javamail.address.map"); |
| while (e.hasMoreElements()) { |
| URL url = (URL) e.nextElement(); |
| InputStream is = url.openStream(); |
| try { |
| // load as a property file |
| addressMap.load(is); |
| } finally{ |
| is.close(); |
| } |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| |
| try { |
| File file = new File(System.getProperty("java.home"), "lib/javamail.address.map"); |
| InputStream is = new FileInputStream(file); |
| try { |
| // load as a property file |
| addressMap.load(is); |
| } finally{ |
| is.close(); |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| try { |
| Enumeration e = cl.getResources("META-INF/javamail.address.map"); |
| while (e.hasMoreElements()) { |
| URL url = (URL) e.nextElement(); |
| InputStream is = url.openStream(); |
| try { |
| // load as a property file |
| addressMap.load(is); |
| } finally{ |
| is.close(); |
| } |
| } |
| } catch (SecurityException e) { |
| // ignore |
| } catch (IOException e) { |
| // ignore |
| } |
| |
| |
| // if unable to load anything, at least create the MimeMessage-smtp protocol mapping. |
| if (addressMap.isEmpty()) { |
| addressMap.put("rfc822", "smtp"); |
| } |
| |
| return addressMap; |
| } |
| |
| /** |
| * Private convenience routine for debug output. |
| * |
| * @param msg The message to write out to the debug stream. |
| */ |
| private void writeDebug(String msg) { |
| debugOut.println(msg); |
| } |
| |
| |
| private static class ProviderInfo { |
| private final Map byClassName = new HashMap(); |
| private final Map byProtocol = new HashMap(); |
| private final List all = new ArrayList(); |
| |
| public void addProvider(Provider provider) { |
| String className = provider.getClassName(); |
| |
| if (!byClassName.containsKey(className)) { |
| byClassName.put(className, provider); |
| } |
| |
| String protocol = provider.getProtocol(); |
| if (!byProtocol.containsKey(protocol)) { |
| byProtocol.put(protocol, provider); |
| } |
| all.add(provider); |
| } |
| } |
| } |
