FTPClient

001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017     
018    package examples.ftp;
019    
020    import java.io.FileInputStream;
021    import java.io.FileOutputStream;
022    import java.io.IOException;
023    import java.io.InputStream;
024    import java.io.OutputStream;
025    import java.io.PrintWriter;
026    
027    import org.apache.commons.net.PrintCommandListener;
028    import org.apache.commons.net.ftp.FTP;
029    import org.apache.commons.net.ftp.FTPClient;
030    import org.apache.commons.net.ftp.FTPConnectionClosedException;
031    import org.apache.commons.net.ftp.FTPReply;
032    
033    /***
034     * This is an example program demonstrating how to use the FTPClient class.
035     * This program connects to an FTP server and retrieves the specified
036     * file.  If the -s flag is used, it stores the local file at the FTP server.
037     * Just so you can see what's happening, all reply strings are printed.
038     * If the -b flag is used, a binary transfer is assumed (default is ASCII).
039     * <p>
040     * Usage: ftp [-s] [-b] <hostname> <username> <password> <remote file> <local file>
041     * <p>
042     ***/
043    public final class FTPClientExample
044    {
045    
046        public static final String USAGE =
047            "Usage: ftp [-s] [-b] <hostname> <username> <password> <remote file> <local file>/n" +
048            "/nDefault behavior is to download a file and use ASCII transfer mode./n" +
049            "/t-s store file on server (upload)/n" +
050            "/t-b use binary transfer mode/n";
051    
052        public static final void main(String[] args)
053        {
054            int base = 0;
055            boolean storeFile = false, binaryTransfer = false, error = false;
056            String server, username, password, remote, local;
057            FTPClient ftp;
058    
059            for (base = 0; base < args.length; base++)
060            {
061                if (args[base].startsWith("-s"))
062                    storeFile = true;
063                else if (args[base].startsWith("-b"))
064                    binaryTransfer = true;
065                else
066                    break;
067            }
068    
069            if ((args.length - base) != 5)
070            {
071                System.err.println(USAGE);
072                System.exit(1);
073            }
074    
075            server = args[base++];
076            username = args[base++];
077            password = args[base++];
078            remote = args[base++];
079            local = args[base];
080    
081            ftp = new FTPClient();
082            ftp.addProtocolCommandListener(new PrintCommandListener(
083                                               new PrintWriter(System.out)));
084    
085            try
086            {
087                int reply;
088                ftp.connect(server);
089                System.out.println("Connected to " + server + ".");
090    
091                // After connection attempt, you should check the reply code to verify
092                // success.
093                reply = ftp.getReplyCode();
094    
095                if (!FTPReply.isPositiveCompletion(reply))
096                {
097                    ftp.disconnect();
098                    System.err.println("FTP server refused connection.");
099                    System.exit(1);
100                }
101            }
102            catch (IOException e)
103            {
104                if (ftp.isConnected())
105                {
106                    try
107                    {
108                        ftp.disconnect();
109                    }
110                    catch (IOException f)
111                    {
112                        // do nothing
113                    }
114                }
115                System.err.println("Could not connect to server.");
116                e.printStackTrace();
117                System.exit(1);
118            }
119    
120    __main:
121            try
122            {
123                if (!ftp.login(username, password))
124                {
125                    ftp.logout();
126                    error = true;
127                    break __main;
128                }
129    
130                System.out.println("Remote system is " + ftp.getSystemName());
131    
132                if (binaryTransfer)
133                    ftp.setFileType(FTP.BINARY_FILE_TYPE);
134    
135                // Use passive mode as default because most of us are
136                // behind firewalls these days.
137                ftp.enterLocalPassiveMode();
138    
139                if (storeFile)
140                {
141                    InputStream input;
142    
143                    input = new FileInputStream(local);
144    
145                    ftp.storeFile(remote, input);
146    
147                    input.close();
148                }
149                else
150                {
151                    OutputStream output;
152    
153                    output = new FileOutputStream(local);
154    
155                    ftp.retrieveFile(remote, output);
156    
157                    output.close();
158                }
159    
160                ftp.logout();
161            }
162            catch (FTPConnectionClosedException e)
163            {
164                error = true;
165                System.err.println("Server closed connection.");
166                e.printStackTrace();
167            }
168            catch (IOException e)
169            {
170                error = true;
171                e.printStackTrace();
172            }
173            finally
174            {
175                if (ftp.isConnected())
176                {
177                    try
178                    {
179                        ftp.disconnect();
180                    }
181                    catch (IOException f)
182                    {
183                        // do nothing
184                    }
185                }
186            }
187    
188            System.exit(error ? 1 : 0);
189        } // end main
190    
191    }
192