Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.ftp.FTPClient |
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.BufferedInputStream;
18 |  |
     import java.io.BufferedOutputStream;
19 |  |
     import java.io.BufferedReader;
20 |  |
     import java.io.IOException;
21 |  |
     import java.io.InputStream;
22 |  |
     import java.io.InputStreamReader;
23 |  |
     import java.io.OutputStream;
24 |  |
     import java.net.InetAddress;
25 |  |
     import java.net.ServerSocket;
26 |  |
     import java.net.Socket;
27 |  |
     import java.util.Vector;
28 |  |
29 |  |
     import org.apache.commons.net.MalformedServerReplyException;
30 |  |
     import org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory;
31 |  |
     import org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory;
32 |  |
     import org.apache.commons.net.ftp.parser.ParserInitializationException;
33 |  |
     import org.apache.commons.net.io.CopyStreamEvent;
34 |  |
     import org.apache.commons.net.io.CopyStreamException;
35 |  |
     import org.apache.commons.net.io.FromNetASCIIInputStream;
36 |  |
     import org.apache.commons.net.io.ToNetASCIIOutputStream;
37 |  |
     import org.apache.commons.net.io.Util;
38 |  |
39 |  |
     /***
40 |  |
      * FTPClient encapsulates all the functionality necessary to store and
41 |  |
      * retrieve files from an FTP server.  This class takes care of all
42 |  |
      * low level details of interacting with an FTP server and provides
43 |  |
      * a convenient higher level interface.  As with all classes derived
44 |  |
      * from {@link org.apache.commons.net.SocketClient},
45 |  |
      * you must first connect to the server with
46 |  |
      * {@link org.apache.commons.net.SocketClient#connect  connect }
47 |  |
      * before doing anything, and finally
48 |  |
      * {@link org.apache.commons.net.SocketClient#disconnect  disconnect }
49 |  |
      * after you're completely finished interacting with the server.
50 |  |
      * Then you need to check the FTP reply code to see if the connection
51 |  |
      * was successful.  For example:
52 |  |
      * <pre>
53 |  |
      *    boolean error = false;
54 |  |
      *    try {
55 |  |
      *      int reply;
56 |  |
      *      ftp.connect("ftp.foobar.com");
57 |  |
      *      System.out.println("Connected to " + server + ".");
58 |  |
      *      System.out.print(ftp.getReplyString());
59 |  |
      *
60 |  |
      *      // After connection attempt, you should check the reply code to verify
61 |  |
      *      // success.
62 |  |
      *      reply = ftp.getReplyCode();
63 |  |
      *
64 |  |
      *      if(!FTPReply.isPositiveCompletion(reply)) {
65 |  |
      *        ftp.disconnect();
66 |  |
      *        System.err.println("FTP server refused connection.");
67 |  |
      *        System.exit(1);
68 |  |
      *      }
69 |  |
      *      ... // transfer files
70 |  |
      *      ftp.logout();
71 |  |
      *    } catch(IOException e) {
72 |  |
      *      error = true;
73 |  |
      *      e.printStackTrace();
74 |  |
      *    } finally {
75 |  |
      *      if(ftp.isConnected()) {
76 |  |
      *        try {
77 |  |
      *          ftp.disconnect();
78 |  |
      *        } catch(IOException ioe) {
79 |  |
      *          // do nothing
80 |  |
      *        }
81 |  |
      *      }
82 |  |
      *      System.exit(error ? 1 : 0);
83 |  |
      *    }
84 |  |
      * </pre>
85 |  |
      * <p>
86 |  |
      * Immediately after connecting is the only real time you need to check the
87 |  |
      * reply code (because connect is of type void).  The convention for all the
88 |  |
      * FTP command methods in FTPClient is such that they either return a
89 |  |
      * boolean value or some other value.
90 |  |
      * The boolean methods return true on a successful completion reply from
91 |  |
      * the FTP server and false on a reply resulting in an error condition or
92 |  |
      * failure.  The methods returning a value other than boolean return a value
93 |  |
      * containing the higher level data produced by the FTP command, or null if a
94 |  |
      * reply resulted in an error condition or failure.  If you want to access
95 |  |
      * the exact FTP reply code causing a success or failure, you must call
96 |  |
      * {@link org.apache.commons.net.ftp.FTP#getReplyCode  getReplyCode } after
97 |  |
      * a success or failure.
98 |  |
      * <p>
99 |  |
      * The default settings for FTPClient are for it to use
100 |  |
      * <code> FTP.ASCII_FILE_TYPE </code>,
101 |  |
      * <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
102 |  |
      * <code> FTP.STREAM_TRANSFER_MODE </code>, and
103 |  |
      * <code> FTP.FILE_STRUCTURE </code>.  The only file types directly supported
104 |  |
      * are <code> FTP.ASCII_FILE_TYPE </code> and
105 |  |
      * <code> FTP.IMAGE_FILE_TYPE </code> (which is the same as
106 |  |
      * <code> FTP.BINARY_FILE_TYPE </code>).  Because there are at lest 4
107 |  |
      * different EBCDIC encodings, we have opted not to provide direct support
108 |  |
      * for EBCDIC.  To transfer EBCDIC and other unsupported file types you
109 |  |
      * must create your own filter InputStreams and OutputStreams and wrap
110 |  |
      * them around the streams returned or required by the FTPClient methods.
111 |  |
      * FTPClient uses the {@link ToNetASCIIOutputStream NetASCII}
112 |  |
      * filter streams to provide transparent handling of ASCII files.  We will
113 |  |
      * consider incorporating EBCDIC support if there is enough demand.
114 |  |
      * <p>
115 |  |
      * <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
116 |  |
      * <code> FTP.STREAM_TRANSFER_MODE </code>, and
117 |  |
      * <code> FTP.FILE_STRUCTURE </code> are the only supported formats,
118 |  |
      * transfer modes, and file structures.
119 |  |
      * <p>
120 |  |
      * Because the handling of sockets on different platforms can differ
121 |  |
      * significantly, the FTPClient automatically issues a new PORT command
122 |  |
      * prior to every transfer requiring that the server connect to the client's
123 |  |
      * data port.  This ensures identical problem-free behavior on Windows, Unix,
124 |  |
      * and Macintosh platforms.  Additionally, it relieves programmers from
125 |  |
      * having to issue the PORT command themselves and dealing with platform
126 |  |
      * dependent issues.
127 |  |
      * <p>
128 |  |
      * Additionally, for security purposes, all data connections to the
129 |  |
      * client are verified to ensure that they originated from the intended
130 |  |
      * party (host and port).  If a data connection is initiated by an unexpected
131 |  |
      * party, the command will close the socket and throw an IOException.  You
132 |  |
      * may disable this behavior with
133 |  |
      * {@link #setRemoteVerificationEnabled setRemoteVerificationEnabled()}.
134 |  |
      * <p>
135 |  |
      * You should keep in mind that the FTP server may choose to prematurely
136 |  |
      * close a connection if the client has been idle for longer than a
137 |  |
      * given time period (usually 900 seconds).  The FTPClient class will detect a
138 |  |
      * premature FTP server connection closing when it receives a
139 |  |
      * {@link org.apache.commons.net.ftp.FTPReply#SERVICE_NOT_AVAILABLE FTPReply.SERVICE_NOT_AVAILABLE }
140 |  |
      *  response to a command.
141 |  |
      * When that occurs, the FTP class method encountering that reply will throw
142 |  |
      * an {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
143 |  |
      * .
144 |  |
      * <code>FTPConnectionClosedException</code>
145 |  |
      * is a subclass of <code> IOException </code> and therefore need not be
146 |  |
      * caught separately, but if you are going to catch it separately, its
147 |  |
      * catch block must appear before the more general <code> IOException </code>
148 |  |
      * catch block.  When you encounter an
149 |  |
      * {@link org.apache.commons.net.ftp.FTPConnectionClosedException}
150 |  |
      * , you must disconnect the connection with
151 |  |
      * {@link #disconnect  disconnect() } to properly clean up the
152 |  |
      * system resources used by FTPClient.  Before disconnecting, you may check the
153 |  |
      * last reply code and text with
154 |  |
      * {@link org.apache.commons.net.ftp.FTP#getReplyCode  getReplyCode },
155 |  |
      * {@link org.apache.commons.net.ftp.FTP#getReplyString  getReplyString },
156 |  |
      * and
157 |  |
      * {@link org.apache.commons.net.ftp.FTP#getReplyStrings  getReplyStrings}.
158 |  |
      * You may avoid server disconnections while the client is idle by
159 |  |
      * periodicaly sending NOOP commands to the server.
160 |  |
      * <p>
161 |  |
      * Rather than list it separately for each method, we mention here that
162 |  |
      * every method communicating with the server and throwing an IOException
163 |  |
      * can also throw a
164 |  |
      * {@link org.apache.commons.net.MalformedServerReplyException}
165 |  |
      * , which is a subclass
166 |  |
      * of IOException.  A MalformedServerReplyException will be thrown when
167 |  |
      * the reply received from the server deviates enough from the protocol
168 |  |
      * specification that it cannot be interpreted in a useful manner despite
169 |  |
      * attempts to be as lenient as possible.
170 |  |
      * <p>
171 |  |
      * Listing API Examples
172 |  |
      * Both paged and unpaged examples of directory listings are available,
173 |  |
      * as follows:
174 |  |
      * <p>
175 |  |
      * Unpaged (whole list) access, using a parser accessible by auto-detect:
176 |  |
      * <pre>
177 |  |
      *    FTPClient f=FTPClient();
178 |  |
      *    f.connect(server);
179 |  |
      *    f.login(username, password);
180 |  |
      *    FTPFile[] files = listFiles(directory);
181 |  |
      * </pre>
182 |  |
      * <p>
183 |  |
      * Paged access, using a parser not accessible by auto-detect.  The class
184 |  |
      * defined in the first parameter of initateListParsing should be derived
185 |  |
      * from org.apache.commons.net.FTPFileEntryParser:
186 |  |
      * <pre>
187 |  |
      *    FTPClient f=FTPClient();
188 |  |
      *    f.connect(server);
189 |  |
      *    f.login(username, password);
190 |  |
      *    FTPListParseEngine engine =
191 |  |
      *       f.initiateListParsing("com.whatever.YourOwnParser", directory);
192 |  |
      *
193 |  |
      *    while (engine.hasNext()) {
194 |  |
      *       FTPFile[] files = engine.getNext(25);  // "page size" you want
195 |  |
      *       //do whatever you want with these files, display them, etc.
196 |  |
      *       //expensive FTPFile objects not created until needed.
197 |  |
      *    }
198 |  |
      * </pre>
199 |  |
      * <p>
200 |  |
      * Paged access, using a parser accessible by auto-detect:
201 |  |
      * <pre>
202 |  |
      *    FTPClient f=FTPClient();
203 |  |
      *    f.connect(server);
204 |  |
      *    f.login(username, password);
205 |  |
      *    FTPListParseEngine engine = f.initiateListParsing(directory);
206 |  |
      *
207 |  |
      *    while (engine.hasNext()) {
208 |  |
      *       FTPFile[] files = engine.getNext(25);  // "page size" you want
209 |  |
      *       //do whatever you want with these files, display them, etc.
210 |  |
      *       //expensive FTPFile objects not created until needed.
211 |  |
      *    }
212 |  |
      * </pre>
213 |  |
      * <p>
214 |  |
      * For examples of using FTPClient on servers whose directory listings
215 |  |
      * <ul>
216 |  |
      * <li>use languages other than English</li>
217 |  |
      * <li>use date formats other than the American English "standard" <code>MM d yyyy</code></li>
218 |  |
      * <li>are in different timezones and you need accurate timestamps for dependency checking
219 |  |
      *     as in Ant</li>
220 |  |
      * </ul>see {@link  FTPClientConfig  FTPClientConfig}.
221 |  |
      * <p>
222 |  |
      * NOTE: If you experience problems with unwanted firing of <pre>setSoTimeout()</pre>
223 |  |
      * during periods of client inactivity, this can be alleviated by calling <pre>setReaderThread(false)</pre>.
224 |  |
      * For more details, see <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=31122">this thread</a>.
225 |  |
      * </p>
226 |  |
      * <p>
227 |  |
      * @author Daniel F. Savarese
228 |  |
      * @see FTP
229 |  |
      * @see FTPConnectionClosedException
230 |  |
      * @see FTPFileEntryParser
231 |  |
      * @see FTPFileEntryParserFactory
232 |  |
      * @see DefaultFTPFileEntryParserFactory
233 |  |
      * @see FTPClientConfig
234 |  |
      * @see org.apache.commons.net.MalformedServerReplyException
235 |  |
      **/
236 |  |
     public class FTPClient extends FTP
237 |  |
     implements Configurable
238 |  |
     {
239 |  |
         /***
240 |  |
          * A constant indicating the FTP session is expecting all transfers
241 |  |
          * to occur between the client (local) and server and that the server
242 |  |
          * should connect to the client's data port to initiate a data transfer.
243 |  |
          * This is the default data connection mode when and FTPClient instance
244 |  |
          * is created.
245 |  |
          ***/
246 |  |
         public static final int ACTIVE_LOCAL_DATA_CONNECTION_MODE = 0;
247 |  |
         /***
248 |  |
          * A constant indicating the FTP session is expecting all transfers
249 |  |
          * to occur between two remote servers and that the server
250 |  |
          * the client is connected to should connect to the other server's
251 |  |
          * data port to initiate a data transfer.
252 |  |
          ***/
253 |  |
         public static final int ACTIVE_REMOTE_DATA_CONNECTION_MODE = 1;
254 |  |
         /***
255 |  |
          * A constant indicating the FTP session is expecting all transfers
256 |  |
          * to occur between the client (local) and server and that the server
257 |  |
          * is in passive mode, requiring the client to connect to the
258 |  |
          * server's data port to initiate a transfer.
259 |  |
          ***/
260 |  |
         public static final int PASSIVE_LOCAL_DATA_CONNECTION_MODE = 2;
261 |  |
         /***
262 |  |
          * A constant indicating the FTP session is expecting all transfers
263 |  |
          * to occur between two remote servers and that the server
264 |  |
          * the client is connected to is in passive mode, requiring the other
265 |  |
          * server to connect to the first server's data port to initiate a data
266 |  |
          * transfer.
267 |  |
          ***/
268 |  |
         public static final int PASSIVE_REMOTE_DATA_CONNECTION_MODE = 3;
269 |  |
270 |  |
         private int __dataConnectionMode, __dataTimeout;
271 |  |
         private int __passivePort;
272 |  |
         private String __passiveHost;
273 |  |
         private int __fileType, __fileFormat, __fileStructure, __fileTransferMode;
274 |  |
         private boolean __remoteVerificationEnabled;
275 |  |
         private long __restartOffset;
276 |  |
         private FTPFileEntryParserFactory __parserFactory;
277 |  |
         private int __bufferSize;
278 |  |
279 |  |
         // __systemName is a cached value that should not be referenced directly
280 |  |
         // except when assigned in getSystemName and __initDefaults.
281 |  |
         private String __systemName;
282 |  |
283 |  |
         // __entryParser is a cached value that should not be referenced directly
284 |  |
         // except when assigned in listFiles(String, String) and __initDefaults.
285 |  |
         private FTPFileEntryParser __entryParser;
286 |  |
287 |  |
         private FTPClientConfig __configuration;
288 |  |
289 |  |
         /***
290 |  |
          * Default FTPClient constructor.  Creates a new FTPClient instance
291 |  |
          * with the data connection mode set to
292 |  |
          * <code> ACTIVE_LOCAL_DATA_CONNECTION_MODE </code>, the file type
293 |  |
          * set to <code> FTP.ASCII_FILE_TYPE </code>, the
294 |  |
          * file format set to <code> FTP.NON_PRINT_TEXT_FORMAT </code>,
295 |  |
          * the file structure set to <code> FTP.FILE_STRUCTURE </code>, and
296 |  |
          * the transfer mode set to <code> FTP.STREAM_TRANSFER_MODE </code>.
297 |  |
          ***/
298 |  |
         public FTPClient()
299 | 0 |
         {
300 | 0 |
             __initDefaults();
301 | 0 |
             __dataTimeout = -1;
302 | 0 |
             __remoteVerificationEnabled = true;
303 | 0 |
             __parserFactory = new DefaultFTPFileEntryParserFactory();
304 | 0 |
             __configuration      = null;
305 | 0 |
         }
306 |  |
307 |  |
308 |  |
         private void __initDefaults()
309 |  |
         {
310 | 0 |
             __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
311 | 0 |
             __passiveHost        = null;
312 | 0 |
             __passivePort        = -1;
313 | 0 |
             __fileType           = FTP.ASCII_FILE_TYPE;
314 | 0 |
             __fileStructure      = FTP.FILE_STRUCTURE;
315 | 0 |
             __fileFormat         = FTP.NON_PRINT_TEXT_FORMAT;
316 | 0 |
             __fileTransferMode   = FTP.STREAM_TRANSFER_MODE;
317 | 0 |
             __restartOffset      = 0;
318 | 0 |
             __systemName         = null;
319 | 0 |
             __entryParser        = null;
320 | 0 |
             __bufferSize 		 = Util.DEFAULT_COPY_BUFFER_SIZE;
321 | 0 |
         }
322 |  |
323 |  |
         private String __parsePathname(String reply)
324 |  |
         {
325 |  |
             int begin, end;
326 |  |
327 | 0 |
             begin = reply.indexOf('"') + 1;
328 | 0 |
             end = reply.indexOf('"', begin);
329 |  |
330 | 0 |
             return reply.substring(begin, end);
331 |  |
         }
332 |  |
333 |  |
334 |  |
         private void __parsePassiveModeReply(String reply)
335 |  |
         throws MalformedServerReplyException
336 |  |
         {
337 |  |
             int i, index, lastIndex;
338 |  |
             String octet1, octet2;
339 |  |
             StringBuffer host;
340 |  |
341 | 0 |
             reply = reply.substring(reply.indexOf('(') + 1,
342 |  |
                                     reply.indexOf(')')).trim();
343 |  |
344 | 0 |
             host = new StringBuffer(24);
345 | 0 |
             lastIndex = 0;
346 | 0 |
             index = reply.indexOf(',');
347 | 0 |
             host.append(reply.substring(lastIndex, index));
348 |  |
349 | 0 |
             for (i = 0; i < 3; i++)
350 |  |
             {
351 | 0 |
                 host.append('.');
352 | 0 |
                 lastIndex = index + 1;
353 | 0 |
                 index = reply.indexOf(',', lastIndex);
354 | 0 |
                 host.append(reply.substring(lastIndex, index));
355 |  |
             }
356 |  |
357 | 0 |
             lastIndex = index + 1;
358 | 0 |
             index = reply.indexOf(',', lastIndex);
359 |  |
360 | 0 |
             octet1 = reply.substring(lastIndex, index);
361 | 0 |
             octet2 = reply.substring(index + 1);
362 |  |
363 |  |
             // index and lastIndex now used as temporaries
364 |  |
             try
365 |  |
             {
366 | 0 |
                 index = Integer.parseInt(octet1);
367 | 0 |
                 lastIndex = Integer.parseInt(octet2);
368 |  |
             }
369 | 0 |
             catch (NumberFormatException e)
370 |  |
             {
371 | 0 |
                 throw new MalformedServerReplyException(
372 |  |
                     "Could not parse passive host information.\nServer Reply: " + reply);
373 | 0 |
             }
374 |  |
375 | 0 |
             index <<= 8;
376 | 0 |
             index |= lastIndex;
377 |  |
378 | 0 |
             __passiveHost = host.toString();
379 | 0 |
             __passivePort = index;
380 | 0 |
         }
381 |  |
382 |  |
         private boolean __storeFile(int command, String remote, InputStream local)
383 |  |
         throws IOException
384 |  |
         {
385 |  |
             OutputStream output;
386 |  |
             Socket socket;
387 |  |
388 | 0 |
             if ((socket = _openDataConnection_(command, remote)) == null)
389 | 0 |
                 return false;
390 |  |
391 | 0 |
             output = new BufferedOutputStream(socket.getOutputStream(),
392 |  |
                                               getBufferSize()
393 |  |
                                               );
394 | 0 |
             if (__fileType == ASCII_FILE_TYPE)
395 | 0 |
                 output = new ToNetASCIIOutputStream(output);
396 |  |
             // Treat everything else as binary for now
397 |  |
             try
398 |  |
             {
399 | 0 |
                 Util.copyStream(local, output, getBufferSize(),
400 |  |
                                 CopyStreamEvent.UNKNOWN_STREAM_SIZE, null,
401 |  |
                                 false);
402 |  |
             }
403 | 0 |
             catch (IOException e)
404 |  |
             {
405 |  |
                 try
406 |  |
                 {
407 | 0 |
                     socket.close();
408 |  |
                 }
409 | 0 |
                 catch (IOException f)
410 | 0 |
                 {}
411 | 0 |
                 throw e;
412 | 0 |
             }
413 | 0 |
             output.close();
414 | 0 |
             socket.close();
415 | 0 |
             return completePendingCommand();
416 |  |
         }
417 |  |
418 |  |
         private OutputStream __storeFileStream(int command, String remote)
419 |  |
         throws IOException
420 |  |
         {
421 |  |
             OutputStream output;
422 |  |
             Socket socket;
423 |  |
424 | 0 |
             if ((socket = _openDataConnection_(command, remote)) == null)
425 | 0 |
                 return null;
426 |  |
427 | 0 |
             output = socket.getOutputStream();
428 | 0 |
             if (__fileType == ASCII_FILE_TYPE) {
429 |  |
               // We buffer ascii transfers because the buffering has to
430 |  |
               // be interposed between ToNetASCIIOutputSream and the underlying
431 |  |
               // socket output stream.  We don't buffer binary transfers
432 |  |
               // because we don't want to impose a buffering policy on the
433 |  |
               // programmer if possible.  Programmers can decide on their
434 |  |
               // own if they want to wrap the SocketOutputStream we return
435 |  |
               // for file types other than ASCII.
436 | 0 |
               output = new BufferedOutputStream(output,
437 |  |
                                                 getBufferSize());
438 | 0 |
               output = new ToNetASCIIOutputStream(output);
439 |  |
440 |  |
             }
441 | 0 |
             return new org.apache.commons.net.io.SocketOutputStream(socket, output);
442 |  |
         }
443 |  |
444 |  |
445 |  |
         /**
446 |  |
          * Establishes a data connection with the FTP server, returning
447 |  |
          * a Socket for the connection if successful.  If a restart
448 |  |
          * offset has been set with {@link #setRestartOffset(long)},
449 |  |
          * a REST command is issued to the server with the offset as
450 |  |
          * an argument before establishing the data connection.  Active
451 |  |
          * mode connections also cause a local PORT command to be issued.
452 |  |
          * <p>
453 |  |
          * @param command  The text representation of the FTP command to send.
454 |  |
          * @param arg The arguments to the FTP command.  If this parameter is
455 |  |
          *             set to null, then the command is sent with no argument.
456 |  |
          * @return A Socket corresponding to the established data connection.
457 |  |
          *         Null is returned if an FTP protocol error is reported at
458 |  |
          *         any point during the establishment and initialization of
459 |  |
          *         the connection.
460 |  |
          * @exception IOException  If an I/O error occurs while either sending a
461 |  |
          *      command to the server or receiving a reply from the server.
462 |  |
          */
463 |  |
         protected Socket _openDataConnection_(int command, String arg)
464 |  |
           throws IOException
465 |  |
         {
466 |  |
             Socket socket;
467 |  |
468 | 0 |
             if (__dataConnectionMode != ACTIVE_LOCAL_DATA_CONNECTION_MODE &&
469 |  |
                     __dataConnectionMode != PASSIVE_LOCAL_DATA_CONNECTION_MODE)
470 | 0 |
                 return null;
471 |  |
472 | 0 |
             if (__dataConnectionMode == ACTIVE_LOCAL_DATA_CONNECTION_MODE)
473 |  |
             {
474 |  |
                 ServerSocket server;
475 | 0 |
                 server = _socketFactory_.createServerSocket(0, 1, getLocalAddress());
476 |  |
477 | 0 |
                 if (!FTPReply.isPositiveCompletion(port(getLocalAddress(),
478 |  |
                                                         server.getLocalPort())))
479 |  |
                 {
480 | 0 |
                     server.close();
481 | 0 |
                     return null;
482 |  |
                 }
483 |  |
484 | 0 |
                 if ((__restartOffset > 0) && !restart(__restartOffset))
485 |  |
                 {
486 | 0 |
                     server.close();
487 | 0 |
                     return null;
488 |  |
                 }
489 |  |
490 | 0 |
                 if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
491 |  |
                 {
492 | 0 |
                     server.close();
493 | 0 |
                     return null;
494 |  |
                 }
495 |  |
496 |  |
                 // For now, let's just use the data timeout value for waiting for
497 |  |
                 // the data connection.  It may be desirable to let this be a
498 |  |
                 // separately configurable value.  In any case, we really want
499 |  |
                 // to allow preventing the accept from blocking indefinitely.
500 | 0 |
                 if (__dataTimeout >= 0)
501 | 0 |
                     server.setSoTimeout(__dataTimeout);
502 | 0 |
                 socket = server.accept();
503 | 0 |
                 server.close();
504 |  |
             }
505 |  |
             else
506 |  |
             { // We must be in PASSIVE_LOCAL_DATA_CONNECTION_MODE
507 |  |
508 | 0 |
                 if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
509 | 0 |
                     return null;
510 |  |
511 | 0 |
                 __parsePassiveModeReply((String)_replyLines.elementAt(0));
512 |  |
513 | 0 |
                 socket = _socketFactory_.createSocket(__passiveHost, __passivePort);
514 | 0 |
                 if ((__restartOffset > 0) && !restart(__restartOffset))
515 |  |
                 {
516 | 0 |
                     socket.close();
517 | 0 |
                     return null;
518 |  |
                 }
519 |  |
520 | 0 |
                 if (!FTPReply.isPositivePreliminary(sendCommand(command, arg)))
521 |  |
                 {
522 | 0 |
                     socket.close();
523 | 0 |
                     return null;
524 |  |
                 }
525 |  |
             }
526 |  |
527 | 0 |
             if (__remoteVerclass="keyword">ificationEnabled && !verclass="keyword">ifyRemote(socket))
528 |  |
             {
529 |  |
                 InetAddress host1, host2;
530 |  |
531 | 0 |
                 host1 = socket.getInetAddress();
532 | 0 |
                 host2 = getRemoteAddress();
533 |  |
534 | 0 |
                 socket.close();
535 |  |
536 | 0 |
                 throw new IOException(
537 |  |
                     "Host attempting data connection " + host1.getHostAddress() +
538 |  |
                     " is not same as server " + host2.getHostAddress());
539 |  |
             }
540 |  |
541 | 0 |
             if (__dataTimeout >= 0)
542 | 0 |
                 socket.setSoTimeout(__dataTimeout);
543 |  |
544 | 0 |
             return socket;
545 |  |
         }
546 |  |
547 |  |
548 |  |
         protected void _connectAction_() throws IOException
549 |  |
         {
550 | 0 |
             super._connectAction_();
551 | 0 |
             __initDefaults();
552 | 0 |
         }
553 |  |
554 |  |
555 |  |
         /***
556 |  |
          * Sets the timeout in milliseconds to use when reading from the
557 |  |
          * data connection.  This timeout will be set immediately after
558 |  |
          * opening the data connection.
559 |  |
          * <p>
560 |  |
          * @param  timeout The default timeout in milliseconds that is used when
561 |  |
          *        opening a data connection socket.
562 |  |
          ***/
563 |  |
         public void setDataTimeout(int timeout)
564 |  |
         {
565 | 0 |
             __dataTimeout = timeout;
566 | 0 |
         }
567 |  |
568 |  |
         /**
569 |  |
          * set the factory used for parser creation to the supplied factory object.
570 |  |
          *
571 |  |
          * @param parserFactory
572 |  |
          *               factory object used to create FTPFileEntryParsers
573 |  |
          *
574 |  |
          * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
575 |  |
          * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
576 |  |
          */
577 |  |
         public void setParserFactory(FTPFileEntryParserFactory parserFactory) {
578 | 0 |
             __parserFactory = parserFactory;
579 | 0 |
         }
580 |  |
581 |  |
582 |  |
         /***
583 |  |
          * Closes the connection to the FTP server and restores
584 |  |
          * connection parameters to the default values.
585 |  |
          * <p>
586 |  |
          * @exception IOException If an error occurs while disconnecting.
587 |  |
          ***/
588 |  |
         public void disconnect() throws IOException
589 |  |
         {
590 | 0 |
             super.disconnect();
591 | 0 |
             __initDefaults();
592 | 0 |
         }
593 |  |
594 |  |
595 |  |
         /***
596 |  |
          * Enable or disable verification that the remote host taking part
597 |  |
          * of a data connection is the same as the host to which the control
598 |  |
          * connection is attached.  The default is for verification to be
599 |  |
          * enabled.  You may set this value at any time, whether the
600 |  |
          * FTPClient is currently connected or not.
601 |  |
          * <p>
602 |  |
          * @param enable True to enable verification, false to disable verification.
603 |  |
          ***/
604 |  |
         public void setRemoteVerificationEnabled(boolean enable)
605 |  |
         {
606 | 0 |
             __remoteVerificationEnabled = enable;
607 | 0 |
         }
608 |  |
609 |  |
         /***
610 |  |
          * Return whether or not verification of the remote host participating
611 |  |
          * in data connections is enabled.  The default behavior is for
612 |  |
          * verification to be enabled.
613 |  |
          * <p>
614 |  |
          * @return True if verification is enabled, false if not.
615 |  |
          ***/
616 |  |
         public boolean isRemoteVerificationEnabled()
617 |  |
         {
618 | 0 |
             return __remoteVerificationEnabled;
619 |  |
         }
620 |  |
621 |  |
         /***
622 |  |
          * Login to the FTP server using the provided username and password.
623 |  |
          * <p>
624 |  |
          * @param username The username to login under.
625 |  |
          * @param password The password to use.
626 |  |
          * @return True if successfully completed, false if not.
627 |  |
          * @exception FTPConnectionClosedException
628 |  |
          *      If the FTP server prematurely closes the connection as a result
629 |  |
          *      of the client being idle or some other reason causing the server
630 |  |
          *      to send FTP reply code 421.  This exception may be caught either
631 |  |
          *      as an IOException or independently as itself.
632 |  |
          * @exception IOException  If an I/O error occurs while either sending a
633 |  |
          *      command to the server or receiving a reply from the server.
634 |  |
          ***/
635 |  |
         public boolean login(String username, String password) throws IOException
636 |  |
         {
637 | 0 |
             user(username);
638 |  |
639 | 0 |
             if (FTPReply.isPositiveCompletion(_replyCode))
640 | 0 |
                 return true;
641 |  |
642 |  |
             // If we get here, we either have an error code, or an intermmediate
643 |  |
             // reply requesting password.
644 | 0 |
             if (!FTPReply.isPositiveIntermediate(_replyCode))
645 | 0 |
                 return false;
646 |  |
647 | 0 |
             return FTPReply.isPositiveCompletion(pass(password));
648 |  |
         }
649 |  |
650 |  |
651 |  |
         /***
652 |  |
          * Login to the FTP server using the provided username, password,
653 |  |
          * and account.  If no account is required by the server, only
654 |  |
          * the username and password, the account information is not used.
655 |  |
          * <p>
656 |  |
          * @param username The username to login under.
657 |  |
          * @param password The password to use.
658 |  |
          * @param account  The account to use.
659 |  |
          * @return True if successfully completed, false if not.
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 a
666 |  |
          *      command to the server or receiving a reply from the server.
667 |  |
          ***/
668 |  |
         public boolean login(String username, String password, String account)
669 |  |
         throws IOException
670 |  |
         {
671 | 0 |
             user(username);
672 |  |
673 | 0 |
             if (FTPReply.isPositiveCompletion(_replyCode))
674 | 0 |
                 return true;
675 |  |
676 |  |
             // If we get here, we either have an error code, or an intermmediate
677 |  |
             // reply requesting password.
678 | 0 |
             if (!FTPReply.isPositiveIntermediate(_replyCode))
679 | 0 |
                 return false;
680 |  |
681 | 0 |
             pass(password);
682 |  |
683 | 0 |
             if (FTPReply.isPositiveCompletion(_replyCode))
684 | 0 |
                 return true;
685 |  |
686 | 0 |
             if (!FTPReply.isPositiveIntermediate(_replyCode))
687 | 0 |
                 return false;
688 |  |
689 | 0 |
             return FTPReply.isPositiveCompletion(acct(account));
690 |  |
         }
691 |  |
692 |  |
         /***
693 |  |
          * Logout of the FTP server by sending the QUIT command.
694 |  |
          * <p>
695 |  |
          * @return True if successfully completed, false if not.
696 |  |
          * @exception FTPConnectionClosedException
697 |  |
          *      If the FTP server prematurely closes the connection as a result
698 |  |
          *      of the client being idle or some other reason causing the server
699 |  |
          *      to send FTP reply code 421.  This exception may be caught either
700 |  |
          *      as an IOException or independently as itself.
701 |  |
          * @exception IOException  If an I/O error occurs while either sending a
702 |  |
          *      command to the server or receiving a reply from the server.
703 |  |
          ***/
704 |  |
         public boolean logout() throws IOException
705 |  |
         {
706 | 0 |
             return FTPReply.isPositiveCompletion(quit());
707 |  |
         }
708 |  |
709 |  |
710 |  |
         /***
711 |  |
          * Change the current working directory of the FTP session.
712 |  |
          * <p>
713 |  |
          * @param pathname  The new current working directory.
714 |  |
          * @return True if successfully completed, false if not.
715 |  |
          * @exception FTPConnectionClosedException
716 |  |
          *      If the FTP server prematurely closes the connection as a result
717 |  |
          *      of the client being idle or some other reason causing the server
718 |  |
          *      to send FTP reply code 421.  This exception may be caught either
719 |  |
          *      as an IOException or independently as itself.
720 |  |
          * @exception IOException  If an I/O error occurs while either sending a
721 |  |
          *      command to the server or receiving a reply from the server.
722 |  |
          ***/
723 |  |
         public boolean changeWorkingDirectory(String pathname) throws IOException
724 |  |
         {
725 | 0 |
             return FTPReply.isPositiveCompletion(cwd(pathname));
726 |  |
         }
727 |  |
728 |  |
729 |  |
         /***
730 |  |
          * Change to the parent directory of the current working directory.
731 |  |
          * <p>
732 |  |
          * @return True if successfully completed, false if not.
733 |  |
          * @exception FTPConnectionClosedException
734 |  |
          *      If the FTP server prematurely closes the connection as a result
735 |  |
          *      of the client being idle or some other reason causing the server
736 |  |
          *      to send FTP reply code 421.  This exception may be caught either
737 |  |
          *      as an IOException or independently as itself.
738 |  |
          * @exception IOException  If an I/O error occurs while either sending a
739 |  |
          *      command to the server or receiving a reply from the server.
740 |  |
          ***/
741 |  |
         public boolean changeToParentDirectory() throws IOException
742 |  |
         {
743 | 0 |
             return FTPReply.isPositiveCompletion(cdup());
744 |  |
         }
745 |  |
746 |  |
747 |  |
         /***
748 |  |
          * Issue the FTP SMNT command.
749 |  |
          * <p>
750 |  |
          * @param pathname The pathname to mount.
751 |  |
          * @return True if successfully completed, false if not.
752 |  |
          * @exception FTPConnectionClosedException
753 |  |
          *      If the FTP server prematurely closes the connection as a result
754 |  |
          *      of the client being idle or some other reason causing the server
755 |  |
          *      to send FTP reply code 421.  This exception may be caught either
756 |  |
          *      as an IOException or independently as itself.
757 |  |
          * @exception IOException  If an I/O error occurs while either sending a
758 |  |
          *      command to the server or receiving a reply from the server.
759 |  |
          ***/
760 |  |
         public boolean structureMount(String pathname) throws IOException
761 |  |
         {
762 | 0 |
             return FTPReply.isPositiveCompletion(smnt(pathname));
763 |  |
         }
764 |  |
765 |  |
         /***
766 |  |
          * Reinitialize the FTP session.  Not all FTP servers support this
767 |  |
          * command, which issues the FTP REIN command.
768 |  |
          * <p>
769 |  |
          * @return True if successfully completed, false if not.
770 |  |
          * @exception FTPConnectionClosedException
771 |  |
          *      If the FTP server prematurely closes the connection as a result
772 |  |
          *      of the client being idle or some other reason causing the server
773 |  |
          *      to send FTP reply code 421.  This exception may be caught either
774 |  |
          *      as an IOException or independently as itself.
775 |  |
          * @exception IOException  If an I/O error occurs while either sending a
776 |  |
          *      command to the server or receiving a reply from the server.
777 |  |
          ***/
778 |  |
         boolean reinitialize() throws IOException
779 |  |
         {
780 | 0 |
             rein();
781 |  |
782 | 0 |
             if (FTPReply.isPositiveCompletion(_replyCode) ||
783 |  |
                     (FTPReply.isPositivePreliminary(_replyCode) &&
784 |  |
                      FTPReply.isPositiveCompletion(getReply())))
785 |  |
             {
786 |  |
787 | 0 |
                 __initDefaults();
788 |  |
789 | 0 |
                 return true;
790 |  |
             }
791 |  |
792 | 0 |
             return false;
793 |  |
         }
794 |  |
795 |  |
796 |  |
         /***
797 |  |
          * Set the current data connection mode to
798 |  |
          * <code>ACTIVE_LOCAL_DATA_CONNECTION_MODE</code>.  No communication
799 |  |
          * with the FTP server is conducted, but this causes all future data
800 |  |
          * transfers to require the FTP server to connect to the client's
801 |  |
          * data port.  Additionally, to accommodate differences between socket
802 |  |
          * implementations on different platforms, this method causes the
803 |  |
          * client to issue a PORT command before every data transfer.
804 |  |
          ***/
805 |  |
         public void enterLocalActiveMode()
806 |  |
         {
807 | 0 |
             __dataConnectionMode = ACTIVE_LOCAL_DATA_CONNECTION_MODE;
808 | 0 |
             __passiveHost = null;
809 | 0 |
             __passivePort = -1;
810 | 0 |
         }
811 |  |
812 |  |
813 |  |
         /***
814 |  |
          * Set the current data connection mode to
815 |  |
          * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code>.  Use this
816 |  |
          * method only for data transfers between the client and server.
817 |  |
          * This method causes a PASV command to be issued to the server
818 |  |
          * before the opening of every data connection, telling the server to
819 |  |
          * open a data port to which the client will connect to conduct
820 |  |
          * data transfers.  The FTPClient will stay in
821 |  |
          * <code> PASSIVE_LOCAL_DATA_CONNECTION_MODE </code> until the
822 |  |
          * mode is changed by calling some other method such as
823 |  |
          * {@link #enterLocalActiveMode  enterLocalActiveMode() }
824 |  |
          ***/
825 |  |
         public void enterLocalPassiveMode()
826 |  |
         {
827 | 0 |
             __dataConnectionMode = PASSIVE_LOCAL_DATA_CONNECTION_MODE;
828 |  |
             // These will be set when just before a data connection is opened
829 |  |
             // in _openDataConnection_()
830 | 0 |
             __passiveHost = null;
831 | 0 |
             __passivePort = -1;
832 | 0 |
         }
833 |  |
834 |  |
835 |  |
         /***
836 |  |
          * Set the current data connection mode to
837 |  |
          * <code> ACTIVE_REMOTE_DATA_CONNECTION </code>.  Use this method only
838 |  |
          * for server to server data transfers.  This method issues a PORT
839 |  |
          * command to the server, indicating the other server and port to which
840 |  |
          * it should connect for data transfers.  You must call this method
841 |  |
          * before EVERY server to server transfer attempt.  The FTPClient will
842 |  |
          * NOT automatically continue to issue PORT commands.  You also
843 |  |
          * must remember to call
844 |  |
          * {@link #enterLocalActiveMode  enterLocalActiveMode() } if you
845 |  |
          * wish to return to the normal data connection mode.
846 |  |
          * <p>
847 |  |
          * @param host The passive mode server accepting connections for data
848 |  |
          *             transfers.
849 |  |
          * @param port The passive mode server's data port.
850 |  |
          * @return True if successfully completed, false if not.
851 |  |
          * @exception FTPConnectionClosedException
852 |  |
          *      If the FTP server prematurely closes the connection as a result
853 |  |
          *      of the client being idle or some other reason causing the server
854 |  |
          *      to send FTP reply code 421.  This exception may be caught either
855 |  |
          *      as an IOException or independently as itself.
856 |  |
          * @exception IOException  If an I/O error occurs while either sending a
857 |  |
          *      command to the server or receiving a reply from the server.
858 |  |
          ***/
859 |  |
         public boolean enterRemoteActiveMode(InetAddress host, int port)
860 |  |
         throws IOException
861 |  |
         {
862 | 0 |
             if (FTPReply.isPositiveCompletion(port(host, port)))
863 |  |
             {
864 | 0 |
                 __dataConnectionMode = ACTIVE_REMOTE_DATA_CONNECTION_MODE;
865 | 0 |
                 __passiveHost = null;
866 | 0 |
                 __passivePort = -1;
867 | 0 |
                 return true;
868 |  |
             }
869 | 0 |
             return false;
870 |  |
         }
871 |  |
872 |  |
         /***
873 |  |
          * Set the current data connection mode to
874 |  |
          * <code> PASSIVE_REMOTE_DATA_CONNECTION_MODE </code>.  Use this
875 |  |
          * method only for server to server data transfers.
876 |  |
          * This method issues a PASV command to the server, telling it to
877 |  |
          * open a data port to which the active server will connect to conduct
878 |  |
          * data transfers.  You must call this method
879 |  |
          * before EVERY server to server transfer attempt.  The FTPClient will
880 |  |
          * NOT automatically continue to issue PASV commands.  You also
881 |  |
          * must remember to call
882 |  |
          * {@link #enterLocalActiveMode  enterLocalActiveMode() } if you
883 |  |
          * wish to return to the normal data connection mode.
884 |  |
          * <p>
885 |  |
          * @return True if successfully completed, false if not.
886 |  |
          * @exception FTPConnectionClosedException
887 |  |
          *      If the FTP server prematurely closes the connection as a result
888 |  |
          *      of the client being idle or some other reason causing the server
889 |  |
          *      to send FTP reply code 421.  This exception may be caught either
890 |  |
          *      as an IOException or independently as itself.
891 |  |
          * @exception IOException  If an I/O error occurs while either sending a
892 |  |
          *      command to the server or receiving a reply from the server.
893 |  |
          ***/
894 |  |
         public boolean enterRemotePassiveMode() throws IOException
895 |  |
         {
896 | 0 |
             if (pasv() != FTPReply.ENTERING_PASSIVE_MODE)
897 | 0 |
                 return false;
898 |  |
899 | 0 |
             __dataConnectionMode = PASSIVE_REMOTE_DATA_CONNECTION_MODE;
900 | 0 |
             __parsePassiveModeReply((String)_replyLines.elementAt(0));
901 |  |
902 | 0 |
             return true;
903 |  |
         }
904 |  |
905 |  |
         /***
906 |  |
          * Returns the hostname or IP address (in the form of a string) returned
907 |  |
          * by the server when entering passive mode.  If not in passive mode,
908 |  |
          * returns null.  This method only returns a valid value AFTER a
909 |  |
          * data connection has been opened after a call to
910 |  |
          * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
911 |  |
          * This is because FTPClient sends a PASV command to the server only
912 |  |
          * just before opening a data connection, and not when you call
913 |  |
          * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
914 |  |
          * <p>
915 |  |
          * @return The passive host name if in passive mode, otherwise null.
916 |  |
          ***/
917 |  |
         public String getPassiveHost()
918 |  |
         {
919 | 0 |
             return __passiveHost;
920 |  |
         }
921 |  |
922 |  |
         /***
923 |  |
          * If in passive mode, returns the data port of the passive host.
924 |  |
          * This method only returns a valid value AFTER a
925 |  |
          * data connection has been opened after a call to
926 |  |
          * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
927 |  |
          * This is because FTPClient sends a PASV command to the server only
928 |  |
          * just before opening a data connection, and not when you call
929 |  |
          * {@link #enterLocalPassiveMode enterLocalPassiveMode()}.
930 |  |
          * <p>
931 |  |
          * @return The data port of the passive server.  If not in passive
932 |  |
          *         mode, undefined.
933 |  |
          ***/
934 |  |
         public int getPassivePort()
935 |  |
         {
936 | 0 |
             return __passivePort;
937 |  |
         }
938 |  |
939 |  |
940 |  |
         /***
941 |  |
          * Returns the current data connection mode (one of the
942 |  |
          * <code> _DATA_CONNECTION_MODE </code> constants.
943 |  |
          * <p>
944 |  |
          * @return The current data connection mode (one of the
945 |  |
          * <code> _DATA_CONNECTION_MODE </code> constants.
946 |  |
          ***/
947 |  |
         public int getDataConnectionMode()
948 |  |
         {
949 | 0 |
             return __dataConnectionMode;
950 |  |
         }
951 |  |
952 |  |
953 |  |
         /***
954 |  |
          * Sets the file type to be transferred.  This should be one of
955 |  |
          * <code> FTP.ASCII_FILE_TYPE </code>, <code> FTP.IMAGE_FILE_TYPE </code>,
956 |  |
          * etc.  The file type only needs to be set when you want to change the
957 |  |
          * type.  After changing it, the new type stays in effect until you change
958 |  |
          * it again.  The default file type is <code> FTP.ASCII_FILE_TYPE </code>
959 |  |
          * if this method is never called.
960 |  |
          * <p>
961 |  |
          * @param fileType The <code> _FILE_TYPE </code> constant indcating the
962 |  |
          *                 type of file.
963 |  |
          * @return True if successfully completed, false if not.
964 |  |
          * @exception FTPConnectionClosedException
965 |  |
          *      If the FTP server prematurely closes the connection as a result
966 |  |
          *      of the client being idle or some other reason causing the server
967 |  |
          *      to send FTP reply code 421.  This exception may be caught either
968 |  |
          *      as an IOException or independently as itself.
969 |  |
          * @exception IOException  If an I/O error occurs while either sending a
970 |  |
          *      command to the server or receiving a reply from the server.
971 |  |
          ***/
972 |  |
         public boolean setFileType(int fileType) throws IOException
973 |  |
         {
974 | 0 |
             if (FTPReply.isPositiveCompletion(type(fileType)))
975 |  |
             {
976 | 0 |
                 __fileType = fileType;
977 | 0 |
                 __fileFormat = FTP.NON_PRINT_TEXT_FORMAT;
978 | 0 |
                 return true;
979 |  |
             }
980 | 0 |
             return false;
981 |  |
         }
982 |  |
983 |  |
984 |  |
         /***
985 |  |
          * Sets the file type to be transferred and the format.  The type should be
986 |  |
          * one of  <code> FTP.ASCII_FILE_TYPE </code>,
987 |  |
          * <code> FTP.IMAGE_FILE_TYPE </code>, etc.  The file type only needs to
988 |  |
          * be set when you want to change the type.  After changing it, the new
989 |  |
          * type stays in effect until you change it again.  The default file type
990 |  |
          * is <code> FTP.ASCII_FILE_TYPE </code> if this method is never called.
991 |  |
          * The format should be one of the FTP class <code> TEXT_FORMAT </code>
992 |  |
          * constants, or if the type is <code> FTP.LOCAL_FILE_TYPE </code>, the
993 |  |
          * format should be the byte size for that type.  The default format
994 |  |
          * is <code> FTP.NON_PRINT_TEXT_FORMAT </code> if this method is never
995 |  |
          * called.
996 |  |
          * <p>
997 |  |
          * @param fileType The <code> _FILE_TYPE </code> constant indcating the
998 |  |
          *                 type of file.
999 |  |
          * @param formatOrByteSize  The format of the file (one of the
1000 |  |
          *              <code>_FORMAT</code> constants.  In the case of
1001 |  |
          *              <code>LOCAL_FILE_TYPE</code>, the byte size.
1002 |  |
          * <p>
1003 |  |
          * @return True if successfully completed, false if not.
1004 |  |
          * @exception FTPConnectionClosedException
1005 |  |
          *      If the FTP server prematurely closes the connection as a result
1006 |  |
          *      of the client being idle or some other reason causing the server
1007 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1008 |  |
          *      as an IOException or independently as itself.
1009 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1010 |  |
          *      command to the server or receiving a reply from the server.
1011 |  |
          ***/
1012 |  |
         public boolean setFileType(int fileType, class="keyword">int formatOrByteSize)
1013 |  |
         throws IOException
1014 |  |
         {
1015 | 0 |
             if (FTPReply.isPositiveCompletion(type(fileType, formatOrByteSize)))
1016 |  |
             {
1017 | 0 |
                 __fileType = fileType;
1018 | 0 |
                 __fileFormat = formatOrByteSize;
1019 | 0 |
                 return true;
1020 |  |
             }
1021 | 0 |
             return false;
1022 |  |
         }
1023 |  |
1024 |  |
1025 |  |
         /***
1026 |  |
          * Sets the file structure.  The default structure is
1027 |  |
          * <code> FTP.FILE_STRUCTURE </code> if this method is never called.
1028 |  |
          * <p>
1029 |  |
          * @param structure  The structure of the file (one of the FTP class
1030 |  |
          *         <code>_STRUCTURE</code> constants).
1031 |  |
          * @return True if successfully completed, false if not.
1032 |  |
          * @exception FTPConnectionClosedException
1033 |  |
          *      If the FTP server prematurely closes the connection as a result
1034 |  |
          *      of the client being idle or some other reason causing the server
1035 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1036 |  |
          *      as an IOException or independently as itself.
1037 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1038 |  |
          *      command to the server or receiving a reply from the server.
1039 |  |
          ***/
1040 |  |
         public boolean setFileStructure(int structure) throws IOException
1041 |  |
         {
1042 | 0 |
             if (FTPReply.isPositiveCompletion(stru(structure)))
1043 |  |
             {
1044 | 0 |
                 __fileStructure = structure;
1045 | 0 |
                 return true;
1046 |  |
             }
1047 | 0 |
             return false;
1048 |  |
         }
1049 |  |
1050 |  |
1051 |  |
         /***
1052 |  |
          * Sets the transfer mode.  The default transfer mode
1053 |  |
          * <code> FTP.STREAM_TRANSFER_MODE </code> if this method is never called.
1054 |  |
          * <p>
1055 |  |
          * @param mode  The new transfer mode to use (one of the FTP class
1056 |  |
          *         <code>_TRANSFER_MODE</code> constants).
1057 |  |
          * @return True if successfully completed, false if not.
1058 |  |
          * @exception FTPConnectionClosedException
1059 |  |
          *      If the FTP server prematurely closes the connection as a result
1060 |  |
          *      of the client being idle or some other reason causing the server
1061 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1062 |  |
          *      as an IOException or independently as itself.
1063 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1064 |  |
          *      command to the server or receiving a reply from the server.
1065 |  |
          ***/
1066 |  |
         public boolean setFileTransferMode(int mode) throws IOException
1067 |  |
         {
1068 | 0 |
             if (FTPReply.isPositiveCompletion(mode(mode)))
1069 |  |
             {
1070 | 0 |
                 __fileTransferMode = mode;
1071 | 0 |
                 return true;
1072 |  |
             }
1073 | 0 |
             return false;
1074 |  |
         }
1075 |  |
1076 |  |
1077 |  |
         /***
1078 |  |
          * Initiate a server to server file transfer.  This method tells the
1079 |  |
          * server to which the client is connected to retrieve a given file from
1080 |  |
          * the other server.
1081 |  |
          * <p>
1082 |  |
          * @param filename  The name of the file to retrieve.
1083 |  |
          * @return True if successfully completed, false if not.
1084 |  |
          * @exception FTPConnectionClosedException
1085 |  |
          *      If the FTP server prematurely closes the connection as a result
1086 |  |
          *      of the client being idle or some other reason causing the server
1087 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1088 |  |
          *      as an IOException or independently as itself.
1089 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1090 |  |
          *      command to the server or receiving a reply from the server.
1091 |  |
          ***/
1092 |  |
         public boolean remoteRetrieve(String filename) throws IOException
1093 |  |
         {
1094 | 0 |
             if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
1095 |  |
                     __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
1096 | 0 |
                 return FTPReply.isPositivePreliminary(retr(filename));
1097 | 0 |
             return false;
1098 |  |
         }
1099 |  |
1100 |  |
1101 |  |
         /***
1102 |  |
          * Initiate a server to server file transfer.  This method tells the
1103 |  |
          * server to which the client is connected to store a file on
1104 |  |
          * the other server using the given filename.  The other server must
1105 |  |
          * have had a <code> remoteRetrieve </code> issued to it by another
1106 |  |
          * FTPClient.
1107 |  |
          * <p>
1108 |  |
          * @param filename  The name to call the file that is to be stored.
1109 |  |
          * @return True if successfully completed, false if not.
1110 |  |
          * @exception FTPConnectionClosedException
1111 |  |
          *      If the FTP server prematurely closes the connection as a result
1112 |  |
          *      of the client being idle or some other reason causing the server
1113 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1114 |  |
          *      as an IOException or independently as itself.
1115 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1116 |  |
          *      command to the server or receiving a reply from the server.
1117 |  |
          ***/
1118 |  |
         public boolean remoteStore(String filename) throws IOException
1119 |  |
         {
1120 | 0 |
             if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
1121 |  |
                     __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
1122 | 0 |
                 return FTPReply.isPositivePreliminary(stor(filename));
1123 | 0 |
             return false;
1124 |  |
         }
1125 |  |
1126 |  |
1127 |  |
         /***
1128 |  |
          * Initiate a server to server file transfer.  This method tells the
1129 |  |
          * server to which the client is connected to store a file on
1130 |  |
          * the other server using a unique filename based on the given filename.
1131 |  |
          * The other server must have had a <code> remoteRetrieve </code> issued
1132 |  |
          * to it by another FTPClient.
1133 |  |
          * <p>
1134 |  |
          * @param filename  The name on which to base the filename of the file
1135 |  |
          *                  that is to be stored.
1136 |  |
          * @return True if successfully completed, false if not.
1137 |  |
          * @exception FTPConnectionClosedException
1138 |  |
          *      If the FTP server prematurely closes the connection as a result
1139 |  |
          *      of the client being idle or some other reason causing the server
1140 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1141 |  |
          *      as an IOException or independently as itself.
1142 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1143 |  |
          *      command to the server or receiving a reply from the server.
1144 |  |
          ***/
1145 |  |
         public boolean remoteStoreUnique(String filename) throws IOException
1146 |  |
         {
1147 | 0 |
             if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
1148 |  |
                     __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
1149 | 0 |
                 return FTPReply.isPositivePreliminary(stou(filename));
1150 | 0 |
             return false;
1151 |  |
         }
1152 |  |
1153 |  |
1154 |  |
         /***
1155 |  |
          * Initiate a server to server file transfer.  This method tells the
1156 |  |
          * server to which the client is connected to store a file on
1157 |  |
          * the other server using a unique filename.
1158 |  |
          * The other server must have had a <code> remoteRetrieve </code> issued
1159 |  |
          * to it by another FTPClient.  Many FTP servers require that a base
1160 |  |
          * filename be given from which the unique filename can be derived.  For
1161 |  |
          * those servers use the other version of <code> remoteStoreUnique</code>
1162 |  |
          * <p>
1163 |  |
          * @return True if successfully completed, false if not.
1164 |  |
          * @exception FTPConnectionClosedException
1165 |  |
          *      If the FTP server prematurely closes the connection as a result
1166 |  |
          *      of the client being idle or some other reason causing the server
1167 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1168 |  |
          *      as an IOException or independently as itself.
1169 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1170 |  |
          *      command to the server or receiving a reply from the server.
1171 |  |
          ***/
1172 |  |
         public boolean remoteStoreUnique() throws IOException
1173 |  |
         {
1174 | 0 |
             if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
1175 |  |
                     __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
1176 | 0 |
                 return FTPReply.isPositivePreliminary(stou());
1177 | 0 |
             return false;
1178 |  |
         }
1179 |  |
1180 |  |
         // For server to server transfers
1181 |  |
         /***
1182 |  |
          * Initiate a server to server file transfer.  This method tells the
1183 |  |
          * server to which the client is connected to append to a given file on
1184 |  |
          * the other server.  The other server must have had a
1185 |  |
          * <code> remoteRetrieve </code> issued to it by another FTPClient.
1186 |  |
          * <p>
1187 |  |
          * @param filename  The name of the file to be appended to, or if the
1188 |  |
          *        file does not exist, the name to call the file being stored.
1189 |  |
          * <p>
1190 |  |
          * @return True if successfully completed, false if not.
1191 |  |
          * @exception FTPConnectionClosedException
1192 |  |
          *      If the FTP server prematurely closes the connection as a result
1193 |  |
          *      of the client being idle or some other reason causing the server
1194 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1195 |  |
          *      as an IOException or independently as itself.
1196 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1197 |  |
          *      command to the server or receiving a reply from the server.
1198 |  |
          ***/
1199 |  |
         public boolean remoteAppend(String filename) throws IOException
1200 |  |
         {
1201 | 0 |
             if (__dataConnectionMode == ACTIVE_REMOTE_DATA_CONNECTION_MODE ||
1202 |  |
                     __dataConnectionMode == PASSIVE_REMOTE_DATA_CONNECTION_MODE)
1203 | 0 |
                 return FTPReply.isPositivePreliminary(stor(filename));
1204 | 0 |
             return false;
1205 |  |
         }
1206 |  |
1207 |  |
         /***
1208 |  |
          * There are a few FTPClient methods that do not complete the
1209 |  |
          * entire sequence of FTP commands to complete a transaction.  These
1210 |  |
          * commands require some action by the programmer after the reception
1211 |  |
          * of a positive intermediate command.  After the programmer's code
1212 |  |
          * completes its actions, it must call this method to receive
1213 |  |
          * the completion reply from the server and verify the success of the
1214 |  |
          * entire transaction.
1215 |  |
          * <p>
1216 |  |
          * For example,
1217 |  |
          * <pre>
1218 |  |
          * InputStream input;
1219 |  |
          * OutputStream output;
1220 |  |
          * input  = new FileInputStream("foobaz.txt");
1221 |  |
          * output = ftp.storeFileStream("foobar.txt")
1222 |  |
          * if(!FTPReply.isPositiveIntermediate(ftp.getReplyCode())) {
1223 |  |
          *     input.close();
1224 |  |
          *     output.close();
1225 |  |
          *     ftp.logout();
1226 |  |
          *     ftp.disconnect();
1227 |  |
          *     System.err.println("File transfer failed.");
1228 |  |
          *     System.exit(1);
1229 |  |
          * }
1230 |  |
          * Util.copyStream(input, output);
1231 |  |
          * input.close();
1232 |  |
          * output.close();
1233 |  |
          * // Must call completePendingCommand() to finish command.
1234 |  |
          * if(!ftp.completePendingCommand()) {
1235 |  |
          *     ftp.logout();
1236 |  |
          *     ftp.disconnect();
1237 |  |
          *     System.err.println("File transfer failed.");
1238 |  |
          *     System.exit(1);
1239 |  |
          * }
1240 |  |
          * </pre>
1241 |  |
          * <p>
1242 |  |
          * @return True if successfully completed, false if not.
1243 |  |
          * @exception FTPConnectionClosedException
1244 |  |
          *      If the FTP server prematurely closes the connection as a result
1245 |  |
          *      of the client being idle or some other reason causing the server
1246 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1247 |  |
          *      as an IOException or independently as itself.
1248 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1249 |  |
          *      command to the server or receiving a reply from the server.
1250 |  |
          ***/
1251 |  |
         public boolean completePendingCommand() throws IOException
1252 |  |
         {
1253 | 0 |
             return FTPReply.isPositiveCompletion(getReply());
1254 |  |
         }
1255 |  |
1256 |  |
1257 |  |
         /***
1258 |  |
          * Retrieves a named file from the server and writes it to the given
1259 |  |
          * OutputStream.  This method does NOT close the given OutputStream.
1260 |  |
          * If the current file type is ASCII, line separators in the file are
1261 |  |
          * converted to the local representation.
1262 |  |
          * <p>
1263 |  |
          * @param remote  The name of the remote file.
1264 |  |
          * @param local   The local OutputStream to which to write the file.
1265 |  |
          * @return True if successfully completed, false if not.
1266 |  |
          * @exception FTPConnectionClosedException
1267 |  |
          *      If the FTP server prematurely closes the connection as a result
1268 |  |
          *      of the client being idle or some other reason causing the server
1269 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1270 |  |
          *      as an IOException or independently as itself.
1271 |  |
          * @exception CopyStreamException  If an I/O error occurs while actually
1272 |  |
          *      transferring the file.  The CopyStreamException allows you to
1273 |  |
          *      determine the number of bytes transferred and the IOException
1274 |  |
          *      causing the error.  This exception may be caught either
1275 |  |
          *      as an IOException or independently as itself.
1276 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1277 |  |
          *      command to the server or receiving a reply from the server.
1278 |  |
          ***/
1279 |  |
         public boolean retrieveFile(String remote, OutputStream local)
1280 |  |
         throws IOException
1281 |  |
         {
1282 |  |
             InputStream input;
1283 |  |
             Socket socket;
1284 |  |
1285 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
1286 | 0 |
                 return false;
1287 |  |
1288 | 0 |
             input = new BufferedInputStream(socket.getInputStream(),
1289 |  |
                                             getBufferSize());
1290 | 0 |
             if (__fileType == ASCII_FILE_TYPE)
1291 | 0 |
               input = new FromNetASCIIInputStream(input);
1292 |  |
             // Treat everything else as binary for now
1293 |  |
             try
1294 |  |
             {
1295 | 0 |
                 Util.copyStream(input, local, getBufferSize(),
1296 |  |
                                 CopyStreamEvent.UNKNOWN_STREAM_SIZE, null,
1297 |  |
                                 false);
1298 |  |
             }
1299 | 0 |
             catch (IOException e)
1300 |  |
             {
1301 |  |
                 try
1302 |  |
                 {
1303 | 0 |
                     socket.close();
1304 |  |
                 }
1305 | 0 |
                 catch (IOException f)
1306 | 0 |
                 {}
1307 | 0 |
                 throw e;
1308 | 0 |
             }
1309 | 0 |
             socket.close();
1310 | 0 |
             return completePendingCommand();
1311 |  |
         }
1312 |  |
1313 |  |
         /***
1314 |  |
          * Returns an InputStream from which a named file from the server
1315 |  |
          * can be read.  If the current file type is ASCII, the returned
1316 |  |
          * InputStream will convert line separators in the file to
1317 |  |
          * the local representation.  You must close the InputStream when you
1318 |  |
          * finish reading from it.  The InputStream itself will take care of
1319 |  |
          * closing the parent data connection socket upon being closed.  To
1320 |  |
          * finalize the file transfer you must call
1321 |  |
          * {@link #completePendingCommand  completePendingCommand } and
1322 |  |
          * check its return value to verify success.
1323 |  |
          * <p>
1324 |  |
          * @param remote  The name of the remote file.
1325 |  |
          * @return An InputStream from which the remote file can be read.  If
1326 |  |
          *      the data connection cannot be opened (e.g., the file does not
1327 |  |
          *      exist), null is returned (in which case you may check the reply
1328 |  |
          *      code to determine the exact reason for failure).
1329 |  |
          * @exception FTPConnectionClosedException
1330 |  |
          *      If the FTP server prematurely closes the connection as a result
1331 |  |
          *      of the client being idle or some other reason causing the server
1332 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1333 |  |
          *      as an IOException or independently as itself.
1334 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1335 |  |
          *      command to the server or receiving a reply from the server.
1336 |  |
          ***/
1337 |  |
         public InputStream retrieveFileStream(String remote) throws IOException
1338 |  |
         {
1339 |  |
             InputStream input;
1340 |  |
             Socket socket;
1341 |  |
1342 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.RETR, remote)) == null)
1343 | 0 |
                 return null;
1344 |  |
1345 | 0 |
             input = socket.getInputStream();
1346 | 0 |
             if (__fileType == ASCII_FILE_TYPE) {
1347 |  |
               // We buffer ascii transfers because the buffering has to
1348 |  |
               // be interposed between FromNetASCIIOutputSream and the underlying
1349 |  |
               // socket input stream.  We don't buffer binary transfers
1350 |  |
               // because we don't want to impose a buffering policy on the
1351 |  |
               // programmer if possible.  Programmers can decide on their
1352 |  |
               // own if they want to wrap the SocketInputStream we return
1353 |  |
               // for file types other than ASCII.
1354 | 0 |
               input = new BufferedInputStream(input,
1355 |  |
                                               getBufferSize());
1356 | 0 |
               input = new FromNetASCIIInputStream(input);
1357 |  |
             }
1358 | 0 |
             return new org.apache.commons.net.io.SocketInputStream(socket, input);
1359 |  |
         }
1360 |  |
1361 |  |
1362 |  |
         /***
1363 |  |
          * Stores a file on the server using the given name and taking input
1364 |  |
          * from the given InputStream.  This method does NOT close the given
1365 |  |
          * InputStream.  If the current file type is ASCII, line separators in
1366 |  |
          * the file are transparently converted to the NETASCII format (i.e.,
1367 |  |
          * you should not attempt to create a special InputStream to do this).
1368 |  |
          * <p>
1369 |  |
          * @param remote  The name to give the remote file.
1370 |  |
          * @param local   The local InputStream from which to read the file.
1371 |  |
          * @return True if successfully completed, false if not.
1372 |  |
          * @exception FTPConnectionClosedException
1373 |  |
          *      If the FTP server prematurely closes the connection as a result
1374 |  |
          *      of the client being idle or some other reason causing the server
1375 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1376 |  |
          *      as an IOException or independently as itself.
1377 |  |
          * @exception CopyStreamException  If an I/O error occurs while actually
1378 |  |
          *      transferring the file.  The CopyStreamException allows you to
1379 |  |
          *      determine the number of bytes transferred and the IOException
1380 |  |
          *      causing the error.  This exception may be caught either
1381 |  |
          *      as an IOException or independently as itself.
1382 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1383 |  |
          *      command to the server or receiving a reply from the server.
1384 |  |
          ***/
1385 |  |
         public boolean storeFile(String remote, InputStream local)
1386 |  |
         throws IOException
1387 |  |
         {
1388 | 0 |
             return __storeFile(FTPCommand.STOR, remote, local);
1389 |  |
         }
1390 |  |
1391 |  |
1392 |  |
         /***
1393 |  |
          * Returns an OutputStream through which data can be written to store
1394 |  |
          * a file on the server using the given name.  If the current file type
1395 |  |
          * is ASCII, the returned OutputStream will convert line separators in
1396 |  |
          * the file to the NETASCII format  (i.e., you should not attempt to
1397 |  |
          * create a special OutputStream to do this).  You must close the
1398 |  |
          * OutputStream when you finish writing to it.  The OutputStream itself
1399 |  |
          * will take care of closing the parent data connection socket upon being
1400 |  |
          * closed.  To finalize the file transfer you must call
1401 |  |
          * {@link #completePendingCommand  completePendingCommand } and
1402 |  |
          * check its return value to verify success.
1403 |  |
          * <p>
1404 |  |
          * @param remote  The name to give the remote file.
1405 |  |
          * @return An OutputStream through which the remote file can be written.  If
1406 |  |
          *      the data connection cannot be opened (e.g., the file does not
1407 |  |
          *      exist), null is returned (in which case you may check the reply
1408 |  |
          *      code to determine the exact reason for failure).
1409 |  |
          * @exception FTPConnectionClosedException
1410 |  |
          *      If the FTP server prematurely closes the connection as a result
1411 |  |
          *      of the client being idle or some other reason causing the server
1412 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1413 |  |
          *      as an IOException or independently as itself.
1414 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1415 |  |
          *      command to the server or receiving a reply from the server.
1416 |  |
          ***/
1417 |  |
         public OutputStream storeFileStream(String remote) throws IOException
1418 |  |
         {
1419 | 0 |
             return __storeFileStream(FTPCommand.STOR, remote);
1420 |  |
         }
1421 |  |
1422 |  |
         /***
1423 |  |
          * Appends to a file on the server with the given name, taking input
1424 |  |
          * from the given InputStream.  This method does NOT close the given
1425 |  |
          * InputStream.  If the current file type is ASCII, line separators in
1426 |  |
          * the file are transparently converted to the NETASCII format (i.e.,
1427 |  |
          * you should not attempt to create a special InputStream to do this).
1428 |  |
          * <p>
1429 |  |
          * @param remote  The name of the remote file.
1430 |  |
          * @param local   The local InputStream from which to read the data to
1431 |  |
          *                be appended to the remote file.
1432 |  |
          * @return True if successfully completed, false if not.
1433 |  |
          * @exception FTPConnectionClosedException
1434 |  |
          *      If the FTP server prematurely closes the connection as a result
1435 |  |
          *      of the client being idle or some other reason causing the server
1436 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1437 |  |
          *      as an IOException or independently as itself.
1438 |  |
          * @exception CopyStreamException  If an I/O error occurs while actually
1439 |  |
          *      transferring the file.  The CopyStreamException allows you to
1440 |  |
          *      determine the number of bytes transferred and the IOException
1441 |  |
          *      causing the error.  This exception may be caught either
1442 |  |
          *      as an IOException or independently as itself.
1443 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1444 |  |
          *      command to the server or receiving a reply from the server.
1445 |  |
          ***/
1446 |  |
         public boolean appendFile(String remote, InputStream local)
1447 |  |
         throws IOException
1448 |  |
         {
1449 | 0 |
             return __storeFile(FTPCommand.APPE, remote, local);
1450 |  |
         }
1451 |  |
1452 |  |
         /***
1453 |  |
          * Returns an OutputStream through which data can be written to append
1454 |  |
          * to a file on the server with the given name.  If the current file type
1455 |  |
          * is ASCII, the returned OutputStream will convert line separators in
1456 |  |
          * the file to the NETASCII format  (i.e., you should not attempt to
1457 |  |
          * create a special OutputStream to do this).  You must close the
1458 |  |
          * OutputStream when you finish writing to it.  The OutputStream itself
1459 |  |
          * will take care of closing the parent data connection socket upon being
1460 |  |
          * closed.  To finalize the file transfer you must call
1461 |  |
          * {@link #completePendingCommand  completePendingCommand } and
1462 |  |
          * check its return value to verify success.
1463 |  |
          * <p>
1464 |  |
          * @param remote  The name of the remote file.
1465 |  |
          * @return An OutputStream through which the remote file can be appended.
1466 |  |
          *      If the data connection cannot be opened (e.g., the file does not
1467 |  |
          *      exist), null is returned (in which case you may check the reply
1468 |  |
          *      code to determine the exact reason for failure).
1469 |  |
          * @exception FTPConnectionClosedException
1470 |  |
          *      If the FTP server prematurely closes the connection as a result
1471 |  |
          *      of the client being idle or some other reason causing the server
1472 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1473 |  |
          *      as an IOException or independently as itself.
1474 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1475 |  |
          *      command to the server or receiving a reply from the server.
1476 |  |
          ***/
1477 |  |
         public OutputStream appendFileStream(String remote) throws IOException
1478 |  |
         {
1479 | 0 |
             return __storeFileStream(FTPCommand.APPE, remote);
1480 |  |
         }
1481 |  |
1482 |  |
         /***
1483 |  |
          * Stores a file on the server using a unique name derived from the
1484 |  |
          * given name and taking input
1485 |  |
          * from the given InputStream.  This method does NOT close the given
1486 |  |
          * InputStream.  If the current file type is ASCII, line separators in
1487 |  |
          * the file are transparently converted to the NETASCII format (i.e.,
1488 |  |
          * you should not attempt to create a special InputStream to do this).
1489 |  |
          * <p>
1490 |  |
          * @param remote  The name on which to base the unique name given to
1491 |  |
          *                the remote file.
1492 |  |
          * @param local   The local InputStream from which to read the file.
1493 |  |
          * @return True if successfully completed, false if not.
1494 |  |
          * @exception FTPConnectionClosedException
1495 |  |
          *      If the FTP server prematurely closes the connection as a result
1496 |  |
          *      of the client being idle or some other reason causing the server
1497 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1498 |  |
          *      as an IOException or independently as itself.
1499 |  |
          * @exception CopyStreamException  If an I/O error occurs while actually
1500 |  |
          *      transferring the file.  The CopyStreamException allows you to
1501 |  |
          *      determine the number of bytes transferred and the IOException
1502 |  |
          *      causing the error.  This exception may be caught either
1503 |  |
          *      as an IOException or independently as itself.
1504 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1505 |  |
          *      command to the server or receiving a reply from the server.
1506 |  |
          ***/
1507 |  |
         public boolean storeUniqueFile(String remote, InputStream local)
1508 |  |
         throws IOException
1509 |  |
         {
1510 | 0 |
             return __storeFile(FTPCommand.STOU, remote, local);
1511 |  |
         }
1512 |  |
1513 |  |
1514 |  |
         /***
1515 |  |
          * Returns an OutputStream through which data can be written to store
1516 |  |
          * a file on the server using a unique name derived from the given name.
1517 |  |
          * If the current file type
1518 |  |
          * is ASCII, the returned OutputStream will convert line separators in
1519 |  |
          * the file to the NETASCII format  (i.e., you should not attempt to
1520 |  |
          * create a special OutputStream to do this).  You must close the
1521 |  |
          * OutputStream when you finish writing to it.  The OutputStream itself
1522 |  |
          * will take care of closing the parent data connection socket upon being
1523 |  |
          * closed.  To finalize the file transfer you must call
1524 |  |
          * {@link #completePendingCommand  completePendingCommand } and
1525 |  |
          * check its return value to verify success.
1526 |  |
          * <p>
1527 |  |
          * @param remote  The name on which to base the unique name given to
1528 |  |
          *                the remote file.
1529 |  |
          * @return An OutputStream through which the remote file can be written.  If
1530 |  |
          *      the data connection cannot be opened (e.g., the file does not
1531 |  |
          *      exist), null is returned (in which case you may check the reply
1532 |  |
          *      code to determine the exact reason for failure).
1533 |  |
          * @exception FTPConnectionClosedException
1534 |  |
          *      If the FTP server prematurely closes the connection as a result
1535 |  |
          *      of the client being idle or some other reason causing the server
1536 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1537 |  |
          *      as an IOException or independently as itself.
1538 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1539 |  |
          *      command to the server or receiving a reply from the server.
1540 |  |
          ***/
1541 |  |
         public OutputStream storeUniqueFileStream(String remote) throws IOException
1542 |  |
         {
1543 | 0 |
             return __storeFileStream(FTPCommand.STOU, remote);
1544 |  |
         }
1545 |  |
1546 |  |
         /**
1547 |  |
          * Stores a file on the server using a unique name assigned by the
1548 |  |
          * server and taking input from the given InputStream.  This method does
1549 |  |
          * NOT close the given
1550 |  |
          * InputStream.  If the current file type is ASCII, line separators in
1551 |  |
          * the file are transparently converted to the NETASCII format (i.e.,
1552 |  |
          * you should not attempt to create a special InputStream to do this).
1553 |  |
          * <p>
1554 |  |
          * @param local   The local InputStream from which to read the file.
1555 |  |
          * @return True if successfully completed, false if not.
1556 |  |
          * @exception FTPConnectionClosedException
1557 |  |
          *      If the FTP server prematurely closes the connection as a result
1558 |  |
          *      of the client being idle or some other reason causing the server
1559 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1560 |  |
          *      as an IOException or independently as itself.
1561 |  |
          * @exception CopyStreamException  If an I/O error occurs while actually
1562 |  |
          *      transferring the file.  The CopyStreamException allows you to
1563 |  |
          *      determine the number of bytes transferred and the IOException
1564 |  |
          *      causing the error.  This exception may be caught either
1565 |  |
          *      as an IOException or independently as itself.
1566 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1567 |  |
          *      command to the server or receiving a reply from the server.
1568 |  |
          */
1569 |  |
         public boolean storeUniqueFile(InputStream local) throws IOException
1570 |  |
         {
1571 | 0 |
             return __storeFile(FTPCommand.STOU, null, local);
1572 |  |
         }
1573 |  |
1574 |  |
         /**
1575 |  |
          * Returns an OutputStream through which data can be written to store
1576 |  |
          * a file on the server using a unique name assigned by the server.
1577 |  |
          * If the current file type
1578 |  |
          * is ASCII, the returned OutputStream will convert line separators in
1579 |  |
          * the file to the NETASCII format  (i.e., you should not attempt to
1580 |  |
          * create a special OutputStream to do this).  You must close the
1581 |  |
          * OutputStream when you finish writing to it.  The OutputStream itself
1582 |  |
          * will take care of closing the parent data connection socket upon being
1583 |  |
          * closed.  To finalize the file transfer you must call
1584 |  |
          * {@link #completePendingCommand  completePendingCommand } and
1585 |  |
          * check its return value to verify success.
1586 |  |
          * <p>
1587 |  |
          * @return An OutputStream through which the remote file can be written.  If
1588 |  |
          *      the data connection cannot be opened (e.g., the file does not
1589 |  |
          *      exist), null is returned (in which case you may check the reply
1590 |  |
          *      code to determine the exact reason for failure).
1591 |  |
          * @exception FTPConnectionClosedException
1592 |  |
          *      If the FTP server prematurely closes the connection as a result
1593 |  |
          *      of the client being idle or some other reason causing the server
1594 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1595 |  |
          *      as an IOException or independently as itself.
1596 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1597 |  |
          *      command to the server or receiving a reply from the server.
1598 |  |
          */
1599 |  |
         public OutputStream storeUniqueFileStream() throws IOException
1600 |  |
         {
1601 | 0 |
             return __storeFileStream(FTPCommand.STOU, null);
1602 |  |
         }
1603 |  |
1604 |  |
         /***
1605 |  |
          * Reserve a number of bytes on the server for the next file transfer.
1606 |  |
          * <p>
1607 |  |
          * @param bytes  The number of bytes which the server should allocate.
1608 |  |
          * @return True if successfully completed, false if not.
1609 |  |
          * @exception FTPConnectionClosedException
1610 |  |
          *      If the FTP server prematurely closes the connection as a result
1611 |  |
          *      of the client being idle or some other reason causing the server
1612 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1613 |  |
          *      as an IOException or independently as itself.
1614 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1615 |  |
          *      command to the server or receiving a reply from the server.
1616 |  |
          ***/
1617 |  |
         public boolean allocate(int bytes) throws IOException
1618 |  |
         {
1619 | 0 |
             return FTPReply.isPositiveCompletion(allo(bytes));
1620 |  |
         }
1621 |  |
1622 |  |
1623 |  |
         /**
1624 |  |
          * Reserve space on the server for the next file transfer.
1625 |  |
          * <p>
1626 |  |
          * @param bytes  The number of bytes which the server should allocate.
1627 |  |
          * @param recordSize  The size of a file record.
1628 |  |
          * @return True if successfully completed, false if not.
1629 |  |
          * @exception FTPConnectionClosedException
1630 |  |
          *      If the FTP server prematurely closes the connection as a result
1631 |  |
          *      of the client being idle or some other reason causing the server
1632 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1633 |  |
          *      as an IOException or independently as itself.
1634 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1635 |  |
          *      command to the server or receiving a reply from the server.
1636 |  |
          */
1637 |  |
         public boolean allocate(int bytes, class="keyword">int recordSize) throws IOException
1638 |  |
         {
1639 | 0 |
             return FTPReply.isPositiveCompletion(allo(bytes, recordSize));
1640 |  |
         }
1641 |  |
1642 |  |
1643 |  |
         /***
1644 |  |
          * Restart a <code>STREAM_TRANSFER_MODE</code> file transfer starting
1645 |  |
          * from the given offset.  This will only work on FTP servers supporting
1646 |  |
          * the REST comand for the stream transfer mode.  However, most FTP
1647 |  |
          * servers support this.  Any subsequent file transfer will start
1648 |  |
          * reading or writing the remote file from the indicated offset.
1649 |  |
          * <p>
1650 |  |
          * @param offset  The offset into the remote file at which to start the
1651 |  |
          *           next file transfer.
1652 |  |
          * @return True if successfully completed, false if not.
1653 |  |
          * @exception FTPConnectionClosedException
1654 |  |
          *      If the FTP server prematurely closes the connection as a result
1655 |  |
          *      of the client being idle or some other reason causing the server
1656 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1657 |  |
          *      as an IOException or independently as itself.
1658 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1659 |  |
          *      command to the server or receiving a reply from the server.
1660 |  |
          ***/
1661 |  |
         private boolean restart(long offset) throws IOException
1662 |  |
         {
1663 | 0 |
             __restartOffset = 0;
1664 | 0 |
             return FTPReply.isPositiveIntermediate(rest(Long.toString(offset)));
1665 |  |
         }
1666 |  |
1667 |  |
         /***
1668 |  |
          * Sets the restart offset.  The restart command is sent to the server
1669 |  |
          * only before sending the file transfer command.  When this is done,
1670 |  |
          * the restart marker is reset to zero.
1671 |  |
          * <p>
1672 |  |
          * @param offset  The offset into the remote file at which to start the
1673 |  |
          *           next file transfer.  This must be a value greater than or
1674 |  |
          *           equal to zero.
1675 |  |
          ***/
1676 |  |
         public void setRestartOffset(long offset)
1677 |  |
         {
1678 | 0 |
             if (offset >= 0)
1679 | 0 |
                 __restartOffset = offset;
1680 | 0 |
         }
1681 |  |
1682 |  |
         /***
1683 |  |
          * Fetches the restart offset.
1684 |  |
          * <p>
1685 |  |
          * @return offset  The offset into the remote file at which to start the
1686 |  |
          *           next file transfer.
1687 |  |
          ***/
1688 |  |
         public long getRestartOffset()
1689 |  |
         {
1690 | 0 |
             return __restartOffset;
1691 |  |
         }
1692 |  |
1693 |  |
1694 |  |
1695 |  |
         /***
1696 |  |
          * Renames a remote file.
1697 |  |
          * <p>
1698 |  |
          * @param from  The name of the remote file to rename.
1699 |  |
          * @param to    The new name of the remote file.
1700 |  |
          * @return True if successfully completed, false if not.
1701 |  |
          * @exception FTPConnectionClosedException
1702 |  |
          *      If the FTP server prematurely closes the connection as a result
1703 |  |
          *      of the client being idle or some other reason causing the server
1704 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1705 |  |
          *      as an IOException or independently as itself.
1706 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1707 |  |
          *      command to the server or receiving a reply from the server.
1708 |  |
          ***/
1709 |  |
         public boolean rename(String from, String to) throws IOException
1710 |  |
         {
1711 | 0 |
             if (!FTPReply.isPositiveIntermediate(rnfr(from)))
1712 | 0 |
                 return false;
1713 |  |
1714 | 0 |
             return FTPReply.isPositiveCompletion(rnto(to));
1715 |  |
         }
1716 |  |
1717 |  |
1718 |  |
         /***
1719 |  |
          * Abort a transfer in progress.
1720 |  |
          * <p>
1721 |  |
          * @return True if successfully completed, false if not.
1722 |  |
          * @exception FTPConnectionClosedException
1723 |  |
          *      If the FTP server prematurely closes the connection as a result
1724 |  |
          *      of the client being idle or some other reason causing the server
1725 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1726 |  |
          *      as an IOException or independently as itself.
1727 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1728 |  |
          *      command to the server or receiving a reply from the server.
1729 |  |
          ***/
1730 |  |
         public boolean abort() throws IOException
1731 |  |
         {
1732 | 0 |
             return FTPReply.isPositiveCompletion(abor());
1733 |  |
         }
1734 |  |
1735 |  |
         /***
1736 |  |
          * Deletes a file on the FTP server.
1737 |  |
          * <p>
1738 |  |
          * @param pathname   The pathname of the file to be deleted.
1739 |  |
          * @return True if successfully completed, false if not.
1740 |  |
          * @exception FTPConnectionClosedException
1741 |  |
          *      If the FTP server prematurely closes the connection as a result
1742 |  |
          *      of the client being idle or some other reason causing the server
1743 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1744 |  |
          *      as an IOException or independently as itself.
1745 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1746 |  |
          *      command to the server or receiving a reply from the server.
1747 |  |
          ***/
1748 |  |
         public boolean deleteFile(String pathname) throws IOException
1749 |  |
         {
1750 | 0 |
             return FTPReply.isPositiveCompletion(dele(pathname));
1751 |  |
         }
1752 |  |
1753 |  |
1754 |  |
         /***
1755 |  |
          * Removes a directory on the FTP server (if empty).
1756 |  |
          * <p>
1757 |  |
          * @param pathname  The pathname of the directory to remove.
1758 |  |
          * @return True if successfully completed, false if not.
1759 |  |
          * @exception FTPConnectionClosedException
1760 |  |
          *      If the FTP server prematurely closes the connection as a result
1761 |  |
          *      of the client being idle or some other reason causing the server
1762 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1763 |  |
          *      as an IOException or independently as itself.
1764 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1765 |  |
          *      command to the server or receiving a reply from the server.
1766 |  |
          ***/
1767 |  |
         public boolean removeDirectory(String pathname) throws IOException
1768 |  |
         {
1769 | 0 |
             return FTPReply.isPositiveCompletion(rmd(pathname));
1770 |  |
         }
1771 |  |
1772 |  |
1773 |  |
         /***
1774 |  |
          * Creates a new subdirectory on the FTP server in the current directory
1775 |  |
          * (if a relative pathname is given) or where specified (if an absolute
1776 |  |
          * pathname is given).
1777 |  |
          * <p>
1778 |  |
          * @param pathname The pathname of the directory to create.
1779 |  |
          * @return True if successfully completed, false if not.
1780 |  |
          * @exception FTPConnectionClosedException
1781 |  |
          *      If the FTP server prematurely closes the connection as a result
1782 |  |
          *      of the client being idle or some other reason causing the server
1783 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1784 |  |
          *      as an IOException or independently as itself.
1785 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1786 |  |
          *      command to the server or receiving a reply from the server.
1787 |  |
          ***/
1788 |  |
         public boolean makeDirectory(String pathname) throws IOException
1789 |  |
         {
1790 | 0 |
             return FTPReply.isPositiveCompletion(mkd(pathname));
1791 |  |
         }
1792 |  |
1793 |  |
1794 |  |
         /***
1795 |  |
          * Returns the pathname of the current working directory.
1796 |  |
          * <p>
1797 |  |
          * @return The pathname of the current working directory.  If it cannot
1798 |  |
          *         be obtained, returns null.
1799 |  |
          * @exception FTPConnectionClosedException
1800 |  |
          *      If the FTP server prematurely closes the connection as a result
1801 |  |
          *      of the client being idle or some other reason causing the server
1802 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1803 |  |
          *      as an IOException or independently as itself.
1804 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1805 |  |
          *      command to the server or receiving a reply from the server.
1806 |  |
          ***/
1807 |  |
         public String printWorkingDirectory() throws IOException
1808 |  |
         {
1809 | 0 |
             if (pwd() != FTPReply.PATHNAME_CREATED)
1810 | 0 |
                 return null;
1811 |  |
1812 | 0 |
             return __parsePathname((String)_replyLines.elementAt(0));
1813 |  |
         }
1814 |  |
1815 |  |
1816 |  |
         /**
1817 |  |
          * Send a site specific command.
1818 |  |
          * @param arguments The site specific command and arguments.
1819 |  |
          * @return True if successfully completed, false if not.
1820 |  |
          * @exception FTPConnectionClosedException
1821 |  |
          *      If the FTP server prematurely closes the connection as a result
1822 |  |
          *      of the client being idle or some other reason causing the server
1823 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1824 |  |
          *      as an IOException or independently as itself.
1825 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1826 |  |
          *      command to the server or receiving a reply from the server.
1827 |  |
          */
1828 |  |
         public boolean sendSiteCommand(String arguments) throws IOException
1829 |  |
         {
1830 | 0 |
             return FTPReply.isPositiveCompletion(site(arguments));
1831 |  |
         }
1832 |  |
1833 |  |
1834 |  |
         /***
1835 |  |
          * Fetches the system type name from the server and returns the string.
1836 |  |
          * This value is cached for the duration of the connection after the
1837 |  |
          * first call to this method.  In other words, only the first time
1838 |  |
          * that you invoke this method will it issue a SYST command to the
1839 |  |
          * FTP server.  FTPClient will remember the value and return the
1840 |  |
          * cached value until a call to disconnect.
1841 |  |
          * <p>
1842 |  |
          * @return The system type name obtained from the server.  null if the
1843 |  |
          *       information could not be obtained.
1844 |  |
          * @exception FTPConnectionClosedException
1845 |  |
          *      If the FTP server prematurely closes the connection as a result
1846 |  |
          *      of the client being idle or some other reason causing the server
1847 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1848 |  |
          *      as an IOException or independently as itself.
1849 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1850 |  |
          *  command to the server or receiving a reply from the server.
1851 |  |
          ***/
1852 |  |
         public String getSystemName() throws IOException
1853 |  |
         {
1854 |  |
           //if (syst() == FTPReply.NAME_SYSTEM_TYPE)
1855 |  |
           // Technically, we should expect a NAME_SYSTEM_TYPE response, but
1856 |  |
           // in practice FTP servers deviate, so we soften the condition to
1857 |  |
           // a positive completion.
1858 | 0 |
             if (__systemName == null && FTPReply.isPositiveCompletion(syst()))
1859 | 0 |
                 __systemName = ((String)_replyLines.elementAt(0)).substring(4);
1860 |  |
1861 | 0 |
             return __systemName;
1862 |  |
         }
1863 |  |
1864 |  |
1865 |  |
         /***
1866 |  |
          * Fetches the system help information from the server and returns the
1867 |  |
          * full string.
1868 |  |
          * <p>
1869 |  |
          * @return The system help string obtained from the server.  null if the
1870 |  |
          *       information could not be obtained.
1871 |  |
          * @exception FTPConnectionClosedException
1872 |  |
          *      If the FTP server prematurely closes the connection as a result
1873 |  |
          *      of the client being idle or some other reason causing the server
1874 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1875 |  |
          *      as an IOException or independently as itself.
1876 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1877 |  |
          *  command to the server or receiving a reply from the server.
1878 |  |
          ***/
1879 |  |
         public String listHelp() throws IOException
1880 |  |
         {
1881 | 0 |
             if (FTPReply.isPositiveCompletion(help()))
1882 | 0 |
                 return getReplyString();
1883 | 0 |
             return null;
1884 |  |
         }
1885 |  |
1886 |  |
1887 |  |
         /**
1888 |  |
          * Fetches the help information for a given command from the server and
1889 |  |
          * returns the full string.
1890 |  |
          * @param command The command on which to ask for help.
1891 |  |
          * @return The command help string obtained from the server.  null if the
1892 |  |
          *       information could not be obtained.
1893 |  |
          * @exception FTPConnectionClosedException
1894 |  |
          *      If the FTP server prematurely closes the connection as a result
1895 |  |
          *      of the client being idle or some other reason causing the server
1896 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1897 |  |
          *      as an IOException or independently as itself.
1898 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1899 |  |
          *  command to the server or receiving a reply from the server.
1900 |  |
          */
1901 |  |
         public String listHelp(String command) throws IOException
1902 |  |
         {
1903 | 0 |
             if (FTPReply.isPositiveCompletion(help(command)))
1904 | 0 |
                 return getReplyString();
1905 | 0 |
             return null;
1906 |  |
         }
1907 |  |
1908 |  |
1909 |  |
         /***
1910 |  |
          * Sends a NOOP command to the FTP server.  This is useful for preventing
1911 |  |
          * server timeouts.
1912 |  |
          * <p>
1913 |  |
          * @return True if successfully completed, false if not.
1914 |  |
          * @exception FTPConnectionClosedException
1915 |  |
          *      If the FTP server prematurely closes the connection as a result
1916 |  |
          *      of the client being idle or some other reason causing the server
1917 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1918 |  |
          *      as an IOException or independently as itself.
1919 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1920 |  |
          *      command to the server or receiving a reply from the server.
1921 |  |
          ***/
1922 |  |
         public boolean sendNoOp() throws IOException
1923 |  |
         {
1924 | 0 |
             return FTPReply.isPositiveCompletion(noop());
1925 |  |
         }
1926 |  |
1927 |  |
1928 |  |
         /***
1929 |  |
          * Obtain a list of filenames in a directory (or just the name of a given
1930 |  |
          * file, which is not particularly useful).  This information is obtained
1931 |  |
          * through the NLST command.  If the given pathname is a directory and
1932 |  |
          * contains no files,  a zero length array is returned only
1933 |  |
          * if the FTP server returned a positive completion code, otherwise
1934 |  |
          * null is returned (the FTP server returned a 550 error No files found.).
1935 |  |
          * If the directory is not empty, an array of filenames in the directory is
1936 |  |
          * returned. If the pathname corresponds
1937 |  |
          * to a file, only that file will be listed.  The server may or may not
1938 |  |
          * expand glob expressions.
1939 |  |
          * <p>
1940 |  |
          * @param pathname  The file or directory to list.
1941 |  |
          * @return The list of filenames contained in the given path.  null if
1942 |  |
          *     the list could not be obtained.  If there are no filenames in
1943 |  |
          *     the directory, a zero-length array is returned.
1944 |  |
          * @exception FTPConnectionClosedException
1945 |  |
          *      If the FTP server prematurely closes the connection as a result
1946 |  |
          *      of the client being idle or some other reason causing the server
1947 |  |
          *      to send FTP reply code 421.  This exception may be caught either
1948 |  |
          *      as an IOException or independently as itself.
1949 |  |
          * @exception IOException  If an I/O error occurs while either sending a
1950 |  |
          *      command to the server or receiving a reply from the server.
1951 |  |
          ***/
1952 |  |
         public String[] listNames(String pathname) throws IOException
1953 |  |
         {
1954 |  |
             String line;
1955 |  |
             Socket socket;
1956 |  |
             BufferedReader reader;
1957 |  |
             Vector results;
1958 |  |
1959 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.NLST, pathname)) == null)
1960 | 0 |
                 return null;
1961 |  |
1962 | 0 |
             reader =
1963 |  |
                 new BufferedReader(class="keyword">new InputStreamReader(socket.getInputStream(), getControlEncoding()));
1964 |  |
1965 | 0 |
             results = new Vector();
1966 | 0 |
             while ((line = reader.readLine()) != null)
1967 | 0 |
                 results.addElement(line);
1968 | 0 |
             reader.close();
1969 | 0 |
             socket.close();
1970 |  |
1971 | 0 |
             if (completePendingCommand())
1972 |  |
             {
1973 |  |
                 String[] result;
1974 | 0 |
                 result = new String[results.size()];
1975 | 0 |
                 results.copyInto(result);
1976 | 0 |
                 return result;
1977 |  |
             }
1978 |  |
1979 | 0 |
             return null;
1980 |  |
         }
1981 |  |
1982 |  |
1983 |  |
         /***
1984 |  |
          * Obtain a list of filenames in the current working directory
1985 |  |
          * This information is obtained through the NLST command.  If the current
1986 |  |
          * directory contains no files, a zero length array is returned only
1987 |  |
          * if the FTP server returned a positive completion code, otherwise,
1988 |  |
          * null is returned (the FTP server returned a 550 error No files found.).
1989 |  |
          * If the directory is not empty, an array of filenames in the directory is
1990 |  |
          * returned.
1991 |  |
          * <p>
1992 |  |
          * @return The list of filenames contained in the current working
1993 |  |
          *     directory.  null if the list could not be obtained.
1994 |  |
          *     If there are no filenames in the directory, a zero-length array
1995 |  |
          *     is returned.
1996 |  |
          * @exception FTPConnectionClosedException
1997 |  |
          *      If the FTP server prematurely closes the connection as a result
1998 |  |
          *      of the client being idle or some other reason causing the server
1999 |  |
          *      to send FTP reply code 421.  This exception may be caught either
2000 |  |
          *      as an IOException or independently as itself.
2001 |  |
          * @exception IOException  If an I/O error occurs while either sending a
2002 |  |
          *      command to the server or receiving a reply from the server.
2003 |  |
          ***/
2004 |  |
         public String[] listNames() throws IOException
2005 |  |
         {
2006 | 0 |
             return listNames(null);
2007 |  |
         }
2008 |  |
2009 |  |
2010 |  |
         /**
2011 |  |
          * Using the supplied <code>parserKey</code>, obtain a list
2012 |  |
          * of file information for the current working directory or for just a
2013 |  |
          * single file.
2014 |  |
          * <p>
2015 |  |
          * If <code>key</code> is null, this object will try to autodetect
2016 |  |
          * the system-type/parser-type by calling the SYST command.
2017 |  |
          * <p>
2018 |  |
          * Under the DefaultFTPFileEntryParserFactory, which is used unless a
2019 |  |
          * different factory has been specified, the key
2020 |  |
          * can be either a recognized System type for which a parser has been
2021 |  |
          * defined, or the fully qualified class name of a class that implements
2022 |  |
          * org.apache.commons.net.ftp.FTPFileEntryParser.
2023 |  |
          * <p>
2024 |  |
          * This information is obtained through the LIST command.  The contents of
2025 |  |
          * the returned array is determined by the<code> FTPFileEntryParser </code>
2026 |  |
          * used.
2027 |  |
          * <p>
2028 |  |
          * @param parserKey This is a "handle" which the parser factory used
2029 |  |
          *                  must be able to resolve into a class implementing
2030 |  |
          *                  FTPFileEntryParser.
2031 |  |
          *                  <p>
2032 |  |
          *                  In the DefaultFTPFileEntryParserFactory, this
2033 |  |
          *                  may either be a specific key identifying a server type,
2034 |  |
          *                  which is used to identify a parser type,
2035 |  |
          *                  or the fully qualified class name of the parser.  See
2036 |  |
          *                  DefaultFTPFileEntryParserFactory.createFileEntryParser
2037 |  |
          *                  for full details.
2038 |  |
          *                  <p>
2039 |  |
          *                  If this parameter is null, will attempt to generate a key
2040 |  |
          *                  by running the SYST command.  This should cause no problem
2041 |  |
          *                  with the functionality implemented in the
2042 |  |
          *                  DefaultFTPFileEntryParserFactory, but may not map so well
2043 |  |
          *                  to an alternative user-created factory.  If that is the
2044 |  |
          *                  case, calling this routine with a null parameter and a
2045 |  |
          *                  custom parser factory may not be advisable.
2046 |  |
          *                  <p>
2047 |  |
          * @param pathname  The file or directory to list.  Since the server may
2048 |  |
          *                  or may not expand glob expressions, using them here
2049 |  |
          *                  is not recommended and may well cause this method to
2050 |  |
          *                  fail.
2051 |  |
          *
2052 |  |
          * @return The list of file information contained in the given path in
2053 |  |
          *         the format determined by the parser represented by the
2054 |  |
          *         <code> parserKey </code> parameter.
2055 |  |
          *         <p><b>
2056 |  |
          * 		   NOTE:</b> This array may contain null members if any of the
2057 |  |
          *         individual file listings failed to parse.  The caller should
2058 |  |
          *         check each entry for null before referencing it.
2059 |  |
          * @exception FTPConnectionClosedException
2060 |  |
          *                   If the FTP server prematurely closes the connection
2061 |  |
          *                   as a result of the client being idle or some other
2062 |  |
          *                   reason causing the server to send FTP reply code 421.
2063 |  |
          *                   This exception may be caught either as an IOException
2064 |  |
          *                   or independently as itself.
2065 |  |
          * @exception IOException
2066 |  |
          *                   If an I/O error occurs while either sending a
2067 |  |
          *                   command to the server or receiving a reply
2068 |  |
          *                   from the server.
2069 |  |
          * @exception ParserInitializationException
2070 |  |
          *                   Thrown if the parserKey parameter cannot be
2071 |  |
          *                   resolved by the selected parser factory.
2072 |  |
          *                   In the DefaultFTPEntryParserFactory, this will
2073 |  |
          *                   happen when parserKey is neither
2074 |  |
          *                   the fully qualified class name of a class
2075 |  |
          *                   implementing the interface
2076 |  |
          *                   org.apache.commons.net.ftp.FTPFileEntryParser
2077 |  |
          *                   nor a string containing one of the recognized keys
2078 |  |
          *                   mapping to such a parser or if class loader
2079 |  |
          *                   security issues prevent its being loaded.
2080 |  |
          * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
2081 |  |
          * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
2082 |  |
          * @see org.apache.commons.net.ftp.FTPFileEntryParser
2083 |  |
          * @deprecated use {@link  #listFiles()  listFiles()} or
2084 |  |
          * {@link  #listFiles(String)  listFiles(String)} instead and specify the
2085 |  |
          * parser Key in an {@link  #FTPClientConfig  FTPClientConfig} object instead.
2086 |  |
          */
2087 |  |
         public FTPFile[] listFiles(String parserKey, String pathname)
2088 |  |
         throws IOException
2089 |  |
         {
2090 | 0 |
             FTPListParseEngine engine =
2091 |  |
                 initiateListParsing(parserKey, pathname);
2092 | 0 |
             return engine.getFiles();
2093 |  |
         }
2094 |  |
2095 |  |
2096 |  |
         /**
2097 |  |
          * Using the default system autodetect mechanism, obtain a
2098 |  |
          * list of file information for the current working directory
2099 |  |
          * or for just a single file.
2100 |  |
          * <p>
2101 |  |
          * This information is obtained through the LIST command.  The contents of
2102 |  |
          * the returned array is determined by the<code> FTPFileEntryParser </code>
2103 |  |
          * used.
2104 |  |
          * <p>
2105 |  |
          * @param pathname  The file or directory to list.  Since the server may
2106 |  |
          *                  or may not expand glob expressions, using them here
2107 |  |
          *                  is not recommended and may well cause this method to
2108 |  |
          *                  fail.
2109 |  |
          *
2110 |  |
          * @return The list of file information contained in the given path in
2111 |  |
          *         the format determined by the autodetection mechanism
2112 |  |
          * @exception FTPConnectionClosedException
2113 |  |
          *                   If the FTP server prematurely closes the connection
2114 |  |
          *                   as a result of the client being idle or some other
2115 |  |
          *                   reason causing the server to send FTP reply code 421.
2116 |  |
          *                   This exception may be caught either as an IOException
2117 |  |
          *                   or independently as itself.
2118 |  |
          * @exception IOException
2119 |  |
          *                   If an I/O error occurs while either sending a
2120 |  |
          *                   command to the server or receiving a reply
2121 |  |
          *                   from the server.
2122 |  |
          * @exception ParserInitializationException
2123 |  |
          *                   Thrown if the parserKey parameter cannot be
2124 |  |
          *                   resolved by the selected parser factory.
2125 |  |
          *                   In the DefaultFTPEntryParserFactory, this will
2126 |  |
          *                   happen when parserKey is neither
2127 |  |
          *                   the fully qualified class name of a class
2128 |  |
          *                   implementing the interface
2129 |  |
          *                   org.apache.commons.net.ftp.FTPFileEntryParser
2130 |  |
          *                   nor a string containing one of the recognized keys
2131 |  |
          *                   mapping to such a parser or if class loader
2132 |  |
          *                   security issues prevent its being loaded.
2133 |  |
          * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
2134 |  |
          * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
2135 |  |
          * @see org.apache.commons.net.ftp.FTPFileEntryParser
2136 |  |
          */
2137 |  |
         public FTPFile[] listFiles(String pathname)
2138 |  |
         throws IOException
2139 |  |
         {
2140 | 0 |
             String key = null;
2141 | 0 |
             FTPListParseEngine engine =
2142 |  |
                 initiateListParsing(key, pathname);
2143 | 0 |
             return engine.getFiles();
2144 |  |
2145 |  |
         }
2146 |  |
         /**
2147 |  |
          * Using the default system autodetect mechanism, obtain a
2148 |  |
          * list of file information for the current working directory.
2149 |  |
          * <p>
2150 |  |
          * This information is obtained through the LIST command.  The contents of
2151 |  |
          * the returned array is determined by the<code> FTPFileEntryParser </code>
2152 |  |
          * used.
2153 |  |
          * <p>
2154 |  |
          * @return The list of file information contained in the current directory
2155 |  |
          *         in the format determined by the autodetection mechanism.
2156 |  |
          *         <p><b>
2157 |  |
          * 		   NOTE:</b> This array may contain null members if any of the
2158 |  |
          *         individual file listings failed to parse.  The caller should
2159 |  |
          *         check each entry for null before referencing it.
2160 |  |
          * @exception FTPConnectionClosedException
2161 |  |
          *                   If the FTP server prematurely closes the connection
2162 |  |
          *                   as a result of the client being idle or some other
2163 |  |
          *                   reason causing the server to send FTP reply code 421.
2164 |  |
          *                   This exception may be caught either as an IOException
2165 |  |
          *                   or independently as itself.
2166 |  |
          * @exception IOException
2167 |  |
          *                   If an I/O error occurs while either sending a
2168 |  |
          *                   command to the server or receiving a reply
2169 |  |
          *                   from the server.
2170 |  |
          * @exception ParserInitializationException
2171 |  |
          *                   Thrown if the parserKey parameter cannot be
2172 |  |
          *                   resolved by the selected parser factory.
2173 |  |
          *                   In the DefaultFTPEntryParserFactory, this will
2174 |  |
          *                   happen when parserKey is neither
2175 |  |
          *                   the fully qualified class name of a class
2176 |  |
          *                   implementing the interface
2177 |  |
          *                   org.apache.commons.net.ftp.FTPFileEntryParser
2178 |  |
          *                   nor a string containing one of the recognized keys
2179 |  |
          *                   mapping to such a parser or if class loader
2180 |  |
          *                   security issues prevent its being loaded.
2181 |  |
          * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
2182 |  |
          * @see org.apache.commons.net.ftp.parser.FTPFileEntryParserFactory
2183 |  |
          * @see org.apache.commons.net.ftp.FTPFileEntryParser
2184 |  |
          */
2185 |  |
         public FTPFile[] listFiles()
2186 |  |
         throws IOException
2187 |  |
         {
2188 | 0 |
             return listFiles((String) null);
2189 |  |
         }
2190 |  |
2191 |  |
         /**
2192 |  |
          * Using the default autodetect mechanism, initialize an FTPListParseEngine
2193 |  |
          * object containing a raw file information for the current working
2194 |  |
          * directory on the server
2195 |  |
          * This information is obtained through the LIST command.  This object
2196 |  |
          * is then capable of being iterated to return a sequence of FTPFile
2197 |  |
          * objects with information filled in by the
2198 |  |
          * <code> FTPFileEntryParser </code> used.
2199 |  |
          * <p>
2200 |  |
          * This method differs from using the listFiles() methods in that
2201 |  |
          * expensive FTPFile objects are not created until needed which may be
2202 |  |
          * an advantage on large lists.
2203 |  |
          *
2204 |  |
          * @return A FTPListParseEngine object that holds the raw information and
2205 |  |
          * is capable of providing parsed FTPFile objects, one for each file
2206 |  |
          * containing information contained in the given path in the format
2207 |  |
          * determined by the <code> parser </code> parameter.   Null will be
2208 |  |
          * returned if a data connection cannot be opened.  If the current working
2209 |  |
          * directory contains no files, an empty array will be the return.
2210 |  |
          *
2211 |  |
          * @exception FTPConnectionClosedException
2212 |  |
          *                   If the FTP server prematurely closes the connection as a result
2213 |  |
          *                   of the client being idle or some other reason causing the server
2214 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2215 |  |
          *                   as an IOException or independently as itself.
2216 |  |
          * @exception IOException
2217 |  |
          *                   If an I/O error occurs while either sending a
2218 |  |
          *                   command to the server or receiving a reply from the server.
2219 |  |
          * @exception ParserInitializationException
2220 |  |
          *                   Thrown if the autodetect mechanism cannot
2221 |  |
          *                   resolve the type of system we are connected with.
2222 |  |
          * @see FTPListParseEngine
2223 |  |
          */
2224 |  |
         public FTPListParseEngine initiateListParsing()
2225 |  |
         throws IOException
2226 |  |
         {
2227 | 0 |
             return initiateListParsing((String) null);
2228 |  |
         }
2229 |  |
2230 |  |
         /**
2231 |  |
          * Using the default autodetect mechanism, initialize an FTPListParseEngine
2232 |  |
          * object containing a raw file information for the supplied directory.
2233 |  |
          * This information is obtained through the LIST command.  This object
2234 |  |
          * is then capable of being iterated to return a sequence of FTPFile
2235 |  |
          * objects with information filled in by the
2236 |  |
          * <code> FTPFileEntryParser </code> used.
2237 |  |
          * <p>
2238 |  |
          * The server may or may not expand glob expressions.  You should avoid
2239 |  |
          * using glob expressions because the return format for glob listings
2240 |  |
          * differs from server to server and will likely cause this method to fail.
2241 |  |
          * <p>
2242 |  |
          * This method differs from using the listFiles() methods in that
2243 |  |
          * expensive FTPFile objects are not created until needed which may be
2244 |  |
          * an advantage on large lists.
2245 |  |
          * <p>
2246 |  |
          * <pre>
2247 |  |
          *    FTPClient f=FTPClient();
2248 |  |
          *    f.connect(server);
2249 |  |
          *    f.login(username, password);
2250 |  |
          *    FTPListParseEngine engine = f.initiateListParsing(directory);
2251 |  |
          *
2252 |  |
          *    while (engine.hasNext()) {
2253 |  |
          *       FTPFile[] files = engine.getNext(25);  // "page size" you want
2254 |  |
          *       //do whatever you want with these files, display them, etc.
2255 |  |
          *       //expensive FTPFile objects not created until needed.
2256 |  |
          *    }
2257 |  |
          * </pre>
2258 |  |
          *
2259 |  |
          * @return A FTPListParseEngine object that holds the raw information and
2260 |  |
          * is capable of providing parsed FTPFile objects, one for each file
2261 |  |
          * containing information contained in the given path in the format
2262 |  |
          * determined by the <code> parser </code> parameter.   Null will be
2263 |  |
          * returned if a data connection cannot be opened.  If the current working
2264 |  |
          * directory contains no files, an empty array will be the return.
2265 |  |
          *
2266 |  |
          * @exception FTPConnectionClosedException
2267 |  |
          *                   If the FTP server prematurely closes the connection as a result
2268 |  |
          *                   of the client being idle or some other reason causing the server
2269 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2270 |  |
          *                   as an IOException or independently as itself.
2271 |  |
          * @exception IOException
2272 |  |
          *                   If an I/O error occurs while either sending a
2273 |  |
          *                   command to the server or receiving a reply from the server.
2274 |  |
          * @exception ParserInitializationException
2275 |  |
          *                   Thrown if the autodetect mechanism cannot
2276 |  |
          *                   resolve the type of system we are connected with.
2277 |  |
          * @see FTPListParseEngine
2278 |  |
          */
2279 |  |
         public FTPListParseEngine initiateListParsing(
2280 |  |
                 String pathname)
2281 |  |
         throws IOException
2282 |  |
         {
2283 | 0 |
             String key = null;
2284 | 0 |
             return initiateListParsing(key, pathname);
2285 |  |
         }
2286 |  |
2287 |  |
         /**
2288 |  |
          * Using the supplied parser key, initialize an FTPListParseEngine
2289 |  |
          * object containing a raw file information for the supplied directory.
2290 |  |
          * This information is obtained through the LIST command.  This object
2291 |  |
          * is then capable of being iterated to return a sequence of FTPFile
2292 |  |
          * objects with information filled in by the
2293 |  |
          * <code> FTPFileEntryParser </code> used.
2294 |  |
          * <p>
2295 |  |
          * The server may or may not expand glob expressions.  You should avoid
2296 |  |
          * using glob expressions because the return format for glob listings
2297 |  |
          * differs from server to server and will likely cause this method to fail.
2298 |  |
          * <p>
2299 |  |
          * This method differs from using the listFiles() methods in that
2300 |  |
          * expensive FTPFile objects are not created until needed which may be
2301 |  |
          * an advantage on large lists.
2302 |  |
          *
2303 |  |
          * @param parserKey A string representing a designated code or fully-qualified
2304 |  |
          * class name of an  <code> FTPFileEntryParser </code> that should be
2305 |  |
          *               used to parse each server file listing.
2306 |  |
          *
2307 |  |
          * @return A FTPListParseEngine object that holds the raw information and
2308 |  |
          * is capable of providing parsed FTPFile objects, one for each file
2309 |  |
          * containing information contained in the given path in the format
2310 |  |
          * determined by the <code> parser </code> parameter.   Null will be
2311 |  |
          * returned if a data connection cannot be opened.  If the current working
2312 |  |
          * directory contains no files, an empty array will be the return.
2313 |  |
          *
2314 |  |
          * @exception FTPConnectionClosedException
2315 |  |
          *                   If the FTP server prematurely closes the connection as a result
2316 |  |
          *                   of the client being idle or some other reason causing the server
2317 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2318 |  |
          *                   as an IOException or independently as itself.
2319 |  |
          * @exception IOException
2320 |  |
          *                   If an I/O error occurs while either sending a
2321 |  |
          *                   command to the server or receiving a reply from the server.
2322 |  |
          * @exception ParserInitializationException
2323 |  |
          *                   Thrown if the parserKey parameter cannot be
2324 |  |
          *                   resolved by the selected parser factory.
2325 |  |
          *                   In the DefaultFTPEntryParserFactory, this will
2326 |  |
          *                   happen when parserKey is neither
2327 |  |
          *                   the fully qualified class name of a class
2328 |  |
          *                   implementing the interface
2329 |  |
          *                   org.apache.commons.net.ftp.FTPFileEntryParser
2330 |  |
          *                   nor a string containing one of the recognized keys
2331 |  |
          *                   mapping to such a parser or if class loader
2332 |  |
          *                   security issues prevent its being loaded.
2333 |  |
          * @see FTPListParseEngine
2334 |  |
          */
2335 |  |
         public FTPListParseEngine initiateListParsing(
2336 |  |
                 String parserKey, String pathname)
2337 |  |
         throws IOException
2338 |  |
         {
2339 |  |
             // We cache the value to avoid creation of a new object every
2340 |  |
             // time a file listing is generated.
2341 | 0 |
             if(__entryParser == null) {
2342 | 0 |
                 if (null != parserKey) {
2343 |  |
                     // if a parser key was supplied in the parameters,
2344 |  |
                     // use that to create the paraser
2345 | 0 |
             	    __entryParser =
2346 |  |
             	        __parserFactory.createFileEntryParser(parserKey);
2347 |  |
2348 |  |
                 } else {
2349 |  |
     	            // if no parserKey was supplied, check for a configuration
2350 |  |
     	        	// in the params, and if non-null, use that.
2351 | 0 |
                 	if (null != __configuration) {
2352 | 0 |
                 	    __entryParser =
2353 |  |
                 	        __parserFactory.createFileEntryParser(__configuration);
2354 |  |
                 	} else {
2355 |  |
                         // if a parserKey hasn't been supplied, and a configuration
2356 |  |
                 	    // hasn't been supplied, then autodetect by calling
2357 |  |
                         // the SYST command and use that to choose the parser.
2358 | 0 |
                 	    __entryParser =
2359 |  |
                 	        __parserFactory.createFileEntryParser(getSystemName());
2360 |  |
                  	}
2361 |  |
                 }
2362 |  |
             }
2363 |  |
2364 | 0 |
             return initiateListParsing(__entryParser, pathname);
2365 |  |
2366 |  |
         }
2367 |  |
2368 |  |
2369 |  |
         /**
2370 |  |
          * private method through which all listFiles() and
2371 |  |
          * initiateListParsing methods pass once a parser is determined.
2372 |  |
          *
2373 |  |
          * @exception FTPConnectionClosedException
2374 |  |
          *                   If the FTP server prematurely closes the connection as a result
2375 |  |
          *                   of the client being idle or some other reason causing the server
2376 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2377 |  |
          *                   as an IOException or independently as itself.
2378 |  |
          * @exception IOException
2379 |  |
          *                   If an I/O error occurs while either sending a
2380 |  |
          *                   command to the server or receiving a reply from the server.
2381 |  |
          * @see FTPListParseEngine
2382 |  |
          */
2383 |  |
         private FTPListParseEngine initiateListParsing(
2384 |  |
                 FTPFileEntryParser parser, String pathname)
2385 |  |
         throws IOException
2386 |  |
         {
2387 |  |
             Socket socket;
2388 |  |
2389 | 0 |
             FTPListParseEngine engine = new FTPListParseEngine(parser);
2390 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
2391 |  |
             {
2392 | 0 |
                 return engine;
2393 |  |
             }
2394 |  |
2395 |  |
2396 | 0 |
             engine.readServerList(socket.getInputStream(), getControlEncoding());
2397 |  |
2398 | 0 |
             socket.close();
2399 |  |
2400 | 0 |
             completePendingCommand();
2401 | 0 |
             return engine;
2402 |  |
         }
2403 |  |
2404 |  |
         /***
2405 |  |
          * Issue the FTP STAT command to the server.
2406 |  |
          * <p>
2407 |  |
          * @return The status information returned by the server.
2408 |  |
          * @exception FTPConnectionClosedException
2409 |  |
          *      If the FTP server prematurely closes the connection as a result
2410 |  |
          *      of the client being idle or some other reason causing the server
2411 |  |
          *      to send FTP reply code 421.  This exception may be caught either
2412 |  |
          *      as an IOException or independently as itself.
2413 |  |
          * @exception IOException  If an I/O error occurs while either sending a
2414 |  |
          *      command to the server or receiving a reply from the server.
2415 |  |
          ***/
2416 |  |
         public String getStatus() throws IOException
2417 |  |
         {
2418 | 0 |
             if (FTPReply.isPositiveCompletion(stat()))
2419 | 0 |
                 return getReplyString();
2420 | 0 |
             return null;
2421 |  |
         }
2422 |  |
2423 |  |
2424 |  |
         /***
2425 |  |
          * Issue the FTP STAT command to the server for a given pathname.  This
2426 |  |
          * should produce a listing of the file or directory.
2427 |  |
          * <p>
2428 |  |
          * @return The status information returned by the server.
2429 |  |
          * @exception FTPConnectionClosedException
2430 |  |
          *      If the FTP server prematurely closes the connection as a result
2431 |  |
          *      of the client being idle or some other reason causing the server
2432 |  |
          *      to send FTP reply code 421.  This exception may be caught either
2433 |  |
          *      as an IOException or independently as itself.
2434 |  |
          * @exception IOException  If an I/O error occurs while either sending a
2435 |  |
          *      command to the server or receiving a reply from the server.
2436 |  |
          ***/
2437 |  |
         public String getStatus(String pathname) throws IOException
2438 |  |
         {
2439 | 0 |
             if (FTPReply.isPositiveCompletion(stat(pathname)))
2440 | 0 |
                 return getReplyString();
2441 | 0 |
             return null;
2442 |  |
         }
2443 |  |
2444 |  |
         /**
2445 |  |
          * Using a programmer specified <code> FTPFileListParser </code>, obtain a
2446 |  |
          * list of file information for a directory or information for
2447 |  |
          * just a single file.  This information is obtained through the LIST
2448 |  |
          * command.  The contents of the returned array is determined by the
2449 |  |
          * <code> FTPFileListParser </code> used.
2450 |  |
          * The server may or may not expand glob expressions.  You should avoid
2451 |  |
          * using glob expressions because the return format for glob listings
2452 |  |
          * differs from server to server and will likely cause this method to fail.
2453 |  |
          * <p>
2454 |  |
          * @param parser The <code> FTPFileListParser </code> that should be
2455 |  |
          *         used to parse the server file listing.
2456 |  |
          * @param pathname  The file or directory to list.
2457 |  |
          * @return The list of file information contained in the given path in
2458 |  |
          *         the format determined by the <code> parser </code> parameter.
2459 |  |
          *         <p><b>
2460 |  |
          * 		   NOTE:</b> This array may contain null members if any of the
2461 |  |
          *         individual file listings failed to parse.  The caller should
2462 |  |
          *         check each entry for null before referencing it.
2463 |  |
          * @exception FTPConnectionClosedException
2464 |  |
          *      If the FTP server prematurely closes the connection as a result
2465 |  |
          *      of the client being idle or some other reason causing the server
2466 |  |
          *      to send FTP reply code 421.  This exception may be caught either
2467 |  |
          *      as an IOException or independently as itself.
2468 |  |
          * @exception IOException  If an I/O error occurs while either sending a
2469 |  |
          *      command to the server or receiving a reply from the server.
2470 |  |
          *
2471 |  |
          * @return The list of file information contained in the given path in
2472 |  |
          *         the format determined by<code> parserKey </code>parameter.
2473 |  |
          *         <p><b>
2474 |  |
          * 		   NOTE:</b> This array may contain null members if any of the
2475 |  |
          *         individual file listings failed to parse.  The caller should
2476 |  |
          *         check each entry for null before referencing it.
2477 |  |
          *
2478 |  |
          * @exception IOException
2479 |  |
          * @since 5 Jan 2004
2480 |  |
          * @deprecated use listFiles(String parserKey, String pathname) instead
2481 |  |
          */
2482 |  |
         public FTPFile[] listFiles(FTPFileListParser parser, String pathname)
2483 |  |
         throws IOException
2484 |  |
         {
2485 |  |
             Socket socket;
2486 |  |
             FTPFile[] results;
2487 |  |
2488 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
2489 | 0 |
                 return new FTPFile[0];
2490 |  |
2491 | 0 |
             results = parser.parseFileList(socket.getInputStream(), getControlEncoding());
2492 |  |
2493 | 0 |
             socket.close();
2494 |  |
2495 | 0 |
             completePendingCommand();
2496 |  |
2497 | 0 |
             return results;
2498 |  |
         }
2499 |  |
2500 |  |
2501 |  |
         /**
2502 |  |
          * Using a programmer specified <code> FTPFileListParser </code>,
2503 |  |
          * obtain a list of file information for the current working directory.
2504 |  |
          * This information is obtained through the LIST command.
2505 |  |
          * The contents of the array returned is determined by the
2506 |  |
          * <code> FTPFileListParser </code> used.
2507 |  |
          * <p>
2508 |  |
          *
2509 |  |
          * @param parser The <code> FTPFileListParser </code> that should be
2510 |  |
          *               used to parse the server file listing.
2511 |  |
          *
2512 |  |
          * @return The list of file information contained in the given path in
2513 |  |
          *         the format determined by the <code> parser </code> parameter.
2514 |  |
          *         <p><b>
2515 |  |
          * 		   NOTE:</b> This array may contain null members if any of the
2516 |  |
          *         individual file listings failed to parse.  The caller should
2517 |  |
          *         check each entry for null before referencing it.
2518 |  |
          * @exception FTPConnectionClosedException
2519 |  |
          *                   If the FTP server prematurely closes the connection as a result
2520 |  |
          *                   of the client being idle or some other reason causing the server
2521 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2522 |  |
          *                   as an IOException or independently as itself.
2523 |  |
          * @exception IOException
2524 |  |
          *                   If an I/O error occurs while either sending a
2525 |  |
          *                   command to the server or receiving a reply from the server.
2526 |  |
          * @exception IOException
2527 |  |
          * @since 5 Jan 2004
2528 |  |
          * @deprecated use listFiles(String parserKey) instead.
2529 |  |
          */
2530 |  |
         public FTPFile[] listFiles(FTPFileListParser parser) throws IOException
2531 |  |
         {
2532 | 0 |
             return listFiles(parser, null);
2533 |  |
         }
2534 |  |
2535 |  |
2536 |  |
         /**
2537 |  |
          * Using a programmer specified <code> FTPFileEntryParser </code>,
2538 |  |
          * initialize an object containing a raw file information for the
2539 |  |
          * current working directory.  This information is obtained through
2540 |  |
          * the LIST command.  This object is then capable of being iterated to
2541 |  |
          * return a sequence of FTPFile objects with information filled in by the
2542 |  |
          * <code> FTPFileEntryParser </code> used.
2543 |  |
          * <p>
2544 |  |
          * The server may or may not expand glob expressions.  You should avoid
2545 |  |
          * using glob expressions because the return format for glob listings
2546 |  |
          * differs from server to server and will likely cause this method to fail.
2547 |  |
          * <p>
2548 |  |
          * This method differs from using the listFiles() methods in that
2549 |  |
          * expensive FTPFile objects are not created until needed which may be
2550 |  |
          * an advantage on large lists.
2551 |  |
          *
2552 |  |
          * @param parser The <code> FTPFileEntryParser </code> that should be
2553 |  |
          *               used to parse each server file listing.
2554 |  |
          *
2555 |  |
          * @return An iteratable object that holds the raw information and is
2556 |  |
          *         capable of providing parsed FTPFile objects, one for each file containing
2557 |  |
          *         information contained in the given path in the format determined by the
2558 |  |
          *         <code> parser </code> parameter.   Null will be returned if a
2559 |  |
          *         data connection cannot be opened.  If the current working directory
2560 |  |
          *         contains no files, an empty array will be the return.
2561 |  |
          * <pre>
2562 |  |
          *    FTPClient f=FTPClient();
2563 |  |
          *    f.connect(server);
2564 |  |
          *    f.login(username, password);
2565 |  |
          *    FTPFileList list = f.createFileList(directory, parser);
2566 |  |
          *    FTPFileIterator iter = list.iterator();
2567 |  |
          *
2568 |  |
          *    while (iter.hasNext()) {
2569 |  |
          *       FTPFile[] files = iter.getNext(25);  // "page size" you want
2570 |  |
          *       //do whatever you want with these files, display them, etc.
2571 |  |
          *       //expensive FTPFile objects not created until needed.
2572 |  |
          *    }
2573 |  |
          * </pre>
2574 |  |
          *
2575 |  |
          * @exception FTPConnectionClosedException
2576 |  |
          *                   If the FTP server prematurely closes the connection as a result
2577 |  |
          *                   of the client being idle or some other reason causing the server
2578 |  |
          *                   to send FTP reply code 421.  This exception may be caught either
2579 |  |
          *                   as an IOException or independently as itself.
2580 |  |
          * @exception IOException
2581 |  |
          *                   If an I/O error occurs while either sending a
2582 |  |
          *                   command to the server or receiving a reply from the server.
2583 |  |
          * @deprecated - use initiateListParsing(FTPFileEntryParser) method instead.
2584 |  |
          * @see FTPFileList
2585 |  |
          */
2586 |  |
         public FTPFileList createFileList(FTPFileEntryParser parser) throws IOException
2587 |  |
         {
2588 | 0 |
             return createFileList(null, parser);
2589 |  |
         }
2590 |  |
2591 |  |
         /**
2592 |  |
          * Using a programmer specified <code> FTPFileEntryParser </code>,
2593 |  |
          * initialize an object containing a raw file information for a directory
2594 |  |
          * or information for a single file.  This information is obtained through
2595 |  |
          * the LIST command.  This object is then capable of being iterated to
2596 |  |
          * return a sequence of FTPFile objects with information filled in by the
2597 |  |
          * <code> FTPFileEntryParser </code> used.
2598 |  |
          * The server may or may not expand glob expressions.  You should avoid
2599 |  |
          * using glob expressions because the return format for glob listings
2600 |  |
          * differs from server to server and will likely cause this method to fail.
2601 |  |
          * <p>
2602 |  |
          * @param parser The <code> FTPFileEntryParser </code> that should be
2603 |  |
          *         used to parse each server file listing.
2604 |  |
          * @param pathname  The file or directory to list.
2605 |  |
          * @return An iteratable object that holds the raw information and is
2606 |  |
          * capable of providing parsed FTPFile objects, one for each file containing
2607 |  |
          * information contained in the given path in the format determined by the
2608 |  |
          * <code> parser </code> parameter.  Null will be returned if a
2609 |  |
          * data connection cannot be opened.  If the supplied path contains
2610 |  |
          * no files, an empty array will be the return.
2611 |  |
          * @exception FTPConnectionClosedException
2612 |  |
          *      If the FTP server prematurely closes the connection as a result
2613 |  |
          *      of the client being idle or some other reason causing the server
2614 |  |
          *      to send FTP reply code 421.  This exception may be caught either
2615 |  |
          *      as an IOException or independently as itself.
2616 |  |
          * @exception IOException  If an I/O error occurs while either sending a
2617 |  |
          *      command to the server or receiving a reply from the server.
2618 |  |
          * @deprecated - use initiateListParsing(String, FTPFileEntryParser)
2619 |  |
          * method instead.
2620 |  |
          * @see FTPFileList
2621 |  |
          */
2622 |  |
         public FTPFileList createFileList(String pathname,
2623 |  |
                 FTPFileEntryParser parser)
2624 |  |
         throws IOException
2625 |  |
         {
2626 |  |
             Socket socket;
2627 |  |
2628 | 0 |
             if ((socket = _openDataConnection_(FTPCommand.LIST, pathname)) == null)
2629 |  |
             {
2630 | 0 |
                 return null;
2631 |  |
             }
2632 |  |
2633 | 0 |
             FTPFileList list = FTPFileList.create(socket.getInputStream(), parser);
2634 |  |
2635 | 0 |
             socket.close();
2636 |  |
2637 | 0 |
             completePendingCommand();
2638 | 0 |
             return list;
2639 |  |
         }
2640 |  |
2641 |  |
         /**
2642 |  |
          * Set the internal buffer size.
2643 |  |
          *
2644 |  |
          * @param bufSize The size of the buffer
2645 |  |
          */
2646 |  |
         public void setBufferSize(int bufSize) {
2647 | 0 |
         	__bufferSize = bufSize;
2648 | 0 |
         }
2649 |  |
2650 |  |
         /**
2651 |  |
          * Retrieve the current internal buffer size.
2652 |  |
          * @return The current buffer size.
2653 |  |
          */
2654 |  |
         public int getBufferSize() {
2655 | 0 |
         	return __bufferSize;
2656 |  |
         }
2657 |  |
2658 |  |
2659 |  |
         /**
2660 |  |
          * Implementation of the {@link Configurable Configurable} interface.
2661 |  |
          * In the case of this class, configuring merely makes the config object available for the
2662 |  |
          * factory methods that construct parsers.
2663 |  |
          * @param config {@link FTPClientConfig FTPClientConfig} object used to
2664 |  |
          * provide non-standard configurations to the parser.
2665 |  |
          * @since 1.4
2666 |  |
          */
2667 |  |
         public void configure(FTPClientConfig config) {
2668 | 0 |
         	this.__configuration = config;
2669 | 0 |
         }
2670 |  |
2671 |  |
     }
2672 |  |
2673 |  |
     /* Emacs configuration
2674 |  |
      * Local variables:        **
2675 |  |
      * mode:             java  **
2676 |  |
      * c-basic-offset:   4     **
2677 |  |
      * indent-tabs-mode: nil   **
2678 |  |
      * End:                    **
2679 |  |
      */

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.