[dolly86]

import java.net.*;
import java.io.*;
import java.util.*;

/**
* Open an SMTP connection to a remote machine and send one mail.
*
*/
public class SMTPConnection {
/* The socket to the server */
private Socket connection;

/* Streams for reading and writing the socket */
private BufferedReader fromServer;
private DataOutputStream toServer;

private static final int SMTP_PORT = 25;
private static final String CRLF = "\r\n";

/* Are we connected? Used in close() to determine what to do. */
private boolean isConnected = false;

/* Create an SMTPConnection object. Create the socket and the
associated streams. Initialize SMTP connection. */
public SMTPConnection(Envelope envelope) throws IOException {

connection = new Socket("postaci.ug.bilkent.edu.tr",SMTP_PORT);
fromServer = new BufferedReader(new InputStreamReader(connection.getInputStream()));
toServer = new DataOutputStream(connection.getOutputStream());


/* Read a line from server and check that the reply code is 220.
If not, throw an IOException. */

String line = fromServer.readLine();
int replyCode = parseReply(line);
if(replyCode != 220)
throw new IOException("Invalid reply code");

/* SMTP handshake. We need the name of the local machine.
Send the appropriate SMTP handshake command. */
String localhost = "csulb.edu";
String handshake = "HELO " + localhost + CRLF;
sendCommand( handshake, 250 );

isConnected = true;

}

/* Send the message. Write the correct SMTP-commands in the
correct order. No checking for errors, just throw them to the
caller. */
public void send(Envelope envelope) throws IOException {

/* Send all the necessary commands to send a message. Call
sendCommand() to do the dirty work. Do _not_ catch the
exception thrown from sendCommand(). */


String mailFromLine = "MAIL FROM: " + envelope.Sender + CRLF;
String rcptToLine = "";
String dataLine = "DATA" + CRLF;
String messageLine = envelope.Message.Headers + envelope.Message.Body+CRLF +"." + CRLF;

sendCommand(mailFromLine, 250);

sendCommand(dataLine, 354);
sendCommand(messageLine, 250);



}

/* Close the connection. First, terminate on SMTP level, then
close the socket. */
public void close() {

isConnected = false;
try {
sendCommand( "QUIT "+CRLF, 221 );
connection.close();
}
catch (IOException e) {

System.out.println("Unable to close connection: " + e);
isConnected = true;
}
}

/* Send an SMTP command to the server. Check that the reply code
is what is is supposed to be according to RFC 821. */
private void sendCommand(String command, int rc) throws IOException

{

/* Write command to server and read reply from server. */

toServer.writeBytes(command);
String reply = fromServer.readLine();
int replyCode = parseReply(reply);


/* Check that the server's reply code is the same as the
parameter rc. If not, throw an IOException. */
if(replyCode != rc)
throw new IOException("Invalid reply code");



}

/* Parse the reply line from the server. Returns the reply
code. */
private int parseReply(String reply) {

StringTokenizer tokens = new StringTokenizer(reply," ");
String rc = tokens.nextToken();
int replyCode = Integer.parseInt(rc);

return replyCode;
}

/* Destructor. Closes the connection if something bad happens. */
protected void finalize() throws Throwable {
if(isConnected) {
close();
}
super.finalize();
}
}