%line	%branch
org.apache.commons.net.ftp.FTP	0%	0%

1		/*
2		* Copyright 2001-2005 The Apache Software Foundation
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.apache.commons.net.ftp;
17		import java.io.BufferedReader;
18		import java.io.BufferedWriter;
19		import java.io.IOException;
20		import java.io.InputStreamReader;
21		import java.io.OutputStreamWriter;
22		import java.lang.reflect.InvocationTargetException;
23		import java.lang.reflect.Method;
24		import java.net.InetAddress;
25		import java.net.Socket;
26		import java.net.SocketException;
27		import java.util.Enumeration;
28		import java.util.Vector;
29
30		import org.apache.commons.net.MalformedServerReplyException;
31		import org.apache.commons.net.ProtocolCommandListener;
32		import org.apache.commons.net.ProtocolCommandSupport;
33		import org.apache.commons.net.SocketClient;
34		import org.apache.commons.net.telnet.TelnetClient;
35
36		/***
37		* FTP provides the basic the functionality necessary to implement your
38		* own FTP client. It extends org.apache.commons.net.TelnetClient
39		* simply because it saves the writing of extra code to handle the FTP
40		* control connection which always remains open during an FTP session and
41		* uses the Telnet protocol. Aggregation would require writing new
42		* wrapper methods and wouldn't leverage the functionality already
43		* present in org.apache.commons.net.SocketClient.
44		* <p>
45		* To derive the full benefits of the FTP class requires some knowledge
46		* of the FTP protocol defined in RFC 959. However, there is no reason
47		* why you should have to use the FTP class. The
48		* {@link org.apache.commons.net.ftp.FTPClient} class,
49		* derived from FTP,
50		* implements all the functionality required of an FTP client. The
51		* FTP class is made public to provide access to various FTP constants
52		* and to make it easier for adventurous programmers (or those with
53		* special needs) to interact with the FTP protocol and implement their
54		* own clients. A set of methods with names corresponding to the FTP
55		* command names are provided to facilitate this interaction.
56		* <p>
57		* You should keep in mind that the FTP server may choose to prematurely
58		* close a connection if the client has been idle for longer than a
59		* given time period (usually 900 seconds). The FTP class will detect a
60		* premature FTP server connection closing when it receives a
61		* {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
62		* response to a command.
63		* When that occurs, the FTP class method encountering that reply will throw
64		* an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
65		* . <code>FTPConectionClosedException</code>
66		* is a subclass of <code> IOException </code> and therefore need not be
67		* caught separately, but if you are going to catch it separately, its
68		* catch block must appear before the more general <code> IOException </code>
69		* catch block. When you encounter an
70		* {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
71		* , you must disconnect the connection with
72		* {@link #disconnect disconnect() } to properly clean up the
73		* system resources used by FTP. Before disconnecting, you may check the
74		* last reply code and text with
75		* {@link #getReplyCode getReplyCode },
76		* {@link #getReplyString getReplyString },
77		* and {@link #getReplyStrings getReplyStrings}.
78		* You may avoid server disconnections while the client is idle by
79		* periodicaly sending NOOP commands to the server.
80		* <p>
81		* Rather than list it separately for each method, we mention here that
82		* every method communicating with the server and throwing an IOException
83		* can also throw a
84		* {@link org.apache.commons.net.MalformedServerReplyException}
85		* , which is a subclass
86		* of IOException. A MalformedServerReplyException will be thrown when
87		* the reply received from the server deviates enough from the protocol
88		* specification that it cannot be interpreted in a useful manner despite
89		* attempts to be as lenient as possible.
90		* <p>
91		* <p>
92		* @author Daniel F. Savarese
93		* @see FTPClient
94		* @see FTPConnectionClosedException
95		* @see org.apache.commons.net.MalformedServerReplyException
96		***/
97
98		public class FTP extends TelnetClient
99		{
100		/*** The default FTP data port (20). ***/
101		public static final int DEFAULT_DATA_PORT = 20;
102		/*** The default FTP control port (21). ***/
103		public static final int DEFAULT_PORT = 21;
104
105		/***
106		* A constant used to indicate the file(s) being transfered should
107		* be treated as ASCII. This is the default file type. All constants
108		* ending in <code>FILE_TYPE</code> are used to indicate file types.
109		***/
110		public static final int ASCII_FILE_TYPE = 0;
111
112		/***
113		* A constant used to indicate the file(s) being transfered should
114		* be treated as EBCDIC. Note however that there are several different
115		* EBCDIC formats. All constants ending in <code>FILE_TYPE</code>
116		* are used to indicate file types.
117		***/
118		public static final int EBCDIC_FILE_TYPE = 1;
119
120		/***
121		* A constant used to indicate the file(s) being transfered should
122		* be treated as a binary image, i.e., no translations should be
123		* performed. All constants ending in <code>FILE_TYPE</code> are used to
124		* indicate file types.
125		***/
126		public static final int IMAGE_FILE_TYPE = 2;
127
128		/***
129		* A constant used to indicate the file(s) being transfered should
130		* be treated as a binary image, i.e., no translations should be
131		* performed. All constants ending in <code>FILE_TYPE</code> are used to
132		* indicate file types.
133		***/
134		public static final int BINARY_FILE_TYPE = 2;
135
136		/***
137		* A constant used to indicate the file(s) being transfered should
138		* be treated as a local type. All constants ending in
139		* <code>FILE_TYPE</code> are used to indicate file types.
140		***/
141		public static final int LOCAL_FILE_TYPE = 3;
142
143		/***
144		* A constant used for text files to indicate a non-print text format.
145		* This is the default format.
146		* All constants ending in <code>TEXT_FORMAT</code> are used to indicate
147		* text formatting for text transfers (both ASCII and EBCDIC).
148		***/
149		public static final int NON_PRINT_TEXT_FORMAT = 4;
150
151		/***
152		* A constant used to indicate a text file contains format vertical format
153		* control characters.
154		* All constants ending in <code>TEXT_FORMAT</code> are used to indicate
155		* text formatting for text transfers (both ASCII and EBCDIC).
156		***/
157		public static final int TELNET_TEXT_FORMAT = 5;
158
159		/***
160		* A constant used to indicate a text file contains ASA vertical format
161		* control characters.
162		* All constants ending in <code>TEXT_FORMAT</code> are used to indicate
163		* text formatting for text transfers (both ASCII and EBCDIC).
164		***/
165		public static final int CARRIAGE_CONTROL_TEXT_FORMAT = 6;
166
167		/***
168		* A constant used to indicate a file is to be treated as a continuous
169		* sequence of bytes. This is the default structure. All constants ending
170		* in <code>_STRUCTURE</code> are used to indicate file structure for
171		* file transfers.
172		***/
173		public static final int FILE_STRUCTURE = 7;
174
175		/***
176		* A constant used to indicate a file is to be treated as a sequence
177		* of records. All constants ending in <code>_STRUCTURE</code>
178		* are used to indicate file structure for file transfers.
179		***/
180		public static final int RECORD_STRUCTURE = 8;
181
182		/***
183		* A constant used to indicate a file is to be treated as a set of
184		* independent indexed pages. All constants ending in
185		* <code>_STRUCTURE</code> are used to indicate file structure for file
186		* transfers.
187		***/
188		public static final int PAGE_STRUCTURE = 9;
189
190		/***
191		* A constant used to indicate a file is to be transfered as a stream
192		* of bytes. This is the default transfer mode. All constants ending
193		* in <code>TRANSFER_MODE</code> are used to indicate file transfer
194		* modes.
195		***/
196		public static final int STREAM_TRANSFER_MODE = 10;
197
198		/***
199		* A constant used to indicate a file is to be transfered as a series
200		* of blocks. All constants ending in <code>TRANSFER_MODE</code> are used
201		* to indicate file transfer modes.
202		***/
203		public static final int BLOCK_TRANSFER_MODE = 11;
204
205		/***
206		* A constant used to indicate a file is to be transfered as FTP
207		* compressed data. All constants ending in <code>TRANSFER_MODE</code>
208		* are used to indicate file transfer modes.
209		***/
210		public static final int COMPRESSED_TRANSFER_MODE = 12;
211
212		// We have to ensure that the protocol communication is in ASCII
213		// but we use ISO-8859-1 just in case 8-bit characters cross
214		// the wire.
215		/**
216		* The default character encoding used for communicating over an
217		* FTP control connection. The default encoding is an
218		* ASCII-compatible encoding. Some FTP servers expect other
219		* encodings. You can change the encoding used by an FTP instance
220		* with {@link #setControlEncoding setControlEncoding}.
221		*/
222		public static final String DEFAULT_CONTROL_ENCODING = "ISO-8859-1";
223		private static final String __modes = "ABILNTCFRPSBC";
224
225		private StringBuffer __commandBuffer;
226
227		BufferedReader _controlInput;
228		BufferedWriter _controlOutput;
229		int _replyCode;
230		Vector _replyLines;
231		boolean _newReplyString;
232		String _replyString;
233		String _controlEncoding;
234
235		/***
236		* A ProtocolCommandSupport object used to manage the registering of
237		* ProtocolCommandListeners and te firing of ProtocolCommandEvents.
238		***/
239		protected ProtocolCommandSupport _commandSupport_;
240
241		/***
242		* The default FTP constructor. Sets the default port to
243		* <code>DEFAULT_PORT</code> and initializes internal data structures
244		* for saving FTP reply information.
245		***/
246		public FTP()
247	0	{
248	0	setDefaultPort(DEFAULT_PORT);
249	0	__commandBuffer = new StringBuffer();
250	0	_replyLines = new Vector();
251	0	_newReplyString = false;
252	0	_replyString = null;
253	0	_commandSupport_ = new ProtocolCommandSupport(this);
254	0	_controlEncoding = DEFAULT_CONTROL_ENCODING;
255	0	}
256
257		private void __getReply() throws IOException
258		{
259		int length;
260
261	0	_newReplyString = true;
262	0	_replyLines.setSize(0);
263
264	0	String line = _controlInput.readLine();
265
266	0	if (line == null)
267	0	throw new FTPConnectionClosedException(
268		"Connection closed without indication.");
269
270		// In case we run into an anomaly we don't want fatal index exceptions
271		// to be thrown.
272	0	length = line.length();
273	0	if (length < 3)
274	0	throw new MalformedServerReplyException(
275		"Truncated server reply: " + line);
276
277		try
278		{
279	0	String code = line.substring(0, 3);
280	0	_replyCode = Integer.parseInt(code);
281		}
282	0	catch (NumberFormatException e)
283		{
284	0	throw new MalformedServerReplyException(
285		"Could not parse response code.\nServer Reply: " + line);
286	0	}
287
288	0	_replyLines.addElement(line);
289
290		// Get extra lines if message continues.
291	0	if (length > 3 && line.charAt(3) == '-')
292		{
293		do
294		{
295	0	line = _controlInput.readLine();
296
297	0	if (line == null)
298	0	throw new FTPConnectionClosedException(
299		"Connection closed without indication.");
300
301	0	_replyLines.addElement(line);
302
303		// The length() check handles problems that could arise from readLine()
304		// returning too soon after encountering a naked CR or some other
305		// anomaly.
306		}
307	0	while (!(line.length() >= 4 && line.charAt(3) != '-' &&
308		Character.isDigit(line.charAt(0))));
309		// This is too strong a condition because of non-conforming ftp
310		// servers like ftp.funet.fi which sent 226 as the last line of a
311		// 426 multi-line reply in response to ls /. We relax the condition to
312		// test that the line starts with a digit rather than starting with
313		// the code.
314		// line.startsWith(code)));
315		}
316
317	0	if (_commandSupport_.getListenerCount() > 0)
318	0	_commandSupport_.fireReplyReceived(_replyCode, getReplyString());
319
320	0	if (_replyCode == FTPReply.SERVICE_NOT_AVAILABLE)
321	0	throw new FTPConnectionClosedException(
322		"FTP response 421 received. Server closed connection.");
323	0	}
324
325		// initiates control connections and gets initial reply
326		protected void _connectAction_() throws IOException
327		{
328	0	super._connectAction_();
329	0	_controlInput =
330		new BufferedReader(class="keyword">new InputStreamReader(getInputStream(),
331		getControlEncoding()));
332	0	_controlOutput =
333		new BufferedWriter(class="keyword">new OutputStreamWriter(getOutputStream(),
334		getControlEncoding()));
335	0	__getReply();
336		// If we received code 120, we have to fetch completion reply.
337	0	if (FTPReply.isPositivePreliminary(_replyCode))
338	0	__getReply();
339	0	}
340
341
342		/**
343		* Sets the character encoding used by the FTP control connection.
344		* Some FTP servers require that commands be issued in a non-ASCII
345		* encoding like UTF-8 so that filenames with multi-byte character
346		* representations (e.g, Big 8) can be specified.
347		*
348		* @param encoding The new character encoding for the control connection.
349		*/
350		public void setControlEncoding(String encoding) {
351	0	_controlEncoding = encoding;
352	0	}
353
354
355		/**
356		* @return The character encoding used to communicate over the
357		* control connection.
358		*/
359		public String getControlEncoding() {
360	0	return _controlEncoding;
361		}
362
363
364		/***
365		* Adds a ProtocolCommandListener. Delegates this task to
366		* {@link #_commandSupport_ _commandSupport_ }.
367		* <p>
368		* @param listener The ProtocolCommandListener to add.
369		***/
370		public void addProtocolCommandListener(ProtocolCommandListener listener)
371		{
372	0	_commandSupport_.addProtocolCommandListener(listener);
373	0	}
374
375		/***
376		* Removes a ProtocolCommandListener. Delegates this task to
377		* {@link #_commandSupport_ _commandSupport_ }.
378		* <p>
379		* @param listener The ProtocolCommandListener to remove.
380		***/
381		public void removeProtocolCommandListener(ProtocolCommandListener listener)
382		{
383	0	_commandSupport_.removeProtocolCommandListener(listener);
384	0	}
385
386
387		/***
388		* Closes the control connection to the FTP server and sets to null
389		* some internal data so that the memory may be reclaimed by the
390		* garbage collector. The reply text and code information from the
391		* last command is voided so that the memory it used may be reclaimed.
392		* <p>
393		* @exception IOException If an error occurs while disconnecting.
394		***/
395		public void disconnect() throws IOException
396		{
397	0	super.disconnect();
398	0	_controlInput = null;
399	0	_controlOutput = null;
400	0	_replyLines.setSize(0);
401	0	_newReplyString = false;
402	0	_replyString = null;
403	0	}
404
405
406		/***
407		* Sends an FTP command to the server, waits for a reply and returns the
408		* numerical response code. After invocation, for more detailed
409		* information, the actual reply text can be accessed by calling
410		* {@link #getReplyString getReplyString } or
411		* {@link #getReplyStrings getReplyStrings }.
412		* <p>
413		* @param command The text representation of the FTP command to send.
414		* @param args The arguments to the FTP command. If this parameter is
415		* set to null, then the command is sent with no argument.
416		* @return The integer value of the FTP reply code returned by the server
417		* in response to the command.
418		* @exception FTPConnectionClosedException
419		* If the FTP server prematurely closes the connection as a result
420		* of the client being idle or some other reason causing the server
421		* to send FTP reply code 421. This exception may be caught either
422		* as an IOException or independently as itself.
423		* @exception IOException If an I/O error occurs while either sending the
424		* command or receiving the server reply.
425		***/
426		public int sendCommand(String command, String args) throws IOException
427		{
428		String message;
429
430	0	__commandBuffer.setLength(0);
431	0	__commandBuffer.append(command);
432
433	0	if (args != null)
434		{
435	0	__commandBuffer.append(' ');
436	0	__commandBuffer.append(args);
437		}
438	0	__commandBuffer.append(SocketClient.NETASCII_EOL);
439
440		try{
441	0	_controlOutput.write(message = __commandBuffer.toString());
442	0	_controlOutput.flush();
443		}
444	0	catch (SocketException e)
445		{
446	0	if (!isConnected() || !socketIsConnected(_socket_))
447		{
448	0	throw new FTPConnectionClosedException("Connection unexpectedly closed.");
449		}
450		else
451		{
452	0	throw e;
453		}
454	0	}
455
456
457	0	if (_commandSupport_.getListenerCount() > 0)
458	0	_commandSupport_.fireCommandSent(command, message);
459
460	0	__getReply();
461	0	return _replyCode;
462		}
463
464		/**
465		* Checks if the socket is connected using reflection to be backward compatible.
466		* The return value of this method is only meaningful in an java 1.4 environment.
467		*
468		* @param socket
469		* @return true if connected or pre java 1.4
470		*/
471		private boolean socketIsConnected(Socket socket)
472		{
473	0	if (socket == null)
474		{
475	0	return false;
476		}
477
478		try
479		{
480	0	Method isConnected = socket.getClass().getMethod("isConnected", null);
481	0	return ((Boolean) isConnected.invoke(socket, null)).booleanValue();
482		}
483	0	catch (NoSuchMethodException e)
484		{
485	0	return true;
486		}
487	0	catch (IllegalAccessException e)
488		{
489	0	return true;
490		}
491	0	catch (InvocationTargetException e)
492		{
493	0	return true;
494		}
495		}
496
497		/***
498		* Sends an FTP command to the server, waits for a reply and returns the
499		* numerical response code. After invocation, for more detailed
500		* information, the actual reply text can be accessed by calling
501		* {@link #getReplyString getReplyString } or
502		* {@link #getReplyStrings getReplyStrings }.
503		* <p>
504		* @param command The FTPCommand constant corresponding to the FTP command
505		* to send.
506		* @param args The arguments to the FTP command. If this parameter is
507		* set to null, then the command is sent with no argument.
508		* @return The integer value of the FTP reply code returned by the server
509		* in response to the command.
510		* @exception FTPConnectionClosedException
511		* If the FTP server prematurely closes the connection as a result
512		* of the client being idle or some other reason causing the server
513		* to send FTP reply code 421. This exception may be caught either
514		* as an IOException or independently as itself.
515		* @exception IOException If an I/O error occurs while either sending the
516		* command or receiving the server reply.
517		***/
518		public int sendCommand(class="keyword">int command, String args) throws IOException
519		{
520	0	return sendCommand(FTPCommand._commands[command], args);
521		}
522
523
524		/***
525		* Sends an FTP command with no arguments to the server, waits for a
526		* reply and returns the numerical response code. After invocation, for
527		* more detailed information, the actual reply text can be accessed by
528		* calling {@link #getReplyString getReplyString } or
529		* {@link #getReplyStrings getReplyStrings }.
530		* <p>
531		* @param command The text representation of the FTP command to send.
532		* @return The integer value of the FTP reply code returned by the server
533		* in response to the command.
534		* @exception FTPConnectionClosedException
535		* If the FTP server prematurely closes the connection as a result
536		* of the client being idle or some other reason causing the server
537		* to send FTP reply code 421. This exception may be caught either
538		* as an IOException or independently as itself.
539		* @exception IOException If an I/O error occurs while either sending the
540		* command or receiving the server reply.
541		***/
542		public int sendCommand(String command) throws IOException
543		{
544	0	return sendCommand(command, null);
545		}
546
547
548		/***
549		* Sends an FTP command with no arguments to the server, waits for a
550		* reply and returns the numerical response code. After invocation, for
551		* more detailed information, the actual reply text can be accessed by
552		* calling {@link #getReplyString getReplyString } or
553		* {@link #getReplyStrings getReplyStrings }.
554		* <p>
555		* @param command The FTPCommand constant corresponding to the FTP command
556		* to send.
557		* @return The integer value of the FTP reply code returned by the server
558		* in response to the command.
559		* @exception FTPConnectionClosedException
560		* If the FTP server prematurely closes the connection as a result
561		* of the client being idle or some other reason causing the server
562		* to send FTP reply code 421. This exception may be caught either
563		* as an IOException or independently as itself.
564		* @exception IOException If an I/O error occurs while either sending the
565		* command or receiving the server reply.
566		***/
567		public int sendCommand(class="keyword">int command) throws IOException
568		{
569	0	return sendCommand(command, null);
570		}
571
572
573		/***
574		* Returns the integer value of the reply code of the last FTP reply.
575		* You will usually only use this method after you connect to the
576		* FTP server to check that the connection was successful since
577		* <code> connect </code> is of type void.
578		* <p>
579		* @return The integer value of the reply code of the last FTP reply.
580		***/
581		public int getReplyCode()
582		{
583	0	return _replyCode;
584		}
585
586		/***
587		* Fetches a reply from the FTP server and returns the integer reply
588		* code. After calling this method, the actual reply text can be accessed
589		* from either calling {@link #getReplyString getReplyString } or
590		* {@link #getReplyStrings getReplyStrings }. Only use this
591		* method if you are implementing your own FTP client or if you need to
592		* fetch a secondary response from the FTP server.
593		* <p>
594		* @return The integer value of the reply code of the fetched FTP reply.
595		* @exception FTPConnectionClosedException
596		* If the FTP server prematurely closes the connection as a result
597		* of the client being idle or some other reason causing the server
598		* to send FTP reply code 421. This exception may be caught either
599		* as an IOException or independently as itself.
600		* @exception IOException If an I/O error occurs while receiving the
601		* server reply.
602		***/
603		public int getReply() throws IOException
604		{
605	0	__getReply();
606	0	return _replyCode;
607		}
608
609
610		/***
611		* Returns the lines of text from the last FTP server response as an array
612		* of strings, one entry per line. The end of line markers of each are
613		* stripped from each line.
614		* <p>
615		* @return The lines of text from the last FTP response as an array.
616		***/
617		public String[] getReplyStrings()
618		{
619		String[] lines;
620	0	lines = new String[_replyLines.size()];
621	0	_replyLines.copyInto(lines);
622	0	return lines;
623		}
624
625		/***
626		* Returns the entire text of the last FTP server response exactly
627		* as it was received, including all end of line markers in NETASCII
628		* format.
629		* <p>
630		* @return The entire text from the last FTP response as a String.
631		***/
632		public String getReplyString()
633		{
634		Enumeration en;
635		StringBuffer buffer;
636
637	0	if (!_newReplyString)
638	0	return _replyString;
639
640	0	buffer = new StringBuffer(256);
641	0	en = _replyLines.elements();
642	0	while (en.hasMoreElements())
643		{
644	0	buffer.append((String)en.nextElement());
645	0	buffer.append(SocketClient.NETASCII_EOL);
646		}
647
648	0	_newReplyString = false;
649
650	0	return (_replyString = buffer.toString());
651		}
652
653
654		/***
655		* A convenience method to send the FTP USER command to the server,
656		* receive the reply, and return the reply code.
657		* <p>
658		* @param username The username to login under.
659		* @return The reply code received from the server.
660		* @exception FTPConnectionClosedException
661		* If the FTP server prematurely closes the connection as a result
662		* of the client being idle or some other reason causing the server
663		* to send FTP reply code 421. This exception may be caught either
664		* as an IOException or independently as itself.
665		* @exception IOException If an I/O error occurs while either sending the
666		* command or receiving the server reply.
667		***/
668		public int user(String username) throws IOException
669		{
670	0	return sendCommand(FTPCommand.USER, username);
671		}
672
673		/**
674		* A convenience method to send the FTP PASS command to the server,
675		* receive the reply, and return the reply code.
676		* @param password The plain text password of the username being logged into.
677		* @return The reply code received from the server.
678		* @exception FTPConnectionClosedException
679		* If the FTP server prematurely closes the connection as a result
680		* of the client being idle or some other reason causing the server
681		* to send FTP reply code 421. This exception may be caught either
682		* as an IOException or independently as itself.
683		* @exception IOException If an I/O error occurs while either sending the
684		* command or receiving the server reply.
685		*/
686		public int pass(String password) throws IOException
687		{
688	0	return sendCommand(FTPCommand.PASS, password);
689		}
690
691		/***
692		* A convenience method to send the FTP ACCT command to the server,
693		* receive the reply, and return the reply code.
694		* <p>
695		* @param account The account name to access.
696		* @return The reply code received from the server.
697		* @exception FTPConnectionClosedException
698		* If the FTP server prematurely closes the connection as a result
699		* of the client being idle or some other reason causing the server
700		* to send FTP reply code 421. This exception may be caught either
701		* as an IOException or independently as itself.
702		* @exception IOException If an I/O error occurs while either sending the
703		* command or receiving the server reply.
704		***/
705		public int acct(String account) throws IOException
706		{
707	0	return sendCommand(FTPCommand.ACCT, account);
708		}
709
710
711		/***
712		* A convenience method to send the FTP ABOR command to the server,
713		* receive the reply, and return the reply code.
714		* <p>
715		* @return The reply code received from the server.
716		* @exception FTPConnectionClosedException
717		* If the FTP server prematurely closes the connection as a result
718		* of the client being idle or some other reason causing the server
719		* to send FTP reply code 421. This exception may be caught either
720		* as an IOException or independently as itself.
721		* @exception IOException If an I/O error occurs while either sending the
722		* command or receiving the server reply.
723		***/
724		public int abor() throws IOException
725		{
726	0	return sendCommand(FTPCommand.ABOR);
727		}
728
729		/***
730		* A convenience method to send the FTP CWD command to the server,
731		* receive the reply, and return the reply code.
732		* <p>
733		* @param directory The new working directory.
734		* @return The reply code received from the server.
735		* @exception FTPConnectionClosedException
736		* If the FTP server prematurely closes the connection as a result
737		* of the client being idle or some other reason causing the server
738		* to send FTP reply code 421. This exception may be caught either
739		* as an IOException or independently as itself.
740		* @exception IOException If an I/O error occurs while either sending the
741		* command or receiving the server reply.
742		***/
743		public int cwd(String directory) throws IOException
744		{
745	0	return sendCommand(FTPCommand.CWD, directory);
746		}
747
748		/***
749		* A convenience method to send the FTP CDUP command to the server,
750		* receive the reply, and return the reply code.
751		* <p>
752		* @return The reply code received from the server.
753		* @exception FTPConnectionClosedException
754		* If the FTP server prematurely closes the connection as a result
755		* of the client being idle or some other reason causing the server
756		* to send FTP reply code 421. This exception may be caught either
757		* as an IOException or independently as itself.
758		* @exception IOException If an I/O error occurs while either sending the
759		* command or receiving the server reply.
760		***/
761		public int cdup() throws IOException
762		{
763	0	return sendCommand(FTPCommand.CDUP);
764		}
765
766		/***
767		* A convenience method to send the FTP QUIT command to the server,
768		* receive the reply, and return the reply code.
769		* <p>
770		* @return The reply code received from the server.
771		* @exception FTPConnectionClosedException
772		* If the FTP server prematurely closes the connection as a result
773		* of the client being idle or some other reason causing the server
774		* to send FTP reply code 421. This exception may be caught either
775		* as an IOException or independently as itself.
776		* @exception IOException If an I/O error occurs while either sending the
777		* command or receiving the server reply.
778		***/
779		public int quit() throws IOException
780		{
781	0	return sendCommand(FTPCommand.QUIT);
782		}
783
784		/***
785		* A convenience method to send the FTP REIN command to the server,
786		* receive the reply, and return the reply code.
787		* <p>
788		* @return The reply code received from the server.
789		* @exception FTPConnectionClosedException
790		* If the FTP server prematurely closes the connection as a result
791		* of the client being idle or some other reason causing the server
792		* to send FTP reply code 421. This exception may be caught either
793		* as an IOException or independently as itself.
794		* @exception IOException If an I/O error occurs while either sending the
795		* command or receiving the server reply.
796		***/
797		public int rein() throws IOException
798		{
799	0	return sendCommand(FTPCommand.REIN);
800		}
801
802		/***
803		* A convenience method to send the FTP SMNT command to the server,
804		* receive the reply, and return the reply code.
805		* <p>
806		* @param dir The directory name.
807		* @return The reply code received from the server.
808		* @exception FTPConnectionClosedException
809		* If the FTP server prematurely closes the connection as a result
810		* of the client being idle or some other reason causing the server
811		* to send FTP reply code 421. This exception may be caught either
812		* as an IOException or independently as itself.
813		* @exception IOException If an I/O error occurs while either sending the
814		* command or receiving the server reply.
815		***/
816		public int smnt(String dir) throws IOException
817		{
818	0	return sendCommand(FTPCommand.SMNT, dir);
819		}
820
821		/***
822		* A convenience method to send the FTP PORT command to the server,
823		* receive the reply, and return the reply code.
824		* <p>
825		* @param host The host owning the port.
826		* @param port The new port.
827		* @return The reply code received from the server.
828		* @exception FTPConnectionClosedException
829		* If the FTP server prematurely closes the connection as a result
830		* of the client being idle or some other reason causing the server
831		* to send FTP reply code 421. This exception may be caught either
832		* as an IOException or independently as itself.
833		* @exception IOException If an I/O error occurs while either sending the
834		* command or receiving the server reply.
835		***/
836		public int port(InetAddress host, class="keyword">int port) throws IOException
837		{
838		int num;
839	0	StringBuffer info = new StringBuffer(24);
840
841	0	info.append(host.getHostAddress().replace('.', ','));
842	0	num = port >>> 8;
843	0	info.append(',');
844	0	info.append(num);
845	0	info.append(',');
846	0	num = port & 0xff;
847	0	info.append(num);
848
849	0	return sendCommand(FTPCommand.PORT, info.toString());
850		}
851
852		/***
853		* A convenience method to send the FTP PASV command to the server,
854		* receive the reply, and return the reply code. Remember, it's up
855		* to you to interpret the reply string containing the host/port
856		* information.
857		* <p>
858		* @return The reply code received from the server.
859		* @exception FTPConnectionClosedException
860		* If the FTP server prematurely closes the connection as a result
861		* of the client being idle or some other reason causing the server
862		* to send FTP reply code 421. This exception may be caught either
863		* as an IOException or independently as itself.
864		* @exception IOException If an I/O error occurs while either sending the
865		* command or receiving the server reply.
866		***/
867		public int pasv() throws IOException
868		{
869	0	return sendCommand(FTPCommand.PASV);
870		}
871
872		/**
873		* A convenience method to send the FTP TYPE command for text files
874		* to the server, receive the reply, and return the reply code.
875		* @param fileType The type of the file (one of the <code>FILE_TYPE</code>
876		* constants).
877		* @param formatOrByteSize The format of the file (one of the
878		* <code>_FORMAT</code> constants. In the case of
879		* <code>LOCAL_FILE_TYPE</code>, the byte size.
880		* @return The reply code received from the server.
881		* @exception FTPConnectionClosedException
882		* If the FTP server prematurely closes the connection as a result
883		* of the client being idle or some other reason causing the server
884		* to send FTP reply code 421. This exception may be caught either
885		* as an IOException or independently as itself.
886		* @exception IOException If an I/O error occurs while either sending the
887		* command or receiving the server reply.
888		*/
889		public int type(class="keyword">int fileType, class="keyword">int formatOrByteSize) throws IOException
890		{
891	0	StringBuffer arg = new StringBuffer();
892
893	0	arg.append(__modes.charAt(fileType));
894	0	arg.append(' ');
895	0	if (fileType == LOCAL_FILE_TYPE)
896	0	arg.append(formatOrByteSize);
897		else
898	0	arg.append(__modes.charAt(formatOrByteSize));
899
900	0	return sendCommand(FTPCommand.TYPE, arg.toString());
901		}
902
903
904		/**
905		* A convenience method to send the FTP TYPE command to the server,
906		* receive the reply, and return the reply code.
907		* <p>
908		* @param fileType The type of the file (one of the <code>FILE_TYPE</code>
909		* constants).
910		* @return The reply code received from the server.
911		* @exception FTPConnectionClosedException
912		* If the FTP server prematurely closes the connection as a result
913		* of the client being idle or some other reason causing the server
914		* to send FTP reply code 421. This exception may be caught either
915		* as an IOException or independently as itself.
916		* @exception IOException If an I/O error occurs while either sending the
917		* command or receiving the server reply.
918		*/
919		public int type(class="keyword">int fileType) throws IOException
920		{
921	0	return sendCommand(FTPCommand.TYPE,
922		__modes.substring(fileType, fileType + 1));
923		}
924
925		/***
926		* A convenience method to send the FTP STRU command to the server,
927		* receive the reply, and return the reply code.
928		* <p>
929		* @param structure The structure of the file (one of the
930		* <code>_STRUCTURE</code> constants).
931		* @return The reply code received from the server.
932		* @exception FTPConnectionClosedException
933		* If the FTP server prematurely closes the connection as a result
934		* of the client being idle or some other reason causing the server
935		* to send FTP reply code 421. This exception may be caught either
936		* as an IOException or independently as itself.
937		* @exception IOException If an I/O error occurs while either sending the
938		* command or receiving the server reply.
939		***/
940		public int stru(class="keyword">int structure) throws IOException
941		{
942	0	return sendCommand(FTPCommand.STRU,
943		__modes.substring(structure, structure + 1));
944		}
945
946		/***
947		* A convenience method to send the FTP MODE command to the server,
948		* receive the reply, and return the reply code.
949		* <p>
950		* @param mode The transfer mode to use (one of the
951		* <code>TRANSFER_MODE</code> constants).
952		* @return The reply code received from the server.
953		* @exception FTPConnectionClosedException
954		* If the FTP server prematurely closes the connection as a result
955		* of the client being idle or some other reason causing the server
956		* to send FTP reply code 421. This exception may be caught either
957		* as an IOException or independently as itself.
958		* @exception IOException If an I/O error occurs while either sending the
959		* command or receiving the server reply.
960		***/
961		public int mode(class="keyword">int mode) throws IOException
962		{
963	0	return sendCommand(FTPCommand.MODE,
964		__modes.substring(mode, mode + 1));
965		}
966
967		/***
968		* A convenience method to send the FTP RETR command to the server,
969		* receive the reply, and return the reply code. Remember, it is up
970		* to you to manage the data connection. If you don't need this low
971		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
972		* , which will handle all low level details for you.
973		* <p>
974		* @param pathname The pathname of the file to retrieve.
975		* @return The reply code received from the server.
976		* @exception FTPConnectionClosedException
977		* If the FTP server prematurely closes the connection as a result
978		* of the client being idle or some other reason causing the server
979		* to send FTP reply code 421. This exception may be caught either
980		* as an IOException or independently as itself.
981		* @exception IOException If an I/O error occurs while either sending the
982		* command or receiving the server reply.
983		***/
984		public int retr(String pathname) throws IOException
985		{
986	0	return sendCommand(FTPCommand.RETR, pathname);
987		}
988
989		/***
990		* A convenience method to send the FTP STOR command to the server,
991		* receive the reply, and return the reply code. Remember, it is up
992		* to you to manage the data connection. If you don't need this low
993		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
994		* , which will handle all low level details for you.
995		* <p>
996		* @param pathname The pathname to use for the file when stored at
997		* the remote end of the transfer.
998		* @return The reply code received from the server.
999		* @exception FTPConnectionClosedException
1000		* If the FTP server prematurely closes the connection as a result
1001		* of the client being idle or some other reason causing the server
1002		* to send FTP reply code 421. This exception may be caught either
1003		* as an IOException or independently as itself.
1004		* @exception IOException If an I/O error occurs while either sending the
1005		* command or receiving the server reply.
1006		***/
1007		public int stor(String pathname) throws IOException
1008		{
1009	0	return sendCommand(FTPCommand.STOR, pathname);
1010		}
1011
1012		/***
1013		* A convenience method to send the FTP STOU command to the server,
1014		* receive the reply, and return the reply code. Remember, it is up
1015		* to you to manage the data connection. If you don't need this low
1016		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1017		* , which will handle all low level details for you.
1018		* <p>
1019		* @return The reply code received from the server.
1020		* @exception FTPConnectionClosedException
1021		* If the FTP server prematurely closes the connection as a result
1022		* of the client being idle or some other reason causing the server
1023		* to send FTP reply code 421. This exception may be caught either
1024		* as an IOException or independently as itself.
1025		* @exception IOException If an I/O error occurs while either sending the
1026		* command or receiving the server reply.
1027		***/
1028		public int stou() throws IOException
1029		{
1030	0	return sendCommand(FTPCommand.STOU);
1031		}
1032
1033		/***
1034		* A convenience method to send the FTP STOU command to the server,
1035		* receive the reply, and return the reply code. Remember, it is up
1036		* to you to manage the data connection. If you don't need this low
1037		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1038		* , which will handle all low level details for you.
1039		* @param pathname The base pathname to use for the file when stored at
1040		* the remote end of the transfer. Some FTP servers
1041		* require this.
1042		* @return The reply code received from the server.
1043		* @exception FTPConnectionClosedException
1044		* If the FTP server prematurely closes the connection as a result
1045		* of the client being idle or some other reason causing the server
1046		* to send FTP reply code 421. This exception may be caught either
1047		* as an IOException or independently as itself.
1048		* @exception IOException If an I/O error occurs while either sending the
1049		* command or receiving the server reply.
1050		*/
1051		public int stou(String pathname) throws IOException
1052		{
1053	0	return sendCommand(FTPCommand.STOU, pathname);
1054		}
1055
1056		/***
1057		* A convenience method to send the FTP APPE command to the server,
1058		* receive the reply, and return the reply code. Remember, it is up
1059		* to you to manage the data connection. If you don't need this low
1060		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1061		* , which will handle all low level details for you.
1062		* <p>
1063		* @param pathname The pathname to use for the file when stored at
1064		* the remote end of the transfer.
1065		* @return The reply code received from the server.
1066		* @exception FTPConnectionClosedException
1067		* If the FTP server prematurely closes the connection as a result
1068		* of the client being idle or some other reason causing the server
1069		* to send FTP reply code 421. This exception may be caught either
1070		* as an IOException or independently as itself.
1071		* @exception IOException If an I/O error occurs while either sending the
1072		* command or receiving the server reply.
1073		***/
1074		public int appe(String pathname) throws IOException
1075		{
1076	0	return sendCommand(FTPCommand.APPE, pathname);
1077		}
1078
1079		/***
1080		* A convenience method to send the FTP ALLO command to the server,
1081		* receive the reply, and return the reply code.
1082		* <p>
1083		* @param bytes The number of bytes to allocate.
1084		* @return The reply code received from the server.
1085		* @exception FTPConnectionClosedException
1086		* If the FTP server prematurely closes the connection as a result
1087		* of the client being idle or some other reason causing the server
1088		* to send FTP reply code 421. This exception may be caught either
1089		* as an IOException or independently as itself.
1090		* @exception IOException If an I/O error occurs while either sending the
1091		* command or receiving the server reply.
1092		***/
1093		public int allo(class="keyword">int bytes) throws IOException
1094		{
1095	0	return sendCommand(FTPCommand.ALLO, Integer.toString(bytes));
1096		}
1097
1098		/***
1099		* A convenience method to send the FTP ALLO command to the server,
1100		* receive the reply, and return the reply code.
1101		* <p>
1102		* @param bytes The number of bytes to allocate.
1103		* @param recordSize The size of a record.
1104		* @return The reply code received from the server.
1105		* @exception FTPConnectionClosedException
1106		* If the FTP server prematurely closes the connection as a result
1107		* of the client being idle or some other reason causing the server
1108		* to send FTP reply code 421. This exception may be caught either
1109		* as an IOException or independently as itself.
1110		* @exception IOException If an I/O error occurs while either sending the
1111		* command or receiving the server reply.
1112		***/
1113		public int allo(class="keyword">int bytes, class="keyword">int recordSize) throws IOException
1114		{
1115	0	return sendCommand(FTPCommand.ALLO, Integer.toString(bytes) + " R " +
1116		Integer.toString(recordSize));
1117		}
1118
1119		/***
1120		* A convenience method to send the FTP REST command to the server,
1121		* receive the reply, and return the reply code.
1122		* <p>
1123		* @param marker The marker at which to restart a transfer.
1124		* @return The reply code received from the server.
1125		* @exception FTPConnectionClosedException
1126		* If the FTP server prematurely closes the connection as a result
1127		* of the client being idle or some other reason causing the server
1128		* to send FTP reply code 421. This exception may be caught either
1129		* as an IOException or independently as itself.
1130		* @exception IOException If an I/O error occurs while either sending the
1131		* command or receiving the server reply.
1132		***/
1133		public int rest(String marker) throws IOException
1134		{
1135	0	return sendCommand(FTPCommand.REST, marker);
1136		}
1137
1138		/***
1139		* A convenience method to send the FTP RNFR command to the server,
1140		* receive the reply, and return the reply code.
1141		* <p>
1142		* @param pathname The pathname to rename from.
1143		* @return The reply code received from the server.
1144		* @exception FTPConnectionClosedException
1145		* If the FTP server prematurely closes the connection as a result
1146		* of the client being idle or some other reason causing the server
1147		* to send FTP reply code 421. This exception may be caught either
1148		* as an IOException or independently as itself.
1149		* @exception IOException If an I/O error occurs while either sending the
1150		* command or receiving the server reply.
1151		***/
1152		public int rnfr(String pathname) throws IOException
1153		{
1154	0	return sendCommand(FTPCommand.RNFR, pathname);
1155		}
1156
1157		/***
1158		* A convenience method to send the FTP RNTO command to the server,
1159		* receive the reply, and return the reply code.
1160		* <p>
1161		* @param pathname The pathname to rename to
1162		* @return The reply code received from the server.
1163		* @exception FTPConnectionClosedException
1164		* If the FTP server prematurely closes the connection as a result
1165		* of the client being idle or some other reason causing the server
1166		* to send FTP reply code 421. This exception may be caught either
1167		* as an IOException or independently as itself.
1168		* @exception IOException If an I/O error occurs while either sending the
1169		* command or receiving the server reply.
1170		***/
1171		public int rnto(String pathname) throws IOException
1172		{
1173	0	return sendCommand(FTPCommand.RNTO, pathname);
1174		}
1175
1176		/***
1177		* A convenience method to send the FTP DELE command to the server,
1178		* receive the reply, and return the reply code.
1179		* <p>
1180		* @param pathname The pathname to delete.
1181		* @return The reply code received from the server.
1182		* @exception FTPConnectionClosedException
1183		* If the FTP server prematurely closes the connection as a result
1184		* of the client being idle or some other reason causing the server
1185		* to send FTP reply code 421. This exception may be caught either
1186		* as an IOException or independently as itself.
1187		* @exception IOException If an I/O error occurs while either sending the
1188		* command or receiving the server reply.
1189		***/
1190		public int dele(String pathname) throws IOException
1191		{
1192	0	return sendCommand(FTPCommand.DELE, pathname);
1193		}
1194
1195		/***
1196		* A convenience method to send the FTP RMD command to the server,
1197		* receive the reply, and return the reply code.
1198		* <p>
1199		* @param pathname The pathname of the directory to remove.
1200		* @return The reply code received from the server.
1201		* @exception FTPConnectionClosedException
1202		* If the FTP server prematurely closes the connection as a result
1203		* of the client being idle or some other reason causing the server
1204		* to send FTP reply code 421. This exception may be caught either
1205		* as an IOException or independently as itself.
1206		* @exception IOException If an I/O error occurs while either sending the
1207		* command or receiving the server reply.
1208		***/
1209		public int rmd(String pathname) throws IOException
1210		{
1211	0	return sendCommand(FTPCommand.RMD, pathname);
1212		}
1213
1214		/***
1215		* A convenience method to send the FTP MKD command to the server,
1216		* receive the reply, and return the reply code.
1217		* <p>
1218		* @param pathname The pathname of the new directory to create.
1219		* @return The reply code received from the server.
1220		* @exception FTPConnectionClosedException
1221		* If the FTP server prematurely closes the connection as a result
1222		* of the client being idle or some other reason causing the server
1223		* to send FTP reply code 421. This exception may be caught either
1224		* as an IOException or independently as itself.
1225		* @exception IOException If an I/O error occurs while either sending the
1226		* command or receiving the server reply.
1227		***/
1228		public int mkd(String pathname) throws IOException
1229		{
1230	0	return sendCommand(FTPCommand.MKD, pathname);
1231		}
1232
1233		/***
1234		* A convenience method to send the FTP PWD command to the server,
1235		* receive the reply, and return the reply code.
1236		* <p>
1237		* @return The reply code received from the server.
1238		* @exception FTPConnectionClosedException
1239		* If the FTP server prematurely closes the connection as a result
1240		* of the client being idle or some other reason causing the server
1241		* to send FTP reply code 421. This exception may be caught either
1242		* as an IOException or independently as itself.
1243		* @exception IOException If an I/O error occurs while either sending the
1244		* command or receiving the server reply.
1245		***/
1246		public int pwd() throws IOException
1247		{
1248	0	return sendCommand(FTPCommand.PWD);
1249		}
1250
1251		/***
1252		* A convenience method to send the FTP LIST command to the server,
1253		* receive the reply, and return the reply code. Remember, it is up
1254		* to you to manage the data connection. If you don't need this low
1255		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1256		* , which will handle all low level details for you.
1257		* <p>
1258		* @return The reply code received from the server.
1259		* @exception FTPConnectionClosedException
1260		* If the FTP server prematurely closes the connection as a result
1261		* of the client being idle or some other reason causing the server
1262		* to send FTP reply code 421. This exception may be caught either
1263		* as an IOException or independently as itself.
1264		* @exception IOException If an I/O error occurs while either sending the
1265		* command or receiving the server reply.
1266		***/
1267		public int list() throws IOException
1268		{
1269	0	return sendCommand(FTPCommand.LIST);
1270		}
1271
1272		/***
1273		* A convenience method to send the FTP LIST command to the server,
1274		* receive the reply, and return the reply code. Remember, it is up
1275		* to you to manage the data connection. If you don't need this low
1276		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1277		* , which will handle all low level details for you.
1278		* <p>
1279		* @param pathname The pathname to list.
1280		* @return The reply code received from the server.
1281		* @exception FTPConnectionClosedException
1282		* If the FTP server prematurely closes the connection as a result
1283		* of the client being idle or some other reason causing the server
1284		* to send FTP reply code 421. This exception may be caught either
1285		* as an IOException or independently as itself.
1286		* @exception IOException If an I/O error occurs while either sending the
1287		* command or receiving the server reply.
1288		***/
1289		public int list(String pathname) throws IOException
1290		{
1291	0	return sendCommand(FTPCommand.LIST, pathname);
1292		}
1293
1294		/***
1295		* A convenience method to send the FTP NLST command to the server,
1296		* receive the reply, and return the reply code. Remember, it is up
1297		* to you to manage the data connection. If you don't need this low
1298		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1299		* , which will handle all low level details for you.
1300		* <p>
1301		* @return The reply code received from the server.
1302		* @exception FTPConnectionClosedException
1303		* If the FTP server prematurely closes the connection as a result
1304		* of the client being idle or some other reason causing the server
1305		* to send FTP reply code 421. This exception may be caught either
1306		* as an IOException or independently as itself.
1307		* @exception IOException If an I/O error occurs while either sending the
1308		* command or receiving the server reply.
1309		***/
1310		public int nlst() throws IOException
1311		{
1312	0	return sendCommand(FTPCommand.NLST);
1313		}
1314
1315		/***
1316		* A convenience method to send the FTP NLST command to the server,
1317		* receive the reply, and return the reply code. Remember, it is up
1318		* to you to manage the data connection. If you don't need this low
1319		* level of access, use {@link org.apache.commons.net.ftp.FTPClient}
1320		* , which will handle all low level details for you.
1321		* <p>
1322		* @param pathname The pathname to list.
1323		* @return The reply code received from the server.
1324		* @exception FTPConnectionClosedException
1325		* If the FTP server prematurely closes the connection as a result
1326		* of the client being idle or some other reason causing the server
1327		* to send FTP reply code 421. This exception may be caught either
1328		* as an IOException or independently as itself.
1329		* @exception IOException If an I/O error occurs while either sending the
1330		* command or receiving the server reply.
1331		***/
1332		public int nlst(String pathname) throws IOException
1333		{
1334	0	return sendCommand(FTPCommand.NLST, pathname);
1335		}
1336
1337		/***
1338		* A convenience method to send the FTP SITE command to the server,
1339		* receive the reply, and return the reply code.
1340		* <p>
1341		* @param parameters The site parameters to send.
1342		* @return The reply code received from the server.
1343		* @exception FTPConnectionClosedException
1344		* If the FTP server prematurely closes the connection as a result
1345		* of the client being idle or some other reason causing the server
1346		* to send FTP reply code 421. This exception may be caught either
1347		* as an IOException or independently as itself.
1348		* @exception IOException If an I/O error occurs while either sending the
1349		* command or receiving the server reply.
1350		***/
1351		public int site(String parameters) throws IOException
1352		{
1353	0	return sendCommand(FTPCommand.SITE, parameters);
1354		}
1355
1356		/***
1357		* A convenience method to send the FTP SYST command to the server,
1358		* receive the reply, and return the reply code.
1359		* <p>
1360		* @return The reply code received from the server.
1361		* @exception FTPConnectionClosedException
1362		* If the FTP server prematurely closes the connection as a result
1363		* of the client being idle or some other reason causing the server
1364		* to send FTP reply code 421. This exception may be caught either
1365		* as an IOException or independently as itself.
1366		* @exception IOException If an I/O error occurs while either sending the
1367		* command or receiving the server reply.
1368		***/
1369		public int syst() throws IOException
1370		{
1371	0	return sendCommand(FTPCommand.SYST);
1372		}
1373
1374		/***
1375		* A convenience method to send the FTP STAT command to the server,
1376		* receive the reply, and return the reply code.
1377		* <p>
1378		* @return The reply code received from the server.
1379		* @exception FTPConnectionClosedException
1380		* If the FTP server prematurely closes the connection as a result
1381		* of the client being idle or some other reason causing the server
1382		* to send FTP reply code 421. This exception may be caught either
1383		* as an IOException or independently as itself.
1384		* @exception IOException If an I/O error occurs while either sending the
1385		* command or receiving the server reply.
1386		***/
1387		public int stat() throws IOException
1388		{
1389	0	return sendCommand(FTPCommand.STAT);
1390		}
1391
1392		/***
1393		* A convenience method to send the FTP STAT command to the server,
1394		* receive the reply, and return the reply code.
1395		* <p>
1396		* @param pathname A pathname to list.
1397		* @return The reply code received from the server.
1398		* @exception FTPConnectionClosedException
1399		* If the FTP server prematurely closes the connection as a result
1400		* of the client being idle or some other reason causing the server
1401		* to send FTP reply code 421. This exception may be caught either
1402		* as an IOException or independently as itself.
1403		* @exception IOException If an I/O error occurs while either sending the
1404		* command or receiving the server reply.
1405		***/
1406		public int stat(String pathname) throws IOException
1407		{
1408	0	return sendCommand(FTPCommand.STAT, pathname);
1409		}
1410
1411		/***
1412		* A convenience method to send the FTP HELP command to the server,
1413		* receive the reply, and return the reply code.
1414		* <p>
1415		* @return The reply code received from the server.
1416		* @exception FTPConnectionClosedException
1417		* If the FTP server prematurely closes the connection as a result
1418		* of the client being idle or some other reason causing the server
1419		* to send FTP reply code 421. This exception may be caught either
1420		* as an IOException or independently as itself.
1421		* @exception IOException If an I/O error occurs while either sending the
1422		* command or receiving the server reply.
1423		***/
1424		public int help() throws IOException
1425		{
1426	0	return sendCommand(FTPCommand.HELP);
1427		}
1428
1429		/***
1430		* A convenience method to send the FTP HELP command to the server,
1431		* receive the reply, and return the reply code.
1432		* <p>
1433		* @param command The command name on which to request help.
1434		* @return The reply code received from the server.
1435		* @exception FTPConnectionClosedException
1436		* If the FTP server prematurely closes the connection as a result
1437		* of the client being idle or some other reason causing the server
1438		* to send FTP reply code 421. This exception may be caught either
1439		* as an IOException or independently as itself.
1440		* @exception IOException If an I/O error occurs while either sending the
1441		* command or receiving the server reply.
1442		***/
1443		public int help(String command) throws IOException
1444		{
1445	0	return sendCommand(FTPCommand.HELP, command);
1446		}
1447
1448		/***
1449		* A convenience method to send the FTP NOOP command to the server,
1450		* receive the reply, and return the reply code.
1451		* <p>
1452		* @return The reply code received from the server.
1453		* @exception FTPConnectionClosedException
1454		* If the FTP server prematurely closes the connection as a result
1455		* of the client being idle or some other reason causing the server
1456		* to send FTP reply code 421. This exception may be caught either
1457		* as an IOException or independently as itself.
1458		* @exception IOException If an I/O error occurs while either sending the
1459		* command or receiving the server reply.
1460		***/
1461		public int noop() throws IOException
1462		{
1463	0	return sendCommand(FTPCommand.NOOP);
1464		}
1465
1466		}
1467
1468		/* Emacs configuration
1469		* Local variables: **
1470		* mode: java **
1471		* c-basic-offset: 4 **
1472		* indent-tabs-mode: nil **
1473		* End: **
1474		*/