* This method should return false if authentication fails,
* due to the username or password being unavailable or incorrect, or may
* throw AuthenticationFailedException for further details.
*
* In the case of failures not related to authentication, such as an
* invalid configuration or network error, this method should throw an
* appropriate MessagingException.
* @param host the name of the host to connect to
* @param port the port to use (-1 for the default port)
* @param user the username
* @param password the password
* @return true on success, false if authentication failed
* @exception AuthenticationFailedException on authentication failure
* @exception MessagingException for non-authentication failures
*/
protected boolean protocolConnect(String host, int port,
String user, String password)
throws MessagingException
{
return false;
}
/**
* Indicates whether this service is currently connected.
*/
public boolean isConnected()
{
return connected;
}
/**
* Sets the connection state of this service.
*/
protected void setConnected(boolean connected)
{
this.connected = connected;
}
/**
* Closes this service, terminating any underlying connections.
*/
public synchronized void close()
throws MessagingException
{
setConnected(false);
notifyConnectionListeners(ConnectionEvent.CLOSED);
}
/**
* Return a URLName representing this service. The password field will not
* be returned.
*/
public URLName getURLName()
{
if (url != null && (url.getPassword() != null || url.getFile() != null))
{
return new URLName(url.getProtocol(), url.getHost(), url.getPort(),
null, url.getUsername(), null);
}
return url;
}
/**
* Set the URLName representing this service.
* This method is called when the service has successfully connected.
*/
protected void setURLName(URLName url)
{
this.url = url;
}
// -- Event management --
/*
* Because the propagation of events of different kinds in the JavaMail
* API is so haphazard, I have here sacrificed a small time advantage for
* readability and consistency.
*
* All the various propagation methods now call a method with a name based
* on the eventual listener method name prefixed by 'fire', as is the
* preferred pattern for usage of the EventListenerList in Swing.
*
* Note that all events are currently delivered synchronously, where in
* Sun's implementation a different thread is used for event delivery.
*
* TODO Examine the impact of this.
*/
// -- Connection events --
/**
* Adds a listener for connection events on this service.
*/
public void addConnectionListener(ConnectionListener l)
{
if (connectionListeners == null)
{
connectionListeners = new ArrayList();
}
synchronized (connectionListeners)
{
connectionListeners.add(l);
}
}
/**
* Removes a connection event listener.
*/
public void removeConnectionListener(ConnectionListener l)
{
if (connectionListeners != null)
{
synchronized (connectionListeners)
{
connectionListeners.remove(l);
}
}
}
/**
* Notify all connection listeners.
*/
protected void notifyConnectionListeners(int type)
{
ConnectionEvent event = new ConnectionEvent(this, type);
switch (type)
{
case ConnectionEvent.OPENED:
fireOpened(event);
break;
case ConnectionEvent.DISCONNECTED:
fireDisconnected(event);
break;
case ConnectionEvent.CLOSED:
fireClosed(event);
break;
}
}
/*
* Propagates an OPENED ConnectionEvent to all registered listeners.
*/
void fireOpened(ConnectionEvent event)
{
if (connectionListeners != null)
{
ConnectionListener[] l = null;
synchronized (connectionListeners)
{
l = new ConnectionListener[connectionListeners.size()];
connectionListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].opened(event);
}
}
}
/*
* Propagates a DISCONNECTED ConnectionEvent to all registered listeners.
*/
void fireDisconnected(ConnectionEvent event)
{
if (connectionListeners != null)
{
ConnectionListener[] l = null;
synchronized (connectionListeners)
{
l = new ConnectionListener[connectionListeners.size()];
connectionListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].disconnected(event);
}
}
}
/*
* Propagates a CLOSED ConnectionEvent to all registered listeners.
*/
void fireClosed(ConnectionEvent event)
{
if (connectionListeners != null)
{
ConnectionListener[] l = null;
synchronized (connectionListeners)
{
l = new ConnectionListener[connectionListeners.size()];
connectionListeners.toArray(l);
}
for (int i = 0; i < l.length; i++)
{
l[i].closed(event);
}
}
}
/**
* Returns getURLName.toString if this service has a URLName,
* otherwise returns the default toString.
*/
public String toString()
{
URLName urlName = getURLName();
return (urlName != null) ? urlName.toString() : super.toString();
}
/**
* Adds the event and vector of listeners to be notified.
*/
protected void queueEvent(MailEvent event, Vector vector)
{
for (Iterator i = vector.iterator(); i.hasNext(); )
{
event.dispatch(i.next());
}
}
}