Custom mail providers distributed under META-INF/javamail.properties are no longer loaded with Jakarta Mail 2.1.5 #812

Signed-off-by: Jorge Bescos Gascon <[email protected]>

Author: jbescos

api/src/main/java/jakarta/mail/Provider.java

@@ -22,7 +22,8 @@
  * configuring providers using the Java SE
  * {@link java.util.ServiceLoader ServiceLoader} mechanism.
  * As an alternative the values could come from the
- * javamail.providers and javamail.default.providers
+ * javamail.providers, javamail.default.providers,
+ * jakarta.providers and jakarta.default.providers
  * resource files.  An application may also create and
  * register a Provider object to dynamically add support
  * for a new provider.

api/src/main/java/jakarta/mail/Session.java

@@ -55,15 +55,22 @@
  * implement the <code>Store</code>, <code>Transport</code>, and related
  * classes.  The protocol providers are configured using the following files:
  * <ul>
- *  <li> <code>jakarta.providers</code> and
- * 	<code>jakarta.default.providers</code> </li>
- *  <li> <code>jakarta.address.map</code> and
+ *  <li> <code>javamail.providers</code>,
+ * 	<code>javamail.default.providers</code>,
+ *  <code>jakarta.providers</code> and
+ *  <code>jakarta.default.providers</code></li>
+ *  <li><code>javamail.address.map</code>,
+ *  <code>javamail.default.address.map</code>,
+ *  <code>jakarta.address.map</code> and
  * 	<code>jakarta.default.address.map</code> </li>
  * </ul>
  * <p>
- * Each <code>jakarta.</code><i>X</i> resource file is searched for using
- * three methods in the following order:
+ * Each <code>javamail.</code><i>X</i> and <code>jakarta.</code><i>X</i>
+ * resource file is searched for using three methods in the following order:
  * <ol>
+ *  <li> <code><i>java.home</i>/<i>conf</i>/javamail.</code><i>X</i> </li>
+ *  <li> <code>META-INF/javamail.</code><i>X</i> </li>
+ *  <li> <code>META-INF/javamail.default.</code><i>X</i> </li>
  *  <li> <code><i>java.home</i>/<i>conf</i>/jakarta.</code><i>X</i> </li>
  *  <li> <code>META-INF/jakarta.</code><i>X</i> </li>
  *  <li> <code>META-INF/jakarta.default.</code><i>X</i> </li>
@@ -79,7 +86,8 @@
  * <code>java.home</code> property points.  The second method allows an
  * application that uses the Jakarta Mail APIs to include their own resource
  * files in their application's or jar file's <code>META-INF</code>
- * directory.  The <code>jakarta.default.</code><i>X</i> default files
+ * directory.  The <code>javamail.default.</code><i>X</i> and
+ * <code>jakarta.default.</code><i>X</i> default files
  * are part of the Jakarta Mail <code>mail.jar</code> file and should not be
  * supplied by users. <p>
  *
@@ -96,6 +104,8 @@
  * do not override, the default files included with the Jakarta Mail APIs.
  * This means that all entries in all files loaded will be available. <p>
  *
+ * <b><code>javamail.providers</code></b>,
+ * <b><code>javamail.default.providers</code></b>,
  * <b><code>jakarta.providers</code></b> and
  * <b><code>jakarta.default.providers</code></b><p>
  *
@@ -168,13 +178,16 @@
  * </pre>
  * <p>
  *
+ * <b><code>javamail.address.map</code></b>,
+ * <b><code>javamail.default.address.map</code></b>,
  * <b><code>jakarta.address.map</code></b> and
  * <b><code>jakarta.default.address.map</code></b><p>
  *
  * These resource files map transport address types to the transport
  * protocol.  The <code>getType</code> method of
  * <code>jakarta.mail.Address</code> returns the address type.  The
- * <code>jakarta.address.map</code> file maps the transport type to the
+ * <code>javamail.address.map</code> and <code>jakarta.address.map</code>
+ * files map the transport type to the
  * protocol.  The file format is a series of name-value pairs.  Each key
  * name should correspond to an address type that is currently installed
  * on the system; there should also be an entry for each
@@ -202,11 +215,12 @@ public final class Session {
     // Support legacy @DefaultProvider
     private static final String DEFAULT_PROVIDER = "org.eclipse.angus.mail.util.DefaultProvider";
 
-    // This is for backwards compatibility. Eventually we have to remove the second value of the next arrays.
-    private static final String[] DEFAULT_ADDRESS_MAP_RESOURCES = new String[] {"/META-INF/jakarta.default.address.map", "/META-INF/javamail.default.address.map"};
-    private static final String[] ADDRESS_MAP_RESOURCES = new String[] {"META-INF/jakarta.address.map", "META-INF/javamail.address.map"};
-    private static final String[] DEFAULT_PROVIDER_RESOURCES = new String[] {"/META-INF/jakarta.default.providers", "/META-INF/javamail.default.providers"};
-    private static final String[] PROVIDER_RESOURCES = new String[] {"META-INF/jakarta.providers", "META-INF/javamail.providers"};
+    // This is for backwards compatibility. javamail has more precedence than jakarta to not break compatibility
+    // Eventually we have to remove the first value of the next arrays.
+    private static final String[] DEFAULT_ADDRESS_MAP_RESOURCES = new String[] {"/META-INF/javamail.default.address.map", "/META-INF/jakarta.default.address.map"};
+    private static final String[] ADDRESS_MAP_RESOURCES = new String[] {"META-INF/javamail.address.map", "META-INF/jakarta.address.map"};
+    private static final String[] DEFAULT_PROVIDER_RESOURCES = new String[] {"/META-INF/javamail.default.providers", "/META-INF/jakarta.default.providers"};
+    private static final String[] PROVIDER_RESOURCES = new String[] {"META-INF/javamail.providers", "META-INF/jakarta.providers"};
 
     private final StreamProvider streamProvider;
     private final Properties props;
@@ -467,8 +481,8 @@ public synchronized PrintStream getDebugOut() {
 
     /**
      * This method returns an array of all the implementations installed
-     * via the jakarta.[default.]providers files that can
-     * be loaded using the ClassLoader available to this application.
+     * via the javamail.[default.]providers and jakarta.[default.]providers
+     * files that can be loaded using the ClassLoader available to this application.
      *
      * @return Array of configured providers
      */
@@ -949,10 +963,10 @@ public void load(InputStream is) throws IOException {
             }
         };
 
-        // load system-wide jakarta.providers from the
+        // load system-wide javamail.providers and jakarta.providers from the
         // <java.home>/{conf,lib} directory
         if (confDir != null)
-            loadFile(loader, confDir + "jakarta.providers", confDir + "javamail.providers");
+            loadFile(loader, confDir + "javamail.providers", confDir + "jakarta.providers");
 
         //Fetch classloader of given class, falling back to others if needed.
         ClassLoader gcl;
@@ -978,10 +992,10 @@ public void load(InputStream is) throws IOException {
                 addProvider(p);
         }
 
-        // load the META-INF/jakarta.providers file supplied by an application
+        // load the META-INF/javamail.providers and META-INF/jakarta.providers file supplied by an application
         loadAllResources(cl, loader, PROVIDER_RESOURCES);
 
-        // load default META-INF/jakarta.default.providers from mail.jar file
+        // load default META-INF/javamail.providers and META-INF/jakarta.default.providers from mail.jar file
         loadResource(cl, loader, false, DEFAULT_PROVIDER_RESOURCES);
 
         // finally, add all the default services
@@ -1102,7 +1116,8 @@ private void loadProvidersFromStream(InputStream is) throws IOException {
      */
     public synchronized void addProvider(Provider provider) {
         providers.add(provider);
-        providersByClassName.put(provider.getClassName(), provider);
+        if (!providersByClassName.containsKey(provider.getClassName()))
+            providersByClassName.put(provider.getClassName(), provider);
         if (!providersByProtocol.containsKey(provider.getProtocol()))
             providersByProtocol.put(provider.getProtocol(), provider);
     }
@@ -1117,16 +1132,16 @@ public void load(InputStream is) throws IOException {
             }
         };
 
-        // load default META-INF/jakarta.default.address.map from mail.jar
+        // load default META-INF/javamail.default.address.map and META-INF/jakarta.default.address.map from mail.jar
         loadResource(cl, loader, true, DEFAULT_ADDRESS_MAP_RESOURCES);
 
-        // load the META-INF/jakarta.address.map file supplied by an app
+        // load the META-INF/javamail.address.map and META-INF/jakarta.address.map files supplied by an app
         loadAllResources(cl, loader, ADDRESS_MAP_RESOURCES);
 
-        // load system-wide jakarta.address.map from the
+        // load system-wide javamail.address.map and jakarta.address.map from the
         // <java.home>/{conf,lib} directory
         if (confDir != null)
-            loadFile(loader, confDir + "jakarta.address.map", confDir + "javamail.address.map");
+            loadFile(loader, confDir + "javamail.address.map", confDir + "jakarta.address.map");
 
         if (addressMap.isEmpty()) {
             logger.config("failed to load address map, using defaults");
@@ -1156,24 +1171,20 @@ public synchronized void setProtocolForAddress(String addresstype, String protoc
      * Load from the named file.
      */
     private void loadFile(StreamLoader loader, String ... names) {
-        InputStream clis = null;
-        for (String name : names) {
-            try {
-                clis = new BufferedInputStream(new FileInputStream(name));
+        for (int i = 0; i < names.length; i++) {
+            String name = names[i];
+            try (InputStream clis = new BufferedInputStream(new FileInputStream(name))) {
                 loader.load(clis);
                 logger.log(Level.CONFIG, "successfully loaded file: {0}", name);
-                break;
+                // We already know size is two, but just in case, we don't want to fail here for a logger reason
+                if (i == 0 && names.length == 2) {
+                    logger.log(Level.WARNING, "[DEPRECATED] {0} is deprecated and will be removed. Future versions will require {1}.", names[0], names[1]);
+                }
             } catch (FileNotFoundException fex) {
                 // ignore it
             } catch (IOException e) {
                 if (logger.isLoggable(Level.CONFIG))
                     logger.log(Level.CONFIG, "not loading file: " + name, e);
-            } finally {
-                try {
-                    if (clis != null)
-                        clis.close();
-                } catch (IOException ex) {
-                }    // ignore it
             }
         }
     }
@@ -1182,28 +1193,27 @@ private void loadFile(StreamLoader loader, String ... names) {
      * Load from the named resource.
      */
     private void loadResource(Class<?> cl, StreamLoader loader, boolean expected, String ... names) {
-        InputStream clis = null;
-        try {
-            for (String name : names) {
-                clis = getResourceAsStream(cl, name);
+        boolean loaded = false;
+        for (int i = 0; i < names.length; i++) {
+            String name = names[i];
+            try (InputStream clis = getResourceAsStream(cl, name)) {
                 if (clis != null) {
+                    loaded = true;
                     loader.load(clis);
                     logger.log(Level.CONFIG, "successfully loaded resource: {0}", name);
-                    break;
+                    // We already know size is two, but just in case, we don't want to fail here for a logger reason
+                    if (i == 0 && names.length == 2) {
+                        logger.log(Level.WARNING, "[DEPRECATED] {0} is deprecated and will be removed. Future versions will require {1}.", names[0], names[1]);
+                    }
                 }
+            } catch (IOException e) {
+                logger.log(Level.CONFIG, "Exception loading resource", e);
             }
-            if (clis == null) {
-                if (expected)
-                    logger.log(Level.WARNING, "expected resource not found: {0}", Arrays.asList(names));
-            }
-        } catch (IOException e) {
-            logger.log(Level.CONFIG, "Exception loading resource", e);
-        } finally {
-            try {
-                if (clis != null)
-                    clis.close();
-            } catch (IOException ex) {
-            }    // ignore it
+            
+        }
+        if (!loaded) {
+            if (expected)
+                logger.log(Level.WARNING, "expected resource not found: {0}", Arrays.asList(names));
         }
     }
 
@@ -1213,7 +1223,8 @@ private void loadResource(Class<?> cl, StreamLoader loader, boolean expected, St
     private void loadAllResources(Class<?> cl, StreamLoader loader, String ... names) {
         boolean anyLoaded = false;
         try {
-            for (String name : names) {
+            for (int j = 0; j < names.length; j++) {
+                String name = names[j];
                 URL[] urls;
                 ClassLoader cld = null;
                 // First try the "application's" class loader.
@@ -1227,10 +1238,8 @@ private void loadAllResources(Class<?> cl, StreamLoader loader, String ... names
                 if (urls != null) {
                     for (int i = 0; i < urls.length; i++) {
                         URL url = urls[i];
-                        InputStream clis = null;
                         logger.log(Level.CONFIG, "URL {0}", url);
-                        try {
-                            clis = url.openStream();
+                        try (InputStream clis = url.openStream()) {
                             if (clis != null) {
                                 loader.load(clis);
                                 anyLoaded = true;
@@ -1245,16 +1254,11 @@ private void loadAllResources(Class<?> cl, StreamLoader loader, String ... names
                         } catch (IOException ioex) {
                             logger.log(Level.CONFIG, "Exception loading resource",
                                     ioex);
-                        } finally {
-                            try {
-                                if (clis != null)
-                                    clis.close();
-                            } catch (IOException cex) {
-                            }
                         }
                     }
-                    if (anyLoaded) {
-                        break;
+                    // We already know size is two, but just in case, we don't want to fail here for a logger reason
+                    if (j == 0 && names.length == 2) {
+                        logger.log(Level.WARNING, "[DEPRECATED] {0} is deprecated and will be removed. Future versions will require {1}.", names[0], names[1]);
                     }
                 }
             }

api/src/main/java/jakarta/mail/internet/MimeUtility.java

@@ -40,6 +40,8 @@
 import java.util.NoSuchElementException;
 import java.util.Properties;
 import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * This is a utility class that provides various MIME related
@@ -139,9 +141,12 @@ public class MimeUtility {
     private MimeUtility() {
     }
 
+    private static final Logger LOGGER = Logger.getLogger(MimeUtility.class.getName());
+
     public static final int ALL = -1;
 
     // This is for backwards compatibility. Eventually we have to remove the second value of the next array.
+    // Note this order is different than in Session arrays. This is because here the key-value pair is overwritten.
     private static final String[] CHARSET_MAP_RESOURCES = new String[] {"/META-INF/jakarta.charset.map", "/META-INF/javamail.charset.map"};
 
     // cached map of whether a charset is compatible with ASCII
@@ -1353,29 +1358,27 @@ static String getDefaultMIMECharset() {
         java2mime = new HashMap<>(40);
         mime2java = new HashMap<>(14);
 
-        try {
-            // Use this class's classloader to load the mapping file
-            // XXX - we should use SecuritySupport, but it's in another package
-            InputStream is = resource(CHARSET_MAP_RESOURCES);
-
-            if (is != null) {
-                try {
+        // Use this class's classloader to load the mapping file
+        // XXX - we should use SecuritySupport, but it's in another package
+        for (int i = 0; i < CHARSET_MAP_RESOURCES.length; i++) {
+            String charsetResource = CHARSET_MAP_RESOURCES[i];
+            try (InputStream is = MimeUtility.class.getResourceAsStream(charsetResource)) {
+                if (is != null) {
                     LineInputStream lineInput = StreamProvider.provider().inputLineStream(is, false);
 
                     // Load the JDK-to-MIME charset mapping table
                     loadMappings(lineInput, java2mime);
 
                     // Load the MIME-to-JDK charset mapping table
                     loadMappings(lineInput, mime2java);
-                } finally {
-                    try {
-                        is.close();
-                    } catch (Exception cex) {
-                        // ignore
-                    }
                 }
+                // We already know size is two, but just in case, we don't want to fail here for a logger reason
+                if (i == 0 && CHARSET_MAP_RESOURCES.length == 2) {
+                    LOGGER.log(Level.WARNING, "[DEPRECATED] {0} is deprecated and will be removed. Future versions will require {1}.",
+                            new Object[]{CHARSET_MAP_RESOURCES[0], CHARSET_MAP_RESOURCES[1]});
+                }
+            } catch (Exception ex) {
             }
-        } catch (Exception ex) {
         }
 
         // If we didn't load the tables, e.g., because we didn't have
@@ -1444,16 +1447,6 @@ static String getDefaultMIMECharset() {
             mime2java.put("gbk", "GB18030");
         }
     }
-
-    private static InputStream resource(String[] resources) {
-        for (String resource : resources) {
-            InputStream is = MimeUtility.class.getResourceAsStream(resource);
-            if (is != null) {
-                return is;
-            }
-        }
-        return null;
-    }
 
     private static void loadMappings(LineInputStream is,
                                      Map<String, String> table) {