com.sun.mail.pop3.POP3Store Maven / Gradle / Ivy
/*
* Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package com.sun.mail.pop3;
import java.util.Locale;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.lang.reflect.*;
import jakarta.mail.*;
import jakarta.mail.internet.*;
import java.io.File;
import java.io.PrintStream;
import java.io.IOException;
import java.io.EOFException;
import java.util.Collections;
import java.util.Map;
import com.sun.mail.util.PropUtil;
import com.sun.mail.util.MailLogger;
import com.sun.mail.util.SocketConnectException;
import com.sun.mail.util.MailConnectException;
/**
* A POP3 Message Store. Contains only one folder, "INBOX".
*
* See the com.sun.mail.pop3 package
* documentation for further information on the POP3 protocol provider.
*
* @author Bill Shannon
* @author John Mani
*/
public class POP3Store extends Store {
private String name = "pop3"; // my protocol name
private int defaultPort = 110; // default POP3 port
private boolean isSSL = false; // use SSL?
private Protocol port = null; // POP3 port for self
private POP3Folder portOwner = null; // folder owning port
private String host = null; // host
private int portNum = -1;
private String user = null;
private String passwd = null;
private boolean useStartTLS = false;
private boolean requireStartTLS = false;
private boolean usingSSL = false;
private Map capabilities;
private MailLogger logger;
// following set here and accessed by other classes in this package
volatile Constructor messageConstructor = null;
volatile boolean rsetBeforeQuit = false;
volatile boolean disableTop = false;
volatile boolean forgetTopHeaders = false;
volatile boolean supportsUidl = true;
volatile boolean cacheWriteTo = false;
volatile boolean useFileCache = false;
volatile File fileCacheDir = null;
volatile boolean keepMessageContent = false;
volatile boolean finalizeCleanClose = false;
public POP3Store(Session session, URLName url) {
this(session, url, "pop3", false);
}
public POP3Store(Session session, URLName url,
String name, boolean isSSL) {
super(session, url);
if (url != null)
name = url.getProtocol();
this.name = name;
logger = new MailLogger(this.getClass(), "DEBUG POP3",
session.getDebug(), session.getDebugOut());
if (!isSSL)
isSSL = PropUtil.getBooleanProperty(session.getProperties(),
"mail." + name + ".ssl.enable", false);
if (isSSL)
this.defaultPort = 995;
else
this.defaultPort = 110;
this.isSSL = isSSL;
rsetBeforeQuit = getBoolProp("rsetbeforequit");
disableTop = getBoolProp("disabletop");
forgetTopHeaders = getBoolProp("forgettopheaders");
cacheWriteTo = getBoolProp("cachewriteto");
useFileCache = getBoolProp("filecache.enable");
String dir = session.getProperty("mail." + name + ".filecache.dir");
if (dir != null && logger.isLoggable(Level.CONFIG))
logger.config("mail." + name + ".filecache.dir: " + dir);
if (dir != null)
fileCacheDir = new File(dir);
keepMessageContent = getBoolProp("keepmessagecontent");
// mail.pop3.starttls.enable enables use of STLS command
useStartTLS = getBoolProp("starttls.enable");
// mail.pop3.starttls.required requires use of STLS command
requireStartTLS = getBoolProp("starttls.required");
// mail.pop3.finalizecleanclose requires clean close when finalizing
finalizeCleanClose = getBoolProp("finalizecleanclose");
String s = session.getProperty("mail." + name + ".message.class");
if (s != null) {
logger.log(Level.CONFIG, "message class: {0}", s);
try {
ClassLoader cl = this.getClass().getClassLoader();
// now load the class
Class messageClass = null;
try {
// First try the "application's" class loader.
// This should eventually be replaced by
// Thread.currentThread().getContextClassLoader().
messageClass = Class.forName(s, false, cl);
} catch (ClassNotFoundException ex1) {
// That didn't work, now try the "system" class loader.
// (Need both of these because JDK 1.1 class loaders
// may not delegate to their parent class loader.)
messageClass = Class.forName(s);
}
Class[] c = {jakarta.mail.Folder.class, int.class};
messageConstructor = messageClass.getConstructor(c);
} catch (Exception ex) {
logger.log(Level.CONFIG, "failed to load message class", ex);
}
}
}
/**
* Get the value of a boolean property.
* Print out the value if logging is enabled.
*/
private final synchronized boolean getBoolProp(String prop) {
prop = "mail." + name + "." + prop;
boolean val = PropUtil.getBooleanProperty(session.getProperties(),
prop, false);
if (logger.isLoggable(Level.CONFIG))
logger.config(prop + ": " + val);
return val;
}
/**
* Get a reference to the session.
*/
synchronized Session getSession() {
return session;
}
@Override
protected synchronized boolean protocolConnect(String host, int portNum,
String user, String passwd) throws MessagingException {
// check for non-null values of host, password, user
if (host == null || passwd == null || user == null)
return false;
// if port is not specified, set it to value of mail.pop3.port
// property if it exists, otherwise default to 110
if (portNum == -1)
portNum = PropUtil.getIntProperty(session.getProperties(),
"mail." + name + ".port", -1);
if (portNum == -1)
portNum = defaultPort;
this.host = host;
this.portNum = portNum;
this.user = user;
this.passwd = passwd;
try {
port = getPort(null);
} catch (EOFException eex) {
throw new AuthenticationFailedException(eex.getMessage());
} catch (SocketConnectException scex) {
throw new MailConnectException(scex);
} catch (IOException ioex) {
throw new MessagingException("Connect failed", ioex);
}
return true;
}
/**
* Check whether this store is connected. Override superclass
* method, to actually ping our server connection.
*/
/*
* Note that we maintain somewhat of an illusion of being connected
* even if we're not really connected. This is because a Folder
* can use the connection and close it when it's done. If we then
* ask whether the Store's connected we want the answer to be true,
* as long as we can reconnect at that point. This means that we
* need to be able to reconnect the Store on demand.
*/
@Override
public synchronized boolean isConnected() {
if (!super.isConnected())
// if we haven't been connected at all, don't bother with
// the NOOP.
return false;
try {
if (port == null)
port = getPort(null);
else if (!port.noop())
throw new IOException("NOOP failed");
return true;
} catch (IOException ioex) {
// no longer connected, close it down
try {
super.close(); // notifies listeners
} catch (MessagingException mex) {
// ignore it
}
return false;
}
}
synchronized Protocol getPort(POP3Folder owner) throws IOException {
Protocol p;
// if we already have a port, remember who's using it
if (port != null && portOwner == null) {
portOwner = owner;
return port;
}
// need a new port, create it and try to login
p = new Protocol(host, portNum, logger,
session.getProperties(), "mail." + name, isSSL);
if (useStartTLS || requireStartTLS) {
if (p.hasCapability("STLS")) {
if (p.stls()) {
// success, refresh capabilities
p.setCapabilities(p.capa());
} else if (requireStartTLS) {
logger.fine("STLS required but failed");
throw cleanupAndThrow(p,
new EOFException("STLS required but failed"));
}
} else if (requireStartTLS) {
logger.fine("STLS required but not supported");
throw cleanupAndThrow(p,
new EOFException("STLS required but not supported"));
}
}
capabilities = p.getCapabilities(); // save for later, may be null
usingSSL = p.isSSL(); // in case anyone asks
/*
* If we haven't explicitly disabled use of the TOP command,
* and the server has provided its capabilities,
* and the server doesn't support the TOP command,
* disable the TOP command.
*/
if (!disableTop &&
capabilities != null && !capabilities.containsKey("TOP")) {
disableTop = true;
logger.fine("server doesn't support TOP, disabling it");
}
supportsUidl = capabilities == null || capabilities.containsKey("UIDL");
try {
if (!authenticate(p, user, passwd))
throw cleanupAndThrow(p, new EOFException("login failed"));
} catch (EOFException ex) {
throw cleanupAndThrow(p, ex);
} catch (Exception ex) {
throw cleanupAndThrow(p, new EOFException(ex.getMessage()));
}
/*
* If a Folder closes the port, and then a Folder
* is opened, the Store won't have a port. In that
* case, the getPort call will come from Folder.open,
* but we need to keep track of the port in the Store
* so that a later call to Folder.isOpen, which calls
* Store.isConnected, will use the same port.
*/
if (port == null && owner != null) {
port = p;
portOwner = owner;
}
if (portOwner == null)
portOwner = owner;
return p;
}
private static IOException cleanupAndThrow(Protocol p, IOException ife) {
try {
p.quit();
} catch (Throwable thr) {
if (isRecoverable(thr)) {
ife.addSuppressed(thr);
} else {
thr.addSuppressed(ife);
if (thr instanceof Error) {
throw (Error) thr;
}
if (thr instanceof RuntimeException) {
throw (RuntimeException) thr;
}
throw new RuntimeException("unexpected exception", thr);
}
}
return ife;
}
/**
* Authenticate to the server.
*
* XXX - This extensible authentication mechanism scheme was adapted
* from the SMTPTransport class. The work was done at the last
* minute for the 1.6.5 release and so is not as clean as it
* could be. There's great confusion over boolean success/failure
* return codes vs exceptions. This should all be cleaned up at
* some point, and more testing should be done, but I'm leaving
* it in this "I believe it works" state for now. I've tested
* it with LOGIN, PLAIN, and XOAUTH2 mechanisms, the latter being
* the primary motivation for the work right now.
*
* @param p the Protocol object to use
* @param user the user to authenticate as
* @param passwd the password for the user
* @return true if authentication succeeds
* @exception MessagingException if authentication fails
* @since Jakarta Mail 1.6.5
*/
private boolean authenticate(Protocol p, String user, String passwd)
throws MessagingException {
// setting mail.pop3.auth.mechanisms controls which mechanisms will
// be used, and in what order they'll be considered. only the first
// match is used.
String mechs = session.getProperty("mail." + name + ".auth.mechanisms");
boolean usingDefaultMechs = false;
if (mechs == null) {
mechs = p.getDefaultMechanisms();
usingDefaultMechs = true;
}
String authzid =
session.getProperty("mail." + name + ".sasl.authorizationid");
if (authzid == null)
authzid = user;
/*
* XXX - maybe someday
*
if (enableSASL) {
logger.fine("Authenticate with SASL");
try {
if (sasllogin(getSASLMechanisms(), getSASLRealm(), authzid,
user, passwd)) {
return true; // success
} else {
logger.fine("SASL authentication failed");
return false;
}
} catch (UnsupportedOperationException ex) {
logger.log(Level.FINE, "SASL support failed", ex);
// if the SASL support fails, fall back to non-SASL
}
}
*/
if (logger.isLoggable(Level.FINE))
logger.fine("Attempt to authenticate using mechanisms: " + mechs);
/*
* Loop through the list of mechanisms supplied by the user
* (or defaulted) and try each in turn. If the server supports
* the mechanism and we have an authenticator for the mechanism,
* and it hasn't been disabled, use it.
*/
StringTokenizer st = new StringTokenizer(mechs);
while (st.hasMoreTokens()) {
String m = st.nextToken();
m = m.toUpperCase(Locale.ENGLISH);
if (!p.supportsMechanism(m)) {
logger.log(Level.FINE, "no authenticator for mechanism {0}", m);
continue;
}
if (!p.supportsAuthentication(m)) {
logger.log(Level.FINE, "mechanism {0} not supported by server",
m);
continue;
}
/*
* If using the default mechanisms, check if this one is disabled.
*/
if (usingDefaultMechs) {
String dprop = "mail." + name + ".auth." +
m.toLowerCase(Locale.ENGLISH) + ".disable";
boolean disabled = PropUtil.getBooleanProperty(
session.getProperties(),
dprop, !p.isMechanismEnabled(m));
if (disabled) {
if (logger.isLoggable(Level.FINE))
logger.fine("mechanism " + m +
" disabled by property: " + dprop);
continue;
}
}
// only the first supported and enabled mechanism is used
logger.log(Level.FINE, "Using mechanism {0}", m);
String msg =
p.authenticate(m, host, authzid, user, passwd);
if (msg != null)
throw new AuthenticationFailedException(msg);
return true;
}
// if no authentication mechanism found, fail
throw new AuthenticationFailedException(
"No authentication mechanisms supported by both server and client");
}
private static boolean isRecoverable(Throwable t) {
return (t instanceof Exception) || (t instanceof LinkageError);
}
synchronized void closePort(POP3Folder owner) {
if (portOwner == owner) {
port = null;
portOwner = null;
}
}
@Override
public synchronized void close() throws MessagingException {
close(false);
}
synchronized void close(boolean force) throws MessagingException {
try {
if (port != null) {
if (force)
port.close();
else
port.quit();
}
} catch (IOException ioex) {
} finally {
port = null;
// to set the state and send the closed connection event
super.close();
}
}
@Override
public Folder getDefaultFolder() throws MessagingException {
checkConnected();
return new DefaultFolder(this);
}
/**
* Only the name "INBOX" is supported.
*/
@Override
public Folder getFolder(String name) throws MessagingException {
checkConnected();
return new POP3Folder(this, name);
}
@Override
public Folder getFolder(URLName url) throws MessagingException {
checkConnected();
return new POP3Folder(this, url.getFile());
}
/**
* Return a Map of the capabilities the server provided,
* as per RFC 2449. If the server doesn't support RFC 2449,
* an emtpy Map is returned. The returned Map can not be modified.
* The key to the Map is the upper case capability name as
* a String. The value of the entry is the entire String
* capability line returned by the server.
*
* For example, to check if the server supports the STLS capability, use:
* if (store.capabilities().containsKey("STLS")) ...
*
* @return Map of capabilities
* @exception MessagingException for failures
* @since JavaMail 1.4.3
*/
public Map capabilities() throws MessagingException {
Map c;
synchronized (this) {
c = capabilities;
}
if (c != null)
return Collections.unmodifiableMap(c);
else
return Collections.emptyMap();
}
/**
* Is this POP3Store using SSL to connect to the server?
*
* @return true if using SSL
* @since JavaMail 1.4.6
*/
public synchronized boolean isSSL() {
return usingSSL;
}
@Override
protected void finalize() throws Throwable {
try {
if (port != null) // don't force a connection attempt
close(!finalizeCleanClose);
} finally {
super.finalize();
}
}
private void checkConnected() throws MessagingException {
if (!super.isConnected())
throw new MessagingException("Not connected");
}
}