mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-31 14:15:30 +00:00
519 lines
16 KiB
Java
519 lines
16 KiB
Java
|
/* -*- Mode: java; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
||
|
*
|
||
|
* The contents of this file are subject to the Mozilla Public License
|
||
|
* Version 1.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.mozilla.org/MPL/
|
||
|
*
|
||
|
* Software distributed under the License is distributed on an "AS IS"
|
||
|
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
|
||
|
* the License for the specific language governing rights and limitations
|
||
|
* under the License.
|
||
|
*
|
||
|
* The Original Code is the Grendel mail/news client.
|
||
|
*
|
||
|
* The Initial Developer of the Original Code is Netscape Communications
|
||
|
* Corporation. Portions created by Netscape are Copyright (C) 1997
|
||
|
* Netscape Communications Corporation. All Rights Reserved.
|
||
|
*
|
||
|
* Created: Terry Weissman <terry@netscape.com>, 28 Aug 1997.
|
||
|
*/
|
||
|
|
||
|
package grendel.storage;
|
||
|
|
||
|
import java.io.BufferedReader;
|
||
|
import java.io.DataOutputStream;
|
||
|
import java.io.File;
|
||
|
import java.io.InputStream;
|
||
|
import java.io.InputStreamReader;
|
||
|
import java.io.IOException;
|
||
|
import java.io.InterruptedIOException;
|
||
|
import java.io.RandomAccessFile;
|
||
|
import java.io.Reader;
|
||
|
import java.net.Socket;
|
||
|
import java.net.UnknownHostException;
|
||
|
import java.util.Enumeration;
|
||
|
import java.util.Hashtable;
|
||
|
import java.util.StringTokenizer;
|
||
|
import java.util.Vector;
|
||
|
|
||
|
import javax.mail.Folder;
|
||
|
import javax.mail.Message;
|
||
|
import javax.mail.MessagingException;
|
||
|
|
||
|
//import netscape.pop3.POP3Client;
|
||
|
//import netscape.pop3.POP3Status;
|
||
|
//import netscape.pop3.POP3MailDropStats;
|
||
|
|
||
|
class PopMailDrop implements MailDrop {
|
||
|
static final String KEEP = "k";
|
||
|
static final String DELETE = "d";
|
||
|
|
||
|
String fHost;
|
||
|
int fPort = 110;
|
||
|
String fUser;
|
||
|
String fPass;
|
||
|
Folder fFolder;
|
||
|
int fNumWaiting = -1;
|
||
|
Socket fSocket;
|
||
|
InputStream fInput;
|
||
|
DataOutputStream fOutput;
|
||
|
int stat_msgcount;
|
||
|
int stat_octetcount;
|
||
|
File popstatefile;
|
||
|
boolean uidlUnimplemented;
|
||
|
boolean xtndUnimplemented;
|
||
|
boolean leaveMessagesOnServer;
|
||
|
|
||
|
static final boolean DEBUG = false;
|
||
|
static void Spew(String s) {
|
||
|
if (DEBUG) System.out.println("PopMailDrop: " + s);
|
||
|
}
|
||
|
|
||
|
PopMailDrop() {
|
||
|
}
|
||
|
|
||
|
protected void clearAssumptionsAboutServer() {
|
||
|
uidlUnimplemented = false;
|
||
|
xtndUnimplemented = false;
|
||
|
}
|
||
|
|
||
|
void setHost(String hostname) {
|
||
|
fHost = hostname;
|
||
|
clearAssumptionsAboutServer();
|
||
|
}
|
||
|
|
||
|
void setPort(int port) {
|
||
|
fPort = port;
|
||
|
clearAssumptionsAboutServer();
|
||
|
}
|
||
|
|
||
|
void setUser(String username) {
|
||
|
fUser = username;
|
||
|
clearAssumptionsAboutServer();
|
||
|
}
|
||
|
|
||
|
void setPassword(String password) {
|
||
|
fPass = password;
|
||
|
clearAssumptionsAboutServer();
|
||
|
}
|
||
|
|
||
|
void setDestinationFolder(Folder dest) {
|
||
|
fFolder = dest;
|
||
|
}
|
||
|
|
||
|
Folder getDestinationFolder() {
|
||
|
return fFolder;
|
||
|
}
|
||
|
|
||
|
void setPopStateFile(File f) {
|
||
|
popstatefile = f;
|
||
|
Spew("popstatefile set to " + f);
|
||
|
}
|
||
|
|
||
|
File getPopStateFile() {
|
||
|
return popstatefile;
|
||
|
}
|
||
|
|
||
|
void setLeaveMessagesOnServer(boolean value) {
|
||
|
leaveMessagesOnServer = value;
|
||
|
}
|
||
|
|
||
|
boolean getLeaveMessagesOnServer() {
|
||
|
return leaveMessagesOnServer;
|
||
|
}
|
||
|
|
||
|
/** All the real work is done here. Go to the POP server, determine
|
||
|
what messages need downloading, and optionally actually download them.
|
||
|
(The only reason not to go ahead and download them is if we're doing a
|
||
|
biff check.) */
|
||
|
protected void fetchOrCheck(boolean dofetch) throws IOException {
|
||
|
try {
|
||
|
fNumWaiting = -1;
|
||
|
String response;
|
||
|
int bytesToLoad = 0; // How many bytes total we're going to
|
||
|
// download. Someday, this will be used for
|
||
|
// progress indication. ###
|
||
|
login();
|
||
|
Hashtable leave = loadLeaveOnServerList();
|
||
|
Hashtable newleave = null;
|
||
|
stat();
|
||
|
Vector getlist = new Vector();
|
||
|
if (leave == null && !leaveMessagesOnServer) {
|
||
|
for (int id=1 ; id<=stat_msgcount ; id++) {
|
||
|
getlist.addElement(new Integer(id));
|
||
|
}
|
||
|
bytesToLoad = stat_octetcount;
|
||
|
} else {
|
||
|
int sizes[] = new int[stat_msgcount + 1];
|
||
|
if (dofetch) { // Only bother getting sizes if we're going
|
||
|
// to be downloading some of these.
|
||
|
writeln("LIST");
|
||
|
check(readln(), "LIST command failed");
|
||
|
for (;;) {
|
||
|
String line = readln();
|
||
|
if (line.charAt(0) == '.') break;
|
||
|
StringTokenizer st = new StringTokenizer(line);
|
||
|
int id = Integer.parseInt(st.nextToken());
|
||
|
int count = Integer.parseInt(st.nextToken());
|
||
|
if (id >= 1 && id <= stat_msgcount) {
|
||
|
sizes[id] = count;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
boolean processingXtnd = false;
|
||
|
for (int id=1 ; id<=stat_msgcount ; id++) {
|
||
|
String uidl = null;
|
||
|
if (!uidlUnimplemented) {
|
||
|
writeln("UIDL " + id);
|
||
|
response = readln();
|
||
|
if (!resultOK(response)) {
|
||
|
uidlUnimplemented = true;
|
||
|
} else {
|
||
|
StringTokenizer st = new StringTokenizer(response);
|
||
|
st.nextToken();
|
||
|
st.nextToken();
|
||
|
uidl = st.nextToken();
|
||
|
}
|
||
|
}
|
||
|
if (uidl == null && !xtndUnimplemented && id == 1) {
|
||
|
writeln("XTND XLST Message-Id");
|
||
|
response = readln();
|
||
|
if (!resultOK(response)) {
|
||
|
xtndUnimplemented = true;
|
||
|
} else {
|
||
|
processingXtnd = true;
|
||
|
}
|
||
|
}
|
||
|
if (processingXtnd) {
|
||
|
response = readln();
|
||
|
if (response.startsWith(".")) {
|
||
|
processingXtnd = false;
|
||
|
} else {
|
||
|
StringTokenizer st = new StringTokenizer(response);
|
||
|
int i = Integer.parseInt(st.nextToken());
|
||
|
if (i != id) {
|
||
|
// Huh? xtnd skipped a message or something. Fine, throw
|
||
|
// away all the xtnd data, go use TOP instead.
|
||
|
do {
|
||
|
response = readln();
|
||
|
} while (!response.startsWith("."));
|
||
|
processingXtnd = false;
|
||
|
} else {
|
||
|
st.nextToken();
|
||
|
uidl = st.nextToken();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (uidl == null) {
|
||
|
writeln("TOP " + id + " 0");
|
||
|
check(readln(), "The POP3 server (%s) does not\n" +
|
||
|
"support UIDL, which Netscape Mail needs to implement\n" +
|
||
|
"the ``Leave on Server'' and ``Maximum Message Size''\n" +
|
||
|
"options.\n\n" +
|
||
|
"To download your mail, turn off these options in the\n" +
|
||
|
"Servers panel of the ``Mail and News'' Preferences.");
|
||
|
|
||
|
do {
|
||
|
response = readln();
|
||
|
if (uidl == null &&
|
||
|
response.regionMatches(true, 0, "Message-Id:", 0, 11)) {
|
||
|
uidl = response.substring(11).trim();
|
||
|
Spew("Top found message-id: " + uidl);
|
||
|
}
|
||
|
} while (!response.startsWith("."));
|
||
|
if (uidl == null) {
|
||
|
// Gack. No message-id in this message. Um, well, choke.
|
||
|
uidl = "unknown"; // ### Any better ideas???
|
||
|
Spew("Top couldn't find message-id.");
|
||
|
}
|
||
|
}
|
||
|
if (uidl.charAt(0) == '<' && uidl.endsWith(">")) {
|
||
|
uidl = uidl.substring(1, uidl.length() - 1);
|
||
|
}
|
||
|
|
||
|
String code = null;
|
||
|
if (leave != null) {
|
||
|
code = (String) leave.get(uidl);
|
||
|
if (code != null && !leaveMessagesOnServer && code.equals(KEEP)) {
|
||
|
// ### This causes us to redownload anything that we were
|
||
|
// keeping on the server if you turn off "keep messages on
|
||
|
// server". This is arguably wrong, because it floods peoples
|
||
|
// mailboxes with messages they've probably already seen. On
|
||
|
// the other hand, just deleting it could potentially lose
|
||
|
// mail for people. Bleah!
|
||
|
code = null;
|
||
|
}
|
||
|
}
|
||
|
if (code == null) {
|
||
|
getlist.addElement(new Integer(id));
|
||
|
bytesToLoad += sizes[id];
|
||
|
if (leaveMessagesOnServer) {
|
||
|
code = KEEP;
|
||
|
}
|
||
|
}
|
||
|
if (code != null) {
|
||
|
if (newleave == null) {
|
||
|
newleave = new Hashtable();
|
||
|
}
|
||
|
newleave.put(uidl, code);
|
||
|
}
|
||
|
}
|
||
|
if (processingXtnd) {
|
||
|
do {
|
||
|
response = readln();
|
||
|
} while (!response.startsWith("."));
|
||
|
processingXtnd = false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fNumWaiting = getlist.size();
|
||
|
|
||
|
// if (dofetch && fNumWaiting > 0) {
|
||
|
// for (Enumeration e = getlist.elements() ; e.hasMoreElements() ; ) {
|
||
|
// int id = ((Integer) e.nextElement()).intValue();
|
||
|
// // ### Insert code here to do partial messages...
|
||
|
// writeln("RETR " + id);
|
||
|
// check(readln(), "Requesting message from server");
|
||
|
// InputStream in = new DotTerminatedInputStream(fInput);
|
||
|
// Message m = new MessageFromStream(in);
|
||
|
// Message[] stupidlist = { m };
|
||
|
// try {
|
||
|
// fFolder.appendMessages(stupidlist);
|
||
|
// } catch (MessagingException err) {
|
||
|
// throw new IOException(err.toString());
|
||
|
// }
|
||
|
//
|
||
|
// // Do filters, something like:
|
||
|
// FilterMaster.Get().applyFilters(m);
|
||
|
// // though it probably makes more sense to do this before the
|
||
|
// // fFolder.appendMessages() and not do that if the filter
|
||
|
// // has already saved the message...djw
|
||
|
//
|
||
|
// if (!leaveMessagesOnServer) {
|
||
|
// writeln("DELE " + id);
|
||
|
// check(readln(), "Deleting retrieved message from server");
|
||
|
// }
|
||
|
// }
|
||
|
// fNumWaiting = 0;
|
||
|
// if (leave != null || newleave != null) {
|
||
|
// saveLeaveOnServerList(newleave);
|
||
|
// }
|
||
|
// }
|
||
|
logout();
|
||
|
} finally {
|
||
|
cleanup();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
protected Hashtable loadLeaveOnServerList() {
|
||
|
if (popstatefile == null) return null;
|
||
|
RandomAccessFile f = null;
|
||
|
Hashtable result = null;
|
||
|
try {
|
||
|
f = new RandomAccessFile(popstatefile, "r");
|
||
|
boolean found = false;
|
||
|
for (String line = f.readLine() ; line != null ; line = f.readLine()) {
|
||
|
if (line.length() == 0) continue;
|
||
|
if (!found) {
|
||
|
if (line.charAt(0) == '*') {
|
||
|
StringTokenizer st = new StringTokenizer(line.substring(1));
|
||
|
if (fHost.equals(st.nextToken())) {
|
||
|
if (fUser.equals(st.nextToken())) {
|
||
|
found = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
} else {
|
||
|
if (line.charAt(0) == '*') break; // Start of next host; we're done.
|
||
|
if (result == null) {
|
||
|
result = new Hashtable();
|
||
|
}
|
||
|
result.put(line.substring(2).trim(), line.substring(0, 1));
|
||
|
}
|
||
|
}
|
||
|
} catch (IOException e) {
|
||
|
} finally {
|
||
|
if (f != null) {
|
||
|
try {
|
||
|
f.close();
|
||
|
} catch (IOException e) {
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
protected void saveLeaveOnServerList(Hashtable table) throws IOException {
|
||
|
synchronized(popstatefile) {
|
||
|
// This is all done synchronized via the popstatefile, so that if we
|
||
|
// have multiple pop servers they will not attempt to write to the file
|
||
|
// at the same time. This assumes that every pop server was given the
|
||
|
// same File object to represent the popstate file.
|
||
|
|
||
|
RandomAccessFile in = null;
|
||
|
RandomAccessFile out = null;
|
||
|
File outfile = new File(popstatefile.getPath() + "-temp");
|
||
|
try {
|
||
|
out = new RandomAccessFile(outfile, "rw");
|
||
|
out.writeBytes("# Netscape POP3 State File" + Constants.LINEBREAK +
|
||
|
"# This is a generated file! Do not edit." +
|
||
|
Constants.LINEBREAK + Constants.LINEBREAK);
|
||
|
|
||
|
if (table != null) {
|
||
|
out.writeBytes("*" + fHost + " " + fUser + Constants.LINEBREAK);
|
||
|
for (Enumeration e = table.keys() ; e.hasMoreElements() ; ) {
|
||
|
String key = (String) e.nextElement();
|
||
|
out.writeBytes((String) (table.get(key)) + " " + key +
|
||
|
Constants.LINEBREAK);
|
||
|
}
|
||
|
}
|
||
|
if (popstatefile.exists()) {
|
||
|
in = new RandomAccessFile(popstatefile, "r");
|
||
|
boolean copyit = false;
|
||
|
String line;
|
||
|
for (line = in.readLine() ; line != null ; line = in.readLine()) {
|
||
|
if (line.length() == 0) continue;
|
||
|
if (line.charAt(0) == '*') {
|
||
|
copyit = true;
|
||
|
StringTokenizer st = new StringTokenizer(line.substring(1));
|
||
|
if (fHost.equals(st.nextToken())) {
|
||
|
if (fUser.equals(st.nextToken())) {
|
||
|
copyit = false;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (copyit) {
|
||
|
out.writeBytes(line.trim() + Constants.LINEBREAK);
|
||
|
}
|
||
|
}
|
||
|
in.close();
|
||
|
in = null;
|
||
|
}
|
||
|
out.close();
|
||
|
out = null;
|
||
|
outfile.renameTo(popstatefile);
|
||
|
} finally {
|
||
|
if (in != null) in.close();
|
||
|
if (out != null) out.close();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
synchronized public void fetchNewMail() throws IOException {
|
||
|
fetchOrCheck(true);
|
||
|
}
|
||
|
|
||
|
synchronized public void doBiff() throws IOException {
|
||
|
fetchOrCheck(false);
|
||
|
}
|
||
|
|
||
|
protected void login() throws IOException {
|
||
|
// ### I18N -- all these exceptions need to be internationalized.
|
||
|
if (fHost == null) {
|
||
|
throw new MailDropException("No host specified for POP3 maildrop");
|
||
|
}
|
||
|
if (fUser == null) {
|
||
|
throw new MailDropException("No user specified for POP3 maildrop");
|
||
|
}
|
||
|
try {
|
||
|
fSocket = new Socket(fHost, fPort);
|
||
|
} catch (UnknownHostException e) {
|
||
|
throw new MailDropException("Unknown host: " + e.getMessage());
|
||
|
}
|
||
|
|
||
|
fInput = fSocket.getInputStream();
|
||
|
fOutput = new DataOutputStream(fSocket.getOutputStream());
|
||
|
|
||
|
check(readln(), "Connecting to server");
|
||
|
writeln("USER " + fUser);
|
||
|
check(readln(), "USER command not accepted");
|
||
|
writeln("PASS " + fPass);
|
||
|
check(readln(), "Login failed");
|
||
|
// ### Should probably do GURL at this point, if necessary, to remember
|
||
|
// the URL used to manage this account.
|
||
|
}
|
||
|
|
||
|
protected void cleanup() {
|
||
|
if (fSocket != null) {
|
||
|
try {
|
||
|
fSocket.close();
|
||
|
} catch (IOException e) {
|
||
|
}
|
||
|
}
|
||
|
fSocket = null;
|
||
|
fInput = null;
|
||
|
fOutput = null;
|
||
|
}
|
||
|
|
||
|
protected void logout() throws IOException {
|
||
|
writeln("QUIT");
|
||
|
check(readln(), "Logout failed");
|
||
|
}
|
||
|
|
||
|
protected void stat() throws IOException {
|
||
|
writeln("STAT");
|
||
|
String line = readln();
|
||
|
check(line, "Stat failed");
|
||
|
StringTokenizer st = new StringTokenizer(line);
|
||
|
st.nextToken(); //skip +OK
|
||
|
stat_msgcount = Integer.parseInt(st.nextToken());
|
||
|
stat_octetcount = Integer.parseInt(st.nextToken());
|
||
|
}
|
||
|
|
||
|
protected void writeln(String line) throws IOException {
|
||
|
Spew(">> " + line);
|
||
|
fOutput.writeBytes(line + "\n");
|
||
|
}
|
||
|
|
||
|
StringBuffer inbuffer = new StringBuffer();
|
||
|
protected String readln() throws IOException {
|
||
|
inbuffer.setLength(0);
|
||
|
int c;
|
||
|
do {
|
||
|
c = fInput.read();
|
||
|
if (c >= 0) inbuffer.append((char) c);
|
||
|
} while (c != '\n');
|
||
|
Spew("<< " + inbuffer);
|
||
|
return inbuffer.toString();
|
||
|
}
|
||
|
|
||
|
protected void check(String line, String err) throws MailDropException {
|
||
|
if (!resultOK(line)) {
|
||
|
throw new MailDropException(err + " (Server response: " + line + ")");
|
||
|
// ### I18N
|
||
|
}
|
||
|
}
|
||
|
|
||
|
protected boolean resultOK(String line) {
|
||
|
return line.startsWith("+OK");
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
public int getBiffState() {
|
||
|
if (fNumWaiting < 0) return UNKNOWN;
|
||
|
if (fNumWaiting == 0) return NONE;
|
||
|
return NEW;
|
||
|
}
|
||
|
|
||
|
public int getNumMessagesWaiting() {
|
||
|
return fNumWaiting;
|
||
|
}
|
||
|
|
||
|
// protected void check(POP3Status status) throws MailDropException {
|
||
|
// check(status.getStatus(), status.getServerResponse());
|
||
|
// }
|
||
|
|
||
|
protected void check(boolean status, String response)
|
||
|
throws MailDropException
|
||
|
{
|
||
|
if (!status) {
|
||
|
throw new MailDropException("Pop server reports: " + response);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
}
|