Win a copy of OCP Java SE 8 Programmer II Exam Study Guide this week in the OCP forum!

Prabhu Chandrasekaran

Ranch Hand
+ Follow
since Oct 14, 2000
Cows and Likes
Cows
Total received
0
In last 30 days
0
Total given
0
Likes
Total received
0
Received in last 30 days
0
Total given
0
Given in last 30 days
0
Forums and Threads
Scavenger Hunt
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt

Recent posts by Prabhu Chandrasekaran

Hi,

One connection can have multiple open resultsets. The issue is that in case you are using nested resultset loops like the foll code snippet :

while(rs.next())
{
// Do something //
while(rs1.next())
{
// Do something //
}
}

Then,

Resultsets rs and rs1 should have been executed using different statement objects. The connection can be same or different.

Regards,
Prabhu Chandrasekaran.
Hi Dave,
Thanks. Henceforth I will follow your advice.
Regards,
Prabhu.V.C
16 years ago
JSP
Hi,
Thanks for the reply. Can u send me the code for Multipart MIME transfer. My mail ID is prabhu_vc@yahoo.com.
Advance Thanks,
Prabhu.V.C
16 years ago
JSP
Hi friends,
The following is a generic java file used for FTP uploads
--------------------------------------------------
/**
* File: FTPConnection.java
* Author: Bret Taylor <btaylor@cs.stanford.edu>
* ---------------------------------------------
* $Id$
* ---------------------------------------------
* Parts of this code were adopted from a variety of other FTP classes the
* author has encountered that he was not completely satisfied with. If you
* think more thanks are due to any particular author than is given, please
* let him know. With that caveat, this class can be freely distributed and
* modified as long as Bret Taylor is given credit in the source code comments.
*/
import java.io.*;
import java.net.*;
import java.util.*;
/**
* <p>A wrapper for the network and command protocols needed for the most common
* FTP commands. Standard usage looks something like this:</p>
* <pre> FTPConnection connection = new FTPConnection();
* try {
* if (connection.connect(host)) {
* if (connection.login(username, password)) {
* connection.downloadFile(serverFileName);
* connection.uploadFile(localFileName);
* }
* connection.disconnect();
* }
* } catch (UnknownHostException e) {
* // handle unknown host
* } catch (IOException e) {
* // handle I/O exception
* }</pre>
* <p>Most FTP commands are wrapped by easy-to-use methods, but in case clients
* need more flexibility, you can execute commands directly using the methods
* <a href="#executeCommand(java.lang.String)">executeCommand</a> and
* <a href="#executeDataCommand(java.lang.String, java.io.OutputStream)">executeDataCommand</a>,
* the latter of which is used for commands that require an open data port.</p>
*
* @author Bret Taylor
* @version 1.0
*/
public class FTPConnection extends Object {
/**
* If this flag is on, we print out debugging information to stdout during
* execution. Useful for debugging the FTP class and seeing the server's
* responses directly.
*/
private static boolean PRINT_DEBUG_INFO = false;
/**
* Connects to the given FTP host on port 21, the default FTP port.
*/
public boolean connect(String host)
throws UnknownHostException, IOException
{
return connect(host, 21);
}
/**
* Connects to the given FTP host on the given port.
*/
public boolean connect(String host, int port)
throws UnknownHostException, IOException
{
connectionSocket = new Socket(host, port);
outputStream = new PrintStream(connectionSocket.getOutputStream());
inputStream = new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
if (!isPositiveCompleteResponse(getServerReply())){
disconnect();
return false;
}
return true;
}
/**
* Disconnects from the host to which we are currently connected.
*/
public void disconnect()
{
if (outputStream != null) {
try {
outputStream.close();
inputStream.close();
connectionSocket.close();
} catch (IOException e) {}
outputStream = null;
inputStream = null;
connectionSocket = null;
}
}
/**
* Wrapper for the commands <code>user [username]</code> and <code>pass
* [password]</code>.
*/
public boolean login(String username, String password)
throws IOException
{
int response = executeCommand("user " + username);
if (!isPositiveIntermediateResponse(response)) return false;
response = executeCommand("pass " + password);
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the command <code>cwd [directory]</code>.
*/
public boolean changeDirectory(String directory)
throws IOException
{
int response = executeCommand("cwd " + directory);
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the commands <code>rnfr [oldName]</code> and <code>rnto
* [newName]</code>.
*/
public boolean renameFile(String oldName, String newName)
throws IOException
{
int response = executeCommand("rnfr " + oldName);
if (!isPositiveIntermediateResponse(response)) return false;
response = executeCommand("rnto " + newName);
return isPositiveCompleteResponse(response);
}

/**
* Wrapper for the command <code>mkd [directory]</code>.
*/
public boolean makeDirectory(String directory)
throws IOException
{
int response = executeCommand("mkd " + directory);
return isPositiveCompleteResponse(response);
}

/**
* Wrapper for the command <code>rmd [directory]</code>.
*/
public boolean removeDirectory(String directory)
throws IOException
{
int response = executeCommand("rmd " + directory);
return isPositiveCompleteResponse(response);
}

/**
* Wrapper for the command <code>cdup</code>.
*/
public boolean parentDirectory()
throws IOException
{
int response = executeCommand("cdup");
return isPositiveCompleteResponse(response);
}

/**
* Wrapper for the command <code>dele [fileName]</code>.
*/
public boolean deleteFile(String fileName)
throws IOException
{
int response = executeCommand("dele " + fileName);
return isPositiveCompleteResponse(response);
}

/**
* Wrapper for the command <code>pwd</code>.
*/
public String getCurrentDirectory()
throws IOException
{
String response = getExecutionResponse("pwd");
StringTokenizer strtok = new StringTokenizer(response);
// Get rid of the first token, which is the return code
if (strtok.countTokens() < 2) return null;
strtok.nextToken();
String directoryName = strtok.nextToken();
// Most servers surround the directory name with quotation marks
int strlen = directoryName.length();
if (strlen == 0) return null;
if (directoryName.charAt(0) == '\"') {
directoryName = directoryName.substring(1);
strlen--;
}
if (directoryName.charAt(strlen - 1) == '\"')
return directoryName.substring(0, strlen - 1);
return directoryName;
}

/**
* Wrapper for the command <code>syst</code>.
*/
public String getSystemType()
throws IOException
{
return excludeCode(getExecutionResponse("syst"));
}

/**
* Wrapper for the command <code>mdtm [fileName]</code>. If the file does
* not exist, we return -1;
*/
public long getModificationTime(String fileName)
throws IOException
{
String response = excludeCode(getExecutionResponse("mdtm " + fileName));
try {
return Long.parseLong(response);
} catch (Exception e) {
return -1L;
}
}

/**
* Wrapper for the command <code>size [fileName]</code>. If the file does
* not exist, we return -1;
*/
public long getFileSize(String fileName)
throws IOException
{
String response = excludeCode(getExecutionResponse("size " + fileName));
try {
return Long.parseLong(response);
} catch (Exception e) {
return -1L;
}
}
/**
* Wrapper for the command <code>retr [fileName]</code>.
*/
public boolean downloadFile(String fileName)
throws IOException
{
return readDataToFile("retr " + fileName, fileName);
}
/**
* Wrapper for the command <code>retr [serverPath]</code>. The local file
* path to which we will write is given by <code>localPath</code>.
*/
public boolean downloadFile(String serverPath, String localPath)
throws IOException
{
return readDataToFile("retr " + serverPath, localPath);
}
/**
* Wrapper for the command <code>stor [fileName]</code>.
*/
public boolean uploadFile(String fileName)
throws IOException
{
return writeDataFromFile("stor " + fileName, fileName);
}
/**
* Wrapper for the command <code>stor [localPath]</code>. The server file
* path to which we will write is given by <code>serverPath</code>.
*/
public boolean uploadFile(String serverPath, String localPath)
throws IOException
{
return writeDataFromFile("stor " + serverPath, localPath);
}
/**
* Set the restart point for the next download or upload operation. This
* lets clients resume interrupted uploads or downloads.
*/
public void setRestartPoint(int point)
{
restartPoint = point;
debugPrint("Restart noted");
}
/**
* Gets server reply code from the control port after an ftp command has
* been executed. It knows the last line of the response because it begins
* with a 3 digit number and a space, (a dash instead of a space would be a
* continuation).
*/
private int getServerReply()
throws IOException
{
return Integer.parseInt(getFullServerReply().substring(0, 3));
}
/**
* Gets server reply string from the control port after an ftp command has
* been executed. This consists only of the last line of the response,
* and only the part after the response code.
*/
private String getFullServerReply()
throws IOException
{
String reply;
do {
reply = inputStream.readLine();
debugPrint(reply);
} while(!(Character.isDigit(reply.charAt(0)) &&
Character.isDigit(reply.charAt(1)) &&
Character.isDigit(reply.charAt(2)) &&
reply.charAt(3) == ' '));
return reply;
}
/**
* Executes the given FTP command on our current connection, returning the
* three digit response code from the server. This method only works for
* commands that do not require an additional data port.
*/
public int executeCommand(String command)
throws IOException
{
outputStream.println(command);
return getServerReply();
}
/**
* Executes the given FTP command on our current connection, returning the
* last line of the server's response. Useful for commands that return
* one line of information.
*/
public String getExecutionResponse(String command)
throws IOException
{
outputStream.println(command);
return getFullServerReply();
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the file with the given name, returning true
* if the server indicates that the operation was successful.
*/
public boolean readDataToFile(String command, String fileName)
throws IOException
{
// Open the local file
RandomAccessFile outfile = new RandomAccessFile(fileName, "rw");
// Do restart if desired
if (restartPoint != 0) {
debugPrint("Seeking to " + restartPoint);
outfile.seek(restartPoint);
}
// Convert the RandomAccessFile to an OutputStream
FileOutputStream fileStream = new FileOutputStream(outfile.getFD());
boolean success = executeDataCommand(command, fileStream);
outfile.close();
return success;
}
/**
* Executes the given ftpd command on the server and writes the contents
* of the given file to the server on an opened data port, returning true
* if the server indicates that the operation was successful.
*/
public boolean writeDataFromFile(String command, String fileName)
throws IOException
{
// Open the local file
RandomAccessFile infile = new RandomAccessFile(fileName, "r");
// Do restart if desired
if (restartPoint != 0) {
debugPrint("Seeking to " + restartPoint);
infile.seek(restartPoint);
}
// Convert the RandomAccessFile to an InputStream
FileInputStream fileStream = new FileInputStream(infile.getFD());
boolean success = executeDataCommand(command, fileStream);
infile.close();
return success;
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the given OutputStream, returning true
* if the server indicates that the operation was successful.
*/
public boolean executeDataCommand(String command, OutputStream out)
throws IOException
{
// Open a data socket on this computer
ServerSocket serverSocket = new ServerSocket(0);
if (!setupDataPort(command, serverSocket)) return false;
Socket clientSocket = serverSocket.accept();
// Transfer the data
InputStream in = clientSocket.getInputStream();
transferData(in, out);
// Clean up the data structures
in.close();
clientSocket.close();
serverSocket.close();
return isPositiveCompleteResponse(getServerReply());
}
/**
* Executes the given ftpd command on the server and writes the contents
* of the given InputStream to the server on an opened data port, returning
* true if the server indicates that the operation was successful.
*/
public boolean executeDataCommand(String command, InputStream in)
throws IOException
{
// Open a data socket on this computer
ServerSocket serverSocket = new ServerSocket(0);
if (!setupDataPort(command, serverSocket)) return false;
Socket clientSocket = serverSocket.accept();
// Transfer the data
OutputStream out = clientSocket.getOutputStream();
transferData(in, out);
// Clean up the data structures
out.close();
clientSocket.close();
serverSocket.close();
return isPositiveCompleteResponse(getServerReply());
}
/**
* Transfers the data from the given input stream to the given output
* stream until we reach the end of the stream.
*/
private void transferData(InputStream in, OutputStream out)
throws IOException
{
byte b[] = new byte[1024]; // 1K blocks I guess
int amount;
// Read the data into the file
while ((amount = in.read(b)) > 0) {
out.write(b, 0, amount);
}
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the given FilterOutputStream, returning true
* if the server indicates that the operation was successful.
*/
private boolean setupDataPort(String command, ServerSocket serverSocket)
throws IOException
{
// Send our local data port to the server
if (!openPort(serverSocket)) return false;
// Set binary type transfer
outputStream.println("type i");
if (!isPositiveCompleteResponse(getServerReply())) {
debugPrint("Could not set transfer type");
return false;
}
// If we have a restart point, send that information
if (restartPoint != 0) {
outputStream.println("rest " + restartPoint);
restartPoint = 0;
// TODO: Interpret server response here
getServerReply();
}
// Send the command
outputStream.println(command);
return isPositivePreliminaryResponse(getServerReply());
}
/**
* Get IP address and port number from serverSocket and send them via the
* <code>port</code> command to the ftp server, returning true if we get a
* valid response from the server, returning true if the server indicates
* that the operation was successful.
*/
private boolean openPort(ServerSocket serverSocket)
throws IOException
{
int localport = serverSocket.getLocalPort();
// get local ip address
InetAddress inetaddress = serverSocket.getInetAddress();
InetAddress localip;
try {
localip = inetaddress.getLocalHost();
} catch(UnknownHostException e) {
debugPrint("Can't get local host");
return false;
}
// get ip address in high byte order
byte[] addrbytes = localip.getAddress();
// tell server what port we are listening on
short addrshorts[] = new short[4];
// problem: bytes greater than 127 are printed as negative numbers
for(int i = 0; i <= 3; i++) {
addrshorts[i] = addrbytes[i];
if (addrshorts[i] < 0)
addrshorts[i] += 256;
}
outputStream.println("port " + addrshorts[0] + "," + addrshorts[1] +
"," + addrshorts[2] + "," + addrshorts[3] + "," +
((localport & 0xff00) >> 8) + "," +
(localport & 0x00ff));
return isPositiveCompleteResponse(getServerReply());
}
/**
* True if the given response code is in the 100-199 range.
*/
private boolean isPositivePreliminaryResponse(int response)
{
return (response >= 100 && response < 200);
}
/**
* True if the given response code is in the 300-399 range.
*/
private boolean isPositiveIntermediateResponse(int response)
{
return (response >= 300 && response < 400);
}
/**
* True if the given response code is in the 200-299 range.
*/
private boolean isPositiveCompleteResponse(int response)
{
return (response >= 200 && response < 300);
}
/**
* True if the given response code is in the 400-499 range.
*/
private boolean isTransientNegativeResponse(int response)
{
return (response >= 400 && response < 500);
}
/**
* True if the given response code is in the 500-599 range.
*/
private boolean isPermanentNegativeResponse(int response)
{
return (response >= 500 && response < 600);
}
/**
* Eliminates the response code at the beginning of the response string.
*/
private String excludeCode(String response)
{
if (response.length() < 5) return response;
return response.substring(4);
}
/**
* Prints debugging information to stdout if the private flag
* <code>PRINT_DEBUG_INFO</code> is turned on.
*/
private void debugPrint(String message) {
if (PRINT_DEBUG_INFO) System.err.println(message);
}
/**
* The socket through which we are connected to the FTP server.
*/
private Socket connectionSocket = null;
/**
* The socket output stream.
*/
private PrintStream outputStream = null;
/**
* The socket input stream.
*/
private BufferedReader inputStream = null;
/**
* The offset at which we resume a file transfer.
*/
private long restartPoint = 0L;
}
--------------------------------------------------
The following is the jsp file that uses the FTPConnection java file
--------------------------------------------------
<%@page import="java.io.*,FTPConnection"%>
<html>
<title> FTP Try Jsp </title>
<%
String mfilename=request.getParameter("mfilename");
try
{
FTPConnection fconnect = new FTPConnection();
fconnect.connect("193.1.1.6");
// login //
fconnect.login("userpos","userpos");
fconnect.changeDirectory("../kws/library");
out.println("<B>"+fconnect.getCurrentDirectory()+"</b><BR>");
fconnect.uploadFile(mfilename);
fconnect.disconnect();
}
catch(Exception ex)
{
out.println("EXception caused :: "+ex+"<BR>");
}
%>
--------------------------------------------------
The file to be ported is got from the user via a <input type=file> tag and onSubmit the above jsp file is called. This throws an FileNotFoundException as it is unable to recognise that the file selected is from the local hard disk.
Can anyone help me out ??
It is Urgent.
Advance Thanks,
Prabhu.V.C
16 years ago
JSP
hi friends,
I want to port a file from local windows machines to solaris server.
Iam using <input type=file> tag and have given enctype="multipart/form-data" in the <form tag>
can anyone of you pls enlighten how to access the file contents that the user has chosen in the jsp page that opens on submit. on giving getParameterNames in the jsp, the output is a HashTable$Enumerator.
Advance Thanks,
Prabhu.V.C
16 years ago
JSP
The following is the code ...
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class FilePort extends HttpServlet
{
public void doGet (HttpServletRequestrequest,HttpServletResponseresponse) throws ServletException, IOException
{
PrintWriterout;
String title = "File Port Test Program ";
response.setContentType("text/html");
String mfilename=request.getParameter("mfilename");
// then write the data of the response
out = response.getWriter();
out.println("<HTML><HEAD><TITLE>");
out.println(title);
out.println("</TITLE></HEAD><BODY>");
out.println("<form name=PortFile action=http://iis-development:7777/pos/FilePort method=GET>");
out.println("<H3>" + title + "</H3>");
out.println("<BR>");
if(mfilename == null)
{
out.println("<input type=file name=mfilename>");
out.println("<BR><BR><BR>");
out.println("<input type=submit value='Port File ... '>");
}
else
{
int i=0;
out.println("File Name :: "+mfilename.trim());
try
{
//out.println("File Name :: "+mfilename+"<BR>");
String newpath="\\datadisk1\\pos\\";
FileInputStream fi=new FileInputStream(mfilename);
int last_slash_posn=mfilename.lastIndexOf("\\");
String newfilename=mfilename.substring(last_slash_posn+1,mfilename.length());
out.println("New File Name :: "+newfilename+"<BR>");
FileOutputStream fo=new FileOutputStream(newpath+newfilename);
while(i != -1)
{
i=fi.read();
if(i != -1)
{
fo.write((char) i);
}
}
fi.close();
fo.close();
out.println("<BR><BR><a href="+newpath+newfilename+"> Click To Open </a>");
}
catch(Exception ex)
{
out.println("Problem in File Porting ... "+ex);
}
}
out.println("</BODY></HTML>");
out.close();
}
}
16 years ago
JSP
Hi Friends,
I have to port files from local machines running on windows platform to a server running in solaris. The files should be ported in the same format as they are currently in ..
Using File Input / Output Streams throws an FileNotFound Exception.
Please help.
Advance Thanks,
Prabhu.V.C
16 years ago
JSP
Thanks,
I will try to change this program style so that it fits to the requirements.
Thanks again for the advice. Henceforth, I will be more specific with my subject line.
Regards,
Prabhu.V.C
16 years ago
JSP
Friends,
i have one jsp report which comes to 5000 lines. it is compiling properly but on runtime, it gives an error stating
java.lang.VerifyError Illegal target for jump or branch found.
what is the problem and how to rectify ?? Pls. help.
Advance thanks,
Prabhu.V.C
16 years ago
JSP
hi friends,
thanks for the replies.
after setting the mime type, my problem is solved.
thanks again
16 years ago
JSP
hi friends,
my requirement is that the output html of a jsp page be redirected as an excel sheet. how to go about doing this ??
pls. help
Advance thanks,
Prabhu Chandrasekaran
16 years ago
JSP
Hi Friends,
Iam trying out a mailing code which will mail via a smtp server. It is compiling without a problem.
but on execution of the same.. the following msgs are shown :
DEBUG: SMTPTransport connected to host "193.1.1.22", PORT: 25
DEBUG SMTP SENT: NOOP
DEBUG SMTP RCVD: 500 unknown ??? command ""
java.lang.IllegalStateException: Not Connected
The code is as follows :
import java.io.*;
import java.util.*;
import java.net.InetAddress;
//mail imports for activation.jar and mail.jar
import javax.mail.Session;
import javax.mail.Message;
import javax.mail.Transport;
import javax.mail.Multipart;
import javax.mail.BodyPart;
import javax.activation.DataSource;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
class test
{
public static void main(String[] args)
{
try
{
HashMap x=new HashMap();
x.put("mailServer","193.1.1.22");
x.put("toAddress","prabhu_vc@yahoo.com");
x.put("subject","sent by vcp");
x.put("message","congratulations on ur first step");
boolean sent=sendMail(x);
}
catch(Exception ex)
{
System.out.println(ex);
}
}
public static boolean sendMail(HashMap mailDetails) throws Exception
{
try
{
boolean debugFlag=true;
String mailServer=(String)mailDetails.get("mailServer");
Properties properties = System.getProperties();
Session session = Session.getDefaultInstance(properties,null);
session.setDebug(debugFlag);
Message mess = new MimeMessage(session);
if(mailDetails.get("toAddress")!=null)
{
//String to[] =(String[])mailDetails.get("toAddress");
String to[] = StringSplit.splitString((String)mailDetails.get("toAddress"),",");
InternetAddress toInternetAddress[] = new InternetAddress[to.length];
for(int i=0;i<to.length;i++)
{
toInternetAddress[i]=new InternetAddress(to[i].trim());
}
mess.setRecipients(Message.RecipientType.TO,toInternetAddress);
}
String message=(String)mailDetails.get("message");
String attachment[] = (String[])mailDetails.get("attachment");
properties.put("mail.smtp.host",mailServer); // get snmphost property
String from = (String)mailDetails.get("fromAddress");
if(from!=null && !from.equals(""))
mess.setFrom(new InternetAddress(from));
mess.setSentDate(new Date());
if(mailDetails.get("ccAddress")!=null)
{
String cc[] =(String[])mailDetails.get("ccAddress");
InternetAddress ccInternetAddress[] = new InternetAddress[cc.length];
for(int i=0;i<cc.length;i++)
{
ccInternetAddress[i]=new InternetAddress(cc[i].trim());
}
mess.setRecipients(Message.RecipientType.CC,ccInternetAddress);
}
mess.setSubject((String)(mailDetails.get("subject")));
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(message);
Multipart multipart = new MimeMultipart();
multipart.addBodyPart(messageBodyPart);
if(attachment!=null)
{
for(int i=0;i<attachment.length;i++)
{
File f = new File(attachment[i].trim());
if(f.exists())
{
messageBodyPart = new MimeBodyPart();
DataSource dataSource = new FileDataSource(attachment[i]);
messageBodyPart.setDataHandler(new DataHandler(dataSource));
messageBodyPart.setFileName(f.getName());
multipart.addBodyPart(messageBodyPart);
}
}
}
mess.setContent(multipart);
mess.saveChanges();
try
{
Transport.send(mess);
}
catch(Exception ex)
{
System.out.println("While Sending Only .... "+ex);
}
}
catch(Exception ex)
{
System.out.println("inside fn :"+ex);
}
return true;
}
}

I would be very much thankful if any of u can reply with some clarifications.
Advance Thanks,
Prabhu.V.C
16 years ago
Thanks yet again for ur prompt replies.
Bye,
Prabhu.V.C

------------------
16 years ago
Thanks everybody for your replies ....
I rectified the problem i had mentioned about. I had included a stylesheet prior to the <jsp:forward> being given. I dont know the cause of the problem, but when I shifted the <include> directive after the <jsp:forward> it is now working fine.
Thanks again.
If any ou U friends can enlighten me as to reason of the error, it would be very helpful.
Thanks,
Prabhu.V.C

------------------
16 years ago
Hi Friends,
I need an immediate clarification. My jsp program uses a session. I want to redirect the page to a html page when the session times out. but when I give jsp:forward, it throws an exception saying that "cannot clear JspWriter buffer. Already written source ... " and it does not re direct the page.
Please help.
Thanks,
Prabhu.V.C
16 years ago