Docstoc

Internet Programming with Java Course

Document Sample
Internet Programming with Java Course Powered By Docstoc
					Internet Programming with Java Course 1.8 Пример: Разработка на mail клиент – изпращане и извличане на e-mail по SMTP/POP3

Mail Services
Users consider electronic mail the most important network service because they use it for interpersonal communications. Some applications are newer and fancier. Other applications consume more network bandwidth. Others are more important for the continued operation of the network. But email is the application people use to communicate with each other. It isn't very fancy, but it's vital. TCP/IP provides a reliable, flexible email system built on a few basic protocols. These are: Simple Mail Transfer Protocol (SMTP), Post Office Protocol (POP), and Multipurpose Internet Mail Extensions (MIME). There are other TCP/IP mail protocols. Interactive Mail Access Protocol, defined in RFC 1176, is an interesting protocol designed to supplant POP. It provides remote text searches and message parsing features not found in POP. We will touch only briefly on IMAP. It and other protocols have some very interesting features, but they are not yet widely implemented. Our coverage concentrates on the three protocols you are most likely to use building your network: SMTP, POP, and MIME. We start with SMTP, the foundation of all TCP/IP email systems.

Simple Mail Transfer Protocol
SMTP is the TCP/IP mail delivery protocol. It moves mail across the Internet and across your local network. SMTP is defined in RFC 821, A Simple Mail Transfer Protocol. It runs over the reliable, connection-oriented service provided by Transmission Control Protocol (TCP), and it uses well-known port number 25. [7] Table 3.1 lists some of the simple, human-readable commands used by SMTP. [7] Most standard TCP/IP applications are assigned a well-known port in the Assigned Numbers RFC, so that remote systems know how to connect the service. Table 3.1: SMTP Commands Syntax Function HELO <sending-host> Identify sending SMTP MAIL FROM:<from-address> Sender address RCPT TO:<to-address> Recipient address DATA Begin a message RSET Abort a message VRFY <string> Verify a username EXPN <string> Expand a mailing list HELP [string] Request online help QUIT End the SMTP session

Command Hello From Recipient Data Reset Verify Expand Help Quit

SMTP is such a simple protocol you can literally do it yourself. telnet to port 25 on a remote host and type mail in from the command line using the SMTP commands. This technique is sometimes used to test a remote system's SMTP server, but we use it here to illustrate how mail is delivered between systems. The example below shows mail manually input from Daniel on peanut.nuts.com to Tyler on almond.nuts.com.
% telnet almond.nuts.com 25 Trying 172.16.12.1 ... Connected to almond.nuts.com. Escape character is '^]'. 220 almond Sendmail 4.1/1.41 ready at Tue, 29 Mar 94 17:21:26 EST helo peanut.nuts.com

250 almond Hello peanut.nuts.com, pleased to meet you mail from:<daniel@peanut.nuts.com> 250 <daniel@peanut.nuts.com>... Sender ok rcpt to:<tyler@almond.nuts.com> 250 <tyler@almond.nuts.com>... Recipient ok data 354 Enter mail, end with "." on a line by itself Hi Tyler! . 250 Mail accepted quit 221 almond delivering mail Connection closed by foreign host.

The user input is shown in bold type. All of the other lines are output from the system. This example shows how simple it is. A TCP connection is opened. The sending system identifies itself. The From address and the To address are provided. The message transmission begins with the DATA command and ends with a line that contains only a period (.). The session terminates with a QUIT command. Very simple, and very few commands are used. There are other commands (SEND, SOML, SAML, and TURN) defined in RFC 821 that are optional and not widely implemented. Even some of the commands that are implemented are not commonly used. The commands HELP, VRFY, and EXPN are designed more for interactive use than for the normal machine-tomachine interaction used by SMTP. The following excerpt from a SMTP session shows how these odd commands work.
HELP 214-Commands: 214HELO MAIL RCPT DATA RSET 214NOOP QUIT HELP VRFY EXPN 214-For more info use "HELP <topic>". 214-For local information contact postmaster at this site. 214 End of HELP info HELP RSET 214-RSET 214Resets the system. 214 End of HELP info VRFY <jane> 250 <jane@brazil.nuts.com> VRFY <mac> 250 Kathy McCafferty <<mac>> EXPN <admin> 250-<sara@pecan.nuts.com> 250 David Craig <<david>> 250-<tyler@nuts.com>

The HELP command prints out a summary of the commands implemented on the system. The HELP RSET command specifically requests information about the RSET command. Frankly, this help system isn't very helpful! The VRFY and EXPN commands are more useful, but are often disabled for security reasons because they provide user account information that might be exploited by network intruders. The EXPN <admin> command asks for a listing of the email addresses in the mailing list admin, and that is what the system provides. The VRFY command asks for information about an individual instead of a mailing list. In the case of the VRFY <mac> command, mac is a local user account and the user's account information is returned. In the case of VRFY <jane>, jane is an alias in the /etc/aliases file. The value returned is the email address for jane found in that file. The three commands in this example are interesting, but rarely used. SMTP depends on the other commands to get the real work done. SMTP provides direct end-to-end mail delivery. This is unusual. Most mail systems use store and forward protocols like UUCP and X.400 that move mail toward its destination one hop at a time, storing the complete message at each hop and then forwarding it on to the next system. The message proceeds in this manner until final delivery is made. Figure 3.3 illustrates both store and forward and direct delivery mail systems. The

UUCP address clearly shows the path that the mail takes to its destination, while the SMTP mail address implies direct delivery. The address doesn't have anything to do with whether or not a system is store and forward or direct delivery. It just happens that UUCP provides an address that helps to illustrate this point. Figure 3.3: Mail delivery systems

Direct delivery allows SMTP to deliver mail without relying on intermediate hosts. If the delivery fails, the local system knows it right away. It can inform the user that sent the mail or queue the mail for later delivery without reliance on remote systems. The disadvantage of direct delivery is that it requires both systems to be fully capable of handling mail. Some systems cannot handle mail, particularly small systems such as PCs or mobile systems such as laptops. These systems are usually shut down at the end of the day and are frequently offline. Mail directed from a remote host fails with a "cannot connect" error when the local system is turned off or offline. To handle these cases, features in the DNS system are used to route the message to a mail server in lieu of direct delivery. The mail is then moved from the server to the client system when the client is back online. The protocol most TCP/IP networks use for this task is POP.

Example – sending e-mail using SMTP protocol
/** * SMTPSession - Class for sending e-mails using SMTP protocol. */ import java.io.*; import java.net.*; import java.util.*; public class SMTPSession { /** 15 sec. socket read timeout */ public static final int SOCKET_READ_TIMEOUT = 15*1000; private private private private private private String host; int port; String recipient; String sender; String subject; String message;

protected Socket smtpSocket; protected BufferedReader in; protected OutputStreamWriter out;

/** * Creates new SMTP session by given SMTP * address, sender's email address, email */ public SMTPSession(String host, int port, String sender, String subject, String { this.host = host; this.port = port; this.recipient = recipient; this.message = message; this.sender = sender; this.subject = subject; }

host and port, recipient's email subject and email message text. String recipient, message)

/** * Creates new SMTP session by given SMTP host, recipient's email address, * sender's email address, email subject and email message text. Assumes * SMTP port is 25 (default for SMTP service). */ public SMTPSession(String host, String recipient, String sender, String subject, String message) { this(host, 25, recipient, sender, subject, message); } /** * Closes down the connection to SMTP server (if open). * Should be called if an exception is raised during the SMTP session. */ public void close() { try { in.close(); out.close(); smtpSocket.close(); } catch (Exception ex) { // Ignore the exception. Probably the socket is not open. } } /** * Connects to the SMTP server and gets input and output streams (in, out). */ protected void connect() throws IOException { smtpSocket = new Socket(host, port); smtpSocket.setSoTimeout(SOCKET_READ_TIMEOUT); in = new BufferedReader(new InputStreamReader(smtpSocket.getInputStream())); out = new OutputStreamWriter(smtpSocket.getOutputStream()); } /** * Sends given command and waits for a response from server. * @return response received from the server. */ protected String sendCommand(String commandString) throws IOException { out.write(commandString + "\n"); out.flush(); String response = getResponse(); return response; } /** * Sends given commandString to the server, gets its reply and checks if * it starts with expectedResponseStart. If not, throws IOException with

* server's reply (which is unexpected). */ protected void doCommand(String commandString, char expectedResponseStart) throws IOException { String response = sendCommand(commandString); checkServerResponse(response, expectedResponseStart); } /** * Checks if given server reply starts with expectedResponseStart. * If not, throws IOException with this reply (because it is unexpected). */ protected void checkServerResponse(String response, char expectedResponseStart) throws IOException { if (response.charAt(0) != expectedResponseStart) throw new IOException(response); } /** * Gets a response back from the server. Handles multi-line responses * (according to SMTP protocol) and returns them as multi-line string. * Each line of the server's reply consists of 3-digit number followed * by some text. If there is a '-' immediately after the number, the SMTP * response continues on the next line. Otherwise it finished at this line. */ protected String getResponse() throws IOException { String response = ""; String line; do { line = in.readLine(); if ((line == null) || (line.length() < 3)) { // SMTP response lines should at the very least have a 3-digit number throw new IOException("Bad response from server."); } response += line + "\n"; } while ((line.length() > 3) && (line.charAt(3) == '-')); return response; } /** * Prepares and returns e-mail message headers. */ protected String getMessageHeaders() { // Most header are less than 1024 characters long String headers = ""; headers = headers + "Date: " + new Date().toString() + "\n"; headers = headers + "Sender: " + sender + "\n"; headers = headers + "From: " + sender + "\n"; headers = headers + "To: " + recipient + "\n"; headers = headers + "Subject: " + subject + "\n"; return headers + "\n\n"; } /** * Sends a message using the SMTP protocol. */ public void sendMessage() throws IOException { connect(); // After connecting, the SMTP server will send a response string.

// Make sure it starts with a '2' (reponses in the 200's are positive). String response = getResponse(); checkServerResponse(response,'2'); // Introduce ourselves to the SMTP server with a polite "HELO localhostname" doCommand("HELO " + smtpSocket.getLocalAddress().toString(), '2'); // Tell the server who this message is from doCommand("MAIL FROM: <" + sender + ">", '2'); // Now tell the server who we want to send a message to doCommand("RCPT TO: <" + recipient + ">", '2'); // Okay, now send the mail message. We expect a response beginning // with '3' indicating that the server is ready for data. doCommand("DATA", '3'); // Send the message headers out.write(getMessageHeaders()); BufferedReader msgBodyReader = new BufferedReader(new StringReader(message)); // Send each line of the message String line; while ((line=msgBodyReader.readLine()) != null) { // If the line begins with a ".", put an extra "." in front of it. if (line.startsWith(".")) out.write('.'); out.write(line + "\n"); } // A "." on a line by itself ends a message. doCommand(".", '2'); // Message is sent. Close the connection to the server close(); } }

/** * SMTPSession example. Sends emails using SMTP protocol. * (c) 2002 by Svetlin Nakov */ import SMTPSession; public class SMTPClient { public static void main(String[] args) { SMTPSession smtp = new SMTPSession( "localhost", "recipient@mycompany.com", "sender@mycompany.com", "Some subject", "... Message text ..."); try { System.out.println("Sending e-mail..."); smtp.sendMessage(); System.out.println("E-mail sent."); } catch (Exception e) { smtp.close(); System.out.println("Can not send e-mail!"); e.printStackTrace(); } } }

Post Office Protocol (POP)
There are two versions of POP in widespread use: POP2 and POP3. POP2 is defined in RFC 937 and POP3 is defined in RFC 1725. POP2 uses port 109 and POP3 uses port 110. These are incompatible protocols that use different commands, but they perform the same basic functions. The POP protocols verify the user's login name and password, and move the user's mail from the server to the user's local mail reader. A sample POP2 session clearly illustrates how a POP protocol works. POP2 is a simple request/response protocol, and just as with SMTP, you can type POP2 commands directly into its well-known port (109) and observe their effect. Here's an example with the user input shown in bold type:
% telnet almond.nuts.com 109 Trying 172.16.12.1 ... Connected to almond.nuts.com. Escape character is '^]'. + POP2 almond POP2 Server at Wed 30-Mar-94 3:48PM-EST HELO hunt WatsWatt #3 ...(From folder 'NEWMAIL') READ =496 RETR {The full text of message 1} ACKD =929 RETR {The full text of message 2} ACKD =624 RETR {The full text of message 3} ACKD =0 QUIT +OK POP2 Server exiting (0 NEWMAIL messages left) Connection closed by foreign host.

The HELO command provides the username and password for the account of the mailbox that is being retrieved. (This is the same username and password used to log into the mail server.) In response to the HELO command the server sends a count of the number of messages in the mailbox, three (#3) in our example. The READ command begins reading the mail. RETR retrieves the full text of the current message. ACKD acknowledges receipt of the message and deletes it from the server. After each acknowledgment the server sends a count of the number of bytes in the new message. If the byte count is zero (=0) it indicates that there are no more messages to be retrieved and the client ends the session with the QUIT command. Simple! Table 3.2 lists the full set of POP2 commands. Table 3.2: POP2 Commands Command Syntax Function Hello HELO user password Identify user account Folder FOLD mail-folder Select mail folder Read READ [n] Read mail, optionally start with message n Retrieve RETR Retrieve message Save ACKS Acknowledge and save Delete ACKD Acknowledge and delete Failed NACK Negative acknowledgement Quit QUIT End the POP2 session The commands for POP3 are completely different from the commands used for POP2. Table 3.3 shows the set of POP3 commands defined in RFC 1725.

Command USER username PASS password STAT RETR n DELE n LAST LIST [n] RSET TOP n l NOOP QUIT

Table 3.3: POP3 Commands Function The user's account name The user's password Display the number of unread messages/bytes Retrieve message number n Delete message number n Display the number of the last message accessed Display the size of message n or of all messages Undelete all messages; reset message number to 1 Print the headers and l lines of message n Do nothing End the POP3 session

Despite the fact that these commands are different from those used by POP2, they can be used to perform similar functions. In the POP2 example we logged into the server and read and deleted three mail messages. Here's a similar session using POP3:
% telnet almond 110 Trying 172.16.12.1 ... Connected to almond.nuts.com. Escape character is '^]'. +OK almond POP3 Server Process 3.3(1) at Mon 15-May-95 4:48PM-EDT user hunt +OK User name (hunt) ok. Password, please. pass Watts?Watt? +OK 3 messages in folder NEWMAIL (V3.3 Rev B04) stat +OK 3 459 retr 1 +OK 146 octets The full text of message 1 dele 1 +OK message # 1 deleted retr 2 +OK 155 octets The full text of message 2 dele 2 +OK message # 2 deleted retr 3 +OK 158 octets The full text of message 3 dele 3 +OK message # 3 deleted quit +OK POP3 almond Server exiting (0 NEWMAIL messages left) Connection closed by foreign host.

Naturally you don't really type these commands in yourself, but experiencing hands-on interaction with SMTP and POP gives you a clearer understanding of what these programs do and why they are needed.

Example – receiving e-mail using POP3 protocol
/** * POP3Session - Class for checking e-mail via POP3 protocol. */ import java.io.*; import java.net.*; import java.util.*;

public class POP3Session extends Object { /** 15 sec. socket read timeout */ public static final int SOCKET_READ_TIMEOUT = 15*1000; protected Socket pop3Socket; protected BufferedReader in; protected PrintWriter out; private private private private String host; int port; String userName; String password;

/** * Creates new POP3 session by given POP3 host, username and password. * Assumes POP3 port is 110 (default for POP3 service). */ public POP3Session(String host, String userName, String password) { this(host, 110, userName, password); } /** * Creates new POP3 session by given POP3 host and port, username and password. */ public POP3Session(String host, int port, String userName, String password) { this.host = host; this.port = port; this.userName = userName; this.password = password; } /** * Throws exception if given server response if negative. According to POP3 * protocol, positive responses start with a '+' and negative start with '-'. */ protected void checkForError(String response) throws IOException { if (response.charAt(0) != '+') throw new IOException(response); } /** * @return the current number of messages using the POP3 STAT command. */ public int getMessageCount() throws IOException { // Send STAT command String response = doCommand("STAT"); // The format of the response is +OK msg_count size_in_bytes // We take the substring from offset 4 (the start of the msg_count) and // go up to the first space, then convert that string to a number. try { String countStr = response.substring(4, response.indexOf(' ', 4)); int count = (new Integer(countStr)).intValue(); return count; } catch (Exception e) { throw new IOException("Invalid response - " + response); } } /** * Get headers returns a list of message numbers along with some sizing

* information, and possibly other information depending on the server. */ public String[] getHeaders() throws IOException { doCommand("LIST"); return getMultilineResponse(); } /** * Gets header returns the message number and message size for a particular * message number. It may also contain other information. */ public String getHeader(String messageId) throws IOException { String response = doCommand("LIST " + messageId); return response; } /** * Retrieves the entire text of a message using the POP3 RETR command. */ public String getMessage(String messageId) throws IOException { doCommand("RETR " + messageId); String[] messageLines = getMultilineResponse(); StringBuffer message = new StringBuffer(); for (int i=0; i<messageLines.length; i++) { message.append(messageLines[i]); message.append("\n"); } return new String(message); } /** * Retrieves the first <linecount> lines of a message using the POP3 TOP * command. Note: this command may not be available on all servers. If * it isn't available, you'll get an exception. */ public String[] getMessageHead(String messageId, int lineCount) throws IOException { doCommand("TOP " + messageId + " " + lineCount); return getMultilineResponse(); } /** * Deletes a particular message with DELE command. */ public void deleteMessage(String messageId) throws IOException { doCommand("DELE " + messageId); } /** * Initiates a graceful exit by sending QUIT command. */ public void quit() throws IOException { doCommand("QUIT"); } /** * Connects to the POP3 server and logs on it * with the USER and PASS commands.

*/ public void connectAndAuthenticate() throws IOException { // Make the connection pop3Socket = new Socket(host, port); pop3Socket.setSoTimeout(SOCKET_READ_TIMEOUT); in = new BufferedReader(new InputStreamReader(pop3Socket.getInputStream())); out = new PrintWriter(new OutputStreamWriter(pop3Socket.getOutputStream())); // Receive the welcome message String response = in.readLine(); checkForError(response); // Send a USER command to authenticate doCommand("USER " + userName); // Send a PASS command to finish authentication doCommand("PASS " + password); } /** * Closes down the connection to POP3 server (if open). * Should be called if an exception is raised during the POP3 session. */ public void close() { try { in.close(); out.close(); pop3Socket.close(); } catch (Exception ex) { // Ignore the exception. Probably the socket is not open. } } /** * Sends a POP3 command and retrieves the response. If the response is * negative (begins with '-'), throws an IOException with received response. */ protected String doCommand(String command) throws IOException { out.println(command); out.flush(); String response = in.readLine(); checkForError(response); return response; } /** * Retrieves a multi-line POP3 response. If a line contains "." by itself, * it is the end of the response. If a line starts with a ".", it should * really have two "."'s. We strip off the leading ".". If a line does not * start with ".", there should be at least one line more. */ protected String[] getMultilineResponse() throws IOException { ArrayList lines = new ArrayList(); while (true) { String line = in.readLine(); if (line == null) { // Server closed connection throw new IOException("Server unawares closed the connection."); } if (line.equals(".")) {

// No more lines in the server response break; } if ((line.length() > 0) && (line.charAt(0) == '.')) { // The line starts with a "." - strip it off. line = line.substring(1); } // Add read line to the list of lines lines.add(line); } String response[] = new String[lines.size()]; lines.toArray(response); return response; } }

/** * POP3Session example. Receives email using POP3 protocol. */ import POP3Session; import java.util.StringTokenizer; public class POP3Client { public static void main(String[] args) { POP3Session pop3 = new POP3Session("pop.mycompany.com", "username", "password"); try { System.out.println("Connecting to POP3 server..."); pop3.connectAndAuthenticate(); System.out.println("Connected to POP3 server."); int messageCount = pop3.getMessageCount(); System.out.println("\nWaiting massages on POP3 server : " + messageCount); String[] messages = pop3.getHeaders(); for (int i=0; i<messages.length; i++) { StringTokenizer messageTokens = new StringTokenizer(messages[i]); String messageId = messageTokens.nextToken(); String messageSize = messageTokens.nextToken(); String messageBody = pop3.getMessage(messageId); System.out.println( "\n-------------------- messsage " + messageId + ", size=" + messageSize + " --------------------"); System.out.print(messageBody); System.out.println("-------------------- end of message " + messageId + " --------------------"); } } catch (Exception e) { pop3.close(); System.out.println("Can not receive e-mail!"); e.printStackTrace(); } } }


				
Jun Wang Jun Wang Dr
About Some of Those documents come from internet for research purpose,if you have the copyrights of one of them,tell me by mail vixychina@gmail.com.Thank you!